clank-cli 0.1.61 → 0.1.65

package/README.md

@@ -84,6 +84,9 @@ clank link ~/my-project # Link to specific project
 
 Move a file to the overlay and replace it with a symlink. If the file doesn't exist, an empty file is created. Accepts [scope options](#scope-options).
 
+**Options:**
+- `-i, --interactive` - Interactively add all unadded files, prompting for scope on each
+
 **Examples:**
 ```bash
 clank add style.md                            # Project scope (default)
@@ -92,6 +95,24 @@ clank add notes.md --worktree                 # Worktree scope
 clank add .claude/commands/review.md --global # Global command
 clank add .claude/commands/build.md           # Project command (default)
 clank add CLAUDE.md                           # Creates agents.md + agent symlinks
+clank add -i                                  # Interactive mode for all unadded files
+```
+
+**Interactive mode:**
+
+Running `clank add --interactive` finds all unadded files and prompts for each:
+
+```
+Found 3 unadded file(s):
+
+[1/3] clank/notes.md
+      (P)roject  (W)orktree  (G)lobal  (S)kip  (Q)uit  [P]:
+```
+
+Press a single key to select the scope (default: Project). The summary shows what was added:
+
+```
+Added 2 to project, 1 skipped
 ```
 
 ### `clank unlink [target]`
@@ -173,10 +194,13 @@ clank rm style.md --global         # Remove global style guide
 
 ### `clank mv <files...>` (alias: `move`)
 
