@vortex-ai/cli 0.1.2

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vortex-ai/cli",
+  "version": "0.1.2",
+  "description": "Vortex CLI - The main entry point",
+  "main": "./dist/index.js",
+  "bin": {
+    "vortex": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --external @xenova/transformers",
+    "dev": "tsx src/index.ts",
+    "watch": "tsup src/index.ts --format cjs,esm --watch",
+    "lint": "eslint .",
+    "check-types": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@octokit/rest": "^22.0.1",
+    "@types/marked-terminal": "^6.1.1",
+    "@vortex/engine": "workspace:*",
+    "@vortex/github": "workspace:*",
+    "@vortex/git": "workspace:*",
+    "@vortex/shared": "workspace:*",
+    "@vortex/retrieval": "workspace:*",
+    "@vortex/db": "workspace:*",
+    "@xenova/transformers": "^2.17.2",
+    "boxen": "7",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "commander": "^12.1.0",
+    "dotenv": "^17.4.2",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "ora": "^9.4.0",
+    "parse-diff": "^0.12.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@vortex/typescript-config": "workspace:*",
+    "tsup": "^8.0.2",
+    "tsx": "^4.21.0",
+    "typescript": "5.9.2"
+  }
+}

package/src/commands/analyze.ts

@@ -0,0 +1,74 @@
+import { IntelligenceAgent } from "@vortex/engine";
+import { createGithubClient } from "@vortex/github";
+import { getGithubRepoInfo } from "@vortex/git";
+
+export async function analyzeCommand(options: {
+  pr: number;
+  deep?: boolean;
+}) {
+  const { default: ora } = await import("ora");
+  const { default: chalk } = 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() as any,
+  });
+
+  console.log(
+    chalk.blue.bold(`\nAnalyzing External PR #${options.pr}\n`)
+  );
+
+  if (!process.env.GITHUB_TOKEN) {
+    console.error(
+      chalk.red("Please set GITHUB_TOKEN environment variable.")
+    );
+    return;
+  }
+
+  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(
+      chalk.red(
+        "Could not determine GitHub repository. Please run this command inside a git repository or set GITHUB_OWNER and GITHUB_REPO."
+      )
+    );
+    return;
+  }
+
+  const spinner = ora(
+    `Fetching diff for ${owner}/${repo}#${options.pr}...`
+  ).start();
+
+  try {
+    const github = createGithubClient(process.env.GITHUB_TOKEN);
+    const diff = await github.fetchPullRequestDiff(owner, repo, options.pr);
+
+    spinner.text = "Generating AI analysis...";
+
+    const agent = new IntelligenceAgent();
+    const review = await agent.generateReview(diff);
+
+    spinner.succeed(chalk.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: chalk.magenta.bold(" External PR Analysis "),
+      titleAlignment: "center",
+    });
+
+    console.log(formatted);
+  } catch (err) {
+    spinner.fail(chalk.red("Failed to analyze PR"));
+    console.error(err);
+  }
+}

package/src/commands/cache.ts

