@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/intelligence/graph/incremental.js

@@ -0,0 +1,234 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { PACKAGE_VERSION } from "../../constants.js";
+import { resolveRepoRoot, toPosixRelative } from "../../utils/path.js";
+import { atomicWriteTextFile } from "../../utils/fs.js";
+import { buildIntelligenceGraph, listTsFiles } from "./build.js";
+export const GRAPH_INDEX_SCHEMA = "1.0.0";
+function indexPath(root) {
+    return path.join(root, ".agentdoctor", "graph", "index.json");
+}
+function sha256FileContent(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+async function hashFiles(root, absFiles) {
+    const out = {};
+    for (const abs of absFiles) {
+        const rel = toPosixRelative(root, abs);
+        try {
+            const buf = await fs.readFile(abs);
+            out[rel] = sha256FileContent(buf);
+        }
+        catch {
+            // skip unreadable
+        }
+    }
+    return out;
+}
+function gitChangedFiles(root) {
+    const run = (args) => {
+        const r = spawnSync("git", args, { cwd: root, encoding: "utf8" });
+        return r.status === 0 && typeof r.stdout === "string" ? r.stdout : null;
+    };
+    const staged = run(["diff", "--name-only", "--cached"]);
+    const unstaged = run(["diff", "--name-only"]);
+    const untracked = run(["ls-files", "--others", "--exclude-standard"]);
+    if (staged === null && unstaged === null && untracked === null)
+        return null;
+    const set = new Set();
+    for (const block of [staged, unstaged, untracked]) {
+        if (!block)
+            continue;
+        for (const line of block.split("\n")) {
+            const t = line.trim();
+            if (t)
+                set.add(t.split(path.sep).join("/"));
+        }
+    }
+    return [...set].sort();
+}
+function isValidSnapshot(raw) {
+    if (!raw || typeof raw !== "object")
+        return false;
+    const s = raw;
+    return (typeof s.schemaVersion === "string" &&
+        typeof s.root === "string" &&
+        typeof s.generatedAt === "string" &&
+        s.fileHashes !== null &&
+        typeof s.fileHashes === "object" &&
+        Array.isArray(s.nodes) &&
+        Array.isArray(s.edges));
+}
+async function loadSnapshot(root) {
+    const file = indexPath(root);
+    try {
+        const raw = await fs.readFile(file, "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return { ok: false, corrupt: true, error: "index.json is not valid JSON" };
+        }
+        if (!isValidSnapshot(parsed)) {
+            return { ok: false, corrupt: true, error: "index.json failed schema checks" };
+        }
+        return { ok: true, snapshot: parsed };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            corrupt: false,
+            error: error instanceof Error ? error.message : "index missing",
+        };
+    }
+}
+async function persistSnapshot(root, snapshot) {
+    const file = indexPath(root);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await atomicWriteTextFile(file, `${JSON.stringify(snapshot, null, 2)}\n`);
+    return file;
+}
+async function buildAndPersist(root, mode = "auto") {
+    const graph = await buildIntelligenceGraph({ root, mode });
+    const files = await listTsFiles(root);
+    const fileHashes = await hashFiles(root, files);
+    const snapshot = {
+        schemaVersion: GRAPH_INDEX_SCHEMA,
+        agentDoctorVersion: PACKAGE_VERSION,
+        root,
+        generatedAt: graph.generatedAt,
+        builder: graph.builder,
+        astFilesParsed: graph.astFilesParsed,
+        fileHashes,
+        nodes: graph.nodes,
+        edges: graph.edges,
+        limitations: [
+            ...graph.limitations,
+            "Incremental index persists file hashes for change detection",
+        ],
+    };
+    const saved = await persistSnapshot(root, snapshot);
+    return { snapshot, path: saved };
+}
+/**
+ * Full graph build and persist to `.agentdoctor/graph/index.json`.
+ */
+export async function graphBuild(options) {
+    const root = resolveRepoRoot(options.root);
+    const result = await buildAndPersist(root, options.mode ?? "auto");
+    return { ...result, rebuilt: true };
+}
+/**
+ * Force full rebuild (same as build, clears prior assumptions).
+ */
+export async function graphRebuild(options) {
+    return graphBuild(options);
+}
+/**
+ * Update graph from git-changed files or content-hash comparison.
+ * On corruption → rebuild. When nothing changed → reuse snapshot.
+ */
+export async function graphUpdate(options) {
+    const root = resolveRepoRoot(options.root);
+    const loaded = await loadSnapshot(root);
+    if (!loaded.ok) {
+        if (loaded.corrupt) {
+            const result = await buildAndPersist(root, options.mode ?? "auto");
+            return {
+                ...result,
+                rebuilt: true,
+                reason: `corrupt index rebuilt: ${loaded.error}`,
+                changedFiles: Object.keys(result.snapshot.fileHashes),
+            };
+        }
+        const result = await buildAndPersist(root, options.mode ?? "auto");
+        return {
+            ...result,
+            rebuilt: true,
+            reason: "no prior index; built fresh",
+            changedFiles: Object.keys(result.snapshot.fileHashes),
+        };
+    }
+    const files = await listTsFiles(root);
+    const currentHashes = await hashFiles(root, files);
+    const prev = loaded.snapshot.fileHashes;
+    const changedFromHash = [];
+    for (const [rel, hash] of Object.entries(currentHashes)) {
+        if (prev[rel] !== hash)
+            changedFromHash.push(rel);
+    }
+    for (const rel of Object.keys(prev)) {
+        if (!(rel in currentHashes))
+            changedFromHash.push(rel);
+    }
+    const gitFiles = gitChangedFiles(root);
+    const tsGitChanged = gitFiles?.filter((f) => /\.(ts|tsx|mts|cts)$/i.test(f) && !f.endsWith(".d.ts")) ?? [];
+    const changedSet = new Set([...changedFromHash, ...tsGitChanged]);
+    const changedFiles = [...changedSet].sort();
+    if (changedFiles.length === 0) {
+        return {
+            snapshot: loaded.snapshot,
+            path: indexPath(root),
+            rebuilt: false,
+            reason: "file hashes unchanged; snapshot reused",
+            changedFiles: [],
+        };
+    }
+    // Incremental: drop nodes/edges for changed paths, re-run full builder for correctness
+    // (TypeScript program needs whole set; hash gate already skipped no-op updates).
+    const result = await buildAndPersist(root, options.mode ?? "auto");
+    return {
+        ...result,
+        rebuilt: true,
+        reason: `updated ${changedFiles.length} changed file(s)`,
+        changedFiles,
+    };
+}
+export async function graphStatus(options) {
+    const root = resolveRepoRoot(options.root);
+    const file = indexPath(root);
+    const loaded = await loadSnapshot(root);
+    if (!loaded.ok) {
+        return {
+            present: false,
+            path: file,
+            nodeCount: 0,
+            edgeCount: 0,
+            fileCount: 0,
+            corrupt: loaded.corrupt,
+            error: loaded.error,
+            staleFiles: [],
+            missingFiles: [],
+        };
+    }
+    const files = await listTsFiles(root);
+    const currentHashes = await hashFiles(root, files);
+    const prev = loaded.snapshot.fileHashes;
+    const staleFiles = [];
+    const missingFiles = [];
+    for (const [rel, hash] of Object.entries(currentHashes)) {
+        if (!(rel in prev))
+            staleFiles.push(rel);
+        else if (prev[rel] !== hash)
+            staleFiles.push(rel);
+    }
+    for (const rel of Object.keys(prev)) {
+        if (!(rel in currentHashes))
+            missingFiles.push(rel);
+    }
+    return {
+        present: true,
+        path: file,
+        schemaVersion: loaded.snapshot.schemaVersion,
+        builder: String(loaded.snapshot.builder),
+        nodeCount: loaded.snapshot.nodes.length,
+        edgeCount: loaded.snapshot.edges.length,
+        fileCount: Object.keys(prev).length,
+        generatedAt: loaded.snapshot.generatedAt,
+        staleFiles: staleFiles.sort(),
+        missingFiles: missingFiles.sort(),
+    };
+}

