@vortex-ai/cli 0.1.2

package/README.md

@@ -0,0 +1,155 @@
+# Vortex - Developer Intelligence & PR Review Engine
+
+![npm version](https://img.shields.io/npm/v/vortex-cli)
+![Node.js Version](https://img.shields.io/node/v/vortex-cli)
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+
+**Vortex** is an autonomous, AI-powered developer assistant and CLI tool that combines semantic code search, Git integration, and LLM-based intelligence. It provides contextual code reviews, deeply technical issue analysis, interactive semantic search, and an autonomous coding agent to help you solve tasks right in your terminal.
+
+---
+
+## Quick Start
+
+### Installation
+
+Install Vortex globally via npm:
+```bash
+npm install -g vortex-cli
+```
+
+### Configuration
+
+Vortex requires an API key for its LLM engine (e.g., Google Gemini or Groq). Set up a global configuration in your home directory:
+
+```bash
+echo "GEMINI_API_KEY=your_gemini_key_here" > ~/.vortexenv
+```
+
+You can also use project-specific `.env` files or inline environment variables.
+
+### Your First Commands
+
+```bash
+# 1. Initialize the local vector and BM25 indexes for your repository
+vortex init
+
+# 2. Ask the autonomous agent to solve a task
+vortex solve "Refactor the authentication middleware to use JWT"
+
+# 3. Perform a multi-agent review on a pull request
+vortex review --pr 42
+```
+
+---
+
+## Core Features
+
+- **`vortex solve <prompt>`**: Autonomous AI agent that explores your codebase, writes code, and executes terminal commands to solve your task.
+- **`vortex solve-issue --id <id>`**: Seamlessly connects GitHub issues with the Autonomous Agent. Fetches the issue, runs RAG to find relevant local code, and automatically writes the fix.
+- **`vortex review --pr <id>`**: Multi-agent PR review analyzing security, architecture, and logic.
+- **`vortex search -q <query>`**: Semantic, natural language code search backed by AI explanations.
+- **`vortex issue --id <id>`**: Analyzes GitHub issues and proposes step-by-step local code fixes.
+- **`vortex graph`**: Automatically generates Mermaid dependency graphs of your files or entire project.
+- **`vortex fix-nitbits`**: AI-powered auto-fixer for linting, formatting, and minor structural issues.
+
+*Note: Most read-only analysis commands automatically cache LLM requests to speed up subsequent runs and save API costs.*
+
+---
+
+## Real-world Examples
+
+**Scenario 1: Refactoring Code Autonomously**
+```bash
+vortex solve "Refactor the authentication middleware to use JWT instead of sessions, making sure it aligns with the existing User model"
+```
+
+**Scenario 2: Pre-Merge Security & Architecture Review**
+```bash
+vortex review --pr 104 --deep
+# Output: The Security Agent flags a data leak, the Architecture Agent suggests abstracting the API call, and the Synthesizer provides the exact diff to fix it.
+```
+
+**Scenario 3: Fully Autonomously Solving a GitHub Issue**
+```bash
+vortex solve-issue --id 45
+# Output: Fetches Issue #45, grabs local RAG context, and hands it directly to the ReAct agent which actively writes the code to fix the bug.
+```
+
+---
+
+## Architecture Overview
+
+Vortex runs on a sophisticated **Multi-Agent Cognitive Architecture** backed by **Hybrid RAG** (Retrieval-Augmented Generation).
+
+### Multi-Agent System
+Instead of passing code blindly to an LLM, Vortex uses specialized agents:
+- **Security Agent**: Scans for vulnerabilities and insecure patterns.
+- **Architecture Agent**: Checks code for design consistency against your repo's existing patterns.
+- **Synthesizer Agent**: Combines outputs into an actionable, unified review.
+- **Base Agent (ReAct Loop)**: An autonomous loop that can execute file system tools, read code, and run terminal commands to iteratively solve tasks.
+
+### Memory & Retrieval
+Vortex utilizes a multi-layered memory architecture to maintain context without exceeding token limits or sacrificing privacy.
+
+1. **Persistent Agentic Memory (`MemoryService`)**: Acts as episodic memory. Stores review history, architectural decisions, and known bugs in a local SQLite database for cross-PR consistency.
+2. **Hybrid RAG Indexing (`HybridRetriever`)**: Uses AST-aware chunking, on-device Xenova Transformer dense vector embeddings, and sparse lexical BM25 indexing. Cross-encoder reranking ensures only the most relevant context is fed to the LLM.
+
+```mermaid
+graph TD
+    User((User / Developer)) -->|CLI Commands| CLI[Vortex CLI Interface]
+    CLI -->|Task & State Context| Engine[Intelligence Engine Core]
+    
+    subgraph Multi-Agent Cognitive Architecture
+        Engine -->|Delegates to| Orchestrator[ReAct Base Agent / Review Orchestrator]
+        Orchestrator <-->|Zero-Shot Analysis| Sec[Security Vulnerability Agent]
+        Orchestrator <-->|Pattern Recognition| Arch[Architectural Consistency Agent]
+        Orchestrator <-->|Context Aggregation| Synth[Synthesizer / Response Generation Agent]
+    end
+    
+    subgraph Hybrid RAG Pipeline
+        Engine -->|Semantic Queries| Retriever[Hybrid Semantic Retriever]
+        Retriever -->|Dense Embeddings| VectorStore[(Prisma SQLite Vector DB)]
+        Retriever -->|Sparse Lexical| BM25[(BM25 Keyword Index)]
+        Retriever -->|Structural Parse| Chunking[AST-Aware Semantic Chunker]
+        Retriever -->|On-Device Inference| Embedder[Local Xenova Transformers]
+    end
+    
+    Engine <-->|Few-Shot Prompts / Tool Calling| AI((Google Gemini API / Groq LLMs))
+    Orchestrator -->|Autonomous Execution| FileSystem[Local File System & Git Operations]
+```
+
+---
+
+## Security & Safety Boundaries
+
+Running autonomous agents on your local machine requires strict safety rails. Vortex includes:
+- **Interactive Diff Approvals**: The `solve` command will pause and ask for your permission (Y/n) before running any terminal commands or overwriting files. You can bypass this in CI pipelines with the `--auto-approve` flag.
+- **Rollback Backups**: Whenever the agent modifies a file, the original version is automatically backed up to `.vortex_backup/` to prevent data loss.
+- **Command Blacklist**: Dangerous commands like `rm`, `sudo`, `chmod`, and `chown` are instantly rejected if the agent attempts to run them.
+- **Real-Time Visuals**: See what the agent is doing with inline `git diff` outputs as files are successfully edited.
+
+---
+
+## Performance & Privacy
+
+Vortex is engineered for speed and cost-efficiency, keeping the heavy lifting local to your machine:
+- **Zero-Cost Indexing**: Generating embeddings for your repository runs entirely on-device via Xenova Transformers, meaning **no API costs** and **complete privacy**.
+- **Token Efficiency**: By intelligently chunking code (AST-aware) and only sending the most relevant segments to the LLM, Vortex uses significantly fewer tokens.
+
+---
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details on how to set up the development environment, run tests, and submit pull requests.
+
+### Development Setup
+```bash
+git clone https://github.com/your-org/vortex.git
+cd vortex
+npm install
+npm run build
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/chunk-C6P2IO65.mjs

@@ -0,0 +1,41 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-FC2JQ4EC.mjs

@@ -0,0 +1,119 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-C6P2IO65.mjs";
+
+// ../db/dist/index.js
+var require_dist = __commonJS({
+  "../db/dist/index.js"(exports, module) {
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      initDatabase: () => initDatabase,
+      prisma: () => prisma
+    });
+    module.exports = __toCommonJS(index_exports);
+    var import_client = __require("@prisma/client");
+    var path = __toESM(__require("path"));
+    __reExport(index_exports, __require("@prisma/client"), module.exports);
+    var prisma = new import_client.PrismaClient({
+      datasources: {
+        db: {
+          url: `file:${path.resolve(process.cwd(), ".vortex.db")}`
+        }
+      }
+    });
+    async function initDatabase() {
+      await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "Chunk" (
+      "id" TEXT NOT NULL PRIMARY KEY,
+      "file" TEXT NOT NULL,
+      "language" TEXT NOT NULL,
+      "name" TEXT NOT NULL,
+      "symbolPath" TEXT NOT NULL,
+      "kind" TEXT NOT NULL,
+      "parent" TEXT,
+      "isExported" BOOLEAN NOT NULL,
+      "isAsync" BOOLEAN NOT NULL,
+      "signature" TEXT,
+      "dependencies" TEXT NOT NULL,
+      "startLine" INTEGER NOT NULL,
+      "endLine" INTEGER NOT NULL,
+      "hash" TEXT NOT NULL,
+      "content" TEXT NOT NULL,
+      "embedding" TEXT,
+      "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+      await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "Memory" (
+      "id" TEXT NOT NULL PRIMARY KEY,
+      "type" TEXT NOT NULL,
+      "content" TEXT NOT NULL,
+      "source" TEXT NOT NULL,
+      "tags" TEXT NOT NULL,
+      "embedding" TEXT,
+      "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+      await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "ReviewHistory" (
+      "id" TEXT NOT NULL PRIMARY KEY,
+      "prNumber" INTEGER NOT NULL,
+      "owner" TEXT NOT NULL,
+      "repo" TEXT NOT NULL,
+      "verdict" TEXT NOT NULL,
+      "summary" TEXT NOT NULL,
+      "findings" TEXT NOT NULL,
+      "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+      await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "LLMCache" (
+      "key" TEXT NOT NULL PRIMARY KEY,
+      "model" TEXT NOT NULL,
+      "response" TEXT NOT NULL,
+      "promptHash" TEXT NOT NULL,
+      "contextHash" TEXT NOT NULL,
+      "commitHash" TEXT,
+      "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "lastAccessedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "hitCount" INTEGER NOT NULL DEFAULT 0
+    );
+  `);
+    }
+  }
+});
+
+export {
+  require_dist
+};