@vortex-ai/cli 0.1.2

package/dist/index.mjs

@@ -0,0 +1,880 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Command as Command2 } from "commander";
+import * as path3 from "path";
+import * as dotenv from "dotenv";
+import * as os from "os";
+
+// src/commands/init.ts
+import { Indexer } from "@vortex/engine";
+async function initCommand(options) {
+  const { default: ora2 } = await import("ora");
+  const { default: chalk2 } = await import("chalk");
+  console.log(chalk2.blue.bold("\nInitializing Vortex Intelligence Layer\n"));
+  if (options.reindex) {
+    console.log(chalk2.yellow("  Reindex mode: Rebuilding embeddings and BM25 index"));
+    console.log(chalk2.yellow("  Historical review memory will be preserved\n"));
+  }
+  const spinner = ora2("Scanning repository and building indices...").start();
+  const indexer = new Indexer();
+  try {
+    const stats = await indexer.indexRepository(process.cwd());
+    spinner.succeed(chalk2.green("Initialization complete!\n"));
+    console.log(chalk2.white.bold("  Index Statistics:"));
+    console.log(chalk2.gray(`     Files processed:  ${stats.filesProcessed}`));
+    console.log(chalk2.gray(`     Chunks indexed:   ${stats.chunksIndexed}`));
+    console.log(chalk2.cyan(`     BM25 documents:   ${stats.bm25Documents}`));
+    console.log(chalk2.gray(`     Vector store:     SQLite (Prisma)`));
+    console.log(chalk2.gray(`     BM25 index:       .vortex-bm25.json
+`));
+    console.log(chalk2.green("  Ready for:"));
+    console.log(chalk2.gray('     \u2022 vortex search -q "your query"     (hybrid search)'));
+    console.log(chalk2.gray("     \u2022 vortex review --pr <number>       (multi-agent review)"));
+    console.log(chalk2.gray("     \u2022 vortex issue --id <number>        (issue analysis)\n"));
+  } catch (err) {
+    spinner.fail(chalk2.red("Failed to initialize"));
+    console.error(err);
+  }
+}
+
+// src/commands/search.ts
+import { Indexer as Indexer2, IntelligenceAgent, MemoryService } from "@vortex/engine";
+async function searchCommand(options) {
+  const { default: ora2 } = await import("ora");
+  const { default: chalk2 } = await import("chalk");
+  const { default: boxen } = await import("boxen");
+  const { marked } = await import("marked");
+  const { default: TerminalRenderer } = await import("marked-terminal");
+  marked.setOptions({
+    renderer: new TerminalRenderer()
+  });
+  const spinner = ora2(`Searching codebase for: "${options.query}"...`).start();
+  const indexer = new Indexer2();
+  try {
+    spinner.text = "Running hybrid search (vector + BM25 + cross-encoder)...";
+    const results = await indexer.hybridSearch(options.query, parseInt(options.limit, 10));
+    if (results.length === 0) {
+      spinner.fail("No relevant code found.");
+      return;
+    }
+    spinner.text = `Found ${results.length} relevant code chunks. Analyzing with Gemini...`;
+    const memoryService = new MemoryService();
+    const memories = await memoryService.recallRelevantMemories(options.query, 3);
+    const agent = new IntelligenceAgent();
+    const answer = await agent.answerQueryWithContext(options.query, results);
+    spinner.succeed("Analysis complete!\n");
+    const parsedAnswer = await marked.parse(answer);
+    const formatted = boxen(parsedAnswer.trim(), {
+      padding: { top: 1, bottom: 1, left: 2, right: 2 },
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "double",
+      borderColor: "cyan",
+      title: chalk2.cyan.bold(" Vortex AI Engine (Hybrid Search) "),
+      titleAlignment: "center"
+    });
+    console.log(formatted);
+    console.log(chalk2.cyan.dim(" Reference Material (Hybrid Retrieval)"));
+    results.forEach((res, i) => {
+      const sources = res.sources ? res.sources.join("+") : "vector";
+      const scoreStr = res.score ? (res.score * 100).toFixed(1) + "%" : "N/A";
+      console.log(chalk2.gray(`  \u2502 [${i + 1}] ${res.file.replace(process.cwd(), "")} \u2794 ${res.symbolPath || "(anonymous)"} (${scoreStr}) [${sources}]`));
+    });
+    if (memories.length > 0) {
+      console.log(chalk2.yellow.dim("\n Relevant Memories"));
+      memories.forEach((mem, i) => {
+        console.log(chalk2.gray(`  \u2502 [${i + 1}] ${mem.slice(0, 120)}...`));
+      });
+    }
+  } catch (err) {
+    spinner.fail("Search failed");
+    console.error(err);
+  }
+}
+
+// src/commands/review.ts
+import {
+  IntelligenceAgent as IntelligenceAgent2,
+  Indexer as Indexer3,
+  MemoryService as MemoryService2
+} from "@vortex/engine";
+import { createGithubClient } from "@vortex/github";
+async function reviewCommand(options) {
+  const { default: ora2 } = await import("ora");
+  const { default: chalk2 } = await import("chalk");
+  const { default: boxen } = await import("boxen");
+  const { marked } = await import("marked");
+  const { default: TerminalRenderer } = await import("marked-terminal");
+  marked.setOptions({
+    renderer: new TerminalRenderer()
+  });
+  if (options.pr) {
+    console.log(chalk2.blue.bold(`
+Multi-Agent Review for PR #${options.pr}
+`));
+  } else {
+    console.log(chalk2.blue.bold(`
+Multi-Agent Review for Local Changes
+`));
+  }
+  if (!process.env.GITHUB_TOKEN) {
+    console.log(
+      chalk2.yellow(
+        "\u26A0\uFE0F No GITHUB_TOKEN found. Using anonymous access (subject to rate limits)."
+      )
+    );
+  }
+  const repoInfo = await import("@vortex/git").then(
+    (m) => m.getGithubRepoInfo(process.cwd())
+  );
+  const owner = process.env.GITHUB_OWNER || repoInfo?.owner;
+  const repo = process.env.GITHUB_REPO || repoInfo?.repo;
+  if (!owner || !repo) {
+    console.error(
+      chalk2.red(
+        "Could not determine GitHub repository. Please run this command inside a git repository or set GITHUB_OWNER and GITHUB_REPO."
+      )
+    );
+    return;
+  }
+  const spinner = ora2(
+    options.pr ? `Fetching diff for ${owner}/${repo}#${options.pr}...` : `Fetching local git diff...`
+  ).start();
+  try {
+    let diff;
+    if (options.pr) {
+      const github = createGithubClient(process.env.GITHUB_TOKEN);
+      diff = await github.fetchPullRequestDiff(owner, repo, options.pr);
+    } else {
+      const { execSync: execSync2 } = await import("child_process");
+      diff = execSync2("git diff HEAD").toString();
+      if (!diff.trim()) {
+        spinner.fail("No local changes found to review. Make some changes or specify a --pr.");
+        return;
+      }
+    }
+    spinner.text = "Extracting architectural queries from diff...";
+    const agent = new IntelligenceAgent2();
+    const indexer = new Indexer3();
+    const queries = await agent.extractSearchQueriesFromDiff(diff);
+    const allChunks = [];
+    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);
+      }
+    }
+    const uniqueChunks = Array.from(
+      new Map(allChunks.map((c) => [c.id, c])).values()
+    );
+    spinner.text = "Checking memory for relevant past reviews...";
+    const memoryService = new MemoryService2();
+    const memories = await memoryService.recallRelevantMemories(
+      `PR review ${queries.join(" ")}`,
+      3
+    );
+    spinner.text = `Running multi-agent review (Security + Architecture + Synthesis)...`;
+    const review = await agent.generateMultiAgentReview(
+      diff,
+      uniqueChunks,
+      memories
+    );
+    spinner.succeed(
+      chalk2.green(
+        `Review complete in ${(review.durationMs / 1e3).toFixed(1)}s!
+`
+      )
+    );
+    const parsedReview = await marked.parse(review.markdownReport);
+    const verdictColor = review.verdict === "SAFE_TO_MERGE" ? chalk2.green : review.verdict === "REQUIRES_CHANGES" ? chalk2.red : chalk2.yellow;
+    const borderColor = review.verdict === "SAFE_TO_MERGE" ? "green" : review.verdict === "REQUIRES_CHANGES" ? "red" : "yellow";
+    const formatted = boxen(parsedReview.trim(), {
+      padding: { top: 1, bottom: 1, left: 2, right: 2 },
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "double",
+      borderColor,
+      title: chalk2.bold(` Multi-Agent Code Review `),
+      titleAlignment: "center"
+    });
+    console.log(formatted);
+    console.log(
+      boxen(verdictColor.bold(`  ${review.verdict}  `), {
+        padding: { left: 2, right: 2 },
+        borderStyle: "round",
+        borderColor,
+        textAlignment: "center"
+      })
+    );
+    const { security, architecture } = review.agentOutputs;
+    console.log(
+      chalk2.dim(
+        `
+ Security: ${security.riskLevel} (${security.findings.length} findings)`
+      )
+    );
+    security.findings.forEach((f, i) => {
+      const severityColor = f.severity === "critical" || f.severity === "high" ? chalk2.red : f.severity === "medium" ? chalk2.yellow : chalk2.gray;
+      console.log(severityColor(`    [${f.severity.toUpperCase()}] ${f.title}`));
+    });
+    console.log(
+      chalk2.dim(
+        `
+ Architecture: ${architecture.consistencyScore} (${architecture.findings.length} findings)`
+      )
+    );
+    architecture.findings.forEach((f, i) => {
+      const severityColor = f.severity === "breaking" ? chalk2.red : f.severity === "major" ? chalk2.yellow : chalk2.gray;
+      console.log(severityColor(`    [${f.severity.toUpperCase()}] ${f.title}`));
+    });
+    if (uniqueChunks.length > 0) {
+      console.log(chalk2.cyan.dim("\n Cross-Referenced Architecture:"));
+      uniqueChunks.forEach((res, i) => {
+        const sources = res.sources ? res.sources.join("+") : "vector";
+        console.log(
+          chalk2.gray(
+            `  \u2502 [${i + 1}] ${res.file.replace(process.cwd(), "")} \u2794 ${res.symbolPath || "(anonymous)"} [${sources}]`
+          )
+        );
+      });
+    }
+    if (memories.length > 0) {
+      console.log(chalk2.yellow.dim("\n Past Review Memories Used:"));
+      memories.forEach((mem, i) => {
+        console.log(chalk2.gray(`  \u2502 [${i + 1}] ${mem.slice(0, 120)}...`));
+      });
+    }
+    if (options.pr) {
+      try {
+        await memoryService.storeReviewMemory(options.pr, owner, repo, review);
+      } catch (err) {
+        console.warn(chalk2.yellow("\n\u26A0\uFE0F Failed to store review in memory:"), err);
+      }
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail("Failed to review PR");
+    console.error(err);
+  }
+}
+
+// src/commands/issue.ts
+import { Indexer as Indexer4, IntelligenceAgent as IntelligenceAgent3 } from "@vortex/engine";
+import { createGithubClient as createGithubClient2 } from "@vortex/github";
+import { getGithubRepoInfo } from "@vortex/git";
+async function issueCommand(options) {
+  const { default: ora2 } = await import("ora");
+  const { default: chalk2 } = await import("chalk");
+  const { default: boxen } = await import("boxen");
+  const { marked } = await import("marked");
+  const { default: TerminalRenderer } = await import("marked-terminal");
+  marked.setOptions({
+    renderer: new TerminalRenderer()
+  });
+  console.log(chalk2.blue(`
+Analyzing Issue #${options.id}`));
+  if (!process.env.GITHUB_TOKEN) {
+    console.log(chalk2.yellow("\u26A0\uFE0F No GITHUB_TOKEN found. Using anonymous access (subject to rate limits)."));
+  }
+  const repoInfo = getGithubRepoInfo(process.cwd());
+  const owner = process.env.GITHUB_OWNER || repoInfo?.owner;
+  const repo = process.env.GITHUB_REPO || repoInfo?.repo;
+  if (!owner || !repo) {
+    console.error(chalk2.red("Could not determine GitHub repository. Please run this command inside a git repository or set GITHUB_OWNER and GITHUB_REPO."));
+    return;
+  }
+  const spinner = ora2(`Fetching Issue #${options.id} from ${owner}/${repo}...`).start();
+  try {
+    const github = createGithubClient2(process.env.GITHUB_TOKEN);
+    const issue = await github.fetchIssue(owner, repo, options.id);
+    const comments = await github.fetchIssueComments(owner, repo, options.id);
+    spinner.text = `Issue fetched. Searching local vector database for relevant code...`;
+    const indexer = new Indexer4();
+    const relevantContext = await indexer.search(issue.title, 5);
+    spinner.text = "Analyzing issue and relevant codebase context with Vortex Intelligence...";
+    const agent = new IntelligenceAgent3();
+    const analysis = await agent.generateIssueAnalysis(
+      issue.title,
+      issue.body,
+      comments,
+      relevantContext
+    );
+    spinner.succeed("Issue Analysis complete!\n");
+    const parsedAnalysis = await marked.parse(analysis);
+    const formatted = boxen(parsedAnalysis.trim(), {
+      padding: { top: 1, bottom: 1, left: 2, right: 2 },
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "double",
+      borderColor: "green",
+      title: chalk2.green.bold(" AI Issue Analyzer "),
+      titleAlignment: "center"
+    });
+    console.log(formatted);
+    if (relevantContext.length > 0) {
+      console.log(chalk2.cyan.dim(" Relevant Code Files Discovered"));
+      relevantContext.forEach((res, i) => {
+        console.log(chalk2.gray(`  \u2502 [${i + 1}] ${res.file.replace(process.cwd(), "")} \u2794 ${res.symbolPath || "(anonymous)"} (${res.score ? (res.score * 100).toFixed(1) + "%" : "N/A"})`));
+      });
+    }
+  } catch (err) {
+    spinner.fail("Failed to analyze issue");
+    console.error(err);
+  }
+}
+
+// src/commands/graph.ts
+import { GraphRetriever } from "@vortex/retrieval";
+import { initDatabase, findProjectRoot } from "@vortex/db";
+import * as path from "path";
+async function graphCommand(options) {
+  const { default: chalk2 } = await import("chalk");
+  const { default: boxen } = await import("boxen");
+  console.log(chalk2.blue.bold("\nGenerating Dependency Graph...\n"));
+  try {
+    await initDatabase();
+    const graphRetriever = new GraphRetriever();
+    let fileFilter = options.file;
+    if (!fileFilter) {
+      const projectRoot = findProjectRoot(process.cwd());
+      const relPath = path.relative(projectRoot, process.cwd());
+      if (relPath && relPath !== ".") {
+        fileFilter = relPath;
+        console.log(chalk2.dim(`Directory filter auto-applied: ${fileFilter}`));
+      }
+    }
+    const asciiTree = await graphRetriever.generateAsciiTree(fileFilter);
+    const mermaidCode = await graphRetriever.generateMermaidGraph(fileFilter, options.detailed);
+    console.log(
+      boxen(asciiTree.trim(), {
+        padding: { top: 1, bottom: 1, left: 2, right: 2 },
+        margin: { top: 1, bottom: 1 },
+        borderStyle: "round",
+        borderColor: "cyan",
+        title: chalk2.bold(` Dependency Graph `),
+        titleAlignment: "center"
+      })
+    );
+    if (options.file) {
+      console.log(chalk2.green(`\u2705 Graph generated successfully for file: ${options.file}`));
+    } else {
+      console.log(chalk2.green("\u2705 Project dependency graph generated successfully."));
+    }
+    const mermaidConfig = {
+      theme: "dark",
+      maxTextSize: 9e5
+    };
+    const state = { code: mermaidCode, mermaid: JSON.stringify(mermaidConfig, null, 2), autoSync: true, updateDiagram: true };
+    const base64 = Buffer.from(JSON.stringify(state)).toString("base64");
+    const liveUrl = `https://mermaid.live/edit#base64:${base64}`;
+    console.log(chalk2.dim(`
+Want a visual flowchart? Open this URL:
+${liveUrl}`));
+  } catch (err) {
+    console.error(chalk2.red("Failed to generate graph:"), err);
+  }
+}
+
+// src/commands/suggest.ts
+import { IntelligenceAgent as IntelligenceAgent4 } from "@vortex/engine";
+import * as fs from "fs";
+async function suggestCommand(options) {
+  const { default: ora2 } = await import("ora");
+  const { default: chalk2 } = await import("chalk");
+  const { default: boxen } = await import("boxen");
+  const { marked } = await import("marked");
+  const { default: TerminalRenderer } = await import("marked-terminal");
+  marked.setOptions({
+    renderer: new TerminalRenderer()
+  });
+  console.log(
+    chalk2.blue.bold(`
+Generating Suggestions for: ${options.file}
+`)
+  );
+  if (!fs.existsSync(options.file)) {
+    console.error(chalk2.red(`File not found: ${options.file}`));
+    return;
+  }
+  const spinner = ora2("Analyzing file...").start();
+  try {
+    const content = fs.readFileSync(options.file, "utf8");
+    const agent = new IntelligenceAgent4();
+    const suggestions = await agent.generateSuggestions(content);
+    spinner.succeed(chalk2.green("Analysis complete!\n"));
+    const parsedSuggestions = await marked.parse(suggestions);
+    const formatted = boxen(parsedSuggestions.trim(), {
+      padding: { top: 1, bottom: 1, left: 2, right: 2 },
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "double",
+      borderColor: "cyan",
+      title: chalk2.cyan.bold(" AI Code Suggestions "),
+      titleAlignment: "center"
+    });
+    console.log(formatted);
+  } catch (err) {
+    spinner.fail(chalk2.red("Failed to generate suggestions"));
+    console.error(err);
+  }
+}
+
+// src/commands/fix-nitbits.ts
+import { IntelligenceAgent as IntelligenceAgent5 } from "@vortex/engine";
+import * as fs2 from "fs";
+async function fixNitbitsCommand(options) {
+  const { default: ora2 } = await import("ora");
+  const { default: chalk2 } = await import("chalk");
+  console.log(chalk2.blue.bold("\nFixing Repository Nitbits\n"));
+  if (!options.files) {
+    console.error(
+      chalk2.red("Please provide --files to fix (comma-separated list).")
+    );
+    return;
+  }
+  const files = options.files.split(",").map((file) => file.trim());
+  const agent = new IntelligenceAgent5();
+  let fixedCount = 0;
+  let failedCount = 0;
+  for (const file of files) {
+    if (!fs2.existsSync(file)) {
+      console.warn(chalk2.yellow(`\u26A0\uFE0F  File not found: ${file}`));
+      failedCount++;
+      continue;
+    }
+    const spinner = ora2(`Auto-fixing ${file}...`).start();
+    try {
+      const content = fs2.readFileSync(file, "utf8");
+      const fixedContent = await agent.autoFix(content);
+      if (options.dryRun) {
+        spinner.succeed(chalk2.cyan(`[DRY RUN] ${file}`));
+        console.log(chalk2.gray(`
+--- FIXED OUTPUT ---
+`));
+        console.log(fixedContent);
+        console.log(chalk2.gray(`
+--- END ---
+`));
+      } else {
+        fs2.writeFileSync(file, fixedContent, "utf8");
+        spinner.succeed(chalk2.green(`Fixed and saved ${file}`));
+      }
+      fixedCount++;
+    } catch (err) {
+      spinner.fail(chalk2.red(`Failed to fix ${file}`));
+      console.error(err);
+      failedCount++;
+    }
+  }
+  console.log(
+    chalk2.dim(
+      `
+  Summary: ${fixedCount} fixed, ${failedCount} failed out of ${files.length} files
+`
+    )
+  );
+}
+
+// src/commands/analyze.ts
+import { IntelligenceAgent as IntelligenceAgent6 } from "@vortex/engine";
+import { createGithubClient as createGithubClient3 } from "@vortex/github";
+import { getGithubRepoInfo as getGithubRepoInfo2 } from "@vortex/git";
+async function analyzeCommand(options) {
+  const { default: ora2 } = await import("ora");
+  const { default: chalk2 } = await import("chalk");
+  const { default: boxen } = await import("boxen");
+  const { marked } = await import("marked");
+  const { default: TerminalRenderer } = await import("marked-terminal");
+  marked.setOptions({
+    renderer: new TerminalRenderer()
+  });
+  console.log(
+    chalk2.blue.bold(`
+Analyzing External PR #${options.pr}
+`)
+  );
+  if (!process.env.GITHUB_TOKEN) {
+    console.error(
+      chalk2.red("Please set GITHUB_TOKEN environment variable.")
+    );
+    return;
+  }
+  const repoInfo = getGithubRepoInfo2(process.cwd());
+  const owner = process.env.GITHUB_OWNER || repoInfo?.owner;
+  const repo = process.env.GITHUB_REPO || repoInfo?.repo;
+  if (!owner || !repo) {
+    console.error(
+      chalk2.red(
+        "Could not determine GitHub repository. Please run this command inside a git repository or set GITHUB_OWNER and GITHUB_REPO."
+      )
+    );
+    return;
+  }
+  const spinner = ora2(
+    `Fetching diff for ${owner}/${repo}#${options.pr}...`
+  ).start();
+  try {
+    const github = createGithubClient3(process.env.GITHUB_TOKEN);
+    const diff = await github.fetchPullRequestDiff(owner, repo, options.pr);
+    spinner.text = "Generating AI analysis...";
+    const agent = new IntelligenceAgent6();
+    const review = await agent.generateReview(diff);
+    spinner.succeed(chalk2.green("Analysis complete!\n"));
+    const parsedReview = await marked.parse(review);
+    const formatted = boxen(parsedReview.trim(), {
+      padding: { top: 1, bottom: 1, left: 2, right: 2 },
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "double",
+      borderColor: "magenta",
+      title: chalk2.magenta.bold(" External PR Analysis "),
+      titleAlignment: "center"
+    });
+    console.log(formatted);
+  } catch (err) {
+    spinner.fail(chalk2.red("Failed to analyze PR"));
+    console.error(err);
+  }
+}
+
+// src/commands/watch.ts
+import { IntelligenceAgent as IntelligenceAgent7 } from "@vortex/engine";
+import * as fs3 from "fs";
+import * as chokidar from "chokidar";
+async function watchCommand(options) {
+  const { default: chalk2 } = await import("chalk");
+  console.log(
+    chalk2.blue.bold("\nVortex Live Watcher\n")
+  );
+  console.log(
+    chalk2.gray("  Watching repository changes for live AI feedback...")
+  );
+  if (options.deep) {
+    console.log(
+      chalk2.yellow(
+        "  \u26A0\uFE0F  Deep live analysis enabled (may consume more API tokens).\n"
+      )
+    );
+  }
+  const watcher = chokidar.watch(process.cwd(), {
+    ignored: /(^|[\/\\])\\..|node_modules|dist/,
+    persistent: true
+  });
+  const agent = new IntelligenceAgent7();
+  let isProcessing = false;
+  watcher.on("change", async (filePath) => {
+    if (isProcessing) return;
+    console.log(
+      chalk2.cyan(`
+Detected change in ${filePath}. Analyzing...`)
+    );
+    isProcessing = true;
+    try {
+      const content = fs3.readFileSync(filePath, "utf8");
+      const feedback = await agent.generateSuggestions(content);
+      console.log(
+        chalk2.green(`
+--- LIVE AI FEEDBACK FOR ${filePath} ---
+`)
+      );
+      console.log(feedback);
+    } catch (err) {
+      console.error(chalk2.red("Analysis failed:"), err);
+    } finally {
+      isProcessing = false;
+      console.log(chalk2.gray("\n  Watching for more changes..."));
+    }
+  });
+  console.log(chalk2.green("  Watcher started. Press Ctrl+C to exit.\n"));
+}
+
+// src/commands/solve.ts
+import ora from "ora";
+import * as readline from "readline/promises";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import * as fs4 from "fs";
+import * as path2 from "path";
+import {
+  AutonomousAgent,
+  FileReadTool as FileReadTool3,
+  FileWriteTool,
+  ShellExecuteTool,
+  GrepTool as GrepTool3,
+  RagSearchTool
+} from "@vortex/engine";
+import { initDatabase as initDatabase2 } from "@vortex/db";
+import { getGitRoot, isGitRepo } from "@vortex/git";
+import { VectorStore, LocalEmbedder, BM25Index, HybridRetriever } from "@vortex/retrieval";
+async function solveCommand(prompt, options = {}) {
+  let cwd = process.cwd();
+  if (options.newProject) {
+    const projectPath = path2.resolve(cwd, options.newProject);
+    if (!fs4.existsSync(projectPath)) {
+      fs4.mkdirSync(projectPath, { recursive: true });
+      console.log(chalk.green(`
+Created new project folder: ${projectPath}`));
+    }
+    cwd = projectPath;
+    process.chdir(cwd);
+    if (!fs4.existsSync(path2.join(cwd, ".git"))) {
+      try {
+        execSync("git init", { cwd, stdio: "ignore" });
+        console.log(chalk.green(`Initialized empty Git repository in ${cwd}`));
+      } catch (e) {
+        console.error(chalk.red("Failed to initialize git repository."));
+      }
+    }
+  }
+  let rootPath = cwd;
+  if (isGitRepo(cwd)) {
+    rootPath = getGitRoot(cwd);
+  }
+  console.log(`
+Vortex Autonomous Agent activated`);
+  console.log(`Task: "${prompt}"
+`);
+  await initDatabase2();
+  const spinner = ora("Initializing Vector Store for Project Memory...").start();
+  try {
+    const vectorStore = new VectorStore();
+    const bm25Index = new BM25Index();
+    const embedder = new LocalEmbedder();
+    const hybridRetriever = new HybridRetriever(vectorStore, bm25Index, embedder);
+    const agent = new AutonomousAgent();
+    if (options.maxSteps !== void 0) {
+      agent.maxToolIterations = options.maxSteps;
+    }
+    spinner.text = "Thinking...";
+    const approvalCallback = async (action, description) => {
+      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") {
+        question = `
+${chalk.yellow("\u26A0\uFE0F Agent wants to execute command:")}
+> ${description}
+Allow? (y/N) `;
+      } else if (action === "write_file") {
+        question = `
+${chalk.yellow("\u26A0\uFE0F Agent wants to overwrite file:")} ${description}
+Allow? (y/N) `;
+      } else {
+        question = `
+${chalk.yellow("\u26A0\uFE0F Agent wants to perform action:")} ${action} on ${description}
+Allow? (y/N) `;
+      }
+      const answer = await rl.question(question);
+      rl.close();
+      spinner.start(currentText);
+      return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+    };
+    agent.registerTools([
+      new FileReadTool3(rootPath),
+      new FileWriteTool(rootPath, vectorStore, embedder, approvalCallback),
+      new ShellExecuteTool(rootPath, approvalCallback),
+      new GrepTool3(rootPath),
+      new RagSearchTool(hybridRetriever)
+    ]);
+    const result = await agent.run(
+      {
+        diff: prompt,
+        contextChunks: options.contextChunks || []
+      },
+      {
+        onToolCall: (toolName, args) => {
+          if (toolName === "write_file") {
+            spinner.text = `Writing file: ${args.path}...`;
+          } else if (toolName === "shell_execute") {
+            spinner.text = `Executing shell command...`;
+          } else if (toolName === "rag_search") {
+            spinner.text = `Searching project memory for context...`;
+          } else {
+            spinner.text = `Agent is using tool: ${toolName}...`;
+          }
+        },
+        onToolResult: (toolName, toolResult) => {
+          if (toolName === "write_file" && toolResult.startsWith("Success")) {
+            spinner.stop();
+            try {
+              const match = toolResult.match(/Wrote to (.*) successfully/);
+              if (match && match[1]) {
+                const filePath = match[1];
+                console.log(`
+${chalk.green("\u2713 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));
+                }
+              }
+            } catch (e) {
+            }
+            spinner.start("Thinking...");
+          }
+        }
+      }
+    );
+    spinner.succeed("Task completed");
+    try {
+      const statOut = execSync(`git diff --stat`, { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] });
+      if (statOut.trim()) {
+        console.log(`
+${chalk.cyan("=== Changed Files Summary ===")}`);
+        console.log(statOut);
+      }
+    } catch (e) {
+    }
+    console.log(`
+${chalk.cyan("=== Final Output ===")}
+`);
+    console.log(result.summary);
+    const packageJsonPath = path2.join(cwd, "package.json");
+    if (fs4.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+        if (pkg.scripts && pkg.scripts.build) {
+          console.log(`
+${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) {
+            buildSpinner.fail("Build failed.");
+            console.error(chalk.red(e.stdout ? e.stdout.toString() : e.message));
+          }
+        }
+      } catch (e) {
+      }
+    }
+  } catch (err) {
+    spinner.fail("Agent encountered an error");
+    console.error(err.message);
+  }
+}
+
+// src/commands/solve-issue.ts
+import { Indexer as Indexer5 } from "@vortex/engine";
+import { createGithubClient as createGithubClient4 } from "@vortex/github";
+import { getGithubRepoInfo as getGithubRepoInfo3 } from "@vortex/git";
+async function solveIssueCommand(options) {
+  const { default: ora2 } = await import("ora");
+  const { default: chalk2 } = await import("chalk");
+  console.log(chalk2.blue(`
+Autonomous Agent solving Issue #${options.id}`));
+  if (!process.env.GITHUB_TOKEN) {
+    console.log(chalk2.yellow("\u26A0\uFE0F No GITHUB_TOKEN found. Using anonymous access (subject to rate limits)."));
+  }
+  const repoInfo = getGithubRepoInfo3(process.cwd());
+  const owner = process.env.GITHUB_OWNER || repoInfo?.owner;
+  const repo = process.env.GITHUB_REPO || repoInfo?.repo;
+  if (!owner || !repo) {
+    console.error(chalk2.red("Could not determine GitHub repository. Please run this command inside a git repository or set GITHUB_OWNER and GITHUB_REPO."));
+    return;
+  }
+  const spinner = ora2(`Fetching Issue #${options.id} from ${owner}/${repo}...`).start();
+  try {
+    const github = createGithubClient4(process.env.GITHUB_TOKEN);
+    const issue = await github.fetchIssue(owner, repo, options.id);
+    const comments = await github.fetchIssueComments(owner, repo, options.id);
+    spinner.text = `Issue fetched. Searching local vector database for relevant code...`;
+    const indexer = new Indexer5();
+    const relevantContext = await indexer.hybridSearch(issue.title, 5);
+    spinner.succeed("Issue and Context fetched successfully!\n");
+    const prompt = `Solve the following GitHub issue:
+# ${issue.title}
+
+${issue.body || "No description provided."}
+
+## Discussion Comments
+${comments.map((c, i) => `Comment ${i + 1} (@${c.user?.login}): ${c.body}`).join("\n")}
+
+Please fix this issue in the codebase.`;
+    const contextChunks = relevantContext.map((c) => ({
+      file: c.file,
+      symbolPath: c.symbolPath || "anonymous",
+      content: c.content,
+      kind: c.kind || "unknown"
+    }));
+    await solveCommand(prompt, {
+      autoApprove: options.autoApprove,
+      maxSteps: options.maxSteps,
+      contextChunks
+    });
+  } catch (err) {
+    spinner.fail("Failed to setup solve-issue");
+    console.error(err);
+  }
+}
+
+// src/commands/cache.ts
+import { Command } from "commander";
+import { LLMCacheManager } from "@vortex/engine";
+var cacheCommand = new Command("cache").description("Manage the LLM response cache");
+cacheCommand.command("stats").description("View LLM cache statistics").action(async () => {
+  try {
+    const stats = await LLMCacheManager.getStats();
+    console.log("\nLLM Cache Statistics\n");
+    console.log(`Entries:    ${stats.entries.toLocaleString()}`);
+    console.log(`Hits:       ${stats.hits.toLocaleString()}`);
+    const storageMB = (stats.storage / 1024 / 1024).toFixed(2);
+    console.log(`Storage:    ${storageMB} MB
+`);
+  } catch (err) {
+    console.error("Failed to retrieve cache stats:", err);
+  }
+});
+cacheCommand.command("clear").description("Clear all entries from the LLM cache").action(async () => {
+  try {
+    await LLMCacheManager.clearCache();
+    console.log("\u2705 LLM Cache cleared successfully.");
+  } catch (err) {
+    console.error("Failed to clear LLM cache:", err);
+  }
+});
+
+// src/index.ts
+var monorepoEnv = path3.resolve(__dirname, "../../../.env");
+if (__require("fs").existsSync(monorepoEnv)) {
+  const envConfig = dotenv.parse(__require("fs").readFileSync(monorepoEnv));
+  for (const k in envConfig) {
+    if (k === "NODE_ENV") continue;
+    if (!process.env[k]) process.env[k] = envConfig[k];
+  }
+}
+dotenv.config({ path: path3.resolve(os.homedir(), ".vortexenv"), override: true });
+var cwdEnv = path3.resolve(process.cwd(), ".env");
+if (__require("fs").existsSync(cwdEnv)) {
+  const envConfig = dotenv.parse(__require("fs").readFileSync(cwdEnv));
+  for (const k in envConfig) {
+    if (k === "NODE_ENV") continue;
+    process.env[k] = envConfig[k];
+  }
+}
+var program = new Command2();
+program.name("vortex").description("Developer Intelligence & PR Review Engine").version("0.1.0");
+program.hook("preAction", (thisCommand, actionCommand) => {
+  if (actionCommand.opts().cache === false) {
+    process.env.VORTEX_DISABLE_CACHE = "true";
+  }
+});
+program.command("init").description("Initialize repository intelligence, embeddings, and PR history").option("--reindex", "Rebuild repository embeddings while preserving historical PR intelligence").action(initCommand);
+program.command("search").description("Search the indexed codebase semantically and get an AI explanation").requiredOption("-q, --query <text>", "Search query").option("-l, --limit <number>", "Number of results to consider", "5").option("--no-cache", "Disable LLM response caching").action(searchCommand);
+program.command("review").description("Review your changes using repository intelligence and historical PR patterns").option("--pr <number>", "Pull request number", Number).option("--deep", "Enable deep review analysis").option("--no-cache", "Disable LLM response caching").action(reviewCommand);
+program.command("issue").description("Analyze a GitHub issue, locate relevant codebase files, and propose a fix").requiredOption("--id <number>", "Issue number", Number).option("--no-cache", "Disable LLM response caching").action(issueCommand);
+program.command("graph").description("Generate a Mermaid JS dependency graph of the project or a specific file").option("--file <path>", "Filter graph to only include dependencies for a specific file").option("--detailed", "Include individual functions and classes in the graph instead of just files").action(graphCommand);
+program.command("solve").description("Autonomously solve a task by writing code and executing commands").argument("<prompt>", "The task you want the autonomous agent to solve").option("--auto-approve", "Skip interactive prompts for file writes and shell commands").option("--max-steps <number>", "Maximum number of agent loop iterations", Number, 30).option("--new-project <folder>", "Create a new project folder and initialize git before solving").action((prompt, options) => solveCommand(prompt, options));
+program.command("solve-issue").description("Autonomously solve a GitHub issue using local RAG context").requiredOption("--id <number>", "Issue number", Number).option("--auto-approve", "Skip interactive prompts for file writes and shell commands").option("--max-steps <number>", "Maximum number of agent loop iterations", Number, 30).action(solveIssueCommand);
+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);
+program.command("watch").description("Continuously monitor local changes and provide live review feedback").option("--deep", "Enable deep live analysis").action(watchCommand);
+program.addCommand(cacheCommand);
+program.parse();