@imenam/mcp-documentor 1.0.85 → 1.0.87

package/dist/src/gui-worker.js

@@ -197,7 +197,15 @@ function setupIpcErrorHandlers() {
             });
             return;
         }
-        if (msg && (msg.type === "INITIAL_STATE" || msg.type === "CONFIG_UPDATED" || msg.type === "BUNDLES_UPDATED")) {
+        const BROADCAST_TYPES = [
+            "INITIAL_STATE",
+            "CONFIG_UPDATED",
+            "BUNDLES_UPDATED",
+            "PROJECTS_CHANGED",
+            "DOCS_CHANGED",
+            "CODE_SOURCES_CHANGED",
+        ];
+        if (msg && BROADCAST_TYPES.includes(msg.type)) {
             for (const controller of sseControllers) {
                 try {
                     controller.writeSSE({ data: JSON.stringify(msg), event: "message" });
@@ -217,6 +225,8 @@ const READ_ONLY_WRITE_ROUTES = [
     { method: "POST", prefix: "/api/images" },
     { method: "POST", prefix: "/api/configurations/apply" },
     { method: "POST", prefix: "/api/sync" },
+    { method: "POST", prefix: "/api/code-sources/apply" },
+    { method: "POST", prefix: "/api/code-roots/apply" },
 ];
 app.use("*", async (c, next) => {
     if (isReadOnly()) {
@@ -359,6 +369,64 @@ app.post("/api/sync", async (c) => {
         return c.json({ error: result.error }, 500);
     return c.json(result.data);
 });
+// --- Code sources ---
+/** Relays one IPC request and answers with its data, or with its error and `errorStatus`. */
+async function relay(c, type, data, timeout, errorStatus = 500) {
+    const result = await ipcRequest(type, data, timeout);
+    if (result.error)
+        return c.json({ error: result.error }, errorStatus);
+    return c.json(result.data);
+}
+async function readJson(c) {
+    try {
+        return await c.req.json();
+    }
+    catch {
+        return {};
+    }
+}
+// GitHub projects are checked against their branch: one API round trip each.
+app.get("/api/code-sources", (c) => relay(c, "LIST_CODE_SOURCES", {}, 30000));
+app.post("/api/code-sources/inspect", async (c) => {
+    const { repo, branch } = await readJson(c);
+    if (!repo)
+        return c.json({ error: "repo is required" }, 400);
+    return relay(c, "INSPECT_REPOSITORY", { repo, branch }, 30000);
+});
+// Reads every tracked file of the project at the previewed source.
+// `codeRoot`: omitted keeps the project's root, "" means the machine default, else the project's own.
+app.post("/api/code-sources/preview", async (c) => {
+    const { project, config, codeRoot } = await readJson(c);
+    if (!project || !config)
+        return c.json({ error: "project and config are required" }, 400);
+    return relay(c, "PREVIEW_CODE_SOURCE", { project, config, codeRoot }, 120000, 400);
+});
+app.post("/api/code-sources/apply", async (c) => {
+    const { project, config, codeRoot } = await readJson(c);
+    if (!project || !config)
+        return c.json({ error: "project and config are required" }, 400);
+    return relay(c, "SAVE_CODE_SOURCE", { project, config, codeRoot }, 10000, 400);
+});
+app.get("/api/code-roots", (c) => relay(c, "GET_CODE_ROOTS", {}, 5000));
+app.post("/api/code-sources/search", async (c) => {
+    const { query } = await readJson(c);
+    return relay(c, "SEARCH_REPOSITORIES", { query: query ?? "" }, 15000);
+});
+app.post("/api/code-roots/inspect", async (c) => {
+    const { path: root } = await readJson(c);
+    return relay(c, "INSPECT_CODE_ROOT", { path: root ?? "" }, 5000);
+});
+// Without a project, sets the machine default root. An empty path removes the root.
+app.post("/api/code-roots/apply", async (c) => {
+    const { path: root, project } = await readJson(c);
+    if (typeof root !== "string")
+        return c.json({ error: "path is required" }, 400);
+    return relay(c, "SET_CODE_ROOT", { path: root, project }, 5000, 400);
+});
+// The token is read from MCP_DOCUMENTOR_CODE_TOKEN only: the GUI shows its status, never sets it.
+app.get("/api/github-token", (c) => relay(c, "GET_GITHUB_TOKEN", {}, 15000));
+app.get("/api/code-source-migration", (c) => relay(c, "GET_CODE_SOURCE_MIGRATION", {}, 5000));
+app.post("/api/code-source-migration/ack", (c) => relay(c, "ACK_CODE_SOURCE_MIGRATION", {}, 5000));
 app.get("/api/projects", async (c) => {
     const result = await ipcRequest("LIST_PROJECTS");
     if (result.error)
@@ -575,7 +643,7 @@ app.get("/api/export-zip/:id", async (c) => {
             docId = ref;
         }
         else {
-            zip.file(`${ref}.md`, `# [Unqualified doc reference: ${ref} — no project given]
+            zip.file(`${ref}.md`, `# [Unqualified doc reference: ${ref} — no project given]
 `);
             continue;
         }

package/dist/src/index.js

@@ -20,7 +20,12 @@ import { searchDocs } from "./tools/search-docs.js";
 import { checkFreshness, computeFreshness, DOC_CONCURRENCY } from "./tools/check-freshness.js";
 import { mapWithConcurrency } from "./core/concurrency.js";
 import { findAndHashSection } from "./core/section-tracker.js";
-import { getCodeSource } from "./core/code-source.js";
+import { getCodeSource, invalidateCodeSources, setCodeSourceProvider } from "./core/code-source.js";
+import { readCodeSourceConfig } from "./core/project-settings.js";
+import { LocalState } from "./core/local-state.js";
+import { migrateCodeSources } from "./core/migrate-code-sources.js";
+import { setCodeRootProvider } from "./core/path-resolver.js";
+import { getCodeSourceTool, getGitHubTokenStatus, GITHUB_TOKEN_VAR, inspectCodeRoot, inspectRepository, listCodeSources, previewCodeSource, saveCodeSource, searchRepositoriesForInput, setCodeRoot, setCodeRootTool, setCodeSourceTool, } from "./tools/code-sources.js";
 import { runInCodeOperation } from "./core/code-operation.js";
 import { listProjects } from "./tools/list-projects.js";
 import { refreshFileSnapshot } from "./tools/refresh-file-snapshot.js";
@@ -98,6 +103,12 @@ const historyStore = new HistoryStore();
 historyStore.init(storageEngine.getDataDir());
 storageEngine.setHistoryStore(historyStore);
 const syncEngine = new SyncEngine(storageEngine);
+const localState = new LocalState(storageEngine.getDataDir());
+setCodeRootProvider((project) => localState.getCodeRoot(project));
+setCodeSourceProvider({
+    codeSourceConfig: (project) => readCodeSourceConfig(storageEngine.getProjectDir(project)),
+    githubToken: () => process.env[GITHUB_TOKEN_VAR]?.trim() || undefined,
+});
 const server = new Server({ name: "mcp-documentor", version: APP_VERSION }, { capabilities: { tools: {} } });
 let guiLauncher;
 let guiStatus = "disabled";
@@ -189,6 +200,44 @@ function dispatchIPCMessage(msg) {
     else if (msg.type === "SYNC_DOCS") {
         handleSyncDocsIPC(msg);
     }
+    else if (msg.type === "LIST_CODE_SOURCES") {
+        replyToGUI(msg, "LIST_CODE_SOURCES_RESPONSE", async () => ({ projects: await listCodeSources(storageEngine, localState) }));
+    }
+    else if (msg.type === "INSPECT_REPOSITORY") {
+        replyToGUI(msg, "INSPECT_REPOSITORY_RESPONSE", () => inspectRepository(msg.data ?? {}));
+    }
+    else if (msg.type === "SEARCH_REPOSITORIES") {
+        replyToGUI(msg, "SEARCH_REPOSITORIES_RESPONSE", async () => ({
+            results: await searchRepositoriesForInput(String(msg.data?.query ?? "")),
+        }));
+    }
+    else if (msg.type === "INSPECT_CODE_ROOT") {
+        replyToGUI(msg, "INSPECT_CODE_ROOT_RESPONSE", () => inspectCodeRoot(String(msg.data?.path ?? "")));
+    }
+    else if (msg.type === "PREVIEW_CODE_SOURCE") {
+        replyToGUI(msg, "PREVIEW_CODE_SOURCE_RESPONSE", () => previewCodeSource(storageEngine, localState, requireProjectFromIPC(msg), msg.data?.config, msg.data?.codeRoot));
+    }
+    else if (msg.type === "SAVE_CODE_SOURCE") {
+        handleSaveCodeSource(msg);
+    }
+    else if (msg.type === "GET_CODE_ROOTS") {
+        replyToGUI(msg, "GET_CODE_ROOTS_RESPONSE", () => localState.getCodeRoots());
+    }
+    else if (msg.type === "SET_CODE_ROOT") {
+        handleSetCodeRoot(msg);
+    }
+    else if (msg.type === "GET_GITHUB_TOKEN") {
+        replyToGUI(msg, "GET_GITHUB_TOKEN_RESPONSE", () => getGitHubTokenStatus());
+    }
+    else if (msg.type === "GET_CODE_SOURCE_MIGRATION") {
+        replyToGUI(msg, "GET_CODE_SOURCE_MIGRATION_RESPONSE", () => ({ report: localState.getMigrationReport() ?? null }));
+    }
+    else if (msg.type === "ACK_CODE_SOURCE_MIGRATION") {
+        replyToGUI(msg, "ACK_CODE_SOURCE_MIGRATION_RESPONSE", () => {
+            localState.markMigrationReportSeen();
+            return { success: true };
+        });
+    }
     else {
         logger.debug(`Unhandled message from GUI: ${msg.type}`);
     }
@@ -203,6 +252,54 @@ function requireProjectFromIPC(msg) {
         throw new Error("project is required for this operation");
     return project;
 }
+/** Answers a GUI request with what `compute` returns, or with the error it throws. */
+async function replyToGUI(msg, type, compute) {
+    try {
+        const data = await compute();
+        broadcastToGUI({ type, correlationId: msg.correlationId, data, timestamp: new Date().toISOString() });
+    }
+    catch (err) {
+        broadcastToGUI({ type, correlationId: msg.correlationId, error: err.message, timestamp: new Date().toISOString() });
+    }
+}
+/** Tells every connected GUI that code sources changed, so selectors and freshness are re-read. */
+function broadcastCodeSourcesChanged(project) {
+    broadcastToGUI({
+        type: "CODE_SOURCES_CHANGED",
+        data: { project: project ?? null },
+        timestamp: new Date().toISOString(),
+    });
+}
+function handleSaveCodeSource(msg) {
+    if (isReadOnly()) {
+        replyToGUI(msg, "SAVE_CODE_SOURCE_RESPONSE", () => {
+            throw new Error("READ_ONLY mode: configuration changes disabled");
+        });
+        return;
+    }
+    return replyToGUI(msg, "SAVE_CODE_SOURCE_RESPONSE", () => {
+        const project = requireProjectFromIPC(msg);
+        const config = saveCodeSource(storageEngine, localState, project, msg.data?.config, msg.data?.codeRoot);
+        logger.info(`Code source of project "${project}" set to ${getCodeSource(project).label}`);
+        broadcastCodeSourcesChanged(project);
+        return { config };
+    });
+}
+/** Sets the machine default code root, or a project's own when the message names one. */
+function handleSetCodeRoot(msg) {
+    if (isReadOnly()) {
+        replyToGUI(msg, "SET_CODE_ROOT_RESPONSE", () => {
+            throw new Error("READ_ONLY mode: configuration changes disabled");
+        });
+        return;
+    }
+    return replyToGUI(msg, "SET_CODE_ROOT_RESPONSE", () => {
+        const project = msg.data?.project || undefined;
+        const root = setCodeRoot(storageEngine, localState, String(msg.data?.path ?? ""), project);
+        broadcastCodeSourcesChanged(project);
+        return { path: root ?? null };
+    });
+}
 /** Loads one project's summaries and flags each entry as stale/broken. */
 async function listDocsWithFreshness(project) {
     const listings = await storageEngine.listDocsDetailed(project);
@@ -245,6 +342,7 @@ async function handleGetInitialState(msg) {
                 bundles,
                 readOnly: isReadOnly(),
                 syncEnabled: syncEngine.isConfigured(),
+                codeSourceMigrationPending: localState.getMigrationReport()?.seen === false,
             },
             timestamp: new Date().toISOString(),
         });
@@ -684,9 +782,9 @@ async function handleSyncDocsIPC(msg) {
     }
     try {
         // Reuse the tool so the GUI and the agent get identical pull/push semantics.
-        const result = await syncDocs(syncEngine, storageEngine, embeddingEngine, embeddingStore, {
+        const result = afterSync(await syncDocs(syncEngine, storageEngine, embeddingEngine, embeddingStore, {
             message: msg.data?.message,
-        });
+        }));
         const text = result.content.map((c) => c.text).join("\n");
         if (result.isError) {
             broadcastToGUI({
@@ -1031,15 +1129,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
         {
             name: "move_doc",
-            description: "Move a documentation entry to a new path (changes its folder and/or name). All existing doc:// links and related_docs references pointing to the old path are automatically rewritten across the project. This is the only way to relocate a document — update_doc does not change the location.",
+            description: "Move a documentation entry to a new path (changes its folder and/or name) and/or to another project. All existing doc:// links and related_docs references pointing to the old location are automatically rewritten across all projects. When the entry changes project, its own same-project links are qualified with the source project so they keep their target, and its tracked_files are then resolved against the target project's code source. This is the only way to relocate a document — update_doc does not change the location. Provide new_path, new_project, or both.",
             inputSchema: {
                 type: "object",
                 properties: {
                     path: { type: "string", description: "Current path of the documentation entry, e.g. 'backend/authentication'" },
-                    new_path: { type: "string", description: "New path for the documentation entry, e.g. 'backend/v2/authentication'. Can change folder, name, or both." },
-                    project: { type: "string", description: PROJECT_PARAM_DESCRIPTION + " The doc stays in this project — move_doc never moves an entry across projects." },
+                    new_path: { type: "string", description: "New path for the documentation entry, e.g. 'backend/v2/authentication'. Can change folder, name, or both. Omitted: the entry keeps its current path (new_project is then required)." },
+                    project: { type: "string", description: PROJECT_PARAM_DESCRIPTION + " This is the project the entry is moved from." },
+                    new_project: { type: "string", description: "Project the entry is moved to. Must already exist (see list_projects). Omitted: the entry stays in `project`." },
                 },
-                required: ["path", "new_path", "project"],
+                required: ["path", "project"],
             },
         },
         {
@@ -1370,6 +1469,42 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 required: ["path", "decisions"],
             },
         },
+        {
+            name: "get_code_source",
+            description: "Show where each project's source code is read from when checking freshness: its local working copy or one branch of a GitHub repository, and the code root that applies on this machine. GitHub sources are checked against their branch, and a project whose repository or branch cannot be found is flagged.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project: { type: "string", description: "Project to show (defaults to every project)" },
+                },
+            },
+        },
+        {
+            name: "set_code_source",
+            description: "Set where a project's source code is read from: 'local' (the working copy on this machine, under its code root) or 'github' (one branch of a repository, read over the GitHub API). The repository and branch are checked before saving. The setting is stored with the docs, so every machine reads the same source after a sync. The GitHub token is not settable here: it is read from the MCP_DOCUMENTOR_CODE_TOKEN environment variable only.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project: { type: "string", description: "Project to configure. REQUIRED." },
+                    kind: { type: "string", enum: ["local", "github"], description: "'local' reads the working copy, 'github' reads a repository branch" },
+                    repo: { type: "string", description: "Repository when kind is 'github': 'owner/repo' or a GitHub URL" },
+                    branch: { type: "string", description: "Branch when kind is 'github' (defaults to the repository's default branch)" },
+                },
+                required: ["project", "kind"],
+            },
+        },
+        {
+            name: "set_code_root",
+            description: "Set the code root on THIS machine: the folder tracked-file paths are stored relative to, and that the local working copy is read from. With a project, sets that project's own root; without, sets the machine default used by every project that has none. An empty path removes the root (a project then uses the machine default). The folder must exist. Code roots are machine-local and never synced.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Absolute path of the folder, or an empty string to remove the root" },
+                    project: { type: "string", description: "Project whose own root is set (omit to set the machine default)" },
+                },
+                required: ["path"],
+            },
+        },
         {
             name: "reconnect_gui",
             description: "Relaunch the GUI worker and re-register it with the proxy server. Use this when the proxy server was not running when the MCP server started (so the GUI registration failed), to redeploy the GUI without restarting the MCP server. Does nothing if the GUI is already registered, unless force=true.",
@@ -1479,19 +1614,31 @@ async function handleToolCall(request) {
             case "sync_status":
                 return await syncStatus(syncEngine);
             case "pull_docs":
-                return await pullDocs(syncEngine, storageEngine, embeddingEngine, embeddingStore);
+                return afterSync(await pullDocs(syncEngine, storageEngine, embeddingEngine, embeddingStore));
             case "push_docs":
                 return await pushDocs(syncEngine, args);
             case "sync_docs":
-                return await syncDocs(syncEngine, storageEngine, embeddingEngine, embeddingStore, args);
+                return afterSync(await syncDocs(syncEngine, storageEngine, embeddingEngine, embeddingStore, args));
             case "resolve_sync_conflict":
-                return await resolveSyncConflict(syncEngine, args);
+                return afterSync(await resolveSyncConflict(syncEngine, args));
             case "list_conflicts":
                 return await listConflicts(syncEngine);
             case "get_conflict_hunks":
                 return await getConflictHunks(syncEngine, args);
             case "resolve_conflict_hunks":
-                return await resolveConflictHunks(syncEngine, args);
+                return afterSync(await resolveConflictHunks(syncEngine, args));
+            case "get_code_source":
+                return await getCodeSourceTool(storageEngine, localState, args);
+            case "set_code_source": {
+                const result = await setCodeSourceTool(storageEngine, localState, args);
+                broadcastCodeSourcesChanged(args?.project);
+                return result;
+            }
+            case "set_code_root": {
+                const result = setCodeRootTool(storageEngine, localState, args);
+                broadcastCodeSourcesChanged(args?.project);
+                return result;
+            }
             case "reconnect_gui":
                 return await reconnectGui(args);
             default:
@@ -1505,6 +1652,12 @@ async function handleToolCall(request) {
         };
     }
 }
+/** A sync can bring other machines' project settings: code sources are re-read on next use. */
+function afterSync(result) {
+    invalidateCodeSources();
+    broadcastCodeSourcesChanged();
+    return result;
+}
 async function syncPullOnStartup() {
     if (!syncEngine.isConfigured())
         return;
@@ -1533,6 +1686,7 @@ async function main() {
     await migrateFolders(storageEngine);
     await migrateEmbeddings(embeddingStore, storageEngine);
     await syncPullOnStartup();
+    migrateCodeSources(storageEngine, localState);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     logger.info("MCP Server connected and running on stdio");

package/dist/src/tools/check-freshness.d.ts

@@ -1,12 +1,13 @@
 import type { TrackedFile, FreshnessReport } from "../../shared/schemas/doc.schema.js";
 import type { StorageEngine } from "../core/storage-engine.js";
+import { type CodeSource } from "../core/code-source.js";
 /**
  * Docs checked at once during a whole-project scan. With FILE_CONCURRENCY this caps in-flight
  * source reads at 32 — enough to hide network latency on a 160-doc project, far below anything
  * GitHub objects to.
  */
 export declare const DOC_CONCURRENCY = 8;
-export declare function computeFreshness(trackedFiles: TrackedFile[], project: string): Promise<FreshnessReport>;
+export declare function computeFreshness(trackedFiles: TrackedFile[], project: string, source?: CodeSource): Promise<FreshnessReport>;
 export declare function formatFreshnessReport(title: string, report: FreshnessReport): string;
 export declare function checkFreshness(storageEngine: StorageEngine, args: unknown): Promise<{
     content: {

package/dist/src/tools/check-freshness.js

@@ -48,8 +48,7 @@ async function checkTrackedFile(tracked, source) {
         return { kind: "source_error", message: err instanceof Error ? err.message : String(err) };
     }
 }
-export async function computeFreshness(trackedFiles, project) {
-    const source = getCodeSource(project);
+export async function computeFreshness(trackedFiles, project, source = getCodeSource(project)) {
     const empty = { modified: [], missing: [], unchanged: [], anchors_lost: [], broken: [], source: source.label };
     if (!trackedFiles || trackedFiles.length === 0) {
         return { status: "no_tracking", ...empty, total: 0 };

package/dist/src/tools/code-sources.d.ts

@@ -0,0 +1,102 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+import type { LocalState } from "../core/local-state.js";
+import { type BranchHead, type RepositoryInfo, type RepositorySearchResult } from "../core/github-code-api.js";
+import { type CodeSourceConfig } from "../core/project-settings.js";
+/** The only variable the GitHub token is read from. It is never stored nor settable elsewhere. */
+export declare const GITHUB_TOKEN_VAR = "MCP_DOCUMENTOR_CODE_TOKEN";
+/** One project as the project selector shows it. */
+export interface ProjectCodeSource {
+    project: string;
+    /** Undefined when the project's settings cannot be read — `error` then says why. */
+    config?: CodeSourceConfig;
+    /** The code root that applies to the project on this machine. */
+    codeRoot?: string;
+    /** Whether that root is the project's own, or the machine default. */
+    codeRootOrigin?: "project" | "default";
+    /** The machine default root, shown as what an empty project root falls back to. */
+    defaultCodeRoot?: string;
+    /** Why the source cannot be read right now: unreadable settings, unknown repository or branch… */
+    error?: string;
+}
+/** Every project's code source and code root, with GitHub ones checked against their branch. */
+export declare function listCodeSources(storageEngine: StorageEngine, localState: LocalState): Promise<ProjectCodeSource[]>;
+export type RepositoryInspection = {
+    ok: true;
+    repo: RepositoryInfo;
+    branches: string[];
+    branch: string;
+    head: BranchHead;
+} | {
+    ok: false;
+    field: "repo" | "branch";
+    error: string;
+    repo?: RepositoryInfo;
+    branches?: string[];
+};
+/**
+ * Checks a repository: whether it exists for the configured token, its branches, and the commit
+ * the chosen branch — or the default one — points at.
+ */
+export declare function inspectRepository(input: {
+    repo: string;
+    branch?: string;
+}): Promise<RepositoryInspection>;
+/** Repositories matching what is typed in the repository field — empty below two characters. */
+export declare function searchRepositoriesForInput(term: string): Promise<RepositorySearchResult[]>;
+/** Checks that a code root is an existing folder given as an absolute path. */
+export declare function inspectCodeRoot(root: string): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** How the project's docs would read against a code source that is not saved yet. */
+export interface CodeSourcePreview {
+    label: string;
+    docs: number;
+    upToDate: number;
+    stale: number;
+    unverifiable: number;
+    broken: number;
+    /** Set when the source itself could not be consulted. */
+    sourceError?: string;
+}
+export declare function previewCodeSource(storageEngine: StorageEngine, localState: LocalState, project: string, rawConfig: unknown, codeRoot?: string): Promise<CodeSourcePreview>;
+/**
+ * Sets a code root on this machine: the project's own one, or the machine default when `project`
+ * is undefined. An empty root removes it — a project then uses the default.
+ */
+export declare function setCodeRoot(storageEngine: StorageEngine, localState: LocalState, root: string, project?: string): string | undefined;
+/**
+ * Saves a project's code source and, when `codeRoot` is given, its code root on this machine (see
+ * `setCodeRoot`). The next operation on that project reads them.
+ */
+export declare function saveCodeSource(storageEngine: StorageEngine, localState: LocalState, project: string, rawConfig: unknown, codeRoot?: string): CodeSourceConfig;
+export interface GitHubTokenStatus {
+    /** The variable the token is read from. */
+    variable: string;
+    configured: boolean;
+    /** Account the token belongs to. */
+    login?: string;
+    /** Why the token was rejected. */
+    error?: string;
+}
+export declare function getGitHubTokenStatus(): Promise<GitHubTokenStatus>;
+export declare function getCodeSourceTool(storageEngine: StorageEngine, localState: LocalState, args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function setCodeSourceTool(storageEngine: StorageEngine, localState: LocalState, args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function setCodeRootTool(storageEngine: StorageEngine, localState: LocalState, args: unknown): {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};