@@ -0,0 +1,33 @@
+import { Command } from "commander";
+import { LLMCacheManager } from "@vortex/engine";
+
+export const 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\n`);
+    } 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("✅ LLM Cache cleared successfully.");
+    } catch (err) {
+      console.error("Failed to clear LLM cache:", err);
+    }
+  });

package/src/commands/fix-nitbits.ts

@@ -0,0 +1,63 @@
+import { IntelligenceAgent } from "@vortex/engine";
+import * as fs from "fs";
+
+export async function fixNitbitsCommand(options: {
+  safe?: boolean;
+  dryRun?: boolean;
+  files?: string;
+}) {
+  const { default: ora } = await import("ora");
+  const { default: chalk } = await import("chalk");
+
+  console.log(chalk.blue.bold("\nFixing Repository Nitbits\n"));
+
+  if (!options.files) {
+    console.error(
+      chalk.red("Please provide --files to fix (comma-separated list).")
+    );
+    return;
+  }
+
+  const files = options.files.split(",").map((file: string) => file.trim());
+  const agent = new IntelligenceAgent();
+
+  let fixedCount = 0;
+  let failedCount = 0;
+
+  for (const file of files) {
+    if (!fs.existsSync(file)) {
+      console.warn(chalk.yellow(`⚠️  File not found: ${file}`));
+      failedCount++;
+      continue;
+    }
+
+    const spinner = ora(`Auto-fixing ${file}...`).start();
+
+    try {
+      const content = fs.readFileSync(file, "utf8");
+      const fixedContent = await agent.autoFix(content);
+
+      if (options.dryRun) {
+        spinner.succeed(chalk.cyan(`[DRY RUN] ${file}`));
+        console.log(chalk.gray(`\n--- FIXED OUTPUT ---\n`));
+        console.log(fixedContent);
+        console.log(chalk.gray(`\n--- END ---\n`));
+      } else {
+        fs.writeFileSync(file, fixedContent, "utf8");
+        spinner.succeed(chalk.green(`Fixed and saved ${file}`));
+      }
+
+      fixedCount++;
+    } catch (err) {
+      spinner.fail(chalk.red(`Failed to fix ${file}`));
+      console.error(err);
+      failedCount++;
+    }
+  }
+
+  console.log(
+    chalk.dim(
+      `\n  Summary: ${fixedCount} fixed, ${failedCount} failed out of ${files.length} files\n`
+    )
+  );
+}

package/src/commands/graph.ts

@@ -0,0 +1,59 @@
+import { GraphRetriever } from "@vortex/retrieval";
+import { initDatabase, findProjectRoot } from "@vortex/db";
+import * as path from "path";
+
+export async function graphCommand(options: { file?: string; detailed?: boolean }) {
+  const { default: chalk } = await import("chalk");
+  const { default: boxen } = await import("boxen");
+  
+  console.log(chalk.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(chalk.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: chalk.bold(` Dependency Graph `),
+        titleAlignment: "center",
+      })
+    );
+
+    if (options.file) {
+      console.log(chalk.green(`✅ Graph generated successfully for file: ${options.file}`));
+    } else {
+      console.log(chalk.green("✅ Project dependency graph generated successfully."));
+    }
+    
+
+    const mermaidConfig = {
+      theme: "dark",
+      maxTextSize: 900000
+    };
+    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(chalk.dim(`\nWant a visual flowchart? Open this URL:\n${liveUrl}`));
+  } catch (err) {
+    console.error(chalk.red("Failed to generate graph:"), err);
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,37 @@
+import { Indexer } from "@vortex/engine";
+
+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"));
+  }
+
+  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`));
+
+    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/issue.ts

@@ -0,0 +1,79 @@
+import { Indexer, IntelligenceAgent } from "@vortex/engine";
+import { createGithubClient } from "@vortex/github";
+import { getGithubRepoInfo } from "@vortex/git";
+
+export async function issueCommand(options: any) {
+  const { default: ora } = await import("ora");
+  const { default: chalk } = 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() as any
+  });
+
+  console.log(chalk.blue(`\nAnalyzing Issue #${options.id}`));
+
+  if (!process.env.GITHUB_TOKEN) {
+    console.log(chalk.yellow("⚠️ 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(chalk.red("Could not determine GitHub repository. Please run this command inside a git repository or set GITHUB_OWNER and GITHUB_REPO."));
+    return;
+  }
+
+  const spinner = ora(`Fetching Issue #${options.id} from ${owner}/${repo}...`).start();
+
+  try {
+    const github = createGithubClient(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 Indexer();
+    const relevantContext = await indexer.search(issue.title, 5);
+
+    spinner.text = "Analyzing issue and relevant codebase context with Vortex Intelligence...";
+    const agent = new IntelligenceAgent();
+    
+    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: chalk.green.bold(' AI Issue Analyzer '),
+      titleAlignment: 'center'
+    });
+
+    console.log(formatted);
+    
+    if (relevantContext.length > 0) {
+      console.log(chalk.cyan.dim(" Relevant Code Files Discovered"));
+      relevantContext.forEach((res: any, i: number) => {
+         console.log(chalk.gray(`  │ [${i + 1}] ${res.file.replace(process.cwd(), '')} ➔ ${res.symbolPath || '(anonymous)'} (${res.score ? (res.score * 100).toFixed(1) + '%' : 'N/A'})`));
+      });
+    }
+
+  } catch (err) {
+    spinner.fail("Failed to analyze issue");
+    console.error(err);
+  }
+}

package/src/commands/review.ts

