ragcode-context-engine 0.1.0

package/dist/src/cli/configure/state.js

@@ -0,0 +1,174 @@
+export function createWizardState(mode, repoRoot, current) {
+    const steps = [
+        {
+            key: "graphStore",
+            kind: "select",
+            title: "Graph store",
+            options: [
+                { value: "sqlite", label: "sqlite (persistent, recommended)" },
+                { value: "memory", label: "memory (ephemeral)" }
+            ],
+            defaultValue: current.graphStore
+        },
+        {
+            key: "semanticStore",
+            kind: "select",
+            title: "Semantic store",
+            options: [
+                { value: "lancedb", label: "lancedb (persistent vectors, recommended)" },
+                { value: "memory", label: "memory (ephemeral)" }
+            ],
+            defaultValue: current.semanticStore
+        },
+        {
+            key: "embeddingProvider",
+            kind: "select",
+            title: "Embedding provider",
+            options: [
+                { value: "deterministic", label: "deterministic (offline, no API key)" },
+                { value: "openai-compatible", label: "openai-compatible (better recall, needs API key)" }
+            ],
+            defaultValue: current.embeddingProvider
+        },
+        {
+            key: "embeddingBaseUrl",
+            kind: "text",
+            title: "Embedding base URL",
+            defaultValue: current.embeddingBaseUrl ?? "https://api.openai.com/v1",
+            skip: (answers) => answers.embeddingProvider !== "openai-compatible"
+        },
+        {
+            key: "embeddingModel",
+            kind: "text",
+            title: "Embedding model",
+            defaultValue: current.embeddingModel ?? "text-embedding-3-small",
+            skip: (answers) => answers.embeddingProvider !== "openai-compatible"
+        },
+        {
+            key: "embeddingApiKey",
+            kind: "text",
+            title: current.embeddingApiKey === "set" ? "Embedding API key (Enter keeps existing)" : "Embedding API key",
+            defaultValue: "",
+            secret: true,
+            skip: (answers) => answers.embeddingProvider !== "openai-compatible"
+        },
+        {
+            key: "embeddingDimensions",
+            kind: "text",
+            title: "Embedding dimensions (empty = provider default)",
+            defaultValue: current.embeddingDimensions !== undefined ? String(current.embeddingDimensions) : "",
+            skip: (answers) => answers.embeddingProvider !== "openai-compatible"
+        },
+        {
+            key: "embeddingRequestDimensions",
+            kind: "confirm",
+            title: "Send the dimensions parameter to the provider?",
+            defaultValue: current.embeddingRequestDimensions ? "yes" : "no",
+            skip: (answers) => answers.embeddingProvider !== "openai-compatible" || !answers.embeddingDimensions
+        },
+        {
+            key: "testEmbedding",
+            kind: "confirm",
+            title: "Test the embedding provider now?",
+            defaultValue: "yes"
+        },
+        {
+            key: "save",
+            kind: "confirm",
+            title: "Save this configuration to .ragcode/config.json?",
+            defaultValue: "yes"
+        },
+        {
+            key: "indexNow",
+            kind: "confirm",
+            title: "Index the repository now?",
+            defaultValue: mode === "first_run" ? "yes" : "no",
+            skip: (answers) => answers.save !== "yes"
+        },
+        {
+            key: "setupMcp",
+            kind: "confirm",
+            title: "Register the MCP server for your agent client now?",
+            defaultValue: mode === "first_run" ? "yes" : "no",
+            skip: (answers) => answers.save !== "yes"
+        },
+        {
+            key: "installWatcherService",
+            kind: "confirm",
+            // Without this, freshness silently depends on a long-lived `ragcode watch` nobody starts.
+            // Installing the OS service is what actually closes the onboarding loop.
+            title: "Enable a background watcher service so the index stays fresh automatically?",
+            defaultValue: mode === "first_run" ? "yes" : "no",
+            skip: (answers) => answers.save !== "yes"
+        }
+    ];
+    return {
+        mode,
+        repoRoot,
+        steps,
+        stepIndex: firstActiveStep(steps, {}, 0),
+        answers: {},
+        done: false,
+        cancelled: false
+    };
+}
+export function currentStep(state) {
+    return state.done || state.cancelled ? undefined : state.steps[state.stepIndex];
+}
+// Records the answer for the current step and advances past any steps whose skip()
+// predicate now holds. An empty answer falls back to the step's default.
+export function answerCurrentStep(state, rawValue) {
+    const step = currentStep(state);
+    if (!step)
+        return state;
+    const value = rawValue.trim() === "" ? step.defaultValue : rawValue.trim();
+    const answers = { ...state.answers, [step.key]: value };
+    const nextIndex = firstActiveStep(state.steps, answers, state.stepIndex + 1);
+    return {
+        ...state,
+        answers,
+        stepIndex: nextIndex,
+        done: nextIndex >= state.steps.length
+    };
+}
+export function cancelWizard(state) {
+    return { ...state, cancelled: true };
+}
+export function wizardResult(state) {
+    if (!state.done || state.cancelled)
+        return undefined;
+    const answers = state.answers;
+    const updates = {
+        graphStore: answers.graphStore,
+        semanticStore: answers.semanticStore,
+        embeddingProvider: answers.embeddingProvider
+    };
+    if (answers.embeddingProvider === "openai-compatible") {
+        if (answers.embeddingBaseUrl)
+            updates.embeddingBaseUrl = answers.embeddingBaseUrl;
+        if (answers.embeddingModel)
+            updates.embeddingModel = answers.embeddingModel;
+        if (answers.embeddingApiKey)
+            updates.embeddingApiKey = answers.embeddingApiKey;
+        if (answers.embeddingDimensions)
+            updates.embeddingDimensions = Number(answers.embeddingDimensions);
+        if (answers.embeddingRequestDimensions)
+            updates.embeddingRequestDimensions = answers.embeddingRequestDimensions === "yes";
+    }
+    return {
+        updates,
+        actions: {
+            testEmbedding: answers.testEmbedding === "yes",
+            save: answers.save === "yes",
+            indexNow: answers.indexNow === "yes",
+            setupMcp: answers.setupMcp === "yes",
+            installWatcherService: answers.installWatcherService === "yes"
+        }
+    };
+}
+function firstActiveStep(steps, answers, from) {
+    let index = from;
+    while (index < steps.length && steps[index].skip?.(answers))
+        index += 1;
+    return index;
+}

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

