@praneeth_54/agentdoctor 1.1.0 → 2.0.0

package/dist/core/monorepo/detect.js

@@ -0,0 +1,121 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveRepoRoot, toPosixRelative } from "../../utils/path.js";
+async function readJson(file) {
+    try {
+        const raw = await fs.readFile(file, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveGlobDirs(root, pattern) {
+    // Support simple patterns: "packages/*", "apps/*", "."
+    if (pattern === "." || pattern === "./") {
+        return [root];
+    }
+    const normalized = pattern.replace(/^\.\//, "").replace(/\/$/, "");
+    if (normalized.endsWith("/*")) {
+        const parent = path.join(root, normalized.slice(0, -2));
+        try {
+            const entries = await fs.readdir(parent, { withFileTypes: true });
+            return entries
+                .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+                .map((e) => path.join(parent, e.name));
+        }
+        catch {
+            return [];
+        }
+    }
+    const candidate = path.join(root, normalized);
+    try {
+        const st = await fs.stat(candidate);
+        return st.isDirectory() ? [candidate] : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function packageFromDir(root, dir) {
+    const pkg = await readJson(path.join(dir, "package.json"));
+    if (!pkg)
+        return null;
+    const name = typeof pkg.name === "string" ? pkg.name : path.basename(dir);
+    return {
+        name,
+        relativePath: toPosixRelative(root, dir) || ".",
+        absolutePath: dir,
+    };
+}
+export async function detectMonorepo(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const limitations = [];
+    const packages = [];
+    const rootPkg = await readJson(path.join(root, "package.json"));
+    let tool = "none";
+    const patterns = [];
+    if (rootPkg) {
+        const workspaces = rootPkg.workspaces;
+        if (Array.isArray(workspaces)) {
+            tool = "npm-workspaces";
+            for (const p of workspaces) {
+                if (typeof p === "string")
+                    patterns.push(p);
+            }
+        }
+        else if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
+            const pkgs = workspaces.packages;
+            if (Array.isArray(pkgs)) {
+                tool = "npm-workspaces";
+                for (const p of pkgs) {
+                    if (typeof p === "string")
+                        patterns.push(p);
+                }
+            }
+        }
+    }
+    try {
+        const pnpmRaw = await fs.readFile(path.join(root, "pnpm-workspace.yaml"), "utf8");
+        tool = "pnpm-workspaces";
+        for (const line of pnpmRaw.split(/\r?\n/)) {
+            const m = line.match(/^\s*-\s+['"]?([^'"]+)['"]?\s*$/);
+            if (m?.[1])
+                patterns.push(m[1]);
+        }
+    }
+    catch {
+        // optional
+    }
+    const seen = new Set();
+    for (const pattern of patterns) {
+        const dirs = await resolveGlobDirs(root, pattern);
+        for (const dir of dirs) {
+            const pkg = await packageFromDir(root, dir);
+            if (!pkg)
+                continue;
+            if (seen.has(pkg.absolutePath))
+                continue;
+            seen.add(pkg.absolutePath);
+            packages.push(pkg);
+        }
+    }
+    if (packages.length === 0) {
+        const self = await packageFromDir(root, root);
+        if (self) {
+            packages.push(self);
+        }
+        limitations.push("No workspace packages discovered; treating repository as a single package");
+    }
+    packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    return {
+        root,
+        isMonorepo: tool !== "none",
+        tool,
+        packages,
+        limitations,
+    };
+}

package/dist/core/rules/build-context.js

@@ -1,10 +1,13 @@
 import { parseProjectMcpConfigs } from "../mcp/parse.js";
 import { createIgnoreIndex, parseIgnoreFile, relativizeIgnorePatterns } from "./ignore.js";
 import { TextCache } from "./text-cache.js";
+const ROOT_IGNORE_FILES = new Set([".gitignore", ".cursorignore", ".geminiignore", ".aiderignore"]);
 export async function buildRuleContext(options) {
     const textCache = new TextCache(options.root, options.maxFileSizeBytes);
     const gitignorePatterns = [];
     const cursorignorePatterns = [];
+    const geminiignorePatterns = [];
+    const aiderignorePatterns = [];
     const rootGitignore = await textCache.read(".gitignore");
     if (rootGitignore.text) {
         gitignorePatterns.push(...parseIgnoreFile(rootGitignore.text));
@@ -13,12 +16,20 @@ export async function buildRuleContext(options) {
     if (rootCursorignore.text) {
         cursorignorePatterns.push(...parseIgnoreFile(rootCursorignore.text));
     }
+    const rootGeminiignore = await textCache.read(".geminiignore");
+    if (rootGeminiignore.text) {
+        geminiignorePatterns.push(...parseIgnoreFile(rootGeminiignore.text));
+    }
+    const rootAiderignore = await textCache.read(".aiderignore");
+    if (rootAiderignore.text) {
+        aiderignorePatterns.push(...parseIgnoreFile(rootAiderignore.text));
+    }
     for (const file of options.discovery.files) {
         const base = file.relativePath.split("/").pop() ?? file.relativePath;
-        if (base !== ".gitignore" && base !== ".cursorignore") {
+        if (!ROOT_IGNORE_FILES.has(base)) {
             continue;
         }
-        if (file.relativePath === ".gitignore" || file.relativePath === ".cursorignore") {
+        if (ROOT_IGNORE_FILES.has(file.relativePath)) {
             continue;
         }
         const cached = await textCache.read(file.relativePath);
@@ -32,13 +43,21 @@ export async function buildRuleContext(options) {
         if (base === ".gitignore") {
             gitignorePatterns.push(...patterns);
         }
-        else {
+        else if (base === ".cursorignore") {
             cursorignorePatterns.push(...patterns);
         }
+        else if (base === ".geminiignore") {
+            geminiignorePatterns.push(...patterns);
+        }
+        else if (base === ".aiderignore") {
+            aiderignorePatterns.push(...patterns);
+        }
     }
     const ignore = createIgnoreIndex({
         gitignorePatterns,
         cursorignorePatterns,
+        geminiignorePatterns,
+        aiderignorePatterns,
     });
     const mcp = await parseProjectMcpConfigs(options.root, options.maxFileSizeBytes);
     const instructionPaths = new Set();

package/dist/core/rules/context/generated-directory.js

@@ -33,6 +33,16 @@ async function agentsStillExposed(context, relativePath, configured) {
         if (agent === "codex" && (await codexDeniesPath(context, relativePath))) {
             continue;
         }
+        if (agent === "gemini-cli" &&
+            (context.ignore.matchesGeminiignore(relativePath) ||
+                context.ignore.matchesGeminiignore(`${relativePath}/`))) {
+            continue;
+        }
+        if (agent === "aider" &&
+            (context.ignore.matchesAiderignore(relativePath) ||
+                context.ignore.matchesAiderignore(`${relativePath}/`))) {
+            continue;
+        }
         exposed.push(agent);
     }
     return exposed;
@@ -78,7 +88,7 @@ export const generatedDirectoryRule = {
                     title: "Generated directory may enter agent context",
                     message: `${relativePath}/ (${entry.label}) is present and no project ignore pattern was detected`,
                     whyItMatters: "Generated directories are usually low-value for coding agents and can bloat indexing/context when not excluded.",
-                    recommendation: `Add an ignore pattern covering ${relativePath}/ to .gitignore and agent exclusions (.cursorignore, Claude Code Read deny, and/or Codex filesystem deny).`,
+                    recommendation: `Add an ignore pattern covering ${relativePath}/ to .gitignore and agent exclusions (.cursorignore, Claude Code Read deny, Codex filesystem deny, .geminiignore, and/or .aiderignore).`,
                     affectedAgents: affected,
                     evidence: { path: relativePath },
                     fixability: "safe",

package/dist/core/rules/context/large-instruction-file.js

@@ -7,6 +7,12 @@ const INSTRUCTION_KINDS = new Set([
     "claude-md",
     "claude-local-md",
     "claude-rule-md",
+    "copilot-instructions",
+    "copilot-path-instructions",
+    "windsurf-rule-md",
+    "windsurf-legacy-rules",
+    "gemini-md",
+    "aider-conventions",
 ]);
 export const largeInstructionFileRule = {
     id: "context/large-instruction-file",

package/dist/core/rules/context/large-log-file.js

@@ -26,7 +26,15 @@ export const largeLogFileRule = {
             if (context.ignore.matchesGitignore(file.relativePath)) {
                 continue;
             }
-            const defaultAgents = ["cursor", "claude-code", "codex"];
+            const defaultAgents = [
+                "cursor",
+                "claude-code",
+                "codex",
+                "copilot",
+                "windsurf",
+                "gemini-cli",
+                "aider",
+            ];
             const candidates = configured.length > 0 ? configured : defaultAgents;
             const affected = [];
             for (const agent of candidates) {
@@ -39,6 +47,13 @@ export const largeLogFileRule = {
                 if (agent === "codex" && (await codexDeniesPath(context, file.relativePath))) {
                     continue;
                 }
+                if (agent === "gemini-cli" && context.ignore.matchesGeminiignore(file.relativePath)) {
+                    continue;
+                }
+                if (agent === "aider" && context.ignore.matchesAiderignore(file.relativePath)) {
+                    continue;
+                }
+                // Copilot / Windsurf: no official project deny/ignore path.
                 affected.push(agent);
             }
             if (affected.length === 0) {

package/dist/core/rules/ignore.d.ts

@@ -1,14 +1,22 @@
 /**
- * Minimal gitignore-style pattern matching for .gitignore / .cursorignore.
+ * Minimal gitignore-style pattern matching for .gitignore / agent ignore files.
  * Supports common patterns used in agent ignore files — not a full gitignore clone.
  */
 export interface IgnoreIndex {
     gitignorePatterns: string[];
     cursorignorePatterns: string[];
+    geminiignorePatterns: string[];
+    aiderignorePatterns: string[];
     matchesGitignore(relativePath: string): boolean;
     matchesCursorignore(relativePath: string): boolean;
+    matchesGeminiignore(relativePath: string): boolean;
+    matchesAiderignore(relativePath: string): boolean;
     /** Whether a path appears excluded for Cursor agent/indexing purposes. */
     isExcludedForCursor(relativePath: string): boolean;
+    /** Gemini CLI respects .geminiignore and .gitignore. */
+    isExcludedForGemini(relativePath: string): boolean;
+    /** Aider respects .aiderignore and typically .gitignore. */
+    isExcludedForAider(relativePath: string): boolean;
 }
 export declare function parseIgnoreFile(content: string): string[];
 /**
@@ -25,4 +33,6 @@ export declare function pathMatchesAny(relativePath: string, patterns: string[])
 export declare function createIgnoreIndex(options: {
     gitignorePatterns: string[];
     cursorignorePatterns: string[];
+    geminiignorePatterns?: string[];
+    aiderignorePatterns?: string[];
 }): IgnoreIndex;

package/dist/core/rules/ignore.js

@@ -50,7 +50,6 @@ export function matchIgnorePattern(relativePath, pattern) {
     if (pat.endsWith("/")) {
         const dir = pat.slice(0, -1);
         if (!dir.includes("/")) {
-            // `build/` matches build at any directory level (gitignore semantics)
             matched =
                 pathNorm === dir ||
                     pathNorm.endsWith(`/${dir}`) ||
@@ -114,15 +113,25 @@ const CURSOR_DEFAULT_ENV_PATTERNS = [".env", ".env.*", "**/.env", "**/.env.*"];
 export function createIgnoreIndex(options) {
     const gitignorePatterns = options.gitignorePatterns;
     const cursorignorePatterns = options.cursorignorePatterns;
+    const geminiignorePatterns = options.geminiignorePatterns ?? [];
+    const aiderignorePatterns = options.aiderignorePatterns ?? [];
     return {
         gitignorePatterns,
         cursorignorePatterns,
+        geminiignorePatterns,
+        aiderignorePatterns,
         matchesGitignore(relativePath) {
             return pathMatchesAny(relativePath, gitignorePatterns);
         },
         matchesCursorignore(relativePath) {
             return pathMatchesAny(relativePath, cursorignorePatterns);
         },
+        matchesGeminiignore(relativePath) {
+            return pathMatchesAny(relativePath, geminiignorePatterns);
+        },
+        matchesAiderignore(relativePath) {
+            return pathMatchesAny(relativePath, aiderignorePatterns);
+        },
         isExcludedForCursor(relativePath) {
             if (pathMatchesAny(relativePath, cursorignorePatterns)) {
                 return true;
@@ -132,5 +141,17 @@ export function createIgnoreIndex(options) {
             }
             return pathMatchesAny(relativePath, CURSOR_DEFAULT_ENV_PATTERNS);
         },
+        isExcludedForGemini(relativePath) {
+            if (pathMatchesAny(relativePath, geminiignorePatterns)) {
+                return true;
+            }
+            return pathMatchesAny(relativePath, gitignorePatterns);
+        },
+        isExcludedForAider(relativePath) {
+            if (pathMatchesAny(relativePath, aiderignorePatterns)) {
+                return true;
+            }
+            return pathMatchesAny(relativePath, gitignorePatterns);
+        },
     };
 }

package/dist/core/rules/instructions/empty-instructions.js

@@ -6,6 +6,13 @@ const EMPTYABLE_KINDS = new Set([
     "claude-md",
     "claude-local-md",
     "claude-rule-md",
+    "copilot-instructions",
+    "copilot-path-instructions",
+    "windsurf-rule-md",
+    "windsurf-legacy-rules",
+    "gemini-md",
+    "aider-conventions",
+    "aider-conf",
 ]);
 export const emptyInstructionsRule = {
     id: "instructions/empty-instructions",

package/dist/core/rules/security/env-file-exposure.js

@@ -60,6 +60,27 @@ function agentsWithoutClearExclusion(context, relativePath) {
         }
         if (agent.id === "codex") {
             affected.push("codex");
+            continue;
+        }
+        if (agent.id === "copilot") {
+            // No official project-local Copilot deny/ignore file; treat as exposed when present.
+            affected.push("copilot");
+            continue;
+        }
+        if (agent.id === "windsurf") {
+            affected.push("windsurf");
+            continue;
+        }
+        if (agent.id === "gemini-cli") {
+            if (!context.ignore.isExcludedForGemini(relativePath)) {
+                affected.push("gemini-cli");
+            }
+            continue;
+        }
+        if (agent.id === "aider") {
+            if (!context.ignore.isExcludedForAider(relativePath)) {
+                affected.push("aider");
+            }
         }
     }
     return affected;
@@ -95,7 +116,7 @@ export const envFileExposureRule = {
                     severity: kind === "backup" ? "warning" : "critical",
                     title: "Sensitive environment file present in repository",
                     message: `Sensitive environment file present in the repository: ${file.relativePath}`,
-                    whyItMatters: "No supported coding-agent configuration was detected, so agent-specific exposure was not asserted. The file is still high-risk repository material if tracked or shared.",
+                    whyItMatters: "No supported coding-agent configuration was detected, so agent-specific exposure was not asserted. Repository hygiene still applies: the file is high-risk if tracked or shared.",
                     recommendation: "Keep runtime environment files out of version control and rotate credentials if the file may have been shared.",
                     affectedAgents: [],
                     evidence: {
@@ -127,7 +148,7 @@ export const envFileExposureRule = {
                 title: "Sensitive environment file may enter agent context",
                 message: `Sensitive environment file detected and no relevant exclusion was found for: ${file.relativePath}`,
                 whyItMatters: "Environment files frequently hold API keys and credentials. If readable by an AI coding agent, those values may be included in prompts or logs.",
-                recommendation: "Add an agent-specific exclusion (for example .cursorignore, a Claude Code Read deny rule, or a Codex filesystem deny), keep the file out of version control, and rotate any credentials that may have been exposed.",
+                recommendation: "Add an agent-specific exclusion (for example .cursorignore, a Claude Code Read deny rule, a Codex filesystem deny, .geminiignore, or .aiderignore), keep the file out of version control, and rotate any credentials that may have been exposed.",
                 affectedAgents: affected,
                 evidence: {
                     path: file.relativePath,

package/dist/core/rules/security/private-key-file.js

@@ -58,7 +58,7 @@ export const privateKeyFileRule = {
                 message: `Possible ${label} detected at ${file.relativePath}`,
                 whyItMatters: agentsPresent
                     ? "Credential material in the working tree can be read by AI coding agents and may leak into model context or logs. Filename heuristics only — contents were not inspected."
-                    : "Credential material in the working tree is high-risk repository content. No supported coding-agent configuration was detected, so agent-specific exposure was not asserted. Filename heuristics only — contents were not inspected.",
+                    : "Credential material in the working tree is high-risk repository content. No supported coding-agent configuration was detected, so agent-specific exposure was not asserted. Repository hygiene still applies. Filename heuristics only — contents were not inspected.",
                 recommendation: "Remove the file from the repository, rotate the credential, add ignore rules, and never commit replacements.",
                 affectedAgents: affected,
                 evidence: { path: file.relativePath, detail: label },

package/dist/core/scanner/scan.js

@@ -49,7 +49,7 @@ export async function scan(options = {}) {
     const agentsPresent = agents.some((a) => a.detected || a.configured);
     const agentSecurityAnalysis = agentsPresent ? "full" : "limited";
     if (agentSecurityAnalysis === "limited") {
-        warnings.push("No supported coding-agent configuration detected; agent-specific security exposure checks are limited.");
+        warnings.push("Agent-specific exposure checks are limited (no supported agent config); repository hygiene still applied.");
     }
     const scoringStarted = performance.now();
     const scores = computeReadinessScores(findings);

package/dist/core/schemas/validate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Minimal JSON Schema subset validator for AgentDoctor v2 report schemas.
+ * Supports: type, required, properties, items, enum, integer/string/boolean/object/array/null unions.
+ * Not a full draft-2020 implementation — sufficient for shipped schemas without new deps.
+ */
+export declare function validateAgainstSchema(schema: Record<string, unknown>, value: unknown, path?: string): string[];

package/dist/core/schemas/validate.js

@@ -0,0 +1,62 @@
+/**
+ * Minimal JSON Schema subset validator for AgentDoctor v2 report schemas.
+ * Supports: type, required, properties, items, enum, integer/string/boolean/object/array/null unions.
+ * Not a full draft-2020 implementation — sufficient for shipped schemas without new deps.
+ */
+export function validateAgainstSchema(schema, value, path = "$") {
+    const errors = [];
+    const type = schema.type;
+    if (type !== undefined) {
+        const types = Array.isArray(type) ? type : [type];
+        if (!types.some((t) => matchesType(t, value))) {
+            errors.push(`${path}: expected type ${types.join("|")}`);
+            return errors;
+        }
+    }
+    if (value === null || value === undefined) {
+        return errors;
+    }
+    if (schema.enum && Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+        errors.push(`${path}: value not in enum`);
+    }
+    if (typeof value === "object" && !Array.isArray(value) && schema.properties) {
+        const obj = value;
+        const props = schema.properties;
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        for (const key of required) {
+            if (!(key in obj))
+                errors.push(`${path}.${key}: required`);
+        }
+        for (const [key, childSchema] of Object.entries(props)) {
+            if (key in obj) {
+                errors.push(...validateAgainstSchema(childSchema, obj[key], `${path}.${key}`));
+            }
+        }
+    }
+    if (Array.isArray(value) && schema.items && typeof schema.items === "object") {
+        for (let i = 0; i < value.length; i += 1) {
+            errors.push(...validateAgainstSchema(schema.items, value[i], `${path}[${i}]`));
+        }
+    }
+    return errors;
+}
+function matchesType(type, value) {
+    switch (type) {
+        case "string":
+            return typeof value === "string";
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "object":
+            return typeof value === "object" && value !== null && !Array.isArray(value);
+        case "array":
+            return Array.isArray(value);
+        case "null":
+            return value === null;
+        default:
+            return true;
+    }
+}

package/dist/core/scoring/compute-scores.d.ts

@@ -1,6 +1,6 @@
 import type { Finding, Scores } from "../../types/index.js";
 /**
  * v1 readiness scores from post-dedupe findings.
- * Spec: docs/scoring.md
+ * Spec: docs/reference/scoring.md
  */
 export declare function computeReadinessScores(findings: readonly Finding[]): Scores;

package/dist/core/scoring/compute-scores.js

@@ -10,7 +10,7 @@ const SEVERITY_SORT_RANK = {
 };
 /**
  * v1 readiness scores from post-dedupe findings.
- * Spec: docs/scoring.md
+ * Spec: docs/reference/scoring.md
  */
 export function computeReadinessScores(findings) {
     const overallRaw = 100 - sumDeductions(findings);
@@ -29,6 +29,10 @@ export function computeReadinessScores(findings) {
             cursor: scoreSubset(findings.filter((f) => f.affectedAgents.includes("cursor"))),
             "claude-code": scoreSubset(findings.filter((f) => f.affectedAgents.includes("claude-code"))),
             codex: scoreSubset(findings.filter((f) => f.affectedAgents.includes("codex"))),
+            copilot: scoreSubset(findings.filter((f) => f.affectedAgents.includes("copilot"))),
+            windsurf: scoreSubset(findings.filter((f) => f.affectedAgents.includes("windsurf"))),
+            "gemini-cli": scoreSubset(findings.filter((f) => f.affectedAgents.includes("gemini-cli"))),
+            aider: scoreSubset(findings.filter((f) => f.affectedAgents.includes("aider"))),
         },
     };
 }

package/dist/core/scoring/placeholder.d.ts

@@ -2,6 +2,6 @@ import type { Scores } from "../../types/index.js";
 /**
  * Historical filesScanned-based stub. Kept for unit tests that document the
  * pre-v1 placeholder behavior. Production scans use computeReadinessScores
- * (docs/scoring.md) — do not call this from scan().
+ * (docs/reference/scoring.md) — do not call this from scan().
  */
 export declare function computePlaceholderScores(filesScanned: number): Scores;

package/dist/core/scoring/placeholder.js

@@ -1,7 +1,7 @@
 /**
  * Historical filesScanned-based stub. Kept for unit tests that document the
  * pre-v1 placeholder behavior. Production scans use computeReadinessScores
- * (docs/scoring.md) — do not call this from scan().
+ * (docs/reference/scoring.md) — do not call this from scan().
  */
 export function computePlaceholderScores(filesScanned) {
     const base = 72;
@@ -21,6 +21,10 @@ export function computePlaceholderScores(filesScanned) {
             cursor: clamp(overall - 5),
             "claude-code": clamp(overall - 8),
             codex: clamp(overall - 6),
+            copilot: clamp(overall - 7),
+            windsurf: clamp(overall - 6),
+            "gemini-cli": clamp(overall - 5),
+            aider: clamp(overall - 7),
         },
     };
 }

package/dist/core/secrets/scan.d.ts

@@ -0,0 +1,23 @@
+export interface SecretFinding {
+    file: string;
+    line: number;
+    ruleId: string;
+    /** Always redacted — never contains the secret value */
+    redactedSnippet: string;
+    severity: "critical" | "warning";
+}
+export interface SecretScanReport {
+    root: string;
+    enabled: boolean;
+    filesScanned: number;
+    findings: SecretFinding[];
+    limitations: string[];
+}
+/**
+ * Opt-in content secret scan. Findings never include raw secret values.
+ */
+export declare function scanSecrets(options: {
+    root: string;
+    enabled: boolean;
+    maxFiles?: number;
+}): Promise<SecretScanReport>;