codexa 1.0.0

package/dist/models/index.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLLMClient = createLLMClient;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const ai_1 = require("ai");
+const groq_1 = require("@ai-sdk/groq");
+class OllamaLLM {
+    model;
+    baseURL;
+    constructor(model, baseURL) {
+        this.model = model;
+        this.baseURL = baseURL;
+    }
+    async generate(messages, options) {
+        const prompt = messages.map((m) => `${m.role.toUpperCase()}: ${m.content}`).join('\n\n');
+        const body = {
+            model: this.model,
+            prompt,
+            stream: options?.stream ?? false,
+        };
+        const resp = await (0, node_fetch_1.default)(`${this.baseURL}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!resp.ok) {
+            const text = await resp.text();
+            throw new Error(`Ollama request failed: ${resp.status} ${text}`);
+        }
+        if (!options?.stream) {
+            const json = await resp.json();
+            return (json.response ??
+                json.output ??
+                '');
+        }
+        const stream = resp.body;
+        if (!stream) {
+            throw new Error('Streaming not supported on this response body.');
+        }
+        let full = '';
+        let buffer = '';
+        for await (const chunk of stream) {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    const token = parsed.response ?? '';
+                    if (token) {
+                        full += token;
+                        options.onToken?.(token);
+                    }
+                }
+                catch {
+                    // Should not happen with proper buffering, but ignore if it does
+                }
+            }
+        }
+        // Process any remaining buffer
+        if (buffer.trim()) {
+            try {
+                const parsed = JSON.parse(buffer.trim());
+                const token = parsed.response ?? '';
+                if (token) {
+                    full += token;
+                    options.onToken?.(token);
+                }
+            }
+            catch {
+                // Ignore incomplete final chunk
+            }
+        }
+        return full;
+    }
+}
+class GroqLLM {
+    model;
+    apiKey;
+    groq;
+    constructor(model, apiKey) {
+        this.model = model;
+        this.apiKey = apiKey;
+        this.groq = (0, groq_1.createGroq)({
+            apiKey: this.apiKey,
+        });
+    }
+    async generate(messages, options) {
+        const modelId = this.model;
+        if (!options?.stream) {
+            const { text } = await (0, ai_1.generateText)({
+                model: this.groq(modelId),
+                messages,
+            });
+            return text;
+        }
+        const result = (0, ai_1.streamText)({
+            model: this.groq(modelId),
+            messages,
+        });
+        let fullText = '';
+        for await (const textPart of result.textStream) {
+            fullText += textPart;
+            options.onToken?.(textPart);
+        }
+        return fullText;
+    }
+}
+function createLLMClient(config) {
+    if (config.modelProvider === 'local') {
+        const base = config.localModelUrl?.replace(/\/$/, '') || 'http://localhost:11434';
+        if (process.env.AGENT_DEBUG) {
+            console.error('Using Ollama client:', config.model, config.localModelUrl);
+        }
+        return new OllamaLLM(config.model, base);
+    }
+    if (config.modelProvider === 'groq') {
+        if (process.env.AGENT_DEBUG) {
+            console.error('Using Groq client:', config.model);
+        }
+        return new GroqLLM(config.model, process.env.GROQ_API_KEY);
+    }
+    throw new Error('Only local provider supported for now.');
+}

package/dist/retriever.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveContext = retrieveContext;
+exports.formatContext = formatContext;
+const embeddings_1 = require("./embeddings");
+const db_1 = require("./db");
+async function retrieveContext(question, config) {
+    const embedder = await (0, embeddings_1.createEmbedder)(config);
+    const [qvec] = await embedder.embed([question]);
+    const store = new db_1.VectorStore(config.dbPath);
+    store.init();
+    return store.search(qvec, config.topK);
+}
+function formatContext(results) {
+    return results
+        .map((r) => {
+        const snippet = r.compressed ?? r.content.slice(0, 300);
+        return `FILE: ${r.filePath}:${r.startLine}-${r.endLine}
+CODE_SNIPPET: ${snippet}`;
+    })
+        .join('\n\n---\n\n');
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/logger.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.log = {
+    info: (msg) => console.log(chalk_1.default.cyan('info'), msg),
+    success: (msg) => console.log(chalk_1.default.green('success'), msg),
+    warn: (msg) => console.log(chalk_1.default.yellow('warn'), msg),
+    error: (msg) => console.log(chalk_1.default.red('error'), msg),
+};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "codexa",
+  "version": "1.0.0",
+  "description": "CLI agent that indexes local repos and answers questions with hosted or local LLMs.",
+  "bin": {
+    "codexa": "bin/codexa.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run clean && npm run build",
+    "dev": "tsx src/cli.ts",
+    "smoke": "ts-node --transpile-only scripts/smoke.ts",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "test": "vitest"
+  },
+  "type": "commonjs",
+  "keywords": [
+    "ai",
+    "cli",
+    "rag",
+    "codebase"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sahitya-chandra/codexa.git"
+  },
+  "homepage": "https://github.com/sahitya-chandra/codexa#readme",
+  "bugs": {
+    "url": "https://github.com/sahitya-chandra/codexa/issues"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@ai-sdk/groq": "^2.0.32",
+    "@xenova/transformers": "^2.17.2",
+    "ai": "^5.0.105",
+    "better-sqlite3": "^9.6.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "fs-extra": "^11.2.0",
+    "globby": "^13.0.0",
+    "ignore": "^5.3.1",
+    "node-fetch": "^3.3.2",
+    "openai": "^4.73.1",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/better-sqlite3": "^7.6.9",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.19.1",
+    "@typescript-eslint/eslint-plugin": "^8.47.0",
+    "@typescript-eslint/parser": "^8.47.0",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.5.0",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.47.0",
+    "vitest": "^4.0.14"
+  }
+}