@praneeth_54/agentdoctor 2.1.0 → 3.0.0

package/dist/product/discovery/roots.js

@@ -0,0 +1,215 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { DEFAULT_IGNORE_DIRECTORIES } from "../../constants.js";
+import { isDirectory, pathExists } from "../../utils/fs.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+/** Markers that strongly suggest a software project root. */
+const PROJECT_MARKERS = [
+    "package.json",
+    "composer.json",
+    "pyproject.toml",
+    "Cargo.toml",
+    "go.mod",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "Gemfile",
+    "mix.exs",
+    "pubspec.yaml",
+    ".git",
+];
+const SUSPICIOUS_DIR_NAMES = new Set([
+    "desktop",
+    "downloads",
+    "documents",
+    "pictures",
+    "movies",
+    "music",
+    "library",
+    "applications",
+]);
+function normalizeHome(home) {
+    return path.resolve(home);
+}
+function isUnderHomeSubtree(abs, home, leaf) {
+    const target = path.resolve(home, leaf);
+    const resolved = path.resolve(abs);
+    return resolved === target || resolved.startsWith(target + path.sep);
+}
+async function countEntriesShallow(dir, budget) {
+    let count = 0;
+    const queue = [dir];
+    const skip = DEFAULT_IGNORE_DIRECTORIES;
+    while (queue.length > 0 && count < budget) {
+        const current = queue.pop();
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            count += 1;
+            if (count >= budget)
+                return count;
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            if (skip.has(entry.name) || entry.name.startsWith("."))
+                continue;
+            queue.push(path.join(current, entry.name));
+        }
+    }
+    return count;
+}
+async function markersAt(dir) {
+    const found = [];
+    for (const marker of PROJECT_MARKERS) {
+        if (await pathExists(path.join(dir, marker))) {
+            found.push(marker);
+        }
+    }
+    return found;
+}
+function scoreMarkers(markers) {
+    let score = 0;
+    for (const m of markers) {
+        if (m === ".git")
+            score += 3;
+        else if (m === "package.json" || m === "composer.json" || m === "pyproject.toml")
+            score += 5;
+        else
+            score += 4;
+    }
+    return score;
+}
+/**
+ * Discover likely project roots from cwd without silently scanning home/Desktop/Downloads
+ * or unbounded parent trees.
+ */
+export async function discoverProjectRoots(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const home = normalizeHome(os.homedir());
+    const maxEntries = options.maxEntries ?? 25_000;
+    const limitations = [
+        "Discovery uses shallow marker probes and bounded entry counts — not a full repository index.",
+        "Candidates are VERIFIED only when marker files/directories exist on disk.",
+    ];
+    const baselower = path.basename(cwd).toLowerCase();
+    if (cwd === home ||
+        SUSPICIOUS_DIR_NAMES.has(baselower) ||
+        isUnderHomeSubtree(cwd, home, "Desktop") ||
+        isUnderHomeSubtree(cwd, home, "Downloads") ||
+        isUnderHomeSubtree(cwd, home, "Documents")) {
+        const estimatedEntries = await countEntriesShallow(cwd, Math.min(maxEntries, 5_000));
+        return {
+            cwd,
+            home,
+            candidates: [],
+            selected: null,
+            blocked: true,
+            blockReason: "Refusing to scan home / Desktop / Downloads / Documents (or similarly broad user folders) as a project root. Navigate into a project directory or pass an explicit project path.",
+            estimatedEntries,
+            limitations,
+        };
+    }
+    const estimatedEntries = await countEntriesShallow(cwd, maxEntries + 1);
+    if (estimatedEntries > maxEntries) {
+        return {
+            cwd,
+            home,
+            candidates: [],
+            selected: null,
+            blocked: true,
+            blockReason: `Directory tree exceeds safe scan budget (${maxEntries} entries). Narrow to a project subdirectory or raise --max-entries deliberately.`,
+            estimatedEntries,
+            limitations,
+        };
+    }
+    const candidates = [];
+    const seen = new Set();
+    async function consider(dir, reason) {
+        const resolved = path.resolve(dir);
+        if (seen.has(resolved))
+            return;
+        if (!(await isDirectory(resolved)))
+            return;
+        if (resolved === home)
+            return;
+        const markers = await markersAt(resolved);
+        if (markers.length === 0)
+            return;
+        seen.add(resolved);
+        candidates.push({
+            root: resolved,
+            score: scoreMarkers(markers),
+            markers,
+            truth: "VERIFIED",
+            reason,
+        });
+    }
+    if (options.prefer) {
+        await consider(options.prefer, "explicit prefer path");
+    }
+    await consider(cwd, "current working directory");
+    // Walk up a few parents looking for markers (bounded).
+    let parent = path.dirname(cwd);
+    for (let i = 0; i < 4; i++) {
+        if (parent === home || parent === path.dirname(parent))
+            break;
+        await consider(parent, "parent directory with project markers");
+        parent = path.dirname(parent);
+    }
+    // Immediate children that look like projects (monorepo packages / sibling apps).
+    try {
+        const entries = await fs.readdir(cwd, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            if (DEFAULT_IGNORE_DIRECTORIES.has(entry.name) || entry.name.startsWith("."))
+                continue;
+            await consider(path.join(cwd, entry.name), "child directory with project markers");
+        }
+    }
+    catch {
+        limitations.push("Could not list child directories for candidate discovery.");
+    }
+    candidates.sort((a, b) => b.score - a.score || a.root.localeCompare(b.root));
+    let selected = null;
+    if (options.prefer) {
+        selected = candidates.find((c) => c.root === path.resolve(options.prefer)) ?? null;
+    }
+    else if (options.autoSelect !== false) {
+        const strong = candidates.filter((c) => c.score >= 5);
+        if (strong.length === 1) {
+            selected = strong[0];
+        }
+        else if (candidates.length === 1) {
+            selected = candidates[0];
+        }
+    }
+    return {
+        cwd,
+        home,
+        candidates,
+        selected,
+        blocked: false,
+        blockReason: null,
+        estimatedEntries,
+        limitations,
+    };
+}
+export async function resolveStartedProjectRoot(pathArg, options) {
+    const prefer = pathArg ? resolveRepoRoot(pathArg) : undefined;
+    const discovery = await discoverProjectRoots({
+        cwd: prefer ?? process.cwd(),
+        ...(prefer !== undefined ? { prefer } : {}),
+        ...(options?.maxEntries !== undefined ? { maxEntries: options.maxEntries } : {}),
+        autoSelect: true,
+    });
+    if (discovery.blocked || !discovery.selected) {
+        return { ok: false, discovery };
+    }
+    return { ok: true, root: discovery.selected.root, discovery };
+}

