ragcode-context-engine 0.1.0

package/dist/src/lsp/typescript-language-service.js

@@ -0,0 +1,82 @@
+import path from "node:path";
+import ts from "typescript";
+import { normalizeRepoPath } from "../utils/path.js";
+export class TypeScriptLanguageService {
+    repoRoot;
+    service;
+    absoluteByRepoPath = new Map();
+    contentByAbsolutePath = new Map();
+    constructor(repoRoot, sources) {
+        this.repoRoot = repoRoot;
+        for (const source of sources) {
+            const absolutePath = normalizeAbsolutePath(source.absolutePath);
+            this.absoluteByRepoPath.set(source.filePath, absolutePath);
+            this.contentByAbsolutePath.set(absolutePath, source.content);
+        }
+        this.service = ts.createLanguageService(this.createHost());
+    }
+    getDefinitionAt(repoFilePath, position) {
+        const absolutePath = this.absoluteByRepoPath.get(repoFilePath);
+        if (!absolutePath)
+            return [];
+        const definitions = this.service.getDefinitionAtPosition(absolutePath, position) ?? [];
+        return definitions
+            .map((definition) => this.toDefinitionLocation(definition))
+            .filter((definition) => Boolean(definition));
+    }
+    createHost() {
+        return {
+            getCompilationSettings: () => ({
+                allowJs: true,
+                checkJs: false,
+                esModuleInterop: true,
+                jsx: ts.JsxEmit.Preserve,
+                module: ts.ModuleKind.NodeNext,
+                moduleResolution: ts.ModuleResolutionKind.NodeNext,
+                noEmit: true,
+                skipLibCheck: true,
+                target: ts.ScriptTarget.ES2022
+            }),
+            getCurrentDirectory: () => this.repoRoot,
+            getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+            getScriptFileNames: () => [...this.contentByAbsolutePath.keys()],
+            getScriptVersion: () => "1",
+            getScriptSnapshot: (fileName) => {
+                const normalized = normalizeAbsolutePath(fileName);
+                const content = this.contentByAbsolutePath.get(normalized) ?? ts.sys.readFile(normalized);
+                return content === undefined ? undefined : ts.ScriptSnapshot.fromString(content);
+            },
+            fileExists: (fileName) => this.contentByAbsolutePath.has(normalizeAbsolutePath(fileName)) || ts.sys.fileExists(fileName),
+            readFile: (fileName) => this.contentByAbsolutePath.get(normalizeAbsolutePath(fileName)) ?? ts.sys.readFile(fileName),
+            readDirectory: ts.sys.readDirectory,
+            directoryExists: ts.sys.directoryExists,
+            getDirectories: ts.sys.getDirectories
+        };
+    }
+    toDefinitionLocation(definition) {
+        const absolutePath = normalizeAbsolutePath(definition.fileName);
+        const content = this.contentByAbsolutePath.get(absolutePath);
+        if (!content)
+            return undefined;
+        const start = lineAt(content, definition.textSpan.start);
+        const end = lineAt(content, definition.textSpan.start + definition.textSpan.length);
+        return {
+            filePath: normalizeRepoPath(this.repoRoot, absolutePath),
+            startLine: start,
+            endLine: end,
+            name: definition.name
+        };
+    }
+}
+function normalizeAbsolutePath(filePath) {
+    return path.resolve(filePath);
+}
+function lineAt(content, position) {
+    const safePosition = Math.max(0, Math.min(position, content.length));
+    let line = 1;
+    for (let index = 0; index < safePosition; index += 1) {
+        if (content.charCodeAt(index) === 10)
+            line += 1;
+    }
+    return line;
+}

package/dist/src/mcp/server.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ContextEngine } from "../core/contracts.js";
+import { type RagCodeEngineOptions } from "../core/engine.js";
+export interface McpServerOptions {
+    name?: string;
+    version?: string;
+}
+export interface StdioMcpServerOptions extends McpServerOptions, RagCodeEngineOptions {
+}
+export declare function createMcpServer(engine: ContextEngine, options?: McpServerOptions): McpServer;
+export declare function startStdioMcpServer(options?: StdioMcpServerOptions): Promise<void>;

package/dist/src/mcp/server.js

@@ -0,0 +1,64 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.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"
+    });
+    for (const tool of listRuntimeToolDefinitions()) {
+        server.registerTool(tool.name, {
+            title: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema
+        }, async (args) => ({
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(await callTool(engine, tool.name, args), null, 2)
+                }
+            ]
+        }));
+    }
+    return server;
+}
+export async function startStdioMcpServer(options = {}) {
+    // Entry points resolve runtime config through the shared loader (CLI args > env >
+    // .ragcode/config.json > offline-first defaults). The engine constructor itself stays
+    // env-driven so embedded/library/test usage keeps its lightweight in-memory defaults.
+    const components = (options.graphStore && options.semanticStore && options.embeddingProvider)
+        ? undefined
+        : createRuntimeComponentsForRepo({ cwd: options.cwd, env: options.env });
+    const engine = new RagCodeEngine({
+        ...options,
+        graphStore: options.graphStore ?? components?.graphStore,
+        semanticStore: options.semanticStore ?? components?.semanticStore,
+        embeddingProvider: options.embeddingProvider ?? components?.embeddingProvider
+    });
+    const server = createMcpServer(engine, options);
+    const transport = new StdioServerTransport();
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        try {
+            await server.close();
+        }
+        finally {
+            engine.close();
+        }
+    };
+    process.once("SIGINT", () => {
+        void close().finally(() => process.exit(0));
+    });
+    process.once("SIGTERM", () => {
+        void close().finally(() => process.exit(0));
+    });
+    process.once("exit", () => {
+        engine.close();
+    });
+    await server.connect(transport);
+}

