clank-cli 0.1.67 → 0.1.74

package/src/commands/Check.ts

@@ -7,8 +7,15 @@ import {
   formatAgentFileProblems,
 } from "../ClassifyFiles.ts";
 import { expandPath, loadConfig } from "../Config.ts";
-import { fileExists, relativePath, walkDirectory } from "../FsUtil.ts";
+import {
+  fileExists,
+  getCwd,
+  relativePath,
+  toSlash,
+  walkDirectory,
+} from "../FsUtil.ts";
 import { type GitContext, getGitContext } from "../Git.ts";
+import { loadGitignore } from "../Gitignore.ts";
 import { type MapperContext, overlayProjectDir } from "../Mapper.ts";
 import { formatStatusLines, getOverlayStatus } from "../OverlayGit.ts";
 import { type ManagedFileState, verifyManaged } from "../OverlayLinks.ts";
@@ -28,12 +35,19 @@ export type UnaddedFile = ManagedFileState & {
   relativePath: string;
 };
 
+export interface CheckOptions {
+  prompt?: boolean;
+}
+
 /** Files that should remain local and not be tracked by clank */
 const localOnlyFiles = ["settings.local.json"];
 
+/** Switch to a one-line summary when a category has at least this many files */
+const compactThreshold = 5;
+
 /** Check for orphaned overlay paths that don't match target structure */
