clank-cli 0.1.52

package/src/commands/Rm.ts

@@ -0,0 +1,161 @@
+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 { getGitContext } from "../Git.ts";
+import {
+  isAgentFile,
+  type MapperContext,
+  normalizeAddPath,
+  resolveScopeFromOptions,
+  type Scope,
+  type ScopeOptions,
+  targetToOverlay,
+} from "../Mapper.ts";
+import { isSymlinkToOverlay } from "../OverlayLinks.ts";
+import { scopeFromSymlink } from "../ScopeFromSymlink.ts";
+
+export type RmOptions = ScopeOptions;
+
+/** Remove file(s) from overlay and target */
+export async function rmCommand(
+  filePaths: string[],
+  options: RmOptions = {},
+): Promise<void> {
+  const cwd = process.cwd();
+  const gitContext = await getGitContext(cwd);
+  const config = await loadConfig();
+  const overlayRoot = expandPath(config.overlayRepo);
+
+  await validateOverlayExists(overlayRoot);
+
+  const { gitRoot } = gitContext;
+
+  const context: MapperContext = {
+    overlayRoot,
+    targetRoot: gitRoot,
+    gitContext,
+  };
+
+  for (const filePath of filePaths) {
+    const normalizedPath = normalizeAddPath(filePath, cwd, gitRoot);
+
+    const scope = await resolveScope(normalizedPath, options, context);
+    const overlayPath = targetToOverlay(normalizedPath, scope, context);
+
+    if (!(await fileExists(overlayPath))) {
+      throw new Error(`Not found in overlay: ${relative(cwd, normalizedPath)}`);
+    }
+
+    if (isAgentFile(filePath)) {
+      await removeAgentFiles(normalizedPath, overlayPath, overlayRoot, config);
+    } else {
+      await removeFile(normalizedPath, overlayPath, overlayRoot, cwd);
+    }
+  }
+}
+
+/** Resolve which scope to remove from */
+async function resolveScope(
+  targetPath: string,
+  options: RmOptions,
+  context: MapperContext,
+): Promise<Scope> {
+  // Explicit scope takes priority
+  if (options.global || options.project || options.worktree) {
+    return resolveScopeFromOptions(options);
+  }
+
+  const scope = await scopeFromSymlink(targetPath, context);
+  if (scope) return scope;
+
+  const found = await findInScopes(targetPath, context);
+
+  if (found.length === 0) {
+    throw new Error(
+      `Not found in overlay: ${basename(targetPath)}\n` +
+        `File does not exist in any scope (global, project, worktree)`,
+    );
+  }
+
+  if (found.length > 1) {
+    const scopeList = found.join(", ");
+    throw new Error(
+      `File exists in multiple scopes: ${scopeList}\n` +
+        `Specify --global, --project, or --worktree`,
+    );
+  }
+
+  return found[0];
+}
+
+/** Search all scopes to find where the file exists */
+async function findInScopes(
+  targetPath: string,
+  context: MapperContext,
+): Promise<Scope[]> {
+  const found: Scope[] = [];
+
+  for (const scope of ["worktree", "project", "global"] as const) {
+    const overlayPath = targetToOverlay(targetPath, scope, context);
+    if (await fileExists(overlayPath)) {
+      found.push(scope);
+    }
+  }
+
+  return found;
+}
+
+/** Remove a regular file */
+async function removeFile(
+  targetPath: string,
+  overlayPath: string,
+  overlayRoot: string,
+  cwd: string,
+): Promise<void> {
+  const fileName = relative(cwd, targetPath);
+
+  // Check if local file exists and handle it
+  if (await fileExists(targetPath)) {
+    if (await isSymlinkToOverlay(targetPath, overlayRoot)) {
+      await unlink(targetPath);
+      console.log(`Removed symlink: ${fileName}`);
+    } else {
+      throw new Error(
+        `File exists but is not managed by clank: ${fileName}\n` +
+          `Cannot remove a file that is not a symlink to the overlay`,
+      );
+    }
+  }
+
+  // Remove from overlay
+  await rm(overlayPath);
+  console.log(`Removed from overlay: ${basename(overlayPath)}`);
+}
+
+/** Remove agent files (CLAUDE.md, GEMINI.md, AGENTS.md → agents.md) */
+async function removeAgentFiles(
+  targetPath: string,
+  overlayPath: string,
+  overlayRoot: string,
+  config: { agents: string[] },
+): Promise<void> {
+  const dir = dirname(targetPath);
+  const removed: string[] = [];
+
+  await forEachAgentPath(dir, config.agents, async (linkPath) => {
+    if (await isSymlinkToOverlay(linkPath, overlayRoot)) {
+      await unlink(linkPath);
+      removed.push(basename(linkPath));
+    }
+  });
+
+  if (removed.length > 0) {
+    console.log(`Removed symlinks: ${removed.join(", ")}`);
+  }
+
+  // Remove agents.md from overlay
+  await rm(overlayPath);
+  console.log(`Removed from overlay: agents.md`);
+}

