@synergenius/flow-weaver 0.16.0 → 0.17.1

package/dist/cli/commands/init.js

@@ -1,10 +1,11 @@
 /* eslint-disable no-console */
 /**
- * Init command — scaffolds a new flow-weaver project interactively
+ * Init command — scaffolds a new flow-weaver project interactively.
+ * Supports persona-aware onboarding for nocode, low-code, vibe-coder, and expert users.
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import input from '@inquirer/input';
 import select, { Separator } from '@inquirer/select';
 import confirm from '@inquirer/confirm';
@@ -12,6 +13,8 @@ import { ExitPromptError } from '@inquirer/core';
 import { getWorkflowTemplate, workflowTemplates } from '../templates/index.js';
 import { logger } from '../utils/logger.js';
 import { compileCommand } from './compile.js';
+import { runMcpSetupFromInit, CLI_TOOL_BINARY, detectCliTools } from './mcp-setup.js';
+import { PERSONA_CHOICES, PERSONA_CONFIRMATIONS, USE_CASE_CHOICES, selectTemplateForPersona, getTemplateSubChoices, printNextSteps, generateReadme, generateExampleWorkflow, generateAgentPrompt, generateEditorPrompt, generateSetupPromptFile, printCopyablePrompt, AGENT_LAUNCH_DEFAULTS, } from './init-personas.js';
 // ── Utilities ────────────────────────────────────────────────────────────────
 const PROJECT_NAME_RE = /^[a-zA-Z0-9][-a-zA-Z0-9_.]*$/;
 export function validateProjectName(name) {
@@ -35,11 +38,14 @@ export function isNonInteractive() {
     return !process.stdin.isTTY;
 }
 const VALID_TEMPLATES = workflowTemplates.map((t) => t.id);
+const VALID_PERSONAS = ['nocode', 'vibecoder', 'lowcode', 'expert'];
+const VALID_USE_CASES = ['data', 'ai', 'api', 'automation', 'cicd', 'minimal'];
 // ── Config resolution (prompts) ──────────────────────────────────────────────
 export async function resolveInitConfig(dirArg, options) {
     const skipPrompts = options.yes || isNonInteractive();
     const force = options.force ?? false;
-    // 1. Project name
+    const hasExplicitTemplate = !!options.template;
+    // 1. Project name (unchanged)
     let projectName;
     if (options.name) {
         projectName = options.name;
@@ -61,72 +67,163 @@ export async function resolveInitConfig(dirArg, options) {
     if (valid !== true) {
         throw new Error(valid);
     }
-    // Target directory
     const targetDir = path.resolve(dirArg ?? projectName);
-    // 2. Template
+    // 2. Persona
+    let persona;
+    if (options.preset) {
+        if (!VALID_PERSONAS.includes(options.preset)) {
+            throw new Error(`Unknown preset "${options.preset}". Available: ${VALID_PERSONAS.join(', ')}`);
+        }
+        persona = options.preset;
+    }
+    else if (skipPrompts || hasExplicitTemplate) {
+        persona = 'expert';
+    }
+    else {
+        persona = await select({
+            message: 'How do you plan to build?',
+            choices: PERSONA_CHOICES,
+            default: 'vibecoder',
+        });
+    }
+    // Print persona confirmation (interactive only)
+    if (!skipPrompts) {
+        const confirmation = PERSONA_CONFIRMATIONS[persona];
+        if (confirmation) {
+            logger.log(`  ${logger.dim(confirmation)}`);
+            logger.newline();
+        }
+    }
+    // 3. Template selection (persona-dependent)
     let template;
-    if (options.template) {
+    let useCase;
+    if (hasExplicitTemplate) {
+        // Direct --template flag bypasses everything
         template = options.template;
         if (!VALID_TEMPLATES.includes(template)) {
             throw new Error(`Unknown template "${template}". Available: ${VALID_TEMPLATES.join(', ')}`);
         }
     }
-    else if (skipPrompts) {
-        template = 'sequential';
+    else if (persona === 'expert') {
+        // Expert: show today's flat template list
+        if (skipPrompts) {
+            template = 'sequential';
+        }
+        else {
+            template = await select({
+                message: 'Workflow template:',
+                choices: [
+                    new Separator('── Data Processing ──'),
+                    { value: 'sequential', name: 'sequential', description: 'Linear pipeline' },
+                    { value: 'foreach', name: 'foreach', description: 'Batch iteration' },
+                    { value: 'aggregator', name: 'aggregator', description: 'Collect and aggregate results' },
+                    new Separator('── Automation ──'),
+                    { value: 'conditional', name: 'conditional', description: 'Route by condition' },
+                    new Separator('── AI ──'),
+                    { value: 'ai-agent', name: 'ai-agent', description: 'LLM agent with tool calling' },
+                    { value: 'ai-react', name: 'ai-react', description: 'ReAct pattern' },
+                    { value: 'ai-rag', name: 'ai-rag', description: 'Retrieval-Augmented Generation' },
+                    { value: 'ai-chat', name: 'ai-chat', description: 'Conversational AI' },
+                    new Separator('── Durable ──'),
+                    { value: 'ai-agent-durable', name: 'ai-agent-durable', description: 'Durable agent with approval gate' },
+                    { value: 'ai-pipeline-durable', name: 'ai-pipeline-durable', description: 'Durable data pipeline' },
+                    new Separator('── Integration ──'),
+                    { value: 'webhook', name: 'webhook', description: 'HTTP webhook handler' },
+                    new Separator('── Utility ──'),
+                    { value: 'error-handler', name: 'error-handler', description: 'Error handling and recovery' },
+                    new Separator('── CI/CD ──'),
+                    { value: 'cicd-test-deploy', name: 'cicd-test-deploy', description: 'Test and deploy pipeline' },
+                    { value: 'cicd-docker', name: 'cicd-docker', description: 'Docker build and push' },
+                    { value: 'cicd-multi-env', name: 'cicd-multi-env', description: 'Multi-environment deploy' },
+                    { value: 'cicd-matrix', name: 'cicd-matrix', description: 'Matrix build strategy' },
+                ],
+                default: 'sequential',
+            });
+        }
     }
     else {
-        template = await select({
-            message: 'Workflow template:',
-            choices: [
-                new Separator('── Data Processing ──'),
-                { value: 'sequential', name: 'sequential', description: 'Linear pipeline' },
-                { value: 'foreach', name: 'foreach', description: 'Batch iteration' },
-                { value: 'aggregator', name: 'aggregator', description: 'Collect and aggregate results' },
-                new Separator('── Automation ──'),
-                { value: 'conditional', name: 'conditional', description: 'Route by condition' },
-                new Separator('── AI ──'),
-                { value: 'ai-agent', name: 'ai-agent', description: 'LLM agent with tool calling' },
-                { value: 'ai-react', name: 'ai-react', description: 'ReAct pattern' },
-                { value: 'ai-rag', name: 'ai-rag', description: 'Retrieval-Augmented Generation' },
-                { value: 'ai-chat', name: 'ai-chat', description: 'Conversational AI' },
-                new Separator('── Durable ──'),
-                { value: 'ai-agent-durable', name: 'ai-agent-durable', description: 'Durable agent with approval gate' },
-                { value: 'ai-pipeline-durable', name: 'ai-pipeline-durable', description: 'Durable data pipeline' },
-                new Separator('── Integration ──'),
-                { value: 'webhook', name: 'webhook', description: 'HTTP webhook handler' },
-                new Separator('── Utility ──'),
-                {
-                    value: 'error-handler',
-                    name: 'error-handler',
-                    description: 'Error handling and recovery',
-                },
-            ],
-            default: 'sequential',
+        // Non-expert: use-case categories
+        if (options.useCase) {
+            if (!VALID_USE_CASES.includes(options.useCase)) {
+                throw new Error(`Unknown use case "${options.useCase}". Available: ${VALID_USE_CASES.join(', ')}`);
+            }
+            useCase = options.useCase;
+        }
+        else if (skipPrompts) {
+            useCase = 'data';
+        }
+        else {
+            useCase = await select({
+                message: 'What are you building?',
+                choices: USE_CASE_CHOICES,
+                default: 'data',
+            });
+        }
+        const selection = selectTemplateForPersona(persona, useCase);
+        if (selection.choices && !skipPrompts) {
+            // Lowcode with multiple choices: show sub-select
+            template = await select({
+                message: 'Pick a template:',
+                choices: getTemplateSubChoices(selection.choices),
+                default: selection.template,
+            });
+        }
+        else {
+            template = selection.template;
+        }
+    }
+    // 3b. "Something else" follow-up: ask what they're building
+    let useCaseDescription;
+    if (useCase === 'minimal' && !skipPrompts && persona !== 'expert') {
+        useCaseDescription = await input({
+            message: 'Briefly describe what you want to build:',
+        });
+        if (useCaseDescription) {
+            useCaseDescription = useCaseDescription.trim();
+        }
+        if (!useCaseDescription)
+            useCaseDescription = undefined;
+    }
+    // 4. MCP setup (nocode, vibecoder, lowcode: prompt; expert: skip unless --mcp)
+    let mcp;
+    if (options.mcp !== undefined) {
+        mcp = options.mcp;
+    }
+    else if (skipPrompts) {
+        mcp = false;
+    }
+    else if (persona === 'nocode' || persona === 'vibecoder' || persona === 'lowcode') {
+        mcp = await confirm({
+            message: 'Set up AI editor integration? (Claude Code, Cursor, VS Code, etc.)',
+            default: true,
         });
     }
-    // 3. Install deps?
+    else {
+        mcp = false;
+    }
+    // 5. Install deps (expert: prompt, others: auto-yes)
     let installDeps;
     if (options.install !== undefined) {
         installDeps = options.install;
     }
-    else if (skipPrompts) {
+    else if (skipPrompts || persona !== 'expert') {
         installDeps = true;
     }
     else {
         installDeps = await confirm({ message: 'Install dependencies (npm install)?', default: true });
     }
-    // 4. Git init?
+    // 6. Git init (expert: prompt, others: auto-yes)
     let gitInit;
     if (options.git !== undefined) {
         gitInit = options.git;
     }
-    else if (skipPrompts) {
+    else if (skipPrompts || persona !== 'expert') {
         gitInit = true;
     }
     else {
         gitInit = await confirm({ message: 'Initialize a git repository?', default: true });
     }
-    // 5. Module format
+    // 7. Module format (expert only)
     let format;
     if (options.format) {
         format = options.format;
@@ -134,23 +231,15 @@ export async function resolveInitConfig(dirArg, options) {
             throw new Error(`Invalid format "${format}". Use "esm" or "cjs".`);
         }
     }
-    else if (skipPrompts) {
+    else if (skipPrompts || persona !== 'expert') {
         format = 'esm';
     }
     else {
         format = await select({
             message: 'Module format:',
             choices: [
-                {
-                    value: 'esm',
-                    name: 'ESM (Recommended)',
-                    description: 'ECMAScript modules (import/export)',
-                },
-                {
-                    value: 'cjs',
-                    name: 'CommonJS',
-                    description: 'CommonJS modules (require/module.exports)',
-                },
+                { value: 'esm', name: 'ESM (Recommended)', description: 'ECMAScript modules (import/export)' },
+                { value: 'cjs', name: 'CommonJS', description: 'CommonJS modules (require/module.exports)' },
             ],
             default: 'esm',
         });
@@ -163,10 +252,14 @@ export async function resolveInitConfig(dirArg, options) {
         install: installDeps,
         git: gitInit,
         force,
+        persona,
+        useCase,
+        useCaseDescription,
+        mcp,
     };
 }
 // ── Pure file generation ─────────────────────────────────────────────────────
-export function generateProjectFiles(projectName, template, format = 'esm') {
+export function generateProjectFiles(projectName, template, format = 'esm', persona = 'expert') {
     const workflowName = toWorkflowName(projectName);
     const workflowFile = `${projectName}-workflow.ts`;
     const tmpl = getWorkflowTemplate(template);
@@ -174,17 +267,22 @@ export function generateProjectFiles(projectName, template, format = 'esm') {
         throw new Error(`Unknown template "${template}"`);
     }
     const workflowCode = tmpl.generate({ workflowName });
-    // Package.json differs based on module format
+    // Package.json
+    const scripts = {
+        dev: `npx flow-weaver compile src/${workflowFile} -o src && npx tsx src/main.ts`,
+        start: 'npx tsx src/main.ts',
+        compile: `npx flow-weaver compile src/${workflowFile} -o src`,
+        validate: `npx flow-weaver validate src/${workflowFile}`,
+        doctor: 'npx flow-weaver doctor',
+    };
+    // Add diagram script for non-expert personas
+    if (persona !== 'expert') {
+        scripts.diagram = `npx flow-weaver diagram src/${workflowFile} --format ascii-compact`;
+    }
     const packageJsonContent = {
         name: projectName,
         version: '1.0.0',
-        scripts: {
-            dev: `npx flow-weaver compile src/${workflowFile} -o src && npx tsx src/main.ts`,
-            start: 'npx tsx src/main.ts',
-            compile: `npx flow-weaver compile src/${workflowFile} -o src`,
-            validate: `npx flow-weaver validate src/${workflowFile}`,
-            doctor: 'npx flow-weaver doctor',
-        },
+        scripts,
         dependencies: {
             '@synergenius/flow-weaver': 'latest',
         },
@@ -194,13 +292,11 @@ export function generateProjectFiles(projectName, template, format = 'esm') {
             tsx: '^4.21.0',
         },
     };
-    // ESM projects need "type": "module"
     if (format === 'esm') {
         packageJsonContent.type = 'module';
     }
-    // CJS projects can optionally have "type": "commonjs" but it's the default
     const packageJson = JSON.stringify(packageJsonContent, null, 2);
-    // tsconfig.json differs based on module format
+    // tsconfig.json
     const tsconfigContent = {
         compilerOptions: {
             target: 'ES2020',
@@ -216,7 +312,7 @@ export function generateProjectFiles(projectName, template, format = 'esm') {
         include: ['src'],
     };
     const tsconfigJson = JSON.stringify(tsconfigContent, null, 2);
-    // main.ts import syntax differs based on module format
+    // main.ts
     const workflowJsFile = workflowFile.replace(/\.ts$/, '.js');
     let mainTs;
     if (format === 'esm') {
@@ -246,7 +342,6 @@ export function generateProjectFiles(projectName, template, format = 'esm') {
         ].join('\n');
     }
     else {
-        // CommonJS format
         mainTs = [
             '/**',
             ` * ${projectName} — workflow runner`,
@@ -274,7 +369,7 @@ export function generateProjectFiles(projectName, template, format = 'esm') {
     }
     const gitignore = `node_modules/\ndist/\n.tsbuildinfo\n`;
     const configYaml = `defaultFileType: ts\n`;
-    return {
+    const files = {
         'package.json': packageJson,
         'tsconfig.json': tsconfigJson,
         [`src/${workflowFile}`]: workflowCode,
@@ -282,6 +377,13 @@ export function generateProjectFiles(projectName, template, format = 'esm') {
         '.gitignore': gitignore,
         '.flowweaver/config.yaml': configYaml,
     };
+    // Add README for all personas
+    files['README.md'] = generateReadme(projectName, persona, template);
+    // Add example workflow for lowcode persona
+    if (persona === 'lowcode') {
+        files['examples/example-workflow.ts'] = generateExampleWorkflow(projectName);
+    }
+    return files;
 }
 // ── Filesystem writer ────────────────────────────────────────────────────────
 export function scaffoldProject(targetDir, files, options) {
@@ -321,6 +423,74 @@ export function runGitInit(targetDir) {
         return { success: false, error: message };
     }
 }
+/**
+ * After init + MCP setup, offer to launch a CLI agent or generate a prompt for GUI editors.
+ * Returns true if a CLI agent was spawned (init should exit and let the agent take over).
+ */
+export async function handleAgentHandoff(opts) {
+    const { projectName, persona, template, targetDir, cliTools, guiTools, filesCreated, useCaseDescription } = opts;
+    // Step 1: If CLI agent available, offer to launch it
+    if (cliTools.length > 0) {
+        const toolId = cliTools[0]; // Prefer first (claude > codex)
+        const binary = CLI_TOOL_BINARY[toolId];
+        const displayName = toolId === 'claude' ? 'Claude Code' : 'Codex';
+        const launchDefault = AGENT_LAUNCH_DEFAULTS[persona];
+        const shouldLaunch = await confirm({
+            message: `Launch ${displayName} to set up your project?`,
+            default: launchDefault,
+        });
+        if (shouldLaunch && binary) {
+            const prompt = generateAgentPrompt(projectName, persona, template, useCaseDescription);
+            logger.newline();
+            logger.log(`  ${logger.dim(`Starting ${displayName}...`)}`);
+            logger.newline();
+            const child = spawn(binary, [prompt], {
+                cwd: targetDir,
+                stdio: 'inherit',
+                env: { ...process.env },
+            });
+            child.on('error', (err) => {
+                logger.error(`Failed to start ${displayName}: ${err.message}`);
+            });
+            return true;
+        }
+    }
+    // Step 2: If GUI editors configured (or user declined CLI), offer prompt options
+    if (guiTools.length > 0 || cliTools.length > 0) {
+        const promptAction = await select({
+            message: 'Generate a setup prompt for your editor?',
+            choices: [
+                { value: 'terminal', name: 'Print to terminal', description: 'Copy and paste into your editor' },
+                { value: 'file', name: 'Save as file', description: 'Write PROJECT_SETUP.md to your project' },
+                { value: 'both', name: 'Both' },
+                { value: 'skip', name: 'Skip' },
+            ],
+            default: 'terminal',
+        });
+        if (promptAction === 'skip')
+            return false;
+        const editorPrompt = generateEditorPrompt(projectName, persona, template, useCaseDescription);
+        if (promptAction === 'terminal' || promptAction === 'both') {
+            printCopyablePrompt(editorPrompt);
+        }
+        if (promptAction === 'file' || promptAction === 'both') {
+            const setupContent = generateSetupPromptFile(projectName, persona, template, filesCreated, useCaseDescription);
+            const setupPath = path.join(targetDir, 'PROJECT_SETUP.md');
+            fs.writeFileSync(setupPath, setupContent, 'utf8');
+            // Add to .gitignore
+            const gitignorePath = path.join(targetDir, '.gitignore');
+            if (fs.existsSync(gitignorePath)) {
+                const existing = fs.readFileSync(gitignorePath, 'utf8');
+                if (!existing.includes('PROJECT_SETUP.md')) {
+                    fs.appendFileSync(gitignorePath, 'PROJECT_SETUP.md\n', 'utf8');
+                }
+            }
+            logger.newline();
+            logger.success(`Wrote ${logger.highlight('PROJECT_SETUP.md')} ${logger.dim('(delete after first setup)')}`);
+        }
+    }
+    return false;
+}
 // ── CLI entrypoint ───────────────────────────────────────────────────────────
 export async function initCommand(dirArg, options) {
     try {
@@ -331,7 +501,7 @@ export async function initCommand(dirArg, options) {
             throw new Error(`${config.targetDir} already contains a package.json. Use --force to overwrite.`);
         }
         // Generate and scaffold
-        const files = generateProjectFiles(config.projectName, config.template, config.format);
+        const files = generateProjectFiles(config.projectName, config.template, config.format, config.persona);
         const { filesCreated, filesSkipped } = scaffoldProject(config.targetDir, files, {
             force: config.force,
         });
@@ -351,8 +521,7 @@ export async function initCommand(dirArg, options) {
         if (config.git) {
             gitResult = runGitInit(config.targetDir);
         }
-        // Auto-compile the workflow so `npm start` works immediately.
-        // Skip in JSON mode since compileCommand writes to logger.
+        // Auto-compile the workflow so `npm start` works immediately
         const workflowFile = `${config.projectName}-workflow.ts`;
         const workflowPath = path.join(config.targetDir, 'src', workflowFile);
         let compileResult;
@@ -366,6 +535,45 @@ export async function initCommand(dirArg, options) {
                 compileResult = { success: false, error: message };
             }
         }
+        // MCP setup
+        let mcpConfigured;
+        let mcpResult;
+        if (config.mcp && !options.json) {
+            const spinner = logger.spinner('Detecting AI editors...');
+            try {
+                mcpResult = await runMcpSetupFromInit();
+                mcpConfigured = mcpResult.configured;
+                spinner.stop();
+                // Per-tool status lines
+                for (const t of mcpResult.detected) {
+                    if (!t.detected)
+                        continue;
+                    const wasConfigured = mcpConfigured.includes(t.displayName);
+                    if (wasConfigured) {
+                        logger.success(`${t.displayName} configured`);
+                    }
+                }
+                if (mcpResult.failed.length > 0) {
+                    for (const name of mcpResult.failed) {
+                        logger.warn(`${name} failed to configure`);
+                    }
+                }
+                if (mcpResult.detected.every((t) => !t.detected)) {
+                    logger.log(`  ${logger.dim('No AI editors detected')}`);
+                }
+            }
+            catch {
+                spinner.fail('MCP setup failed');
+            }
+        }
+        // Agent handoff
+        let agentLaunched = false;
+        let mcpCliTools = [];
+        let mcpGuiTools = [];
+        if (mcpResult) {
+            mcpCliTools = mcpResult.cliTools;
+            mcpGuiTools = mcpResult.guiTools;
+        }
         // Build report
         const report = {
             projectDir: config.targetDir,
@@ -373,20 +581,30 @@ export async function initCommand(dirArg, options) {
             filesSkipped,
             template: config.template,
             format: config.format,
+            persona: config.persona,
             installResult,
             gitResult,
+            mcpConfigured,
+            agentLaunched: false,
         };
         if (options.json) {
             console.log(JSON.stringify(report, null, 2));
             return;
         }
-        // Human output
+        // Human output — status lines
         logger.newline();
         logger.success(`Created ${logger.highlight(config.projectName)} ${logger.dim(`(${config.template}, ${config.format.toUpperCase()})`)}`);
-        logger.log(`  ${filesCreated.join(', ')}`);
         if (filesSkipped.length > 0) {
             logger.warn(`Skipped ${filesSkipped.length} existing file(s)`);
         }
+        if (installResult) {
+            if (installResult.success) {
+                logger.success('Dependencies installed');
+            }
+            else {
+                logger.warn(`npm install failed: ${installResult.error}`);
+            }
+        }
         if (gitResult) {
             if (gitResult.success) {
                 logger.success('Git initialized');
@@ -403,18 +621,62 @@ export async function initCommand(dirArg, options) {
                 logger.warn(`Compile failed: ${compileResult.error}`);
             }
         }
-        logger.newline();
-        logger.log(`  ${logger.bold('Next steps')}`);
+        // Read the workflow code for preview
+        const workflowCode = files[`src/${workflowFile}`] ?? null;
+        // Persona-specific rich output
         const relDir = path.relative(process.cwd(), config.targetDir);
         const displayDir = !relDir || relDir === '.' ? null : relDir.startsWith('../../') ? config.targetDir : relDir;
-        if (displayDir) {
-            logger.log(`  cd ${displayDir}`);
+        // Agent handoff: offer to launch CLI agent or generate prompt for GUI editors.
+        // Decoupled from MCP: even if MCP wasn't run, check for available CLI tools.
+        const skipAgent = options.agent === false || options.yes || isNonInteractive();
+        if (!skipAgent) {
+            // If MCP didn't run or found no CLI tools, do a quick binary check
+            if (mcpCliTools.length === 0) {
+                try {
+                    mcpCliTools = await detectCliTools();
+                }
+                catch {
+                    // Non-fatal
+                }
+            }
+            const hasTools = mcpCliTools.length > 0 || mcpGuiTools.length > 0;
+            if (hasTools) {
+                try {
+                    agentLaunched = await handleAgentHandoff({
+                        projectName: config.projectName,
+                        persona: config.persona,
+                        template: config.template,
+                        targetDir: config.targetDir,
+                        cliTools: mcpCliTools,
+                        guiTools: mcpGuiTools,
+                        filesCreated,
+                        useCaseDescription: config.useCaseDescription,
+                    });
+                    report.agentLaunched = agentLaunched;
+                }
+                catch (err) {
+                    if (err instanceof ExitPromptError)
+                        return;
+                    // Non-fatal: just skip agent handoff
+                }
+            }
         }
-        if (!config.install) {
-            logger.log('  npm install');
+        // If an agent was spawned, it takes over. Print minimal output.
+        if (agentLaunched) {
+            return;
         }
-        logger.log(compileResult?.success ? '  npm start' : '  npm run dev');
-        logger.newline();
+        printNextSteps({
+            projectName: config.projectName,
+            persona: config.persona,
+            template: config.template,
+            displayDir,
+            installSkipped: !config.install,
+            workflowCode,
+            workflowFile,
+            mcpConfigured,
+            agentLaunched,
+            compiled: compileResult?.success,
+        });
     }
     catch (err) {
         // Clean exit on Ctrl+C during prompts

package/dist/cli/commands/mcp-setup.d.ts

@@ -2,6 +2,10 @@
  * mcp-setup command — detect AI coding tools and configure the Flow Weaver MCP server.
  */
 export type ToolId = 'claude' | 'cursor' | 'vscode' | 'windsurf' | 'codex' | 'openclaw';
+/** Tools that can be spawned as interactive CLI sessions */
+export declare const CLI_TOOL_IDS: ReadonlySet<ToolId>;
+/** Binary name to spawn for each CLI tool */
+export declare const CLI_TOOL_BINARY: Partial<Record<ToolId, string>>;
 export interface McpSetupDeps {
     execCommand: (cmd: string) => Promise<{
         stdout: string;
@@ -40,6 +44,26 @@ export declare function mergeJsonConfig(deps: McpSetupDeps, filePath: string, ro
 }>;
 export declare const TOOL_REGISTRY: ToolDefinition[];
 export declare function detectTools(deps: McpSetupDeps): Promise<DetectedTool[]>;
+export interface McpSetupFromInitResult {
+    configured: string[];
+    failed: string[];
+    /** Full detection results for each tool (used by init for transparent feedback) */
+    detected: DetectedTool[];
+    /** Tool IDs that can be spawned as interactive CLI sessions (e.g. claude, codex) */
+    cliTools: ToolId[];
+    /** Tool IDs that are GUI-only editors (e.g. cursor, vscode, windsurf) */
+    guiTools: ToolId[];
+}
+/**
+ * Detect and configure all AI tools without interactive prompts.
+ * Used by the init command after the user has already consented.
+ */
+export declare function runMcpSetupFromInit(deps?: McpSetupDeps): Promise<McpSetupFromInitResult>;
+/**
+ * Check which CLI agent tools are available on PATH.
+ * Lightweight: only runs `which` for known CLI binaries.
+ */
+export declare function detectCliTools(deps?: McpSetupDeps): Promise<ToolId[]>;
 export declare function mcpSetupCommand(options: McpSetupOptions, deps?: McpSetupDeps): Promise<void>;
 export {};
 //# sourceMappingURL=mcp-setup.d.ts.map