@getreka/cli 0.1.0

package/dist/api.d.ts

@@ -0,0 +1,7 @@
+/**
+ * API client for Reka CLI
+ */
+import { AxiosInstance } from "axios";
+import { RekaConfig } from "./config";
+export declare function createClient(config: RekaConfig): AxiosInstance;
+export declare function formatError(err: unknown): string;

package/dist/api.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * API client for Reka CLI
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+exports.formatError = formatError;
+const axios_1 = __importStar(require("axios"));
+function createClient(config) {
+    const headers = {
+        "Content-Type": "application/json",
+        "X-Project-Name": config.project.name,
+        "X-Project-Path": config.project.path,
+    };
+    if (config.api.key) {
+        headers["Authorization"] = `Bearer ${config.api.key}`;
+    }
+    return axios_1.default.create({
+        baseURL: config.api.url,
+        timeout: 120000,
+        headers,
+    });
+}
+function formatError(err) {
+    if (err instanceof axios_1.AxiosError) {
+        if (err.code === "ECONNREFUSED") {
+            return `Cannot connect to Reka API at ${err.config?.baseURL}. Is it running?`;
+        }
+        if (err.response) {
+            const data = err.response.data;
+            return data?.error || data?.message || `HTTP ${err.response.status}`;
+        }
+    }
+    return err.message || String(err);
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from "axios";
+import { RekaConfig } from "../config";
+export declare function indexCommand(client: AxiosInstance, config: RekaConfig, opts: {
+    path?: string;
+    watch?: boolean;
+}): Promise<void>;

package/dist/commands/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexCommand = indexCommand;
+const ora_1 = __importDefault(require("ora"));
+const api_1 = require("../api");
+async function indexCommand(client, config, opts) {
+    const indexPath = opts.path || config.project.path;
+    const spinner = (0, ora_1.default)(`Indexing ${indexPath}...`).start();
+    try {
+        const { data } = await client.post("/api/index", {
+            path: indexPath,
+            projectName: config.project.name,
+        });
+        spinner.succeed(`Indexed ${data.filesProcessed || "N/A"} files`);
+        if (data.stats) {
+            console.log("");
+            console.log(`  Chunks:   ${data.stats.chunks || "N/A"}`);
+            console.log(`  Symbols:  ${data.stats.symbols || "N/A"}`);
+            console.log(`  Duration: ${data.stats.duration || "N/A"}`);
+        }
+    }
+    catch (err) {
+        spinner.fail(`Index failed: ${(0, api_1.formatError)(err)}`);
+        process.exit(1);
+    }
+    console.log("");
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+export declare function initCommand(opts: {
+    project?: string;
+    path?: string;
+    force?: boolean;
+    cloud?: boolean;
+    key?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../api");
+const config_1 = require("../config");
+const MCP_TEMPLATE = `{
+  "mcpServers": {
+    "reka": {
+      "command": "npx",
+      "args": ["-y", "@getreka/mcp"],
+      "env": {
+        "REKA_API_KEY": "{{API_KEY}}"
+      }
+    }
+  }
+}`;
+async function initCommand(opts) {
+    const projectPath = opts.path || process.cwd();
+    const projectName = opts.project || path.basename(projectPath);
+    // Cloud mode: use provided key, skip keygen
+    if (opts.cloud || opts.key) {
+        if (!opts.key) {
+            console.log(chalk_1.default.red("\n  --key is required for cloud mode. Get one at https://getreka.dev/dashboard\n"));
+            return;
+        }
+        writeMcpConfig(projectPath, opts.key, opts.force);
+        console.log(chalk_1.default.green(`\n  ✓ Connected to Reka Cloud`));
+        console.log(`  Project will be resolved from your API key.\n`);
+        return;
+    }
+    // Self-hosted: generate key via local API
+    const config = (0, config_1.loadConfig)({
+        api: { url: opts.apiUrl || "http://localhost:3100" },
+        project: { name: projectName, path: projectPath },
+    });
+    const client = (0, api_1.createClient)(config);
+    console.log(`\n  Generating API key for project ${chalk_1.default.bold(projectName)}...`);
+    try {
+        const { data } = await client.post("/api/keys", {
+            projectName,
+            label: `init-${Date.now()}`,
+        });
+        const apiKey = data.key;
+        writeMcpConfig(projectPath, apiKey, opts.force);
+        console.log(chalk_1.default.green(`  ✓ API key created: ${apiKey.slice(0, 20)}...`));
+        console.log(chalk_1.default.green(`  ✓ .mcp.json written`));
+        console.log("");
+        console.log("  Your AI assistant now has memory. Try asking it about your codebase!");
+        console.log("");
+    }
+    catch (err) {
+        const msg = err.response?.data?.error || err.message;
+        console.log(chalk_1.default.red(`\n  Failed to generate key: ${msg}`));
+        console.log(chalk_1.default.yellow(`  Is the Reka API running? Start with: docker-compose up -d\n`));
+    }
+}
+function writeMcpConfig(projectPath, apiKey, force) {
+    const mcpPath = path.join(projectPath, ".mcp.json");
+    if (fs.existsSync(mcpPath) && !force) {
+        // Merge into existing .mcp.json
+        try {
+            const existing = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+            existing.mcpServers = existing.mcpServers || {};
+            existing.mcpServers.reka = {
+                command: "npx",
+                args: ["-y", "@getreka/mcp"],
+                env: { REKA_API_KEY: apiKey },
+            };
+            fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+            return;
+        }
+        catch {
+            // Fall through to overwrite
+        }
+    }
+    const content = MCP_TEMPLATE.replace("{{API_KEY}}", apiKey);
+    fs.writeFileSync(mcpPath, content + "\n", "utf-8");
+}

package/dist/commands/models.d.ts

@@ -0,0 +1,3 @@
+import { RekaConfig } from "../config";
+export declare function modelsListCommand(config: RekaConfig): Promise<void>;
+export declare function modelsTestCommand(config: RekaConfig): Promise<void>;

package/dist/commands/models.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelsListCommand = modelsListCommand;
+exports.modelsTestCommand = modelsTestCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const axios_1 = __importDefault(require("axios"));
+const api_1 = require("../api");
+async function checkProvider(name, url) {
+    const start = Date.now();
+    try {
+        if (name === "ollama") {
+            const { data } = await axios_1.default.get(`${url}/api/tags`, { timeout: 5000 });
+            return {
+                name,
+                url,
+                status: "healthy",
+                latency: Date.now() - start,
+                models: (data.models || []).map((m) => m.name),
+            };
+        }
+        else if (name === "bge-m3") {
+            await axios_1.default.get(`${url}/health`, { timeout: 5000 });
+            return { name, url, status: "healthy", latency: Date.now() - start };
+        }
+        else {
+            await axios_1.default.get(url, { timeout: 5000 });
+            return { name, url, status: "healthy", latency: Date.now() - start };
+        }
+    }
+    catch {
+        return { name, url, status: "unreachable", latency: Date.now() - start };
+    }
+}
+async function modelsListCommand(config) {
+    console.log(chalk_1.default.bold("\n  Model Providers\n"));
+    const spinner = (0, ora_1.default)("Checking providers...").start();
+    const checks = [];
+    // Always check default providers
+    const ollamaUrl = config.models?.llm?.utility?.url || "http://localhost:11434";
+    const bgeUrl = config.models?.embeddings?.url || "http://localhost:8080";
+    checks.push(checkProvider("ollama", ollamaUrl));
+    checks.push(checkProvider("bge-m3", bgeUrl));
+    const results = await Promise.all(checks);
+    spinner.stop();
+    for (const r of results) {
+        const icon = r.status === "healthy" ? chalk_1.default.green("●") : chalk_1.default.red("●");
+        const latency = r.latency ? chalk_1.default.gray(`${r.latency}ms`) : "";
+        console.log(`  ${icon} ${chalk_1.default.bold(r.name)} ${chalk_1.default.gray(r.url)} ${latency}`);
+        if (r.models && r.models.length > 0) {
+            for (const m of r.models.slice(0, 10)) {
+                console.log(`    ${chalk_1.default.gray("→")} ${m}`);
+            }
+            if (r.models.length > 10) {
+                console.log(`    ${chalk_1.default.gray(`  ...and ${r.models.length - 10} more`)}`);
+            }
+        }
+    }
+    // Show configured routing
+    if (config.models?.llm) {
+        console.log(chalk_1.default.bold("\n  Routing"));
+        const llm = config.models.llm;
+        if (llm.utility)
+            console.log(`  Utility:  ${llm.utility.provider} / ${llm.utility.model || "default"}`);
+        if (llm.standard)
+            console.log(`  Standard: ${llm.standard.provider} / ${llm.standard.model || "default"}`);
+        if (llm.complex)
+            console.log(`  Complex:  ${llm.complex.provider} / ${llm.complex.model || "default"}`);
+    }
+    console.log("");
+}
+async function modelsTestCommand(config) {
+    console.log(chalk_1.default.bold("\n  Testing Model Connections\n"));
+    const ollamaUrl = config.models?.llm?.utility?.url || "http://localhost:11434";
+    const bgeUrl = config.models?.embeddings?.url || "http://localhost:8080";
+    // Test embedding
+    const embedSpinner = (0, ora_1.default)("Testing embeddings...").start();
+    try {
+        const start = Date.now();
+        await axios_1.default.post(`${bgeUrl}/embed`, {
+            text: "test embedding connection",
+        }, { timeout: 10000 });
+        embedSpinner.succeed(`Embeddings OK (${Date.now() - start}ms)`);
+    }
+    catch (err) {
+        embedSpinner.fail(`Embeddings failed: ${(0, api_1.formatError)(err)}`);
+    }
+    // Test LLM
+    const llmSpinner = (0, ora_1.default)("Testing LLM...").start();
+    try {
+        const model = config.models?.llm?.utility?.model || "qwen3.5:35b";
+        const start = Date.now();
+        await axios_1.default.post(`${ollamaUrl}/api/generate`, {
+            model,
+            prompt: 'Say "ok" and nothing else.',
+            stream: false,
+            options: { num_predict: 10 },
+        }, { timeout: 30000 });
+        llmSpinner.succeed(`LLM OK — ${model} (${Date.now() - start}ms)`);
+    }
+    catch (err) {
+        llmSpinner.fail(`LLM failed: ${(0, api_1.formatError)(err)}`);
+    }
+    console.log("");
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from "axios";
+import { RekaConfig } from "../config";
+export declare function searchCommand(client: AxiosInstance, config: RekaConfig, query: string, opts: {
+    limit?: string;
+    type?: string;
+}): Promise<void>;

package/dist/commands/search.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchCommand = searchCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const api_1 = require("../api");
+async function searchCommand(client, config, query, opts) {
+    const limit = parseInt(opts.limit || "5", 10);
+    const spinner = (0, ora_1.default)("Searching...").start();
+    try {
+        const { data } = await client.post("/api/search", {
+            query,
+            limit,
+            collection: opts.type || "codebase",
+        });
+        spinner.stop();
+        const results = data.results || data;
+        if (!results || results.length === 0) {
+            console.log(chalk_1.default.yellow("\n  No results found.\n"));
+            return;
+        }
+        console.log(chalk_1.default.bold(`\n  ${results.length} results for "${query}"\n`));
+        for (const [i, r] of results.entries()) {
+            const score = r.score
+                ? chalk_1.default.gray(`(${(r.score * 100).toFixed(0)}%)`)
+                : "";
+            const filePath = r.metadata?.filePath || r.metadata?.file_path || "";
+            const lines = r.metadata?.startLine
+                ? `:${r.metadata.startLine}-${r.metadata.endLine || ""}`
+                : "";
+            console.log(`  ${chalk_1.default.blue(`${i + 1}.`)} ${chalk_1.default.bold(filePath)}${lines} ${score}`);
+            // Show snippet (first 3 lines)
+            if (r.content || r.text) {
+                const text = (r.content || r.text);
+                const snippet = text.split("\n").slice(0, 3).join("\n");
+                console.log(chalk_1.default.gray(`     ${snippet.replace(/\n/g, "\n     ")}`));
+            }
+            console.log("");
+        }
+    }
+    catch (err) {
+        spinner.fail(`Search failed: ${(0, api_1.formatError)(err)}`);
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,3 @@
+import { AxiosInstance } from "axios";
+import { RekaConfig } from "../config";
+export declare function statusCommand(client: AxiosInstance, config: RekaConfig): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../api");
+async function statusCommand(client, config) {
+    console.log(chalk_1.default.bold("\n  Reka Status\n"));
+    console.log(`  API:     ${config.api.url}`);
+    console.log(`  Project: ${config.project.name}`);
+    console.log(`  Path:    ${config.project.path}`);
+    console.log("");
+    // Check API health
+    try {
+        const { data } = await client.get("/health");
+        console.log(`  API:     ${chalk_1.default.green("● healthy")}`);
+        if (data.cache) {
+            console.log(`  Cache:   ${chalk_1.default.green("● connected")} (${data.cache.hitRate || "N/A"} hit rate)`);
+        }
+    }
+    catch (err) {
+        console.log(`  API:     ${chalk_1.default.red("● unreachable")} — ${(0, api_1.formatError)(err)}`);
+        return;
+    }
+    // Check services
+    try {
+        const { data } = await client.get("/api/project/stats");
+        const stats = data.stats || data;
+        console.log("");
+        console.log(chalk_1.default.bold("  Project Stats"));
+        if (stats.collections) {
+            console.log(`  Collections:  ${stats.collections}`);
+        }
+        if (stats.totalPoints !== undefined) {
+            console.log(`  Vectors:      ${stats.totalPoints.toLocaleString()}`);
+        }
+        if (stats.memoryCount !== undefined) {
+            console.log(`  Memories:     ${stats.memoryCount}`);
+        }
+    }
+    catch {
+        // Stats endpoint may not exist, that's ok
+    }
+    // Check index status
+    try {
+        const { data } = await client.get("/api/index/status");
+        if (data.status) {
+            const s = data.status;
+            console.log("");
+            console.log(chalk_1.default.bold("  Index"));
+            console.log(`  Status:   ${s.indexing ? chalk_1.default.yellow("● indexing") : chalk_1.default.green("● idle")}`);
+            if (s.totalFiles)
+                console.log(`  Files:    ${s.totalFiles}`);
+            if (s.lastIndexed)
+                console.log(`  Last run: ${new Date(s.lastIndexed).toLocaleString()}`);
+        }
+    }
+    catch {
+        // Index status may not exist
+    }
+    console.log("");
+}

package/dist/config.d.ts

@@ -0,0 +1,41 @@
+/**
+ * CLI configuration loader
+ * Reads reka.config.yaml → env vars → defaults
+ */
+export interface RekaConfig {
+    api: {
+        url: string;
+        key?: string;
+    };
+    project: {
+        name: string;
+        path: string;
+    };
+    models?: {
+        embeddings?: {
+            provider: string;
+            model?: string;
+            url?: string;
+            dimensions?: number;
+        };
+        llm?: {
+            utility?: {
+                provider: string;
+                model?: string;
+                url?: string;
+            };
+            standard?: {
+                provider: string;
+                model?: string;
+                url?: string;
+            };
+            complex?: {
+                provider: string;
+                model?: string;
+                url?: string;
+            };
+        };
+    };
+}
+export declare function loadConfig(overrides?: Partial<RekaConfig>): RekaConfig;
+export declare function getConfigFilePath(): string | null;

package/dist/config.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * CLI configuration loader
+ * Reads reka.config.yaml → env vars → defaults
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.getConfigFilePath = getConfigFilePath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const CONFIG_FILES = ["reka.config.yaml", "reka.config.yml", ".rekarc.yaml"];
+function findConfigFile(startDir) {
+    let dir = startDir;
+    while (true) {
+        for (const name of CONFIG_FILES) {
+            const filePath = path.join(dir, name);
+            if (fs.existsSync(filePath))
+                return filePath;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Check home directory
+    const homeConfig = path.join(process.env.HOME || "~", ".config", "reka", "config.yaml");
+    if (fs.existsSync(homeConfig))
+        return homeConfig;
+    return null;
+}
+function loadConfig(overrides) {
+    const configFile = findConfigFile(process.cwd());
+    let fileConfig = {};
+    if (configFile) {
+        try {
+            const raw = fs.readFileSync(configFile, "utf-8");
+            fileConfig = yaml.load(raw) || {};
+        }
+        catch {
+            // Silently ignore malformed config
+        }
+    }
+    const projectName = overrides?.project?.name ||
+        fileConfig.project?.name ||
+        process.env.REKA_PROJECT ||
+        path.basename(process.cwd());
+    const config = {
+        api: {
+            url: overrides?.api?.url ||
+                fileConfig.api?.url ||
+                process.env.REKA_API_URL ||
+                process.env.RAG_API_URL ||
+                "http://localhost:3100",
+            key: overrides?.api?.key ||
+                fileConfig.api?.key ||
+                process.env.REKA_API_KEY ||
+                process.env.RAG_API_KEY,
+        },
+        project: {
+            name: projectName,
+            path: overrides?.project?.path ||
+                fileConfig.project?.path ||
+                process.env.REKA_PROJECT_PATH ||
+                process.cwd(),
+        },
+        models: fileConfig.models || overrides?.models,
+    };
+    return config;
+}
+function getConfigFilePath() {
+    return findConfigFile(process.cwd());
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * Reka CLI — manage your self-hosted RAG infrastructure
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Reka CLI — manage your self-hosted RAG infrastructure
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const config_1 = require("./config");
+const api_1 = require("./api");
+const status_1 = require("./commands/status");
+const init_1 = require("./commands/init");
+const index_1 = require("./commands/index");
+const search_1 = require("./commands/search");
+const models_1 = require("./commands/models");
+const program = new commander_1.Command();
+program
+    .name("reka")
+    .description("Reka — Memory your AI can trust")
+    .version("0.1.0")
+    .option("--api-url <url>", "RAG API URL")
+    .option("--api-key <key>", "API key")
+    .option("--project <name>", "Project name");
+// reka init
+program
+    .command("init")
+    .description("Initialize Reka for current project — generates API key and .mcp.json")
+    .option("--project <name>", "Project name (defaults to directory name)")
+    .option("-p, --path <path>", "Project path")
+    .option("-f, --force", "Overwrite existing .mcp.json")
+    .option("--cloud", "Connect to Reka Cloud instead of local")
+    .option("--key <key>", "API key (required for --cloud)")
+    .option("--api-url <url>", "RAG API URL (default: http://localhost:3100)")
+    .action(async (opts) => {
+    await (0, init_1.initCommand)(opts);
+});
+// reka status
+program
+    .command("status")
+    .description("Show Reka API and project status")
+    .action(async () => {
+    const config = (0, config_1.loadConfig)(getOverrides());
+    const client = (0, api_1.createClient)(config);
+    await (0, status_1.statusCommand)(client, config);
+});
+// reka index [path]
+program
+    .command("index [path]")
+    .description("Index a codebase for search")
+    .option("-w, --watch", "Watch for file changes")
+    .action(async (indexPath, opts) => {
+    const config = (0, config_1.loadConfig)(getOverrides());
+    const client = (0, api_1.createClient)(config);
+    await (0, index_1.indexCommand)(client, config, { path: indexPath, ...opts });
+});
+// reka search <query>
+program
+    .command("search <query>")
+    .description("Search indexed codebase")
+    .option("-l, --limit <n>", "Number of results", "5")
+    .option("-t, --type <type>", "Collection type (codebase, docs, memory)")
+    .action(async (query, opts) => {
+    const config = (0, config_1.loadConfig)(getOverrides());
+    const client = (0, api_1.createClient)(config);
+    await (0, search_1.searchCommand)(client, config, query, opts);
+});
+// reka models
+const models = program.command("models").description("Manage model providers");
+models
+    .command("list")
+    .description("List configured model providers and their status")
+    .action(async () => {
+    const config = (0, config_1.loadConfig)(getOverrides());
+    await (0, models_1.modelsListCommand)(config);
+});
+models
+    .command("test")
+    .description("Test connection to all model providers")
+    .action(async () => {
+    const config = (0, config_1.loadConfig)(getOverrides());
+    await (0, models_1.modelsTestCommand)(config);
+});
+// Helper to extract global overrides
+function getOverrides() {
+    const opts = program.opts();
+    const overrides = {};
+    if (opts.apiUrl || opts.apiKey) {
+        overrides.api = {};
+        if (opts.apiUrl)
+            overrides.api.url = opts.apiUrl;
+        if (opts.apiKey)
+            overrides.api.key = opts.apiKey;
+    }
+    if (opts.project) {
+        overrides.project = { name: opts.project };
+    }
+    return overrides;
+}
+program.parse();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@getreka/cli",
+  "version": "0.1.0",
+  "description": "Reka CLI — manage self-hosted RAG infrastructure for AI coding agents",
+  "bin": {
+    "reka": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": ["dist", "README.md"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/getreka/reka.git",
+    "directory": "cli"
+  },
+  "homepage": "https://getreka.dev",
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "axios": "^1.7.0",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "js-yaml": "^4.1.0",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0",
+    "ts-node": "^10.9.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "BSL-1.1",
+  "keywords": ["reka", "rag", "mcp", "ai", "cli", "coding-agent", "memory"]
+}