ragcode-context-engine 0.1.0 → 0.1.1

package/dist/scripts/init-config.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Interactive configuration wizard for RagCode
+ */
+import { type RuntimeConfigFile } from '../src/config/runtime-config.js';
+export interface InitConfigOptions {
+    targetDir?: string;
+    defaults?: boolean;
+}
+export interface InitConfigResult {
+    targetDir: string;
+    configPath: string;
+    config: RuntimeConfigFile;
+}
+export declare function runInitConfig(options?: InitConfigOptions): Promise<InitConfigResult>;

package/dist/scripts/init-config.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Interactive configuration wizard for RagCode
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_RUNTIME_CONFIG, writeRuntimeConfigFile } from '../src/config/runtime-config.js';
+const DEFAULT_INIT_CONFIG = {
+    graphStore: DEFAULT_RUNTIME_CONFIG.graphStore,
+    sqlitePath: DEFAULT_RUNTIME_CONFIG.sqlitePath,
+    semanticStore: DEFAULT_RUNTIME_CONFIG.semanticStore,
+    lancedbUri: DEFAULT_RUNTIME_CONFIG.lancedbUri,
+    embeddingProvider: DEFAULT_RUNTIME_CONFIG.embeddingProvider
+};
+function createInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+}
+function question(rl, prompt) {
+    return new Promise(resolve => {
+        rl.question(prompt, answer => resolve(answer.trim()));
+    });
+}
+async function runWizard() {
+    const rl = createInterface();
+    const config = {
+        graphStore: 'sqlite',
+        semanticStore: 'lancedb',
+        embeddingProvider: 'deterministic'
+    };
+    console.log('🧙 RagCode Configuration Wizard\n');
+    // Graph store
+    console.log('📊 Graph Store (structural code graph)');
+    const graphStore = await question(rl, '  Choose: [1] SQLite (persistent), [2] Memory (testing only) [1]: ');
+    config.graphStore = graphStore === '2' ? 'memory' : 'sqlite';
+    if (config.graphStore === 'sqlite') {
+        const sqlitePath = await question(rl, '  SQLite database path [.ragcode/graph.sqlite]: ');
+        config.sqlitePath = sqlitePath || '.ragcode/graph.sqlite';
+    }
+    // Semantic store
+    console.log('\n🔍 Semantic Store (vector embeddings)');
+    const semanticStore = await question(rl, '  Choose: [1] LanceDB (persistent), [2] Memory (testing only) [1]: ');
+    config.semanticStore = semanticStore === '2' ? 'memory' : 'lancedb';
+    if (config.semanticStore === 'lancedb') {
+        const lancedbUri = await question(rl, '  LanceDB directory [.ragcode/lancedb]: ');
+        config.lancedbUri = lancedbUri || '.ragcode/lancedb';
+    }
+    // Embedding provider
+    console.log('\n🤖 Embedding Provider');
+    const embeddingProvider = await question(rl, '  Choose: [1] Deterministic (offline), [2] OpenAI-compatible (requires API key) [1]: ');
+    config.embeddingProvider = embeddingProvider === '2' ? 'openai-compatible' : 'deterministic';
+    if (config.embeddingProvider === 'openai-compatible') {
+        console.log('  💡 Set OPENAI_API_KEY environment variable or provide it now.');
+        const apiKey = await question(rl, '  OpenAI API Key (leave empty to use env var): ');
+        if (apiKey) {
+            config.openaiApiKey = apiKey;
+        }
+    }
+    rl.close();
+    return config;
+}
+function toRuntimeConfigFile(config) {
+    const configObj = {
+        graphStore: config.graphStore,
+        semanticStore: config.semanticStore,
+        embeddingProvider: config.embeddingProvider
+    };
+    if (config.sqlitePath)
+        configObj.sqlitePath = config.sqlitePath;
+    if (config.lancedbUri)
+        configObj.lancedbUri = config.lancedbUri;
+    if (config.openaiApiKey)
+        configObj.embeddingApiKey = config.openaiApiKey;
+    return configObj;
+}
+function writeConfigFile(targetDir, config) {
+    const ragcodeDir = path.join(targetDir, '.ragcode');
+    if (!fs.existsSync(ragcodeDir)) {
+        fs.mkdirSync(ragcodeDir, { recursive: true });
+        console.log(`\n📁 Created directory: ${ragcodeDir}`);
+    }
+    const configPath = writeRuntimeConfigFile(targetDir, toRuntimeConfigFile(config));
+    console.log(`✅ Configuration saved to: ${configPath}\n`);
+    return configPath;
+}
+function writeEnvExample(targetDir, config) {
+    const envPath = path.join(targetDir, '.ragcode', '.env.example');
+    let envContent = '# RagCode Environment Variables\n\n';
+    envContent += `RAGCODE_GRAPH_STORE=${config.graphStore}\n`;
+    if (config.sqlitePath) {
+        envContent += `RAGCODE_SQLITE_PATH=${config.sqlitePath}\n`;
+    }
+    envContent += `\nRAGCODE_SEMANTIC_STORE=${config.semanticStore}\n`;
+    if (config.lancedbUri) {
+        envContent += `RAGCODE_LANCEDB_URI=${config.lancedbUri}\n`;
+    }
+    envContent += `\nRAGCODE_EMBEDDING_PROVIDER=${config.embeddingProvider}\n`;
+    if (config.embeddingProvider === 'openai-compatible') {
+        envContent += 'OPENAI_API_KEY=your-api-key-here\n';
+    }
+    fs.writeFileSync(envPath, envContent, 'utf-8');
+    console.log(`📄 Environment template saved to: ${envPath}`);
+}
+function printNextSteps(config) {
+    console.log('\n🎉 Setup complete!\n');
+    console.log('Next steps:');
+    console.log('  1. Index your codebase:');
+    console.log('     ragcode index .\n');
+    console.log('  2. Search code:');
+    console.log('     ragcode search . "your query"\n');
+    if (config.embeddingProvider === 'openai-compatible' && !config.openaiApiKey) {
+        console.log('  ⚠️  Remember to set OPENAI_API_KEY:');
+        console.log('     export OPENAI_API_KEY=your-key\n');
+    }
+    console.log('  3. Start the MCP server:');
+    console.log('     ragcode setup-mcp\n');
+    console.log('  4. Upgrade embedding provider if needed:');
+    console.log('     ragcode configure\n');
+    console.log('  5. Launch the web dashboard for observation:');
+    console.log('     ragcode dashboard\n');
+}
+export async function runInitConfig(options = {}) {
+    const targetDir = path.resolve(options.targetDir || process.cwd());
+    console.log(`📍 Target directory: ${targetDir}\n`);
+    const config = options.defaults ? { ...DEFAULT_INIT_CONFIG } : await runWizard();
+    const configPath = writeConfigFile(targetDir, config);
+    writeEnvExample(targetDir, config);
+    printNextSteps(config);
+    return { targetDir, configPath, config: toRuntimeConfigFile(config) };
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`
+RagCode Configuration Wizard
+
+Usage:
+  ragcode init [directory] [--defaults]
+
+Examples:
+  ragcode init              # Initialize in current directory
+  ragcode init /path/to/project
+  ragcode init --defaults   # Write offline-first defaults without prompts
+    `);
+        process.exit(0);
+    }
+    const positional = args.filter((arg) => !arg.startsWith('-'));
+    await runInitConfig({
+        targetDir: positional[0],
+        defaults: args.includes('--defaults') || args.includes('--yes') || args.includes('-y')
+    });
+}
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : undefined;
+if (invokedPath && invokedPath === fileURLToPath(import.meta.url)) {
+    main().catch(err => {
+        console.error('❌ Setup failed:', err);
+        process.exit(1);
+    });
+}

