claudeup 6.2.1 → 6.3.0

package/src/services/gitignore-resolver.ts

@@ -13,178 +13,196 @@
  * overrides to track."
  */
 
+import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 import { homedir } from "node:os";
-import { existsSync } from "node:fs";
-import type {
-  GitignoreManifest,
-  ResolvedManifest,
-  ResolvedRule,
-  ResolvedConflict,
-  Tier,
-  RuleAction,
-} from "../types/gitignore.js";
+import { join } from "node:path";
 import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults.js";
 import { BUILTIN_TEMPLATES } from "../data/gitignore-templates.js";
+import type {
+	GitignoreManifest,
+	ResolvedConflict,
+	ResolvedManifest,
+	ResolvedRule,
+	RuleAction,
+	Tier,
+} from "../types/gitignore.js";
 
 export interface ResolveOptions {
-  /** Override $HOME (test seam). */
-  homeDir?: string;
-  /** Optional logger for non-fatal warnings (malformed JSON, missing template). */
-  logger?: (msg: string) => void;
+	/** Override $HOME (test seam). */
+	homeDir?: string;
+	/** Optional logger for non-fatal warnings (malformed JSON, missing template). */
+	logger?: (msg: string) => void;
 }
 
 const TIER_ORDER: Tier[] = ["builtin", "global", "project"];
 
 export async function resolveGitignore(
-  projectCwd: string,
-  opts: ResolveOptions = {},
+	projectCwd: string,
+	opts: ResolveOptions = {},
 ): Promise<ResolvedManifest> {
-  const home = opts.homeDir ?? homedir();
-  const log = opts.logger ?? (() => {});
-
-  const tierManifests = new Map<Tier, GitignoreManifest>();
-
-  // 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: GitignoreManifest = {
-      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<
-    string,
-    { action: RuleAction; source: Tier; history: Array<{ tier: Tier; action: RuleAction }> }
-  >();
-
-  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: ResolvedRule[] = [];
-  const conflicts: ResolvedConflict[] = [];
-
-  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 };
+	const home = opts.homeDir ?? homedir();
+	const log = opts.logger ?? (() => {});
+
+	const tierManifests = new Map<Tier, GitignoreManifest>();
+
+	// 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: GitignoreManifest = {
+			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<
+		string,
+		{
+			action: RuleAction;
+			source: Tier;
+			history: Array<{ tier: Tier; action: RuleAction }>;
+		}
+	>();
+
+	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: ResolvedRule[] = [];
+	const conflicts: ResolvedConflict[] = [];
+
+	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: Map<
-    string,
-    { action: RuleAction; source: Tier; history: Array<{ tier: Tier; action: RuleAction }> }
-  >,
-  pattern: string,
-  action: RuleAction,
-  tier: Tier,
+	map: Map<
+		string,
+		{
+			action: RuleAction;
+			source: Tier;
+			history: Array<{ tier: Tier; action: RuleAction }>;
+		}
+	>,
+	pattern: string,
+	action: RuleAction,
+	tier: Tier,
 ): void {
-  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 }] });
-  }
+	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: Array<{ tier: Tier; action: RuleAction }>,
+	history: Array<{ tier: Tier; action: RuleAction }>,
 ): boolean {
-  const actions = new Set(history.map((h) => h.action));
-  return actions.size > 1;
+	const actions = new Set(history.map((h) => h.action));
+	return actions.size > 1;
 }
 
 function dedupe(xs: string[]): string[] {
-  return Array.from(new Set(xs));
+	return Array.from(new Set(xs));
 }
 
 async function readManifest(
-  path: string,
-  log: (msg: string) => void,
+	path: string,
+	log: (msg: string) => void,
 ): Promise<GitignoreManifest | null> {
-  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;
-  }
+	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: unknown): x is GitignoreManifest {
-  if (!x || typeof x !== "object") return false;
-  const m = x as Record<string, unknown>;
-  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;
+	if (!x || typeof x !== "object") return false;
+	const m = x as Record<string, unknown>;
+	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.ts

@@ -5,80 +5,83 @@
  * 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,
-  type SafeFixResult,
-  type DestructiveFixResult,
-} from "./gitignore-fixer.js";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { BUILTIN_TEMPLATES } from "../data/gitignore-templates.js";
 import type {
-  GitignoreManifest,
-  ResolvedManifest,
-  Violation,
+	GitignoreManifest,
+	ResolvedManifest,
+	Violation,
 } from "../types/gitignore.js";
