feat: add ai command for cli to start the project

src/commands/init/ai-rules.ts

@@ -0,0 +1,255 @@
+import { resolve } from 'node:path'
+import { promises as fs } from 'node:fs'
+import type { NetlifyAPI } from '@netlify/api'
+
+import { chalk, log, logAndThrowError, type APIError } from '../../utils/command-helpers.js'
+import { normalizeRepoUrl } from '../../utils/normalize-repo-url.js'
+import { runGit } from '../../utils/run-git.js'
+import { startSpinner } from '../../lib/spinner.js'
+import { detectIDE } from '../../recipes/ai-context/index.js'
+import { type ConsumerConfig } from '../../recipes/ai-context/context.js'
+import {
+  generateMcpConfig,
+  configureMcpForVSCode,
+  configureMcpForCursor,
+  configureMcpForWindsurf,
+  showGenericMcpConfig,
+} from '../../utils/mcp-utils.js'
+import type BaseCommand from '../base-command.js'
+import type { SiteInfo } from '../../utils/types.js'
+import inquirer from 'inquirer'
+
+/**
+ * Project information interface for AI projects
+ */
+interface ProjectInfo {
+  success: boolean
+  projectId: string
+  prompt: string
+}
+
+// Trigger IDE-specific MCP configuration
+const triggerMcpConfiguration = async (ide: ConsumerConfig, projectPath: string): Promise<boolean> => {
+  log(`\n${chalk.blue('🔧 MCP Configuration for')} ${chalk.cyan(ide.presentedName)}`)
+
+  const { shouldConfigure } = await inquirer.prompt<{ shouldConfigure: boolean }>([
+    {
+      type: 'confirm',
+      name: 'shouldConfigure',
+      message: `Would you like to automatically configure the MCP server for ${ide.presentedName}?`,
+      default: true,
+    },
+  ])
+
+  if (!shouldConfigure) {
+    log(`   ${chalk.gray('You can configure MCP manually later for enhanced AI capabilities:')}`)
+    log(
+      `   ${chalk.gray('Documentation:')} ${chalk.cyan(
+        'https://docs.netlify.com/welcome/build-with-ai/netlify-mcp-server/',
+      )}`,
+    )
+
+    return false
+  }
+
+  try {
+    const config = generateMcpConfig(ide)
+
+    // IDE-specific configuration actions
+    switch (ide.key) {
+      case 'vscode':
+        await configureMcpForVSCode(config, projectPath)
+        break
+      case 'cursor':
+        await configureMcpForCursor(config, projectPath)
+        break
+      case 'windsurf':
+        await configureMcpForWindsurf(config, projectPath)
+        break
+      default:
+        showGenericMcpConfig(config, ide.presentedName)
+    }
+
+    log(`${chalk.green('✅')} MCP configuration completed for ${chalk.cyan(ide.presentedName)}`)
+    return true
+  } catch (error) {
+    log(`${chalk.red('❌')} Failed to configure MCP: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    return false
+  }
+}
+
+// Helper functions reused from ai-start.ts
+const decodeHash = (hash: string): string => {
+  try {
+    return atob(hash)
+  } catch (error) {
+    throw new Error(`Failed to decode hash: ${error instanceof Error ? error.message : 'Invalid base64 or URL'}`)
+  }
+}
+
+const fetchProjectInfo = async (url: string): Promise<ProjectInfo> => {
+  try {
+    const response = await fetch(url, {
+      headers: {
+        'content-type': 'text/plain',
+      },
+    })
+
+    const data = (await response.text()) as unknown as string
+    const parsedData = JSON.parse(data) as unknown as ProjectInfo
+    return parsedData
+  } catch (error) {
+    throw new Error(`Failed to fetch project information: ${error instanceof Error ? error.message : 'Unknown error'}`)
+  }
+}
+
+const getRepoUrlFromProjectId = async (api: NetlifyAPI, projectId: string): Promise<string> => {
+  try {
+    const siteInfo = (await api.getSite({ siteId: projectId })) as SiteInfo
+    const repoUrl = siteInfo.build_settings?.repo_url
+
+    if (!repoUrl) {
+      throw new Error(`No repository URL found for project ID: ${projectId}`)
+    }
+
+    return repoUrl
+  } catch (error) {
+    if ((error as APIError).status === 404) {
+      throw new Error(`Project with ID ${projectId} not found`)
+    }
+    throw new Error(`Failed to fetch project data: ${(error as Error).message}`)
+  }
+}
+
+const savePrompt = async (instructions: string, ntlContext: string | null, targetDir: string): Promise<void> => {
+  try {
+    const filePath = resolve(targetDir, 'AI-instructions.md')
+    await fs.writeFile(filePath, `Context: ${ntlContext ?? ''}\n\n${instructions}`, 'utf-8')
+    log(`${chalk.green('✅')} AI instructions saved to ${chalk.cyan('AI-instructions.md')}`)
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    log(`${chalk.yellow('⚠️')} Warning: Failed to save AI instructions: ${errorMessage}`)
+  }
+}
+
+const cloneRepo = async (repoUrl: string, targetDir: string, debug: boolean): Promise<void> => {
+  try {
+    await runGit(['clone', repoUrl, targetDir], !debug)
+  } catch (error) {
+    throw new Error(`Failed to clone repository: ${error instanceof Error ? error.message : error?.toString() ?? ''}`)
+  }
+}
+
+/**
+ * Handles AI rules initialization workflow
+ * This is the experimental --ai-rules functionality for the init command
+ */
+export const initWithAiRules = async (hash: string, command: BaseCommand): Promise<void> => {
+  // Authenticate first before any API operations
+  await command.authenticate()
+  const { api } = command.netlify
+
+  log(`${chalk.blue('🤖 Initializing AI project')} with rules...`)
+  log(`${chalk.gray('User:')} ${api.accessToken ? 'Authenticated ✅' : 'Not authenticated ❌'}`)
+
+  try {
+    // Step 1: Decode hash and fetch project information
+    log('\n📋 Extracting project details...')
+    const decodedUrl = decodeHash(hash)
+    log(`${chalk.cyan('Decoded URL:')} ${decodedUrl}`)
+
+    log('\n🔍 Fetching project information...')
+    const projectInfo = await fetchProjectInfo(decodedUrl)
+
+    log(`${chalk.cyan('Project ID:')} ${projectInfo.projectId}`)
+
+    // Step 2: Get repository URL from project ID via Netlify site API
+    log('\n🔗 Linking to Netlify project and fetching repository...')
+    const repositoryUrl = await getRepoUrlFromProjectId(api, projectInfo.projectId)
+    log(`${chalk.cyan('Repository:')} ${repositoryUrl}`)
+
+    // Step 3: Clone repository
+    const { repoUrl, repoName } = normalizeRepoUrl(repositoryUrl)
+    const targetDir = `ai-project-${repoName}-${hash.substring(0, 8)}`
+
+    const cloneSpinner = startSpinner({ text: `Cloning repository to ${chalk.cyan(targetDir)}` })
+
+    await cloneRepo(repoUrl, targetDir, false)
+    cloneSpinner.success({ text: `Cloned repository to ${chalk.cyan(targetDir)}` })
+
+    // Step 4: Save AI instructions to file
+    if (projectInfo.prompt) {
+      const ntlContext = await fetch(
+        'https://docs.netlify.com/ai-context/scoped-context?scopes=serverless,blobs,forms',
+        {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'text/plain',
+          },
+        },
+      )
+        .then((res) => res.text())
+        .catch(() => {
+          return null
+        })
+      log('\n📝 Saving AI instructions...')
+      await savePrompt(projectInfo.prompt, ntlContext, targetDir)
+    }
+
+    // Step 5: Detect IDE and configure MCP server
+    log('\n🔍 Detecting development environment...')
+    const detectedIDE = await detectIDE()
+    let mcpConfigured = false
+
+    if (detectedIDE) {
+      log(`${chalk.green('✅')} Detected development environment: ${chalk.cyan(detectedIDE.presentedName)}`)
+      mcpConfigured = await triggerMcpConfiguration(detectedIDE, targetDir)
+    }
+
+    // Update working directory to cloned repo
+    process.chdir(targetDir)
+    command.workingDir = targetDir
+
+    // Success message with next steps
+    log()
+    log(chalk.green('✔ Your AI project is ready to go!'))
+    log(`→ Project ID: ${chalk.cyanBright(projectInfo.projectId)}`)
+    log(`→ Project cloned to: ${chalk.cyanBright(targetDir)}`)
+    if (projectInfo.prompt) {
+      log(`→ AI instructions saved: ${chalk.cyanBright('AI-instructions.md')}`)
+    }
+    log()
+    log(chalk.yellowBright(`📁 Step 1: Enter your project directory`))
+    log(`   ${chalk.cyanBright(`cd ${targetDir}`)}`)
+
+    if (detectedIDE) {
+      if (mcpConfigured) {
+        log(chalk.yellowBright(`🔧 Step 2: MCP Server Configured`))
+        log(`   ${chalk.green('✅')} ${chalk.cyan(detectedIDE.key)} is ready with Netlify MCP server`)
+        log(`   ${chalk.gray('💡 MCP will activate when you reload/restart your development environment')}`)
+      } else {
+        log(chalk.yellowBright(`🔧 Step 2: Manual MCP Configuration`))
+        log(`   ${chalk.cyan(detectedIDE.key)} detected - MCP setup was skipped`)
+        log(`   ${chalk.gray('You can configure MCP manually later for enhanced AI capabilities:')}`)
+        log(
+          `   ${chalk.gray('Documentation:')} ${chalk.cyan(
+            'https://docs.netlify.com/welcome/build-with-ai/netlify-mcp-server/',
+          )}`,
+        )
+      }
+      log()
+    }
+
+    if (projectInfo.prompt) {
+      const stepNumber = detectedIDE ? '3' : '2'
+      log(chalk.yellowBright(`🤖 Step ${stepNumber}: Ask your AI assistant to process the instructions`))
+      log()
+      log(chalk.gray('*'.repeat(60)))
+      log(chalk.cyan(`Follow ${targetDir}/AI-instructions.md and create a new site`))
+      log(chalk.gray('*'.repeat(60)))
+      log()
+    }
+  } catch (error) {
+    return logAndThrowError(error)
+  }
+}

src/commands/init/index.ts

@@ -1,4 +1,4 @@
-import { OptionValues } from 'commander'
+import { OptionValues, Option } from 'commander'
 import terminalLink from 'terminal-link'
 
 import BaseCommand from '../base-command.js'
@@ -11,13 +11,22 @@ export const createInitCommand = (program: BaseCommand) =>
     )
     .option('-m, --manual', 'Manually configure a git remote for CI')
     .option('--git-remote-name <name>', 'Name of Git remote to use. e.g. "origin"')
+    .addOption(new Option('--ai-rules <hash>', 'Initialize with AI project configuration (experimental)').hideHelp())
     .addHelpText('after', () => {
       const docsUrl = 'https://docs.netlify.com/cli/get-started/'
       return `
 For more information about getting started with Netlify CLI, see ${terminalLink(docsUrl, docsUrl, { fallback: false })}
 `
     })
     .action(async (options: OptionValues, command: BaseCommand) => {
+      // Check for experimental AI rules flag
+      if (options.aiRules) {
+        const { initWithAiRules } = await import('./ai-rules.js')
+        await initWithAiRules(options.aiRules as string, command)
+        return
+      }
+
+      // Standard init flow
       const { init } = await import('./init.js')
       await init(options, command)
     })

src/lib/functions/server.ts

@@ -169,7 +169,8 @@ export const createHandler = function (options: GetFunctionsServerOptions): Requ
     const rawQuery = new URL(request.originalUrl, 'http://example.com').search.slice(1)
     // TODO(serhalp): Update several tests to pass realistic `config` objects and remove nullish coalescing.
     const protocol = options.config?.dev?.https ? 'https' : 'http'
-    const url = new URL(requestPath, `${protocol}://${request.get('host') || 'localhost'}`)
+    const hostname = request.get('host') || 'localhost'
+    const url = new URL(requestPath, `${protocol}://${hostname}`)
     url.search = rawQuery
     const rawUrl = url.toString()
     const event = {

src/recipes/ai-context/index.ts

@@ -77,7 +77,7 @@ const promptForContextConsumerSelection = async (): Promise<ConsumerConfig> => {
  * Checks if a command belongs to a known IDEs by checking if it includes a specific string.
  * For example, the command that starts windsurf looks something like "/applications/windsurf.app/contents/...".
  */
-const getConsumerKeyFromCommand = (command: string): string | null => {
+export const getConsumerKeyFromCommand = (command: string): string | null => {
   // The actual command is something like "/applications/windsurf.app/contents/...", but we are only looking for windsurf
   const match = cliContextConsumers.find(
     (consumer) => consumer.consumerProcessCmd && command.includes(consumer.consumerProcessCmd),
@@ -88,7 +88,7 @@ const getConsumerKeyFromCommand = (command: string): string | null => {
 /**
  * Receives a process ID (pid) and returns both the command that the process was run with and its parent process ID. If the process is a known IDE, also returns information about that IDE.
  */
-const getCommandAndParentPID = async (
+export const getCommandAndParentPID = async (
   pid: number,
 ): Promise<{
   parentPID: number
@@ -107,7 +107,10 @@ const getCommandAndParentPID = async (
   }
 }
 
-const getPathByDetectingIDE = async (): Promise<ConsumerConfig | null> => {
+/**
+ * Detects the IDE by walking up the process tree and matching against known consumer processes
+ */
+export const detectIDE = async (): Promise<ConsumerConfig | null> => {
   // Go up the chain of ancestor process IDs and find if one of their commands matches an IDE.
   const ppid = process.ppid
   let result: Awaited<ReturnType<typeof getCommandAndParentPID>>
@@ -142,7 +145,7 @@ export const run = async (runOptions: RunRecipeOptions) => {
   }
 
   if (!consumer && process.env.AI_CONTEXT_SKIP_DETECTION !== 'true') {
-    consumer = await getPathByDetectingIDE()
+    consumer = await detectIDE()
   }
 
   if (!consumer) {