ragcode-context-engine 0.1.0

package/dist/src/cli/index.js

@@ -0,0 +1,503 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { Command } from "commander";
+import { loadDotEnv } from "../config/dotenv.js";
+import { createRuntimeComponentsForRepo } from "../config/runtime-config.js";
+import { RagCodeEngine } from "../core/engine.js";
+import { runConfigureCommand } from "./configure.js";
+import { runDoctor } from "../diagnostics/doctor.js";
+import { startStdioMcpServer } from "../mcp/server.js";
+import { buildExplainImpactReport } from "../subgraph/impact-explainer.js";
+import { expandNode, parseNodeRef } from "../subgraph/node-expander.js";
+import { FileWatchDaemon } from "../watch/watch-daemon.js";
+import { WatcherLockError, readWatcherLiveness } from "../watch/watcher-liveness.js";
+import { installWatcherService, uninstallWatcherService, watcherServiceStatus } from "../service/service-manager.js";
+import { runInitConfig } from "../../scripts/init-config.js";
+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
+    .command("index")
+    .argument("<repoRoot>")
+    .description("Index a repository")
+    .action(async (repoRoot) => {
+    if (process.stdout.isTTY) {
+        const { runIndexProgressTui } = await import("./tui/index-progress.js");
+        await runIndexProgressTui({
+            repoRoot,
+            run: async (onProgress) => withEngine(repoRoot, (engine) => engine.indexRepo(repoRoot, { onProgress }))
+        });
+        return;
+    }
+    await withEngine(repoRoot, async (engine) => {
+        const result = await engine.indexRepo(repoRoot);
+        console.log(JSON.stringify({ repoRoot: result.repoRoot, files: result.files.length, chunks: result.chunks.length }, null, 2));
+    });
+});
+program
+    .command("search")
+    .argument("<repoRoot>")
+    .argument("<query>")
+    .option("-l, --limit <number>", "maximum hits", parseNumber)
+    .description("Search an already-indexed repository without re-indexing")
+    .action(async (repoRoot, query, options) => {
+    await withEngine(repoRoot, async (engine) => {
+        const hits = await engine.searchCode({ repoRoot, query, limit: options.limit });
+        console.log(JSON.stringify(hits.map((hit) => ({ filePath: hit.chunk.filePath, startLine: hit.chunk.startLine, endLine: hit.chunk.endLine, score: hit.score, source: hit.source, reason: hit.reason })), null, 2));
+    });
+});
+program
+    .command("status")
+    .argument("<repoRoot>")
+    .description("Report persisted index and dirty watcher state without indexing")
+    .action(async (repoRoot) => {
+    await withEngine(repoRoot, async (engine) => {
+        console.log(JSON.stringify(await engine.indexStatus(repoRoot), null, 2));
+    });
+});
+program
+    .command("context")
+    .argument("<repoRoot>")
+    .argument("<query>")
+    .option("-m, --mode <mode>", "context mode: auto/debug/feature/refactor/review/explain")
+    .option("-b, --budget <chars>", "character budget", parseNumber)
+    .description("Build a context pack")
+    .action(async (repoRoot, query, options) => {
+    await withEngine(repoRoot, async (engine) => {
+        const context = await engine.getContext({ repoRoot, query, budgetChars: options.budget, mode: options.mode });
+        console.log(JSON.stringify(context, null, 2));
+    });
+});
+program
+    .command("owner")
+    .argument("<repoRoot>")
+    .argument("<query>")
+    .description("Find likely owner files and symbols")
+    .action(async (repoRoot, query) => {
+    await withEngine(repoRoot, async (engine) => {
+        console.log(JSON.stringify(await engine.findOwner(repoRoot, query), null, 2));
+    });
+});
+program
+    .command("reuse")
+    .argument("<repoRoot>")
+    .argument("<query>")
+    .option("-l, --limit <number>", "maximum candidates", parseNumber)
+    .description("Find reusable existing code before implementing new behavior")
+    .action(async (repoRoot, query, options) => {
+    await withEngine(repoRoot, async (engine) => {
+        console.log(JSON.stringify(await engine.findReuseCandidates({ repoRoot, query, limit: options.limit }), null, 2));
+    });
+});
+program
+    .command("expand-node")
+    .argument("<repoRoot>")
+    .argument("<nodeRef>")
+    .option("-e, --expansion <level>", "file_card/skeleton/focused_body/full_body")
+    .option("-b, --budget <chars>", "character budget", parseNumber)
+    .description("Expand one compact subgraph node under budget")
+    .action(async (repoRoot, nodeRef, options) => {
+    await withEngine(repoRoot, async (engine) => {
+        const parsed = parseNodeRef(nodeRef);
+        const indexedFile = await engine.explainFile(repoRoot, parsed.filePath);
+        console.log(JSON.stringify(expandNode({
+            nodeRef,
+            chunks: indexedFile.chunks,
+            symbols: indexedFile.symbols,
+            expansionLevel: options.expansion,
+            budgetChars: options.budget
+        }), null, 2));
+    });
+});
+program
+    .command("impact")
+    .argument("<repoRoot>")
+    .argument("<target>")
+    .description("Estimate structural impact for a file or symbol")
+    .action(async (repoRoot, target) => {
+    await withEngine(repoRoot, async (engine) => {
+        console.log(JSON.stringify(await engine.impactAnalysis(repoRoot, target), null, 2));
+    });
+});
+program
+    .command("explain-impact")
+    .argument("<repoRoot>")
+    .argument("<target>")
+    .option("-b, --budget <chars>", "character budget", parseNumber)
+    .option("--max-hops <number>", "maximum graph hops", parseNumber)
+    .description("Explain blast radius as a verified minimal code subgraph")
+    .action(async (repoRoot, target, options) => {
+    await withEngine(repoRoot, async (engine) => {
+        const subgraph = await engine.verifiedSubgraph({
+            repoRoot,
+            query: target,
+            seed: target,
+            mode: "impact",
+            budgetChars: options.budget,
+            maxHops: options.maxHops
+        });
+        console.log(JSON.stringify(buildExplainImpactReport(target, subgraph), null, 2));
+    });
+});
+program
+    .command("tests")
+    .argument("<repoRoot>")
+    .argument("<target>")
+    .description("Find likely related tests")
+    .action(async (repoRoot, target) => {
+    await withEngine(repoRoot, async (engine) => {
+        console.log(JSON.stringify(await engine.relatedTests(repoRoot, target), null, 2));
+    });
+});
+program
+    .command("trace-request-flow")
+    .argument("<repoRoot>")
+    .argument("<entry>")
+    .option("-q, --query <query>", "optional flow query text")
+    .option("-b, --budget <chars>", "character budget", parseNumber)
+    .option("--max-hops <number>", "maximum graph hops", parseNumber)
+    .description("Trace request/data flow as a verified ordered code subgraph")
+    .action(async (repoRoot, entry, options) => {
+    await withEngine(repoRoot, async (engine) => {
+        console.log(JSON.stringify(await engine.verifiedSubgraph({
+            repoRoot,
+            query: options.query ?? entry,
+            seed: entry,
+            mode: "flow",
+            budgetChars: options.budget,
+            maxHops: options.maxHops
+        }), null, 2));
+    });
+});
+program
+    .command("record-events")
+    .argument("<repoRoot>")
+    .argument("<filePaths...>")
+    .option("--burst-threshold <number>", "dirty file count that activates burst mode", parseNumber)
+    .option("--max-dirty-files <number>", "maximum dirty file paths to retain from one batch", parseNumber)
+    .description("Record watcher file events as dirty state without indexing immediately")
+    .action(async (repoRoot, filePaths, options) => {
+    await withEngine(repoRoot, async (engine) => {
+        console.log(JSON.stringify(await engine.recordFileEvents(repoRoot, filePaths, options), null, 2));
+    });
+});
+program
+    .command("watch")
+    .argument("<repoRoot>")
+    .option("--batch-delay <ms>", "delay before background indexing after dirty events", parseNumber)
+    .option("--quiet <ms>", "minimum quiet period before indexing", parseNumber)
+    .option("--flush-events <ms>", "delay before flushing observed file events to dirty state", parseNumber)
+    .option("--await-write <ms>", "await-write-finish stability threshold", parseNumber)
+    .option("--burst-threshold <number>", "dirty file count that activates burst mode", parseNumber)
+    .option("--max-dirty-files <number>", "maximum dirty file paths to retain from one batch", parseNumber)
+    .option("--max-batch-files <number>", "maximum dirty file paths to mark indexing in one scheduler batch", parseNumber)
+    .option("--poll", "use polling instead of native fs.watch")
+    .option("--no-auto-index", "record dirty events but do not run background refresh")
+    .option("--no-index-on-start", "fail if the repo is not already indexed instead of indexing before watching")
+    .description("Run a long-lived filesystem watcher daemon with event journal replay and background batch indexing")
+    .action(async (repoRoot, options) => {
+    const engine = buildCliEngine(repoRoot);
+    if (process.stdout.isTTY) {
+        const { createWatchStatusTui } = await import("./tui/watch-status.js");
+        const absoluteRoot = path.resolve(repoRoot);
+        let tui;
+        let shuttingDown = false;
+        const daemon = new FileWatchDaemon(engine, repoRoot, {
+            batchDelayMs: options.batchDelay,
+            minQuietMs: options.quiet,
+            flushEventsMs: options.flushEvents,
+            awaitWriteFinishMs: options.awaitWrite,
+            burstThreshold: options.burstThreshold,
+            maxDirtyFiles: options.maxDirtyFiles,
+            maxBatchFiles: options.maxBatchFiles,
+            usePolling: options.poll,
+            autoIndex: options.autoIndex,
+            indexOnStart: options.indexOnStart,
+            onStatus: (status) => tui?.update(status)
+        });
+        tui = createWatchStatusTui({
+            repoRoot: absoluteRoot,
+            running: false,
+            ready: false,
+            bufferedEvents: 0,
+            scheduler: {
+                repoRoot: absoluteRoot,
+                running: false,
+                scheduled: false,
+                indexing: false,
+                pendingFiles: 0,
+                indexingFiles: 0
+            }
+        });
+        const shutdown = async () => {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            await daemon.stop();
+            engine.close();
+            tui?.unmount();
+        };
+        const exitFromSignal = () => {
+            void shutdown().finally(() => process.exit(0));
+        };
+        process.once("SIGINT", exitFromSignal);
+        process.once("SIGTERM", exitFromSignal);
+        try {
+            await daemon.start();
+            tui.update(await daemon.status());
+            await tui.waitUntilExit();
+        }
+        catch (error) {
+            if (error instanceof WatcherLockError) {
+                // Another live watcher already owns this repo. shutdown() (guarded, runs in finally)
+                // tears down our half-started daemon and closes the engine; just surface the reason.
+                tui?.unmount();
+                console.error(`⚠️  ${error.message}`);
+                return;
+            }
+            throw error;
+        }
+        finally {
+            process.removeListener("SIGINT", exitFromSignal);
+            process.removeListener("SIGTERM", exitFromSignal);
+            await shutdown();
+        }
+        return;
+    }
+    const daemon = new FileWatchDaemon(engine, repoRoot, {
+        batchDelayMs: options.batchDelay,
+        minQuietMs: options.quiet,
+        flushEventsMs: options.flushEvents,
+        awaitWriteFinishMs: options.awaitWrite,
+        burstThreshold: options.burstThreshold,
+        maxDirtyFiles: options.maxDirtyFiles,
+        maxBatchFiles: options.maxBatchFiles,
+        usePolling: options.poll,
+        autoIndex: options.autoIndex,
+        indexOnStart: options.indexOnStart,
+        onStatus: (status) => {
+            console.error(JSON.stringify({ watcher: status }));
+        }
+    });
+    const shutdown = async () => {
+        await daemon.stop();
+        engine.close();
+    };
+    process.once("SIGINT", () => {
+        void shutdown().finally(() => process.exit(0));
+    });
+    process.once("SIGTERM", () => {
+        void shutdown().finally(() => process.exit(0));
+    });
+    try {
+        await daemon.start();
+    }
+    catch (error) {
+        if (error instanceof WatcherLockError) {
+            engine.close();
+            console.error(error.message);
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+    console.log(JSON.stringify(await daemon.status(), null, 2));
+});
+const service = program
+    .command("service")
+    .description("Manage the background watcher as an OS service (one per repo) so freshness survives reboots");
+service
+    .command("install")
+    .argument("<repoRoot>")
+    .option("--poll", "register the watcher with polling instead of native fs.watch")
+    .description("Register and start a background watcher service for this repo (systemd user / launchd / Task Scheduler)")
+    .action(async (repoRoot, options) => {
+    // Index once up front so the service can start with --no-index-on-start and not block on a full
+    // reindex at boot. Then register the OS unit. The per-repo lock (P0) makes redundant launches safe.
+    await withEngine(repoRoot, (engine) => engine.indexRepo(repoRoot));
+    try {
+        const result = await installWatcherService(repoRoot, { extraArgs: options.poll ? ["--poll"] : undefined });
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.ok)
+            process.exitCode = 1;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+});
+service
+    .command("uninstall")
+    .argument("<repoRoot>")
+    .description("Stop and remove the background watcher service for this repo")
+    .action(async (repoRoot) => {
+    try {
+        const result = await uninstallWatcherService(repoRoot);
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.ok)
+            process.exitCode = 1;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+});
+service
+    .command("status")
+    .argument("<repoRoot>")
+    .description("Report whether a watcher service is registered and whether the watcher process is alive")
+    .action(async (repoRoot) => {
+    const [registration, liveness] = await Promise.all([
+        watcherServiceStatus(repoRoot),
+        readWatcherLiveness(path.resolve(repoRoot))
+    ]);
+    console.log(JSON.stringify({ registration, liveness }, null, 2));
+});
+program
+    .command("doctor")
+    .argument("[repoRoot]")
+    .option("-q, --query <query>", "query to use when repoRoot smoke indexing is enabled")
+    .description("Check runtime dependencies, env config, MCP registration, and optional repo indexing/search smoke")
+    .action(async (repoRoot, options) => {
+    const report = await runDoctor({ repoRoot, searchQuery: options.query });
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.ok)
+        process.exitCode = 1;
+});
+program
+    .command("mcp")
+    .description("Start the RagCode MCP server over stdio")
+    .action(async () => {
+    await startStdioMcpServer();
+});
+program
+    .command("init")
+    .argument("[directory]")
+    .option("-y, --yes", "write offline-first defaults without interactive prompts")
+    .option("--defaults", "write offline-first defaults without interactive prompts")
+    .description("Initialize RagCode configuration (interactive first-run setup)")
+    .action(async (directory, options) => {
+    const targetDir = directory || process.cwd();
+    const defaults = Boolean(options.yes || options.defaults);
+    if (!defaults && process.stdin.isTTY) {
+        // Interactive first-run goes through the Ink wizard (same app as `ragcode configure`,
+        // first_run mode defaults index/setup-mcp to yes). Loaded lazily to keep --defaults light.
+        const { runInkConfigure } = await import("./configure/run.js");
+        await runInkConfigure({ repoRoot: targetDir, mode: "first_run" });
+        return;
+    }
+    await runInitConfig({ targetDir, defaults: true });
+});
+program
+    .command("setup-mcp")
+    .option("--config <path>", "Custom MCP config path")
+    .option("--print", "Print config without writing")
+    .option("--include-secrets", "Include real secrets instead of redacted placeholders")
+    .option("--client <client>", "Client format: claude (Desktop), claude-code (project .mcp.json), codex (~/.codex/config.toml), or generic")
+    .option("--force", "Overwrite an existing ragcode entry without prompting")
+    .description("Register RagCode as an MCP server for Claude Desktop, Claude Code, or Codex")
+    .action(async (options) => {
+    setupMCP({
+        configPath: options.config,
+        print: options.print,
+        includeSecrets: options.includeSecrets,
+        client: options.client,
+        force: options.force,
+        cwd: process.cwd(),
+        env: process.env
+    });
+});
+program
+    .command("configure")
+    .argument("[repoRoot]")
+    .option("--show", "Print the effective runtime config (secrets redacted) and exit")
+    .option("--graph-store <store>", "Graph store: memory or sqlite")
+    .option("--sqlite-path <path>", "SQLite graph database path")
+    .option("--semantic-store <store>", "Semantic store: memory or lancedb")
+    .option("--lancedb-uri <path>", "LanceDB storage path")
+    .option("--embedding-provider <provider>", "Embedding provider: deterministic or openai-compatible")
+    .option("--base-url <url>", "Embedding API base URL")
+    .option("--model <model>", "Embedding model name")
+    .option("--api-key <key>", "Embedding API key (persisted to .ragcode/config.json)")
+    .option("--dimensions <number>", "Embedding dimensions", parseNumber)
+    .option("--request-dimensions <bool>", "Send dimensions parameter to the provider (true/false)")
+    .description("Edit storage and embedding runtime config from the terminal, with embedding test")
+    .action(async (repoRoot, options) => {
+    await runConfigureCommand(repoRoot, {
+        show: options.show,
+        test: options.test,
+        graphStore: options.graphStore,
+        sqlitePath: options.sqlitePath,
+        semanticStore: options.semanticStore,
+        lancedbUri: options.lancedbUri,
+        embeddingProvider: options.embeddingProvider,
+        embeddingBaseUrl: options.baseUrl,
+        embeddingModel: options.model,
+        embeddingApiKey: options.apiKey,
+        embeddingDimensions: options.dimensions,
+        embeddingRequestDimensions: options.requestDimensions === undefined ? undefined : options.requestDimensions === "true"
+    });
+});
+program
+    .command("update")
+    .option("--check", "only report whether a newer version is available; don't install")
+    .option("--pm <manager>", "package manager to use: npm, pnpm, or yarn (default: auto-detect)")
+    .option("--version <version>", "install a specific version or dist-tag instead of latest")
+    .description("Update the globally-installed RagCode CLI to the latest version")
+    .action(async (options) => {
+    const result = await runUpdate({ checkOnly: options.check, packageManager: options.pm, version: options.version });
+    console.log(result.message);
+    if (!result.ok)
+        process.exitCode = 1;
+});
+program
+    .command("dashboard")
+    .description("Start the Web observability dashboard API (graph/search/context/watch observation)")
+    .action(async () => {
+    await import("../web/server.js");
+});
+program.parseAsync().catch((error) => {
+    const message = formatCliError(error);
+    console.error(message);
+    process.exitCode = 1;
+});
+async function withEngine(repoRoot, fn) {
+    const engine = buildCliEngine(repoRoot);
+    try {
+        return await fn(engine);
+    }
+    finally {
+        engine.close();
+    }
+}
+// CLI commands resolve runtime config through the shared loader so that explicit args, env,
+// .ragcode/config.json, and offline-first defaults (sqlite + lancedb + deterministic) apply
+// uniformly across CLI, MCP, Web, and doctor. The engine constructor itself stays env-driven
+// for embedded/library/test usage.
+function buildCliEngine(repoRoot) {
+    const components = createRuntimeComponentsForRepo({
+        cwd: process.cwd(),
+        overrides: repoRoot ? { repoRoot } : undefined
+    });
+    return new RagCodeEngine({
+        cwd: repoRoot,
+        graphStore: components.graphStore,
+        semanticStore: components.semanticStore,
+        embeddingProvider: components.embeddingProvider
+    });
+}
+function parseNumber(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`Invalid number: ${value}`);
+    return parsed;
+}
+function formatCliError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/Workspace is not indexed|Missing workspace|Repository is not indexed/i.test(message)) {
+        return `${message}\nRun "ragcode index <repoRoot>" first, then retry the read command. CLI reads default to SQLite at <repoRoot>/.ragcode/graph.sqlite unless RAGCODE_SQLITE_PATH is set.`;
+    }
+    return message;
+}