package/src/commands/Unlink.ts

@@ -0,0 +1,45 @@
+import { expandPath, loadConfig } from "../Config.ts";
+import { removeGitExcludes } from "../Exclude.ts";
+import { fileExists, 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 targetRoot = gitContext.gitRoot;
+
+  console.log(`Removing clank symlinks from: ${targetRoot}\n`);
+
+  // Load config to get overlay path
+  const config = await loadConfig();
+  const overlayRoot = expandPath(config.overlayRepo);
+
+  if (!(await fileExists(overlayRoot))) {
+    console.error(`Warning: Overlay repository not found at ${overlayRoot}`);
+    console.log("Will still attempt to remove symlinks...\n");
+  }
+
+  // Walk directory and remove all symlinks to overlay
+  let removedCount = 0;
+
+  for await (const { path, isDirectory } of walkDirectory(targetRoot)) {
+    if (isDirectory) continue;
+
+    if (await isSymlinkToOverlay(path, overlayRoot)) {
+      await removeSymlink(path);
+      console.log(`Removed: ${path}`);
+      removedCount++;
+    }
+  }
+
+  await removeGitExcludes(targetRoot);
+  await removeVscodeSettings(targetRoot);
+
+  if (removedCount === 0) {
+    console.log("No clank symlinks found.");
+  } else {
+    console.log(`\nDone! Removed ${removedCount} symlinks.`);
+  }
+}

package/src/commands/VsCode.ts

