@praneeth_54/agentdoctor 2.1.0 → 3.0.1

package/dist/product/dna/build.js

@@ -0,0 +1,255 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { detectProject } from "../../detectors/project.js";
+import { detectMonorepo } from "../../core/monorepo/detect.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { pathExists, readJsonFile } from "../../utils/fs.js";
+const FRONTEND_FW = new Set(["react", "nextjs", "vue", "nuxt", "angular", "svelte", "solid"]);
+const BACKEND_FW = new Set([
+    "express",
+    "nestjs",
+    "fastapi",
+    "django",
+    "flask",
+    "laravel",
+    "rails",
+    "spring",
+]);
+function classifyFramework(id) {
+    const lower = id.toLowerCase();
+    if (FRONTEND_FW.has(lower))
+        return "frontend";
+    if (BACKEND_FW.has(lower))
+        return "backend";
+    return "other";
+}
+function isSourcePath(p) {
+    return /\.(ts|tsx|js|jsx|mjs|cjs|py|php|go|rs|java|kt|kts|dart|rb|cs)$/i.test(p);
+}
+function isTestPath(p) {
+    const lower = p.toLowerCase();
+    return (lower.includes(".test.") ||
+        lower.includes(".spec.") ||
+        lower.startsWith("tests/") ||
+        lower.startsWith("test/") ||
+        lower.includes("/__tests__/"));
+}
+function isConfigPath(p) {
+    const base = path.posix.basename(p).toLowerCase();
+    return (base.endsWith(".json") ||
+        base.endsWith(".yml") ||
+        base.endsWith(".yaml") ||
+        base.endsWith(".toml") ||
+        base.endsWith(".ini") ||
+        base.startsWith(".env") ||
+        base.includes("config"));
+}
+/**
+ * Deterministic Project DNA from repository detectors + file inventory.
+ */
+export async function buildProjectDna(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const limitations = [
+        "DNA is derived from file markers and dependency manifests — not runtime introspection.",
+        "Database/cloud signals are heuristic (PARTIAL) unless schema/infra files are present.",
+    ];
+    const detection = await detectProject(root);
+    const mono = await detectMonorepo(root);
+    const repo = detection.repository;
+    const relativePaths = detection.discovery.files.map((f) => f.relativePath.replace(/\\/g, "/"));
+    const languages = (repo.languages ?? []).filter((l) => l !== "unknown");
+    const frameworks = (repo.frameworks ?? []).filter((f) => f !== "unknown");
+    const packageManagers = (repo.packageManagers ?? []).filter((p) => p !== "unknown");
+    const frontend = [];
+    const backend = [];
+    for (const fw of frameworks) {
+        const kind = classifyFramework(fw);
+        if (kind === "frontend")
+            frontend.push(fw);
+        else if (kind === "backend")
+            backend.push(fw);
+    }
+    const database = [];
+    const dbMarkers = [
+        ["prisma", /(^|\/)prisma\/schema\.prisma$/i],
+        ["sql-migrations", /(^|\/)migrations\/.+\.sql$/i],
+        ["laravel-migrations", /database\/migrations\/.+\.php$/i],
+        ["sequelize", /sequelize/i],
+        ["typeorm", /typeorm/i],
+        ["mongoose", /mongoose/i],
+    ];
+    for (const [label, re] of dbMarkers) {
+        if (relativePaths.some((p) => re.test(p)))
+            database.push(label);
+    }
+    const infrastructure = [];
+    const infraFiles = [
+        ["docker", "Dockerfile"],
+        ["compose", "docker-compose.yml"],
+        ["compose", "docker-compose.yaml"],
+        ["kubernetes", "k8s"],
+        ["terraform", ".tf"],
+        ["github-actions", ".github/workflows"],
+    ];
+    for (const [label, marker] of infraFiles) {
+        if (relativePaths.some((p) => p === marker ||
+            p.endsWith(`/${marker}`) ||
+            p.startsWith(`${marker}/`) ||
+            p.endsWith(marker))) {
+            if (!infrastructure.includes(label))
+                infrastructure.push(label);
+        }
+    }
+    const cloudIndicators = [];
+    for (const p of relativePaths) {
+        const lower = p.toLowerCase();
+        if (lower.includes("serverless") || lower.includes("sam.template"))
+            cloudIndicators.push("serverless");
+        if (lower.includes("vercel.json"))
+            cloudIndicators.push("vercel");
+        if (lower.includes("netlify.toml"))
+            cloudIndicators.push("netlify");
+        if (lower.includes("fly.toml"))
+            cloudIndicators.push("fly");
+    }
+    const buildSystems = [];
+    for (const [label, file] of [
+        ["tsc", "tsconfig.json"],
+        ["vite", "vite.config.ts"],
+        ["webpack", "webpack.config.js"],
+        ["gradle", "build.gradle"],
+        ["maven", "pom.xml"],
+        ["cargo", "Cargo.toml"],
+    ]) {
+        if (relativePaths.some((p) => p === file || p.endsWith(`/${file}`)))
+            buildSystems.push(label);
+    }
+    const testFrameworks = [];
+    const pkg = await readJsonFile(path.join(root, "package.json"), 512 * 1024);
+    const deps = {
+        ...(pkg.ok ? (pkg.data.dependencies ?? {}) : {}),
+        ...(pkg.ok ? (pkg.data.devDependencies ?? {}) : {}),
+    };
+    for (const name of ["vitest", "jest", "mocha", "pytest", "phpunit", "go test"]) {
+        if (name === "go test") {
+            if (await pathExists(path.join(root, "go.mod")))
+                testFrameworks.push("go-test");
+            continue;
+        }
+        if (name in deps || relativePaths.some((p) => p.includes(name))) {
+            if (!testFrameworks.includes(name))
+                testFrameworks.push(name);
+        }
+    }
+    // Marker scan for common AI coding tool configuration directories/files
+    const aiCodingTools = [];
+    for (const [id, marker] of [
+        ["cursor", ".cursor"],
+        ["claude-code", ".claude"],
+        ["codex", ".codex"],
+        ["copilot", ".github/copilot-instructions.md"],
+        ["windsurf", ".windsurfrules"],
+        ["gemini-cli", ".gemini"],
+        ["aider", ".aider"],
+    ]) {
+        if (relativePaths.some((p) => p === marker || p.startsWith(`${marker}/`) || p.endsWith(`/${marker}`)) ||
+            (await pathExists(path.join(root, marker)))) {
+            aiCodingTools.push(id);
+        }
+    }
+    const hasGit = await pathExists(path.join(root, ".git"));
+    const name = (pkg.ok && typeof pkg.data.name === "string" && pkg.data.name) || path.basename(root);
+    let projectType = "library-or-app";
+    if (mono.isMonorepo)
+        projectType = "monorepo";
+    else if (frontend.length && backend.length)
+        projectType = "fullstack-app";
+    else if (frontend.length)
+        projectType = "frontend-app";
+    else if (backend.length)
+        projectType = "backend-app";
+    else if (languages.includes("python"))
+        projectType = "python-project";
+    else if (languages.includes("php"))
+        projectType = "php-project";
+    const sourceFiles = relativePaths.filter(isSourcePath).length;
+    const testFiles = relativePaths.filter(isTestPath).length;
+    const configFiles = relativePaths.filter(isConfigPath).length;
+    const configurationStructure = [
+        ...new Set(relativePaths
+            .filter(isConfigPath)
+            .map((p) => p.split("/").slice(0, 2).join("/"))
+            .slice(0, 40)),
+    ].sort();
+    const packages = mono.packages.map((p) => p.name);
+    const applications = mono.packages
+        .filter((p) => /app|web|api|service/i.test(p.relativePath) || /app|web|api/i.test(p.name))
+        .map((p) => p.name);
+    const services = applications.slice();
+    const externalIntegrations = [];
+    for (const key of Object.keys(deps)) {
+        if (/stripe|twilio|sendgrid|aws-sdk|@aws-sdk|firebase|supabase|openai|anthropic/i.test(key)) {
+            externalIntegrations.push(key);
+        }
+    }
+    const fingerprintPayload = JSON.stringify({
+        name,
+        languages: [...languages].sort(),
+        frameworks: [...frameworks].sort(),
+        packageManagers: [...packageManagers].sort(),
+        monorepo: mono.isMonorepo,
+        packages: [...packages].sort(),
+        fileCount: relativePaths.length,
+    });
+    const fingerprint = createHash("sha256").update(fingerprintPayload).digest("hex").slice(0, 16);
+    return {
+        fingerprint,
+        name,
+        root,
+        projectType,
+        languages,
+        frameworks,
+        frontend,
+        backend,
+        database: [...new Set(database)],
+        packageManagers,
+        buildSystems: [...new Set(buildSystems)],
+        testFrameworks: [...new Set(testFrameworks)],
+        infrastructure: [...new Set(infrastructure)],
+        cloudIndicators: [...new Set(cloudIndicators)],
+        git: { present: hasGit, truth: hasGit ? "VERIFIED" : "UNKNOWN" },
+        monorepo: {
+            isMonorepo: mono.isMonorepo,
+            tool: mono.tool,
+            packages: mono.packages.map((p) => ({ name: p.name, path: p.relativePath })),
+            truth: mono.isMonorepo ? "VERIFIED" : "VERIFIED",
+        },
+        services,
+        packages,
+        applications,
+        externalIntegrations: [...new Set(externalIntegrations)].sort(),
+        aiCodingTools: [...new Set(aiCodingTools)].sort(),
+        counts: {
+            files: relativePaths.length,
+            sourceFiles,
+            testFiles,
+            configFiles,
+        },
+        configurationStructure,
+        truth: "VERIFIED",
+        limitations: [...limitations, ...mono.limitations],
+        generatedAt: new Date().toISOString(),
+    };
+}
+export async function persistProjectDna(rootInput, dna) {
+    const root = resolveRepoRoot(rootInput);
+    const built = dna ?? (await buildProjectDna(root));
+    const dir = path.join(root, ".agentdoctor", "dna");
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(path.join(dir, "project-dna.json"), `${JSON.stringify(built, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    return built;
+}

package/dist/product/eval/lab.d.ts

@@ -0,0 +1,17 @@
+import type { TruthLabel } from "../truth.js";
+export interface EvalCheckResult {
+    id: string;
+    description: string;
+    passed: boolean;
+    truth: TruthLabel;
+    detail?: string;
+}
+export interface EvalLabReport {
+    root: string;
+    fixtureRoot: string;
+    fixturesRun: string[];
+    checks: EvalCheckResult[];
+    passed: boolean;
+    limitations: string[];
+}
+export declare function runEvalLab(rootInput?: string): Promise<EvalLabReport>;

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;