claudeup 4.18.0 → 4.22.0

package/src/services/gitignore-detector.js

@@ -1,155 +0,0 @@
-/**
- * Detect violations of the resolved gitignore manifest against a working
- * tree. Emits one Violation per offending path.
- *
- * Strategy:
- *   - For ignore rules: ask `git ls-files` whether the path (or anything
- *     under it for directory-style rules) is currently tracked. If so,
- *     it's "tracked-but-should-ignore" (destructive). Then check whether
- *     the existing .gitignore covers the path; if not, that's
- *     "missing-from-gitignore" (safe additive fix).
- *   - For track rules: ask `git check-ignore` whether the path is being
- *     excluded by the current .gitignore. If yes, "ignored-but-should-track"
- *     (destructive — must remove the .gitignore line). If the path exists
- *     on disk but isn't tracked and isn't ignored, "untracked-and-should-track".
- *
- * Glob expansion is intentionally limited: we treat patterns as literals
- * with directory-suffix awareness ("foo/" matches anything under foo/).
- * Full gitignore-syntax glob expansion is deferred — git itself handles
- * the heavy lifting via ls-files / check-ignore.
- */
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-export async function detectViolations(cwd, resolved) {
-    if (!(await isGitRepo(cwd)))
-        return [];
-    const violations = [];
-    const trackedFiles = await listTrackedFiles(cwd);
-    const trackedSet = new Set(trackedFiles);
-    for (const rule of resolved.rules) {
-        if (rule.action === "ignore") {
-            const tracked = matchesTrackedFile(rule.pattern, trackedSet);
-            if (tracked.length > 0) {
-                for (const path of tracked) {
-                    violations.push({
-                        kind: "tracked-but-should-ignore",
-                        path,
-                        source: rule.source,
-                        severity: "destructive",
-                    });
-                }
-            }
-            else {
-                // Not tracked — check if .gitignore covers it. If not, suggest
-                // a safe additive fix (append to .gitignore).
-                const ignored = await pathIsIgnored(cwd, rule.pattern);
-                if (!ignored) {
-                    violations.push({
-                        kind: "missing-from-gitignore",
-                        path: rule.pattern,
-                        source: rule.source,
-                        severity: "safe",
-                    });
-                }
-            }
-        }
-        else {
-            // action === "track"
-            const ignored = await pathIsIgnored(cwd, rule.pattern);
-            if (ignored) {
-                violations.push({
-                    kind: "ignored-but-should-track",
-                    path: rule.pattern,
-                    source: rule.source,
-                    severity: "destructive",
-                });
-                continue;
-            }
-            const isTracked = trackedSet.has(rule.pattern);
-            const existsOnDisk = existsSync(join(cwd, rule.pattern));
-            if (existsOnDisk && !isTracked) {
-                violations.push({
-                    kind: "untracked-and-should-track",
-                    path: rule.pattern,
-                    source: rule.source,
-                    severity: "destructive",
-                });
-            }
-        }
-    }
-    return violations;
-}
-/**
- * Match a pattern against the tracked-files set. Directory-style patterns
- * (trailing "/") match every tracked path under that prefix.
- */
-function matchesTrackedFile(pattern, tracked) {
-    if (pattern.endsWith("/")) {
-        const prefix = pattern;
-        return Array.from(tracked).filter((p) => p.startsWith(prefix));
-    }
-    if (pattern.includes("*")) {
-        // Very limited literal-prefix glob handling. Full expansion is git's job.
-        const star = pattern.indexOf("*");
-        const prefix = pattern.slice(0, star);
-        return Array.from(tracked).filter((p) => p.startsWith(prefix));
-    }
-    return tracked.has(pattern) ? [pattern] : [];
-}
-async function isGitRepo(cwd) {
-    try {
-        await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function listTrackedFiles(cwd) {
-    try {
-        const out = await runGit(["ls-files"], cwd);
-        return out.split("\n").map((l) => l.trim()).filter(Boolean);
-    }
-    catch {
-        return [];
-    }
-}
-async function pathIsIgnored(cwd, path) {
-    try {
-        // git check-ignore exits 0 when path IS ignored, 1 when NOT, >1 on error.
-        await runGit(["check-ignore", "--quiet", "--", path], cwd);
-        return true;
-    }
-    catch (err) {
-        // exit code 1 = not ignored (expected), anything else swallowed.
-        if (err instanceof GitError && err.code === 1)
-            return false;
-        return false;
-    }
-}
-class GitError extends Error {
-    code;
-    stderr;
-    constructor(code, stderr) {
-        super(`git exited ${code}: ${stderr}`);
-        this.code = code;
-        this.stderr = stderr;
-    }
-}
-function runGit(args, cwd) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("git", args, { cwd });
-        let stdout = "";
-        let stderr = "";
-        proc.stdout.on("data", (b) => { stdout += b.toString(); });
-        proc.stderr.on("data", (b) => { stderr += b.toString(); });
-        proc.on("error", reject);
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve(stdout);
-            else
-                reject(new GitError(code ?? -1, stderr));
-        });
-    });
-}

