@praneeth_54/agentdoctor 1.1.1 → 2.0.0

package/dist/architecture/c4.js

@@ -0,0 +1,62 @@
+/**
+ * C4-style views derived from repository graph evidence.
+ * Always labels inferred vs observed.
+ */
+export function buildC4Views(graph) {
+    const files = graph.nodes.filter((n) => n.kind === "file" || n.kind === "test");
+    const deps = graph.edges.filter((e) => e.kind === "imports" || e.kind === "depends_on");
+    const containers = [
+        { id: "c_app", label: "Application", kind: "container" },
+        { id: "c_tests", label: "Tests", kind: "container" },
+        { id: "c_docs", label: "Docs", kind: "container" },
+    ];
+    const system = {
+        level: "system-context",
+        title: "System context (inferred)",
+        nodes: [
+            { id: "sys", label: graph.root.split("/").pop() ?? "system", kind: "system" },
+            { id: "dev", label: "Developer / Agent", kind: "person" },
+        ],
+        edges: [{ from: "dev", to: "sys", kind: "uses" }],
+        evidenceKind: "inferred",
+        limitations: ["System context is scaffolding from repository root name only"],
+    };
+    const container = {
+        level: "container",
+        title: "Containers (inferred from paths)",
+        nodes: containers,
+        edges: [
+            { from: "c_app", to: "c_tests", kind: "tested_by" },
+            { from: "c_docs", to: "c_app", kind: "documents" },
+        ],
+        evidenceKind: "inferred",
+        limitations: ["Container boundaries inferred from folder conventions, not runtime topology"],
+    };
+    const component = {
+        level: "component",
+        title: "Components (from graph files)",
+        nodes: files.slice(0, 40).map((n) => ({
+            id: n.id,
+            label: n.label,
+            kind: n.kind,
+        })),
+        edges: deps.slice(0, 80).map((e) => ({ from: e.from, to: e.to, kind: e.kind })),
+        evidenceKind: deps.some((e) => e.evidence === "verified") ? "observed" : "inferred",
+        limitations: ["Component view capped; not a full deployment diagram"],
+    };
+    const code = {
+        level: "code",
+        title: "Code-level symbols",
+        nodes: graph.nodes
+            .filter((n) => n.kind === "function" || n.kind === "class")
+            .slice(0, 60)
+            .map((n) => ({ id: n.id, label: n.label, kind: n.kind })),
+        edges: graph.edges
+            .filter((e) => e.kind === "calls" || e.kind === "extends" || e.kind === "implements")
+            .slice(0, 80)
+            .map((e) => ({ from: e.from, to: e.to, kind: e.kind })),
+        evidenceKind: "observed",
+        limitations: ["Code view depends on active graph builder (AST or regex)"],
+    };
+    return [system, container, component, code];
+}

package/dist/cli/commands/brain.d.ts

@@ -0,0 +1,12 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runBrainCommand(options: {
+    action: string;
+    root?: string;
+    query?: string;
+    snapshotId?: string;
+    file?: string;
+    json?: boolean;
+    artifactId?: string;
+    decision?: "approved" | "rejected" | "pending-review" | "deprecated";
+    note?: string;
+}): Promise<ExitCode>;

package/dist/cli/commands/brain.js