package/dist/src/cli/tui/index-progress.d.ts

@@ -0,0 +1,12 @@
+import type { IndexProgressEvent, RepoIndex } from "../../core/types.js";
+export interface IndexProgressAppProps {
+    repoRoot: string;
+    events: IndexProgressEvent[];
+    result?: RepoIndex;
+    error?: string;
+}
+export declare function IndexProgressApp({ repoRoot, events, result, error }: IndexProgressAppProps): React.ReactElement;
+export declare function runIndexProgressTui(options: {
+    repoRoot: string;
+    run: (onProgress: (event: IndexProgressEvent) => void) => Promise<RepoIndex>;
+}): Promise<RepoIndex>;

package/dist/src/cli/tui/index-progress.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, Box, Text } from "ink";
+export function IndexProgressApp({ repoRoot, events, result, error }) {
+    const latest = events.at(-1);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "RagCode Index" }), _jsxs(Text, { dimColor: true, children: ["repo: ", repoRoot] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [events.slice(-6).map((event, index) => (_jsxs(Text, { color: index === events.slice(-6).length - 1 && !result && !error ? "green" : undefined, children: [event.phase === "complete" ? "✓" : "•", " ", event.message, formatEventStats(event)] }, `${event.phase}-${index}`))), !latest ? _jsx(Text, { children: "\u2022 Preparing index" }) : null] }), result ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: "green", children: ["Indexed ", result.files.length, " files, ", result.chunks.length, " chunks."] }), _jsxs(Text, { dimColor: true, children: ["changed ", result.changedFiles.length, ", deleted ", result.deletedFiles.length, ", refreshed ", result.refreshedFiles?.length ?? 0] })] })) : null, error ? _jsxs(Text, { color: "red", children: ["Index failed: ", error] }) : null] }));
+}
+export async function runIndexProgressTui(options) {
+    const events = [];
+    let result;
+    let error;
+    const app = render(_jsx(IndexProgressApp, { repoRoot: options.repoRoot, events: events }));
+    const update = () => {
+        app.rerender(_jsx(IndexProgressApp, { repoRoot: options.repoRoot, events: [...events], result: result, error: error }));
+    };
+    try {
+        result = await options.run((event) => {
+            events.push(event);
+            update();
+        });
+        update();
+        return result;
+    }
+    catch (caught) {
+        error = caught instanceof Error ? caught.message : String(caught);
+        update();
+        throw caught;
+    }
+    finally {
+        app.unmount();
+    }
+}
+function formatEventStats(event) {
+    const parts = [];
+    if (event.scannedFiles !== undefined)
+        parts.push(`scanned ${event.scannedFiles}`);
+    if (event.changedFiles !== undefined)
+        parts.push(`changed ${event.changedFiles}`);
+    if (event.deletedFiles !== undefined)
+        parts.push(`deleted ${event.deletedFiles}`);
+    if (event.refreshedFiles !== undefined)
+        parts.push(`refreshed ${event.refreshedFiles}`);
+    if (event.chunks !== undefined)
+        parts.push(`chunks ${event.chunks}`);
+    if (event.symbols !== undefined)
+        parts.push(`symbols ${event.symbols}`);
+    if (event.edges !== undefined)
+        parts.push(`edges ${event.edges}`);
+    return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}