-export async function checkCommand(): Promise<void> {
-  const cwd = process.cwd();
+export async function checkCommand(options: CheckOptions = {}): Promise<void> {
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const config = await loadConfig();
   const overlayRoot = expandPath(config.overlayRepo);
@@ -43,7 +57,7 @@ export async function checkCommand(): Promise<void> {
 
   await showOverlayStatus(overlayRoot, ignorePatterns);
 
-  const problems = await checkAllProblems(ctx, cwd, ignorePatterns);
+  const problems = await checkAllProblems(ctx, cwd, ignorePatterns, options);
   if (!problems) {
     console.log("No issues found. Overlay matches target structure.");
   }
@@ -53,15 +67,17 @@ export async function checkCommand(): Promise<void> {
 export async function findUnaddedFiles(
   context: MapperContext,
 ): Promise<UnaddedFile[]> {
-  const { targetRoot } = context;
+  const { targetRoot, overlayRoot } = context;
   const unadded: UnaddedFile[] = [];
+  const isIgnored = await loadGitignore(overlayRoot);
 
   for await (const { path, isDirectory } of walkDirectory(targetRoot)) {
     if (isDirectory) continue;
 
-    const relPath = relative(targetRoot, path);
+    const relPath = toSlash(relative(targetRoot, path));
     if (!isInManagedDir(relPath)) continue;
     if (isLocalOnlyFile(relPath)) continue;
+    if (isIgnored(basename(relPath))) continue;
 
     const managed = await verifyManaged(path, context);
     if (managed.kind !== "valid") {
@@ -89,13 +105,8 @@ export async function findOrphans(
   const isIgnored =
     ignorePatterns.length > 0 ? picomatch(ignorePatterns) : null;
 
-  const skip = (relPath: string): boolean => {
-    if (isIgnored) {
-      const pathBasename = relPath.split("/").at(-1) ?? "";
-      if (isIgnored(relPath) || isIgnored(pathBasename)) return true;
-    }
-    return false;
-  };
+  const skip = (relPath: string): boolean =>
+    !!isIgnored && (isIgnored(relPath) || isIgnored(basename(relPath)));
 
   for await (const { path, isDirectory } of walkDirectory(projectDir, {
     skipDirs: [".git", "node_modules", "worktrees"],
@@ -103,7 +114,7 @@ export async function findOrphans(
   })) {
     if (isDirectory) continue;
 
-    const relPath = relative(projectDir, path);
+    const relPath = toSlash(relative(projectDir, path));
 
     // Skip files at project root (agents.md, settings.json)
     if (!relPath.includes("/")) continue;
@@ -113,7 +124,6 @@ export async function findOrphans(
       continue;
     }
 
-    // This is a subdirectory file - check if target dir exists
     // e.g., tools/packages/wesl/clank/notes.md -> check tools/packages/wesl/
     const targetSubdir = extractTargetSubdir(relPath);
     if (!targetSubdir) continue;
@@ -164,6 +174,7 @@ async function checkAllProblems(
   ctx: MapperContext,
   cwd: string,
   ignorePatterns: string[] = [],
+  options: CheckOptions = {},
 ): Promise<boolean> {
   const { overlayRoot, targetRoot, gitContext } = ctx;
   let hasProblems = false;
@@ -193,7 +204,7 @@ async function checkAllProblems(
   );
   if (orphans.length > 0) {
     hasProblems = true;
-    showOrphanedPaths(orphans, targetRoot, overlayRoot);
+    showOrphanedPaths(orphans, targetRoot, overlayRoot, options);
   }
 
   return hasProblems;
@@ -218,12 +229,10 @@ function isLocalOnlyFile(relPath: string): boolean {
  * @example "tools/packages/wesl/agents.md" -> "tools/packages/wesl"
  */
 function extractTargetSubdir(relPath: string): string | null {
-  // Check for /clank/ or /claude/ in path
   for (const dir of managedDirs) {
     const idx = relPath.indexOf(`/${dir}/`);
     if (idx !== -1) return relPath.slice(0, idx);
   }
-  // Check for agents.md in a subdirectory
   if (relPath.endsWith("/agents.md")) {
     return relPath.slice(0, -"/agents.md".length);
   }
@@ -241,46 +250,27 @@ function showUnaddedFiles(
     ? `${projectName}/${worktreeName}`
     : projectName;
 
-  const outsideOverlay = unadded.filter((f) => f.kind === "outside-overlay");
-  const wrongMapping = unadded.filter((f) => f.kind === "wrong-mapping");
+  const outsideOverlay = unadded.filter(
+    (
+      f,
+    ): f is UnaddedFile & { kind: "outside-overlay"; currentTarget: string } =>
+      f.kind === "outside-overlay",
+  );
+  const wrongMapping = unadded.filter(
+    (
+      f,
+    ): f is UnaddedFile & {
+      kind: "wrong-mapping";
+      currentTarget: string;
+      expectedTarget: string;
+    } => f.kind === "wrong-mapping",
+  );
   const regularFiles = unadded.filter((f) => f.kind === "unadded");
 
-  if (outsideOverlay.length > 0) {
-    console.log(
-      `Found ${outsideOverlay.length} stale symlink(s) in ${targetName}:\n`,
-    );
-    console.log("These symlinks point outside the clank overlay.");
-    console.log("Remove them manually, then run `clank link` to recreate:\n");
-    for (const file of outsideOverlay) {
-      console.log(`  rm ${relativePath(cwd, file.targetPath)}`);
-    }
-    console.log();
-  }
-
-  if (wrongMapping.length > 0) {
-    console.log(
-      `Found ${wrongMapping.length} mislinked symlink(s) in ${targetName}:\n`,
-    );
-    console.log("These symlinks point to the wrong overlay location.");
-    console.log("Run `clank link` to fix them.\n");
-    for (const file of wrongMapping) {
-      console.log(`  ${relativePath(cwd, file.targetPath)}`);
-      if (file.currentTarget) {
-        console.log(`    points to: ${file.currentTarget}`);
-      }
-    }
-    console.log();
-  }
-
-  if (regularFiles.length > 0) {
-    console.log(
-      `Found ${regularFiles.length} unadded file(s) in ${targetName}:\n`,
-    );
-    for (const file of regularFiles) {
-      console.log(`  clank add ${relativePath(cwd, file.targetPath)}`);
-    }
-    console.log();
-  }
+  if (outsideOverlay.length > 0)
+    showOutsideOverlay(outsideOverlay, cwd, targetName);
+  if (wrongMapping.length > 0) showWrongMapping(wrongMapping, cwd, targetName);
+  if (regularFiles.length > 0) showUnadded(regularFiles, cwd, targetName);
 }
 
 /** Display orphaned paths and remediation prompt */
@@ -288,12 +278,26 @@ function showOrphanedPaths(
   orphans: OrphanedPath[],
   targetRoot: string,
   overlayRoot: string,
+  options: CheckOptions = {},
 ): void {
-  console.log(`Found ${orphans.length} orphaned overlay path(s):\n`);
-  for (const orphan of orphans) {
-    console.log(`  ${orphan.fileName} (${orphan.scope})`);
-    console.log(`    Overlay: ${orphan.overlayPath}`);
-    console.log(`    Expected dir: ${orphan.expectedTargetDir}\n`);
+  const compact = orphans.length >= compactThreshold;
+
+  if (compact) {
+    const names = orphans.map((o) => `${o.expectedTargetDir}/${o.fileName}`);
+    console.log(`Found ${orphans.length} orphaned overlay path(s):`);
+    console.log(`  ${formatInlineList(names)}\n`);
+  } else {
+    console.log(`Found ${orphans.length} orphaned overlay path(s):\n`);
+    for (const orphan of orphans) {
+      console.log(`  ${orphan.fileName} (${orphan.scope})`);
+      console.log(`    Overlay: ${orphan.overlayPath}`);
+      console.log(`    Expected dir: ${orphan.expectedTargetDir}\n`);
+    }
+  }
+
+  if (compact && !options.prompt) {
+    console.log("Run `clank status --prompt` for an agent fix prompt.");
+    return;
   }
 
   console.log("Target project:", targetRoot);
@@ -304,6 +308,85 @@ function showOrphanedPaths(
   console.log("─".repeat(50));
 }
 
+function showOutsideOverlay(
+  items: (UnaddedFile & { currentTarget: string })[],
+  cwd: string,
+  targetName: string,
+): void {
+  console.log(`Found ${items.length} stale symlink(s) in ${targetName}:\n`);
+  console.log("These symlinks point outside the clank overlay.");
+  console.log("Remove them manually, then run `clank link` to recreate:\n");
+  for (const file of items) {
+    console.log(`  rm ${relativePath(cwd, file.targetPath)}`);
+  }
+  console.log();
+}
+
+function showWrongMapping(
+  items: (UnaddedFile & { currentTarget: string })[],
+  cwd: string,
+  targetName: string,
+): void {
+  if (items.length >= compactThreshold) {
+    const names = items.map((f) => relativePath(cwd, f.targetPath));
+    console.log(
+      `Found ${items.length} mislinked symlink(s) in ${targetName} — run \`clank link\` to fix:`,
+    );
+    console.log(`  ${formatInlineList(names)}\n`);
+    return;
+  }
+  console.log(`Found ${items.length} mislinked symlink(s) in ${targetName}:\n`);
+  console.log("These symlinks point to the wrong overlay location.");
+  console.log("Run `clank link` to fix them.\n");
+  for (const file of items) {
+    console.log(`  ${relativePath(cwd, file.targetPath)}`);
+    if (file.currentTarget) {
+      console.log(`    points to: ${file.currentTarget}`);
+    }
+  }
+  console.log();
+}
+
+function showUnadded(
+  items: UnaddedFile[],
+  cwd: string,
+  targetName: string,
+): void {
+  if (items.length >= compactThreshold) {
+    const names = items.map((f) => relativePath(cwd, f.targetPath));
+    console.log(
+      `Found ${items.length} unadded file(s) in ${targetName} — run \`clank add\` to add:`,
+    );
+    console.log(`  ${formatInlineList(names)}\n`);
+    return;
+  }
+  console.log(`Found ${items.length} unadded file(s) in ${targetName}:\n`);
+  for (const file of items) {
+    console.log(`  ${relativePath(cwd, file.targetPath)}`);
+  }
+  console.log();
+  console.log("  clank add                     # add interactively");
+  console.log("  clank add <file> [<file>...]  # add specific files");
+  console.log();
+}
+
+/** Join names with spaces up to maxChars, then append "(+N more)" if truncated */
+function formatInlineList(names: string[], maxChars = 80): string {
+  const parts: string[] = [];
+  let used = 0;
+  for (let i = 0; i < names.length; i++) {
+    const next = names[i];
+    const sep = parts.length === 0 ? 0 : 1;
+    if (parts.length > 0 && used + sep + next.length > maxChars) {
+      parts.push(`(+${names.length - i} more)`);
+      break;
+    }
+    parts.push(next);
+    used += sep + next.length;
+  }
+  return parts.join(" ");
+}
+
 /** Generate agent prompt for fixing orphaned paths */
 function generateAgentPrompt(
   orphans: OrphanedPath[],

package/src/commands/Init.ts

@@ -33,6 +33,7 @@ export async function initCommand(overlayPath?: string): Promise<void> {
   await ensureDir(join(targetPath, "targets"));
 
   await createDefaultTemplates(targetPath);
+  await writeFile(join(targetPath, ".gitignore"), ".DS_Store\n", "utf-8");
 
   await createDefaultConfig(targetPath);
 

package/src/commands/Link.ts

@@ -12,14 +12,17 @@ import {
   loadConfig,
   validateOverlayExists,
 } from "../Config.ts";
+import { consolidateRulesIntoAgentFiles } from "../Consolidate.ts";
 import { addGitExcludes } from "../Exclude.ts";
 import {
   createSymlink,
   ensureDir,
   fileExists,
+  getCwd,
   getLinkTarget,
   isSymlink,
-  isTrackedByGit,
+  isTrackedRealFile,
+  toSlash,
 } from "../FsUtil.ts";
 import { type GitContext, getGitContext } from "../Git.ts";
 import {
@@ -64,7 +67,7 @@ interface SeparatedMappings {
 
 /** Link overlay repository to target directory */
 export async function linkCommand(targetDir?: string): Promise<void> {
-  const gitContext = await getGitContext(targetDir || process.cwd());
+  const gitContext = await getGitContext(targetDir || (await getCwd()));
   const targetRoot = gitContext.gitRoot;
   console.log(`Linking clank overlay to: ${targetRoot}\n`);
   logGitContext(gitContext);
@@ -73,21 +76,7 @@ export async function linkCommand(targetDir?: string): Promise<void> {
   const overlayRoot = expandPath(config.overlayRepo);
   await validateOverlayExists(overlayRoot);
 
-  // Clean up symlinks pointing to wrong worktree before linking
-  const staleRemoved = await cleanStaleWorktreeSymlinks(
-    targetRoot,
-    overlayRoot,
-    gitContext,
-  );
-  if (staleRemoved.length > 0) {
-    console.log(`\nCleaned ${staleRemoved.length} stale worktree symlink(s):`);
-    for (const path of staleRemoved) {
-      console.log(`  ${path}`);
-    }
-  }
-
-  // Check for problematic agent files before proceeding
-  await checkAgentFiles(targetRoot, overlayRoot);
+  await cleanStaleAndCheck(targetRoot, overlayRoot, gitContext);
 
   await ensureDir(join(overlayRoot, "targets", gitContext.projectName));
   await maybeInitWorktree(overlayRoot, gitContext);
@@ -102,6 +91,8 @@ export async function linkCommand(targetDir?: string): Promise<void> {
   await createAgentLinks(agentsMappings, targetRoot, config.agents);
   await createPromptLinks(promptsMappings, targetRoot);
 
+  await maybeConsolidateRules(overlayRoot, targetRoot, gitContext, config);
+
   await setupProjectSettings(overlayRoot, gitContext, targetRoot);
   await addGitExcludes(targetRoot);
   await maybeGenerateVscodeSettings(config, targetRoot);
@@ -119,15 +110,27 @@ function logGitContext(ctx: GitContext): void {
   console.log(`Branch: ${ctx.worktreeName}${suffix}`);
 }
 
-/** Check for problematic agent files and error if found */
-async function checkAgentFiles(
+/** Clean stale worktree symlinks and check for problematic agent files */
+async function cleanStaleAndCheck(
   targetRoot: string,
   overlayRoot: string,
+  gitContext: GitContext,
 ): Promise<void> {
-  const classification = await classifyAgentFiles(targetRoot, overlayRoot);
+  const staleRemoved = await cleanStaleWorktreeSymlinks(
+    targetRoot,
+    overlayRoot,
+    gitContext,
+  );
+  if (staleRemoved.length > 0) {
+    console.log(`\nCleaned ${staleRemoved.length} stale worktree symlink(s):`);
+    for (const path of staleRemoved) {
+      console.log(`  ${path}`);
+    }
+  }
 
+  const classification = await classifyAgentFiles(targetRoot, overlayRoot);
   if (agentFileProblems(classification)) {
-    throw new Error(formatAgentFileProblems(classification, process.cwd()));
+    throw new Error(formatAgentFileProblems(classification, await getCwd()));
   }
 }
 
@@ -160,7 +163,7 @@ async function collectMappings(
   const isAgent = ({ targetPath }: FileMapping) =>
     basename(targetPath) === "agents.md";
   const isPrompt = ({ targetPath }: FileMapping) =>
-    targetPath.includes("/.claude/prompts/");
+    toSlash(targetPath).includes("/.claude/prompts/");
 
   const agentsMappings = mappings.filter(isAgent);
   const promptsMappings = mappings.filter((m) => !isAgent(m) && isPrompt(m));
@@ -234,7 +237,7 @@ async function createAgentLinks(
   }
 }
 
-/** Create prompt symlinks in all agent directories (.claude/prompts/, .gemini/prompts/) */
+/** Create prompt symlinks in all agent directories (.claude/prompts/, .gemini/prompts/, .codex/prompts/) */
 async function createPromptLinks(
   promptsMappings: FileMapping[],
   targetRoot: string,
@@ -254,6 +257,27 @@ async function createPromptLinks(
   }
 }
 
+/** Consolidate rules into generated AGENTS.md/GEMINI.md if rules exist */
+async function maybeConsolidateRules(
+  overlayRoot: string,
+  targetRoot: string,
+  gitContext: GitContext,
+  config: ClankConfig,
+): Promise<void> {
+  const consolidated = await consolidateRulesIntoAgentFiles({
+    overlayRoot,
+    targetRoot,
+    gitContext,
+    agents: config.agents,
+  });
+  if (consolidated.length > 0) {
+    console.log(`\nGenerated consolidated agent files:`);
+    for (const name of consolidated) {
+      console.log(`  ${name}`);
+    }
+  }
+}
+
 /** Setup project settings.json - adopt existing or create new */
 async function setupProjectSettings(
   overlayRoot: string,
@@ -408,7 +432,7 @@ async function processAgentMapping(
   const skipped: string[] = [];
 
   await forEachAgentPath(targetDir, agents, async (agentPath) => {
-    if (await isTrackedFile(agentPath, targetRoot)) {
+    if (await isTrackedRealFile(agentPath, targetRoot)) {
       skipped.push(relative(targetRoot, agentPath));
     } else {
       const linkTarget = getLinkTarget(agentPath, overlayPath);
@@ -459,7 +483,7 @@ async function checkMappingParentExists(
   m: FileMapping,
   targetRoot: string,
 ): Promise<FileMapping | null> {
-  const relPath = relative(targetRoot, m.targetPath);
+  const relPath = toSlash(relative(targetRoot, m.targetPath));
   // Subdirectory clank files have /clank/ in the middle of the path
   const clankIndex = relPath.indexOf("/clank/");
   if (clankIndex !== -1) {
@@ -471,10 +495,3 @@ async function checkMappingParentExists(
   }
   return m;
 }
-
-/** Check if a file is tracked in git (exists as real file, not symlink, and tracked) */
-async function isTrackedFile(path: string, gitRoot: string): Promise<boolean> {
-  if (!(await fileExists(path))) return false;
-  if (await isSymlink(path)) return false;
-  return isTrackedByGit(path, gitRoot);
-}

package/src/commands/Move.ts

@@ -6,6 +6,7 @@ import {
   createSymlink,
   ensureDir,
   fileExists,
+  getCwd,
   getLinkTarget,
 } from "../FsUtil.ts";
 import { getGitContext } from "../Git.ts";
@@ -37,7 +38,7 @@ export async function moveCommand(
   options: MoveOptions,
 ): Promise<void> {
   const hasScope = options.global || options.project || options.worktree;
-  const cwd = process.cwd();
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const config = await loadConfig();
   const overlayRoot = expandPath(config.overlayRepo);

package/src/commands/Rm.ts

@@ -2,7 +2,7 @@ import { rm, unlink } from "node:fs/promises";
 import { basename, dirname, relative } from "node:path";
 import { forEachAgentPath } from "../AgentFiles.ts";
 import { expandPath, loadConfig, validateOverlayExists } from "../Config.ts";
-import { fileExists } from "../FsUtil.ts";
+import { fileExists, getCwd } from "../FsUtil.ts";
 import { getGitContext } from "../Git.ts";
 import {
   isAgentFile,
@@ -23,7 +23,7 @@ export async function rmCommand(
   filePaths: string[],
   options: RmOptions = {},
 ): Promise<void> {
-  const cwd = process.cwd();
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const config = await loadConfig();
   const overlayRoot = expandPath(config.overlayRepo);

package/src/commands/Unlink.ts

@@ -1,13 +1,14 @@
 import { expandPath, loadConfig } from "../Config.ts";
+import { removeGeneratedAgentFiles } from "../Consolidate.ts";
 import { removeGitExcludes } from "../Exclude.ts";
-import { fileExists, removeSymlink, walkDirectory } from "../FsUtil.ts";
+import { fileExists, getCwd, removeSymlink, walkDirectory } from "../FsUtil.ts";
 import { getGitContext } from "../Git.ts";
 import { isSymlinkToOverlay } from "../OverlayLinks.ts";
 import { removeVscodeSettings } from "./VsCode.ts";
 
 /** Remove all symlinks pointing to overlay repository */
 export async function unlinkCommand(targetDir?: string): Promise<void> {
-  const gitContext = await getGitContext(targetDir || process.cwd());
+  const gitContext = await getGitContext(targetDir || (await getCwd()));
   const targetRoot = gitContext.gitRoot;
 
   console.log(`Removing clank symlinks from: ${targetRoot}\n`);
@@ -34,6 +35,10 @@ export async function unlinkCommand(targetDir?: string): Promise<void> {
     }
   }
 
+  // Remove generated agent files (from rules consolidation)
+  const generatedRemoved = await removeGeneratedAgentFiles(targetRoot);
+  removedCount += generatedRemoved.length;
+
   await removeGitExcludes(targetRoot);
   await removeVscodeSettings(targetRoot);
 

package/src/commands/VsCode.ts

@@ -5,6 +5,7 @@ import { addToGitExclude } from "../Exclude.ts";
 import {
   ensureDir,
   fileExists,
+  getCwd,
   isTrackedByGit,
   writeJsonFile,
 } from "../FsUtil.ts";
@@ -109,7 +110,7 @@ export async function checkVscodeTracking(
 
 /** Generate VS Code settings to show clank files in search and explorer */
 export async function vscodeCommand(options?: VscodeOptions): Promise<void> {
-  const targetRoot = await detectGitRoot(process.cwd());
+  const targetRoot = await detectGitRoot(await getCwd());
 
   if (options?.remove) {
     await removeVscodeSettings(targetRoot);

package/src/commands/files/Dedupe.ts

@@ -1,4 +1,4 @@
-import { dirname } from "node:path";
+import { basename, dirname } from "node:path";
 import { agentFiles } from "../../AgentFiles.ts";
 import { getPromptRelPath } from "../../Mapper.ts";
 import { partition } from "../../Util.ts";
@@ -15,9 +15,9 @@ export function dedupeEntries(
 
 /** Check if a relative path ends with an agent filename (CLAUDE.md, etc.) */
 export function isAgentFilePath(relPath: string): boolean {
-  const base = relPath.split("/").at(-1)?.toLowerCase();
-  if (!base) return false;
-  return agentFiles.some((f) => f.toLowerCase() === base);
+  return agentFiles.some(
+    (f) => f.toLowerCase() === basename(relPath).toLowerCase(),
+  );
 }
 
 /** Keep at most one agent file per directory, using the configured preference order. */
@@ -129,6 +129,5 @@ function mapPreference(
 }
 
 function basenameUpper(relPath: string): string {
-  const base = relPath.split("/").at(-1) ?? "";
-  return base.toUpperCase();
+  return basename(relPath).toUpperCase();
 }