@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/integrations/local-ai/provider.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Optional local AI integration.
+ * Core AgentDoctor never requires a model. Providers are opt-in and must redact
+ * sensitive content before any optional call. AI output must not bypass Safe Fix.
+ */
+export type LocalAiProviderId = "none" | "mock" | "ollama";
+export interface LocalAiRequest {
+    prompt: string;
+    /** Already-redacted context snippets only */
+    context: string[];
+    maxTokens?: number;
+    timeoutMs?: number;
+}
+export interface LocalAiResponse {
+    provider: LocalAiProviderId;
+    text: string;
+    /** Always true for AI-generated content so callers can label output */
+    aiGenerated: true;
+    truncated: boolean;
+    error?: string;
+}
+export interface LocalAiProvider {
+    id: LocalAiProviderId;
+    generate(request: LocalAiRequest): Promise<LocalAiResponse>;
+}
+export declare function redactForModel(text: string): string;
+export declare class NoneAiProvider implements LocalAiProvider {
+    id: LocalAiProviderId;
+    generate(_request: LocalAiRequest): Promise<LocalAiResponse>;
+}
+export declare class MockAiProvider implements LocalAiProvider {
+    id: LocalAiProviderId;
+    generate(request: LocalAiRequest): Promise<LocalAiResponse>;
+}
+/**
+ * Ollama provider stub: documents integration without requiring ollama installed.
+ * Calls fail closed with a clear error when the daemon is unavailable.
+ */
+export declare class OllamaAiProvider implements LocalAiProvider {
+    private readonly endpoint;
+    id: LocalAiProviderId;
+    constructor(endpoint?: string);
+    generate(request: LocalAiRequest): Promise<LocalAiResponse>;
+}
+export declare function createLocalAiProvider(id: LocalAiProviderId): LocalAiProvider;

package/dist/integrations/local-ai/provider.js