@@ -0,0 +1,31 @@
+import { type RedactedRuntimeConfig } from "../config/runtime-config.js";
+import { type EmbeddingTestResult } from "../diagnostics/embedding-test.js";
+export interface ConfigureUpdates {
+    graphStore?: string;
+    sqlitePath?: string;
+    semanticStore?: string;
+    lancedbUri?: string;
+    embeddingProvider?: string;
+    embeddingBaseUrl?: string;
+    embeddingModel?: string;
+    embeddingApiKey?: string;
+    embeddingDimensions?: number;
+    embeddingRequestDimensions?: boolean;
+}
+export interface ConfigureResult {
+    configPath: string;
+    config: RedactedRuntimeConfig;
+    embeddingTest?: EmbeddingTestResult;
+}
+export declare function applyConfigureUpdates(options: {
+    repoRoot: string;
+    updates: ConfigureUpdates;
+    env?: NodeJS.ProcessEnv;
+    testEmbedding?: boolean;
+}): Promise<ConfigureResult>;
+export interface ConfigureCommandOptions extends ConfigureUpdates {
+    show?: boolean;
+    test?: boolean;
+    yes?: boolean;
+}
+export declare function runConfigureCommand(repoRootArg: string | undefined, options: ConfigureCommandOptions): Promise<void>;

package/dist/src/cli/configure.js

