@vortex-ai/cli 0.1.2

package/src/commands/solve-issue.ts

@@ -0,0 +1,69 @@
+import { Indexer } from "@vortex/engine";
+import { createGithubClient } from "@vortex/github";
+import { getGithubRepoInfo } from "@vortex/git";
+import { solveCommand } from "./solve";
+
+export async function solveIssueCommand(options: any) {
+  const { default: ora } = await import("ora");
+  const { default: chalk } = await import("chalk");
+
+  console.log(chalk.blue(`\nAutonomous Agent solving 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.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: any, i: number) => `Comment ${i + 1} (@${c.user?.login}): ${c.body}`).join('\n')}
+
+Please fix this issue in the codebase.`;
+
+
+    const contextChunks = relevantContext.map((c: any) => ({
+      file: c.file,
+      symbolPath: c.symbolPath || "anonymous",
+      content: c.content,
+      kind: c.kind || "unknown",
+    }));
+
+
+    await solveCommand(prompt, {
+      autoApprove: options.autoApprove,
+      maxSteps: options.maxSteps,
+      contextChunks: contextChunks
+    });
+
+  } catch (err) {
+    spinner.fail("Failed to setup solve-issue");
+    console.error(err);
+  }
+}

package/src/commands/solve.ts

@@ -0,0 +1,177 @@
+import ora from "ora";
+import * as readline from "node:readline/promises";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import * as fs from "fs";
+import * as path from "path";
+import {
+  AutonomousAgent,
+  FileReadTool,
+  FileWriteTool,
+  ShellExecuteTool,
+  GrepTool,
+  RagSearchTool,
+  ApprovalCallback,
+  AgentContextChunk
+} 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 } = {}) {
+  let cwd = process.cwd();
+
+  if (options.newProject) {
+    const projectPath = path.resolve(cwd, options.newProject);
+    if (!fs.existsSync(projectPath)) {
+      fs.mkdirSync(projectPath, { recursive: true });
+      console.log(chalk.green(`\nCreated new project folder: ${projectPath}`));
+    }
+    cwd = projectPath;
+    process.chdir(cwd);
+    
+    if (!fs.existsSync(path.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(`\nVortex Autonomous Agent activated`);
+  console.log(`Task: "${prompt}"\n`);
+
+  await initDatabase();
+
+  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 !== undefined) {
+      (agent as any).maxToolIterations = options.maxSteps;
+    }
+
+    spinner.text = "Thinking...";
+
+    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") {
+        question = `\n${chalk.yellow('⚠️ Agent wants to execute command:')}\n> ${description}\nAllow? (y/N) `;
+      } else if (action === "write_file") {
+        question = `\n${chalk.yellow('⚠️ Agent wants to overwrite file:')} ${description}\nAllow? (y/N) `;
+      } 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";
+    };
+
+
+    agent.registerTools([
+      new FileReadTool(rootPath),
+      new FileWriteTool(rootPath, vectorStore, embedder, approvalCallback),
+      new ShellExecuteTool(rootPath, approvalCallback),
+      new GrepTool(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(`\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));
+                 }
+              }
+            } 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(`\n${chalk.cyan('=== Changed Files Summary ===')}`);
+        console.log(statOut);
+      }
+    } catch (e) {}
+
+    console.log(`\n${chalk.cyan('=== Final Output ===')}\n`);
+    console.log(result.summary);
+
+
+    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 (err: any) {
+    spinner.fail("Agent encountered an error");
+    console.error(err.message);
+  }
+}

package/src/commands/suggest.ts

@@ -0,0 +1,54 @@
+import { IntelligenceAgent } from "@vortex/engine";
+import * as fs from "fs";
+
+export async function suggestCommand(options: {
+  file: string;
+  apply?: boolean;
+  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(`\nGenerating Suggestions for: ${options.file}\n`)
+  );
+
+  if (!fs.existsSync(options.file)) {
+    console.error(chalk.red(`File not found: ${options.file}`));
+    return;
+  }
+
+  const spinner = ora("Analyzing file...").start();
+
+  try {
+    const content = fs.readFileSync(options.file, "utf8");
+    const agent = new IntelligenceAgent();
+
+    const suggestions = await agent.generateSuggestions(content);
+
+    spinner.succeed(chalk.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: chalk.cyan.bold(" AI Code Suggestions "),
+      titleAlignment: "center",
+    });
+
+    console.log(formatted);
+  } catch (err) {
+    spinner.fail(chalk.red("Failed to generate suggestions"));
+    console.error(err);
+  }
+}

package/src/commands/watch.ts

@@ -0,0 +1,56 @@
+import { IntelligenceAgent } from "@vortex/engine";
+import * as fs from "fs";
+import * as chokidar from "chokidar";
+
+export async function watchCommand(options: { deep?: boolean }) {
+  const { default: chalk } = await import("chalk");
+
+  console.log(
+    chalk.blue.bold("\nVortex Live Watcher\n")
+  );
+  console.log(
+    chalk.gray("  Watching repository changes for live AI feedback...")
+  );
+
+  if (options.deep) {
+    console.log(
+      chalk.yellow(
+        "  ⚠️  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 IntelligenceAgent();
+  let isProcessing = false;
+
+  watcher.on("change", async (filePath) => {
+    if (isProcessing) return; // Debounce
+
+    console.log(
+      chalk.cyan(`\nDetected change in ${filePath}. Analyzing...`)
+    );
+    isProcessing = true;
+
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      const feedback = await agent.generateSuggestions(content);
+
+      console.log(
+        chalk.green(`\n--- LIVE AI FEEDBACK FOR ${filePath} ---\n`)
+      );
+      console.log(feedback);
+    } catch (err) {
+      console.error(chalk.red("Analysis failed:"), err);
+    } finally {
+      isProcessing = false;
+      console.log(chalk.gray("\n  Watching for more changes..."));
+    }
+  });
+
+  console.log(chalk.green("  Watcher started. Press Ctrl+C to exit.\n"));
+}

package/src/index.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import * as path from "path";
+import * as dotenv from "dotenv";
+import * as os from "os";
+
+
+const monorepoEnv = path.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: path.resolve(os.homedir(), ".vortexenv"), override: true });
+
+
+const cwdEnv = path.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];
+  }
+}
+
+import { initCommand } from "./commands/init";
+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 { watchCommand } from "./commands/watch";
+import { solveCommand } from "./commands/solve";
+import { solveIssueCommand } from "./commands/solve-issue";
+import { cacheCommand } from "./commands/cache";
+
+const program = new Command();
+
+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";
+  }
+});
+
+// ── Core Commands ──
+
+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);
+
+// ── 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);
+
+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();

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "@vortex/typescript-config/base",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}