package/dist/intelligence/resolve/imports.d.ts

@@ -0,0 +1,36 @@
+export type ImportConfidence = "EXACT" | "RESOLVED" | "INFERRED" | "UNRESOLVED";
+export interface TsconfigPathsConfig {
+    baseUrl: string;
+    paths: Record<string, string[]>;
+    configPath: string;
+}
+export interface ImportResolutionResult {
+    specifier: string;
+    fromFile: string;
+    resolvedPath: string | null;
+    confidence: ImportConfidence;
+    via?: string;
+}
+/**
+ * Read tsconfig.json paths/baseUrl when present. Returns null when absent or unreadable.
+ * Does not invent mappings.
+ */
+export declare function loadTsconfigPaths(root: string): TsconfigPathsConfig | null;
+/**
+ * Resolve an import specifier relative to `fromFile` (repo-relative POSIX).
+ * Never invents a path for UNRESOLVED — `resolvedPath` is null.
+ */
+export declare function resolveImportSpecifier(options: {
+    root: string;
+    fromFile: string;
+    specifier: string;
+    tsconfig?: TsconfigPathsConfig | null;
+    fileExists?: (absolutePath: string) => boolean;
+}): ImportResolutionResult;
+/**
+ * Resolve many import edges; filters to those with a concrete resolved path.
+ */
+export declare function resolveImportEdges(root: string, imports: Array<{
+    fromFile: string;
+    specifier: string;
+}>, tsconfig?: TsconfigPathsConfig | null): ImportResolutionResult[];