@@ -0,0 +1,101 @@
+import { loadRuntimeConfig, readRuntimeConfigFile, redactRuntimeConfig, writeRuntimeConfigFile } from "../config/runtime-config.js";
+import { testEmbeddingForConfig } from "../diagnostics/embedding-test.js";
+// Non-interactive core of `ragcode configure`: merge updates into .ragcode/config.json,
+// then re-resolve the effective config through the shared loader. Returns redacted output
+// so callers never see the API key back. Kept UI-free so tests and a future Ink app can
+// drive it directly.
+export async function applyConfigureUpdates(options) {
+    const env = options.env ?? process.env;
+    const existingPath = loadRuntimeConfig({ cwd: options.repoRoot, env, overrides: { repoRoot: options.repoRoot } }).configPath;
+    const merged = mergeConfigFile(readRuntimeConfigFile(existingPath), options.updates);
+    const configPath = writeRuntimeConfigFile(options.repoRoot, merged);
+    const effective = loadRuntimeConfig({ cwd: options.repoRoot, env, overrides: { repoRoot: options.repoRoot } });
+    const embeddingTest = options.testEmbedding ? await testEmbeddingForConfig(effective) : undefined;
+    return { configPath, config: redactRuntimeConfig(effective), embeddingTest };
+}
+function mergeConfigFile(existing, updates) {
+    const merged = { ...existing };
+    if (updates.graphStore !== undefined)
+        merged.graphStore = updates.graphStore;
+    if (updates.sqlitePath !== undefined)
+        merged.sqlitePath = updates.sqlitePath;
+    if (updates.semanticStore !== undefined)
+        merged.semanticStore = updates.semanticStore;
+    if (updates.lancedbUri !== undefined)
+        merged.lancedbUri = updates.lancedbUri;
+    if (updates.embeddingProvider !== undefined)
+        merged.embeddingProvider = updates.embeddingProvider === "openai" ? "openai-compatible" : updates.embeddingProvider;
+    if (updates.embeddingBaseUrl !== undefined)
+        merged.embeddingBaseUrl = updates.embeddingBaseUrl;
+    if (updates.embeddingModel !== undefined)
+        merged.embeddingModel = updates.embeddingModel;
+    if (updates.embeddingApiKey !== undefined)
+        merged.embeddingApiKey = updates.embeddingApiKey;
+    if (updates.embeddingDimensions !== undefined)
+        merged.embeddingDimensions = updates.embeddingDimensions;
+    if (updates.embeddingRequestDimensions !== undefined)
+        merged.embeddingRequestDimensions = updates.embeddingRequestDimensions;
+    return merged;
+}
+export async function runConfigureCommand(repoRootArg, options) {
+    const repoRoot = repoRootArg ?? process.cwd();
+    const hasEditFlags = configureUpdateKeys.some((key) => options[key] !== undefined);
+    if (options.show || (!hasEditFlags && !options.test && !process.stdin.isTTY)) {
+        const effective = loadRuntimeConfig({ cwd: repoRoot, overrides: { repoRoot } });
+        console.log(JSON.stringify(redactRuntimeConfig(effective), null, 2));
+        return;
+    }
+    if (options.test && !hasEditFlags) {
+        const effective = loadRuntimeConfig({ cwd: repoRoot, overrides: { repoRoot } });
+        printEmbeddingTest(await testEmbeddingForConfig(effective));
+        return;
+    }
+    if (!hasEditFlags) {
+        // Interactive path: the Ink wizard (loaded lazily so flag-driven runs never pull in
+        // ink/react). It collects answers via the state machine and executes test/save/index/
+        // setup-mcp itself.
+        const { runInkConfigure } = await import("./configure/run.js");
+        await runInkConfigure({ repoRoot, mode: "configure" });
+        return;
+    }
+    const updates = pickUpdates(options);
+    const result = await applyConfigureUpdates({
+        repoRoot,
+        updates,
+        testEmbedding: options.test ?? true
+    });
+    console.log(`✅ Configuration saved to: ${result.configPath}`);
+    console.log(JSON.stringify(result.config, null, 2));
+    if (result.embeddingTest)
+        printEmbeddingTest(result.embeddingTest);
+}
+const configureUpdateKeys = [
+    "graphStore",
+    "sqlitePath",
+    "semanticStore",
+    "lancedbUri",
+    "embeddingProvider",
+    "embeddingBaseUrl",
+    "embeddingModel",
+    "embeddingApiKey",
+    "embeddingDimensions",
+    "embeddingRequestDimensions"
+];
+function pickUpdates(options) {
+    const updates = {};
+    for (const key of configureUpdateKeys) {
+        if (options[key] !== undefined)
+            updates[key] = options[key];
+    }
+    return updates;
+}
+function printEmbeddingTest(result) {
+    if (result.ok) {
+        console.log(`🧪 Embedding test OK: provider=${result.provider}${result.model ? ` model=${result.model}` : ""} dimensions=${result.dimensions} latency=${result.latencyMs}ms`);
+        return;
+    }
+    console.log(`🧪 Embedding test FAILED (${result.failure?.kind}): ${result.failure?.message}`);
+    if (result.provider === "openai-compatible") {
+        console.log("   Fix the provider settings with `ragcode configure`, or fall back to the offline deterministic provider.");
+    }
+}

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};