claudeup 6.2.1 → 6.3.0

package/src/services/gitignore-detector.ts

@@ -25,66 +25,66 @@ import { join } from "node:path";
 import type { ResolvedManifest, Violation } from "../types/gitignore.js";
 
 export async function detectViolations(
-  cwd: string,
-  resolved: ResolvedManifest,
+	cwd: string,
+	resolved: ResolvedManifest,
 ): Promise<Violation[]> {
-  if (!(await isGitRepo(cwd))) return [];
+	if (!(await isGitRepo(cwd))) return [];
 
-  const violations: Violation[] = [];
-  const trackedFiles = await listTrackedFiles(cwd);
-  const trackedSet = new Set(trackedFiles);
+	const violations: Violation[] = [];
+	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",
-        });
-      }
-    }
-  }
+	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;
+	return violations;
 }
 
 /**
@@ -92,66 +92,76 @@ export async function detectViolations(
  * (trailing "/") match every tracked path under that prefix.
  */
 function matchesTrackedFile(pattern: string, tracked: Set<string>): string[] {
-  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] : [];
+	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: string): Promise<boolean> {
-  try {
-    await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+		return true;
+	} catch {
+		return false;
+	}
 }
 
 async function listTrackedFiles(cwd: string): Promise<string[]> {
-  try {
-    const out = await runGit(["ls-files"], cwd);
-    return out.split("\n").map((l) => l.trim()).filter(Boolean);
-  } catch {
-    return [];
-  }
+	try {
+		const out = await runGit(["ls-files"], cwd);
+		return out
+			.split("\n")
+			.map((l) => l.trim())
+			.filter(Boolean);
+	} catch {
+		return [];
+	}
 }
 
 async function pathIsIgnored(cwd: string, path: string): Promise<boolean> {
-  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;
-  }
+	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 {
-  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));
+		});
+	});
 }