package/dist/src/mcp/tools.d.ts

@@ -0,0 +1,266 @@
+import { z } from "zod";
+import type { ContextEngine } from "../core/contracts.js";
+export declare const ToolNameSchema: z.ZodEnum<{
+    index_repo: "index_repo";
+    refresh_index: "refresh_index";
+    index_status: "index_status";
+    watch_status: "watch_status";
+    record_file_events: "record_file_events";
+    search_code: "search_code";
+    get_context: "get_context";
+    topology_map: "topology_map";
+    find_symbol: "find_symbol";
+    explain_file: "explain_file";
+    expand_node: "expand_node";
+    find_owner: "find_owner";
+    find_reuse_candidates: "find_reuse_candidates";
+    impact_analysis: "impact_analysis";
+    explain_impact: "explain_impact";
+    related_tests: "related_tests";
+    trace_flow: "trace_flow";
+    trace_request_flow: "trace_request_flow";
+    review_diff: "review_diff";
+}>;
+export type ToolName = z.infer<typeof ToolNameSchema>;
+export declare const IndexRepoInput: z.ZodObject<{
+    repoRoot: z.ZodString;
+}, z.core.$strip>;
+export declare const ContextModeSchema: z.ZodEnum<{
+    auto: "auto";
+    debug: "debug";
+    feature: "feature";
+    refactor: "refactor";
+    review: "review";
+    explain: "explain";
+}>;
+export declare const ExpansionLevelSchema: z.ZodEnum<{
+    file_card: "file_card";
+    skeleton: "skeleton";
+    focused_body: "focused_body";
+    full_body: "full_body";
+}>;
+export declare const SubgraphOutputPresetSchema: z.ZodEnum<{
+    compact: "compact";
+    agent_edit: "agent_edit";
+    debug_trace: "debug_trace";
+    review_risk: "review_risk";
+}>;
+export declare const WorkspaceHintInput: z.ZodOptional<z.ZodObject<{
+    root: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const RefreshIndexInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const IndexStatusInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const WatchStatusInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const RecordFileEventsInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    filePaths: z.ZodArray<z.ZodString>;
+    burstThreshold: z.ZodOptional<z.ZodNumber>;
+    maxDirtyFiles: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const SearchCodeInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        debug: "debug";
+        feature: "feature";
+        refactor: "refactor";
+        review: "review";
+        explain: "explain";
+    }>>;
+}, z.core.$strip>;
+export declare const GetContextInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        debug: "debug";
+        feature: "feature";
+        refactor: "refactor";
+        review: "review";
+        explain: "explain";
+    }>>;
+    budgetChars: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const TopologyMapInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        debug: "debug";
+        feature: "feature";
+        refactor: "refactor";
+        review: "review";
+        explain: "explain";
+    }>>;
+    budgetChars: z.ZodOptional<z.ZodNumber>;
+    maxEdges: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const FindSymbolInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const ExplainFileInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    filePath: z.ZodString;
+}, z.core.$strip>;
+export declare const ExpandNodeInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    nodeRef: z.ZodString;
+    expansionLevel: z.ZodOptional<z.ZodEnum<{
+        file_card: "file_card";
+        skeleton: "skeleton";
+        focused_body: "focused_body";
+        full_body: "full_body";
+    }>>;
+    budgetChars: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const FindOwnerInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const FindReuseCandidatesInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    reuseGuard: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ImpactAnalysisInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    target: z.ZodString;
+}, z.core.$strip>;
+export declare const ExplainImpactInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    target: z.ZodString;
+    budgetChars: z.ZodOptional<z.ZodNumber>;
+    maxHops: z.ZodOptional<z.ZodNumber>;
+    preset: z.ZodOptional<z.ZodEnum<{
+        compact: "compact";
+        agent_edit: "agent_edit";
+        debug_trace: "debug_trace";
+        review_risk: "review_risk";
+    }>>;
+}, z.core.$strip>;
+export declare const RelatedTestsInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    target: z.ZodString;
+}, z.core.$strip>;
+export declare const TraceFlowInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    entry: z.ZodString;
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const TraceRequestFlowInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    entry: z.ZodString;
+    query: z.ZodOptional<z.ZodString>;
+    budgetChars: z.ZodOptional<z.ZodNumber>;
+    maxHops: z.ZodOptional<z.ZodNumber>;
+    preset: z.ZodOptional<z.ZodEnum<{
+        compact: "compact";
+        agent_edit: "agent_edit";
+        debug_trace: "debug_trace";
+        review_risk: "review_risk";
+    }>>;
+}, z.core.$strip>;
+export declare const ReviewDiffInput: z.ZodObject<{
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    diff: z.ZodOptional<z.ZodString>;
+    changedFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export interface McpToolDefinition {
+    name: ToolName;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface McpRuntimeToolDefinition {
+    name: ToolName;
+    description: string;
+    inputSchema: z.ZodType;
+}
+export declare function listToolDefinitions(): McpToolDefinition[];
+export declare function listRuntimeToolDefinitions(): McpRuntimeToolDefinition[];
+export declare function callTool(engine: ContextEngine, name: ToolName, rawInput: unknown): Promise<unknown>;