package/dist/product/dna/build.d.ts

@@ -0,0 +1,50 @@
+import type { TruthLabel } from "../truth.js";
+export interface ProjectDna {
+    fingerprint: string;
+    name: string;
+    root: string;
+    projectType: string;
+    languages: string[];
+    frameworks: string[];
+    frontend: string[];
+    backend: string[];
+    database: string[];
+    packageManagers: string[];
+    buildSystems: string[];
+    testFrameworks: string[];
+    infrastructure: string[];
+    cloudIndicators: string[];
+    git: {
+        present: boolean;
+        truth: TruthLabel;
+    };
+    monorepo: {
+        isMonorepo: boolean;
+        tool: string;
+        packages: Array<{
+            name: string;
+            path: string;
+        }>;
+        truth: TruthLabel;
+    };
+    services: string[];
+    packages: string[];
+    applications: string[];
+    externalIntegrations: string[];
+    aiCodingTools: string[];
+    counts: {
+        files: number;
+        sourceFiles: number;
+        testFiles: number;
+        configFiles: number;
+    };
+    configurationStructure: string[];
+    truth: TruthLabel;
+    limitations: string[];
+    generatedAt: string;
+}
+/**
+ * Deterministic Project DNA from repository detectors + file inventory.
+ */
+export declare function buildProjectDna(rootInput: string): Promise<ProjectDna>;
+export declare function persistProjectDna(rootInput: string, dna?: ProjectDna): Promise<ProjectDna>;

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>;