package/src/services/gitignore-fixer.js

@@ -1,231 +0,0 @@
-/**
- * Apply fixes for gitignore violations. Two flavors:
- *
- *   - `applySafeFixes`: additive — appends missing patterns to .gitignore
- *     under a "# Added by claudeup" header. Idempotent (re-running is a no-op
- *     because patterns are already present).
- *
- *   - `applyDestructiveFix`: index-mutating — runs `git rm --cached <path>`
- *     for tracked-but-should-ignore, `git add <path>` (after making sure
- *     gitignore has any needed `!` exceptions) for ignored-but-should-track /
- *     untracked-and-should-track.
- *     Each call handles ONE violation; the caller is responsible for confirming
- *     each one with the user.
- *
- * `formatViolationSummary` is a pure helper for prerun warning + TUI.
- */
-import { readFile, writeFile, appendFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { getGitignoreRuleReason } from "../data/gitignore-reasons.js";
-const CLAUDEUP_HEADER = "# Added by claudeup";
-export async function applySafeFixes(cwd, violations) {
-    const safe = violations.filter((v) => v.severity === "safe" && v.kind === "missing-from-gitignore");
-    if (safe.length === 0) {
-        return { appended: [], alreadyPresent: [] };
-    }
-    const gitignorePath = join(cwd, ".gitignore");
-    const existing = existsSync(gitignorePath)
-        ? await readFile(gitignorePath, "utf8")
-        : "";
-    const lines = new Set(existing.split("\n").map((l) => l.trim()).filter(Boolean));
-    const appended = [];
-    const alreadyPresent = [];
-    for (const v of safe) {
-        if (lines.has(v.path)) {
-            alreadyPresent.push(v.path);
-        }
-        else {
-            appended.push(v.path);
-            lines.add(v.path);
-        }
-    }
-    if (appended.length === 0)
-        return { appended, alreadyPresent };
-    const block = [
-        "",
-        CLAUDEUP_HEADER,
-        ...appended.flatMap(formatGitignoreEntry),
-        "",
-    ].join("\n");
-    if (existing.length > 0 && !existing.endsWith("\n")) {
-        await appendFile(gitignorePath, "\n" + block);
-    }
-    else {
-        await appendFile(gitignorePath, block);
-    }
-    return { appended, alreadyPresent };
-}
-export async function applyDestructiveFix(cwd, violation, rulePattern = violation.path) {
-    switch (violation.kind) {
-        case "tracked-but-should-ignore": {
-            await runGit(["rm", "--cached", "--", violation.path], cwd);
-            // Then make sure .gitignore has the entry so it stays out
-            await appendIfMissing(cwd, rulePattern);
-            return {
-                applied: true,
-                message: `Removed ${violation.path} from index and added ${rulePattern} to .gitignore`,
-            };
-        }
-        case "ignored-but-should-track": {
-            await stripGitignoreLine(cwd, violation.path);
-            await appendTrackExceptionsIfNeeded(cwd, violation.path);
-            if (!existsSync(join(cwd, violation.path))) {
-                return {
-                    applied: true,
-                    message: `Made ${violation.path} trackable; file does not exist yet`,
-                };
-            }
-            try {
-                await runGit(["add", "--", violation.path], cwd);
-            }
-            catch (err) {
-                return {
-                    applied: false,
-                    message: `Removed .gitignore line but git add failed: ${err instanceof Error ? err.message : String(err)}`,
-                };
-            }
-            return {
-                applied: true,
-                message: `Removed .gitignore line and staged ${violation.path}`,
-            };
-        }
-        case "untracked-and-should-track": {
-            await appendTrackExceptionsIfNeeded(cwd, violation.path);
-            await runGit(["add", "--", violation.path], cwd);
-            return { applied: true, message: `Staged ${violation.path}` };
-        }
-        case "missing-from-gitignore": {
-            // Treat as a safe append for symmetry — caller can route through here too.
-            await appendIfMissing(cwd, rulePattern);
-            return { applied: true, message: `Added ${rulePattern} to .gitignore` };
-        }
-    }
-}
-export function formatViolationSummary(violations) {
-    if (violations.length === 0)
-        return "No gitignore issues detected.";
-    const byKind = new Map();
-    for (const v of violations) {
-        const arr = byKind.get(v.kind) ?? [];
-        arr.push(v);
-        byKind.set(v.kind, arr);
-    }
-    const labels = {
-        "tracked-but-should-ignore": "tracked but should be ignored",
-        "ignored-but-should-track": "ignored but should be tracked",
-        "untracked-and-should-track": "exist but not tracked (should be)",
-        "missing-from-gitignore": "missing from .gitignore",
-    };
-    const lines = [];
-    for (const [kind, vs] of byKind.entries()) {
-        lines.push(`  ${labels[kind]}: ${vs.length}`);
-        for (const v of vs.slice(0, 5)) {
-            lines.push(`    - ${v.path}`);
-        }
-        if (vs.length > 5)
-            lines.push(`    … and ${vs.length - 5} more`);
-    }
-    return lines.join("\n");
-}
-async function appendIfMissing(cwd, pattern) {
-    const gitignorePath = join(cwd, ".gitignore");
-    const existing = existsSync(gitignorePath)
-        ? await readFile(gitignorePath, "utf8")
-        : "";
-    const lines = existing.split("\n").map((l) => l.trim());
-    if (lines.includes(pattern))
-        return;
-    // Only emit the "# Added by claudeup" header once — when fixing several
-    // entries in one pass (F), the file already has the header from the first.
-    const needsHeader = !lines.includes(CLAUDEUP_HEADER);
-    const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-    const header = needsHeader ? `${CLAUDEUP_HEADER}\n` : "";
-    const block = `${prefix}${header}${formatGitignoreEntry(pattern).join("\n")}\n`;
-    await appendFile(gitignorePath, block);
-}
-function formatGitignoreEntry(pattern) {
-    return [`# ${getGitignoreRuleReason("ignore", pattern)}`, pattern];
-}
-async function appendTrackExceptionsIfNeeded(cwd, path) {
-    if (!(await pathIsIgnored(cwd, path)))
-        return;
-    const gitignorePath = join(cwd, ".gitignore");
-    const existing = existsSync(gitignorePath)
-        ? await readFile(gitignorePath, "utf8")
-        : "";
-    const lines = new Set(existing.split("\n").map((line) => line.trim()).filter(Boolean));
-    const additions = unignorePatternsForPath(path).filter((line) => !lines.has(line));
-    if (additions.length === 0)
-        return;
-    const block = [
-        existing.length > 0 && !existing.endsWith("\n") ? "\n" : "",
-        CLAUDEUP_HEADER,
-        `# ${getGitignoreRuleReason("track", path)}`,
-        ...additions,
-        "",
-    ].join("\n");
-    await appendFile(gitignorePath, block);
-}
-function unignorePatternsForPath(path) {
-    const normalized = path.replace(/^\/+/, "").replace(/\/+$/, "");
-    if (!normalized)
-        return [];
-    const parts = normalized.split("/");
-    const patterns = [];
-    for (let i = 0; i < parts.length - 1; i++) {
-        patterns.push(`!/${parts.slice(0, i + 1).join("/")}/`);
-    }
-    patterns.push(`!/${normalized}`);
-    return patterns;
-}
-async function stripGitignoreLine(cwd, pattern) {
-    const gitignorePath = join(cwd, ".gitignore");
-    if (!existsSync(gitignorePath))
-        return;
-    const content = await readFile(gitignorePath, "utf8");
-    const filtered = content
-        .split("\n")
-        .filter((line) => line.trim() !== pattern)
-        .join("\n");
-    if (filtered !== content) {
-        await writeFile(gitignorePath, filtered);
-    }
-}
-async function pathIsIgnored(cwd, path) {
-    try {
-        await runGit(["check-ignore", "--quiet", "--", path], cwd);
-        return true;
-    }
-    catch (err) {
-        if (err instanceof GitError && err.code === 1)
-            return false;
-        return false;
-    }
-}
-class GitError extends Error {
-    code;
-    stderr;
-    constructor(code, stderr) {
-        super(`git exited ${code}: ${stderr}`);
-        this.code = code;
-        this.stderr = stderr;
-    }
-}
-function runGit(args, cwd) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("git", args, { cwd });
-        let stdout = "";
-        let stderr = "";
-        proc.stdout.on("data", (b) => { stdout += b.toString(); });
-        proc.stderr.on("data", (b) => { stderr += b.toString(); });
-        proc.on("error", reject);
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve(stdout);
-            else
-                reject(new GitError(code ?? -1, stderr));
-        });
-    });
-}

