@vortex-ai/cli 0.1.45 → 0.1.50

package/package.json

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

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(", ")}...`;
+      spinner.text = `Hybrid searching for context...`;
       for (const query of queries) {
         const results = await indexer.hybridSearch(query, 3);
         allChunks.push(...results);
       }
     }
 
-
     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

@@ -23,7 +23,7 @@ export async function searchCommand(options: any) {
       return;
     }
     
-    spinner.text = `Found ${results.length} relevant code chunks. Analyzing with Gemini...`;
+    spinner.text = `Found ${results.length} relevant code chunks. Analyzing with AI engine...`;
     
     const memoryService = new MemoryService();
     const memories = await memoryService.recallRelevantMemories(options.query, 3);

package/src/commands/solve.ts

@@ -8,11 +8,15 @@ 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";
@@ -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,89 @@ 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, 5);
+        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: string, i: number) => `${i + 1}. ${s}`).join("\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 +154,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 +166,37 @@ 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,
         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 +205,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 +221,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");

package/src/index.ts

@@ -4,8 +4,6 @@ import { Command } from "commander";
 import * as path from "path";
 import * as dotenv from "dotenv";
 import * as os from "os";
-
-// Suppress dotenv logging
 process.env.DOTENV_CONFIG_QUIET = "true";
 
 
@@ -36,13 +34,10 @@ import { searchCommand } from "./commands/search";
 import { reviewCommand } from "./commands/review";
 import { issueCommand } from "./commands/issue";
 import { graphCommand } from "./commands/graph";
-import { suggestCommand } from "./commands/suggest";
-import { fixNitbitsCommand } from "./commands/fix-nitbits";
-import { analyzeCommand } from "./commands/analyze";
+
 import { solveCommand } from "./commands/solve";
 import { solveIssueCommand } from "./commands/solve-issue";
 import { cacheCommand } from "./commands/cache";
-import { configSet, configGet, configList } from "./commands/config";
 
 const program = new Command();
 
@@ -53,10 +48,32 @@ program
   .description("Developer Intelligence & PR Review Engine")
   .version(version);
 
-program.hook("preAction", (thisCommand, actionCommand) => {
+program.hook("preAction", async (thisCommand, actionCommand) => {
   if (actionCommand.opts().cache === false) {
     process.env.VORTEX_DISABLE_CACHE = "true";
   }
+
+  const cmdName = actionCommand.name();
+  if (['solve', 'solve-issue', 'review', 'suggest', 'analyze', 'search'].includes(cmdName)) {
+    const { default: ora } = await import("ora");
+    const { default: chalk } = await import("chalk");
+    
+    console.log(`\n  ${chalk.cyan('◆')} Vortex\n`);
+    const spinner = ora("Looking for model...").start();
+    
+    if (process.env.GEMINI_API_KEY || process.env.OPENROUTER_API_KEY || process.env.GROQ_API_KEY) {
+       const priorityString = process.env.VORTEX_MODEL_PRIORITY;
+       const models = priorityString 
+         ? priorityString.split(",").map(s => s.trim()).filter(Boolean)
+         : ["nvidia/nemotron-3-ultra-550b-a55b:free", "nex-agi/nex-n2-pro:free", "openrouter/owl-alpha", "gemini-2.5-flash"];
+       const topModel = models[0] || "gemini";
+       spinner.succeed(`Model router active  ·  priority: ${topModel}\n`);
+    } else {
+       spinner.fail(chalk.red("No model configured"));
+       console.log(`\n  Run:  ${chalk.cyan('vortex config set gemini "your_key_here"')}\n`);
+       process.exit(1);
+    }
+  }
 });
 
 // ── Core Commands ──
@@ -116,50 +133,6 @@ program
 
 // ── AI-Powered Commands ──
 
-program
-  .command("suggest")
-  .description("Generate AI-powered code suggestions using repository patterns and historical intelligence")
-  .requiredOption("--file <path>", "Target file path")
-  .option("--apply", "Apply suggestions automatically")
-  .option("--deep", "Enable advanced contextual suggestions")
-  .option("--no-cache", "Disable LLM response caching")
-  .action(suggestCommand);
-
-program
-  .command("fix-nitbits")
-  .description("Automatically fix formatting, comments, tests, CI issues, and repository-specific patterns")
-  .option("--safe", "Apply only deterministic safe fixes")
-  .option("--dry-run", "Preview fixes without modifying files")
-  .option("--files <paths>", "Comma-separated list of target files")
-  .action(fixNitbitsCommand);
-
-program
-  .command("analyze")
-  .description("Analyze other contributors' PRs using repository history and architectural intelligence")
-  .requiredOption("--pr <number>", "Pull request number", Number)
-  .option("--deep", "Enable advanced PR intelligence analysis")
-  .option("--no-cache", "Disable LLM response caching")
-  .action(analyzeCommand);
-
-const configCmd = program
-  .command("config")
-  .description("Manage global configuration and API keys");
-
-configCmd
-  .command("set <provider> <key>")
-  .description("Set an API key for a specific provider (gemini or groq)")
-  .action(configSet);
-
-configCmd
-  .command("get <key>")
-  .description("Get a global configuration value")
-  .action(configGet);
-
-configCmd
-  .command("list")
-  .description("List all global configuration values")
-  .action(configList);
-
 program.addCommand(cacheCommand);
 
 program.parse();