@praneeth_54/agentdoctor 1.1.0 → 2.0.0

package/dist/index.js

@@ -1,3 +1,15 @@
+export { CONTRACTS_VERSION, DEFAULT_FEATURE_FLAGS } from "./contracts/index.js";
+export { buildIntelligenceGraph } from "./intelligence/graph/build.js";
+export { analyzeGitIntelligence } from "./intelligence/git/analyze.js";
+export { buildC4Views } from "./architecture/c4.js";
+export { createKnowledgeRecord, listKnowledge, transitionKnowledge, retrieveAuthoritative, } from "./knowledge/store.js";
+export { FilesystemStorageProvider, MemoryStorageProvider } from "./storage/provider.js";
+export { runControlledCommand } from "./enforcement/runner.js";
+export { registerLocalDevUser, authenticateLocalDev, authorize } from "./team/auth.js";
+export { runProjectInit, listProposals, reviewProposal } from "./core/brain-product/init.js";
+export { collectOpsHealth } from "./ops/health.js";
+export { listPolicyPacks, getPolicyPack } from "./policy/packs.js";
+export { listIntelligenceMcpTools, INTELLIGENCE_MCP_TOOL_NAMES, } from "./mcp/intelligence/registry.js";
 export { scan } from "./core/scanner/scan.js";
 export { verify } from "./core/verify/verify.js";
 export { compareFindings } from "./core/verify/compare.js";

package/dist/integrations/github/pr-analyze.d.ts

@@ -0,0 +1,28 @@
+export interface PrReviewFinding {
+    severity: "critical" | "warning" | "info";
+    title: string;
+    message: string;
+    file?: string;
+    line?: number;
+    confidence: "high" | "medium" | "low";
+    source: "scan" | "context-health" | "changes";
+}
+export interface PrReviewReport {
+    root: string;
+    mode: "local" | "github-dry-run";
+    baseRef: string | null;
+    headRef: string | null;
+    findings: PrReviewFinding[];
+    commentMarkdown: string;
+    limitations: string[];
+    posted: false;
+}
+/**
+ * Local PR review. Never posts to GitHub unless a future explicit command is added.
+ * GitHub token is unused; dry-run is the only supported remote mode.
+ */
+export declare function analyzePullRequest(options: {
+    root: string;
+    baseRef?: string;
+    dryRun?: boolean;
+}): Promise<PrReviewReport>;

package/dist/integrations/github/pr-analyze.js

@@ -0,0 +1,98 @@
+import { spawnSync } from "node:child_process";
+import { analyzeChanges } from "../../core/changes/analyze.js";
+import { analyzeContextHealth } from "../../core/context-health/analyze.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { scan } from "../../core/scanner/scan.js";
+function redactSecretsInText(text) {
+    return text
+        .replace(/\bAKIA[0-9A-Z]{16}\b/g, "[REDACTED]")
+        .replace(/\bghp_[A-Za-z0-9]{36}\b/g, "[REDACTED]")
+        .replace(/-----BEGIN [^-]+PRIVATE KEY-----/g, "[REDACTED PRIVATE KEY]");
+}
+function buildComment(findings) {
+    const lines = [
+        "## AgentDoctor PR review (local)",
+        "",
+        "_Generated locally. Secrets are redacted. Nothing was posted to GitHub._",
+        "",
+    ];
+    if (findings.length === 0) {
+        lines.push("No actionable findings in local analysis.");
+        return lines.join("\n");
+    }
+    for (const f of findings) {
+        const loc = f.file ? ` \`${f.file}${f.line ? `:${f.line}` : ""}\`` : "";
+        lines.push(`- **${f.severity}** (${f.confidence}) ${redactSecretsInText(f.title)}${loc}: ${redactSecretsInText(f.message)}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+/**
+ * Local PR review. Never posts to GitHub unless a future explicit command is added.
+ * GitHub token is unused; dry-run is the only supported remote mode.
+ */
+export async function analyzePullRequest(options) {
+    const root = resolveRepoRoot(options.root);
+    const limitations = [
+        "GitHub comment posting is disabled; use --dry-run / local mode only",
+        "Optional GitHub API integration requires explicit future invocation with a token",
+    ];
+    const baseRef = options.baseRef ?? null;
+    const changes = await analyzeChanges({
+        root,
+        ...(baseRef ? { since: baseRef } : {}),
+    });
+    const context = await analyzeContextHealth(root);
+    const scanResult = await scan({ cwd: root });
+    const findings = [];
+    for (const f of scanResult.findings.filter((x) => x.severity === "critical" || x.severity === "warning")) {
+        findings.push({
+            severity: f.severity,
+            title: f.title,
+            message: f.message,
+            ...(f.evidence?.path ? { file: f.evidence.path } : {}),
+            ...(typeof f.evidence?.line === "number" ? { line: f.evidence.line } : {}),
+            confidence: "high",
+            source: "scan",
+        });
+    }
+    for (const c of context.conflicts) {
+        findings.push({
+            severity: c.severity === "warning" ? "warning" : "info",
+            title: c.kind,
+            message: c.message,
+            ...(c.files[0] ? { file: c.files[0] } : {}),
+            confidence: "medium",
+            source: "context-health",
+        });
+    }
+    if (changes.gitAvailable && changes.files.length > 0) {
+        findings.push({
+            severity: "info",
+            title: "changed-files",
+            message: `${changes.files.length} changed file(s) in working tree / range`,
+            confidence: "high",
+            source: "changes",
+        });
+    }
+    else if (!changes.gitAvailable) {
+        limitations.push(...changes.limitations);
+    }
+    let headRef = changes.head;
+    if (!headRef) {
+        const probe = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            cwd: root,
+            encoding: "utf8",
+        });
+        headRef = probe.status === 0 ? probe.stdout.trim() : null;
+    }
+    return {
+        root,
+        mode: options.dryRun === false ? "local" : "github-dry-run",
+        baseRef,
+        headRef,
+        findings,
+        commentMarkdown: buildComment(findings),
+        limitations,
+        posted: false,
+    };
+}

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,13 @@
+import type { RepositoryGraph } from "../../platform/types.js";
+export type GraphBuilderMode = "regex" | "typescript-ast" | "auto";
+/**
+ * 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;
+}>;