@@ -0,0 +1,162 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { exportBrain, getBrainStatus, importBrain, initBrainStore, inspectBrainSummary, listBrainSnapshots, loadLatestBrain, rebuildBrain, searchBrain, showBrainSnapshot, } from "../../core/brain-cli/service.js";
+import { listProposals, reviewProposal, writeBrainProductSnapshot, } from "../../core/brain-product/init.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runBrainCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const json = options.json === true;
+    try {
+        switch (options.action) {
+            case "init": {
+                const status = await initBrainStore(root);
+                if (json)
+                    printJson(status);
+                else
+                    process.stdout.write(`Project Brain store ready at ${status.storeRoot}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "status": {
+                const status = await getBrainStatus(root);
+                if (json)
+                    printJson(status);
+                else
+                    process.stdout.write(`Brain status\n  root: ${status.root}\n  snapshots: ${status.snapshotCount}\n  latest: ${status.latestSnapshotId ?? "(none)"}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "inspect": {
+                const summary = await inspectBrainSummary(root);
+                if (json)
+                    printJson(summary);
+                else
+                    process.stdout.write(`Brain inspect\n  project: ${String(summary.projectName)}\n  snapshot: ${String(summary.snapshotId)}\n  claims: ${String(summary.claimCount)}\n  components: ${String(summary.componentCount)}\n  risks: ${String(summary.riskCount)}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "rebuild":
+            case "update": {
+                const brain = await rebuildBrain(root);
+                const productSnap = await writeBrainProductSnapshot(root);
+                if (json)
+                    printJson({
+                        snapshotId: brain.snapshot.id,
+                        projectName: brain.metadata.projectName,
+                        productSnapshot: productSnap,
+                    });
+                else
+                    process.stdout.write(`Rebuilt Project Brain snapshot ${brain.snapshot.id}\nRepository Brain product snapshot: ${productSnap}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "snapshot": {
+                const brain = await rebuildBrain(root);
+                const productSnap = await writeBrainProductSnapshot(root);
+                if (json)
+                    printJson({ brainSnapshotId: brain.snapshot.id, productSnapshot: productSnap });
+                else
+                    process.stdout.write(`Brain snapshot ${brain.snapshot.id}\nProduct snapshot ${productSnap}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "review": {
+                if (!options.artifactId || !options.decision) {
+                    console.error("Error: --artifact <id> and --decision <approved|rejected|...> required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const item = await reviewProposal({
+                    root,
+                    artifactId: options.artifactId,
+                    decision: options.decision,
+                    ...(options.note ? { note: options.note } : {}),
+                });
+                if (json)
+                    printJson(item);
+                else
+                    process.stdout.write(`Reviewed ${item.artifactId} -> ${item.status}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "proposals": {
+                const proposals = await listProposals(root);
+                if (json)
+                    printJson({ proposals });
+                else {
+                    for (const p of proposals) {
+                        process.stdout.write(`${p.id}  [${p.status}]  ${p.kind}  ${p.path}\n`);
+                    }
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "snapshot-list":
+            case "history": {
+                const snapshots = await listBrainSnapshots(root);
+                if (json)
+                    printJson({ snapshots });
+                else if (snapshots.length === 0) {
+                    process.stdout.write("No snapshots yet. Run: agentdoctor brain rebuild\n");
+                }
+                else {
+                    for (const snap of snapshots) {
+                        process.stdout.write(`${snap.id}  ${snap.createdAt}  ${snap.projectName}\n`);
+                    }
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "snapshot-show": {
+                if (!options.snapshotId) {
+                    console.error("Error: snapshot id required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const brain = await showBrainSnapshot(root, options.snapshotId);
+                printJson({
+                    snapshotId: brain.snapshot.id,
+                    projectName: brain.metadata.projectName,
+                    claimCount: brain.claims.length,
+                    componentCount: brain.components.length,
+                });
+                return EXIT_CODES.SUCCESS;
+            }
+            case "search": {
+                if (!options.query) {
+                    console.error("Error: search query required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                let brain = await loadLatestBrain(root);
+                if (!brain)
+                    brain = await rebuildBrain(root);
+                const hits = searchBrain(brain, options.query);
+                if (json)
+                    printJson({ query: options.query, hits });
+                else if (hits.length === 0)
+                    process.stdout.write("No matches.\n");
+                else
+                    for (const hit of hits)
+                        process.stdout.write(`[${hit.kind}] ${hit.id}: ${hit.text}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "export": {
+                if (!options.file) {
+                    console.error("Error: --file <path> required for export");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const out = await exportBrain(root, options.file, options.snapshotId);
+                process.stdout.write(`Exported redacted brain to ${out}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "import": {
+                if (!options.file) {
+                    console.error("Error: --file <path> required for import");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const meta = await importBrain(root, options.file);
+                process.stdout.write(`Imported snapshot ${meta.id}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            default:
+                console.error(`Error: unknown brain action: ${options.action}`);
+                return EXIT_CODES.USAGE_ERROR;
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}

package/dist/cli/commands/complete.d.ts

@@ -0,0 +1,23 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runInitCommand(options: {
+    root?: string;
+    json?: boolean;
+    name?: string;
+    domain?: string;
+}): Promise<ExitCode>;
+export declare function runV2SurfaceCommand(options: {
+    action: string;
+    root?: string;
+    json?: boolean;
+    query?: string;
+    title?: string;
+    content?: string;
+    id?: string;
+    decision?: string;
+    username?: string;
+    password?: string;
+    token?: string;
+    command?: string;
+    mode?: string;
+    symbol?: string;
+}): Promise<ExitCode>;

package/dist/cli/commands/complete.js

@@ -0,0 +1,232 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { runProjectInit } from "../../core/brain-product/init.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { analyzeGitIntelligence, deadCodeCategory } from "../../intelligence/git/analyze.js";
+import { buildC4Views } from "../../architecture/c4.js";
+import { createKnowledgeRecord, listKnowledge, retrieveAuthoritative, transitionKnowledge, } from "../../knowledge/store.js";
+import { authenticateLocalDev, authorize, registerLocalDevUser } from "../../team/auth.js";
+import { runControlledCommand } from "../../enforcement/runner.js";
+import { analyzeTestImpact, analyzeRenameImpact, buildRepositoryGraph, } from "../../platform/index.js";
+import { CONTRACTS_VERSION, DEFAULT_FEATURE_FLAGS } from "../../contracts/index.js";
+import { platformFindingToContract } from "../../contracts/adapters.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runInitCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const result = await runProjectInit(root, {
+        ...(options.name ? { projectName: options.name } : {}),
+        ...(options.domain ? { businessDomain: options.domain } : {}),
+    });
+    if (options.json)
+        printJson(result);
+    else {
+        process.stdout.write(`AgentDoctor init wrote ${result.artifacts.length} PROPOSED artifacts under .agentdoctor/repository-brain/proposals/\nNone are approved facts until: agentdoctor brain review --artifact <id> --decision approved\n`);
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runV2SurfaceCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    try {
+        switch (options.action) {
+            case "graph-ast": {
+                const graph = await buildIntelligenceGraph({
+                    root,
+                    mode: options.mode ?? "auto",
+                });
+                if (options.json)
+                    printJson(graph);
+                else
+                    process.stdout.write(`graph builder=${graph.builder} nodes=${graph.nodes.length} edges=${graph.edges.length} astFiles=${graph.astFilesParsed}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "health":
+            case "git-intel": {
+                const report = await analyzeGitIntelligence(root);
+                if (options.json)
+                    printJson(report);
+                else
+                    process.stdout.write(`git-intel hotspots=${report.hotspots.length} coChanges=${report.coChanges.length} git=${report.gitAvailable}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "c4": {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const views = buildC4Views(graph);
+                if (options.json)
+                    printJson({ views, featureFlag: DEFAULT_FEATURE_FLAGS.architectureC4 });
+                else
+                    process.stdout.write(`C4 views: ${views.map((v) => v.level).join(", ")}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "dead-code-demo": {
+                const sample = deadCodeCategory({
+                    exported: true,
+                    referenced: false,
+                    frameworkEntry: false,
+                    dynamicHint: false,
+                });
+                if (options.json)
+                    printJson(sample);
+                else
+                    process.stdout.write(`${sample.category} confidence=${sample.confidence}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "knowledge-create": {
+                if (!options.title || !options.content) {
+                    console.error("Error: --title and --content required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const rec = await createKnowledgeRecord({
+                    root,
+                    title: options.title,
+                    content: options.content,
+                    status: "draft",
+                });
+                if (options.json)
+                    printJson(rec);
+                else
+                    process.stdout.write(`Created draft knowledge ${rec.id}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "knowledge-list": {
+                const list = await listKnowledge(root);
+                if (options.json)
+                    printJson({ records: list });
+                else
+                    for (const r of list)
+                        process.stdout.write(`${r.id} [${r.status}] ${r.title}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "knowledge-transition": {
+                if (!options.id || !options.decision) {
+                    console.error("Error: --id and --decision required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const rec = await transitionKnowledge({
+                    root,
+                    id: options.id,
+                    to: options.decision,
+                });
+                if (options.json)
+                    printJson(rec);
+                else
+                    process.stdout.write(`${rec.id} -> ${rec.status}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "knowledge-query": {
+                const list = await listKnowledge(root);
+                const result = retrieveAuthoritative(list, options.query ?? "");
+                if (options.json)
+                    printJson(result);
+                else
+                    process.stdout.write(result.abstain
+                        ? `ABSTAIN: ${result.reason}\n`
+                        : `AUTHORITATIVE: ${result.record?.title}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "team-register": {
+                if (!options.username || !options.password) {
+                    console.error("Error: --username and --password required (local-dev auth only)");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const user = await registerLocalDevUser({
+                    root,
+                    username: options.username,
+                    password: options.password,
+                    role: "admin",
+                });
+                if (options.json)
+                    printJson({ ...user, notice: "local-dev auth — not enterprise SSO" });
+                else
+                    process.stdout.write(`Registered local-dev user ${user.username} (${user.id})\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "team-login": {
+                if (!options.username || !options.password) {
+                    console.error("Error: --username and --password required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const session = await authenticateLocalDev({
+                    root,
+                    username: options.username,
+                    password: options.password,
+                });
+                if (options.json)
+                    printJson({ ...session, notice: "local-dev session — not enterprise SSO" });
+                else
+                    process.stdout.write(`token=${session.token} expires=${session.expiresAt}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "team-authorize": {
+                if (!options.token) {
+                    console.error("Error: --token required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const result = await authorize(root, options.token, "member");
+                if (options.json)
+                    printJson(result);
+                else
+                    process.stdout.write(`${result.ok ? "OK" : "DENIED"}: ${result.reason}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "enforce-check": {
+                if (!options.command) {
+                    console.error("Error: --command required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const result = await runControlledCommand({ root, command: options.command });
+                if (options.json)
+                    printJson(result);
+                else
+                    process.stdout.write(`enforced=${result.enforced} status=${result.decision.executionStatus} decision=${result.decision.decision}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "impact": {
+                const impact = await analyzeTestImpact(root);
+                if (options.json)
+                    printJson({ kind: "test-impact", contractsVersion: CONTRACTS_VERSION, impact });
+                else
+                    process.stdout.write(`impact recommendedTests=${impact.recommendedTests.length}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "refactor-impact": {
+                if (!options.symbol) {
+                    console.error("Error: --symbol required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const graph = await buildRepositoryGraph(root);
+                const impact = await analyzeRenameImpact({ root, symbol: options.symbol, graph });
+                if (options.json)
+                    printJson(impact);
+                else
+                    process.stdout.write(`refactor ${options.symbol} affected=${impact.affectedFiles.length}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "contracts-demo": {
+                const sample = platformFindingToContract({
+                    id: "demo",
+                    module: "demo",
+                    severity: "info",
+                    title: "demo",
+                    message: "demo",
+                    recommendation: "n/a",
+                    confidence: 1,
+                    evidence: [{ kind: "verified", detail: "ok" }],
+                });
+                if (options.json)
+                    printJson({ contractsVersion: CONTRACTS_VERSION, sample });
+                else
+                    process.stdout.write(`contracts ${CONTRACTS_VERSION}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            default:
+                console.error(`Error: unknown action ${options.action}`);
+                return EXIT_CODES.USAGE_ERROR;
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}

package/dist/cli/commands/explain.js

@@ -13,7 +13,7 @@ export async function runExplainCommand(ruleId) {
     const rule = getRuleById(ruleId.trim());
     if (!rule) {
         console.error(`Error: unknown rule id "${ruleId}"`);
-        console.error("Run agentdoctor explain with a documented rule from docs/rules.md");
+        console.error("Run agentdoctor explain with a documented rule from docs/reference/rules.md");
         return EXIT_CODES.USAGE_ERROR;
     }
     const agents = rule.affectedAgents?.map((id) => AGENT_DISPLAY_NAMES[id] ?? id).join(", ") ??

package/dist/cli/commands/fix.js

@@ -1,7 +1,7 @@
 import { EXIT_CODES } from "../../types/index.js";
 import { isDirectory } from "../../utils/fs.js";
 import { resolveRepoRoot } from "../../utils/path.js";
-import { applyFixPlan, readClaudeSettings, readCodexConfig, readCursorignore, } from "../../core/fix/apply.js";
+import { applyFixPlan, readClaudeSettings, readCodexConfig, readCursorignore, readSimpleIgnore, } from "../../core/fix/apply.js";
 import { buildFixPlan } from "../../core/fix/plan.js";
 import { renderFixPlanTerminal } from "../../core/fix/render.js";
 import { runFix } from "../../core/fix/run.js";
@@ -25,14 +25,22 @@ export async function runFixCommand(options) {
             const cursorContent = await readCursorignore(plan.root);
             const claudeSettingsContent = await readClaudeSettings(plan.root);
             const codexConfigContent = await readCodexConfig(plan.root);
+            const geminiignoreContent = await readSimpleIgnore(plan.root, ".geminiignore");
+            const aiderignoreContent = await readSimpleIgnore(plan.root, ".aiderignore");
             const applyResult = await applyFixPlan(plan, { dryRun: true });
             process.stdout.write(renderFixPlanTerminal(plan, {
                 dryRun: true,
                 cursorContent,
                 claudeSettingsContent,
                 codexConfigContent,
+                geminiignoreContent,
+                aiderignoreContent,
                 applyResult,
             }));
+            if (applyResult.error) {
+                console.error(`Error: ${applyResult.error}`);
+                return EXIT_CODES.USAGE_ERROR;
+            }
             return EXIT_CODES.SUCCESS;
         }
         const { plan, applyResult, cancelled } = await runFix({
@@ -47,13 +55,23 @@ export async function runFixCommand(options) {
         const cursorContentAfter = await readCursorignore(plan.root);
         const claudeSettingsAfter = await readClaudeSettings(plan.root);
         const codexConfigAfter = await readCodexConfig(plan.root);
+        const geminiignoreAfter = await readSimpleIgnore(plan.root, ".geminiignore");
+        const aiderignoreAfter = await readSimpleIgnore(plan.root, ".aiderignore");
         process.stdout.write(renderFixPlanTerminal(plan, {
             dryRun: false,
             cursorContent: cursorContentAfter,
             claudeSettingsContent: claudeSettingsAfter,
             codexConfigContent: codexConfigAfter,
+            geminiignoreContent: geminiignoreAfter,
+            aiderignoreContent: aiderignoreAfter,
             applyResult,
         }));
+        if (applyResult.error) {
+            console.error(`Error: ${applyResult.error}`);
+            return isFixConfigOrPermissionError(applyResult.error)
+                ? EXIT_CODES.USAGE_ERROR
+                : EXIT_CODES.INTERNAL_ERROR;
+        }
         if (applyResult.writtenFiles.length > 0) {
             const after = await scan({ cwd: target });
             const remainingSafeContext = after.findings.filter((f) => f.fixability === "safe" &&
@@ -73,8 +91,10 @@ export async function runFixCommand(options) {
 }
 function isFixConfigOrPermissionError(message) {
     return (message.includes("refusing") ||
+        message.includes("not allowlisted") ||
         message.includes("not valid JSON") ||
         message.includes("EACCES") ||
         message.includes("EPERM") ||
-        message.includes("permission denied"));
+        message.includes("permission denied") ||
+        message.includes("symlink"));
 }

package/dist/cli/commands/mcp.d.ts

@@ -0,0 +1,8 @@
+import type { ExitCode } from "../../types/index.js";
+/**
+ * Start combined AgentDoctor MCP (Brain tools + intelligence tools) over STDIO.
+ */
+export declare function runMcpCommand(options: {
+    root: string;
+    buildIfMissing?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/mcp.js

@@ -0,0 +1,14 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { runAgentDoctorMcpStdio } from "../../mcp/agentdoctor/server.js";
+/**
+ * Start combined AgentDoctor MCP (Brain tools + intelligence tools) over STDIO.
+ */
+export async function runMcpCommand(options) {
+    const root = resolveRepoRoot(options.root);
+    await runAgentDoctorMcpStdio({
+        root,
+        buildIfMissing: options.buildIfMissing !== false,
+    });
+    return EXIT_CODES.SUCCESS;
+}

package/dist/cli/commands/platform.d.ts

@@ -0,0 +1,15 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runPlatformCommand(options: {
+    action: string;
+    root?: string;
+    json?: boolean;
+    query?: string;
+    symbol?: string;
+    left?: string;
+    right?: string;
+    command?: string;
+    path?: string;
+    actionType?: string;
+    sessionId?: string;
+    failClosed?: boolean;
+}): Promise<ExitCode>;