+import { detectViolations } from "./gitignore-detector.js";
+import {
+	type DestructiveFixResult,
+	type SafeFixResult,
+	applyDestructiveFix as coreApplyDestructiveFix,
+	applySafeFixes as coreApplySafeFixes,
+} from "./gitignore-fixer.js";
+import { resolveGitignore } from "./gitignore-resolver.js";
 
 export interface GitignoreState {
-  resolved: ResolvedManifest;
-  violations: Violation[];
-  /** Logger lines from resolution (malformed JSON, missing template, etc). */
-  warnings: string[];
+	resolved: ResolvedManifest;
+	violations: Violation[];
+	/** Logger lines from resolution (malformed JSON, missing template, etc). */
+	warnings: string[];
 }
 
 export async function loadGitignoreState(cwd: string): Promise<GitignoreState> {
-  const warnings: string[] = [];
-  const resolved = await resolveGitignore(cwd, {
-    logger: (m) => warnings.push(m),
-  });
-  const violations = await detectViolations(cwd, resolved);
-  return { resolved, violations, warnings };
+	const warnings: string[] = [];
+	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: string,
-  violations: Violation[],
+	cwd: string,
+	violations: Violation[],
 ): Promise<SafeFixResult> {
-  return coreApplySafeFixes(cwd, violations);
+	return coreApplySafeFixes(cwd, violations);
 }
 
 export async function applyDestructiveFix(
-  cwd: string,
-  violation: Violation,
-  rulePattern?: string,
+	cwd: string,
+	violation: Violation,
+	rulePattern?: string,
 ): Promise<DestructiveFixResult> {
-  return coreApplyDestructiveFix(cwd, violation, rulePattern);
+	return coreApplyDestructiveFix(cwd, violation, rulePattern);
 }
 
 export async function ensureProjectManifestForEdit(
-  cwd: string,
-  resolved: ResolvedManifest,
+	cwd: string,
+	resolved: ResolvedManifest,
 ): Promise<string> {
-  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: GitignoreManifest = { 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;
+	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: GitignoreManifest = { 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;
 }
 
 export interface ApplyTemplateResult {
-  appliedTo: string;
-  added: { ignore: string[]; track: string[] };
-  conflicts: string[];
+	appliedTo: string;
+	added: { ignore: string[]; track: string[] };
+	conflicts: string[];
 }
 
 /**
@@ -87,78 +90,78 @@ export interface ApplyTemplateResult {
  * skipped and reported back to the caller.
  */
 export async function applyTemplate(
-  cwd: string,
-  templateName: string,
+	cwd: string,
+	templateName: string,
 ): Promise<ApplyTemplateResult> {
-  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: string[] = [];
-  const newIgnore: string[] = [];
-  const newTrack: string[] = [];
-
-  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: GitignoreManifest = {
-    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,
-  };
+	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: string[] = [];
+	const newIgnore: string[] = [];
+	const newTrack: string[] = [];
+
+	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: GitignoreManifest = {
+		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: string): Promise<GitignoreManifest> {
-  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: [] };
-  }
+	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: unknown): x is GitignoreManifest {
-  if (!x || typeof x !== "object") return false;
-  const m = x as Record<string, unknown>;
-  return (
-    Array.isArray(m.ignore) &&
-    m.ignore.every((p) => typeof p === "string") &&
-    Array.isArray(m.track) &&
-    m.track.every((p) => typeof p === "string")
-  );
+	if (!x || typeof x !== "object") return false;
+	const m = x as Record<string, unknown>;
+	return (
+		Array.isArray(m.ignore) &&
+		m.ignore.every((p) => typeof p === "string") &&
+		Array.isArray(m.track) &&
+		m.track.every((p) => typeof p === "string")
+	);
 }

package/src/services/install-plan.ts

@@ -24,8 +24,8 @@ export interface VersionDrift {
 /** Highest valid semver in a list, or the raw first value if none parse. */
 function maxVersion(versions: string[]): string | null {
 	const valid = versions.filter((v) => semver.valid(v));
-	if (valid.length > 0) return valid.sort(semver.rcompare)[0]!;
-	return versions[0] ?? null;
+	const highest = valid.sort(semver.rcompare)[0];
+	return highest ?? versions[0] ?? null;
 }
 
 /**
@@ -86,8 +86,8 @@ export function summarizeClosure(closure: ResolvedClosure): string[] {
 	const lines: string[] = [];
 	const mps = Object.keys(closure.marketplaces);
 	if (mps.length) lines.push(`marketplaces  ${mps.join(", ")}`);
-	const plugins = Object.entries(closure.plugins).map(
-		([id, v]) => (v === "latest" ? id : `${id}@${v}`),
+	const plugins = Object.entries(closure.plugins).map(([id, v]) =>
+		v === "latest" ? id : `${id}@${v}`,
 	);
 	if (plugins.length) lines.push(`plugins       ${plugins.join(", ")}`);
 	const mcps = Object.keys(closure.mcpServers);

package/src/services/manifest.ts

@@ -7,8 +7,8 @@
  * structural subset of a v2 manifest entry, so migration is a version bump.
  */
 
-import fs from "fs-extra";
 import path from "node:path";
+import fs from "fs-extra";
 import type { ProfileManifest, ProfileManifestEntry } from "../types/index.js";
 
 const PROFILES_FILE = "profiles.json";