package/dist/intelligence/resolve/imports.js

@@ -0,0 +1,245 @@
+import fs from "node:fs";
+import path from "node:path";
+const FILE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+function fileExists(abs, existsFn) {
+    if (existsFn)
+        return existsFn(abs);
+    try {
+        return fs.statSync(abs).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function dirExists(abs, existsFn) {
+    if (existsFn) {
+        // Approximate: any index file under the dir.
+        return FILE_EXTENSIONS.some((ext) => existsFn(path.join(abs, `index${ext}`)));
+    }
+    try {
+        return fs.statSync(abs).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Try exact file, extension variants, then index/barrel.
+ * Returns confidence EXACT when the written path exists as-is,
+ * RESOLVED when found via extension or index.
+ */
+function resolveFilesystemCandidate(root, absWithoutExt, existsFn) {
+    const tryFile = (abs, confidence, via) => {
+        if (fileExists(abs, existsFn)) {
+            return { abs, confidence, via };
+        }
+        return null;
+    };
+    const exact = tryFile(absWithoutExt, "EXACT", "exact");
+    if (exact)
+        return exact;
+    for (const ext of FILE_EXTENSIONS) {
+        if (absWithoutExt.endsWith(ext))
+            continue;
+        const hit = tryFile(`${absWithoutExt}${ext}`, "RESOLVED", `extension:${ext}`);
+        if (hit)
+            return hit;
+    }
+    if (dirExists(absWithoutExt, existsFn)) {
+        for (const ext of FILE_EXTENSIONS) {
+            const hit = tryFile(path.join(absWithoutExt, `index${ext}`), "RESOLVED", `index:index${ext}`);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
+function stripJsonComments(text) {
+    // Minimal strip for // and /* */ outside strings — enough for typical tsconfig.
+    let out = "";
+    let i = 0;
+    let inString = null;
+    while (i < text.length) {
+        const ch = text[i];
+        if (inString) {
+            out += ch;
+            if (ch === "\\" && i + 1 < text.length) {
+                out += text[i + 1];
+                i += 2;
+                continue;
+            }
+            if (ch === inString)
+                inString = null;
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = ch;
+            out += ch;
+            i += 1;
+            continue;
+        }
+        if (ch === "/" && text[i + 1] === "/") {
+            i += 2;
+            while (i < text.length && text[i] !== "\n")
+                i += 1;
+            continue;
+        }
+        if (ch === "/" && text[i + 1] === "*") {
+            i += 2;
+            while (i + 1 < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+                i += 1;
+            i += 2;
+            continue;
+        }
+        // Trailing commas before } or ]
+        if (ch === "," && (text.slice(i + 1).match(/^\s*[}\]]/) ?? false)) {
+            i += 1;
+            continue;
+        }
+        out += ch;
+        i += 1;
+    }
+    return out;
+}
+/**
+ * Read tsconfig.json paths/baseUrl when present. Returns null when absent or unreadable.
+ * Does not invent mappings.
+ */
+export function loadTsconfigPaths(root) {
+    const configPath = path.join(root, "tsconfig.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(stripJsonComments(raw));
+        const baseUrl = parsed.compilerOptions?.baseUrl ?? ".";
+        const paths = parsed.compilerOptions?.paths ?? {};
+        return { baseUrl, paths, configPath };
+    }
+    catch {
+        return null;
+    }
+}
+function matchTsconfigPath(specifier, config) {
+    const entries = Object.entries(config.paths);
+    // Prefer longest pattern key for specificity.
+    entries.sort((a, b) => b[0].length - a[0].length);
+    for (const [pattern, targets] of entries) {
+        if (!targets.length)
+            continue;
+        if (pattern.includes("*")) {
+            const [prefix, suffix] = pattern.split("*");
+            if (typeof prefix === "string" &&
+                typeof suffix === "string" &&
+                specifier.startsWith(prefix) &&
+                specifier.endsWith(suffix)) {
+                const star = specifier.slice(prefix.length, specifier.length - suffix.length);
+                const target = targets[0];
+                const mapped = target.includes("*") ? target.replace("*", star) : target;
+                return { mapped, pattern };
+            }
+        }
+        else if (specifier === pattern) {
+            return { mapped: targets[0], pattern };
+        }
+    }
+    return null;
+}
+/**
+ * Resolve an import specifier relative to `fromFile` (repo-relative POSIX).
+ * Never invents a path for UNRESOLVED — `resolvedPath` is null.
+ */
+export function resolveImportSpecifier(options) {
+    const { root, fromFile, specifier } = options;
+    const fromPosix = toPosix(fromFile);
+    const base = {
+        specifier,
+        fromFile: fromPosix,
+    };
+    if (!specifier || specifier.includes("\0")) {
+        return { ...base, resolvedPath: null, confidence: "UNRESOLVED" };
+    }
+    const existsFn = options.fileExists;
+    const toRel = (abs) => toPosix(path.relative(root, abs));
+    // Relative imports
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+        const fromDir = path.dirname(path.join(root, fromPosix));
+        const abs = path.resolve(fromDir, specifier);
+        // Containment: refuse escaping the repo when resolving relatives.
+        const rel = path.relative(root, abs);
+        if (rel.startsWith("..") || path.isAbsolute(rel)) {
+            return { ...base, resolvedPath: null, confidence: "UNRESOLVED" };
+        }
+        const hit = resolveFilesystemCandidate(root, abs, existsFn);
+        if (!hit) {
+            return { ...base, resolvedPath: null, confidence: "UNRESOLVED" };
+        }
+        return {
+            ...base,
+            resolvedPath: toRel(hit.abs),
+            confidence: hit.confidence,
+            via: hit.via,
+        };
+    }
+    // tsconfig paths / baseUrl (non-relative)
+    const tsconfig = options.tsconfig === undefined ? loadTsconfigPaths(root) : options.tsconfig;
+    if (tsconfig) {
+        const matched = matchTsconfigPath(specifier, tsconfig);
+        if (matched) {
+            const abs = path.resolve(root, tsconfig.baseUrl, matched.mapped);
+            const rel = path.relative(root, abs);
+            if (rel.startsWith("..") || path.isAbsolute(rel)) {
+                return { ...base, resolvedPath: null, confidence: "UNRESOLVED" };
+            }
+            const hit = resolveFilesystemCandidate(root, abs, existsFn);
+            if (hit) {
+                return {
+                    ...base,
+                    resolvedPath: toRel(hit.abs),
+                    confidence: "RESOLVED",
+                    via: `tsconfig-paths:${matched.pattern}`,
+                };
+            }
+            // Pattern matched but file missing — do not invent.
+            return { ...base, resolvedPath: null, confidence: "UNRESOLVED", via: "tsconfig-paths-miss" };
+        }
+        // baseUrl bare specifier (e.g. "utils/foo" with baseUrl=src) — INFERRED only when found.
+        if (!specifier.startsWith(".") && !specifier.includes(":")) {
+            const abs = path.resolve(root, tsconfig.baseUrl, specifier);
+            const rel = path.relative(root, abs);
+            if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+                const hit = resolveFilesystemCandidate(root, abs, existsFn);
+                if (hit) {
+                    return {
+                        ...base,
+                        resolvedPath: toRel(hit.abs),
+                        confidence: "INFERRED",
+                        via: "tsconfig-baseUrl",
+                    };
+                }
+            }
+        }
+    }
+    // Package / URL / unknown — unresolved; never invent a repo edge.
+    return { ...base, resolvedPath: null, confidence: "UNRESOLVED" };
+}
+/**
+ * Resolve many import edges; filters to those with a concrete resolved path.
+ */
+export function resolveImportEdges(root, imports, tsconfig) {
+    const cfg = tsconfig === undefined ? loadTsconfigPaths(root) : tsconfig;
+    return imports.map((item) => resolveImportSpecifier({
+        root,
+        fromFile: item.fromFile,
+        specifier: item.specifier,
+        tsconfig: cfg,
+    }));
+}

package/dist/knowledge/store.d.ts

@@ -0,0 +1,25 @@
+import type { KnowledgeRecordContract, KnowledgeStatus } from "../contracts/index.js";
+import type { StorageProvider } from "../contracts/index.js";
+export declare function createKnowledgeRecord(options: {
+    root: string;
+    title: string;
+    content: string;
+    status?: KnowledgeStatus;
+    owner?: string;
+    storage?: StorageProvider;
+}): Promise<KnowledgeRecordContract>;
+export declare function transitionKnowledge(options: {
+    root: string;
+    id: string;
+    to: KnowledgeStatus;
+    by?: string;
+    note?: string;
+    storage?: StorageProvider;
+}): Promise<KnowledgeRecordContract>;
+export declare function listKnowledge(root: string, storage?: StorageProvider): Promise<KnowledgeRecordContract[]>;
+/** Authoritative retrieval abstains when no approved record matches. */
+export declare function retrieveAuthoritative(records: KnowledgeRecordContract[], query: string): {
+    record: KnowledgeRecordContract | null;
+    abstain: boolean;
+    reason: string;
+};

package/dist/knowledge/store.js

@@ -0,0 +1,91 @@
+import { createHash, randomUUID } from "node:crypto";
+import { FilesystemStorageProvider } from "../storage/provider.js";
+import { resolveRepoRoot } from "../utils/path.js";
+function kid(title) {
+    return `know_${createHash("sha1").update(title).digest("hex").slice(0, 12)}`;
+}
+export async function createKnowledgeRecord(options) {
+    const storage = options.storage ?? new FilesystemStorageProvider(options.root, ".agentdoctor/knowledge");
+    const record = {
+        id: kid(`${options.title}:${randomUUID()}`),
+        title: options.title,
+        content: options.content,
+        status: options.status ?? "draft",
+        owner: options.owner ?? null,
+        approver: null,
+        version: "1",
+        evidence: [
+            {
+                id: "ev_create",
+                kind: "proposed",
+                detail: "Created via knowledge governance API",
+            },
+        ],
+        relatedRepositoryId: resolveRepoRoot(options.root),
+        changeHistory: [
+            {
+                at: new Date().toISOString(),
+                note: "created",
+                to: options.status ?? "draft",
+                ...(options.owner ? { by: options.owner } : {}),
+            },
+        ],
+    };
+    await storage.set(`records/${record.id}.json`, `${JSON.stringify(record, null, 2)}\n`);
+    return record;
+}
+export async function transitionKnowledge(options) {
+    const storage = options.storage ?? new FilesystemStorageProvider(options.root, ".agentdoctor/knowledge");
+    const raw = await storage.get(`records/${options.id}.json`);
+    if (!raw)
+        throw new Error(`knowledge record not found: ${options.id}`);
+    const record = JSON.parse(raw);
+    const from = record.status;
+    // Authority: only pending-review/draft/proposed can become approved via explicit transition
+    if (options.to === "approved" && !["draft", "proposed", "pending-review"].includes(from)) {
+        throw new Error(`cannot approve from status ${from}`);
+    }
+    record.status = options.to;
+    if (options.to === "approved") {
+        record.approver = options.by ?? "local-approver";
+        record.effectiveAt = new Date().toISOString();
+    }
+    record.changeHistory.push({
+        at: new Date().toISOString(),
+        note: options.note ?? `transition ${from} -> ${options.to}`,
+        from,
+        to: options.to,
+        ...(options.by ? { by: options.by } : {}),
+    });
+    record.version = String(Number(record.version || "1") + 1);
+    await storage.set(`records/${record.id}.json`, `${JSON.stringify(record, null, 2)}\n`);
+    return record;
+}
+export async function listKnowledge(root, storage) {
+    const store = storage ?? new FilesystemStorageProvider(root, ".agentdoctor/knowledge");
+    const keys = await store.list("records");
+    const out = [];
+    for (const key of keys) {
+        if (!key.endsWith(".json"))
+            continue;
+        const raw = await store.get(key.startsWith("records/") ? key : `records/${key}`);
+        if (!raw)
+            continue;
+        out.push(JSON.parse(raw));
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+/** Authoritative retrieval abstains when no approved record matches. */
+export function retrieveAuthoritative(records, query) {
+    const q = query.toLowerCase();
+    const approved = records.filter((r) => r.status === "approved" &&
+        (r.title.toLowerCase().includes(q) || r.content.toLowerCase().includes(q)));
+    if (approved.length === 0) {
+        return {
+            record: null,
+            abstain: true,
+            reason: "No approved authoritative knowledge matched the query",
+        };
+    }
+    return { record: approved[0], abstain: false, reason: "approved match" };
+}

package/dist/languages/go.d.ts

@@ -0,0 +1,9 @@
+import type { LanguageAdapter } from "./types.js";
+/**
+ * Go toolchain bridge placeholder.
+ * Prefer real `go/ast` via `go run` when the Go toolchain is present; until an
+ * extractor is bundled, capability remains unsupported even if `go` exists.
+ * Today: always unsupported (no bundled extractor; avoids fake AST claims).
+ */
+export declare function goAvailable(): boolean;
+export declare const goAdapter: LanguageAdapter;

package/dist/languages/go.js

@@ -0,0 +1,45 @@
+import { spawnSync } from "node:child_process";
+/**
+ * Go toolchain bridge placeholder.
+ * Prefer real `go/ast` via `go run` when the Go toolchain is present; until an
+ * extractor is bundled, capability remains unsupported even if `go` exists.
+ * Today: always unsupported (no bundled extractor; avoids fake AST claims).
+ */
+export function goAvailable() {
+    const r = spawnSync("go", ["version"], { encoding: "utf8" });
+    return r.status === 0;
+}
+export const goAdapter = {
+    id: "go",
+    extensions: [".go"],
+    capabilities: () => ({
+        parse: "unsupported",
+        symbols: "unsupported",
+        definitions: "unsupported",
+        references: "unsupported",
+        imports: "unsupported",
+        calls: "unsupported",
+        diagnostics: "unsupported",
+    }),
+    async parse(filePath, _source) {
+        const hasGo = goAvailable();
+        return {
+            language: "go",
+            file: filePath,
+            ok: false,
+            capabilities: goAdapter.capabilities(),
+            symbols: [],
+            imports: [],
+            calls: [],
+            diagnostics: [
+                hasGo
+                    ? "Go toolchain present but AgentDoctor go/ast extractor is not bundled yet"
+                    : "go not available on PATH",
+            ],
+            limitations: [
+                "Go AST requires a go/ast bridge or tree-sitter-go; not shipped in this package",
+                "Capability remains unsupported — no regex fallback under an AST claim",
+            ],
+        };
+    },
+};