@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/platform/test-impact/analyze.js

@@ -0,0 +1,350 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { analyzeChanges } from "../../core/changes/analyze.js";
+import { loadCoverage } from "../../coverage/load.js";
+import { normalizeCoveragePath } from "../../coverage/types.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { writeJsonArtifact } from "../store.js";
+function modulesForPath(file, attributed) {
+    const mods = new Set(attributed ?? []);
+    const parts = file.split("/");
+    if (parts[0] === "src" && parts[1])
+        mods.add(parts[1]);
+    if (parts[0] === "tests" && parts[1])
+        mods.add(parts[1]);
+    const base = path.basename(file, path.extname(file));
+    if (base && !base.startsWith("."))
+        mods.add(base);
+    return [...mods].sort();
+}
+async function fileExists(root, rel) {
+    try {
+        await fs.access(path.join(root, rel));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isTestPath(file) {
+    return /\.(test|spec)\./i.test(file) || file.includes("__tests__");
+}
+function heuristicCandidates(file) {
+    const ext = path.extname(file);
+    const base = ext ? file.slice(0, -ext.length) : file;
+    return [
+        `${base}.test${ext || ".ts"}`,
+        `${base}.spec${ext || ".ts"}`,
+        file.replace(/\/src\//, "/tests/"),
+        file.replace(/^src\//, "tests/"),
+    ].filter((c, i, arr) => c !== file && arr.indexOf(c) === i);
+}
+function coverageFileFor(changed, coverage) {
+    const norm = normalizeCoveragePath(changed);
+    if (coverage.files[norm])
+        return norm;
+    // Match by suffix (absolute paths in LCOV vs repo-relative changed paths)
+    const keys = Object.keys(coverage.files);
+    const suffixHit = keys.find((k) => k === norm || k.endsWith(`/${norm}`) || norm.endsWith(`/${k}`));
+    return suffixHit ?? null;
+}
+function countLineHits(fileCov) {
+    if (!fileCov)
+        return { covered: 0, uncovered: 0, hits: 0 };
+    let covered = 0;
+    let uncovered = 0;
+    let hits = 0;
+    for (const h of Object.values(fileCov.lines)) {
+        if (h > 0) {
+            covered += 1;
+            hits += h;
+        }
+        else {
+            uncovered += 1;
+        }
+    }
+    return { covered, uncovered, hits };
+}
+function testsFromCoverageMap(coverage, sourceKey) {
+    const fileCov = coverage.files[sourceKey];
+    const fromFile = fileCov?.coveredByTests ?? [];
+    const fromMap = [];
+    if (coverage.testToFiles) {
+        for (const [test, sources] of Object.entries(coverage.testToFiles)) {
+            if (sources.some((s) => s === sourceKey || s.endsWith(`/${sourceKey}`) || sourceKey.endsWith(`/${s}`))) {
+                fromMap.push(test);
+            }
+        }
+    }
+    return [...new Set([...fromFile, ...fromMap].map(normalizeCoveragePath))].sort();
+}
+/**
+ * Module H — Test impact analysis.
+ * Heuristic by default; coverage-backed when a coverage file is loaded and used
+ * for changed-line evidence. Never claims tests passed.
+ */
+export async function analyzeTestImpact(rootInput, maybeOptions) {
+    // Support both analyzeTestImpact(root) and analyzeTestImpact({ root, ... })
+    const options = typeof rootInput === "string" ? { ...(maybeOptions ?? {}), root: rootInput } : rootInput;
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const changes = await analyzeChanges({
+        root,
+        impact: true,
+        ...(options.since ? { since: options.since } : {}),
+    });
+    const changed = changes.files.map((f) => f.path);
+    const recommended = [];
+    const uncovered = [];
+    const missingTestWarnings = [];
+    const allModules = new Set();
+    const limitations = [
+        "Does not execute tests; never claims pass/fail",
+        ...changes.limitations,
+    ];
+    let coverage = null;
+    let coverageSummary = null;
+    let mode = "heuristic";
+    let testAttribution = "none";
+    if (options.coveragePath) {
+        try {
+            coverage = await loadCoverage(options.coveragePath);
+            if (Object.keys(coverage.files).length === 0) {
+                limitations.push(`Coverage path provided but no file hits loaded (${coverage.format}): ${options.coveragePath}`);
+                limitations.push(...coverage.limitations);
+                coverage = null;
+            }
+            else {
+                limitations.push(...coverage.limitations);
+            }
+        }
+        catch (error) {
+            limitations.push(`Failed to load coverage from ${options.coveragePath}: ${error instanceof Error ? error.message : String(error)}`);
+            coverage = null;
+        }
+    }
+    if (!changes.gitAvailable) {
+        return {
+            root,
+            gitAvailable: false,
+            mode: "heuristic",
+            changedFiles: [],
+            recommendedTests: [],
+            relatedModules: [],
+            uncoveredAreas: [],
+            missingTestWarnings: [],
+            skipRisk: "Git not available — cannot infer changed files",
+            coverage: null,
+            limitations: ["Requires a git working tree to detect changes", ...limitations],
+        };
+    }
+    let changedCoveredLines = 0;
+    let changedUncoveredLines = 0;
+    let coverageHits = 0;
+    let filesWithHits = 0;
+    let usedCoverageForChangedLines = false;
+    let usedCoverageTestMap = false;
+    let usedHeuristicForTests = false;
+    for (const fileEntry of changes.files) {
+        const file = fileEntry.path;
+        const relatedModules = modulesForPath(file, fileEntry.modules);
+        for (const m of relatedModules)
+            allModules.add(m);
+        if (isTestPath(file)) {
+            recommended.push({
+                testPath: file,
+                reason: "Changed file is itself a test",
+                confidence: 0.95,
+                evidence: "verified",
+                exists: true,
+                relatedModules,
+            });
+            continue;
+        }
+        // Coverage-backed changed-line evidence
+        if (coverage) {
+            const covKey = coverageFileFor(file, coverage);
+            if (covKey) {
+                const counts = countLineHits(coverage.files[covKey]);
+                changedCoveredLines += counts.covered;
+                changedUncoveredLines += counts.uncovered;
+                coverageHits += counts.hits;
+                if (counts.covered + counts.uncovered > 0) {
+                    usedCoverageForChangedLines = true;
+                    filesWithHits += 1;
+                }
+                const mappedTests = testsFromCoverageMap(coverage, covKey);
+                if (mappedTests.length > 0) {
+                    usedCoverageTestMap = true;
+                    for (const testPath of mappedTests) {
+                        const exists = await fileExists(root, testPath);
+                        recommended.push({
+                            testPath,
+                            reason: `Coverage map links test to changed source ${file}`,
+                            confidence: exists ? 0.9 : 0.75,
+                            evidence: "verified",
+                            exists,
+                            relatedModules,
+                        });
+                    }
+                }
+                else {
+                    // Hybrid: coverage proves line hits; tests from naming heuristic
+                    usedHeuristicForTests = true;
+                    const candidates = heuristicCandidates(file);
+                    let anyExists = false;
+                    for (const c of candidates) {
+                        const exists = await fileExists(root, c);
+                        if (exists)
+                            anyExists = true;
+                        recommended.push({
+                            testPath: c,
+                            reason: exists
+                                ? `Heuristic test candidate for coverage-touched file ${file} (no test→source map)`
+                                : `Suggested test path for coverage-touched file ${file} (not found; no test→source map)`,
+                            confidence: exists ? 0.65 : 0.35,
+                            evidence: "inferred",
+                            exists,
+                            relatedModules,
+                        });
+                    }
+                    if (candidates.length === 0) {
+                        uncovered.push(file);
+                    }
+                    else if (!anyExists) {
+                        missingTestWarnings.push({
+                            sourceFile: file,
+                            message: `No co-located or tests/ counterpart found for ${file}`,
+                            relatedModules,
+                        });
+                    }
+                }
+                continue;
+            }
+        }
+        // Pure heuristic path (no coverage for this file, or no coverage loaded)
+        const candidates = heuristicCandidates(file);
+        let anyExists = false;
+        for (const c of candidates) {
+            const exists = await fileExists(root, c);
+            if (exists)
+                anyExists = true;
+            recommended.push({
+                testPath: c,
+                reason: exists
+                    ? `Existing test candidate for changed file ${file} (naming heuristic)`
+                    : `Suggested test path for changed file ${file} (file not found; naming heuristic)`,
+                confidence: exists ? 0.7 : 0.4,
+                evidence: "inferred",
+                exists,
+                relatedModules,
+            });
+        }
+        if (candidates.length === 0) {
+            uncovered.push(file);
+        }
+        else if (!anyExists) {
+            missingTestWarnings.push({
+                sourceFile: file,
+                message: `No co-located or tests/ counterpart found for ${file}`,
+                relatedModules,
+            });
+        }
+    }
+    for (const rel of changes.impact?.relatedPaths ?? []) {
+        for (const m of modulesForPath(rel))
+            allModules.add(m);
+    }
+    if (usedCoverageForChangedLines) {
+        mode = "coverage-backed";
+        if (usedCoverageTestMap && usedHeuristicForTests) {
+            testAttribution = "hybrid-heuristic";
+            limitations.push("mode=coverage-backed: changed-line evidence from coverage; some tests attributed via naming heuristic (hybrid)");
+        }
+        else if (usedCoverageTestMap) {
+            testAttribution = "coverage-map";
+            limitations.push("mode=coverage-backed: test attribution from coverage test→source map");
+        }
+        else {
+            testAttribution = "hybrid-heuristic";
+            limitations.push("mode=coverage-backed: coverage used for changed-line hits; test list uses naming heuristics because coverage lacks test→source map");
+        }
+        coverageSummary = {
+            format: coverage.format,
+            filesWithHits,
+            changedCoveredLines,
+            changedUncoveredLines,
+            coverageHits,
+            testAttribution,
+        };
+    }
+    else {
+        mode = "heuristic";
+        limitations.push("Impact mapping is path/naming heuristic — not coverage-backed (no usable coverage intersection with changed files)");
+        if (coverage) {
+            limitations.push("Coverage file was loaded but did not intersect changed source paths for line evidence");
+            coverageSummary = {
+                format: coverage.format,
+                filesWithHits: Object.keys(coverage.files).length,
+                changedCoveredLines: 0,
+                changedUncoveredLines: 0,
+                coverageHits: 0,
+                testAttribution: "none",
+            };
+        }
+    }
+    const seen = new Set();
+    const deduped = recommended.filter((r) => {
+        if (seen.has(r.testPath))
+            return false;
+        seen.add(r.testPath);
+        return true;
+    });
+    return {
+        root,
+        gitAvailable: true,
+        mode,
+        changedFiles: changed,
+        recommendedTests: deduped,
+        relatedModules: [...allModules].sort(),
+        uncoveredAreas: uncovered,
+        missingTestWarnings,
+        skipRisk: changed.length === 0
+            ? "No changes detected"
+            : missingTestWarnings.length > 0
+                ? "Changed source files lack matching tests — skipping tests risks regressions"
+                : "Skipping recommended tests may miss regressions in changed modules",
+        coverage: coverageSummary,
+        limitations,
+    };
+}
+export async function persistTestImpactReport(root, report) {
+    return writeJsonArtifact(root, "reports/test-impact.json", report);
+}
+export function formatTestImpactHuman(report) {
+    const lines = [
+        "AgentDoctor 2.0 test-impact",
+        `  mode: ${report.mode}`,
+        `  git: ${report.gitAvailable ? "available" : "unavailable"}`,
+        `  changed files: ${report.changedFiles.length}`,
+        `  recommended tests: ${report.recommendedTests.length}`,
+        `  missing-test warnings: ${report.missingTestWarnings.length}`,
+        `  related modules: ${report.relatedModules.slice(0, 12).join(", ") || "(none)"}`,
+        `  skip risk: ${report.skipRisk}`,
+    ];
+    if (report.coverage) {
+        lines.push(`  coverage: format=${report.coverage.format} filesWithHits=${report.coverage.filesWithHits} coveredLines=${report.coverage.changedCoveredLines} uncoveredLines=${report.coverage.changedUncoveredLines} hits=${report.coverage.coverageHits} testAttribution=${report.coverage.testAttribution}`);
+    }
+    if (report.recommendedTests.length) {
+        lines.push("  affected tests:");
+        for (const t of report.recommendedTests.slice(0, 20)) {
+            lines.push(`    - ${t.testPath} (exists=${t.exists}, confidence=${t.confidence}, evidence=${t.evidence}, ${t.reason})`);
+        }
+    }
+    if (report.missingTestWarnings.length) {
+        lines.push("  missing tests:");
+        for (const w of report.missingTestWarnings.slice(0, 10)) {
+            lines.push(`    - ${w.sourceFile}: ${w.message}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/platform/time-machine/compare.d.ts

@@ -0,0 +1,17 @@
+export interface TimeMachineCompare {
+    root: string;
+    left: string;
+    right: string;
+    changedFiles: string[];
+    summary: string;
+    limitations: string[];
+}
+/**
+ * Module J — Repository time machine (git-backed).
+ */
+export declare function compareCommits(options: {
+    root: string;
+    left: string;
+    right: string;
+}): Promise<TimeMachineCompare>;
+export declare function listRecentCommits(rootInput: string, limit?: number): Promise<string[]>;

package/dist/platform/time-machine/compare.js

@@ -0,0 +1,62 @@
+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: 8 * 1024 * 1024 });
+    return { ok: r.status === 0, out: typeof r.stdout === "string" ? r.stdout : "" };
+}
+/**
+ * Module J — Repository time machine (git-backed).
+ */
+export async function compareCommits(options) {
+    const root = resolveRepoRoot(options.root);
+    const left = options.left.trim();
+    const right = options.right.trim();
+    if (!isSafeGitRef(left) || !isSafeGitRef(right)) {
+        return {
+            root,
+            left,
+            right,
+            changedFiles: [],
+            summary: "Invalid git ref",
+            limitations: ["Refs must be non-empty and must not start with '-'"],
+        };
+    }
+    const probe = git(root, ["rev-parse", "--is-inside-work-tree"]);
+    if (!probe.ok || probe.out.trim() !== "true") {
+        return {
+            root,
+            left,
+            right,
+            changedFiles: [],
+            summary: "Git not available",
+            limitations: ["Requires a git repository"],
+        };
+    }
+    const diff = git(root, ["diff", "--name-only", `${left}...${right}`]);
+    const files = diff.ok
+        ? diff.out
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter(Boolean)
+        : [];
+    return {
+        root,
+        left,
+        right,
+        changedFiles: files,
+        summary: `${files.length} path(s) differ between ${left} and ${right}`,
+        limitations: [
+            "Architecture/risk trend overlays are extension points; this MVP lists path diffs",
+        ],
+    };
+}
+function isSafeGitRef(ref) {
+    return Boolean(ref) && !ref.includes("\0") && !ref.startsWith("-") && !/[\r\n]/.test(ref);
+}
+export async function listRecentCommits(rootInput, limit = 20) {
+    const root = resolveRepoRoot(rootInput);
+    const log = git(root, ["log", `-${limit}`, "--pretty=format:%H %s"]);
+    if (!log.ok)
+        return [];
+    return log.out.split(/\r?\n/).filter(Boolean);
+}

package/dist/platform/tokens/plan.d.ts

@@ -0,0 +1,28 @@
+import type { RepositoryGraph } from "../types.js";
+export interface ContextPlan {
+    root: string;
+    budgetTokens: number;
+    estimatedTokens: number;
+    selected: Array<{
+        path: string;
+        tokens: number;
+        relevance: number;
+        reason: string;
+    }>;
+    excluded: Array<{
+        path: string;
+        reason: string;
+    }>;
+    recommendations: string[];
+    limitations: string[];
+}
+/**
+ * Module L — Token / context optimization.
+ * Never includes secret-like paths.
+ */
+export declare function planContext(options: {
+    root: string;
+    graph: RepositoryGraph;
+    query: string;
+    budgetTokens?: number;
+}): Promise<ContextPlan>;

package/dist/platform/tokens/plan.js

@@ -0,0 +1,108 @@
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveRepoRoot, isPathInsideRoot } from "../../utils/path.js";
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+const SECRETISH = /\.env|id_rsa|credentials|secrets\//i;
+/**
+ * Module L — Token / context optimization.
+ * Never includes secret-like paths.
+ */
+export async function planContext(options) {
+    const root = resolveRepoRoot(options.root);
+    const budget = options.budgetTokens ?? 8_000;
+    const q = options.query.toLowerCase();
+    const selected = [];
+    const excluded = [];
+    let used = 0;
+    const candidates = options.graph.nodes
+        .filter((n) => (n.kind === "file" || n.kind === "doc" || n.kind === "config") && n.path)
+        .map((n) => n.path)
+        .sort();
+    for (const rel of candidates) {
+        if (rel.includes("\0") || path.isAbsolute(rel) || rel.split(/[/\\]/).includes("..")) {
+            excluded.push({ path: rel, reason: "Unsafe path rejected" });
+            continue;
+        }
+        if (SECRETISH.test(rel)) {
+            excluded.push({ path: rel, reason: "Secret-like path excluded" });
+            continue;
+        }
+        const relevance = (rel.toLowerCase().includes(q) ? 0.6 : 0) +
+            (/\.(ts|tsx|md)$/i.test(rel) ? 0.2 : 0.05) +
+            (rel.startsWith("src/") ? 0.15 : 0);
+        if (relevance < 0.25) {
+            excluded.push({ path: rel, reason: "Low relevance to query" });
+            continue;
+        }
+        try {
+            const absolute = path.resolve(root, rel);
+            if (!isPathInsideRoot(root, absolute)) {
+                excluded.push({ path: rel, reason: "Path escapes repository root" });
+                continue;
+            }
+            // Open first (O_NOFOLLOW rejects symlinks), then fstat+read from the same fd — no TOCTOU.
+            const openFlags = typeof fsConstants.O_NOFOLLOW === "number"
+                ? fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW
+                : fsConstants.O_RDONLY;
+            let handle;
+            try {
+                handle = await fs.open(absolute, openFlags);
+            }
+            catch (error) {
+                const code = error && typeof error === "object" && "code" in error
+                    ? String(error.code)
+                    : "";
+                if (code === "ELOOP") {
+                    excluded.push({ path: rel, reason: "Symlink excluded" });
+                    continue;
+                }
+                throw error;
+            }
+            try {
+                const st = await handle.stat();
+                if (st.size > 100_000) {
+                    excluded.push({ path: rel, reason: "File too large for context budget" });
+                    continue;
+                }
+                const text = await handle.readFile("utf8");
+                const tokens = estimateTokens(text);
+                if (used + tokens > budget) {
+                    excluded.push({ path: rel, reason: "Would exceed token budget" });
+                    continue;
+                }
+                selected.push({
+                    path: rel,
+                    tokens,
+                    relevance,
+                    reason: relevance >= 0.6 ? "Path matches query" : "Likely relevant source/doc",
+                });
+                used += tokens;
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch {
+            excluded.push({ path: rel, reason: "Unreadable" });
+        }
+    }
+    selected.sort((a, b) => b.relevance - a.relevance || a.path.localeCompare(b.path));
+    return {
+        root,
+        budgetTokens: budget,
+        estimatedTokens: used,
+        selected,
+        excluded: excluded.slice(0, 200),
+        recommendations: [
+            used > budget * 0.9 ? "Increase budget or narrow query" : "Budget headroom available",
+            "Prefer Project Brain claims over dumping entire directories",
+        ],
+        limitations: [
+            "Token estimate is chars/4 heuristic",
+            "Relevance is lexical, not embedding-based",
+        ],
+    };
+}

package/dist/platform/types.d.ts

@@ -0,0 +1,120 @@
+/**
+ * AgentDoctor 2.0 platform contracts.
+ * Local-first: no mandatory cloud, DB, or API keys.
+ */
+export type EvidenceKind = "verified" | "inferred" | "unknown";
+export interface EvidenceRef {
+    kind: EvidenceKind;
+    path?: string;
+    detail: string;
+    line?: number;
+}
+export type PlatformSeverity = "critical" | "high" | "medium" | "low" | "info";
+export interface PlatformFinding {
+    id: string;
+    module: string;
+    severity: PlatformSeverity;
+    title: string;
+    message: string;
+    recommendation: string;
+    confidence: number;
+    evidence: EvidenceRef[];
+    falsePositiveWarning?: string;
+}
+export interface GraphNode {
+    id: string;
+    kind: "file" | "directory" | "function" | "class" | "module" | "api" | "test" | "dependency" | "doc" | "config" | "service" | "commit" | "owner";
+    label: string;
+    path?: string;
+    meta?: Record<string, string | number | boolean>;
+}
+export interface GraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    kind: string;
+    evidence: EvidenceKind;
+}
+export interface RepositoryGraph {
+    root: string;
+    generatedAt: string;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    limitations: string[];
+}
+export type FirewallDecision = "allow" | "block" | "require-approval" | "sandbox-only" | "deny-network" | "deny-secrets";
+export type AgentActionType = "shell" | "file-create" | "file-modify" | "file-delete" | "git" | "package-install" | "database" | "network" | "docker" | "infra" | "secret-access" | "config-change" | "deploy";
+export interface AgentActionRequest {
+    actionId: string;
+    agentId: string;
+    userId?: string;
+    timestamp: string;
+    type: AgentActionType;
+    params: Record<string, string>;
+    repositoryRoot: string;
+}
+export interface FirewallVerdict {
+    actionId: string;
+    decision: FirewallDecision;
+    reason: string;
+    riskLevel: PlatformSeverity;
+    policyId?: string;
+    approvalStatus: "not-required" | "pending" | "approved" | "denied";
+    executionResult: "not-executed";
+}
+export type LocalRole = "admin" | "developer" | "reviewer" | "auditor" | "readonly";
+export interface PlatformSnapshot {
+    version: "2.0";
+    root: string;
+    generatedAt: string;
+    graph: RepositoryGraph;
+    findings: PlatformFinding[];
+    readiness: ReadinessReport;
+    testImpact?: TestImpactSnapshot;
+    limitations: string[];
+}
+/** Persisted subset of Module H test-impact analysis. */
+export interface TestImpactSnapshot {
+    gitAvailable: boolean;
+    mode: "coverage-backed" | "heuristic";
+    changedFiles: string[];
+    recommendedTests: Array<{
+        testPath: string;
+        reason: string;
+        confidence: number;
+        evidence: EvidenceKind;
+        exists: boolean;
+        relatedModules: string[];
+    }>;
+    relatedModules: string[];
+    missingTestWarnings: Array<{
+        sourceFile: string;
+        message: string;
+        relatedModules: string[];
+    }>;
+    uncoveredAreas: string[];
+    skipRisk: string;
+    coverage: {
+        format: string;
+        filesWithHits: number;
+        changedCoveredLines: number;
+        changedUncoveredLines: number;
+        coverageHits: number;
+        testAttribution: "coverage-map" | "hybrid-heuristic" | "none";
+    } | null;
+    limitations: string[];
+}
+export interface ReadinessCategory {
+    id: string;
+    title: string;
+    score: number;
+    evidence: EvidenceRef[];
+    gaps: string[];
+    recommendations: string[];
+}
+export interface ReadinessReport {
+    root: string;
+    categories: ReadinessCategory[];
+    overallNote: string;
+    limitations: string[];
+}

package/dist/platform/types.js

@@ -0,0 +1,5 @@
+/**
+ * AgentDoctor 2.0 platform contracts.
+ * Local-first: no mandatory cloud, DB, or API keys.
+ */
+export {};