@praneeth_54/agentdoctor 1.1.0 → 2.0.0

package/dist/core/fix/plan.js

@@ -16,14 +16,22 @@ function claudeConfigured(result) {
 function codexConfigured(result) {
     return result.agents.some((a) => a.id === "codex" && (a.detected || a.configured));
 }
-async function loadCursorignorePatterns(root) {
-    const filePath = path.join(root, ".cursorignore");
-    const text = await readTextFile(filePath, DEFAULT_MAX_IGNORE_BYTES);
+function geminiConfigured(result) {
+    return result.agents.some((a) => a.id === "gemini-cli" && (a.detected || a.configured));
+}
+function aiderConfigured(result) {
+    return result.agents.some((a) => a.id === "aider" && (a.detected || a.configured));
+}
+async function loadIgnorePatterns(root, relativePath) {
+    const text = await readTextFile(path.join(root, relativePath), DEFAULT_MAX_IGNORE_BYTES);
     if (text === null) {
         return [];
     }
     return parseIgnoreFile(text);
 }
+async function loadCursorignorePatterns(root) {
+    return loadIgnorePatterns(root, ".cursorignore");
+}
 async function loadClaudeSettingsText(root) {
     return readTextFile(path.join(root, ".claude/settings.json"), DEFAULT_MAX_IGNORE_BYTES);
 }
@@ -32,22 +40,29 @@ async function loadCodexConfigText(root) {
 }
 /**
  * Build a fix plan from a scan result.
- * Safe context exclusions: Cursor `.cursorignore`, Claude Code Read deny, Codex filesystem deny.
+ * Safe context exclusions: Cursor `.cursorignore`, Claude Code Read deny, Codex filesystem deny,
+ * Gemini CLI `.geminiignore`, Aider `.aiderignore`.
  */
 export async function buildFixPlan(result) {
     const root = result.repository.root;
     const skipped = [];
     const actionsByKey = new Map();
     const existingCursorPatterns = await loadCursorignorePatterns(root);
+    const existingGeminiPatterns = await loadIgnorePatterns(root, ".geminiignore");
+    const existingAiderPatterns = await loadIgnorePatterns(root, ".aiderignore");
     const cursorIndex = createIgnoreIndex({
         gitignorePatterns: [],
         cursorignorePatterns: existingCursorPatterns,
+        geminiignorePatterns: existingGeminiPatterns,
+        aiderignorePatterns: existingAiderPatterns,
     });
     const claudeSettingsText = await loadClaudeSettingsText(root);
     const codexConfigText = await loadCodexConfigText(root);
     const hasCursor = cursorConfigured(result);
     const hasClaude = claudeConfigured(result);
     const hasCodex = codexConfigured(result);
+    const hasGemini = geminiConfigured(result);
+    const hasAider = aiderConfigured(result);
     for (const finding of result.findings) {
         if (finding.fixability !== "safe") {
             skipped.push({
@@ -82,6 +97,8 @@ export async function buildFixPlan(result) {
         const wantsCursor = finding.affectedAgents.includes("cursor");
         const wantsClaude = finding.affectedAgents.includes("claude-code");
         const wantsCodex = finding.affectedAgents.includes("codex");
+        const wantsGemini = finding.affectedAgents.includes("gemini-cli");
+        const wantsAider = finding.affectedAgents.includes("aider");
         if (wantsCursor && hasCursor) {
             if (cursorIndex.matchesCursorignore(evidencePath) ||
                 cursorIndex.matchesCursorignore(pattern)) {
@@ -132,8 +149,6 @@ export async function buildFixPlan(result) {
                 });
             }
             else if (codexConfigText) {
-                // Refuse unwritable/invalid config the same way Claude Fix refuses bad JSON —
-                // do not silently skip and leave Codex findings uncleared after a partial Cursor write.
                 assertWritableCodexConfig(codexConfigText);
                 mergeCodexAction(actionsByKey, finding, pattern, evidencePath, denyKey);
             }
@@ -148,8 +163,75 @@ export async function buildFixPlan(result) {
                 reason: "Codex not detected; skipping config.toml deny fix",
             });
         }
+        if (wantsGemini && hasGemini) {
+            if (cursorIndex.matchesGeminiignore(evidencePath) ||
+                cursorIndex.matchesGeminiignore(pattern)) {
+                skipped.push({
+                    findingId: finding.id,
+                    ruleId: finding.ruleId,
+                    reason: "Already excluded by .geminiignore",
+                });
+            }
+            else {
+                mergeSimpleIgnoreAction(actionsByKey, finding, pattern, evidencePath, {
+                    agent: "gemini-cli",
+                    targetRelativePath: ".geminiignore",
+                    label: "Gemini CLI",
+                });
+            }
+        }
+        else if (wantsGemini && !hasGemini) {
+            skipped.push({
+                findingId: finding.id,
+                ruleId: finding.ruleId,
+                reason: "Gemini CLI not detected; skipping .geminiignore fix",
+            });
+        }
+        if (wantsAider && hasAider) {
+            if (cursorIndex.matchesAiderignore(evidencePath) || cursorIndex.matchesAiderignore(pattern)) {
+                skipped.push({
+                    findingId: finding.id,
+                    ruleId: finding.ruleId,
+                    reason: "Already excluded by .aiderignore",
+                });
+            }
+            else {
+                mergeSimpleIgnoreAction(actionsByKey, finding, pattern, evidencePath, {
+                    agent: "aider",
+                    targetRelativePath: ".aiderignore",
+                    label: "Aider",
+                });
+            }
+        }
+        else if (wantsAider && !hasAider) {
+            skipped.push({
+                findingId: finding.id,
+                ruleId: finding.ruleId,
+                reason: "Aider not detected; skipping .aiderignore fix",
+            });
+        }
         for (const agent of finding.affectedAgents) {
-            if (agent === "cursor" || agent === "claude-code" || agent === "codex") {
+            if (agent === "cursor" ||
+                agent === "claude-code" ||
+                agent === "codex" ||
+                agent === "gemini-cli" ||
+                agent === "aider") {
+                continue;
+            }
+            if (agent === "copilot") {
+                skipped.push({
+                    findingId: finding.id,
+                    ruleId: finding.ruleId,
+                    reason: "GitHub Copilot has no official project deny/ignore Fix writer; review instructions and .gitignore manually",
+                });
+                continue;
+            }
+            if (agent === "windsurf") {
+                skipped.push({
+                    findingId: finding.id,
+                    ruleId: finding.ruleId,
+                    reason: "Windsurf has no official project deny/ignore Fix writer; review rules and .gitignore manually",
+                });
                 continue;
             }
             skipped.push({
@@ -225,8 +307,28 @@ function mergeCodexAction(actionsByKey, finding, pattern, evidencePath, denyKey)
         description: `Exclude ${evidencePath} from Codex via filesystem deny "${denyKey}"`,
     });
 }
-/** Patterns that would be newly appended given current file contents. */
-export function missingPatternsForCursorignore(currentContent, patterns) {
+function mergeSimpleIgnoreAction(actionsByKey, finding, pattern, evidencePath, options) {
+    const key = `${options.agent}:${options.targetRelativePath}:${pattern}`;
+    const existing = actionsByKey.get(key);
+    if (existing) {
+        if (!existing.findingIds.includes(finding.id)) {
+            existing.findingIds.push(finding.id);
+        }
+        return;
+    }
+    actionsByKey.set(key, {
+        id: key,
+        kind: "append-ignore-pattern",
+        agent: options.agent,
+        targetRelativePath: options.targetRelativePath,
+        pattern,
+        evidencePath,
+        findingIds: [finding.id],
+        description: `Exclude ${evidencePath} from ${options.label} via ${options.targetRelativePath}`,
+    });
+}
+/** Patterns that would be newly appended given current ignore-file contents. */
+export function missingPatternsForIgnoreFile(currentContent, patterns) {
     const existing = currentContent === null ? [] : parseIgnoreFile(currentContent);
     const missing = [];
     for (const pattern of patterns) {
@@ -245,3 +347,5 @@ export function missingPatternsForCursorignore(currentContent, patterns) {
     }
     return missing;
 }
+/** @deprecated Prefer missingPatternsForIgnoreFile */
+export const missingPatternsForCursorignore = missingPatternsForIgnoreFile;

package/dist/core/fix/render.d.ts

@@ -4,5 +4,7 @@ export declare function renderFixPlanTerminal(plan: FixPlan, options: {
     cursorContent: string | null;
     claudeSettingsContent?: string | null;
     codexConfigContent?: string | null;
+    geminiignoreContent?: string | null;
+    aiderignoreContent?: string | null;
     applyResult?: FixApplyResult;
 }): string;

package/dist/core/fix/render.js

@@ -1,6 +1,7 @@
 import { previewClaudeSettingsActions } from "./writers/claude-settings.js";
 import { previewCodexConfigActions } from "./writers/codex-config.js";
 import { previewCursorignoreActions } from "./writers/cursorignore.js";
+import { previewSimpleIgnoreActions } from "./writers/simple-ignore.js";
 export function renderFixPlanTerminal(plan, options) {
     const lines = [];
     lines.push("");
@@ -39,41 +40,55 @@ export function renderFixPlanTerminal(plan, options) {
     const cursorPreview = previewCursorignoreActions(options.cursorContent, plan.actions);
     const claudePreview = previewClaudeSettingsActions(options.claudeSettingsContent ?? null, plan.actions);
     const codexPreview = previewCodexConfigActions(options.codexConfigContent ?? null, plan.actions);
-    if (cursorPreview || claudePreview || codexPreview) {
+    const geminiPreview = previewSimpleIgnoreActions(options.geminiignoreContent ?? null, plan.actions, { agent: "gemini-cli", targetRelativePath: ".geminiignore" });
+    const aiderPreview = previewSimpleIgnoreActions(options.aiderignoreContent ?? null, plan.actions, { agent: "aider", targetRelativePath: ".aiderignore" });
+    const previews = [
+        cursorPreview,
+        claudePreview,
+        codexPreview,
+        geminiPreview,
+        aiderPreview,
+    ].filter((p) => p !== null);
+    if (previews.length > 0) {
         lines.push("");
         lines.push("  File changes:");
         let shown = false;
-        if (cursorPreview) {
-            lines.push(`    ${cursorPreview.targetRelativePath} (+${cursorPreview.patternsToAdd.length} pattern(s))`);
-            lines.push("");
-            for (const previewLine of cursorPreview.preview.split("\n")) {
-                lines.push(`  ${previewLine}`);
-            }
-            shown = true;
-        }
-        if (claudePreview) {
+        for (const preview of previews) {
             if (shown) {
                 lines.push("");
             }
-            lines.push(`    ${claudePreview.targetRelativePath} (+${claudePreview.denyRulesToAdd.length} deny rule(s))`);
+            const count = preview.patternsToAdd?.length ??
+                preview.denyRulesToAdd?.length ??
+                preview.denyKeysToAdd?.length ??
+                0;
+            const unit = preview.patternsToAdd
+                ? "pattern(s)"
+                : preview.denyRulesToAdd
+                    ? "deny rule(s)"
+                    : "deny key(s)";
+            lines.push(`    ${preview.targetRelativePath} (+${count} ${unit})`);
             lines.push("");
-            for (const previewLine of claudePreview.preview.split("\n")) {
+            for (const previewLine of preview.preview.split("\n")) {
                 lines.push(`  ${previewLine}`);
             }
             shown = true;
         }
-        if (codexPreview) {
-            if (shown) {
-                lines.push("");
-            }
-            lines.push(`    ${codexPreview.targetRelativePath} (+${codexPreview.denyKeysToAdd.length} deny key(s))`);
-            lines.push("");
-            for (const previewLine of codexPreview.preview.split("\n")) {
-                lines.push(`  ${previewLine}`);
+    }
+    if (options.applyResult?.error) {
+        lines.push("");
+        if (options.applyResult.partial) {
+            lines.push(`  Partial apply: wrote ${options.applyResult.writtenFiles.join(", ") || "(none)"} then failed on ${options.applyResult.failedTarget ?? "unknown target"}`);
+            lines.push(`  Error: ${options.applyResult.error}`);
+            lines.push("  Safe Fix is not transactional across multiple files — review written paths manually.");
+        }
+        else {
+            lines.push(`  Fix aborted before/during write: ${options.applyResult.error}`);
+            if (options.applyResult.failedTarget) {
+                lines.push(`  Target: ${options.applyResult.failedTarget}`);
             }
         }
     }
-    if (options.applyResult && !options.dryRun) {
+    else if (options.applyResult && !options.dryRun) {
         lines.push("");
         if (options.applyResult.writtenFiles.length > 0) {
             lines.push(`  Wrote: ${options.applyResult.writtenFiles.join(", ")}`);

package/dist/core/fix/run.js

@@ -1,7 +1,7 @@
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { scan } from "../scanner/scan.js";
-import { applyFixPlan, readClaudeSettings, readCodexConfig, readCursorignore } from "./apply.js";
+import { applyFixPlan, readClaudeSettings, readCodexConfig, readCursorignore, readSimpleIgnore, } from "./apply.js";
 import { buildFixPlan } from "./plan.js";
 import { renderFixPlanTerminal } from "./render.js";
 /**
@@ -13,6 +13,8 @@ export async function runFix(options) {
     const cursorContent = await readCursorignore(plan.root);
     const claudeSettingsContent = await readClaudeSettings(plan.root);
     const codexConfigContent = await readCodexConfig(plan.root);
+    const geminiignoreContent = await readSimpleIgnore(plan.root, ".geminiignore");
+    const aiderignoreContent = await readSimpleIgnore(plan.root, ".aiderignore");
     if (plan.actions.length === 0 || options.dryRun) {
         const applyResult = await applyFixPlan(plan, { dryRun: true });
         return { plan, applyResult, cancelled: false };
@@ -23,6 +25,8 @@ export async function runFix(options) {
             cursorContent,
             claudeSettingsContent,
             codexConfigContent,
+            geminiignoreContent,
+            aiderignoreContent,
         });
         process.stdout.write(previewText);
         const confirmed = await confirm("Apply these changes?");

package/dist/core/fix/safe-target.d.ts

@@ -0,0 +1,14 @@
+import { type FixAllowlistedPath } from "./types.js";
+/**
+ * Resolve an allowlisted Fix target and refuse symlink write-through /
+ * path-escape before any Safe Fix writer mutates the filesystem.
+ */
+export declare function resolveSafeFixWritePath(root: string, relativePath: string): Promise<{
+    absolutePath: string;
+    relativePath: FixAllowlistedPath;
+}>;
+/**
+ * Preflight every planned Fix target before any writer mutates the repo.
+ * Fails fast if any target is unsafe; does not create files.
+ */
+export declare function preflightSafeFixTargets(root: string, relativePaths: readonly string[]): Promise<FixAllowlistedPath[]>;

package/dist/core/fix/safe-target.js

@@ -0,0 +1,81 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { FIX_PATH_ALLOWLIST } from "./types.js";
+/**
+ * Resolve an allowlisted Fix target and refuse symlink write-through /
+ * path-escape before any Safe Fix writer mutates the filesystem.
+ */
+export async function resolveSafeFixWritePath(root, relativePath) {
+    if (!FIX_PATH_ALLOWLIST.includes(relativePath)) {
+        throw new Error(`Fix target is not allowlisted: ${relativePath}`);
+    }
+    const allowlisted = relativePath;
+    if (path.isAbsolute(allowlisted) || allowlisted.split(/[/\\]/).includes("..")) {
+        throw new Error(`Fix target path is invalid: ${allowlisted}`);
+    }
+    const rootReal = await fs.realpath(root);
+    const absolutePath = path.resolve(rootReal, allowlisted);
+    const relativeToRoot = path.relative(rootReal, absolutePath);
+    if (relativeToRoot.startsWith("..") ||
+        path.isAbsolute(relativeToRoot) ||
+        relativeToRoot.includes(`..${path.sep}`)) {
+        throw new Error(`Fix target escapes repository root: ${allowlisted}`);
+    }
+    await assertNoSymlinkAncestors(rootReal, absolutePath, allowlisted);
+    try {
+        const stat = await fs.lstat(absolutePath);
+        if (stat.isSymbolicLink()) {
+            throw new Error(`refusing to write through symlink Fix target: ${allowlisted} (replace the symlink with a regular file first)`);
+        }
+        if (stat.isDirectory()) {
+            throw new Error(`refusing Fix target that is a directory: ${allowlisted} (expected a regular file)`);
+        }
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error
+            ? String(error.code)
+            : "";
+        if (code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return { absolutePath, relativePath: allowlisted };
+}
+/**
+ * Preflight every planned Fix target before any writer mutates the repo.
+ * Fails fast if any target is unsafe; does not create files.
+ */
+export async function preflightSafeFixTargets(root, relativePaths) {
+    const unique = [...new Set(relativePaths)];
+    const resolved = [];
+    for (const relativePath of unique) {
+        const { relativePath: allowlisted } = await resolveSafeFixWritePath(root, relativePath);
+        resolved.push(allowlisted);
+    }
+    return resolved;
+}
+async function assertNoSymlinkAncestors(rootReal, absolutePath, label) {
+    let current = path.dirname(absolutePath);
+    while (current.startsWith(rootReal) && current !== rootReal) {
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new Error(`refusing Fix target under symlink directory: ${label} (ancestor ${path.relative(rootReal, current)} is a symlink)`);
+            }
+        }
+        catch (error) {
+            const code = error && typeof error === "object" && "code" in error
+                ? String(error.code)
+                : "";
+            if (code === "ENOENT") {
+                break;
+            }
+            throw error;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+}

package/dist/core/fix/types.d.ts

@@ -1,7 +1,7 @@
 import type { AgentId } from "../../types/index.js";
 export type FixKind = "append-ignore-pattern";
 /** Allowlisted relative paths fix may create or modify. */
-export declare const FIX_PATH_ALLOWLIST: readonly [".cursorignore", ".claude/settings.json", ".codex/config.toml"];
+export declare const FIX_PATH_ALLOWLIST: readonly [".cursorignore", ".claude/settings.json", ".codex/config.toml", ".geminiignore", ".aiderignore"];
 export type FixAllowlistedPath = (typeof FIX_PATH_ALLOWLIST)[number];
 export interface FixAction {
     id: string;
@@ -31,4 +31,15 @@ export interface FixApplyResult {
     writtenFiles: string[];
     /** Relative paths that would be / were written */
     changedFiles: string[];
+    /**
+     * Present when apply stopped after one or more successful writes.
+     * Safe Fix is not transactional across multiple targets.
+     */
+    partial?: boolean;
+    /** Relative path that failed when `partial` is true, or preflight failed. */
+    failedTarget?: string;
+    /** Human-readable failure reason. */
+    error?: string;
+    /** Audit / backup id created before apply (when writes were attempted). */
+    auditId?: string;
 }

package/dist/core/fix/types.js

@@ -3,4 +3,6 @@ export const FIX_PATH_ALLOWLIST = [
     ".cursorignore",
     ".claude/settings.json",
     ".codex/config.toml",
+    ".geminiignore",
+    ".aiderignore",
 ];

package/dist/core/fix/writers/claude-settings.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { atomicWriteTextFile, readTextFile } from "../../../utils/fs.js";
 import { claudeReadDenyRule } from "../../rules/claude-deny.js";
+import { resolveSafeFixWritePath } from "../safe-target.js";
 const MAX_BYTES = 512 * 1024;
 const SETTINGS_RELATIVE = ".claude/settings.json";
 export function denyRuleForFixPattern(pattern, evidencePath) {
@@ -70,7 +71,8 @@ export async function readClaudeSettings(root) {
     return readTextFile(path.join(root, SETTINGS_RELATIVE), MAX_BYTES);
 }
 export async function writeClaudeSettings(root, content) {
-    await atomicWriteTextFile(path.join(root, SETTINGS_RELATIVE), content);
+    const { absolutePath } = await resolveSafeFixWritePath(root, SETTINGS_RELATIVE);
+    await atomicWriteTextFile(absolutePath, content);
 }
 function parseDenyList(currentContent) {
     if (!currentContent || currentContent.trim().length === 0) {

package/dist/core/fix/writers/codex-config.d.ts

@@ -19,4 +19,7 @@ export declare function previewCodexConfigActions(currentContent: string | null,
 export declare function readCodexConfig(root: string): Promise<string | null>;
 export declare function writeCodexConfig(root: string, content: string): Promise<void>;
 export declare function assertWritableCodexConfig(content: string): void;
+/** Escape a filesystem deny key for a TOML basic string assignment. */
+export declare function formatTomlDenyAssignment(key: string): string;
+export declare function assertSafeCodexDenyKey(key: string): void;
 export {};

package/dist/core/fix/writers/codex-config.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { atomicWriteTextFile, readTextFile } from "../../../utils/fs.js";
 import { codexDenyKey, configTextDeniesPath } from "../../rules/codex-deny.js";
+import { resolveSafeFixWritePath } from "../safe-target.js";
 const MAX_BYTES = 512 * 1024;
 const CONFIG_RELATIVE = ".codex/config.toml";
 const AGENTDOCTOR_PROFILE = "agentdoctor_context";
@@ -55,7 +56,7 @@ export function buildCodexConfigContent(currentContent, denyKeysToAdd) {
             next += `"." = "write"\n`;
         }
         for (const key of denyKeysToAdd) {
-            next += `"${key}" = "deny"\n`;
+            next += `${formatTomlDenyAssignment(key)}\n`;
         }
         if (!next.includes(END_MARKER)) {
             next += `${END_MARKER}\n`;
@@ -68,7 +69,7 @@ export function buildCodexConfigContent(currentContent, denyKeysToAdd) {
         if (configTextDeniesPath(body, key) || configTextDeniesPath(next, key)) {
             continue;
         }
-        linesToInsert.push(`"${key}" = "deny"`);
+        linesToInsert.push(formatTomlDenyAssignment(key).trimEnd());
     }
     if (linesToInsert.length === 0) {
         return next;
@@ -105,7 +106,8 @@ export async function readCodexConfig(root) {
     return readTextFile(path.join(root, CONFIG_RELATIVE), MAX_BYTES);
 }
 export async function writeCodexConfig(root, content) {
-    await atomicWriteTextFile(path.join(root, CONFIG_RELATIVE), content);
+    const { absolutePath } = await resolveSafeFixWritePath(root, CONFIG_RELATIVE);
+    await atomicWriteTextFile(absolutePath, content);
 }
 export function assertWritableCodexConfig(content) {
     if (/^\s*sandbox_mode\s*=/m.test(content)) {
@@ -171,6 +173,25 @@ function ensureTrailingNewline(value) {
     }
     return `${value}\n`;
 }
+/** Escape a filesystem deny key for a TOML basic string assignment. */
+export function formatTomlDenyAssignment(key) {
+    assertSafeCodexDenyKey(key);
+    return `"${escapeTomlBasicString(key)}" = "deny"`;
+}
+export function assertSafeCodexDenyKey(key) {
+    if (key.length === 0) {
+        throw new Error("refusing empty Codex deny key");
+    }
+    for (let i = 0; i < key.length; i++) {
+        const code = key.charCodeAt(i);
+        if (code < 32) {
+            throw new Error("refusing Codex deny key with control characters");
+        }
+    }
+}
+function escapeTomlBasicString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
 function formatSimpleDiff(fileLabel, before, after) {
     const lines = [];
     lines.push(`--- a/${fileLabel}`);

package/dist/core/fix/writers/cursorignore.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { atomicWriteTextFile, readTextFile } from "../../../utils/fs.js";
+import { resolveSafeFixWritePath } from "../safe-target.js";
 import { missingPatternsForCursorignore } from "../plan.js";
 const MAX_BYTES = 512 * 1024;
 const BANNER = "# Added by AgentDoctor";
@@ -40,7 +41,8 @@ export async function readCursorignore(root) {
     return readTextFile(path.join(root, ".cursorignore"), MAX_BYTES);
 }
 export async function writeCursorignore(root, content) {
-    await atomicWriteTextFile(path.join(root, ".cursorignore"), content);
+    const { absolutePath } = await resolveSafeFixWritePath(root, ".cursorignore");
+    await atomicWriteTextFile(absolutePath, content);
 }
 function formatSimpleDiff(fileLabel, before, after) {
     const beforeLines = before.length === 0 ? [] : before.split(/\r?\n/);

package/dist/core/fix/writers/simple-ignore.d.ts

@@ -0,0 +1,16 @@
+import type { AgentId } from "../../../types/index.js";
+import type { FixAction, FixAllowlistedPath } from "../types.js";
+export interface SimpleIgnoreWritePreview {
+    targetRelativePath: FixAllowlistedPath;
+    patternsToAdd: string[];
+    before: string;
+    after: string;
+    preview: string;
+}
+export declare function buildSimpleIgnoreContent(currentContent: string | null, patternsToAdd: string[]): string;
+export declare function previewSimpleIgnoreActions(currentContent: string | null, actions: FixAction[], options: {
+    agent: AgentId;
+    targetRelativePath: FixAllowlistedPath;
+}): SimpleIgnoreWritePreview | null;
+export declare function readSimpleIgnore(root: string, relativePath: string): Promise<string | null>;
+export declare function writeSimpleIgnore(root: string, relativePath: string, content: string): Promise<void>;

package/dist/core/fix/writers/simple-ignore.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { atomicWriteTextFile, readTextFile } from "../../../utils/fs.js";
+import { missingPatternsForIgnoreFile } from "../plan.js";
+import { resolveSafeFixWritePath } from "../safe-target.js";
+const MAX_BYTES = 512 * 1024;
+const BANNER = "# Added by AgentDoctor";
+export function buildSimpleIgnoreContent(currentContent, patternsToAdd) {
+    if (patternsToAdd.length === 0) {
+        return currentContent ?? "";
+    }
+    const base = currentContent ?? "";
+    const trimmed = base.replace(/\s+$/, "");
+    const block = [BANNER, ...patternsToAdd].join("\n");
+    if (trimmed.length === 0) {
+        return `${block}\n`;
+    }
+    return `${trimmed}\n\n${block}\n`;
+}
+export function previewSimpleIgnoreActions(currentContent, actions, options) {
+    const matched = actions.filter((a) => a.agent === options.agent && a.targetRelativePath === options.targetRelativePath);
+    if (matched.length === 0) {
+        return null;
+    }
+    const requested = [...new Set(matched.map((a) => a.pattern))];
+    const patternsToAdd = missingPatternsForIgnoreFile(currentContent, requested);
+    if (patternsToAdd.length === 0) {
+        return null;
+    }
+    const before = currentContent ?? "";
+    const after = buildSimpleIgnoreContent(currentContent, patternsToAdd);
+    const preview = formatSimpleDiff(options.targetRelativePath, before, after);
+    return {
+        targetRelativePath: options.targetRelativePath,
+        patternsToAdd,
+        before,
+        after,
+        preview,
+    };
+}
+export async function readSimpleIgnore(root, relativePath) {
+    return readTextFile(path.join(root, relativePath), MAX_BYTES);
+}
+export async function writeSimpleIgnore(root, relativePath, content) {
+    const { absolutePath } = await resolveSafeFixWritePath(root, relativePath);
+    await atomicWriteTextFile(absolutePath, content);
+}
+function formatSimpleDiff(fileLabel, before, after) {
+    const beforeLines = before.length === 0 ? [] : before.split(/\r?\n/);
+    const afterLines = after.split(/\r?\n/);
+    const lines = [];
+    lines.push(`--- a/${fileLabel}`);
+    lines.push(`+++ b/${fileLabel}`);
+    const addedStart = beforeLines.length === 0 ? 0 : beforeLines.length;
+    for (let i = addedStart; i < afterLines.length; i++) {
+        const line = afterLines[i];
+        if (line === undefined) {
+            continue;
+        }
+        lines.push(`+${line}`);
+    }
+    if (before.length === 0) {
+        lines.splice(2, 0, "@@ new file @@");
+    }
+    else {
+        lines.splice(2, 0, "@@ append @@");
+    }
+    return lines.join("\n");
+}

package/dist/core/monorepo/detect.d.ts

@@ -0,0 +1,13 @@
+export interface WorkspacePackage {
+    name: string;
+    relativePath: string;
+    absolutePath: string;
+}
+export interface MonorepoDetection {
+    root: string;
+    isMonorepo: boolean;
+    tool: "npm-workspaces" | "pnpm-workspaces" | "none";
+    packages: WorkspacePackage[];
+    limitations: string[];
+}
+export declare function detectMonorepo(rootInput: string): Promise<MonorepoDetection>;