@praneeth_54/agentdoctor 2.0.1 → 3.0.0

package/dist/languages/php.js

@@ -3,13 +3,20 @@ import { createHash } from "node:crypto";
 function sid(kind, key) {
     return `${kind}:${createHash("sha256").update(key).digest("hex").slice(0, 12)}`;
 }
+const PHP_PROBE_TIMEOUT_MS = 5_000;
+const PHP_EXTRACT_TIMEOUT_MS = 15_000;
 /**
  * Real PHP token extractor via `php -r` + token_get_all (requires `php` on PATH).
  * Not regex. If php is missing, capabilities are unsupported.
+ * Probe timeout skips hanging Windows Store / stub `php` binaries.
  */
 export function phpAvailable() {
-    const r = spawnSync("php", ["-r", "echo PHP_VERSION;"], { encoding: "utf8" });
-    return r.status === 0 && Boolean(r.stdout?.trim());
+    const r = spawnSync("php", ["-r", "echo PHP_VERSION;"], {
+        encoding: "utf8",
+        timeout: PHP_PROBE_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    return r.status === 0 && !r.error && Boolean(r.stdout?.trim());
 }
 const PHP_EXTRACTOR = `
 $source = stream_get_contents(STDIN);
@@ -117,6 +124,8 @@ export const phpAdapter = {
             input: source,
             encoding: "utf8",
             maxBuffer: 8 * 1024 * 1024,
+            timeout: PHP_EXTRACT_TIMEOUT_MS,
+            windowsHide: true,
         });
         if (r.status !== 0 || !r.stdout) {
             return {

package/dist/languages/python.d.ts

@@ -1,7 +1,11 @@
 import type { LanguageAdapter } from "./types.js";
 /**
- * Real Python AST via the CPython `ast` module (requires `python3` on PATH).
- * Not regex. If python3 is missing, capabilities are unsupported.
+ * Resolve a working CPython binary, or null if none responds in time.
+ */
+export declare function resolvePythonBin(): string | null;
+/**
+ * Real Python AST via the CPython `ast` module (requires python on PATH).
+ * Not regex. If no interpreter is available, capabilities are unsupported.
  */
 export declare function pythonAvailable(): boolean;
 export declare const pythonAdapter: LanguageAdapter;

package/dist/languages/python.js

@@ -3,13 +3,40 @@ import { createHash } from "node:crypto";
 function sid(kind, key) {
     return `${kind}:${createHash("sha256").update(key).digest("hex").slice(0, 12)}`;
 }
+const PYTHON_PROBE_TIMEOUT_MS = 5_000;
 /**
- * Real Python AST via the CPython `ast` module (requires `python3` on PATH).
- * Not regex. If python3 is missing, capabilities are unsupported.
+ * Prefer real interpreters; skip hanging Windows Store `python3` stubs via timeout.
+ */
+function pythonCandidates() {
+    return process.platform === "win32" ? ["python", "py", "python3"] : ["python3", "python"];
+}
+let cachedPythonBin;
+/**
+ * Resolve a working CPython binary, or null if none responds in time.
+ */
+export function resolvePythonBin() {
+    if (cachedPythonBin !== undefined)
+        return cachedPythonBin;
+    for (const bin of pythonCandidates()) {
+        const r = spawnSync(bin, ["-c", "import ast, json"], {
+            encoding: "utf8",
+            timeout: PYTHON_PROBE_TIMEOUT_MS,
+            windowsHide: true,
+        });
+        if (r.status === 0 && !r.error) {
+            cachedPythonBin = bin;
+            return bin;
+        }
+    }
+    cachedPythonBin = null;
+    return null;
+}
+/**
+ * Real Python AST via the CPython `ast` module (requires python on PATH).
+ * Not regex. If no interpreter is available, capabilities are unsupported.
  */
 export function pythonAvailable() {
-    const r = spawnSync("python3", ["-c", "import ast, json"], { encoding: "utf8" });
-    return r.status === 0;
+    return resolvePythonBin() !== null;
 }
 const PY_EXTRACTOR = `
 import ast, json, sys
@@ -59,7 +86,8 @@ export const pythonAdapter = {
         };
     },
     async parse(filePath, source) {
-        if (!pythonAvailable()) {
+        const pythonBin = resolvePythonBin();
+        if (!pythonBin) {
             return {
                 language: "python",
                 file: filePath,
@@ -68,14 +96,16 @@ export const pythonAdapter = {
                 symbols: [],
                 imports: [],
                 calls: [],
-                diagnostics: ["python3 not available on PATH"],
-                limitations: ["Python AST adapter requires python3 with stdlib ast module"],
+                diagnostics: ["python not available on PATH"],
+                limitations: ["Python AST adapter requires python3/python with stdlib ast module"],
             };
         }
-        const r = spawnSync("python3", ["-c", PY_EXTRACTOR, filePath], {
+        const r = spawnSync(pythonBin, ["-c", PY_EXTRACTOR, filePath], {
             input: source,
             encoding: "utf8",
             maxBuffer: 8 * 1024 * 1024,
+            timeout: 15_000,
+            windowsHide: true,
         });
         if (r.status !== 0 || !r.stdout) {
             return {
@@ -86,7 +116,7 @@ export const pythonAdapter = {
                 symbols: [],
                 imports: [],
                 calls: [],
-                diagnostics: [r.stderr || "python3 extractor failed"],
+                diagnostics: [r.stderr || r.error?.message || "python extractor failed"],
                 limitations: [],
             };
         }

package/dist/languages/rust.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageAdapter, LanguageImport, LanguageSymbol } from "./types.js";
+export interface RustParseSummary {
+    moduleName: string;
+    imports: LanguageImport[];
+    symbols: LanguageSymbol[];
+    limitations: string[];
+}
+/** Lightweight line-oriented Rust scan — not syn/rustc AST. */
+export declare function parseRustSource(filePath: string, source: string): RustParseSummary;
+export declare const rustAdapter: LanguageAdapter;

package/dist/languages/rust.js

@@ -0,0 +1,93 @@
+/** Lightweight line-oriented Rust scan — not syn/rustc AST. */
+export function parseRustSource(filePath, source) {
+    const lines = source.split(/\r?\n/);
+    const limitations = [
+        "Rust parsing uses a lightweight line scanner — not syn or tree-sitter-rust; calls/types are partial.",
+        "Full rustc/syn or tree-sitter-rust integration remains an EXTERNAL enhancement path (not bundled).",
+    ];
+    let moduleName = "";
+    const imports = [];
+    const symbols = [];
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!moduleName && trimmed.startsWith("mod ") && !trimmed.includes("{")) {
+            moduleName = trimmed.slice("mod ".length).split(/\s+/)[0]?.replace(";", "") ?? "";
+        }
+        if (trimmed.startsWith("use ") && trimmed.endsWith(";")) {
+            const spec = trimmed.slice("use ".length, -1).trim();
+            if (spec)
+                imports.push({ fromFile: filePath, specifier: spec, evidence: "ast" });
+        }
+        const structMatch = /^(?:pub\s+)?(?:struct|enum|trait|type)\s+(\w+)/.exec(trimmed);
+        if (structMatch) {
+            let kind = "struct";
+            if (trimmed.includes("enum"))
+                kind = "enum";
+            else if (trimmed.includes("trait"))
+                kind = "trait";
+            else if (trimmed.includes("type"))
+                kind = "type";
+            symbols.push({
+                id: `rust:${kind}:${filePath}:${structMatch[1]}`,
+                name: structMatch[1],
+                kind,
+                file: filePath,
+                line: i + 1,
+                evidence: "ast",
+            });
+        }
+        const fnMatch = /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/.exec(trimmed);
+        if (fnMatch) {
+            symbols.push({
+                id: `rust:function:${filePath}:${fnMatch[1]}`,
+                name: fnMatch[1],
+                kind: "function",
+                file: filePath,
+                line: i + 1,
+                evidence: "ast",
+            });
+        }
+        const implMatch = /^impl(?:<[^>]+>)?\s+(?:\w+::)*(\w+)/.exec(trimmed);
+        if (implMatch) {
+            symbols.push({
+                id: `rust:impl:${filePath}:${implMatch[1]}`,
+                name: implMatch[1],
+                kind: "impl",
+                file: filePath,
+                line: i + 1,
+                evidence: "ast",
+            });
+        }
+    }
+    return { moduleName, imports, symbols, limitations };
+}
+const RUST_CAPABILITIES = () => ({
+    parse: "supported",
+    symbols: "supported",
+    definitions: "unsupported",
+    references: "unsupported",
+    imports: "supported",
+    calls: "partial",
+    diagnostics: "unsupported",
+    types: "partial",
+});
+export const rustAdapter = {
+    id: "rust",
+    extensions: [".rs"],
+    capabilities: RUST_CAPABILITIES,
+    async parse(filePath, source) {
+        const summary = parseRustSource(filePath, source);
+        const ok = Boolean(summary.moduleName || summary.symbols.length > 0 || summary.imports.length > 0);
+        return {
+            language: "rust",
+            file: filePath,
+            ok,
+            capabilities: rustAdapter.capabilities(),
+            symbols: summary.symbols,
+            imports: summary.imports,
+            calls: [],
+            diagnostics: ok ? [] : ["no mod, use, or declarations detected"],
+            limitations: summary.limitations,
+        };
+    },
+};

package/dist/languages/types.d.ts

@@ -3,7 +3,7 @@
  * Unsupported capabilities must be reported as unsupported, never as inferred AST.
  */
 export type LanguageId = "typescript" | "javascript" | "python" | "java" | "kotlin" | "go" | "rust" | "php" | "dart" | "unknown";
-export type AdapterCapability = "parse" | "symbols" | "definitions" | "references" | "imports" | "calls" | "diagnostics";
+export type AdapterCapability = "parse" | "symbols" | "definitions" | "references" | "imports" | "calls" | "diagnostics" | "types";
 export interface LanguageSymbol {
     id: string;
     name: string;
@@ -22,11 +22,12 @@ export interface LanguageCall {
     callee: string;
     evidence: "ast" | "unsupported";
 }
+export type AdapterCapabilityLevel = "supported" | "unsupported" | "partial";
 export interface ParseResult {
     language: LanguageId;
     file: string;
     ok: boolean;
-    capabilities: Partial<Record<AdapterCapability, "supported" | "unsupported">>;
+    capabilities: Partial<Record<AdapterCapability, AdapterCapabilityLevel>>;
     symbols: LanguageSymbol[];
     imports: LanguageImport[];
     calls: LanguageCall[];
@@ -36,7 +37,7 @@ export interface ParseResult {
 export interface LanguageAdapter {
     id: LanguageId;
     extensions: string[];
-    capabilities(): Partial<Record<AdapterCapability, "supported" | "unsupported">>;
+    capabilities(): Partial<Record<AdapterCapability, AdapterCapabilityLevel>>;
     parse(filePath: string, source: string): Promise<ParseResult>;
 }
 export declare function detectLanguage(filePath: string): LanguageId;

package/dist/mcp/agent/registry.d.ts

@@ -0,0 +1,13 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { ModelProvider } from "../../ai/types.js";
+export declare const AGENT_MCP_TOOL_NAMES: readonly ["project_context", "project_ask", "code_search", "file_read", "file_create", "file_edit", "approval_issue", "agent_plan", "change_verify"];
+export type AgentMcpToolName = (typeof AGENT_MCP_TOOL_NAMES)[number];
+export declare function listAgentMcpTools(): Tool[];
+export declare function invokeAgentMcpTool(root: string, name: string, args: Record<string, unknown>, options?: {
+    provider?: ModelProvider;
+}): Promise<{
+    structured: unknown;
+    isError: boolean;
+}>;
+/** Convenience for tests */
+export declare function projectFingerprint(root: string): Promise<unknown>;

package/dist/mcp/agent/registry.js

@@ -0,0 +1,320 @@
+import { createModelProvider, loadAiConfig } from "../../ai/index.js";
+import { ChatService } from "../../agent/chat/service.js";
+import { buildAgentPlan } from "../../agent/plan.js";
+import { executeAgentTool, newToolCall } from "../../agent/tools/index.js";
+import { retrieveProjectContext } from "../../agent/context/retrieve.js";
+import { summarizeProjectForChat } from "../../agent/chat/project-summary.js";
+import { consumeApprovalGrant, issueApprovalGrant, hashPlanPayload, hashFileWritePlan, } from "../../product/approval/session.js";
+import { assertForensicReadOnly } from "../../product/forensic/mode.js";
+export const AGENT_MCP_TOOL_NAMES = [
+    "project_context",
+    "project_ask",
+    "code_search",
+    "file_read",
+    "file_create",
+    "file_edit",
+    "approval_issue",
+    "agent_plan",
+    "change_verify",
+];
+export function listAgentMcpTools() {
+    return [
+        {
+            name: "project_context",
+            description: "READ: Budgeted project context pack for a query (path-safe).",
+            inputSchema: {
+                type: "object",
+                properties: { query: { type: "string" } },
+                required: ["query"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "project_ask",
+            description: "READ: One-shot Project Chat ask (requires AI provider; no file writes).",
+            inputSchema: {
+                type: "object",
+                properties: { question: { type: "string" } },
+                required: ["question"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "code_search",
+            description: "READ: Search code via AgentDoctor graph search.",
+            inputSchema: {
+                type: "object",
+                properties: { query: { type: "string" } },
+                required: ["query"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "file_read",
+            description: "READ: Path-safe file read inside workspace.",
+            inputSchema: {
+                type: "object",
+                properties: { path: { type: "string" } },
+                required: ["path"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "file_create",
+            description: "WRITE: Create file. Requires approvalToken from issueApprovalGrant / CLI --approve. Bare approved=true is rejected.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string" },
+                    content: { type: "string" },
+                    approvalToken: { type: "string" },
+                    approved: {
+                        type: "boolean",
+                        description: "Legacy flag — insufficient alone; approvalToken required",
+                    },
+                },
+                required: ["path", "content", "approvalToken"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "file_edit",
+            description: "WRITE: Edit file. Requires approvalToken from issueApprovalGrant / CLI --approve.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string" },
+                    content: { type: "string" },
+                    oldContent: { type: "string" },
+                    approvalToken: { type: "string" },
+                    approved: {
+                        type: "boolean",
+                        description: "Legacy flag — insufficient alone; approvalToken required",
+                    },
+                },
+                required: ["path", "approvalToken"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "approval_issue",
+            description: "TRUSTED: Issue a short-lived approval grant for writes. Requires AGENTDOCTOR_MCP_TRUSTED_APPROVE=1 in the MCP server environment (not model-settable).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    action: { type: "string" },
+                    resources: { type: "array", items: { type: "string" } },
+                    planHash: { type: "string" },
+                    risk: { type: "string", enum: ["LOW", "MEDIUM", "HIGH", "CRITICAL"] },
+                },
+                required: ["action", "resources", "planHash"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "agent_plan",
+            description: "READ: Build a change plan without modifying files.",
+            inputSchema: {
+                type: "object",
+                properties: { goal: { type: "string" } },
+                required: ["goal"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "change_verify",
+            description: "READ: Produce evidence/proof for current changes (may write evidence artifacts).",
+            inputSchema: {
+                type: "object",
+                properties: { changeId: { type: "string" } },
+                additionalProperties: false,
+            },
+        },
+    ];
+}
+export async function invokeAgentMcpTool(root, name, args, options) {
+    try {
+        switch (name) {
+            case "project_context": {
+                const query = typeof args.query === "string" ? args.query : "";
+                const bundle = await retrieveProjectContext({ root, query });
+                return { structured: { ok: true, bundle }, isError: false };
+            }
+            case "project_ask": {
+                const question = typeof args.question === "string" ? args.question : "";
+                if (!question) {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: { code: "invalid_argument", message: "question required" },
+                        },
+                        isError: true,
+                    };
+                }
+                const provider = options?.provider ?? createModelProvider(loadAiConfig());
+                const chat = new ChatService({
+                    root,
+                    provider,
+                    persistAudit: false,
+                });
+                try {
+                    const response = await chat.ask(question);
+                    return {
+                        structured: { ok: response.status === "ok", response },
+                        isError: response.status !== "ok" && response.status !== "provider-none",
+                    };
+                }
+                finally {
+                    await chat.end();
+                }
+            }
+            case "code_search": {
+                const result = await executeAgentTool(root, newToolCall("mcp", "search_code", { query: args.query }));
+                return { structured: result, isError: !result.ok };
+            }
+            case "file_read": {
+                const result = await executeAgentTool(root, newToolCall("mcp", "read_file", { path: args.path }));
+                return { structured: result, isError: !result.ok };
+            }
+            case "file_create": {
+                assertForensicReadOnly(process.env.AGENTDOCTOR_FORENSIC_MODE === "1");
+                const token = typeof args.approvalToken === "string" ? args.approvalToken : undefined;
+                const pathArg = typeof args.path === "string" ? args.path : "";
+                const content = typeof args.content === "string" ? args.content : "";
+                const planHash = hashFileWritePlan("file_create", pathArg, content);
+                const gate = await consumeApprovalGrant({
+                    root,
+                    token,
+                    action: "file_create",
+                    resources: [pathArg],
+                    requirePlanHash: planHash,
+                });
+                if (!gate.ok) {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: { code: "approval_required", message: gate.reason },
+                        },
+                        isError: true,
+                    };
+                }
+                const result = await executeAgentTool(root, newToolCall("mcp", "create_file", { path: args.path, content: args.content }), { allowWrite: true, approvedByHuman: true });
+                return { structured: result, isError: !result.ok };
+            }
+            case "file_edit": {
+                assertForensicReadOnly(process.env.AGENTDOCTOR_FORENSIC_MODE === "1");
+                const token = typeof args.approvalToken === "string" ? args.approvalToken : undefined;
+                const pathArg = typeof args.path === "string" ? args.path : "";
+                const content = typeof args.content === "string" ? args.content : "";
+                const planHash = hashFileWritePlan("file_edit", pathArg, content);
+                const gate = await consumeApprovalGrant({
+                    root,
+                    token,
+                    action: "file_edit",
+                    resources: [pathArg],
+                    requirePlanHash: planHash,
+                });
+                if (!gate.ok) {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: { code: "approval_required", message: gate.reason },
+                        },
+                        isError: true,
+                    };
+                }
+                const result = await executeAgentTool(root, newToolCall("mcp", "edit_file", {
+                    path: args.path,
+                    content: args.content,
+                    oldContent: args.oldContent,
+                }), { allowWrite: true, approvedByHuman: true });
+                return { structured: result, isError: !result.ok };
+            }
+            case "approval_issue": {
+                if (process.env.AGENTDOCTOR_MCP_TRUSTED_APPROVE !== "1") {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: {
+                                code: "trust_required",
+                                message: "approval_issue requires AGENTDOCTOR_MCP_TRUSTED_APPROVE=1 in the MCP host environment",
+                            },
+                        },
+                        isError: true,
+                    };
+                }
+                const resources = Array.isArray(args.resources)
+                    ? args.resources.filter((r) => typeof r === "string")
+                    : [];
+                const action = typeof args.action === "string" ? args.action : "file_edit";
+                const planHash = typeof args.planHash === "string" && args.planHash.length >= 8
+                    ? args.planHash
+                    : hashPlanPayload(action);
+                const risk = (typeof args.risk === "string" ? args.risk : "MEDIUM");
+                try {
+                    const grant = await issueApprovalGrant({
+                        root,
+                        action,
+                        resources,
+                        risk,
+                        planHash,
+                        actor: "mcp-trusted-host",
+                    });
+                    return {
+                        structured: { ok: true, token: grant.token, expiresAt: grant.expiresAt, planHash },
+                        isError: false,
+                    };
+                }
+                catch (error) {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: {
+                                code: "invalid_grant",
+                                message: error instanceof Error ? error.message : String(error),
+                            },
+                        },
+                        isError: true,
+                    };
+                }
+            }
+            case "agent_plan": {
+                const goal = typeof args.goal === "string" ? args.goal : "";
+                const plan = await buildAgentPlan({ root, goal });
+                return { structured: { ok: true, plan }, isError: false };
+            }
+            case "change_verify": {
+                const { verifyChange } = await import("../../assurance/change.js");
+                const result = await verifyChange({
+                    root,
+                    ...(typeof args.changeId === "string" ? { changeId: args.changeId } : {}),
+                });
+                return { structured: { ok: true, ...result }, isError: false };
+            }
+            default:
+                return {
+                    structured: {
+                        ok: false,
+                        error: { code: "invalid_argument", message: `unknown agent tool: ${name}` },
+                    },
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            structured: {
+                ok: false,
+                error: {
+                    code: "internal",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            },
+            isError: true,
+        };
+    }
+}
+/** Convenience for tests */
+export async function projectFingerprint(root) {
+    return summarizeProjectForChat(root);
+}

package/dist/mcp/agentdoctor/server.js

@@ -6,6 +6,7 @@ import { resolveRepoRoot } from "../../utils/path.js";
 import { BrainMcpSession } from "../brain/session.js";
 import { BRAIN_MCP_TOOL_NAMES, invokeBrainMcpTool, listBrainMcpTools, } from "../brain/tools/registry.js";
 import { INTELLIGENCE_MCP_TOOL_NAMES, invokeIntelligenceMcpTool, listIntelligenceMcpTools, } from "../intelligence/registry.js";
+import { AGENT_MCP_TOOL_NAMES, invokeAgentMcpTool, listAgentMcpTools } from "../agent/registry.js";
 /**
  * Combined AgentDoctor MCP server: preserves all Brain tool names and adds
  * intelligence tools. No arbitrary shell execution; policy_evaluate is evaluate-only.
@@ -19,6 +20,7 @@ export async function startAgentDoctorMcpServer(options) {
     await session.initialize();
     const brainNames = new Set(BRAIN_MCP_TOOL_NAMES);
     const intelNames = new Set(INTELLIGENCE_MCP_TOOL_NAMES);
+    const agentNames = new Set(AGENT_MCP_TOOL_NAMES);
     const server = new Server({
         name: "agentdoctor",
         version: PACKAGE_VERSION,
@@ -28,7 +30,7 @@ export async function startAgentDoctorMcpServer(options) {
         },
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [...listBrainMcpTools(), ...listIntelligenceMcpTools()],
+        tools: [...listBrainMcpTools(), ...listIntelligenceMcpTools(), ...listAgentMcpTools()],
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const name = request.params.name;
@@ -45,6 +47,11 @@ export async function startAgentDoctorMcpServer(options) {
             structured = result.structured;
             isError = result.isError;
         }
+        else if (agentNames.has(name)) {
+            const result = await invokeAgentMcpTool(root, name, args);
+            structured = result.structured;
+            isError = result.isError;
+        }
         else {
             structured = {
                 ok: false,

package/dist/mcp/intelligence/handlers.d.ts

@@ -14,3 +14,6 @@ export declare function handleArchitectureCheckTool(rootInput: string): Promise<
 export declare function handleProofInspectTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
 export declare function handleEvidenceInspectTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
 export declare function handleGraphQueryTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleProjectDnaTool(rootInput: string): Promise<unknown>;
+export declare function handleSoftwareMapTool(rootInput: string): Promise<unknown>;
+export declare function handleWhatIfTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;