@@ -0,0 +1,218 @@
+import {
+  IntelligenceAgent,
+  Indexer,
+  MemoryService,
+  ToolRegistry,
+  GrepTool,
+  FileReadTool,
+} from "@vortex/engine";
+import { createGithubClient } from "@vortex/github";
+
+export async function reviewCommand(options: any) {
+  const { default: ora } = await import("ora");
+  const { default: chalk } = 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() 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`));
+  }
+
+  if (!process.env.GITHUB_TOKEN) {
+    console.log(
+      chalk.yellow(
+        "⚠️ 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(
+      chalk.red(
+        "Could not determine GitHub repository. Please run this command inside a git repository or set GITHUB_OWNER and GITHUB_REPO."
+      )
+    );
+    return;
+  }
+
+  const spinner = ora(
+    options.pr ? `Fetching diff for ${owner}/${repo}#${options.pr}...` : `Fetching local git diff...`
+  ).start();
+
+  try {
+
+    let diff: string;
+    if (options.pr) {
+      const github = createGithubClient(process.env.GITHUB_TOKEN);
+      diff = await github.fetchPullRequestDiff(owner, repo, options.pr);
+    } else {
+      const { execSync } = await import("child_process");
+      diff = execSync("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 IntelligenceAgent();
+    const indexer = new Indexer();
+
+    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);
+      }
+    }
+
+
+    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(
+      `PR review ${queries.join(" ")}`,
+      3
+    );
+
+
+    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`
+      )
+    );
+
+
+    const parsedReview = await marked.parse(review.markdownReport);
+
+    const verdictColor =
+      review.verdict === "SAFE_TO_MERGE"
+        ? chalk.green
+        : review.verdict === "REQUIRES_CHANGES"
+          ? chalk.red
+          : chalk.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: borderColor as any,
+      title: chalk.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: borderColor as any,
+        textAlignment: "center",
+      })
+    );
+
+
+    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}`));
+    });
+
+    if (uniqueChunks.length > 0) {
+      console.log(chalk.cyan.dim("\n Cross-Referenced Architecture:"));
+      uniqueChunks.forEach((res: any, i: number) => {
+        const sources = res.sources ? res.sources.join("+") : "vector";
+        console.log(
+          chalk.gray(
+            `  │ [${i + 1}] ${res.file.replace(process.cwd(), "")} ➔ ${res.symbolPath || "(anonymous)"} [${sources}]`
+          )
+        );
+      });
+    }
+
+    if (memories.length > 0) {
+      console.log(chalk.yellow.dim("\n Past Review Memories Used:"));
+      memories.forEach((mem: string, i: number) => {
+        console.log(chalk.gray(`  │ [${i + 1}] ${mem.slice(0, 120)}...`));
+      });
+    }
+
+
+    if (options.pr) {
+      try {
+        await memoryService.storeReviewMemory(options.pr, owner, repo, review);
+      } catch (err) {
+        console.warn(chalk.yellow("\n⚠️ Failed to store review in memory:"), err);
+      }
+    }
+
+    console.log("");
+  } catch (err) {
+    spinner.fail("Failed to review PR");
+    console.error(err);
+  }
+}

package/src/commands/search.ts

@@ -0,0 +1,67 @@
+import { Indexer, IntelligenceAgent, MemoryService, ToolRegistry, GrepTool, FileReadTool } from "@vortex/engine";
+
+export async function searchCommand(options: any) {
+  const { default: ora } = await import("ora");
+  const { default: chalk } = 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() as any
+  });
+
+  const spinner = ora(`Searching codebase for: "${options.query}"...`).start();
+  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));
+    
+    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: chalk.cyan.bold(' Vortex AI Engine (Hybrid Search) '),
+      titleAlignment: 'center'
+    });
+    
+    console.log(formatted);
+    
+    console.log(chalk.cyan.dim(" Reference Material (Hybrid Retrieval)"));
+    results.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}]`));
+    });
+
+    if (memories.length > 0) {
+      console.log(chalk.yellow.dim("\n Relevant Memories"));
+      memories.forEach((mem: string, i: number) => {
+        console.log(chalk.gray(`  │ [${i + 1}] ${mem.slice(0, 120)}...`));
+      });
+    }
+    
+  } catch (err) {
+    spinner.fail("Search failed");
+    console.error(err);
+  }
+}