-Move file(s) between overlay scopes. Requires one [scope option](#scope-options) to specify the destination.
+Move or rename file(s) in the overlay. With a [scope option](#scope-options), moves files to that scope. With two arguments and no scope, renames within the current scope.
 
-**Example:**
+**Examples:**
 ```bash
+# Rename a file (keeps same scope)
+clank mv batch-dry-check.md batch-dry.md
+
 # Promote a worktree note to project scope
 clank mv clank/notes.md --project
 
@@ -205,7 +229,7 @@ clank help structure
 
 ### `--config <path>` (global option)
 
-Specify a custom config file location (default `~/.config/clank/config.js`).
+Specify a custom config file location (default `~/.config/clank/clank.config.js`).
 
 ```bash
 clank --config /tmp/test-config.js init /tmp/test-overlay
@@ -243,7 +267,7 @@ clank/
 
 ## Configuration
 
-Global configuration is stored by default in `~/.config/clank/config.js`:
+Global configuration is stored in `~/.config/clank/clank.config.js`:
 
 ```javascript
 export default {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clank-cli",
   "description": "Keep AI files in a separate overlay repository",
-  "version": "0.1.61",
+  "version": "0.1.65",
   "author": "",
   "type": "module",
   "bin": {
@@ -46,10 +46,11 @@
   },
   "scripts": {
     "bump": "monobump",
-    "fix": "biome check --fix --unsafe",
+    "fix": "biome check --fix --unsafe --error-on-warnings",
     "fix:pkgJsonFormat": "syncpack format",
     "global": "pnpm link --global",
     "lint": "biome check --error-on-warnings",
+    "prepush": "run-s fix typecheck fix:pkgJsonFormat test:once",
     "test": "vitest",
     "test:once": "vitest run",
     "test:ui": "vitest --ui",

package/src/AgentFiles.ts

@@ -32,8 +32,7 @@ export async function forEachAgentPath(
 ): Promise<void> {
   const agentPaths = getAgentFilePaths(dir);
   for (const agent of agents) {
-    const key = agent.toLowerCase();
-    const agentPath = agentPaths[key];
+    const agentPath = agentPaths[agent.toLowerCase()];
     if (!agentPath) continue;
     await fn(agentPath, agent);
   }

package/src/ClassifyFiles.ts

@@ -25,8 +25,6 @@ export interface AgentFileClassification {
   outdatedSymlinks: OutdatedSymlink[];
 }
 
-type PartialClassification = Partial<AgentFileClassification>;
-
 export interface OutdatedSymlink {
   /** Path to the symlink in the target */
   symlinkPath: string;
@@ -38,6 +36,8 @@ export interface OutdatedSymlink {
   expectedTarget: string;
 }
 
+type PartialClassification = Partial<AgentFileClassification>;
+
 /** Find all agent files in the repository and classify them.
  * Returns absolute paths in the classification.
  */
@@ -61,14 +61,10 @@ export async function classifyAgentFiles(
 }
 
 /** @return true if classification has any problems */
-export function agentFileProblems(
-  classification: AgentFileClassification,
-): boolean {
-  return (
-    classification.tracked.length > 0 ||
-    classification.untracked.length > 0 ||
-    classification.staleSymlinks.length > 0 ||
-    classification.outdatedSymlinks.length > 0
+export function agentFileProblems(c: AgentFileClassification): boolean {
+  const { tracked, untracked, staleSymlinks, outdatedSymlinks } = c;
+  return [tracked, untracked, staleSymlinks, outdatedSymlinks].some(
+    (a) => a.length > 0,
   );
 }
 
@@ -110,10 +106,12 @@ ${commands.join("\n")}`);
   }
 
   if (classified.outdatedSymlinks.length > 0) {
-    const details = classified.outdatedSymlinks.map((s) => {
-      const symlinkRel = rel(s.symlinkPath);
-      return `  ${symlinkRel}\n    points to: ${s.currentTarget}\n    expected:  ${s.expectedTarget}`;
-    });
+    const details = classified.outdatedSymlinks.map(
+      (s) =>
+        `  ${rel(s.symlinkPath)}\n` +
+        `    points to: ${s.currentTarget}\n` +
+        `    expected:  ${s.expectedTarget}`,
+    );
     sections.push(`Found outdated agent symlinks (pointing to wrong overlay path).
 
 This typically happens after a directory rename. Remove symlinks and run \`clank link\`:
@@ -127,6 +125,21 @@ To fix:
   return sections.join("\n\n");
 }
 
+/** Find all agent files in the repository */
+async function findAllAgentFiles(targetRoot: string): Promise<string[]> {
+  const files: string[] = [];
+  const agentFileSet = new Set(agentFiles);
+
+  for await (const { path, isDirectory } of walkDirectory(targetRoot)) {
+    if (isDirectory) continue;
+    if (agentFileSet.has(basename(path))) {
+      files.push(path);
+    }
+  }
+
+  return files;
+}
+
 /** Classify a single agent file */
 async function classifySingleAgentFile(
   filePath: string,
@@ -146,6 +159,18 @@ async function classifySingleAgentFile(
   return {};
 }
 
+/** Merge sparse classifications into a complete classification with arrays */
+function mergeClassifications(
+  items: PartialClassification[],
+): AgentFileClassification {
+  return {
+    tracked: items.flatMap((i) => i.tracked ?? []),
+    untracked: items.flatMap((i) => i.untracked ?? []),
+    staleSymlinks: items.flatMap((i) => i.staleSymlinks ?? []),
+    outdatedSymlinks: items.flatMap((i) => i.outdatedSymlinks ?? []),
+  };
+}
+
 /** Classify an agent symlink - check if stale or outdated */
 async function classifyAgentSymlink(
   filePath: string,
@@ -165,44 +190,14 @@ async function classifyAgentSymlink(
     const agentsMdPath = join(dirname(filePath), "agents.md");
     const expectedTarget = targetToOverlay(agentsMdPath, "project", mapperCtx);
     if (absoluteTarget !== expectedTarget) {
-      return {
-        outdatedSymlinks: [
-          {
-            symlinkPath: filePath,
-            currentTarget: absoluteTarget,
-            expectedTarget,
-          },
-        ],
+      const symlink = {
+        symlinkPath: filePath,
+        currentTarget: absoluteTarget,
+        expectedTarget,
       };
+      return { outdatedSymlinks: [symlink] };
     }
   }
 
   return {};
 }
-
-/** Merge sparse classifications into a complete classification with arrays */
-function mergeClassifications(
-  items: PartialClassification[],
-): AgentFileClassification {
-  return {
-    tracked: items.flatMap((i) => i.tracked ?? []),
-    untracked: items.flatMap((i) => i.untracked ?? []),
-    staleSymlinks: items.flatMap((i) => i.staleSymlinks ?? []),
-    outdatedSymlinks: items.flatMap((i) => i.outdatedSymlinks ?? []),
-  };
-}
-
-/** Find all agent files in the repository */
-async function findAllAgentFiles(targetRoot: string): Promise<string[]> {
-  const files: string[] = [];
-  const agentFileSet = new Set(agentFiles);
-
-  for await (const { path, isDirectory } of walkDirectory(targetRoot)) {
-    if (isDirectory) continue;
-    if (agentFileSet.has(basename(path))) {
-      files.push(path);
-    }
-  }
-
-  return files;
-}

package/src/Cli.ts

@@ -93,6 +93,24 @@ function registerCoreCommands(program: Command): void {
   registerUtilityCommands(program);
 }
 
+function registerHelpCommands(program: Command): void {
+  const help = program
+    .command("help")
+    .description("Show help information")
+    .argument("[command]", "Command to show help for")
+    .action((commandName?: string) => {
+      if (!commandName) return program.help();
+      const subcommand = program.commands.find((c) => c.name() === commandName);
+      if (subcommand) return subcommand.help();
+      console.error(`Unknown command: ${commandName}`);
+      process.exit(1);
+    });
+  help
+    .command("structure")
+    .description("Show overlay directory structure")
+    .action(() => console.log(structureHelp));
+}
+
 function registerOverlayCommands(program: Command): void {
   program
     .command("init")
@@ -115,9 +133,10 @@ function registerOverlayCommands(program: Command): void {
     .command("add")
     .description("Add file(s) to overlay and create symlinks")
     .argument(
-      "<files...>",
+      "[files...]",
       "File path(s) (e.g., style.md, .claude/commands/review.md)",
     )
+    .option("-i, --interactive", "Interactively add all unadded files")
     .option("-g, --global", "Add to global location (all projects)")
     .option("-p, --project", "Add to project location (default)")
     .option("-w, --worktree", "Add to worktree location (this branch only)")
@@ -155,9 +174,63 @@ function registerUtilityCommands(program: Command): void {
     .action(withErrorHandling(vscodeCommand));
 }
 
+function withErrorHandling<T extends unknown[]>(
+  fn: (...args: T) => Promise<void>,
+): (...args: T) => Promise<void> {
+  return async (...args: T) => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  };
+}
+
+function registerRmCommand(program: Command): void {
+  program
+    .command("rm")
+    .alias("remove")
+    .description("Remove file(s) from overlay and target")
+    .argument("<files...>", "File(s) to remove")
+    .option("-g, --global", "Remove from global scope")
+    .option("-p, --project", "Remove from project scope")
+    .option("-w, --worktree", "Remove from worktree scope")
+    .action(withErrorHandling(rmCommand));
+}
+
+function registerMvCommand(program: Command): void {
+  const cmd = program
+    .command("mv")
+    .alias("move")
+    .description("Move or rename file(s) in overlay")
+    .argument("<files...>", "File(s) to move");
+
+  cmd.addOption(
+    new Option("-g, --global", "Move to global scope").conflicts([
+      "project",
+      "worktree",
+    ]),
+  );
+  cmd.addOption(
+    new Option("-p, --project", "Move to project scope").conflicts([
+      "global",
+      "worktree",
+    ]),
+  );
+  cmd.addOption(
+    new Option("-w, --worktree", "Move to worktree scope").conflicts([
+      "global",
+      "project",
+    ]),
+  );
+  cmd.action(withErrorHandling(moveCommand));
+}
+
 function registerFilesCommand(program: Command): void {
   const files = program
     .command("files")
+    .alias("list")
     .description("List clank-managed files (paths relative to cwd)")
     .argument(
       "[path]",
@@ -201,74 +274,3 @@ function registerFilesCommand(program: Command): void {
 
   files.action(withErrorHandling(filesCommand));
 }
-
-function registerHelpCommands(program: Command): void {
-  const help = program
-    .command("help")
-    .description("Show help information")
-    .argument("[command]", "Command to show help for")
-    .action((commandName?: string) => {
-      if (!commandName) return program.help();
-      const subcommand = program.commands.find((c) => c.name() === commandName);
-      if (subcommand) return subcommand.help();
-      console.error(`Unknown command: ${commandName}`);
-      process.exit(1);
-    });
-  help
-    .command("structure")
-    .description("Show overlay directory structure")
-    .action(() => console.log(structureHelp));
-}
-
-function registerRmCommand(program: Command): void {
-  program
-    .command("rm")
-    .alias("remove")
-    .description("Remove file(s) from overlay and target")
-    .argument("<files...>", "File(s) to remove")
-    .option("-g, --global", "Remove from global scope")
-    .option("-p, --project", "Remove from project scope")
-    .option("-w, --worktree", "Remove from worktree scope")
-    .action(withErrorHandling(rmCommand));
-}
-
-function registerMvCommand(program: Command): void {
-  const cmd = program
-    .command("mv")
-    .alias("move")
-    .description("Move file(s) between overlay scopes")
-    .argument("<files...>", "File(s) to move");
-
-  cmd.addOption(
-    new Option("-g, --global", "Move to global scope").conflicts([
-      "project",
-      "worktree",
-    ]),
-  );
-  cmd.addOption(
-    new Option("-p, --project", "Move to project scope").conflicts([
-      "global",
-      "worktree",
-    ]),
-  );
-  cmd.addOption(
-    new Option("-w, --worktree", "Move to worktree scope").conflicts([
-      "global",
-      "project",
-    ]),
-  );
-  cmd.action(withErrorHandling(moveCommand));
-}
-
-function withErrorHandling<T extends unknown[]>(
-  fn: (...args: T) => Promise<void>,
-): (...args: T) => Promise<void> {
-  return async (...args: T) => {
-    try {
-      await fn(...args);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : error);
-      process.exit(1);
-    }
-  };
-}

package/src/Config.ts

@@ -4,8 +4,6 @@ import { join } from "node:path";
 import { cosmiconfig } from "cosmiconfig";
 import { fileExists } from "./FsUtil.ts";
 
-export const defaultOverlayDir = "clankover";
-
 export interface ClankConfig {
   overlayRepo: string;
   agents: string[];
@@ -17,6 +15,8 @@ export interface ClankConfig {
   ignore?: string[];
 }
 
+export const defaultOverlayDir = "clankover";
+
 const defaultConfig: ClankConfig = {
   overlayRepo: join(homedir(), defaultOverlayDir),
   agents: ["agents", "claude", "gemini"],
@@ -30,14 +30,11 @@ export function setConfigPath(path: string | undefined): void {
   customConfigPath = path;
 }
 
-/** Load global clank configuration from ~/.config/clank/config.js or similar */
+/** Load global clank configuration from ~/.config/clank/clank.config.js or similar */
 export async function loadConfig(): Promise<ClankConfig> {
   if (customConfigPath) {
     const result = await explorer.load(customConfigPath);
-    if (!result) {
-      throw new Error(`Config file not found: ${customConfigPath}`);
-    }
-    if (result.isEmpty) {
+    if (!result || result.isEmpty) {
       return defaultConfig;
     }
     return { ...defaultConfig, ...result.config };
@@ -50,10 +47,10 @@ export async function loadConfig(): Promise<ClankConfig> {
   return { ...defaultConfig, ...result.config };
 }
 
-/** Create default configuration file at ~/.config/clank/config.js */
+/** Create default configuration file at ~/.config/clank/clank.config.js */
 export async function createDefaultConfig(overlayRepo?: string): Promise<void> {
   const configDir = getConfigDir();
-  const configPath = customConfigPath || join(configDir, "config.js");
+  const configPath = customConfigPath || join(configDir, "clank.config.js");
 
   const config = {
     ...defaultConfig,
@@ -84,12 +81,6 @@ export async function getOverlayPath(): Promise<string> {
   return expandPath(config.overlayRepo);
 }
 
-/** Get the XDG config directory (respects XDG_CONFIG_HOME, defaults to ~/.config/clank) */
-function getConfigDir(): string {
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-  return join(xdgConfig, "clank");
-}
-
 /** Validate overlay repository exists, throw if not */
 export async function validateOverlayExists(
   overlayRoot: string,
@@ -100,3 +91,9 @@ export async function validateOverlayExists(
     );
   }
 }
+
+/** Get the XDG config directory (respects XDG_CONFIG_HOME, defaults to ~/.config/clank) */
+function getConfigDir(): string {
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(xdgConfig, "clank");
+}

package/src/Exclude.ts

@@ -102,15 +102,6 @@ export async function removeGitExcludes(targetRoot: string): Promise<void> {
   console.log("Removed clank entries from .git/info/exclude");
 }
 
-/** Remove the clank section from exclude file content */
-function removeClankSection(content: string): string {
-  const pattern = new RegExp(
-    `\\n*${clankMarkerStart}[\\s\\S]*?${clankMarkerEnd}\\n*`,
-    "g",
-  );
-  return content.replace(pattern, "\n");
-}
-
 /** Filter out clank section from lines */
 export function filterClankLines(lines: string[]): string[] {
   const result: string[] = [];
@@ -129,6 +120,15 @@ export function filterClankLines(lines: string[]): string[] {
   return result;
 }
 
+/** Remove the clank section from exclude file content */
+function removeClankSection(content: string): string {
+  const pattern = new RegExp(
+    `\\n*${clankMarkerStart}[\\s\\S]*?${clankMarkerEnd}\\n*`,
+    "g",
+  );
+  return content.replace(pattern, "\n");
+}
+
 /** Check if a directory has any tracked files */
 async function hasTrackedFiles(
   dirPath: string,

package/src/Git.ts

@@ -115,16 +115,6 @@ export function parseRepoName(url: string): string | null {
   return basename(normalizedUrl);
 }
 
-/** Execute a git command and return stdout, or null if it fails */
-async function gitCommand(args: string, cwd?: string): Promise<string | null> {
-  try {
-    const { stdout } = await exec(`git ${args}`, { cwd });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-
 /** Get the .git directory for the current worktree */
 export async function getGitDir(cwd: string): Promise<string | null> {
   const gitDir = await gitCommand("rev-parse --git-dir", cwd);
@@ -138,3 +128,13 @@ export async function getGitCommonDir(cwd: string): Promise<string | null> {
   if (!gitDir) return null;
   return isAbsolute(gitDir) ? gitDir : join(cwd, gitDir);
 }
+
+/** Execute a git command and return stdout, or null if it fails */
+async function gitCommand(args: string, cwd?: string): Promise<string | null> {
+  try {
+    const { stdout } = await exec(`git ${args}`, { cwd });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}

package/src/Gitignore.ts

@@ -99,24 +99,16 @@ export function isClankPattern(glob: string): boolean {
   const normalized = glob.replace(/^\*\*\//, "").replace(/\/$/, "");
 
   // Check against managed directories
-  for (const dir of targetManagedDirs) {
-    if (
-      normalized === dir ||
-      normalized.startsWith(`${dir}/`) ||
-      normalized.endsWith(`/${dir}`)
-    ) {
-      return true;
-    }
-  }
+  const matchesDir = (dir: string) =>
+    normalized === dir ||
+    normalized.startsWith(`${dir}/`) ||
+    normalized.endsWith(`/${dir}`);
+  if (targetManagedDirs.some(matchesDir)) return true;
 
   // Check against agent files
-  for (const agentFile of agentFiles) {
-    if (normalized === agentFile || normalized.endsWith(`/${agentFile}`)) {
-      return true;
-    }
-  }
-
-  return false;
+  const matchesAgent = (f: string) =>
+    normalized === f || normalized.endsWith(`/${f}`);
+  return agentFiles.some(matchesAgent);
 }
 
 /** Convert collected patterns to VS Code exclude globs, filtering clank patterns */
@@ -143,14 +135,11 @@ export function deduplicateGlobs(globs: string[]): string[] {
   const coveredSuffixes = new Set(universal.map((g) => g.slice(3)));
 
   // Keep specific patterns not covered by a universal pattern
-  const uncovered = specific.filter((glob) => {
-    for (const suffix of coveredSuffixes) {
-      if (glob.endsWith(`/**/${suffix}`) || glob.endsWith(`/${suffix}`)) {
-        return false;
-      }
-    }
-    return true;
-  });
+  const isCovered = (glob: string) =>
+    [...coveredSuffixes].some(
+      (s) => glob.endsWith(`/**/${s}`) || glob.endsWith(`/${s}`),
+    );
+  const uncovered = specific.filter((glob) => !isCovered(glob));
 
   return [...universal, ...uncovered];
 }
@@ -169,22 +158,19 @@ async function parseGitignoreFile(
   result.negationWarnings.push(...parsed.negationWarnings);
 }
 
-/** Parse a single gitignore line */
-function parseLine(
-  trimmed: string,
-  source: string,
-  basePath: string,
-): { pattern?: GitignorePattern; negation?: string } {
-  // Skip empty lines and comments
-  if (!trimmed || trimmed.startsWith("#")) return {};
-
-  const isNegation = trimmed.startsWith("!");
-  const pattern = isNegation ? trimmed.slice(1) : trimmed;
+/** Find all nested .gitignore files (excluding root) */
+async function findNestedGitignores(targetRoot: string): Promise<string[]> {
+  const gitignores: string[] = [];
+  const rootGitignore = join(targetRoot, ".gitignore");
 
-  if (isNegation) {
-    return { negation: pattern };
+  for await (const { path, isDirectory } of walkDirectory(targetRoot)) {
+    if (isDirectory) continue;
+    if (basename(path) === ".gitignore" && path !== rootGitignore) {
+      gitignores.push(path);
+    }
   }
-  return { pattern: { pattern, basePath, negation: false, source } };
+
+  return gitignores;
 }
 
 /** Parse gitignore file content into patterns */
@@ -211,17 +197,20 @@ function parseGitignoreContent(
   return { patterns, negationWarnings };
 }
 
-/** Find all nested .gitignore files (excluding root) */
-async function findNestedGitignores(targetRoot: string): Promise<string[]> {
-  const gitignores: string[] = [];
-  const rootGitignore = join(targetRoot, ".gitignore");
+/** Parse a single gitignore line */
+function parseLine(
+  trimmed: string,
+  source: string,
+  basePath: string,
+): { pattern?: GitignorePattern; negation?: string } {
+  // Skip empty lines and comments
+  if (!trimmed || trimmed.startsWith("#")) return {};
 
-  for await (const { path, isDirectory } of walkDirectory(targetRoot)) {
-    if (isDirectory) continue;
-    if (basename(path) === ".gitignore" && path !== rootGitignore) {
-      gitignores.push(path);
-    }
-  }
+  const isNegation = trimmed.startsWith("!");
+  const pattern = isNegation ? trimmed.slice(1) : trimmed;
 
-  return gitignores;
+  if (isNegation) {
+    return { negation: pattern };
+  }
+  return { pattern: { pattern, basePath, negation: false, source } };
 }