package/src/services/gitignore-prerun.js

@@ -1,46 +0,0 @@
-/**
- * Prerunner integration for the gitignore manager.
- *
- * Called from `prerunner/index.ts` (Step 0.9) on every claudeup invocation.
- * Resolves the manifest, runs detection, and prints a concise warning when
- * violations exist. Does NOT auto-apply fixes — the user must open the
- * Git State tab and confirm. This mirrors the plugin-version-mismatch flow
- * where prerun *warns* and the TUI provides the interactive fix dialog.
- */
-import { resolveGitignore } from "./gitignore-resolver.js";
-import { detectViolations } from "./gitignore-detector.js";
-import { formatViolationSummary } from "./gitignore-fixer.js";
-export async function checkGitignore(cwd) {
-    const warnings = [];
-    try {
-        const resolved = await resolveGitignore(cwd, {
-            logger: (m) => warnings.push(m),
-        });
-        const violations = await detectViolations(cwd, resolved);
-        return {
-            violationCount: violations.length,
-            warnings,
-        };
-    }
-    catch (err) {
-        warnings.push(`[gitignore] check failed: ${err instanceof Error ? err.message : String(err)}`);
-        return { violationCount: 0, warnings };
-    }
-}
-/**
- * One-line summary suitable for prerun stderr. Returns null when there's
- * nothing to warn about.
- */
-export function formatPrerunWarning(result) {
-    if (result.violationCount === 0)
-        return null;
-    return `⚠ ${result.violationCount} git state issue(s) detected. Run: claudeup → Git State tab to review and fix`;
-}
-/**
- * Verbose multi-line summary, used by the Git State tab when the user wants
- * to know what's wrong before deciding what to do.
- */
-export async function describeViolations(cwd, violations) {
-    void cwd;
-    return formatViolationSummary(violations);
-}