package/dist/scripts/setup-mcp.d.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * Auto-configure RagCode as an MCP server for AI coding clients.
+ *
+ * Supported clients:
+ *   - claude       Claude Desktop      JSON  ~/.../claude_desktop_config.json   (mcpServers.ragcode)
+ *   - claude-code  Claude Code (repo)  JSON  <cwd>/.mcp.json                    (mcpServers.ragcode)
+ *   - codex        Codex CLI           TOML  ~/.codex/config.toml               (mcp_servers.ragcode)
+ *   - generic      print only          JSON  (paste into any MCP client)
+ *
+ * Merge strategy: existing config is parsed, the `ragcode` entry is upserted, and the
+ * file is rewritten. Other servers and unrelated keys are preserved. The previous file
+ * is backed up alongside the original before any overwrite.
+ */
+export type McpClient = 'claude' | 'claude-code' | 'codex' | 'generic';
+interface MCPServerConfig {
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+interface MCPConfig {
+    mcpServers: Record<string, MCPServerConfig>;
+}
+export interface SetupMcpOptions {
+    configPath?: string;
+    print?: boolean;
+    includeSecrets?: boolean;
+    client?: McpClient;
+    /** Skip the interactive overwrite prompt and replace any existing ragcode entry. */
+    force?: boolean;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function getClaudeMCPConfigPath(): string;
+/** Claude Code reads project-scoped MCP servers from `<repoRoot>/.mcp.json`. */
+export declare function getClaudeCodeMCPConfigPath(cwd: string): string;
+/** Codex CLI reads MCP servers from `~/.codex/config.toml` (CODEX_HOME overrides ~/.codex). */
+export declare function getCodexConfigPath(env?: NodeJS.ProcessEnv): string;
+export declare function buildMcpServerConfig(options?: SetupMcpOptions): MCPServerConfig;
+/**
+ * Upsert the ragcode server into a JSON MCP config object (Claude Desktop / Claude Code).
+ * Unknown top-level keys and other servers are preserved. Returns a new object.
+ */
+export declare function mergeMcpServersJson(existing: unknown, server: MCPServerConfig): MCPConfig;
+/**
+ * Upsert the ragcode server into a Codex config.toml string.
+ * Parses existing TOML, sets `mcp_servers.ragcode`, and re-stringifies. Other tables and
+ * keys are preserved; TOML comments are not (smol-toml limitation — callers back up first).
+ */
+export declare function mergeCodexToml(existingToml: string, server: MCPServerConfig): string;
+export declare function setupMCP(options?: SetupMcpOptions): void;
+export {};

package/dist/scripts/setup-mcp.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+/**
+ * Auto-configure RagCode as an MCP server for AI coding clients.
+ *
+ * Supported clients:
+ *   - claude       Claude Desktop      JSON  ~/.../claude_desktop_config.json   (mcpServers.ragcode)
+ *   - claude-code  Claude Code (repo)  JSON  <cwd>/.mcp.json                    (mcpServers.ragcode)
+ *   - codex        Codex CLI           TOML  ~/.codex/config.toml               (mcp_servers.ragcode)
+ *   - generic      print only          JSON  (paste into any MCP client)
+ *
+ * Merge strategy: existing config is parsed, the `ragcode` entry is upserted, and the
+ * file is rewritten. Other servers and unrelated keys are preserved. The previous file
+ * is backed up alongside the original before any overwrite.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
+import { loadRuntimeConfig, runtimeConfigToEnv } from '../src/config/runtime-config.js';
+const SERVER_KEY = 'ragcode';
+// ---------------------------------------------------------------------------
+// Config-path resolution (one per client)
+// ---------------------------------------------------------------------------
+export function getClaudeMCPConfigPath() {
+    const platform = os.platform();
+    if (platform === 'win32') {
+        return path.join(os.homedir(), 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
+    }
+    else if (platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    else {
+        // Linux
+        return path.join(os.homedir(), '.config', 'claude', 'claude_desktop_config.json');
+    }
+}
+/** Claude Code reads project-scoped MCP servers from `<repoRoot>/.mcp.json`. */
+export function getClaudeCodeMCPConfigPath(cwd) {
+    return path.join(cwd, '.mcp.json');
+}
+/** Codex CLI reads MCP servers from `~/.codex/config.toml` (CODEX_HOME overrides ~/.codex). */
+export function getCodexConfigPath(env = process.env) {
+    const home = env.CODEX_HOME && env.CODEX_HOME.trim().length > 0
+        ? env.CODEX_HOME
+        : path.join(os.homedir(), '.codex');
+    return path.join(home, 'config.toml');
+}
+function resolveConfigPath(client, options) {
+    if (options.configPath)
+        return options.configPath;
+    const cwd = options.cwd ?? process.cwd();
+    switch (client) {
+        case 'codex':
+            return getCodexConfigPath(options.env ?? process.env);
+        case 'claude-code':
+            return getClaudeCodeMCPConfigPath(cwd);
+        case 'claude':
+        default:
+            return getClaudeMCPConfigPath();
+    }
+}
+// ---------------------------------------------------------------------------
+// Server config (shared core — unchanged contract, tests depend on this)
+// ---------------------------------------------------------------------------
+function getRagCodeCommand() {
+    // Check if ragcode is globally installed
+    try {
+        execFileSync('ragcode', ['--version'], { stdio: 'ignore' });
+        return 'ragcode';
+    }
+    catch {
+        // Fallback to npx
+        return 'npx';
+    }
+}
+export function buildMcpServerConfig(options = {}) {
+    const command = getRagCodeCommand();
+    const args = command === 'npx' ? ['ragcode-context-engine', 'mcp'] : ['mcp'];
+    const runtime = loadRuntimeConfig({ cwd: options.cwd ?? process.cwd(), env: options.env ?? process.env });
+    return {
+        command,
+        args,
+        cwd: runtime.repoRoot,
+        env: runtimeConfigToEnv(runtime, { includeSecrets: options.includeSecrets })
+    };
+}
+// ---------------------------------------------------------------------------
+// Pure merge functions (no IO — unit-testable)
+// ---------------------------------------------------------------------------
+/**
+ * Upsert the ragcode server into a JSON MCP config object (Claude Desktop / Claude Code).
+ * Unknown top-level keys and other servers are preserved. Returns a new object.
+ */
+export function mergeMcpServersJson(existing, server) {
+    const base = existing && typeof existing === 'object' ? { ...existing } : {};
+    const servers = base.mcpServers && typeof base.mcpServers === 'object'
+        ? { ...base.mcpServers }
+        : {};
+    servers[SERVER_KEY] = server;
+    return { ...base, mcpServers: servers };
+}
+/**
+ * Upsert the ragcode server into a Codex config.toml string.
+ * Parses existing TOML, sets `mcp_servers.ragcode`, and re-stringifies. Other tables and
+ * keys are preserved; TOML comments are not (smol-toml limitation — callers back up first).
+ */
+export function mergeCodexToml(existingToml, server) {
+    let root = {};
+    const trimmed = existingToml.trim();
+    if (trimmed.length > 0) {
+        const parsed = parseToml(existingToml);
+        if (parsed && typeof parsed === 'object') {
+            root = parsed;
+        }
+    }
+    const mcpServers = root.mcp_servers && typeof root.mcp_servers === 'object'
+        ? { ...root.mcp_servers }
+        : {};
+    // Codex stdio server schema: command, args, env. cwd is honored by recent Codex builds and
+    // ignored by older ones; the env values already carry absolute paths so behavior is correct
+    // either way. Drop undefined keys so the emitted TOML stays clean.
+    const entry = {
+        command: server.command,
+        args: server.args
+    };
+    if (server.cwd)
+        entry.cwd = server.cwd;
+    if (server.env && Object.keys(server.env).length > 0)
+        entry.env = server.env;
+    mcpServers[SERVER_KEY] = entry;
+    root.mcp_servers = mcpServers;
+    return stringifyToml(root);
+}
+function isJsonClient(client) {
+    return client === 'claude' || client === 'claude-code';
+}
+// ---------------------------------------------------------------------------
+// IO helpers
+// ---------------------------------------------------------------------------
+function ensureDir(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        console.log(`📁 Creating config directory: ${dir}`);
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function backupExisting(filePath) {
+    if (!fs.existsSync(filePath))
+        return;
+    const backup = `${filePath}.ragcode-backup`;
+    fs.copyFileSync(filePath, backup);
+    console.log(`🗂️  Backed up existing config to: ${backup}`);
+}
+function readFileSafe(filePath) {
+    try {
+        if (fs.existsSync(filePath))
+            return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch (err) {
+        console.warn(`⚠️  Failed to read existing config: ${err}`);
+    }
+    return undefined;
+}
+/** Detect whether a ragcode entry already exists in the on-disk config. */
+function hasExistingEntry(client, raw) {
+    if (!raw)
+        return false;
+    try {
+        if (isJsonClient(client)) {
+            const parsed = JSON.parse(raw);
+            return Boolean(parsed.mcpServers && SERVER_KEY in parsed.mcpServers);
+        }
+        const parsed = parseToml(raw);
+        return Boolean(parsed.mcp_servers && SERVER_KEY in parsed.mcp_servers);
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+export function setupMCP(options = {}) {
+    const client = options.client ?? 'claude';
+    validateClient(client);
+    if (options.print || client === 'generic') {
+        printConfig(options);
+        return;
+    }
+    const configPath = resolveConfigPath(client, options);
+    const server = buildMcpServerConfig(options);
+    const raw = readFileSafe(configPath);
+    console.log(`📍 ${clientLabel(client)} config path: ${configPath}`);
+    if (hasExistingEntry(client, raw) && !options.force) {
+        if (!process.stdin.isTTY) {
+            console.log('⚠️  RagCode is already configured here. Re-run with --force to overwrite, or remove the existing entry first.');
+            return;
+        }
+        void import('node:readline').then((readline) => {
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            rl.question('\n⚠️  RagCode is already configured. Overwrite existing entry? (y/N): ', (answer) => {
+                rl.close();
+                if (answer.trim().toLowerCase() !== 'y') {
+                    console.log('❌ Setup cancelled.');
+                    return;
+                }
+                writeClientConfig(client, configPath, raw, server);
+            });
+        });
+        return;
+    }
+    writeClientConfig(client, configPath, raw, server);
+}
+function writeClientConfig(client, configPath, raw, server) {
+    ensureDir(configPath);
+    backupExisting(configPath);
+    let contents;
+    if (isJsonClient(client)) {
+        let existing = {};
+        if (raw) {
+            try {
+                existing = JSON.parse(raw);
+            }
+            catch (err) {
+                console.warn(`⚠️  Existing config is not valid JSON; starting fresh. (${err})`);
+            }
+        }
+        contents = `${JSON.stringify(mergeMcpServersJson(existing, server), null, 2)}\n`;
+    }
+    else {
+        // codex
+        contents = mergeCodexToml(raw ?? '', server);
+    }
+    try {
+        fs.writeFileSync(configPath, contents, 'utf-8');
+    }
+    catch (err) {
+        console.error(`❌ Failed to write config: ${err}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`\n✅ RagCode MCP server configured for ${clientLabel(client)}.`);
+    console.log('\n📝 Server entry:');
+    console.log(JSON.stringify(server, null, 2));
+    if (server.env?.RAGCODE_EMBEDDING_API_KEY === '<redacted>') {
+        console.log('\n⚠️  API key was redacted. Re-run with --include-secrets to embed it, or set the key in your environment.');
+    }
+    console.log(`\n🔄 ${restartHint(client)}`);
+}
+function printConfig(options = {}) {
+    const client = options.client ?? 'generic';
+    const server = buildMcpServerConfig(options);
+    if (client === 'codex') {
+        console.log('Add this to your Codex config (~/.codex/config.toml):\n');
+        console.log(mergeCodexToml('', server));
+        return;
+    }
+    console.log('Add this to your MCP client config:\n');
+    console.log(JSON.stringify({ mcpServers: { [SERVER_KEY]: server } }, null, 2));
+}
+function clientLabel(client) {
+    switch (client) {
+        case 'claude':
+            return 'Claude Desktop';
+        case 'claude-code':
+            return 'Claude Code';
+        case 'codex':
+            return 'Codex';
+        case 'generic':
+            return 'generic MCP client';
+    }
+}
+function restartHint(client) {
+    switch (client) {
+        case 'claude':
+            return 'Restart Claude Desktop to activate the MCP server.';
+        case 'claude-code':
+            return 'Reopen the project in Claude Code (it loads .mcp.json on startup) to activate the server.';
+        case 'codex':
+            return 'Restart your Codex session to activate the MCP server.';
+        default:
+            return 'Restart your client to activate the MCP server.';
+    }
+}
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+function printHelp() {
+    console.log(`
+RagCode MCP Setup
+
+Usage:
+  ragcode setup-mcp [options]
+
+Options:
+  --config <path>    Custom config path (overrides the client default)
+  --print            Print config without writing
+  --include-secrets  Include real secrets instead of redacted placeholders
+  --client <client>  Target client: claude, claude-code, codex, or generic (default: claude)
+  --force            Overwrite an existing ragcode entry without prompting
+  --help, -h         Show this help
+
+Examples:
+  ragcode setup-mcp                          # Claude Desktop (default)
+  ragcode setup-mcp --client claude-code     # project .mcp.json for Claude Code
+  ragcode setup-mcp --client codex           # ~/.codex/config.toml
+  ragcode setup-mcp --client codex --print   # print TOML, write nothing
+  ragcode setup-mcp --config ~/custom.json   # custom path
+  `);
+}
+function parseOptions(args) {
+    const configIndex = args.indexOf('--config');
+    const clientIndex = args.indexOf('--client');
+    const client = clientIndex >= 0 ? args[clientIndex + 1] : undefined;
+    validateClient(client);
+    return {
+        print: args.includes('--print'),
+        includeSecrets: args.includes('--include-secrets'),
+        force: args.includes('--force'),
+        configPath: configIndex >= 0 ? args[configIndex + 1] : undefined,
+        client: client
+    };
+}
+function validateClient(client) {
+    if (client && !['claude', 'claude-code', 'codex', 'generic'].includes(client)) {
+        throw new Error(`Unsupported MCP client: ${client} (expected claude, claude-code, codex, or generic)`);
+    }
+}
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : undefined;
+if (invokedPath && invokedPath === fileURLToPath(import.meta.url)) {
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || args.includes('-h')) {
+        printHelp();
+        process.exit(0);
+    }
+    try {
+        setupMCP(parseOptions(args));
+    }
+    catch (error) {
+        console.error(`❌ MCP setup failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}

package/dist/src/cli/index.js

@@ -2,6 +2,7 @@
 import path from "node:path";
 import { Command } from "commander";
 import { loadDotEnv } from "../config/dotenv.js";
+import { getPackageVersion } from "../config/package-info.js";
 import { createRuntimeComponentsForRepo } from "../config/runtime-config.js";
 import { RagCodeEngine } from "../core/engine.js";
 import { runConfigureCommand } from "./configure.js";
@@ -17,7 +18,7 @@ import { setupMCP } from "../../scripts/setup-mcp.js";
 import { runUpdate } from "./update.js";
 loadDotEnv();
 const program = new Command();
-program.name("ragcode").description("Local code intelligence context engine").version("0.1.0");
+program.name("ragcode").description("Local code intelligence context engine").version(getPackageVersion());
 program
     .command("index")
     .argument("<repoRoot>")

package/dist/src/cli/update.d.ts

@@ -1,4 +1,5 @@
-export declare const PACKAGE_NAME = "ragcode-context-engine";
+import { PACKAGE_NAME } from "../config/package-info.js";
+export { PACKAGE_NAME };
 export interface UpdateOptions {
     /** Only report current vs latest; don't install. */
     checkOnly?: boolean;

package/dist/src/cli/update.js

@@ -1,27 +1,8 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { createRequire } from "node:module";
+import { getPackageVersion, PACKAGE_NAME } from "../config/package-info.js";
 const execFileAsync = promisify(execFile);
-// `ragcode update` upgrades the globally-installed CLI in place. We don't bundle an auto-updater;
-// we shell out to the package manager that owns the global install. The published package name is
-// `ragcode-context-engine` (see package.json), which is what npm/pnpm/yarn install globally.
-export const PACKAGE_NAME = "ragcode-context-engine";
-function currentVersion() {
-    // The package.json depth differs between source (src/cli/update.ts -> ../../package.json) and the
-    // built layout (dist/src/cli/update.js -> ../../../package.json), so try both rather than guessing.
-    const require = createRequire(import.meta.url);
-    for (const candidate of ["../../package.json", "../../../package.json"]) {
-        try {
-            const pkg = require(candidate);
-            if (pkg.name === PACKAGE_NAME && pkg.version)
-                return pkg.version;
-        }
-        catch {
-            // try the next candidate
-        }
-    }
-    return "unknown";
-}
+export { PACKAGE_NAME };
 // Auto-detect the package manager from the npm_config_user_agent the parent PM exposes, falling
 // back to npm. This keeps a pnpm-global install from being "updated" by npm into a broken state.
 function detectPackageManager(env = process.env) {
@@ -55,7 +36,7 @@ function installArgv(pm, spec) {
     }
 }
 export async function runUpdate(options = {}) {
-    const current = currentVersion();
+    const current = getPackageVersion();
     const pm = options.packageManager ?? detectPackageManager();
     const target = options.version ?? "latest";
     const latest = target === "latest" ? await fetchLatestVersion() : target;

package/dist/src/config/package-info.d.ts

@@ -0,0 +1,2 @@
+export declare const PACKAGE_NAME = "ragcode-context-engine";
+export declare function getPackageVersion(): string;

package/dist/src/config/package-info.js

@@ -0,0 +1,16 @@
+import { createRequire } from "node:module";
+export const PACKAGE_NAME = "ragcode-context-engine";
+export function getPackageVersion() {
+    const require = createRequire(import.meta.url);
+    for (const candidate of ["../../package.json", "../../../package.json"]) {
+        try {
+            const pkg = require(candidate);
+            if (pkg.name === PACKAGE_NAME && pkg.version)
+                return pkg.version;
+        }
+        catch {
+            // Source and built layouts have different depths; try the next candidate.
+        }
+    }
+    return "unknown";
+}

package/dist/src/mcp/server.js

@@ -1,12 +1,13 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { getPackageVersion } from "../config/package-info.js";
 import { createRuntimeComponentsForRepo } from "../config/runtime-config.js";
 import { RagCodeEngine } from "../core/engine.js";
 import { callTool, listRuntimeToolDefinitions } from "./tools.js";
 export function createMcpServer(engine, options = {}) {
     const server = new McpServer({
         name: options.name ?? "ragcode-context-engine",
-        version: options.version ?? "0.1.0"
+        version: options.version ?? getPackageVersion()
     });
     for (const tool of listRuntimeToolDefinitions()) {
         server.registerTool(tool.name, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ragcode-context-engine",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
   "description": "Local code intelligence foundation: structural code graph, LanceDB semantic layer, retrieval, context packing, and MCP tools.",
@@ -31,6 +31,7 @@
   },
   "files": [
     "dist/src",
+    "dist/scripts",
     "README.md",
     "LICENSE"
   ],