clank-cli 0.1.67 → 0.1.74

package/src/commands/Add.ts

@@ -8,14 +8,16 @@ import {
 import { basename, dirname, join, relative } from "node:path";
 import * as readline from "node:readline";
 import { forEachAgentPath } from "../AgentFiles.ts";
+import { classifyAgentFiles } from "../ClassifyFiles.ts";
 import { expandPath, loadConfig, validateOverlayExists } from "../Config.ts";
 import {
   createSymlink,
   ensureDir,
   fileExists,
+  getCwd,
   getLinkTarget,
   isSymlink,
-  isTrackedByGit,
+  isTrackedRealFile,
   walkDirectory,
 } from "../FsUtil.ts";
 import { type GitContext, getGitContext } from "../Git.ts";
@@ -46,7 +48,6 @@ interface AddContext {
   overlayRoot: string;
 }
 
-/** Create agent symlinks (CLAUDE.md, GEMINI.md, AGENTS.md → agents.md) */
 interface AgentLinkParams {
   overlayPath: string;
   symlinkDir: string;
@@ -70,6 +71,17 @@ type ScopeCounts = {
   skip: number;
 };
 
+interface CreateSymlinksParams {
+  filePath: string;
+  normalizedPath: string;
+  overlayPath: string;
+  config: { agents: string[] };
+  gitRoot: string;
+  overlayRoot: string;
+  cwd: string;
+  quiet?: boolean;
+}
+
 const scopeLabels: Record<Scope, string> = {
   global: "global",
   project: "project",
@@ -81,7 +93,7 @@ export async function addCommand(
   filePaths: string[],
   options: AddOptions = {},
 ): Promise<void> {
-  const cwd = process.cwd();
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const config = await loadConfig();
   const overlayRoot = expandPath(config.overlayRepo);
@@ -90,17 +102,11 @@ export async function addCommand(
 
   const ctx = { cwd, gitContext, config, overlayRoot };
 
-  if (options.interactive) {
+  if (options.interactive || filePaths.length === 0) {
     await addAllInteractive(ctx);
     return;
   }
 
-  if (filePaths.length === 0) {
-    throw new Error(
-      "No files specified. Use --interactive for interactive mode.",
-    );
-  }
-
   for (const filePath of filePaths) {
     const inputPath = join(cwd, filePath);
 
@@ -135,28 +141,40 @@ async function validateAddOptions(
 /** Interactive mode: add all unadded files with per-file scope selection */
 async function addAllInteractive(ctx: AddContext): Promise<void> {
   const { cwd, gitContext, overlayRoot } = ctx;
-  const context: MapperContext = {
-    overlayRoot,
-    targetRoot: gitContext.gitRoot,
-    gitContext,
-  };
+  const { gitRoot: targetRoot } = gitContext;
+  const context: MapperContext = { overlayRoot, targetRoot, gitContext };
 
   const unadded = await findUnaddedFiles(context);
   const regularFiles = unadded.filter((f) => f.kind === "unadded");
 
-  if (regularFiles.length === 0) {
+  // Also find untracked agent files outside managed dirs (e.g. packages/foo/CLAUDE.md)
+  const agentClassification = await classifyAgentFiles(
+    targetRoot,
+    overlayRoot,
+    gitContext,
+  );
+  const regularPaths = new Set(regularFiles.map((f) => f.targetPath));
+  const extraAgentPaths = agentClassification.untracked.filter(
+    (p) => !regularPaths.has(p),
+  );
+
+  const allPaths = [
+    ...regularFiles.map((f) => f.targetPath),
+    ...extraAgentPaths,
+  ];
+
+  if (allPaths.length === 0) {
     console.log("No unadded files found.");
     return;
   }
 
-  console.log(`Found ${regularFiles.length} unadded file(s):\n`);
+  console.log(`Found ${allPaths.length} unadded file(s):\n`);
 
   const counts: ScopeCounts = { project: 0, worktree: 0, global: 0, skip: 0 };
 
-  for (let i = 0; i < regularFiles.length; i++) {
-    const file = regularFiles[i];
-    const relPath = relative(cwd, file.targetPath);
-    const result = await promptAndAddFile(relPath, i, regularFiles.length, ctx);
+  for (let i = 0; i < allPaths.length; i++) {
+    const relPath = relative(cwd, allPaths[i]);
+    const result = await promptAndAddFile(relPath, i, allPaths.length, ctx);
     if (result === "quit") break;
     if (result !== "error") counts[result]++;
   }
@@ -183,7 +201,6 @@ async function addSingleFile(
   const { quiet } = options;
 
   const scope = resolveScopeFromOptions(options);
-  /** Absolute path where symlink will be created in target repo */
   const normalizedPath = normalizeAddPath(filePath, cwd, gitRoot);
   const context: MapperContext = {
     overlayRoot,
@@ -199,7 +216,6 @@ async function addSingleFile(
   // Only check barePath for symlink - we want the user's input file, not clank/foo.md
   const barePath = join(cwd, filePath);
 
-  // Check if already in overlay at a different scope
   await checkScopeConflict(barePath, scope, context, cwd);
 
   if (await fileExists(overlayPath)) {
@@ -229,53 +245,6 @@ async function addSingleFile(
   });
 }
 
-interface CreateSymlinksParams {
-  filePath: string;
-  normalizedPath: string;
-  overlayPath: string;
-  config: { agents: string[] };
-  gitRoot: string;
-  overlayRoot: string;
-  cwd: string;
-  quiet?: boolean;
-}
-
-/** Create symlinks based on file type (agent, prompt, or regular) */
-async function createSymlinksForFile(params: CreateSymlinksParams) {
-  const {
-    filePath,
-    normalizedPath,
-    overlayPath,
-    config,
-    gitRoot,
-    overlayRoot,
-    cwd,
-    quiet,
-  } = params;
-
-  if (isAgentFile(filePath)) {
-    const symlinkDir = dirname(normalizedPath);
-    await createAgentLinks({
-      overlayPath,
-      symlinkDir,
-      gitRoot,
-      overlayRoot,
-      agents: config.agents,
-      quiet,
-    });
-  } else if (isPromptFile(normalizedPath)) {
-    await handlePromptFile(normalizedPath, overlayPath, gitRoot, cwd, quiet);
-  } else {
-    await handleRegularFile(
-      normalizedPath,
-      overlayPath,
-      overlayRoot,
-      cwd,
-      quiet,
-    );
-  }
-}
-
 /** Prompt for scope and add a single file. Returns the choice or "error". */
 async function promptAndAddFile(
   relPath: string,
@@ -315,7 +284,7 @@ async function promptAndAddFile(
 }
 
 /** Print summary of interactive add results */
-function printSummary(counts: Record<string, number>): void {
+function printSummary(counts: ScopeCounts): void {
   const parts: string[] = [];
   if (counts.project > 0) parts.push(`${counts.project} to project`);
   if (counts.worktree > 0) parts.push(`${counts.worktree} to worktree`);
@@ -381,6 +350,87 @@ async function addFileToOverlay(
   }
 }
 
+/** Create symlinks based on file type (agent, prompt, or regular) */
+async function createSymlinksForFile(params: CreateSymlinksParams) {
+  const { filePath, normalizedPath, overlayPath, config } = params;
+  const { gitRoot, overlayRoot, cwd, quiet } = params;
+
+  if (isAgentFile(filePath)) {
+    const symlinkDir = dirname(normalizedPath);
+    await createAgentLinks({
+      overlayPath,
+      symlinkDir,
+      gitRoot,
+      overlayRoot,
+      agents: config.agents,
+      quiet,
+    });
+  } else if (isPromptFile(normalizedPath)) {
+    await handlePromptFile(normalizedPath, overlayPath, gitRoot, cwd, quiet);
+  } else {
+    await handleRegularFile(
+      normalizedPath,
+      overlayPath,
+      overlayRoot,
+      cwd,
+      quiet,
+    );
+  }
+}
+
+/** Read a single keypress for scope selection */
+async function readScopeChoice(
+  isWorktree: boolean,
+): Promise<InteractiveChoice> {
+  const key = await readSingleKey();
+
+  switch (key.toLowerCase()) {
+    case "p":
+    case "\r":
+    case "\n":
+      console.log("project");
+      return "project";
+    case "w":
+      if (!isWorktree) {
+        console.log("(not in worktree, using project)");
+        return "project";
+      }
+      console.log("worktree");
+      return "worktree";
+    case "g":
+      console.log("global");
+      return "global";
+    case "s":
+      console.log("skip");
+      return "skip";
+    case "q":
+    case "\x03": // Ctrl+C
+      return "quit";
+    default:
+      console.log("project");
+      return "project";
+  }
+}
+
+/** Find content from normalized path or bare input path */
+async function findSourceContent(
+  normalizedPath: string,
+  barePath: string,
+): Promise<string> {
+  // Try normalized path first (e.g., cwd/clank/foo.md)
+  if (
+    (await fileExists(normalizedPath)) &&
+    !(await isSymlink(normalizedPath))
+  ) {
+    return await readFile(normalizedPath, "utf-8");
+  }
+  // Fall back to bare input path (e.g., cwd/foo.md)
+  if ((await fileExists(barePath)) && !(await isSymlink(barePath))) {
+    return await readFile(barePath, "utf-8");
+  }
+  return "";
+}
+
 async function createAgentLinks(p: AgentLinkParams): Promise<void> {
   const { overlayPath, quiet, ...classifyParams } = p;
   const { toCreate, existing, skipped } =
@@ -424,9 +474,8 @@ async function handlePromptFile(
       gitRoot,
     );
     if (!quiet && created.length) {
-      console.log(
-        `Created symlinks: ${created.map((p) => relative(cwd, p)).join(", ")}`,
-      );
+      const names = created.map((p) => relative(cwd, p)).join(", ");
+      console.log(`Created symlinks: ${names}`);
     }
   }
 }
@@ -450,57 +499,27 @@ async function handleRegularFile(
   }
 }
 
-/** Read a single keypress for scope selection */
-async function readScopeChoice(
-  isWorktree: boolean,
-): Promise<InteractiveChoice> {
-  const key = await readSingleKey();
+/** Read a single keypress from stdin (raw mode) */
+function readSingleKey(): Promise<string> {
+  return new Promise((resolve) => {
+    const wasRaw = process.stdin.isRaw;
+    if (process.stdin.isTTY) {
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
 
-  switch (key.toLowerCase()) {
-    case "p":
-    case "\r":
-    case "\n":
-      console.log("project");
-      return "project";
-    case "w":
-      if (!isWorktree) {
-        console.log("(not in worktree, using project)");
-        return "project";
+    const onKeypress = (data: Buffer): void => {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(wasRaw ?? false);
       }
-      console.log("worktree");
-      return "worktree";
-    case "g":
-      console.log("global");
-      return "global";
-    case "s":
-      console.log("skip");
-      return "skip";
-    case "q":
-    case "\x03": // Ctrl+C
-      return "quit";
-    default:
-      console.log("project");
-      return "project";
-  }
-}
+      process.stdin.pause();
+      process.stdin.removeListener("data", onKeypress);
+      resolve(data.toString());
+    };
 
-/** Find content from normalized path or bare input path */
-async function findSourceContent(
-  normalizedPath: string,
-  barePath: string,
-): Promise<string> {
-  // Try normalized path first (e.g., cwd/clank/foo.md)
-  if (
-    (await fileExists(normalizedPath)) &&
-    !(await isSymlink(normalizedPath))
-  ) {
-    return await readFile(normalizedPath, "utf-8");
-  }
-  // Fall back to bare input path (e.g., cwd/foo.md)
-  if ((await fileExists(barePath)) && !(await isSymlink(barePath))) {
-    return await readFile(barePath, "utf-8");
-  }
-  return "";
+    process.stdin.once("data", onKeypress);
+  });
 }
 
 /** Classify which agent symlinks to create vs skip */
@@ -513,18 +532,12 @@ async function classifyAgentLinks(
   const toCreate: { targetPath: string; name: string }[] = [];
 
   await forEachAgentPath(symlinkDir, agents, async (targetPath) => {
-    // Check if symlink already points to overlay
     if (await isSymlinkToOverlay(targetPath, overlayRoot)) {
       existing.push(basename(targetPath));
       return;
     }
 
-    const isTrackedFile =
-      (await fileExists(targetPath)) &&
-      !(await isSymlink(targetPath)) &&
-      (await isTrackedByGit(targetPath, gitRoot));
-
-    if (isTrackedFile) {
+    if (await isTrackedRealFile(targetPath, gitRoot)) {
       skipped.push(basename(targetPath));
     } else {
       toCreate.push({ targetPath, name: basename(targetPath) });
@@ -533,26 +546,3 @@ async function classifyAgentLinks(
 
   return { toCreate, existing, skipped };
 }
-
-/** Read a single keypress from stdin (raw mode) */
-function readSingleKey(): Promise<string> {
-  return new Promise((resolve) => {
-    const wasRaw = process.stdin.isRaw;
-    if (process.stdin.isTTY) {
-      readline.emitKeypressEvents(process.stdin);
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-
-    const onKeypress = (data: Buffer): void => {
-      if (process.stdin.isTTY) {
-        process.stdin.setRawMode(wasRaw ?? false);
-      }
-      process.stdin.pause();
-      process.stdin.removeListener("data", onKeypress);
-      resolve(data.toString());
-    };
-
-    process.stdin.once("data", onKeypress);
-  });
-}