@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/core/context-health/analyze.js

@@ -0,0 +1,234 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveRepoRoot, toPosixRelative } from "../../utils/path.js";
+const INSTRUCTION_CANDIDATES = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "GEMINI.md",
+    "CONVENTIONS.md",
+    ".cursorrules",
+    ".windsurfrules",
+    ".github/copilot-instructions.md",
+];
+const IGNORE_CANDIDATES = [
+    ".cursorignore",
+    ".claudeignore",
+    ".codexignore",
+    ".geminiignore",
+    ".aiderignore",
+];
+const OVERSIZE_BYTES = 100_000;
+const PATH_REF = /(?:^|[\s`"'(])((?:\.\.?\/|[A-Za-z0-9_.-]+\/)[A-Za-z0-9_./-]+\.[A-Za-z0-9]+)(?=[\s`"'')]|$)/gm;
+const AMBIGUOUS = /\b(TODO|FIXME|TBD|XXX)\b/g;
+const YEAR_REF = /\b(20[0-1][0-9]|202[0-3])\b/g;
+async function existsFile(root, rel) {
+    try {
+        const st = await fs.lstat(path.join(root, rel));
+        return st.isFile() || st.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+async function readText(root, rel) {
+    try {
+        return await fs.readFile(path.join(root, rel), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+async function fileSize(root, rel) {
+    try {
+        const st = await fs.stat(path.join(root, rel));
+        return st.size;
+    }
+    catch {
+        return 0;
+    }
+}
+function hasContradictoryTone(a, b) {
+    const always = /\balways\b/i;
+    const never = /\bnever\b/i;
+    return (always.test(a) && never.test(b)) || (never.test(a) && always.test(b));
+}
+function extractTerms(text) {
+    const terms = new Set();
+    for (const m of text.matchAll(/\b(repo|repository|codebase|project|workspace)\b/gi)) {
+        terms.add(m[1].toLowerCase());
+    }
+    return terms;
+}
+export async function analyzeContextHealth(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const instructionFiles = [];
+    const ignoreFiles = [];
+    const conflicts = [];
+    for (const rel of INSTRUCTION_CANDIDATES) {
+        if (await existsFile(root, rel)) {
+            instructionFiles.push(rel);
+        }
+    }
+    try {
+        const instructionsDir = path.join(root, ".github", "instructions");
+        const entries = await fs.readdir(instructionsDir);
+        for (const entry of entries) {
+            if (entry.endsWith(".md")) {
+                instructionFiles.push(toPosixRelative(root, path.join(instructionsDir, entry)));
+            }
+        }
+    }
+    catch {
+        // optional
+    }
+    for (const rel of IGNORE_CANDIDATES) {
+        if (await existsFile(root, rel)) {
+            ignoreFiles.push(rel);
+        }
+    }
+    if (instructionFiles.length >= 2) {
+        conflicts.push({
+            kind: "duplicate-instruction-surface",
+            severity: "info",
+            files: [...instructionFiles],
+            message: "Multiple agent instruction surfaces detected; prefer one primary source of truth per agent.",
+            confidence: "high",
+        });
+    }
+    const currentYear = new Date().getUTCFullYear();
+    const termUnion = new Set();
+    const termByFile = new Map();
+    for (const rel of instructionFiles) {
+        const text = await readText(root, rel);
+        if (text.trim().length === 0) {
+            conflicts.push({
+                kind: "empty-instruction-file",
+                severity: "warning",
+                files: [rel],
+                message: `Instruction file is empty: ${rel}`,
+                confidence: "high",
+            });
+            continue;
+        }
+        const size = await fileSize(root, rel);
+        if (size > OVERSIZE_BYTES) {
+            conflicts.push({
+                kind: "oversized-instruction-file",
+                severity: "warning",
+                files: [rel],
+                message: `Instruction file exceeds ${OVERSIZE_BYTES} bytes (${size}): ${rel}`,
+                confidence: "high",
+            });
+        }
+        AMBIGUOUS.lastIndex = 0;
+        const ambiguousHits = text.match(AMBIGUOUS);
+        if (ambiguousHits && ambiguousHits.length > 0) {
+            conflicts.push({
+                kind: "ambiguous-marker",
+                severity: "info",
+                files: [rel],
+                message: `Ambiguous markers (${[...new Set(ambiguousHits)].join(", ")}) in ${rel}`,
+                confidence: "medium",
+            });
+        }
+        YEAR_REF.lastIndex = 0;
+        for (const m of text.matchAll(YEAR_REF)) {
+            const year = Number(m[1]);
+            if (Number.isFinite(year) && year < currentYear - 1) {
+                conflicts.push({
+                    kind: "outdated-year-reference",
+                    severity: "info",
+                    files: [rel],
+                    message: `Possibly outdated year reference ${year} in ${rel}`,
+                    confidence: "low",
+                });
+                break;
+            }
+        }
+        PATH_REF.lastIndex = 0;
+        const seenRefs = new Set();
+        for (const m of text.matchAll(PATH_REF)) {
+            const ref = (m[1] ?? "").replace(/^\.\//, "");
+            if (!ref || seenRefs.has(ref) || ref.includes("http"))
+                continue;
+            seenRefs.add(ref);
+            if (ref.startsWith("node_modules/"))
+                continue;
+            const exists = await existsFile(root, ref);
+            if (!exists) {
+                conflicts.push({
+                    kind: "invalid-path-reference",
+                    severity: "warning",
+                    files: [rel],
+                    message: `Referenced path not found: ${ref} (from ${rel})`,
+                    confidence: "medium",
+                });
+            }
+        }
+        const terms = extractTerms(text);
+        termByFile.set(rel, terms);
+        for (const t of terms)
+            termUnion.add(t);
+    }
+    if (termUnion.has("repo") && termUnion.has("repository") && termByFile.size >= 2) {
+        const filesUsing = [];
+        for (const [file, terms] of termByFile) {
+            if (terms.has("repo") || terms.has("repository"))
+                filesUsing.push(file);
+        }
+        if (filesUsing.length >= 2) {
+            conflicts.push({
+                kind: "terminology-inconsistency",
+                severity: "info",
+                files: filesUsing.sort(),
+                message: 'Mixed terminology "repo" vs "repository" across instruction files',
+                confidence: "low",
+            });
+        }
+    }
+    for (let i = 0; i < instructionFiles.length; i += 1) {
+        for (let j = i + 1; j < instructionFiles.length; j += 1) {
+            const a = instructionFiles[i];
+            const b = instructionFiles[j];
+            const textA = await readText(root, a);
+            const textB = await readText(root, b);
+            if (hasContradictoryTone(textA, textB)) {
+                conflicts.push({
+                    kind: "contradictory-tone",
+                    severity: "warning",
+                    files: [a, b],
+                    message: `Potential always/never contradiction between ${a} and ${b}`,
+                    confidence: "medium",
+                });
+            }
+        }
+    }
+    if (ignoreFiles.length >= 2) {
+        conflicts.push({
+            kind: "overlapping-ignore",
+            severity: "info",
+            files: [...ignoreFiles],
+            message: "Multiple ignore surfaces present; keep patterns aligned across agents.",
+            confidence: "high",
+        });
+    }
+    // Empty ignore files are unused-candidate signals
+    for (const rel of ignoreFiles) {
+        const text = await readText(root, rel);
+        if (text.trim().length === 0) {
+            conflicts.push({
+                kind: "unused-ignore-candidate",
+                severity: "info",
+                files: [rel],
+                message: `Ignore file exists but is empty: ${rel}`,
+                confidence: "medium",
+            });
+        }
+    }
+    return {
+        root,
+        conflicts,
+        instructionFiles: instructionFiles.sort(),
+        ignoreFiles: ignoreFiles.sort(),
+    };
+}

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

@@ -2,13 +2,30 @@ import type { FixApplyResult, FixPlan } from "./types.js";
 import { previewClaudeSettingsActions, readClaudeSettings } from "./writers/claude-settings.js";
 import { previewCodexConfigActions, readCodexConfig } from "./writers/codex-config.js";
 import { previewCursorignoreActions, readCursorignore } from "./writers/cursorignore.js";
+import { previewSimpleIgnoreActions, readSimpleIgnore } from "./writers/simple-ignore.js";
+/** Supported options for Safe Fix apply / dry-run. */
+export interface ApplyFixPlanOptions {
+    dryRun: boolean;
+}
+/**
+ * Internal test-only options. Not a CLI feature and not part of the supported
+ * public consumer API — use only from unit tests.
+ */
+export interface ApplyFixPlanInternalOptions extends ApplyFixPlanOptions {
+    /** Inject a failure after earlier writers succeed (partial-apply tests). */
+    simulateWriteFailureAt?: string;
+}
 /**
  * Apply (or dry-run) a fix plan.
- * Safe writers: `.cursorignore`, Claude settings deny, Codex config.toml deny.
+ * Safe writers: `.cursorignore`, Claude settings deny, Codex config.toml deny,
+ * `.geminiignore`, `.aiderignore`.
+ *
+ * All planned targets are preflighted before any write. Writes still run
+ * sequentially; if a later write fails, earlier files may already be updated
+ * (`partial: true` on the result).
  */
-export declare function applyFixPlan(plan: FixPlan, options: {
-    dryRun: boolean;
-}): Promise<FixApplyResult>;
+export declare function applyFixPlan(plan: FixPlan, options: ApplyFixPlanOptions | ApplyFixPlanInternalOptions): Promise<FixApplyResult>;
 export { previewCursorignoreActions, readCursorignore };
 export { previewClaudeSettingsActions, readClaudeSettings };
 export { previewCodexConfigActions, readCodexConfig };
+export { previewSimpleIgnoreActions, readSimpleIgnore };

package/dist/core/fix/apply.js

@@ -1,47 +1,147 @@
+import { assertTargetsUnchangedSinceBackup, createFixBackup } from "./backup.js";
+import { preflightSafeFixTargets } from "./safe-target.js";
 import { previewClaudeSettingsActions, readClaudeSettings, writeClaudeSettings, } from "./writers/claude-settings.js";
 import { previewCodexConfigActions, readCodexConfig, writeCodexConfig, } from "./writers/codex-config.js";
 import { previewCursorignoreActions, readCursorignore, writeCursorignore, } from "./writers/cursorignore.js";
+import { previewSimpleIgnoreActions, readSimpleIgnore, writeSimpleIgnore, } from "./writers/simple-ignore.js";
 /**
  * Apply (or dry-run) a fix plan.
- * Safe writers: `.cursorignore`, Claude settings deny, Codex config.toml deny.
+ * Safe writers: `.cursorignore`, Claude settings deny, Codex config.toml deny,
+ * `.geminiignore`, `.aiderignore`.
+ *
+ * All planned targets are preflighted before any write. Writes still run
+ * sequentially; if a later write fails, earlier files may already be updated
+ * (`partial: true` on the result).
  */
 export async function applyFixPlan(plan, options) {
+    const simulateWriteFailureAt = "simulateWriteFailureAt" in options ? options.simulateWriteFailureAt : undefined;
     const cursorContent = await readCursorignore(plan.root);
     const claudeContent = await readClaudeSettings(plan.root);
     const codexContent = await readCodexConfig(plan.root);
+    const geminiContent = await readSimpleIgnore(plan.root, ".geminiignore");
+    const aiderContent = await readSimpleIgnore(plan.root, ".aiderignore");
     const cursorPreview = previewCursorignoreActions(cursorContent, plan.actions);
     const claudePreview = previewClaudeSettingsActions(claudeContent, plan.actions);
     const codexPreview = previewCodexConfigActions(codexContent, plan.actions);
-    const writtenFiles = [];
-    const changedFiles = [];
+    const geminiPreview = previewSimpleIgnoreActions(geminiContent, plan.actions, {
+        agent: "gemini-cli",
+        targetRelativePath: ".geminiignore",
+    });
+    const aiderPreview = previewSimpleIgnoreActions(aiderContent, plan.actions, {
+        agent: "aider",
+        targetRelativePath: ".aiderignore",
+    });
+    const steps = [];
     if (cursorPreview) {
-        changedFiles.push(cursorPreview.targetRelativePath);
-        if (!options.dryRun) {
-            await writeCursorignore(plan.root, cursorPreview.after);
-            writtenFiles.push(cursorPreview.targetRelativePath);
-        }
+        steps.push({
+            targetRelativePath: cursorPreview.targetRelativePath,
+            write: async () => writeCursorignore(plan.root, cursorPreview.after),
+        });
     }
     if (claudePreview) {
-        changedFiles.push(claudePreview.targetRelativePath);
-        if (!options.dryRun) {
-            await writeClaudeSettings(plan.root, claudePreview.after);
-            writtenFiles.push(claudePreview.targetRelativePath);
-        }
+        steps.push({
+            targetRelativePath: claudePreview.targetRelativePath,
+            write: async () => writeClaudeSettings(plan.root, claudePreview.after),
+        });
     }
     if (codexPreview) {
-        changedFiles.push(codexPreview.targetRelativePath);
-        if (!options.dryRun) {
-            await writeCodexConfig(plan.root, codexPreview.after);
-            writtenFiles.push(codexPreview.targetRelativePath);
+        steps.push({
+            targetRelativePath: codexPreview.targetRelativePath,
+            write: async () => writeCodexConfig(plan.root, codexPreview.after),
+        });
+    }
+    if (geminiPreview) {
+        steps.push({
+            targetRelativePath: geminiPreview.targetRelativePath,
+            write: async () => writeSimpleIgnore(plan.root, ".geminiignore", geminiPreview.after),
+        });
+    }
+    if (aiderPreview) {
+        steps.push({
+            targetRelativePath: aiderPreview.targetRelativePath,
+            write: async () => writeSimpleIgnore(plan.root, ".aiderignore", aiderPreview.after),
+        });
+    }
+    const changedFiles = steps.map((s) => s.targetRelativePath);
+    try {
+        await preflightSafeFixTargets(plan.root, steps.map((s) => s.targetRelativePath));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            plan,
+            dryRun: options.dryRun,
+            writtenFiles: [],
+            changedFiles,
+            partial: false,
+            ...(steps[0]?.targetRelativePath ? { failedTarget: steps[0].targetRelativePath } : {}),
+            error: message,
+        };
+    }
+    if (options.dryRun) {
+        return {
+            plan,
+            dryRun: true,
+            writtenFiles: [],
+            changedFiles,
+        };
+    }
+    let auditId;
+    let backupRecord;
+    try {
+        backupRecord = await createFixBackup({
+            root: plan.root,
+            relativePaths: steps.map((s) => s.targetRelativePath),
+            note: "safe-fix-apply",
+        });
+        auditId = backupRecord.id;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            plan,
+            dryRun: false,
+            writtenFiles: [],
+            changedFiles,
+            partial: false,
+            error: `backup failed before apply: ${message}`,
+        };
+    }
+    const writtenFiles = [];
+    for (const step of steps) {
+        try {
+            if (backupRecord) {
+                await assertTargetsUnchangedSinceBackup(plan.root, backupRecord, [step.targetRelativePath]);
+            }
+            if (simulateWriteFailureAt && simulateWriteFailureAt === step.targetRelativePath) {
+                throw new Error("simulated later writer failure");
+            }
+            await step.write();
+            writtenFiles.push(step.targetRelativePath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                plan,
+                dryRun: false,
+                writtenFiles,
+                changedFiles,
+                partial: writtenFiles.length > 0,
+                failedTarget: step.targetRelativePath,
+                error: message,
+                ...(auditId ? { auditId } : {}),
+            };
         }
     }
     return {
         plan,
-        dryRun: options.dryRun,
+        dryRun: false,
         writtenFiles,
         changedFiles,
+        ...(auditId ? { auditId } : {}),
     };
 }
 export { previewCursorignoreActions, readCursorignore };
 export { previewClaudeSettingsActions, readClaudeSettings };
 export { previewCodexConfigActions, readCodexConfig };
+export { previewSimpleIgnoreActions, readSimpleIgnore };

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

@@ -0,0 +1,30 @@
+export interface FixBackupEntry {
+    relativePath: string;
+    existed: boolean;
+    backupRelativePath: string | null;
+    sha256Before: string | null;
+    mtimeMsBefore: number | null;
+}
+export interface FixAuditRecord {
+    id: string;
+    createdAt: string;
+    root: string;
+    mode: "apply" | "undo";
+    entries: FixBackupEntry[];
+    note?: string;
+}
+export declare function createFixBackup(options: {
+    root: string;
+    relativePaths: string[];
+    note?: string;
+}): Promise<FixAuditRecord>;
+export declare function listFixAudits(rootInput: string): Promise<FixAuditRecord[]>;
+export declare function undoFix(options: {
+    root: string;
+    auditId: string;
+}): Promise<FixAuditRecord>;
+/**
+ * Ensure a target still matches the backup snapshot (detect concurrent modification).
+ * For files that did not exist at backup time, refuses if the path now exists.
+ */
+export declare function assertTargetsUnchangedSinceBackup(rootInput: string, audit: FixAuditRecord, relativePaths: string[]): Promise<void>;

package/dist/core/fix/backup.js

@@ -0,0 +1,193 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { atomicWriteTextFile } from "../../utils/fs.js";
+import { isPathInsideRoot, resolveRepoRoot } from "../../utils/path.js";
+function resolveSafePath(root, relativePath) {
+    const absolute = path.resolve(root, relativePath);
+    if (!isPathInsideRoot(root, absolute)) {
+        throw new Error(`path escapes repository root: ${relativePath}`);
+    }
+    return absolute;
+}
+function auditDir(root) {
+    return path.join(root, ".agentdoctor", "fix-audit");
+}
+function backupsDir(root, auditId) {
+    return path.join(auditDir(root), auditId, "backups");
+}
+async function sha256File(absolute) {
+    try {
+        const buf = await fs.readFile(absolute);
+        return createHash("sha256").update(buf).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+export async function createFixBackup(options) {
+    const root = resolveRepoRoot(options.root);
+    const id = randomUUID();
+    const createdAt = new Date().toISOString();
+    const backupRoot = backupsDir(root, id);
+    await fs.mkdir(backupRoot, { recursive: true });
+    const entries = [];
+    for (const rel of options.relativePaths) {
+        const absolute = resolveSafePath(root, rel);
+        let existed = false;
+        let backupRelativePath = null;
+        let sha = null;
+        let mtimeMsBefore = null;
+        try {
+            const st = await fs.lstat(absolute);
+            if (st.isSymbolicLink()) {
+                throw new Error(`refusing to backup symlink: ${rel}`);
+            }
+            if (st.isDirectory()) {
+                throw new Error(`refusing to backup directory: ${rel}`);
+            }
+            existed = true;
+            mtimeMsBefore = st.mtimeMs;
+            sha = await sha256File(absolute);
+            const dest = path.join(backupRoot, rel);
+            await fs.mkdir(path.dirname(dest), { recursive: true });
+            await fs.copyFile(absolute, dest);
+            backupRelativePath = path.relative(root, dest).split(path.sep).join("/");
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                existed = false;
+            }
+            else {
+                throw error;
+            }
+        }
+        entries.push({
+            relativePath: rel,
+            existed,
+            backupRelativePath,
+            sha256Before: sha,
+            mtimeMsBefore,
+        });
+    }
+    const record = {
+        id,
+        createdAt,
+        root,
+        mode: "apply",
+        entries,
+        ...(options.note ? { note: options.note } : {}),
+    };
+    await atomicWriteTextFile(path.join(auditDir(root), id, "audit.json"), `${JSON.stringify(record, null, 2)}\n`);
+    return record;
+}
+export async function listFixAudits(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const dir = auditDir(root);
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const name of names) {
+        try {
+            const raw = await fs.readFile(path.join(dir, name, "audit.json"), "utf8");
+            records.push(JSON.parse(raw));
+        }
+        catch {
+            // skip corrupt
+        }
+    }
+    return records.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+export async function undoFix(options) {
+    const root = resolveRepoRoot(options.root);
+    const auditPath = path.join(auditDir(root), options.auditId, "audit.json");
+    const raw = await fs.readFile(auditPath, "utf8");
+    const original = JSON.parse(raw);
+    const undoEntries = [];
+    for (const entry of original.entries) {
+        const target = resolveSafePath(root, entry.relativePath);
+        if (entry.existed && entry.backupRelativePath) {
+            const backupAbs = resolveSafePath(root, entry.backupRelativePath);
+            await fs.mkdir(path.dirname(target), { recursive: true });
+            await fs.copyFile(backupAbs, target);
+            undoEntries.push({
+                relativePath: entry.relativePath,
+                existed: true,
+                backupRelativePath: entry.backupRelativePath,
+                sha256Before: await sha256File(target),
+                mtimeMsBefore: null,
+            });
+        }
+        else if (!entry.existed) {
+            try {
+                await fs.unlink(target);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== "ENOENT")
+                    throw error;
+            }
+            undoEntries.push({
+                relativePath: entry.relativePath,
+                existed: false,
+                backupRelativePath: null,
+                sha256Before: null,
+                mtimeMsBefore: null,
+            });
+        }
+    }
+    const undoRecord = {
+        id: randomUUID(),
+        createdAt: new Date().toISOString(),
+        root,
+        mode: "undo",
+        entries: undoEntries,
+        note: `undo of ${original.id}`,
+    };
+    await fs.mkdir(path.join(auditDir(root), undoRecord.id), { recursive: true });
+    await atomicWriteTextFile(path.join(auditDir(root), undoRecord.id, "audit.json"), `${JSON.stringify(undoRecord, null, 2)}\n`);
+    return undoRecord;
+}
+/**
+ * Ensure a target still matches the backup snapshot (detect concurrent modification).
+ * For files that did not exist at backup time, refuses if the path now exists.
+ */
+export async function assertTargetsUnchangedSinceBackup(rootInput, audit, relativePaths) {
+    const root = resolveRepoRoot(rootInput);
+    const byPath = new Map(audit.entries.map((e) => [e.relativePath, e]));
+    for (const rel of relativePaths) {
+        const entry = byPath.get(rel);
+        if (!entry)
+            continue;
+        const absolute = resolveSafePath(root, rel);
+        try {
+            const st = await fs.lstat(absolute);
+            if (st.isSymbolicLink() || st.isDirectory()) {
+                throw new Error(`concurrent modification risk on non-file target: ${rel}`);
+            }
+            if (!entry.existed) {
+                throw new Error(`concurrent modification detected: ${rel} was created after backup (refusing write)`);
+            }
+            const sha = await sha256File(absolute);
+            if (entry.sha256Before && sha !== entry.sha256Before) {
+                throw new Error(`concurrent modification detected: ${rel} changed since backup (hash mismatch)`);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                if (entry.existed) {
+                    throw new Error(`concurrent modification detected: ${rel} deleted since backup (refusing write)`);
+                }
+                continue;
+            }
+            throw error;
+        }
+    }
+}

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

@@ -2,8 +2,11 @@ import type { ScanResult } from "../../types/index.js";
 import type { FixPlan } from "./types.js";
 /**
  * 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 declare function buildFixPlan(result: ScanResult): Promise<FixPlan>;
-/** Patterns that would be newly appended given current file contents. */
-export declare function missingPatternsForCursorignore(currentContent: string | null, patterns: string[]): string[];
+/** Patterns that would be newly appended given current ignore-file contents. */
+export declare function missingPatternsForIgnoreFile(currentContent: string | null, patterns: string[]): string[];
+/** @deprecated Prefer missingPatternsForIgnoreFile */
+export declare const missingPatternsForCursorignore: typeof missingPatternsForIgnoreFile;