package/dist/src/cli/tui/watch-status.d.ts

@@ -0,0 +1,10 @@
+import type { WatchDaemonStatus } from "../../watch/watch-daemon.js";
+export interface WatchStatusAppProps {
+    status: WatchDaemonStatus;
+}
+export declare function WatchStatusApp({ status }: WatchStatusAppProps): React.ReactElement;
+export declare function createWatchStatusTui(initialStatus: WatchDaemonStatus): {
+    update(status: WatchDaemonStatus): void;
+    waitUntilExit(): Promise<void>;
+    unmount(): void;
+};

package/dist/src/cli/tui/watch-status.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, Box, Text, useApp, useInput } from "ink";
+export function WatchStatusApp({ status }) {
+    const { exit } = useApp();
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === "c"))
+            exit();
+    });
+    const scheduler = status.scheduler;
+    const healthColor = scheduler.lastError ? "red" : status.ready ? "green" : "yellow";
+    const health = scheduler.lastError ? "error" : status.ready ? "ready" : "starting";
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "RagCode Watch" }), _jsxs(Text, { dimColor: true, children: ["repo: ", status.repoRoot] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Status: ", _jsx(Text, { color: healthColor, children: health }), " ", status.running ? "running" : "stopped"] }), _jsxs(Text, { children: ["Events: buffered ", status.bufferedEvents, ", pending ", scheduler.pendingFiles, ", indexing ", scheduler.indexingFiles] }), _jsxs(Text, { children: ["Scheduler: ", scheduler.running ? "running" : "stopped", ", ", scheduler.scheduled ? "scheduled" : "idle", ", ", scheduler.indexing ? "indexing" : "not indexing"] }), _jsxs(Text, { children: ["Last indexed: ", scheduler.lastIndexedAtMs ? new Date(scheduler.lastIndexedAtMs).toLocaleString() : "never in this session"] }), scheduler.lastError ? _jsxs(Text, { color: "red", children: ["Last error: ", scheduler.lastError] }) : null] }), _jsx(Text, { dimColor: true, children: "Ctrl+C or Esc to stop" })] }));
+}
+export function createWatchStatusTui(initialStatus) {
+    const app = render(_jsx(WatchStatusApp, { status: initialStatus }));
+    return {
+        update(status) {
+            app.rerender(_jsx(WatchStatusApp, { status: status }));
+        },
+        async waitUntilExit() {
+            await app.waitUntilExit();
+        },
+        unmount() {
+            app.unmount();
+        }
+    };
+}

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

@@ -0,0 +1,18 @@
+export declare const PACKAGE_NAME = "ragcode-context-engine";
+export interface UpdateOptions {
+    /** Only report current vs latest; don't install. */
+    checkOnly?: boolean;
+    /** Override the package manager (npm/pnpm/yarn). Defaults to auto-detect. */
+    packageManager?: string;
+    /** Override the dist-tag/version to install. Defaults to "latest". */
+    version?: string;
+}
+export interface UpdateResult {
+    ok: boolean;
+    currentVersion: string;
+    latestVersion?: string;
+    upToDate: boolean;
+    installed: boolean;
+    message: string;
+}
+export declare function runUpdate(options?: UpdateOptions): Promise<UpdateResult>;