@praneeth_54/agentdoctor 2.1.0 → 3.0.0

package/dist/product/eval/lab.js

@@ -0,0 +1,218 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { detectProject } from "../../detectors/project.js";
+import { analyzeApiSurface } from "../api/doctor.js";
+import { analyzeDatabaseSchema } from "../database/doctor.js";
+import { analyzeEvents } from "../events/doctor.js";
+import { analyzeSecuritySurface } from "../security/doctor.js";
+import { analyzeContextSecurity } from "../../platform/context-security/analyze.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { pathExists, readTextFile } from "../../utils/fs.js";
+const FIXTURE_DIRS = [
+    "minimal-ts",
+    "rest-api",
+    "prisma-db",
+    "queue-bull",
+    "insecure-sample",
+    "python-flask",
+    "php-laravel-lite",
+    "monorepo-lite",
+    "infra-compose",
+    "prompt-injection",
+];
+async function evalFixturesRoot(agentDoctorRoot) {
+    const primary = path.join(agentDoctorRoot, "fixtures", "eval");
+    if (await pathExists(primary))
+        return primary;
+    return path.join(agentDoctorRoot, "validation", "fixtures");
+}
+async function loadManifest(fixtureRoot) {
+    const manifestPath = path.join(fixtureRoot, "manifest.json");
+    if (await pathExists(manifestPath)) {
+        try {
+            return JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+async function runManifestChecks(fixtureRoot, manifest, prefix) {
+    const checks = [];
+    for (const check of manifest.checks ?? []) {
+        let passed = false;
+        let detail = "";
+        if (check.expectFile && check.expectContains) {
+            const target = path.join(fixtureRoot, check.expectFile);
+            const text = await readTextFile(target, 256 * 1024);
+            passed = text !== null && text.includes(check.expectContains);
+            detail = passed ? `marker in ${check.expectFile}` : `missing marker in ${check.expectFile}`;
+        }
+        else if (check.expectFile) {
+            const target = path.join(fixtureRoot, check.expectFile);
+            passed = await pathExists(target);
+            detail = passed ? `found ${check.expectFile}` : `missing ${check.expectFile}`;
+        }
+        else if (check.expectContains) {
+            const rel = check.expectPathIncludes ?? "README.md";
+            const text = await readTextFile(path.join(fixtureRoot, rel), 256 * 1024);
+            passed = text !== null && text.includes(check.expectContains);
+            detail = passed ? `found marker in ${rel}` : `missing marker in ${rel}`;
+        }
+        else {
+            passed = false;
+            detail = "No executable check defined";
+        }
+        checks.push({
+            id: `${prefix}:${check.id}`,
+            description: check.description,
+            passed,
+            truth: passed ? "VERIFIED" : "UNKNOWN",
+            detail,
+        });
+    }
+    return checks;
+}
+async function runDoctorInvariants(fixtureRoot, prefix) {
+    const checks = [];
+    const name = path.basename(fixtureRoot);
+    if (name === "rest-api") {
+        const api = await analyzeApiSurface(fixtureRoot);
+        const express = api.endpoints.some((e) => e.framework === "express");
+        checks.push({
+            id: `${prefix}:express-routes`,
+            description: "Express routes detected",
+            passed: express,
+            truth: express ? "VERIFIED" : "UNKNOWN",
+            detail: `endpoints=${api.endpoints.length}`,
+        });
+    }
+    if (name === "prisma-db") {
+        const db = await analyzeDatabaseSchema(fixtureRoot);
+        const models = db.objects.filter((o) => o.source === "prisma");
+        checks.push({
+            id: `${prefix}:prisma-models`,
+            description: "Prisma models detected",
+            passed: models.length > 0,
+            truth: models.length ? "VERIFIED" : "UNKNOWN",
+            detail: `models=${models.length}`,
+        });
+    }
+    if (name === "queue-bull") {
+        const events = await analyzeEvents(fixtureRoot);
+        const bull = events.nodes.some((n) => /bull|queue/i.test(n.label));
+        checks.push({
+            id: `${prefix}:bull-markers`,
+            description: "Bull/queue markers detected",
+            passed: bull,
+            truth: bull ? "INFERRED" : "UNKNOWN",
+        });
+    }
+    if (name === "insecure-sample") {
+        const sec = await analyzeSecuritySurface(fixtureRoot);
+        const count = sec.secretScan.findings.length + sec.dangerousPatterns.length + sec.authMarkers.length;
+        checks.push({
+            id: `${prefix}:secret-patterns`,
+            description: "Security doctor finds secret-like patterns",
+            passed: count > 0,
+            truth: count ? "INFERRED" : "UNKNOWN",
+            detail: `findings=${count}`,
+        });
+    }
+    if (name === "python-flask") {
+        const api = await analyzeApiSurface(fixtureRoot);
+        const flask = api.endpoints.some((e) => e.framework === "flask");
+        checks.push({
+            id: `${prefix}:flask-routes`,
+            description: "Flask routes detected",
+            passed: flask,
+            truth: flask ? "VERIFIED" : "UNKNOWN",
+        });
+    }
+    if (name === "infra-compose") {
+        const compose = await pathExists(path.join(fixtureRoot, "docker-compose.yml"));
+        checks.push({
+            id: `${prefix}:compose-file`,
+            description: "docker-compose.yml present",
+            passed: compose,
+            truth: compose ? "VERIFIED" : "UNKNOWN",
+        });
+    }
+    if (name === "monorepo-lite") {
+        const detection = await detectProject(fixtureRoot);
+        const pkgCount = detection.discovery.files.filter((f) => f.relativePath.endsWith("package.json")).length;
+        checks.push({
+            id: `${prefix}:multi-package`,
+            description: "Multiple package.json files (monorepo-lite)",
+            passed: pkgCount >= 2,
+            truth: pkgCount >= 2 ? "VERIFIED" : "UNKNOWN",
+            detail: `package.json count=${pkgCount}`,
+        });
+    }
+    if (name === "prompt-injection") {
+        const ctx = await analyzeContextSecurity(fixtureRoot);
+        const hostile = ctx.some((f) => f.module === "context-security");
+        checks.push({
+            id: `${prefix}:context-security-detect`,
+            description: "Context-security detects hostile README patterns (no execution)",
+            passed: hostile,
+            truth: hostile ? "INFERRED" : "UNKNOWN",
+            detail: `findings=${ctx.length}`,
+        });
+        checks.push({
+            id: `${prefix}:no-shell-exec`,
+            description: "Eval lab does not execute hostile fixture instructions",
+            passed: true,
+            truth: "VERIFIED",
+            detail: "Static pattern scan only",
+        });
+    }
+    return checks;
+}
+export async function runEvalLab(rootInput) {
+    const agentRoot = resolveRepoRoot(rootInput ?? process.cwd());
+    const evalRoot = await evalFixturesRoot(agentRoot);
+    const limitations = [
+        "Eval lab runs static fixture checks and lightweight doctor invariants (no network).",
+        "prompt-injection fixture is scanned for patterns only — hostile README text is never executed as agent instructions.",
+    ];
+    const checks = [];
+    const fixturesRun = [];
+    for (const dir of FIXTURE_DIRS) {
+        const fixtureRoot = path.join(evalRoot, dir);
+        if (!(await pathExists(fixtureRoot))) {
+            checks.push({
+                id: `fixture:${dir}:missing`,
+                description: `Fixture directory ${dir} exists`,
+                passed: false,
+                truth: "UNKNOWN",
+                detail: `missing ${fixtureRoot}`,
+            });
+            continue;
+        }
+        fixturesRun.push(dir);
+        const manifest = await loadManifest(fixtureRoot);
+        if (manifest?.checks?.length) {
+            checks.push(...(await runManifestChecks(fixtureRoot, manifest, dir)));
+        }
+        else {
+            checks.push({
+                id: `${dir}:manifest`,
+                description: `${dir} has manifest.json with checks`,
+                passed: false,
+                truth: "UNKNOWN",
+            });
+        }
+        checks.push(...(await runDoctorInvariants(fixtureRoot, dir)));
+    }
+    const passed = checks.every((c) => c.passed);
+    return {
+        root: agentRoot,
+        fixtureRoot: evalRoot,
+        fixturesRun,
+        checks,
+        passed,
+        limitations,
+    };
+}

package/dist/product/events/doctor.d.ts

@@ -0,0 +1,21 @@
+import type { ProductEvidence, TruthLabel } from "../truth.js";
+export interface EventFlowNode {
+    id: string;
+    kind: "queue" | "worker" | "cron" | "bus" | "job" | "unknown";
+    label: string;
+    truth: TruthLabel;
+    evidence: ProductEvidence[];
+}
+export interface EventFlowEdge {
+    from: string;
+    to: string;
+    kind: "produces" | "consumes" | "schedules" | "inferred";
+    truth: TruthLabel;
+}
+export interface EventsDoctorReport {
+    root: string;
+    nodes: EventFlowNode[];
+    edges: EventFlowEdge[];
+    limitations: string[];
+}
+export declare function analyzeEvents(rootInput: string): Promise<EventsDoctorReport>;

package/dist/product/events/doctor.js

@@ -0,0 +1,147 @@
+import { lineNumberAt, loadProjectSourceFiles } from "../evidence-scan.js";
+const MARKERS = [
+    {
+        id: "bull",
+        kind: "queue",
+        label: "Bull queue",
+        importRe: /from\s+['"]bull['"]|require\(\s*['"]bull['"]\)/,
+    },
+    {
+        id: "bullmq",
+        kind: "queue",
+        label: "BullMQ",
+        importRe: /from\s+['"]bullmq['"]|require\(\s*['"]bullmq['"]\)/,
+    },
+    {
+        id: "sqs",
+        kind: "queue",
+        label: "AWS SQS",
+        contentRe: /@aws-sdk\/client-sqs|SQSClient|aws-sdk.*SQS/i,
+    },
+    { id: "kafka", kind: "bus", label: "Kafka", contentRe: /kafkajs|from\s+['"]kafka['"]/i },
+    {
+        id: "laravel-job",
+        kind: "job",
+        label: "Laravel Job",
+        contentRe: /implements\s+ShouldQueue|use\s+Illuminate\\Contracts\\Queue\\ShouldQueue/,
+    },
+    {
+        id: "cron-node",
+        kind: "cron",
+        label: "node-cron",
+        importRe: /from\s+['"]node-cron['"]|require\(\s*['"]node-cron['"]\)/,
+    },
+    { id: "cron-php", kind: "cron", label: "Laravel schedule", contentRe: /Schedule::|->cron\s*\(/ },
+    {
+        id: "worker",
+        kind: "worker",
+        label: "Worker process",
+        contentRe: /new\s+Worker\s*\(|\.process\s*\(\s*['"]/,
+    },
+];
+const SOURCE_FILTER = (rel) => {
+    const lower = rel.toLowerCase();
+    return (lower.endsWith(".ts") ||
+        lower.endsWith(".js") ||
+        lower.endsWith(".php") ||
+        lower.endsWith(".py") ||
+        lower.endsWith(".yaml") ||
+        lower.endsWith(".yml"));
+};
+function scanFile(relativePath, content) {
+    const nodes = [];
+    for (const marker of MARKERS) {
+        if (marker.importRe) {
+            marker.importRe.lastIndex = 0;
+            const m = marker.importRe.exec(content);
+            if (m) {
+                nodes.push({
+                    id: `${marker.id}:${relativePath}`,
+                    kind: marker.kind,
+                    label: marker.label,
+                    truth: "INFERRED",
+                    evidence: [
+                        {
+                            path: relativePath,
+                            line: lineNumberAt(content, m.index),
+                            excerpt: m[0].slice(0, 120),
+                        },
+                    ],
+                });
+            }
+        }
+        if (marker.contentRe) {
+            marker.contentRe.lastIndex = 0;
+            const m = marker.contentRe.exec(content);
+            if (m) {
+                nodes.push({
+                    id: `${marker.id}:${relativePath}`,
+                    kind: marker.kind,
+                    label: marker.label,
+                    truth: "INFERRED",
+                    evidence: [
+                        {
+                            path: relativePath,
+                            line: lineNumberAt(content, m.index),
+                            excerpt: m[0].slice(0, 120),
+                        },
+                    ],
+                });
+            }
+        }
+    }
+    const queueNameRe = /(?:Queue|queue)\(\s*['"`]([^'"`]+)['"`]/g;
+    let qm;
+    while ((qm = queueNameRe.exec(content)) !== null) {
+        const name = qm[1];
+        nodes.push({
+            id: `queue-name:${name}:${relativePath}`,
+            kind: "queue",
+            label: name,
+            truth: "INFERRED",
+            evidence: [
+                {
+                    path: relativePath,
+                    line: lineNumberAt(content, qm.index),
+                    excerpt: qm[0].slice(0, 120),
+                },
+            ],
+        });
+    }
+    return nodes;
+}
+function inferEdges(nodes) {
+    const edges = [];
+    const workers = nodes.filter((n) => n.kind === "worker");
+    const queues = nodes.filter((n) => n.kind === "queue" || n.kind === "job");
+    for (const w of workers) {
+        for (const q of queues) {
+            if (w.evidence[0]?.path === q.evidence[0]?.path) {
+                edges.push({
+                    from: q.id,
+                    to: w.id,
+                    kind: "inferred",
+                    truth: "INFERRED",
+                });
+            }
+        }
+    }
+    return edges;
+}
+export async function analyzeEvents(rootInput) {
+    const { root, files, limitations: scanLimits, } = await loadProjectSourceFiles(rootInput, SOURCE_FILTER);
+    const limitations = [
+        "Event flow is inferred from imports and string patterns; no runtime queue topology.",
+        "Cross-file producer/consumer links are partial (same-file heuristics only).",
+        ...scanLimits,
+    ];
+    const nodeMap = new Map();
+    for (const file of files) {
+        for (const node of scanFile(file.relativePath, file.content)) {
+            nodeMap.set(node.id, node);
+        }
+    }
+    const nodes = [...nodeMap.values()].sort((a, b) => a.id.localeCompare(b.id));
+    const edges = inferEdges(nodes);
+    return { root, nodes, edges, limitations };
+}

package/dist/product/evidence-scan.d.ts

@@ -0,0 +1,12 @@
+export interface ScannedSourceFile {
+    relativePath: string;
+    content: string;
+}
+export declare function loadProjectSourceFiles(rootInput: string, filter: (relativePath: string) => boolean, maxFileSizeBytes?: number): Promise<{
+    root: string;
+    files: ScannedSourceFile[];
+    limitations: string[];
+}>;
+export declare function lineNumberAt(content: string, index: number): number;
+export declare function isMarkdownDoc(relativePath: string): boolean;
+export declare function isLikelyRequirementsDoc(relativePath: string): boolean;

package/dist/product/evidence-scan.js

@@ -0,0 +1,46 @@
+import path from "node:path";
+import { DEFAULT_MAX_FILE_SIZE_BYTES } from "../constants.js";
+import { detectProject } from "../detectors/project.js";
+import { readTextFile } from "../utils/fs.js";
+import { resolveRepoRoot } from "../utils/path.js";
+export async function loadProjectSourceFiles(rootInput, filter, maxFileSizeBytes = DEFAULT_MAX_FILE_SIZE_BYTES) {
+    const root = resolveRepoRoot(rootInput);
+    const detection = await detectProject(root, maxFileSizeBytes);
+    const limitations = [];
+    if (detection.diagnostics.length) {
+        limitations.push(...detection.diagnostics.slice(0, 5));
+    }
+    const files = [];
+    for (const entry of detection.discovery.files) {
+        const rel = entry.relativePath.replace(/\\/g, "/");
+        if (!filter(rel))
+            continue;
+        const text = await readTextFile(path.join(root, rel), maxFileSizeBytes);
+        if (text === null)
+            continue;
+        files.push({ relativePath: rel, content: text });
+    }
+    return { root, files, limitations };
+}
+export function lineNumberAt(content, index) {
+    if (index <= 0)
+        return 1;
+    let line = 1;
+    for (let i = 0; i < index && i < content.length; i++) {
+        if (content.charCodeAt(i) === 10)
+            line++;
+    }
+    return line;
+}
+export function isMarkdownDoc(relativePath) {
+    const lower = relativePath.toLowerCase();
+    return lower.endsWith(".md") || lower.endsWith(".markdown");
+}
+export function isLikelyRequirementsDoc(relativePath) {
+    const base = relativePath.split("/").pop()?.toLowerCase() ?? "";
+    if (base === "requirements.md" || base === "user-stories.md")
+        return true;
+    if (relativePath.startsWith("docs/") && isMarkdownDoc(relativePath))
+        return true;
+    return false;
+}

package/dist/product/evolution/timeline.d.ts

@@ -0,0 +1,29 @@
+import { analyzeGitIntelligence } from "../../intelligence/git/analyze.js";
+import type { TruthLabel } from "../truth.js";
+export interface EvolutionTimelineEvent {
+    id: string;
+    date: string;
+    author: string;
+    subject: string;
+    filesTouched: number;
+    truth: TruthLabel;
+}
+export interface EvolutionTrend {
+    id: string;
+    label: string;
+    direction: "up" | "down" | "stable";
+    metric: string;
+    truth: TruthLabel;
+    note: string;
+}
+export interface SoftwareEvolutionReport {
+    root: string;
+    gitAvailable: boolean;
+    events: EvolutionTimelineEvent[];
+    trends: EvolutionTrend[];
+    gitIntelligence: Awaited<ReturnType<typeof analyzeGitIntelligence>>;
+    limitations: string[];
+}
+export declare function buildSoftwareEvolutionTimeline(rootInput: string, options?: {
+    maxCommits?: number;
+}): Promise<SoftwareEvolutionReport>;

package/dist/product/evolution/timeline.js

@@ -0,0 +1,123 @@
+import { spawnSync } from "node:child_process";
+import { analyzeGitIntelligence } from "../../intelligence/git/analyze.js";
+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 : "" };
+}
+function parseLogSummary(root, maxCommits) {
+    const log = git(root, [
+        "log",
+        `--max-count=${maxCommits}`,
+        "--pretty=format:%H%x09%ai%x09%an%x09%s",
+        "--name-only",
+    ]);
+    if (!log.ok)
+        return [];
+    const events = [];
+    let pending = null;
+    let fileCount = 0;
+    const flush = () => {
+        if (!pending)
+            return;
+        events.push({ ...pending, filesTouched: fileCount });
+        pending = null;
+        fileCount = 0;
+    };
+    for (const line of log.out.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        if (line.includes("\t")) {
+            flush();
+            const [hash, date, author, subject] = line.split("\t");
+            if (!hash || !date)
+                continue;
+            pending = {
+                id: hash.slice(0, 12),
+                date: date.trim(),
+                author: (author ?? "unknown").trim(),
+                subject: (subject ?? "").trim().slice(0, 240),
+                truth: "VERIFIED",
+            };
+            continue;
+        }
+        if (pending)
+            fileCount += 1;
+    }
+    flush();
+    return events;
+}
+function inferTrends(events, gitReport) {
+    const trends = [];
+    if (events.length >= 2) {
+        const recent = events.slice(0, Math.min(20, events.length));
+        const older = events.slice(Math.min(20, events.length));
+        const avgRecent = recent.reduce((s, e) => s + e.filesTouched, 0) / Math.max(1, recent.length);
+        const avgOlder = older.length > 0 ? older.reduce((s, e) => s + e.filesTouched, 0) / older.length : avgRecent;
+        const direction = avgRecent > avgOlder * 1.15 ? "up" : avgRecent < avgOlder * 0.85 ? "down" : "stable";
+        trends.push({
+            id: "change-breadth",
+            label: "Average files touched per commit (recent window)",
+            direction,
+            metric: avgRecent.toFixed(2),
+            truth: "INFERRED",
+            note: "Compared recent ≤20 commits vs earlier commits in the same log window.",
+        });
+    }
+    if (gitReport.hotspots.length >= 2) {
+        const top = gitReport.hotspots[0];
+        const second = gitReport.hotspots[1];
+        trends.push({
+            id: "hotspot-concentration",
+            label: "Hotspot file churn concentration",
+            direction: top.commits > second.commits * 2 ? "up" : "stable",
+            metric: `${top.path} (${top.commits} commits)`,
+            truth: "INFERRED",
+            note: gitReport.hotspots[0]?.method ?? "git intelligence hotspot method",
+        });
+    }
+    const authors = new Set(events.map((e) => e.author));
+    trends.push({
+        id: "contributor-breadth",
+        label: "Distinct authors in timeline window",
+        direction: authors.size >= 3 ? "stable" : "down",
+        metric: String(authors.size),
+        truth: "INFERRED",
+        note: "Author count in parsed log — not organizational bus factor.",
+    });
+    return trends;
+}
+export async function buildSoftwareEvolutionTimeline(rootInput, options) {
+    const root = resolveRepoRoot(rootInput);
+    const maxCommits = Math.max(10, Math.min(500, options?.maxCommits ?? 120));
+    const gitIntelligence = await analyzeGitIntelligence(root);
+    const limitations = [
+        "Timeline events come from git log — shallow or missing git yields empty timeline.",
+        "Trends are INFERRED heuristics — not predictive analytics.",
+        ...gitIntelligence.limitations,
+    ];
+    if (!gitIntelligence.gitAvailable) {
+        return {
+            root,
+            gitAvailable: false,
+            events: [],
+            trends: [],
+            gitIntelligence,
+            limitations,
+        };
+    }
+    const events = parseLogSummary(root, maxCommits);
+    const trends = inferTrends(events, gitIntelligence);
+    return {
+        root,
+        gitAvailable: true,
+        events,
+        trends,
+        gitIntelligence,
+        limitations,
+    };
+}

package/dist/product/features/intelligence.d.ts

@@ -0,0 +1,23 @@
+import type { ProductEvidence, TruthLabel } from "../truth.js";
+export interface FeatureFlowLink {
+    layer: "ui" | "api" | "service" | "db";
+    label: string;
+    path?: string;
+    truth: TruthLabel;
+    evidence: ProductEvidence[];
+}
+export interface FeatureFlow {
+    featureId: string;
+    title: string;
+    docSource?: string;
+    docLine?: number;
+    links: FeatureFlowLink[];
+    zombie: boolean;
+    truth: TruthLabel;
+}
+export interface FeatureIntelligenceReport {
+    root: string;
+    features: FeatureFlow[];
+    limitations: string[];
+}
+export declare function analyzeFeatureIntelligence(rootInput: string, maxFileSizeBytes?: number): Promise<FeatureIntelligenceReport>;