package/src/services/gitignore-resolver.js

@@ -1,143 +0,0 @@
-/**
- * Three-tier gitignore manifest resolver.
- *
- * Precedence (lowest → highest, last-wins):
- *   1. Built-in defaults (shipped with claudeup)
- *   2. Global manifest at ~/.claude/gitignore.json (team-level, manually shared)
- *   3. Project manifest at <cwd>/.claude/gitignore.json
- *
- * `extends` references are resolved against BUILTIN_TEMPLATES. Within a single
- * tier, the same pattern cannot appear in both `ignore` and `track` — that
- * throws. Across tiers, the higher-precedence tier wins; losers are recorded
- * in `conflicts` so the TUI can show "global says ignore .env, project
- * overrides to track."
- */
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { existsSync } from "node:fs";
-import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults.js";
-import { BUILTIN_TEMPLATES } from "../data/gitignore-templates.js";
-const TIER_ORDER = ["builtin", "global", "project"];
-export async function resolveGitignore(projectCwd, opts = {}) {
-    const home = opts.homeDir ?? homedir();
-    const log = opts.logger ?? (() => { });
-    const tierManifests = new Map();
-    // 1. Built-in (always present)
-    tierManifests.set("builtin", BUILTIN_DEFAULTS);
-    // 2. Global ~/.claude/gitignore.json
-    const globalPath = join(home, ".claude", "gitignore.json");
-    const globalManifest = await readManifest(globalPath, log);
-    if (globalManifest)
-        tierManifests.set("global", globalManifest);
-    // 3. Project .claude/gitignore.json
-    const projectPath = join(projectCwd, ".claude", "gitignore.json");
-    const projectManifest = await readManifest(projectPath, log);
-    if (projectManifest)
-        tierManifests.set("project", projectManifest);
-    // Apply `extends` for each tier (templates count as part of their tier)
-    for (const tier of TIER_ORDER) {
-        const m = tierManifests.get(tier);
-        if (!m?.extends?.length)
-            continue;
-        const merged = {
-            ignore: [...m.ignore],
-            track: [...m.track],
-        };
-        for (const tplName of m.extends) {
-            const tpl = BUILTIN_TEMPLATES[tplName];
-            if (!tpl) {
-                log(`[gitignore] unknown template "${tplName}" in ${tier} manifest`);
-                continue;
-            }
-            merged.ignore.push(...tpl.ignore);
-            merged.track.push(...tpl.track);
-        }
-        tierManifests.set(tier, merged);
-    }
-    // Validate intra-tier consistency
-    for (const [tier, m] of tierManifests.entries()) {
-        const ig = new Set(m.ignore);
-        for (const t of m.track) {
-            if (ig.has(t)) {
-                throw new Error(`Intra-tier conflict in ${tier} manifest: "${t}" is in both ignore and track`);
-            }
-        }
-    }
-    // Merge across tiers — last-wins, track conflicts
-    const ruleByPattern = new Map();
-    for (const tier of TIER_ORDER) {
-        const m = tierManifests.get(tier);
-        if (!m)
-            continue;
-        for (const p of dedupe(m.ignore)) {
-            pushRule(ruleByPattern, p, "ignore", tier);
-        }
-        for (const p of dedupe(m.track)) {
-            pushRule(ruleByPattern, p, "track", tier);
-        }
-    }
-    const rules = [];
-    const conflicts = [];
-    for (const [pattern, entry] of ruleByPattern.entries()) {
-        rules.push({ pattern, action: entry.action, source: entry.source });
-        const losers = entry.history.filter((h) => h.tier !== entry.source || h.action !== entry.action);
-        if (losers.length > 0 && hasActionDisagreement(entry.history)) {
-            conflicts.push({
-                pattern,
-                winner: entry.source,
-                losers: losers.filter((l) => l.action !== entry.action),
-            });
-        }
-    }
-    return { rules, conflicts };
-}
-function pushRule(map, pattern, action, tier) {
-    const existing = map.get(pattern);
-    if (existing) {
-        existing.history.push({ tier, action });
-        existing.action = action;
-        existing.source = tier;
-    }
-    else {
-        map.set(pattern, { action, source: tier, history: [{ tier, action }] });
-    }
-}
-function hasActionDisagreement(history) {
-    const actions = new Set(history.map((h) => h.action));
-    return actions.size > 1;
-}
-function dedupe(xs) {
-    return Array.from(new Set(xs));
-}
-async function readManifest(path, log) {
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = await readFile(path, "utf8");
-        const parsed = JSON.parse(raw);
-        if (!isManifest(parsed)) {
-            log(`[gitignore] ${path} is not a valid manifest (expected { ignore: string[], track: string[] })`);
-            return null;
-        }
-        return parsed;
-    }
-    catch (err) {
-        log(`[gitignore] failed to read ${path}: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-}
-function isManifest(x) {
-    if (!x || typeof x !== "object")
-        return false;
-    const m = x;
-    if (!Array.isArray(m.ignore) || !m.ignore.every((p) => typeof p === "string"))
-        return false;
-    if (!Array.isArray(m.track) || !m.track.every((p) => typeof p === "string"))
-        return false;
-    if (m.extends !== undefined) {
-        if (!Array.isArray(m.extends) || !m.extends.every((p) => typeof p === "string"))
-            return false;
-    }
-    return true;
-}

package/src/services/gitignore-service.js

@@ -1,117 +0,0 @@
-/**
- * TUI-facing wrapper around the gitignore core services. Loads everything
- * the Gitignore screen needs in one call, and exposes a small set of
- * action helpers (apply safe fixes, apply one destructive fix, apply a
- * built-in template).
- */
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { resolveGitignore } from "./gitignore-resolver.js";
-import { detectViolations } from "./gitignore-detector.js";
-import { applySafeFixes as coreApplySafeFixes, applyDestructiveFix as coreApplyDestructiveFix, } from "./gitignore-fixer.js";
-import { BUILTIN_TEMPLATES } from "../data/gitignore-templates.js";
-export async function loadGitignoreState(cwd) {
-    const warnings = [];
-    const resolved = await resolveGitignore(cwd, {
-        logger: (m) => warnings.push(m),
-    });
-    const violations = await detectViolations(cwd, resolved);
-    return { resolved, violations, warnings };
-}
-export async function applyAllSafeFixes(cwd, violations) {
-    return coreApplySafeFixes(cwd, violations);
-}
-export async function applyDestructiveFix(cwd, violation, rulePattern) {
-    return coreApplyDestructiveFix(cwd, violation, rulePattern);
-}
-export async function ensureProjectManifestForEdit(cwd, resolved) {
-    const projectManifestPath = join(cwd, ".claude", "gitignore.json");
-    if (existsSync(projectManifestPath)) {
-        const existing = await readFile(projectManifestPath, "utf8");
-        if (existing.trim().length > 0)
-            return projectManifestPath;
-    }
-    const manifest = { ignore: [], track: [] };
-    for (const rule of resolved.rules) {
-        if (rule.action === "ignore")
-            manifest.ignore.push(rule.pattern);
-        else
-            manifest.track.push(rule.pattern);
-    }
-    await mkdir(dirname(projectManifestPath), { recursive: true });
-    await writeFile(projectManifestPath, JSON.stringify(manifest, null, 2) + "\n");
-    return projectManifestPath;
-}
-/**
- * Merge a built-in template into the project manifest at .claude/gitignore.json.
- * Conflicts (a pattern that already exists with the opposite action) are
- * skipped and reported back to the caller.
- */
-export async function applyTemplate(cwd, templateName) {
-    const tpl = BUILTIN_TEMPLATES[templateName];
-    if (!tpl)
-        throw new Error(`Unknown template: ${templateName}`);
-    const projectManifestPath = join(cwd, ".claude", "gitignore.json");
-    const existing = await readManifestOrEmpty(projectManifestPath);
-    const existingIgnore = new Set(existing.ignore);
-    const existingTrack = new Set(existing.track);
-    const conflicts = [];
-    const newIgnore = [];
-    const newTrack = [];
-    for (const p of tpl.ignore) {
-        if (existingTrack.has(p)) {
-            conflicts.push(p);
-            continue;
-        }
-        if (!existingIgnore.has(p)) {
-            newIgnore.push(p);
-            existingIgnore.add(p);
-        }
-    }
-    for (const p of tpl.track) {
-        if (existingIgnore.has(p)) {
-            conflicts.push(p);
-            continue;
-        }
-        if (!existingTrack.has(p)) {
-            newTrack.push(p);
-            existingTrack.add(p);
-        }
-    }
-    const merged = {
-        ignore: [...existing.ignore, ...newIgnore],
-        track: [...existing.track, ...newTrack],
-        extends: existing.extends,
-    };
-    await mkdir(dirname(projectManifestPath), { recursive: true });
-    await writeFile(projectManifestPath, JSON.stringify(merged, null, 2) + "\n");
-    return {
-        appliedTo: projectManifestPath,
-        added: { ignore: newIgnore, track: newTrack },
-        conflicts,
-    };
-}
-async function readManifestOrEmpty(path) {
-    if (!existsSync(path))
-        return { ignore: [], track: [] };
-    try {
-        const raw = await readFile(path, "utf8");
-        const parsed = JSON.parse(raw);
-        if (!isManifest(parsed))
-            return { ignore: [], track: [] };
-        return parsed;
-    }
-    catch {
-        return { ignore: [], track: [] };
-    }
-}
-function isManifest(x) {
-    if (!x || typeof x !== "object")
-        return false;
-    const m = x;
-    return (Array.isArray(m.ignore) &&
-        m.ignore.every((p) => typeof p === "string") &&
-        Array.isArray(m.track) &&
-        m.track.every((p) => typeof p === "string"));
-}