@vortex-ai/cli 0.1.45 → 0.1.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vortex-ai/cli",
-  "version": "0.1.45",
+  "version": "0.1.55",
   "description": "Vortex CLI - The main entry point",
   "main": "./dist/index.js",
   "bin": {

package/src/commands/cache.ts

@@ -12,9 +12,9 @@ cacheCommand
       const stats = await LLMCacheManager.getStats();
       console.log("\nLLM Cache Statistics\n");
       console.log(`Entries:    ${stats.entries.toLocaleString()}`);
-      console.log(`Hits:       ${stats.hits.toLocaleString()}`);
+      console.log(`Saved API Calls: ${stats.hits.toLocaleString()}`);
       const storageMB = (stats.storage / 1024 / 1024).toFixed(2);
-      console.log(`Storage:    ${storageMB} MB\n`);
+      console.log(`Storage Used:    ${storageMB} MB\n`);
     } catch (err) {
       console.error("Failed to retrieve cache stats:", err);
     }

package/src/commands/config.ts

@@ -28,9 +28,11 @@ export async function configSet(provider: string, value: string) {
     envKey = "GEMINI_API_KEY";
   } else if (providerUpper === "GROQ") {
     envKey = "GROQ_API_KEY";
+  } else if (providerUpper === "OPENROUTER") {
+    envKey = "OPENROUTER_API_KEY";
   } else {
-    console.log(chalk.red(`Invalid option: ${chalk.bold(provider)}. Supported options are 'gemini' and 'groq'.`));
-    console.log(chalk.gray(`Usage: vortex config set gemini <your-key>`));
+    console.log(chalk.red(`Invalid option: ${chalk.bold(provider)}. Supported options are 'gemini', 'groq', and 'openrouter'.`));
+    console.log(chalk.gray(`Usage: vortex config set openrouter <your-key>`));
     process.exit(1);
   }
 

package/src/commands/init.ts

@@ -1,35 +1,50 @@
 import { Indexer } from "@vortex/engine";