@@ -0,0 +1,104 @@
+/**
+ * Optional local AI integration.
+ * Core AgentDoctor never requires a model. Providers are opt-in and must redact
+ * sensitive content before any optional call. AI output must not bypass Safe Fix.
+ */
+const REDACT = /\b(AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{36}|-----BEGIN [^-]+PRIVATE KEY-----)/g;
+export function redactForModel(text) {
+    return text.replace(REDACT, "[REDACTED]");
+}
+export class NoneAiProvider {
+    id = "none";
+    async generate(_request) {
+        return {
+            provider: "none",
+            text: "",
+            aiGenerated: true,
+            truncated: false,
+            error: "Local AI disabled (deterministic mode)",
+        };
+    }
+}
+export class MockAiProvider {
+    id = "mock";
+    async generate(request) {
+        const joined = redactForModel([request.prompt, ...request.context].join("\n"));
+        const max = request.maxTokens ?? 256;
+        const text = `[AI-GENERATED mock] Summary of ${joined.length} redacted chars.`.slice(0, max);
+        return {
+            provider: "mock",
+            text,
+            aiGenerated: true,
+            truncated: joined.length > max,
+        };
+    }
+}
+/**
+ * Ollama provider stub: documents integration without requiring ollama installed.
+ * Calls fail closed with a clear error when the daemon is unavailable.
+ */
+export class OllamaAiProvider {
+    endpoint;
+    id = "ollama";
+    constructor(endpoint = "http://127.0.0.1:11434") {
+        this.endpoint = endpoint;
+    }
+    async generate(request) {
+        const timeoutMs = request.timeoutMs ?? 5_000;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const prompt = redactForModel(`${request.prompt}\n\n${request.context.map(redactForModel).join("\n")}`.slice(0, 8_000));
+            const res = await fetch(`${this.endpoint}/api/generate`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    model: "llama3.2",
+                    prompt,
+                    stream: false,
+                    options: { num_predict: request.maxTokens ?? 256 },
+                }),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                return {
+                    provider: "ollama",
+                    text: "",
+                    aiGenerated: true,
+                    truncated: false,
+                    error: `ollama HTTP ${res.status}`,
+                };
+            }
+            const data = (await res.json());
+            return {
+                provider: "ollama",
+                text: `[AI-GENERATED] ${String(data.response ?? "").trim()}`,
+                aiGenerated: true,
+                truncated: false,
+            };
+        }
+        catch (error) {
+            return {
+                provider: "ollama",
+                text: "",
+                aiGenerated: true,
+                truncated: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+export function createLocalAiProvider(id) {
+    switch (id) {
+        case "mock":
+            return new MockAiProvider();
+        case "ollama":
+            return new OllamaAiProvider();
+        case "none":
+        default:
+            return new NoneAiProvider();
+    }
+}

package/dist/intelligence/git/analyze.d.ts

@@ -0,0 +1,34 @@
+export interface HotspotFile {
+    path: string;
+    commits: number;
+    authors: string[];
+    busFactor: number;
+    method: string;
+}
+export interface GitIntelligenceReport {
+    root: string;
+    gitAvailable: boolean;
+    hotspots: HotspotFile[];
+    coChanges: Array<{
+        a: string;
+        b: string;
+        together: number;
+        method: string;
+    }>;
+    limitations: string[];
+}
+/**
+ * Git engineering intelligence — methods disclosed on every metric.
+ */
+export declare function analyzeGitIntelligence(rootInput: string): Promise<GitIntelligenceReport>;
+export declare function deadCodeCategory(options: {
+    exported: boolean;
+    referenced: boolean;
+    frameworkEntry: boolean;
+    dynamicHint: boolean;
+}): {
+    category: "confirmed-unreachable" | "probably-unused" | "possibly-unused" | "public-api" | "framework-discovered" | "reflection-sensitive" | "dynamic-reference-risk" | "unknown";
+    confidence: number;
+    explanation: string;
+};
+export declare function stableMetricId(kind: string, path: string): string;

package/dist/intelligence/git/analyze.js

@@ -0,0 +1,136 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { resolveRepoRoot } from "../../utils/path.js";
+function git(root, args) {
+    const r = spawnSync("git", args, {
+        cwd: root,
+        encoding: "utf8",
+        maxBuffer: 16 * 1024 * 1024,
+    });
+    return { ok: r.status === 0, out: typeof r.stdout === "string" ? r.stdout : "" };
+}
+/**
+ * Git engineering intelligence — methods disclosed on every metric.
+ */
+export async function analyzeGitIntelligence(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const probe = git(root, ["rev-parse", "--is-inside-work-tree"]);
+    if (!probe.ok || probe.out.trim() !== "true") {
+        return {
+            root,
+            gitAvailable: false,
+            hotspots: [],
+            coChanges: [],
+            limitations: ["Requires a git repository"],
+        };
+    }
+    const log = git(root, ["log", "--name-only", "--pretty=format:===%an", "-n", "200"]);
+    const authorsByFile = new Map();
+    const commitsByFile = new Map();
+    const commitFiles = [];
+    let currentAuthor = "unknown";
+    let bucket = [];
+    for (const line of log.out.split(/\r?\n/)) {
+        if (line.startsWith("===")) {
+            if (bucket.length)
+                commitFiles.push(bucket);
+            bucket = [];
+            currentAuthor = line.slice(3).trim() || "unknown";
+            continue;
+        }
+        const file = line.trim();
+        if (!file || file.includes("\0"))
+            continue;
+        bucket.push(file);
+        commitsByFile.set(file, (commitsByFile.get(file) ?? 0) + 1);
+        if (!authorsByFile.has(file))
+            authorsByFile.set(file, new Set());
+        authorsByFile.get(file).add(currentAuthor);
+    }
+    if (bucket.length)
+        commitFiles.push(bucket);
+    const hotspots = [...commitsByFile.entries()]
+        .map(([path, commits]) => {
+        const authors = [...(authorsByFile.get(path) ?? [])].sort();
+        return {
+            path,
+            commits,
+            authors,
+            busFactor: authors.length,
+            method: "count of file appearances in last ≤200 commits; busFactor=distinct authors in that window",
+        };
+    })
+        .sort((a, b) => b.commits - a.commits || a.path.localeCompare(b.path))
+        .slice(0, 50);
+    const pairCounts = new Map();
+    for (const files of commitFiles) {
+        const uniq = [...new Set(files)].sort();
+        for (let i = 0; i < uniq.length; i += 1) {
+            for (let j = i + 1; j < Math.min(uniq.length, i + 8); j += 1) {
+                const key = `${uniq[i]}||${uniq[j]}`;
+                pairCounts.set(key, (pairCounts.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    const coChanges = [...pairCounts.entries()]
+        .filter(([, n]) => n >= 2)
+        .map(([key, together]) => {
+        const [a, b] = key.split("||");
+        return {
+            a: a,
+            b: b,
+            together,
+            method: "pair co-occurrence in same commit (window ≤200; capped pairs per commit)",
+        };
+    })
+        .sort((x, y) => y.together - x.together)
+        .slice(0, 40);
+    return {
+        root,
+        gitAvailable: true,
+        hotspots,
+        coChanges,
+        limitations: [
+            "Hotspots use recent commit window only (not full history)",
+            "Bus factor is author cardinality in window — not organizational coverage",
+            "Bug-fix history is not classified in this MVP",
+        ],
+    };
+}
+export function deadCodeCategory(options) {
+    if (options.frameworkEntry) {
+        return {
+            category: "framework-discovered",
+            confidence: 0.4,
+            explanation: "Looks like a framework entry — do not mark dead without framework adapter proof",
+        };
+    }
+    if (options.dynamicHint) {
+        return {
+            category: "dynamic-reference-risk",
+            confidence: 0.3,
+            explanation: "Dynamic/reflection-style reference risk",
+        };
+    }
+    if (options.exported && !options.referenced) {
+        return {
+            category: "public-api",
+            confidence: 0.55,
+            explanation: "Exported but no static references observed — may be public API",
+        };
+    }
+    if (!options.exported && !options.referenced) {
+        return {
+            category: "possibly-unused",
+            confidence: 0.5,
+            explanation: "No static references; not confirmed unreachable across all loaders",
+        };
+    }
+    if (!options.exported && options.referenced) {
+        return { category: "unknown", confidence: 0.2, explanation: "Referenced locally" };
+    }
+    return { category: "unknown", confidence: 0.2, explanation: "Insufficient evidence" };
+}
+export function stableMetricId(kind, path) {
+    return `git_${createHash("sha1").update(`${kind}:${path}`).digest("hex").slice(0, 12)}`;
+}

package/dist/intelligence/graph/build.d.ts

@@ -0,0 +1,15 @@
+import type { RepositoryGraph } from "../../platform/types.js";
+export type GraphBuilderMode = "regex" | "typescript-ast" | "auto";
+export declare function nodeId(kind: string, key: string): string;
+export declare function listTsFiles(root: string, limit?: number): Promise<string[]>;
+/**
+ * TypeScript compiler API based graph enrichment.
+ * Falls back to regex graph when mode=regex or on failure.
+ */
+export declare function buildIntelligenceGraph(options: {
+    root: string;
+    mode?: GraphBuilderMode;
+}): Promise<RepositoryGraph & {
+    builder: GraphBuilderMode;
+    astFilesParsed: number;
+}>;

package/dist/intelligence/graph/build.js

@@ -0,0 +1,259 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import ts from "typescript";
+import { resolveRepoRoot, toPosixRelative } from "../../utils/path.js";
+import { buildRepositoryGraph } from "../../platform/graph/build.js";
+import { CONTRACTS_VERSION } from "../../contracts/index.js";
+import { loadTsconfigPaths, resolveImportSpecifier, } from "../resolve/imports.js";
+function evidenceForConfidence(confidence) {
+    if (confidence === "EXACT")
+        return "verified";
+    if (confidence === "RESOLVED" || confidence === "INFERRED")
+        return "inferred";
+    return "unknown";
+}
+export function nodeId(kind, key) {
+    return `${kind}:${createHash("sha1").update(key).digest("hex").slice(0, 12)}`;
+}
+export async function listTsFiles(root, limit = 400) {
+    const out = [];
+    const skip = new Set(["node_modules", ".git", "dist", "coverage", ".agentdoctor", "vendor"]);
+    async function walk(dir) {
+        if (out.length >= limit)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (skip.has(e.name))
+                continue;
+            const abs = path.join(dir, e.name);
+            if (e.isSymbolicLink())
+                continue;
+            if (e.isDirectory()) {
+                await walk(abs);
+                continue;
+            }
+            if (/\.(ts|tsx|mts|cts)$/i.test(e.name) && !e.name.endsWith(".d.ts")) {
+                out.push(abs);
+            }
+        }
+    }
+    await walk(root);
+    return out.sort();
+}
+/**
+ * TypeScript compiler API based graph enrichment.
+ * Falls back to regex graph when mode=regex or on failure.
+ */
+export async function buildIntelligenceGraph(options) {
+    const root = resolveRepoRoot(options.root);
+    const mode = options.mode ?? "auto";
+    if (mode === "regex") {
+        const g = await buildRepositoryGraph(root);
+        return { ...g, builder: "regex", astFilesParsed: 0 };
+    }
+    try {
+        const files = await listTsFiles(root);
+        if (files.length === 0) {
+            const g = await buildRepositoryGraph(root);
+            return {
+                ...g,
+                builder: "regex",
+                astFilesParsed: 0,
+                limitations: [
+                    ...g.limitations,
+                    "No TypeScript sources found for AST builder; used regex fallback",
+                ],
+            };
+        }
+        const program = ts.createProgram({
+            rootNames: files,
+            options: {
+                allowJs: false,
+                target: ts.ScriptTarget.ES2022,
+                module: ts.ModuleKind.ESNext,
+                moduleResolution: ts.ModuleResolutionKind.Bundler,
+                skipLibCheck: true,
+                noEmit: true,
+            },
+        });
+        const nodes = [];
+        const edges = [];
+        const seen = new Set();
+        // TypeScript uses `/` on Windows; path.join uses `\`. Normalize before matching.
+        const normalizeFsPath = (p) => path.normalize(p).toLowerCase();
+        const fileSet = new Set(files.map(normalizeFsPath));
+        const tsconfigPaths = loadTsconfigPaths(root);
+        const pushNode = (n) => {
+            if (seen.has(n.id))
+                return;
+            seen.add(n.id);
+            nodes.push(n);
+        };
+        for (const sf of program.getSourceFiles()) {
+            if (sf.isDeclarationFile)
+                continue;
+            if (!fileSet.has(normalizeFsPath(sf.fileName)))
+                continue;
+            const rel = toPosixRelative(root, sf.fileName);
+            const fileId = nodeId("file", rel);
+            pushNode({ id: fileId, kind: "file", label: path.basename(rel), path: rel });
+            const visit = (node) => {
+                if (ts.isFunctionDeclaration(node) && node.name) {
+                    const name = node.name.text;
+                    pushNode({
+                        id: nodeId("function", `${rel}:${name}`),
+                        kind: "function",
+                        label: name,
+                        path: rel,
+                        meta: { parser: "typescript-ast", analysisVersion: CONTRACTS_VERSION },
+                    });
+                }
+                if (ts.isClassDeclaration(node) && node.name) {
+                    const name = node.name.text;
+                    const classId = nodeId("class", `${rel}:${name}`);
+                    pushNode({
+                        id: classId,
+                        kind: "class",
+                        label: name,
+                        path: rel,
+                        meta: { parser: "typescript-ast" },
+                    });
+                    if (node.heritageClauses) {
+                        for (const h of node.heritageClauses) {
+                            for (const t of h.types) {
+                                const label = t.expression.getText(sf);
+                                const toId = nodeId("dependency", `${rel}->${label}`);
+                                pushNode({ id: toId, kind: "dependency", label, path: rel });
+                                edges.push({
+                                    id: nodeId("edge", `${classId}->${toId}:${h.token}`),
+                                    from: classId,
+                                    to: toId,
+                                    kind: h.token === ts.SyntaxKind.ExtendsKeyword ? "extends" : "implements",
+                                    evidence: "verified",
+                                });
+                            }
+                        }
+                    }
+                }
+                if (ts.isInterfaceDeclaration(node) && node.name) {
+                    pushNode({
+                        id: nodeId("interface", `${rel}:${node.name.text}`),
+                        kind: "module",
+                        label: node.name.text,
+                        path: rel,
+                        meta: { symbolKind: "interface", parser: "typescript-ast" },
+                    });
+                }
+                if (ts.isImportDeclaration(node) &&
+                    node.moduleSpecifier &&
+                    ts.isStringLiteral(node.moduleSpecifier)) {
+                    const spec = node.moduleSpecifier.text;
+                    const resolution = resolveImportSpecifier({
+                        root,
+                        fromFile: rel,
+                        specifier: spec,
+                        tsconfig: tsconfigPaths,
+                    });
+                    // Specifier dependency node (always — records the literal import).
+                    const toId = nodeId("dependency", `${rel}->${spec}`);
+                    pushNode({
+                        id: toId,
+                        kind: "dependency",
+                        label: spec,
+                        path: rel,
+                        meta: {
+                            specifier: spec,
+                            parser: "typescript-ast",
+                            confidence: resolution.confidence,
+                            ...(resolution.resolvedPath ? { resolvedPath: resolution.resolvedPath } : {}),
+                            ...(resolution.via ? { via: resolution.via } : {}),
+                        },
+                    });
+                    edges.push({
+                        id: nodeId("edge", `${fileId}->${toId}`),
+                        from: fileId,
+                        to: toId,
+                        kind: "imports",
+                        evidence: evidenceForConfidence(resolution.confidence),
+                    });
+                    // Concrete file→file edge only when resolved — never invent UNRESOLVED targets.
+                    if (resolution.resolvedPath && resolution.confidence !== "UNRESOLVED") {
+                        const targetFileId = nodeId("file", resolution.resolvedPath);
+                        pushNode({
+                            id: targetFileId,
+                            kind: "file",
+                            label: path.basename(resolution.resolvedPath),
+                            path: resolution.resolvedPath,
+                            meta: { importConfidence: resolution.confidence },
+                        });
+                        edges.push({
+                            id: nodeId("edge", `${fileId}->file:${resolution.resolvedPath}`),
+                            from: fileId,
+                            to: targetFileId,
+                            kind: "imports",
+                            evidence: evidenceForConfidence(resolution.confidence),
+                        });
+                    }
+                }
+                if (ts.isCallExpression(node) &&
+                    ts.isIdentifier(node.expression) &&
+                    node.expression.text.length > 1) {
+                    const callee = node.expression.text;
+                    const toId = nodeId("function", `call:${rel}:${callee}`);
+                    pushNode({
+                        id: toId,
+                        kind: "function",
+                        label: callee,
+                        path: rel,
+                        meta: { callSite: true, parser: "typescript-ast" },
+                    });
+                    edges.push({
+                        id: nodeId("edge", `${fileId}->call:${callee}:${node.getStart(sf)}`),
+                        from: fileId,
+                        to: toId,
+                        kind: "calls",
+                        evidence: "inferred",
+                    });
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(sf);
+        }
+        nodes.sort((a, b) => a.id.localeCompare(b.id));
+        edges.sort((a, b) => a.id.localeCompare(b.id));
+        return {
+            root,
+            generatedAt: new Date().toISOString(),
+            nodes,
+            edges,
+            builder: "typescript-ast",
+            astFilesParsed: files.length,
+            limitations: [
+                "TypeScript AST builder uses the TypeScript compiler API for .ts/.tsx only",
+                "Cross-file call resolution is identifier-based (not full type-checker binding)",
+                "Import edges use EXACT|RESOLVED|INFERRED confidence; UNRESOLVED never invents file targets",
+                "Non-TypeScript languages fall back to regex graph when requested via auto+empty TS set",
+                `analysisVersion=${CONTRACTS_VERSION}`,
+            ],
+        };
+    }
+    catch (error) {
+        const g = await buildRepositoryGraph(root);
+        return {
+            ...g,
+            builder: "regex",
+            astFilesParsed: 0,
+            limitations: [
+                ...g.limitations,
+                `TypeScript AST builder failed; regex fallback used (${error instanceof Error ? error.message : String(error)})`,
+            ],
+        };
+    }
+}

package/dist/intelligence/graph/incremental.d.ts

@@ -0,0 +1,68 @@
+import type { GraphEdge, GraphNode } from "../../platform/types.js";
+import { type GraphBuilderMode } from "./build.js";
+export declare const GRAPH_INDEX_SCHEMA = "1.0.0";
+export interface GraphSnapshot {
+    schemaVersion: string;
+    agentDoctorVersion: string;
+    root: string;
+    generatedAt: string;
+    builder: GraphBuilderMode | string;
+    astFilesParsed: number;
+    fileHashes: Record<string, string>;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    limitations: string[];
+}
+export interface GraphStatus {
+    present: boolean;
+    path: string;
+    schemaVersion?: string;
+    builder?: string;
+    nodeCount: number;
+    edgeCount: number;
+    fileCount: number;
+    generatedAt?: string;
+    staleFiles: string[];
+    missingFiles: string[];
+    corrupt?: boolean;
+    error?: string;
+}
+/**
+ * Full graph build and persist to `.agentdoctor/graph/index.json`.
+ */
+export declare function graphBuild(options: {
+    root: string;
+    mode?: GraphBuilderMode;
+}): Promise<{
+    snapshot: GraphSnapshot;
+    path: string;
+    rebuilt: boolean;
+}>;
+/**
+ * Force full rebuild (same as build, clears prior assumptions).
+ */
+export declare function graphRebuild(options: {
+    root: string;
+    mode?: GraphBuilderMode;
+}): Promise<{
+    snapshot: GraphSnapshot;
+    path: string;
+    rebuilt: boolean;
+}>;
+/**
+ * Update graph from git-changed files or content-hash comparison.
+ * On corruption → rebuild. When nothing changed → reuse snapshot.
+ */
+export declare function graphUpdate(options: {
+    root: string;
+    mode?: GraphBuilderMode;
+}): Promise<{
+    snapshot: GraphSnapshot;
+    path: string;
+    rebuilt: boolean;
+    reason: string;
+    changedFiles: string[];
+}>;
+export declare function graphStatus(options: {
+    root: string;
+}): Promise<GraphStatus>;