claudeup 6.2.1 → 6.3.2

package/src/services/gitignore-fixer.ts

@@ -15,251 +15,266 @@
  * `formatViolationSummary` is a pure helper for prerun warning + TUI.
  */
 
-import { readFile, writeFile, appendFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { appendFile, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { spawn } from "node:child_process";
 import { getGitignoreRuleReason } from "../data/gitignore-reasons.js";
 import type { Violation } from "../types/gitignore.js";
 
 const CLAUDEUP_HEADER = "# Added by claudeup";
 
 export interface SafeFixResult {
-  appended: string[];
-  alreadyPresent: string[];
+	appended: string[];
+	alreadyPresent: string[];
 }
 
 export async function applySafeFixes(
-  cwd: string,
-  violations: Violation[],
+	cwd: string,
+	violations: Violation[],
 ): Promise<SafeFixResult> {
-  const safe = violations.filter(
-    (v) => v.severity === "safe" && v.kind === "missing-from-gitignore",
-  );
-  if (safe.length === 0) {
-    return { appended: [], alreadyPresent: [] };
-  }
+	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 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: string[] = [];
-  const alreadyPresent: string[] = [];
-  for (const v of safe) {
-    if (lines.has(v.path)) {
-      alreadyPresent.push(v.path);
-    } else {
-      appended.push(v.path);
-      lines.add(v.path);
-    }
-  }
+	const appended: string[] = [];
+	const alreadyPresent: string[] = [];
+	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 };
+	if (appended.length === 0) return { appended, alreadyPresent };
 
-  const block = [
-    "",
-    CLAUDEUP_HEADER,
-    ...appended.flatMap(formatGitignoreEntry),
-    "",
-  ].join("\n");
+	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);
-  }
+	if (existing.length > 0 && !existing.endsWith("\n")) {
+		await appendFile(gitignorePath, `\n${block}`);
+	} else {
+		await appendFile(gitignorePath, block);
+	}
 
-  return { appended, alreadyPresent };
+	return { appended, alreadyPresent };
 }
 
 export interface DestructiveFixResult {
-  applied: boolean;
-  message: string;
+	applied: boolean;
+	message: string;
 }
 
 export async function applyDestructiveFix(
-  cwd: string,
-  violation: Violation,
-  rulePattern = violation.path,
+	cwd: string,
+	violation: Violation,
+	rulePattern = violation.path,
 ): Promise<DestructiveFixResult> {
-  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` };
-    }
-  }
+	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: Violation[]): string {
-  if (violations.length === 0) return "No gitignore issues detected.";
+	if (violations.length === 0) return "No gitignore issues detected.";
 
-  const byKind = new Map<string, Violation[]>();
-  for (const v of violations) {
-    const arr = byKind.get(v.kind) ?? [];
-    arr.push(v);
-    byKind.set(v.kind, arr);
-  }
+	const byKind = new Map<string, Violation[]>();
+	for (const v of violations) {
+		const arr = byKind.get(v.kind) ?? [];
+		arr.push(v);
+		byKind.set(v.kind, arr);
+	}
 
-  const labels: Record<Violation["kind"], string> = {
-    "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 labels: Record<Violation["kind"], string> = {
+		"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: string[] = [];
-  for (const [kind, vs] of byKind.entries()) {
-    lines.push(`  ${labels[kind as Violation["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");
+	const lines: string[] = [];
+	for (const [kind, vs] of byKind.entries()) {
+		lines.push(`  ${labels[kind as Violation["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: string, pattern: string): Promise<void> {
-  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);
+	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: string): string[] {
-  return [`# ${getGitignoreRuleReason("ignore", pattern)}`, pattern];
+	return [`# ${getGitignoreRuleReason("ignore", pattern)}`, pattern];
 }
 
 async function appendTrackExceptionsIfNeeded(
-  cwd: string,
-  path: string,
+	cwd: string,
+	path: string,
 ): Promise<void> {
-  if (!(await pathIsIgnored(cwd, path))) return;
+	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 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);
+	const block = [
+		existing.length > 0 && !existing.endsWith("\n") ? "\n" : "",
+		CLAUDEUP_HEADER,
+		`# ${getGitignoreRuleReason("track", path)}`,
+		...additions,
+		"",
+	].join("\n");
+	await appendFile(gitignorePath, block);
 }
 
 function unignorePatternsForPath(path: string): string[] {
-  const normalized = path.replace(/^\/+/, "").replace(/\/+$/, "");
-  if (!normalized) return [];
-  const parts = normalized.split("/");
-  const patterns: string[] = [];
-  for (let i = 0; i < parts.length - 1; i++) {
-    patterns.push(`!/${parts.slice(0, i + 1).join("/")}/`);
-  }
-  patterns.push(`!/${normalized}`);
-  return patterns;
+	const normalized = path.replace(/^\/+/, "").replace(/\/+$/, "");
+	if (!normalized) return [];
+	const parts = normalized.split("/");
+	const patterns: string[] = [];
+	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: string, pattern: string): Promise<void> {
-  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);
-  }
+	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: string, path: string): Promise<boolean> {
-  try {
-    await runGit(["check-ignore", "--quiet", "--", path], cwd);
-    return true;
-  } catch (err) {
-    if (err instanceof GitError && err.code === 1) return false;
-    return false;
-  }
+	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 {
-  constructor(public code: number, public stderr: string) {
-    super(`git exited ${code}: ${stderr}`);
-  }
+	constructor(
+		public code: number,
+		public stderr: string,
+	) {
+		super(`git exited ${code}: ${stderr}`);
+	}
 }
 
 function runGit(args: string[], cwd: string): Promise<string> {
-  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));
-    });
-  });
+	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.ts

@@ -8,33 +8,33 @@
  * where prerun *warns* and the TUI provides the interactive fix dialog.
  */
 
-import { resolveGitignore } from "./gitignore-resolver.js";
+import type { Violation } from "../types/gitignore.js";
 import { detectViolations } from "./gitignore-detector.js";
 import { formatViolationSummary } from "./gitignore-fixer.js";
-import type { Violation } from "../types/gitignore.js";
+import { resolveGitignore } from "./gitignore-resolver.js";
 
 export interface PrerunResult {
-  violationCount: number;
-  warnings: string[];
+	violationCount: number;
+	warnings: string[];
 }
 
 export async function checkGitignore(cwd: string): Promise<PrerunResult> {
-  const warnings: string[] = [];
-  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 };
-  }
+	const warnings: string[] = [];
+	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 };
+	}
 }
 
 /**
@@ -42,8 +42,8 @@ export async function checkGitignore(cwd: string): Promise<PrerunResult> {
  * nothing to warn about.
  */
 export function formatPrerunWarning(result: PrerunResult): string | null {
-  if (result.violationCount === 0) return null;
-  return `⚠ ${result.violationCount} git state issue(s) detected. Run: claudeup → Git State tab to review and fix`;
+	if (result.violationCount === 0) return null;
+	return `⚠ ${result.violationCount} git state issue(s) detected. Run: claudeup → Git State tab to review and fix`;
 }
 
 /**
@@ -51,9 +51,9 @@ export function formatPrerunWarning(result: PrerunResult): string | null {
  * to know what's wrong before deciding what to do.
  */
 export async function describeViolations(
-  cwd: string,
-  violations: Violation[],
+	cwd: string,
+	violations: Violation[],
 ): Promise<string> {
-  void cwd;
-  return formatViolationSummary(violations);
+	void cwd;
+	return formatViolationSummary(violations);
 }