@@ -0,0 +1,195 @@
+import { readdir, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { loadConfig } from "../Config.ts";
+import { addToGitExclude } from "../Exclude.ts";
+import {
+  ensureDir,
+  fileExists,
+  isTrackedByGit,
+  writeJsonFile,
+} from "../FsUtil.ts";
+import { detectGitRoot } from "../Git.ts";
+import {
+  collectGitignorePatterns,
+  patternsToVscodeExcludes,
+} from "../Gitignore.ts";
+
+export interface VscodeOptions {
+  remove?: boolean;
+}
+
+/** 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());
+
+  if (options?.remove) {
+    await removeVscodeSettings(targetRoot);
+    return;
+  }
+
+  await generateVscodeSettings(targetRoot);
+}
+
+/** Generate VS Code settings for a target directory */
+export async function generateVscodeSettings(
+  targetRoot: string,
+): Promise<void> {
+  console.log(`Generating VS Code settings for: ${targetRoot}\n`);
+
+  const { patterns, negationWarnings } =
+    await collectGitignorePatterns(targetRoot);
+
+  const uniqueWarnings = [...new Set(negationWarnings)];
+  for (const pattern of uniqueWarnings) {
+    console.log(
+      `Warning: Cannot represent negation pattern "!${pattern}" in VS Code settings.`,
+    );
+    console.log("  This file may be incorrectly hidden.\n");
+  }
+
+  const excludeGlobs = patternsToVscodeExcludes(patterns);
+  const excludePatterns: Record<string, boolean> = {};
+  for (const glob of excludeGlobs) {
+    excludePatterns[glob] = true;
+  }
+
+  const mergedSettings = await mergeVscodeSettings(targetRoot, excludePatterns);
+
+  await writeVscodeSettings(targetRoot, mergedSettings);
+
+  const config = await loadConfig();
+  if (config.vscodeGitignore !== false) {
+    await addVscodeToGitExclude(targetRoot);
+  }
+
+  console.log(
+    `\nVS Code will now show clank/ and .claude/ in explorer and search`,
+  );
+  console.log(
+    `(while still respecting your ${excludeGlobs.length} gitignore patterns)`,
+  );
+}
+
+/** Remove clank-generated VS Code settings */
+export async function removeVscodeSettings(targetRoot: string): Promise<void> {
+  const settingsPath = join(targetRoot, ".vscode/settings.json");
+
+  if (!(await fileExists(settingsPath))) {
+    return;
+  }
+
+  const content = await readFile(settingsPath, "utf-8");
+
+  let settings: Record<string, unknown>;
+  try {
+    settings = JSON.parse(content);
+  } catch {
+    console.error("Warning: Could not parse .vscode/settings.json");
+    return;
+  }
+
+  // Regenerate the patterns clank would have added
+  const { patterns } = await collectGitignorePatterns(targetRoot);
+  const clankPatterns = patternsToVscodeExcludes(patterns);
+
+  // Selectively remove only clank-generated patterns
+  removePatterns(settings, "search.exclude", clankPatterns);
+  removePatterns(settings, "files.exclude", clankPatterns);
+
+  // Remove useIgnoreFiles (let VS Code use its default)
+  delete settings["search.useIgnoreFiles"];
+
+  if (Object.keys(settings).length === 0) {
+    await unlink(settingsPath);
+    console.log("Removed empty .vscode/settings.json");
+  } else {
+    await writeJsonFile(settingsPath, settings);
+    console.log("Removed clank settings from .vscode/settings.json");
+  }
+}
+
+/** Remove patterns from an exclude object, deleting the key if empty */
+function removePatterns(
+  settings: Record<string, unknown>,
+  key: string,
+  patterns: string[],
+): void {
+  const exclude = settings[key] as Record<string, boolean> | undefined;
+  if (!exclude) return;
+
+  for (const pattern of patterns) {
+    delete exclude[pattern];
+  }
+  if (Object.keys(exclude).length === 0) {
+    delete settings[key];
+  }
+}
+
+/** Merge clank exclude patterns with existing .vscode/settings.json */
+async function mergeVscodeSettings(
+  targetRoot: string,
+  excludePatterns: Record<string, boolean>,
+): Promise<Record<string, unknown>> {
+  const settingsPath = join(targetRoot, ".vscode/settings.json");
+
+  let existingSettings: Record<string, unknown> = {};
+  if (await fileExists(settingsPath)) {
+    const content = await readFile(settingsPath, "utf-8");
+    try {
+      existingSettings = JSON.parse(content);
+    } catch {
+      console.warn(
+        "Warning: Could not parse existing .vscode/settings.json, overwriting",
+      );
+    }
+  }
+
+  // Get existing exclude patterns (preserve user's patterns)
+  const existingSearchExclude =
+    (existingSettings["search.exclude"] as Record<string, boolean>) || {};
+  const existingFilesExclude =
+    (existingSettings["files.exclude"] as Record<string, boolean>) || {};
+
+  return {
+    ...existingSettings,
+    "search.useIgnoreFiles": false,
+    "search.exclude": { ...existingSearchExclude, ...excludePatterns },
+    "files.exclude": { ...existingFilesExclude, ...excludePatterns },
+  };
+}
+
+/** Write settings to .vscode/settings.json */
+async function writeVscodeSettings(
+  targetRoot: string,
+  settings: Record<string, unknown>,
+): Promise<void> {
+  const vscodeDir = join(targetRoot, ".vscode");
+  const settingsPath = join(vscodeDir, "settings.json");
+
+  await ensureDir(vscodeDir);
+  await writeJsonFile(settingsPath, settings);
+
+  console.log(`Wrote ${settingsPath}`);
+}
+
+/** Add .vscode/settings.json to .git/info/exclude */
+async function addVscodeToGitExclude(targetRoot: string): Promise<void> {
+  const settingsPath = join(targetRoot, ".vscode/settings.json");
+  if (await isTrackedByGit(settingsPath, targetRoot)) return;
+  await addToGitExclude(targetRoot, ".vscode/settings.json");
+}
+
+/** Check if target directory has VS Code artifacts */
+export async function isVscodeProject(targetRoot: string): Promise<boolean> {
+  // Check for .vscode directory
+  const hasVscodeDir = await fileExists(join(targetRoot, ".vscode"));
+  if (hasVscodeDir) return true;
+
+  // Check for *.code-workspace files
+  try {
+    const files = await readdir(targetRoot);
+    return files.some((f) => f.endsWith(".code-workspace"));
+  } catch {
+    return false;
+  }
+}