@synergenius/flow-weaver 0.15.2 → 0.17.0

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 } 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,151 @@ 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;
+        }
+    }
+    // 4. MCP setup (nocode + vibecoder only)
+    let mcp;
+    if (options.mcp !== undefined) {
+        mcp = options.mcp;
+    }
+    else if (skipPrompts) {
+        mcp = false;
+    }
+    else if (persona === 'nocode' || persona === 'vibecoder') {
+        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 +219,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 +240,13 @@ export async function resolveInitConfig(dirArg, options) {
         install: installDeps,
         git: gitInit,
         force,
+        persona,
+        useCase,
+        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 +254,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 +279,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 +299,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 +329,6 @@ export function generateProjectFiles(projectName, template, format = 'esm') {
         ].join('\n');
     }
     else {
-        // CommonJS format
         mainTs = [
             '/**',
             ` * ${projectName} — workflow runner`,
@@ -274,7 +356,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 +364,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 +410,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 } = 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);
+            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);
+        if (promptAction === 'terminal' || promptAction === 'both') {
+            printCopyablePrompt(editorPrompt);
+        }
+        if (promptAction === 'file' || promptAction === 'both') {
+            const setupContent = generateSetupPromptFile(projectName, persona, template, filesCreated);
+            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,34 +488,32 @@ 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,
         });
         // Post-scaffold actions
         let installResult;
         if (config.install) {
-            if (!options.json) {
-                logger.info('Installing dependencies...');
-            }
+            const spinner = !options.json ? logger.spinner('Installing dependencies...') : null;
             installResult = runNpmInstall(config.targetDir);
+            if (spinner) {
+                if (installResult.success)
+                    spinner.stop('Dependencies installed');
+                else
+                    spinner.fail(`npm install failed: ${installResult.error}`);
+            }
         }
         let gitResult;
         if (config.git) {
-            if (!options.json) {
-                logger.info('Initializing git repository...');
-            }
             gitResult = runGitInit(config.targetDir);
         }
         // Auto-compile the workflow so `npm start` works immediately
         const workflowFile = `${config.projectName}-workflow.ts`;
         const workflowPath = path.join(config.targetDir, 'src', workflowFile);
-        // Auto-compile the workflow so `npm start` works immediately.
-        // Skip in JSON mode since compileCommand writes to logger.
         let compileResult;
         if (!options.json && fs.existsSync(workflowPath)) {
             try {
-                logger.info('Compiling workflow...');
                 await compileCommand(workflowPath, { format: config.format });
                 compileResult = { success: true };
             }
@@ -367,6 +522,36 @@ 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('Configuring AI editors...');
+            try {
+                mcpResult = await runMcpSetupFromInit();
+                mcpConfigured = mcpResult.configured;
+                if (mcpResult.configured.length > 0) {
+                    spinner.stop(`${mcpResult.configured.join(', ')} configured`);
+                }
+                else if (mcpResult.failed.length > 0) {
+                    spinner.fail('MCP setup failed');
+                }
+                else {
+                    spinner.stop('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,
@@ -374,20 +559,21 @@ 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
-        logger.section('Project created');
-        for (const file of filesCreated) {
-            logger.success(`Created ${file}`);
-        }
-        for (const file of filesSkipped) {
-            logger.warn(`Skipped ${file} (already exists)`);
+        // Human output — status lines
+        logger.newline();
+        logger.success(`Created ${logger.highlight(config.projectName)} ${logger.dim(`(${config.template}, ${config.format.toUpperCase()})`)}`);
+        if (filesSkipped.length > 0) {
+            logger.warn(`Skipped ${filesSkipped.length} existing file(s)`);
         }
         if (installResult) {
             if (installResult.success) {
@@ -399,7 +585,7 @@ export async function initCommand(dirArg, options) {
         }
         if (gitResult) {
             if (gitResult.success) {
-                logger.success('Git repository initialized');
+                logger.success('Git initialized');
             }
             else {
                 logger.warn(`git init failed: ${gitResult.error}`);
@@ -407,24 +593,53 @@ export async function initCommand(dirArg, options) {
         }
         if (compileResult) {
             if (compileResult.success) {
-                logger.success('Workflow compiled (npm start works immediately)');
+                logger.success('Workflow compiled');
             }
             else {
-                logger.warn(`Workflow compile failed: ${compileResult.error}`);
+                logger.warn(`Compile failed: ${compileResult.error}`);
             }
         }
-        logger.newline();
-        logger.section('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
+        const skipAgent = options.agent === false || options.yes || isNonInteractive();
+        if (mcpConfigured && mcpConfigured.length > 0 && !skipAgent) {
+            try {
+                agentLaunched = await handleAgentHandoff({
+                    projectName: config.projectName,
+                    persona: config.persona,
+                    template: config.template,
+                    targetDir: config.targetDir,
+                    cliTools: mcpCliTools,
+                    guiTools: mcpGuiTools,
+                    filesCreated,
+                });
+                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,
+        });
     }
     catch (err) {
         // Clean exit on Ctrl+C during prompts

package/dist/cli/commands/market.js

@@ -191,8 +191,9 @@ export async function marketPackCommand(directory, options = {}) {
             validation,
             parsedFiles: parsedFiles.length,
         }, null, 2));
-        if (!validation.valid)
-            process.exit(1);
+        if (!validation.valid) {
+            process.exitCode = 1;
+        }
         return;
     }
     // Display results
@@ -277,7 +278,8 @@ export async function marketInstallCommand(packageSpec, options = {}) {
         else {
             logger.error(`npm install failed: ${getErrorMessage(err)}`);
         }
-        process.exit(1);
+        process.exitCode = 1;
+        return;
     }
     // 2. Read manifest from installed package
     // Resolve the package name from the spec (could be a tarball path or name@version)
@@ -316,13 +318,18 @@ export async function marketSearchCommand(query, options = {}) {
         logger.newline();
     }
     try {
-        const results = await searchPackages({ query, limit, registryUrl: registry });
+        let results = await searchPackages({ query, limit, registryUrl: registry });
+        // Client-side filtering: npm search may return broad results, narrow to query match
+        if (query) {
+            const q = query.toLowerCase();
+            results = results.filter((pkg) => pkg.name.toLowerCase().includes(q) || (pkg.description && pkg.description.toLowerCase().includes(q)));
+        }
         if (json) {
             console.log(JSON.stringify(results, null, 2));
             return;
         }
         if (results.length === 0) {
-            logger.info('No packages found');
+            logger.info(query ? `No packages matching "${query}"` : 'No packages found');
             return;
         }
         for (const pkg of results) {
@@ -342,7 +349,8 @@ export async function marketSearchCommand(query, options = {}) {
         else {
             logger.error(`Search failed: ${getErrorMessage(err)}`);
         }
-        process.exit(1);
+        process.exitCode = 1;
+        return;
     }
 }
 /**