+import * as fs from "fs";
+import * as path from "path";
 
 export async function initCommand(options: any) {
   const { default: ora } = await import("ora");
   const { default: chalk } = await import("chalk");
 
-  console.log(chalk.blue.bold("\nInitializing Vortex Intelligence Layer\n"));
-
-  if (options.reindex) {
-    console.log(chalk.yellow("  Reindex mode: Rebuilding embeddings and BM25 index"));
-    console.log(chalk.yellow("  Historical review memory will be preserved\n"));
-  }
+  console.log(`\n  ${chalk.cyan('◆')} Vortex\n`);
 
+  const startTime = Date.now();
   const spinner = ora("Scanning repository and building indices...").start();
 
   const indexer = new Indexer();
   try {
     const stats = await indexer.indexRepository(process.cwd());
 
-    spinner.succeed(chalk.green("Initialization complete!\n"));
-
-    console.log(chalk.white.bold("  Index Statistics:"));
-    console.log(chalk.gray(`     Files processed:  ${stats.filesProcessed}`));
-    console.log(chalk.gray(`     Chunks indexed:   ${stats.chunksIndexed}`));
-    console.log(chalk.cyan(`     BM25 documents:   ${stats.bm25Documents}`));
-    console.log(chalk.gray(`     Vector store:     SQLite (Prisma)`));
-    console.log(chalk.gray(`     BM25 index:       .vortex-bm25.json\n`));
+    const durationStr = ((Date.now() - startTime) / 1000).toFixed(1) + "s";
+    spinner.succeed(chalk.green(`${stats.filesProcessed} files indexed  ·  ${durationStr}\n`));
+
+    // Automatically update .gitignore
+    const gitignorePath = path.join(process.cwd(), ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+      let content = fs.readFileSync(gitignorePath, "utf8");
+      const entriesToAdd = [
+        ".vortex.db",
+        ".vortex-bm25.json",
+        ".vortex_backup/"
+      ];
+      
+      let changed = false;
+      for (const entry of entriesToAdd) {
+        if (!content.includes(entry)) {
+          if (!content.endsWith("\n") && content.length > 0) {
+            content += "\n";
+          }
+          content += entry + "\n";
+          changed = true;
+        }
+      }
+      
+      if (changed) {
+        fs.writeFileSync(gitignorePath, content, "utf8");
+        console.log(chalk.gray(`  Updated .gitignore`));
+      }
+    }
 
-    console.log(chalk.green("  Ready for:"));
-    console.log(chalk.gray("     • vortex search -q \"your query\"     (hybrid search)"));
-    console.log(chalk.gray("     • vortex review --pr <number>       (multi-agent review)"));
-    console.log(chalk.gray("     • vortex issue --id <number>        (issue analysis)\n"));
   } catch (err) {
     spinner.fail(chalk.red("Failed to initialize"));
     console.error(err);

package/src/commands/review.ts

@@ -19,11 +19,8 @@ export async function reviewCommand(options: any) {
     renderer: new TerminalRenderer() as any,
   });
 
-  if (options.pr) {
-    console.log(chalk.blue.bold(`\nMulti-Agent Review for PR #${options.pr}\n`));
-  } else {
-    console.log(chalk.blue.bold(`\nMulti-Agent Review for Local Changes\n`));
-  }
+  const reviewTitle = options.pr ? `PR #${options.pr}` : 'local';
+  console.log(`\n  ${chalk.cyan('◆')} Vortex  ·  review  ·  ${reviewTitle}\n`);
 
   if (!process.env.GITHUB_TOKEN) {
     console.log(
@@ -68,28 +65,32 @@ export async function reviewCommand(options: any) {
       }
     }
 
+    const diffLines = diff.split('\n').filter(l => l.startsWith('+++') || l.startsWith('---')).length / 2 || 1;
+    spinner.succeed(`Fetched diff  ·  ~${Math.floor(diffLines)} files changed`);
 
-    spinner.text = "Extracting architectural queries from diff...";
     const agent = new IntelligenceAgent();
     const indexer = new Indexer();
 
+    spinner.start("Scanning repository and building indices for fresh context...");
+    await indexer.indexRepository(process.cwd());
+
+    spinner.start("Extracting architectural queries from diff...");
+
     const queries = await agent.extractSearchQueriesFromDiff(diff);
 
     const allChunks: any[] = [];
     if (queries.length > 0) {
-      spinner.text = `Hybrid searching for: ${queries.join(", ")}...`;
-      for (const query of queries) {
-        const results = await indexer.hybridSearch(query, 3);
-        allChunks.push(...results);
-      }
+      spinner.text = `Hybrid searching for context (parallel)...`;
+      const allResults = await Promise.all(
+        queries.map(query => indexer.hybridSearch(query, 3))
+      );
+      allChunks.push(...allResults.flat());
     }
 
-
     const uniqueChunks = Array.from(
       new Map(allChunks.map((c) => [c.id, c])).values()
     );
 
-
     spinner.text = "Checking memory for relevant past reviews...";
     const memoryService = new MemoryService();
     const memories = await memoryService.recallRelevantMemories(
@@ -97,19 +98,17 @@ export async function reviewCommand(options: any) {
       3
     );
 
-
-    spinner.text = `Running multi-agent review (Security + Architecture + Synthesis)...`;
+    spinner.text = `Running multi-agent review (Security, Architecture, Synthesis)...`;
     const review = await agent.generateMultiAgentReview(
       diff,
       uniqueChunks,
       memories
     );
 
-    spinner.succeed(
-      chalk.green(
-        `Review complete in ${(review.durationMs / 1000).toFixed(1)}s!\n`
-      )
-    );
+    spinner.stop();
+    console.log(`  ${chalk.green('✔')} Security Agent       ${review.agentOutputs.security.findings.length} findings`);
+    console.log(`  ${chalk.green('✔')} Architecture Agent   ${review.agentOutputs.architecture.findings.length} suggestions`);
+    console.log(`  ${chalk.green('✔')} Synthesizer          Report ready\n`);
 
 
     const parsedReview = await marked.parse(review.markdownReport);
@@ -150,37 +149,23 @@ export async function reviewCommand(options: any) {
     );
 
 
-    const { security, architecture } = review.agentOutputs;
-
-    console.log(
-      chalk.dim(
-        `\n Security: ${security.riskLevel} (${security.findings.length} findings)`
-      )
-    );
-    security.findings.forEach((f: any, i: number) => {
-      const severityColor =
-        f.severity === "critical" || f.severity === "high"
-          ? chalk.red
-          : f.severity === "medium"
-            ? chalk.yellow
-            : chalk.gray;
-      console.log(severityColor(`    [${f.severity.toUpperCase()}] ${f.title}`));
-    });
-
-    console.log(
-      chalk.dim(
-        `\n Architecture: ${architecture.consistencyScore} (${architecture.findings.length} findings)`
-      )
-    );
-    architecture.findings.forEach((f: any, i: number) => {
-      const severityColor =
-        f.severity === "breaking"
-          ? chalk.red
-          : f.severity === "major"
-            ? chalk.yellow
-            : chalk.gray;
-      console.log(severityColor(`    [${f.severity.toUpperCase()}] ${f.title}`));
-    });
+    const { security, architecture, synthesis } = review.agentOutputs;
+
+    const secCount = security.findings.length;
+    const archCount = architecture.findings.length;
+    
+    // Draw the summary bar chart
+    console.log(`  ────────────────────────────────────────`);
+    
+    const secBar = secCount > 0 ? chalk.red('█'.repeat(Math.min(secCount, 10))) : chalk.green('░');
+    console.log(`  SECURITY    ${secBar.padEnd(20)}  ${secCount} issues`);
+    
+    const archBar = archCount > 0 ? chalk.yellow('█'.repeat(Math.min(archCount, 10))) : chalk.green('░');
+    console.log(`  ARCH        ${archBar.padEnd(20)}  ${archCount} suggestions`);
+    
+    const logicBar = synthesis.verdict === 'SAFE_TO_MERGE' ? chalk.green('░') : chalk.red('█');
+    console.log(`  LOGIC       ${logicBar.padEnd(20)}  ${synthesis.verdict.toLowerCase().replace(/_/g, ' ')}`);
+    console.log(`  ────────────────────────────────────────\n`);
 
     if (uniqueChunks.length > 0) {
       console.log(chalk.cyan.dim("\n Cross-Referenced Architecture:"));

package/src/commands/search.ts

@@ -15,21 +15,33 @@ export async function searchCommand(options: any) {
   const indexer = new Indexer();
 
   try {
-    spinner.text = "Running hybrid search (vector + BM25 + cross-encoder)...";
-    const results = await indexer.hybridSearch(options.query, parseInt(options.limit, 10));
+    spinner.text = options.expandQuery ? "Expanding query and running parallel hybrid search..." : "Running hybrid search (vector + BM25 + cross-encoder)...";
     
-    if (results.length === 0) {
+    let queriesToSearch = [options.query];
+    const agent = new IntelligenceAgent();
+
+    if (options.expandQuery) {
+      queriesToSearch = await agent.expandQuery(options.query);
+    }
+
+    const allResults = await Promise.all(
+      queriesToSearch.map(q => indexer.hybridSearch(q, parseInt(options.limit, 10)))
+    );
+    
+    const flatResults = allResults.flat();
+    const uniqueResults = Array.from(new Map(flatResults.map((c) => [c.id, c])).values()).sort((a, b) => b.score - a.score).slice(0, parseInt(options.limit, 10));
+
+    if (uniqueResults.length === 0) {
       spinner.fail("No relevant code found.");
       return;
     }
     
-    spinner.text = `Found ${results.length} relevant code chunks. Analyzing with Gemini...`;
+    spinner.text = `Found ${uniqueResults.length} relevant code chunks. Analyzing with AI engine...`;
     
     const memoryService = new MemoryService();
     const memories = await memoryService.recallRelevantMemories(options.query, 3);
     
-    const agent = new IntelligenceAgent();
-    const answer = await agent.answerQueryWithContext(options.query, results);
+    const answer = await agent.answerQueryWithContext(options.query, uniqueResults);
     
     spinner.succeed("Analysis complete!\n");
     
@@ -47,7 +59,7 @@ export async function searchCommand(options: any) {
     console.log(formatted);
     
     console.log(chalk.cyan.dim(" Reference Material (Hybrid Retrieval)"));
-    results.forEach((res: any, i: number) => {
+    uniqueResults.forEach((res: any, i: number) => {
       const sources = res.sources ? res.sources.join("+") : "vector";
       const scoreStr = res.score ? (res.score * 100).toFixed(1) + '%' : 'N/A';
       console.log(chalk.gray(`  │ [${i + 1}] ${res.file.replace(process.cwd(), '')} ➔ ${res.symbolPath || '(anonymous)'} (${scoreStr}) [${sources}]`));

package/src/commands/solve-issue.ts

@@ -59,7 +59,8 @@ Please fix this issue in the codebase.`;
     await solveCommand(prompt, {
       autoApprove: options.autoApprove,
       maxSteps: options.maxSteps,
-      contextChunks: contextChunks
+      contextChunks: contextChunks,
+      verify: options.verify
     });
 
   } catch (err) {

package/src/commands/solve.ts

@@ -8,17 +8,21 @@ import {
   AutonomousAgent,
   FileReadTool,
   FileWriteTool,
+  FileEditTool,
   ShellExecuteTool,
   GrepTool,
   RagSearchTool,
+  WebSearchTool,
   ApprovalCallback,
-  AgentContextChunk
+  AgentContextChunk,
+  IntelligenceAgent,
+  Indexer
 } from "@vortex/engine";
 import { initDatabase } from "@vortex/db";
 import { getGitRoot, isGitRepo } from "@vortex/git";
 import { VectorStore, LocalEmbedder, BM25Index, HybridRetriever } from "@vortex/retrieval";
 
-export async function solveCommand(prompt: string, options: { autoApprove?: boolean; maxSteps?: number; contextChunks?: AgentContextChunk[]; newProject?: string } = {}) {
+export async function solveCommand(prompt: string, options: { autoApprove?: boolean; maxSteps?: number; contextChunks?: AgentContextChunk[]; newProject?: string; verify?: string | boolean } = {}) {
   let cwd = process.cwd();
 
   if (options.newProject) {
@@ -29,7 +33,7 @@ export async function solveCommand(prompt: string, options: { autoApprove?: bool
     }
     cwd = projectPath;
     process.chdir(cwd);
-    
+
     if (!fs.existsSync(path.join(cwd, ".git"))) {
       try {
         execSync("git init", { cwd, stdio: "ignore" });
@@ -46,12 +50,11 @@ export async function solveCommand(prompt: string, options: { autoApprove?: bool
     rootPath = getGitRoot(cwd);
   }
 
-  console.log(`\nVortex Autonomous Agent activated`);
-  console.log(`Task: "${prompt}"\n`);
+  console.log(`\n  ${chalk.cyan('◆')} Vortex  ·  solve\n`);
 
   await initDatabase();
 
-  const spinner = ora("Initializing Vector Store for Project Memory...").start();
+  const spinner = ora("Reading codebase...").start();
 
   try {
     const vectorStore = new VectorStore();
@@ -59,19 +62,92 @@ export async function solveCommand(prompt: string, options: { autoApprove?: bool
     const embedder = new LocalEmbedder();
     const hybridRetriever = new HybridRetriever(vectorStore, bm25Index, embedder);
     const agent = new AutonomousAgent();
-    
+
     if (options.maxSteps !== undefined) {
       (agent as any).maxToolIterations = options.maxSteps;
     }
 
-    spinner.text = "Thinking...";
+    if (!options.contextChunks || options.contextChunks.length === 0) {
+      try {
+        const indexer = new Indexer();
+        const relevantContext = await indexer.hybridSearch(prompt, 15);
+        options.contextChunks = relevantContext.map((c: any) => ({
+          file: c.file,
+          symbolPath: c.symbolPath || "anonymous",
+          content: c.content,
+          kind: c.kind || "unknown",
+        }));
+      } catch (e) {
+        console.warn(chalk.yellow("⚠️ Could not search vector store. Did you run 'vortex init'?"));
+        options.contextChunks = [];
+      }
+    }
+
+    spinner.text = "Planning approach...";
+    const intelligenceAgent = new IntelligenceAgent();
+    let executionPlanStr = await intelligenceAgent.generateExecutionPlan(prompt, options.contextChunks || []);
+    
+    let planSummary = "task";
+    let stepCount = 0;
+    let executionPlan = "";
+    let filesToRead: string[] = [];
+    try {
+      const parsedPlan = JSON.parse(executionPlanStr);
+      planSummary = parsedPlan.summary || planSummary;
+      stepCount = parsedPlan.steps ? parsedPlan.steps.length : 0;
+      executionPlan = parsedPlan.steps ? parsedPlan.steps.map((s: any, i: number) => {
+        if (typeof s === 'string') return `${i + 1}. ${s}`;
+        return `${i + 1}. [${(s.action || 'MODIFY').toUpperCase()}] ${s.file || 'General'}\n   ${s.description}`;
+      }).join("\n\n") : executionPlanStr;
+      filesToRead = parsedPlan.filesToRead || [];
+    } catch {
+      executionPlan = executionPlanStr;
+    }
+
+    if (filesToRead.length > 0) {
+      for (const file of filesToRead) {
+        try {
+          const fullPath = path.resolve(rootPath, file);
+          if (fs.existsSync(fullPath)) {
+            const content = fs.readFileSync(fullPath, "utf-8");
+            options.contextChunks!.push({ file, symbolPath: "file", content, kind: "file" });
+          }
+        } catch { }
+      }
+    }
+
+    spinner.stopAndPersist({ symbol: chalk.green('✔'), text: `Plan ready  ·  ${planSummary}  (${stepCount} steps)\n` });
+
+    console.log(`\n${chalk.cyan.dim("─── Execution Plan ───")}`);
+    console.log(chalk.gray(executionPlan));
+    console.log(`${chalk.cyan.dim("──────────────────────")}\n`);
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(`  Proceed? (Y/n/edit) › `);
+
+    if (answer.toLowerCase() === 'n') {
+      console.log(chalk.red('\n  ✖ Task aborted by user.\n'));
+      rl.close();
+      process.exit(0);
+    } else if (answer.toLowerCase() === 'edit') {
+      const edits = await rl.question(`  Enter instructions › `);
+      if (edits.trim()) {
+        executionPlan += `\n\n### User Modifications\n${edits.trim()}`;
+      }
+    }
+    rl.close();
+
+    const enrichedPrompt = `Original Task:\n${prompt}\n\nExecution Plan generated by Architect:\n${executionPlan}`;
+
+    console.log(`\n  ${chalk.cyan('◆')} Vortex  ·  solving\n`);
+    spinner.start("Initializing agent...");
 
     const approvalCallback: ApprovalCallback = async (action: string, description: string): Promise<boolean> => {
       if (options.autoApprove) return true;
-      
+
       const currentText = spinner.text;
       spinner.stop();
-      
+
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
       let question = "";
       if (action === "shell_execute") {
@@ -81,10 +157,10 @@ export async function solveCommand(prompt: string, options: { autoApprove?: bool
       } else {
         question = `\n${chalk.yellow('⚠️ Agent wants to perform action:')} ${action} on ${description}\nAllow? (y/N) `;
       }
-      
+
       const answer = await rl.question(question);
       rl.close();
-      
+
       spinner.start(currentText);
       return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
     };
@@ -93,26 +169,38 @@ export async function solveCommand(prompt: string, options: { autoApprove?: bool
     agent.registerTools([
       new FileReadTool(rootPath),
       new FileWriteTool(rootPath, vectorStore, embedder, approvalCallback),
+      new FileEditTool(rootPath, vectorStore, embedder, approvalCallback),
       new ShellExecuteTool(rootPath, approvalCallback),
       new GrepTool(rootPath),
       new RagSearchTool(hybridRetriever),
+      new WebSearchTool(),
     ]);
 
+    const initialState = {
+      evidence: { filesRead: filesToRead, symbolsObserved: [], dependenciesObserved: [], externalSchemasFound: {}, confidence: 'LOW' as any },
+      plan: { steps: [], currentStepIndex: 0, completedSteps: [] },
+      execution: { filesModified: [], commandsRun: [], lastError: null, consecutiveFailures: 0 },
+      verification: { contractItems: [], passed: [], failed: [] },
+      verdict: 'IN_PROGRESS' as any
+    };
+
     const result = await agent.run(
       {
-        diff: prompt,
+        diff: enrichedPrompt,
         contextChunks: options.contextChunks || [],
       },
       {
+        initialState,
+        verifyCommand: options.verify,
         onToolCall: (toolName, args) => {
           if (toolName === "write_file") {
-            spinner.text = `Writing file: ${args.path}...`;
+            spinner.text = `Writing ${args.path}...`;
+          } else if (toolName === "read_file") {
+            spinner.text = `Inspecting ${args.path}...`;
           } else if (toolName === "shell_execute") {
-            spinner.text = `Executing shell command...`;
-          } else if (toolName === "rag_search") {
-            spinner.text = `Searching project memory for context...`;
+            spinner.text = `Running verification...`;
           } else {
-            spinner.text = `Agent is using tool: ${toolName}...`;
+            spinner.text = `Using ${toolName}...`;
           }
         },
         onToolResult: (toolName, toolResult) => {
@@ -121,15 +209,15 @@ export async function solveCommand(prompt: string, options: { autoApprove?: bool
             try {
               const match = toolResult.match(/Wrote to (.*) successfully/);
               if (match && match[1]) {
-                 const filePath = match[1];
-                 console.log(`\n${chalk.green('✓ File updated:')} ${filePath}`);
-                 const diffOut = execSync(`git diff --unified=1 ${filePath}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore']});
-                 if (diffOut) {
-                   console.log(chalk.gray(diffOut));
-                 }
+                const filePath = match[1];
+                const diffOut = execSync(`git diff --numstat ${filePath}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+                const diffParts = diffOut.split(/\s+/);
+                const additions = diffParts[0] || '0';
+                const deletions = diffParts[1] || '0';
+                console.log(`  ${chalk.cyan('●')} Writing ${filePath}`);
+                console.log(`    ${chalk.green(`+ ${additions} lines`)}  ·  ${chalk.red(`- ${deletions} lines`)}\n`);
               }
             } catch (e) {
-
             }
             spinner.start("Thinking...");
           }
@@ -137,38 +225,53 @@ export async function solveCommand(prompt: string, options: { autoApprove?: bool
       }
     );
 
-    spinner.succeed("Task completed");
+    let iterationCount = 1;
+    if (result.summary) {
+       const iterMatch = result.summary.match(/Iter (\d+)/);
+       if (iterMatch) iterationCount = parseInt(iterMatch[1], 10);
+    }
     
+    let filesChangedCount = 0;
     try {
-      const statOut = execSync(`git diff --stat`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
-      if (statOut.trim()) {
-        console.log(`\n${chalk.cyan('=== Changed Files Summary ===')}`);
-        console.log(statOut);
+      const statOut = execSync(`git diff --shortstat`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+      const filesMatch = statOut.match(/(\d+) file/);
+      if (filesMatch) {
+         filesChangedCount = parseInt(filesMatch[1], 10);
       }
     } catch (e) {}
 
-    console.log(`\n${chalk.cyan('=== Final Output ===')}\n`);
-    console.log(result.summary);
+    spinner.stop();
+    const isIncomplete = result.verdict === 'INCOMPLETE' || result.state?.verdict === 'INCOMPLETE';
+    const isComplete = !isIncomplete;
 
+    if (isIncomplete) {
+      console.log(`\n  ${chalk.red('✖')} Task incomplete  ·  stopped or failed`);
+    } else {
+      console.log(`\n  ────────────────────────────────────────`);
+      console.log(`  ${chalk.green('✔')} Task complete  ·  ${filesChangedCount} files modified  ·  ${iterationCount} iterations`);
+      console.log(`  ────────────────────────────────────────\n`);
+    }
 
-    const packageJsonPath = path.join(cwd, "package.json");
-    if (fs.existsSync(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-        if (pkg.scripts && pkg.scripts.build) {
-          console.log(`\n${chalk.cyan('=== Verification ===')}`);
-          const buildSpinner = ora("Running build command...").start();
-          try {
-            const env = { ...process.env };
-            delete env.NODE_ENV;
-            execSync("npm run build", { stdio: "pipe", cwd, env });
-            buildSpinner.succeed("Build completed successfully.");
-          } catch (e: any) {
-            buildSpinner.fail("Build failed.");
-            console.error(chalk.red(e.stdout ? e.stdout.toString() : e.message));
+    if (isComplete) {
+      const packageJsonPath = path.join(cwd, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+          if (pkg.scripts && pkg.scripts.build) {
+            console.log(`\n${chalk.cyan('=== Verification ===')}`);
+            const buildSpinner = ora("Running build command...").start();
+            try {
+              const env = { ...process.env };
+              delete env.NODE_ENV;
+              execSync("npm run build", { stdio: "pipe", cwd, env });
+              buildSpinner.succeed("Build completed successfully.");
+            } catch (e: any) {
+              buildSpinner.fail("Build failed.");
+              console.error(chalk.red(e.stdout ? e.stdout.toString() : e.message));
+            }
           }
-        }
-      } catch (e) {}
+        } catch (e) { }
+      }
     }
   } catch (err: any) {
     spinner.fail("Agent encountered an error");