clank-cli 0.1.67 → 0.1.74

package/src/Mapper.ts

@@ -1,5 +1,6 @@
-import { basename, dirname, join, relative } from "node:path";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
 import { managedAgentDirs } from "./AgentFiles.ts";
+import { toSlash } from "./FsUtil.ts";
 import type { GitContext } from "./Git.ts";
 
 /** overlay mappings can be cross project, per project, or per worktree */
@@ -83,14 +84,17 @@ export function overlayToTarget(
   context: MapperContext,
 ): TargetMapping | null {
   const { overlayRoot, targetRoot, gitContext } = context;
-  const projectPrefix = join(overlayRoot, "targets", gitContext.projectName);
-  const globalPrefix = join(overlayRoot, "global");
+  const op = toSlash(overlayPath);
+  const projectPrefix = toSlash(
+    join(overlayRoot, "targets", gitContext.projectName),
+  );
+  const globalPrefix = toSlash(join(overlayRoot, "global"));
 
-  if (overlayPath.startsWith(globalPrefix)) {
+  if (op.startsWith(globalPrefix)) {
     return mapGlobalOverlay(overlayPath, globalPrefix, targetRoot);
   }
 
-  if (overlayPath.startsWith(projectPrefix)) {
+  if (op.startsWith(projectPrefix)) {
     return mapProjectOverlay(overlayPath, projectPrefix, context);
   }
 
@@ -118,7 +122,7 @@ export function targetToOverlay(
   context: MapperContext,
 ): string {
   const { overlayRoot, targetRoot, gitContext } = context;
-  const relPath = relative(targetRoot, targetPath);
+  const relPath = toSlash(relative(targetRoot, targetPath));
 
   let overlayBase: string;
   if (scope === "global") {
@@ -145,7 +149,14 @@ export function normalizeAddPath(
   cwd: string,
   gitRoot: string,
 ): string {
-  const normalized = input.replace(/^\.\//, "");
+  // Normalize separators: strip leading ./ or .\ then use forward slashes
+  // for consistent string matching (path.join handles both on Windows)
+  const normalized = input.replace(/^\.[\\/]/, "").replaceAll("\\", "/");
+
+  // Absolute paths are already resolved — just handle agent file aliasing
+  if (isAbsolute(input)) {
+    return isAgentFile(normalized) ? join(dirname(input), "agents.md") : input;
+  }
 
   // Treat agent files (CLAUDE.md, GEMINI.md) as aliases for agents.md
   // Support both relative paths (packages/foo/CLAUDE.md) and running from subdirectory
@@ -156,19 +167,14 @@ export function normalizeAddPath(
   }
 
   // .claude/ and .gemini/ files keep their path (relative to git root)
-  for (const agentDir of managedAgentDirs) {
-    if (normalized.startsWith(`${agentDir}/`)) {
-      return join(gitRoot, normalized);
-    }
+  if (startsWithAgentDir(normalized)) {
+    return join(gitRoot, normalized);
   }
 
   // If cwd is inside a .claude/ or .gemini/ directory, join directly
   // (e.g., running `clank rm foo.md` from .claude/commands/)
-  const relCwd = relative(gitRoot, cwd);
-  for (const agentDir of managedAgentDirs) {
-    if (relCwd.startsWith(`${agentDir}/`) || relCwd === agentDir) {
-      return join(cwd, normalized);
-    }
+  if (isInsideAgentDir(toSlash(relative(gitRoot, cwd)))) {
+    return join(cwd, normalized);
   }
 
   // If path already contains /clank/ in the middle, preserve its structure
@@ -183,7 +189,7 @@ export function normalizeAddPath(
 
   // Strip trailing /clank from cwd to avoid clank/clank nesting
   // But don't strip if we're at the git root (project might be named "clank")
-  const inClankSubdir = cwd.endsWith("/clank") && cwd !== gitRoot;
+  const inClankSubdir = toSlash(cwd).endsWith("/clank") && cwd !== gitRoot;
   const normalizedCwd = inClankSubdir ? cwd.slice(0, -"/clank".length) : cwd;
 
   return join(normalizedCwd, "clank", filename);
@@ -202,8 +208,9 @@ export function isAgentFile(filename: string): boolean {
 
 /** Check if a path is a prompt file in an agent's prompts directory */
 export function isPromptFile(normalizedPath: string): boolean {
+  const p = toSlash(normalizedPath);
   for (const agentDir of managedAgentDirs) {
-    if (normalizedPath.includes(`/${agentDir}/prompts/`)) {
+    if (p.includes(`/${agentDir}/prompts/`)) {
       return true;
     }
   }
@@ -212,11 +219,12 @@ export function isPromptFile(normalizedPath: string): boolean {
 
 /** Extract the prompt-relative path from a full prompt path */
 export function getPromptRelPath(normalizedPath: string): string | null {
+  const p = toSlash(normalizedPath);
   for (const agentDir of managedAgentDirs) {
     const marker = `/${agentDir}/prompts/`;
-    const idx = normalizedPath.indexOf(marker);
+    const idx = p.indexOf(marker);
     if (idx !== -1) {
-      return normalizedPath.slice(idx + marker.length);
+      return p.slice(idx + marker.length);
     }
   }
   return null;
@@ -240,7 +248,7 @@ function mapGlobalOverlay(
   globalPrefix: string,
   targetRoot: string,
 ): TargetMapping | null {
-  const relPath = relative(globalPrefix, overlayPath);
+  const relPath = toSlash(relative(globalPrefix, overlayPath));
 
   // Skip init templates
   if (relPath.startsWith("init/")) return null;
@@ -255,12 +263,12 @@ function mapProjectOverlay(
   context: MapperContext,
 ): TargetMapping | null {
   const { targetRoot, gitContext } = context;
-  const relPath = relative(projectPrefix, overlayPath);
+  const relPath = toSlash(relative(projectPrefix, overlayPath));
 
   // Worktree-specific files
-  const worktreePrefix = join("worktrees", gitContext.worktreeName);
+  const worktreePrefix = `worktrees/${gitContext.worktreeName}`;
   if (relPath.startsWith(`${worktreePrefix}/`)) {
-    const innerPath = relative(worktreePrefix, relPath);
+    const innerPath = toSlash(relative(worktreePrefix, relPath));
     return decodeOverlayPath(innerPath, targetRoot, "worktree");
   }
 
@@ -284,14 +292,14 @@ function encodeTargetPath(relPath: string, overlayBase: string): string {
   if (basename(relPath) === "agents.md") {
     return join(overlayBase, relPath);
   }
-  // .claude/prompts/ and .gemini/prompts/ → prompts/ in overlay (agent-agnostic)
+  // <agentDir>/prompts/ (.claude/, .gemini/, .codex/) → prompts/ in overlay (agent-agnostic)
   for (const agentDir of managedAgentDirs) {
     const prefix = `${agentDir}/prompts/`;
     if (relPath.startsWith(prefix)) {
       return join(overlayBase, "prompts", relPath.slice(prefix.length));
     }
   }
-  // .claude/* and .gemini/* → claude/*, gemini/* in overlay (agent-specific)
+  // .claude/*, .gemini/*, .codex/* → claude/*, gemini/*, codex/* in overlay (agent-specific)
   for (const agentDir of managedAgentDirs) {
     if (relPath.startsWith(`${agentDir}/`)) {
       const subPath = relPath.slice(agentDir.length + 1);
@@ -306,6 +314,18 @@ function encodeTargetPath(relPath: string, overlayBase: string): string {
   return join(overlayBase, "clank", relPath);
 }
 
+/** Check if path starts with a managed agent dir (.claude/, .gemini/, .codex/) */
+function startsWithAgentDir(path: string): boolean {
+  return managedAgentDirs.some((dir) => path.startsWith(`${dir}/`));
+}
+
+/** Check if path is inside a managed agent dir (.claude/, .gemini/, .codex/) */
+function isInsideAgentDir(relPath: string): boolean {
+  return managedAgentDirs.some(
+    (dir) => relPath.startsWith(`${dir}/`) || relPath === dir,
+  );
+}
+
 /** Decode an overlay-relative path to target (shared by all scopes) */
 function decodeOverlayPath(
   relPath: string,
@@ -326,7 +346,7 @@ function decodeOverlayPath(
     };
   }
 
-  // claude/, gemini/ files → map to .claude/, .gemini/ in target
+  // claude/, gemini/, codex/ files → map to .claude/, .gemini/, .codex/ in target
   for (const agentDir of managedAgentDirs) {
     const overlayDir = agentDir.slice(1); // "claude" or "gemini"
     if (relPath.startsWith(`${overlayDir}/`)) {

package/src/OverlayLinks.ts

@@ -1,5 +1,5 @@
 import { lstat, unlink } from "node:fs/promises";
-import { dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import picomatch from "picomatch";
 import { managedAgentDirs, targetManagedDirs } from "./AgentFiles.ts";
 import {
@@ -8,6 +8,7 @@ import {
   getLinkTarget,
   isSymlink,
   resolveSymlinkTarget,
+  toSlash,
   walkDirectory,
 } from "./FsUtil.ts";
 import type { GitContext } from "./Git.ts";
@@ -44,7 +45,7 @@ export async function verifyManaged(
     const absoluteTarget = await resolveSymlinkTarget(linkPath);
 
     // Check if symlink points to overlay at all
-    if (!absoluteTarget.startsWith(overlayRoot)) {
+    if (!toSlash(absoluteTarget).startsWith(toSlash(overlayRoot))) {
       return { kind: "outside-overlay", currentTarget: absoluteTarget };
     }
 
@@ -58,7 +59,7 @@ export async function verifyManaged(
       };
     }
 
-    // Prompt files are fanned out to all agent directories (.claude/prompts/, .gemini/prompts/)
+    // Prompt files are fanned out to all agent directories (.claude/prompts/, .gemini/prompts/, .codex/prompts/)
     // Accept any agent's prompts dir as valid if the filename matches
     if (mapping.targetPath !== linkPath) {
       if (!isMatchingPromptPath(mapping.targetPath, linkPath)) {
@@ -88,7 +89,7 @@ export async function isSymlinkToOverlay(
     }
 
     const absoluteTarget = await resolveSymlinkTarget(linkPath);
-    return absoluteTarget.startsWith(overlayRoot);
+    return toSlash(absoluteTarget).startsWith(toSlash(overlayRoot));
   } catch {
     return false;
   }
@@ -105,8 +106,7 @@ export async function* walkOverlayFiles(
   const skip = (relPath: string): boolean => {
     if (relPath.startsWith("clank/init/")) return true; // Skip templates
     if (!isIgnored) return false;
-    const basename = relPath.split("/").at(-1) ?? "";
-    return isIgnored(relPath) || isIgnored(basename);
+    return isIgnored(relPath) || isIgnored(basename(relPath));
   };
 
   const genEntries = walkDirectory(overlayRoot, { skip });
@@ -133,15 +133,6 @@ export async function createPromptLinks(
   return created;
 }
 
-/** Check if two paths are equivalent prompt files in different agent directories */
-function isMatchingPromptPath(
-  canonicalPath: string,
-  actualPath: string,
-): boolean {
-  const canonical = getPromptRelPath(canonicalPath);
-  return canonical !== null && canonical === getPromptRelPath(actualPath);
-}
-
 /** Find and remove symlinks pointing to wrong worktree in the overlay.
  *  Returns paths that were removed. */
 export async function cleanStaleWorktreeSymlinks(
@@ -152,16 +143,16 @@ export async function cleanStaleWorktreeSymlinks(
   const removed: string[] = [];
   const currentWorktree = gitContext.worktreeName;
   const projectName = gitContext.projectName;
-  const worktreesPrefix = `${overlayRoot}/targets/${projectName}/worktrees/`;
+  const worktreesPrefix = `${toSlash(overlayRoot)}/targets/${projectName}/worktrees/`;
 
   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 (!(await isSymlink(path))) continue;
 
-    const target = await resolveSymlinkTarget(path);
+    const target = toSlash(await resolveSymlinkTarget(path));
     if (!target.startsWith(worktreesPrefix)) continue;
 
     // Extract worktree name from path like .../worktrees/main/clank/notes.md
@@ -177,6 +168,15 @@ export async function cleanStaleWorktreeSymlinks(
   return removed;
 }
 
+/** Check if two paths are equivalent prompt files in different agent directories */
+function isMatchingPromptPath(
+  canonicalPath: string,
+  actualPath: string,
+): boolean {
+  const canonical = getPromptRelPath(canonicalPath);
+  return canonical !== null && canonical === getPromptRelPath(actualPath);
+}
+
 /** Check if a path is inside a clank-managed directory */
 function isInManagedDir(relPath: string): boolean {
   const parts = relPath.split("/");

package/src/ScopeFromSymlink.ts

@@ -1,5 +1,5 @@
 import { lstat } from "node:fs/promises";
-import { resolveSymlinkTarget } from "./FsUtil.ts";
+import { resolveSymlinkTarget, toSlash } from "./FsUtil.ts";
 import { type MapperContext, overlayToTarget, type Scope } from "./Mapper.ts";
 
 /** Get scope from symlink target if it points to overlay */
@@ -12,7 +12,8 @@ export async function scopeFromSymlink(
     if (!stats.isSymbolicLink()) return null;
 
     const overlayPath = await resolveSymlinkTarget(targetPath);
-    if (!overlayPath.startsWith(context.overlayRoot)) return null;
+    if (!toSlash(overlayPath).startsWith(toSlash(context.overlayRoot)))
+      return null;
 
     const mapping = overlayToTarget(overlayPath, context);
     return mapping?.scope ?? null;