thought-cabinet 0.1.12 → 0.1.13

package/dist/index.js

@@ -2260,7 +2260,6 @@ import { join } from "path";
 import { existsSync } from "fs";
 var home = homedir();
 var claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
-var codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
 var agents = {
   "claude-code": {
     name: "claude-code",
@@ -2275,34 +2274,6 @@ var agents = {
     configDir: ".codebuddy",
     globalConfigDir: join(home, ".codebuddy"),
     detectInstalled: async () => existsSync(join(process.cwd(), ".codebuddy")) || existsSync(join(home, ".codebuddy"))
-  },
-  cursor: {
-    name: "cursor",
-    displayName: "Cursor",
-    configDir: ".cursor",
-    globalConfigDir: join(home, ".cursor"),
-    detectInstalled: async () => existsSync(join(home, ".cursor"))
-  },
-  codex: {
-    name: "codex",
-    displayName: "Codex",
-    configDir: ".codex",
-    globalConfigDir: codexHome,
-    detectInstalled: async () => existsSync(codexHome)
-  },
-  "gemini-cli": {
-    name: "gemini-cli",
-    displayName: "Gemini CLI",
-    configDir: ".gemini",
-    globalConfigDir: join(home, ".gemini"),
-    detectInstalled: async () => existsSync(join(home, ".gemini"))
-  },
-  cline: {
-    name: "cline",
-    displayName: "Cline",
-    configDir: ".cline",
-    globalConfigDir: join(home, ".cline"),
-    detectInstalled: async () => existsSync(join(home, ".cline"))
   }
 };
 function getAllAgents() {
@@ -2323,7 +2294,7 @@ function isValidAgentType(value) {
 
 // src/commands/agent/discovery.ts
 import { readdir, readFile } from "fs/promises";
-import { join as join2, basename, extname } from "path";
+import { join as join2 } from "path";
 function parseSkillFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
@@ -2368,13 +2339,12 @@ async function discoverMarkdownAssets(basePath, category) {
   try {
     const entries = await readdir(basePath, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.isDirectory()) continue;
-      if (extname(entry.name) !== ".md") continue;
-      const filePath = join2(basePath, entry.name);
-      const name = basename(entry.name, ".md");
+      if (!entry.isDirectory()) continue;
+      const dirPath = join2(basePath, entry.name);
+      const mdFile = join2(dirPath, `${entry.name}.md`);
       let description = "";
       try {
-        const content = await readFile(filePath, "utf-8");
+        const content = await readFile(mdFile, "utf-8");
         const match = content.match(/^---\n([\s\S]*?)\n---/);
         if (match) {
           const descMatch = match[1].match(/description:\s*(.+)/);
@@ -2383,13 +2353,14 @@ async function discoverMarkdownAssets(basePath, category) {
           }
         }
       } catch {
+        continue;
       }
       assets.push({
-        name,
+        name: entry.name,
         description,
-        sourcePath: filePath,
+        sourcePath: dirPath,
         category,
-        isDirectory: false
+        isDirectory: true
       });
     }
   } catch {
@@ -2406,7 +2377,7 @@ async function discoverAllAssets(sourcePath) {
 
 // src/commands/agent/installer.ts
 import { mkdir, cp, readdir as readdir2, symlink as fsSymlink, lstat, rm, readlink } from "fs/promises";
-import { join as join3, basename as basename2, normalize, resolve, sep, relative, dirname } from "path";
+import { join as join3, basename, normalize, resolve, sep, relative, dirname } from "path";
 import { platform } from "os";
 
 // src/commands/agent/constants.ts
@@ -2426,10 +2397,6 @@ function isPathSafe(basePath, targetPath) {
   const normalizedTarget = normalize(resolve(targetPath));
   return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
 }
-function getCanonicalDir(category, scope, cwd) {
-  const baseDir = scope === "global" ? getDefaultConfigDir() : join3(cwd || process.cwd(), ".thought-cabinet");
-  return join3(baseDir, CATEGORY_SUBDIRS[category]);
-}
 function getAgentDir(agentType, category, scope, cwd) {
   const agent = agents[agentType];
   const agentBase = scope === "global" && agent.globalConfigDir ? agent.globalConfigDir : join3(cwd || process.cwd(), agent.configDir);
@@ -2515,11 +2482,9 @@ async function installAssetForAgent(asset, agentType, options = {}) {
     };
   }
   const assetName = sanitizeName(asset.name);
-  const canonicalBase = getCanonicalDir(asset.category, scope, cwd);
-  const canonicalDir = join3(canonicalBase, assetName);
   const agentBase = getAgentDir(agentType, asset.category, scope, cwd);
   const agentDir = join3(agentBase, assetName);
-  if (!isPathSafe(canonicalBase, canonicalDir) || !isPathSafe(agentBase, agentDir)) {
+  if (!isPathSafe(agentBase, agentDir)) {
     return {
       success: false,
       path: agentDir,
@@ -2533,7 +2498,7 @@ async function installAssetForAgent(asset, agentType, options = {}) {
         await copyDirectoryContents(asset.sourcePath, targetDir);
       } else {
         await mkdir(targetDir, { recursive: true });
-        const fileName = basename2(asset.sourcePath);
+        const fileName = basename(asset.sourcePath);
         await cp(asset.sourcePath, join3(targetDir, fileName), { dereference: true });
       }
     };
@@ -2542,26 +2507,15 @@ async function installAssetForAgent(asset, agentType, options = {}) {
       await copyAsset(agentDir);
       return { success: true, path: agentDir, mode: "copy" };
     }
-    await cleanAndCreateDirectory(canonicalDir);
-    await copyAsset(canonicalDir);
-    const symlinkCreated = await createSymlink(canonicalDir, agentDir);
+    await rm(agentDir, { recursive: true, force: true });
+    await mkdir(dirname(agentDir), { recursive: true });
+    const symlinkCreated = await createSymlink(asset.sourcePath, agentDir);
     if (!symlinkCreated) {
       await cleanAndCreateDirectory(agentDir);
       await copyAsset(agentDir);
-      return {
-        success: true,
-        path: agentDir,
-        canonicalPath: canonicalDir,
-        mode: "symlink",
-        symlinkFailed: true
-      };
+      return { success: true, path: agentDir, mode: "symlink", symlinkFailed: true };
     }
-    return {
-      success: true,
-      path: agentDir,
-      canonicalPath: canonicalDir,
-      mode: "symlink"
-    };
+    return { success: true, path: agentDir, mode: "symlink" };
   } catch (error) {
     return {
       success: false,
@@ -2664,30 +2618,7 @@ async function agentInitCommand(options) {
         scope = scopeChoice;
       }
     }
-    let mode = options.mode ?? "symlink";
-    if (!options.mode && !options.all) {
-      const modeChoice = await p4.select({
-        message: "Installation mode:",
-        options: [
-          {
-            value: "symlink",
-            label: "Symlink (recommended)",
-            hint: "Canonical storage + symlinks; update once, all agents see changes"
-          },
-          {
-            value: "copy",
-            label: "Copy",
-            hint: "Independent copies for each agent"
-          }
-        ],
-        initialValue: "symlink"
-      });
-      if (p4.isCancel(modeChoice)) {
-        p4.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      mode = modeChoice;
-    }
+    const mode = options.mode ?? "symlink";
     if (!options.force) {
       const cwd2 = process.cwd();
       for (const agentType of selectedAgents) {
@@ -2769,7 +2700,6 @@ async function agentInitCommand(options) {
     const cwd = process.cwd();
     let totalInstalled = 0;
     let totalFailed = 0;
-    const symlinkWarnings = [];
     const s = p4.spinner();
     s.start("Installing assets...");
     for (const asset of assetsToInstall) {
@@ -2778,7 +2708,7 @@ async function agentInitCommand(options) {
         if (result.success) {
           totalInstalled++;
           if (result.symlinkFailed) {
-            symlinkWarnings.push(
+            p4.log.warn(
               `${asset.name} \u2192 ${agents[agentType].displayName}: symlink failed, copied instead`
             );
           }
@@ -2789,12 +2719,6 @@ async function agentInitCommand(options) {
       }
     }
     s.stop("Installation complete.");
-    if (symlinkWarnings.length > 0) {
-      p4.log.warn("Symlink warnings:");
-      for (const warning of symlinkWarnings) {
-        p4.log.warn(`  ${warning}`);
-      }
-    }
     const agentNames = selectedAgents.map((a) => agents[a].displayName).join(", ");
     let message = `Installed ${totalInstalled} asset(s) to ${agentNames}`;
     if (totalFailed > 0) {
@@ -2812,7 +2736,7 @@ async function agentInitCommand(options) {
 // src/commands/agent.ts
 function agentCommand(program) {
   const agent = program.command("agent").description("Manage coding agent configuration");
-  agent.command("init").description("Initialize coding agent configuration in current directory").option("--target <agents...>", "Target agents (e.g., claude-code codebuddy cursor)").option("-g, --global", "Install to global scope").option("--mode <mode>", "Installation mode: symlink or copy (default: symlink)").option("--source <path>", "Source directory for assets").option("--force", "Force overwrite of existing installations").option("--all", "Install all assets without prompting").action(async (options) => {
+  agent.command("init").description("Initialize coding agent configuration in current directory").option("--target <agents...>", "Target agents (e.g., claude-code codebuddy)").option("-g, --global", "Install to global scope").option("--mode <mode>", "Installation mode: symlink or copy (default: symlink)").option("--source <path>", "Source directory for assets").option("--force", "Force overwrite of existing installations").option("--all", "Install all assets without prompting").action(async (options) => {
     const agentTypes = options.target?.map((a) => {
       if (!isValidAgentType(a)) {
         console.error(`Unknown agent: ${a}`);
@@ -2963,23 +2887,10 @@ function tmuxKillSession(sessionName) {
 // src/agent-config.ts
 import fs13 from "fs";
 import path16 from "path";
-var CANONICAL_DIR = ".thought-cabinet";
 function detectAgentConfigDirs(sourceDir) {
   const uniqueDirs = [...new Set(Object.values(agents).map((a) => a.configDir))];
   return uniqueDirs.filter((dir) => fs13.existsSync(path16.join(sourceDir, dir)));
 }
-function getCanonicalSymlinkTarget(entryPath, canonicalDir) {
-  try {
-    if (!fs13.lstatSync(entryPath).isSymbolicLink()) return null;
-    const linkTarget = fs13.readlinkSync(entryPath);
-    const resolvedTarget = path16.resolve(path16.dirname(entryPath), linkTarget);
-    const resolvedCanonical = path16.resolve(canonicalDir);
-    const isInsideCanonical = resolvedTarget === resolvedCanonical || resolvedTarget.startsWith(resolvedCanonical + path16.sep);
-    return isInsideCanonical ? path16.relative(resolvedCanonical, resolvedTarget) : null;
-  } catch {
-    return null;
-  }
-}
 function symlinkOrCopy(srcPath, destPath, linkTarget) {
   try {
     fs13.symlinkSync(linkTarget, destPath);
@@ -2990,19 +2901,15 @@ function symlinkOrCopy(srcPath, destPath, linkTarget) {
     }
   }
 }
-function copyDirWithSymlinkHandling(srcDir, destDir, sourceCanonicalDir, targetCanonicalDir) {
+function copyDirWithSymlinkHandling(srcDir, destDir) {
   fs13.mkdirSync(destDir, { recursive: true });
   for (const entry of fs13.readdirSync(srcDir, { withFileTypes: true })) {
     const srcPath = path16.join(srcDir, entry.name);
     const destPath = path16.join(destDir, entry.name);
-    const canonicalRelPath = getCanonicalSymlinkTarget(srcPath, sourceCanonicalDir);
-    if (canonicalRelPath !== null) {
-      const newTarget = path16.join(targetCanonicalDir, canonicalRelPath);
-      symlinkOrCopy(srcPath, destPath, path16.relative(path16.dirname(destPath), newTarget));
-    } else if (entry.isSymbolicLink()) {
+    if (entry.isSymbolicLink()) {
       symlinkOrCopy(srcPath, destPath, fs13.readlinkSync(srcPath));
     } else if (entry.isDirectory()) {
-      copyDirWithSymlinkHandling(srcPath, destPath, sourceCanonicalDir, targetCanonicalDir);
+      copyDirWithSymlinkHandling(srcPath, destPath);
     } else {
       fs13.cpSync(srcPath, destPath);
     }
@@ -3012,26 +2919,15 @@ function copyAgentConfigDirs(options) {
   const { sourceDir, targetDir } = options;
   const copied = [];
   const skipped = [];
-  const sourceCanonicalDir = path16.join(sourceDir, CANONICAL_DIR);
-  const targetCanonicalDir = path16.join(targetDir, CANONICAL_DIR);
-  const canonicalCopied = fs13.existsSync(sourceCanonicalDir);
-  if (canonicalCopied) {
-    fs13.cpSync(sourceCanonicalDir, targetCanonicalDir, { recursive: true });
-  }
   for (const dirName of detectAgentConfigDirs(sourceDir)) {
     try {
-      copyDirWithSymlinkHandling(
-        path16.join(sourceDir, dirName),
-        path16.join(targetDir, dirName),
-        sourceCanonicalDir,
-        targetCanonicalDir
-      );
+      copyDirWithSymlinkHandling(path16.join(sourceDir, dirName), path16.join(targetDir, dirName));
       copied.push(dirName);
     } catch {
       skipped.push(dirName);
     }
   }
-  return { copied, skipped, canonicalCopied };
+  return { copied, skipped };
 }
 
 // src/commands/worktree/add.ts
@@ -3103,11 +2999,8 @@ async function worktreeAddCommand(name, options) {
       sourceDir: mainRoot,
       targetDir: worktreePath
     });
-    if (configResult.copied.length > 0 || configResult.canonicalCopied) {
-      const parts = [];
-      if (configResult.canonicalCopied) parts.push(".thought-cabinet");
-      parts.push(...configResult.copied);
-      console.log(chalk16.gray(`Copied config: ${parts.join(", ")}`));
+    if (configResult.copied.length > 0) {
+      console.log(chalk16.gray(`Copied config: ${configResult.copied.join(", ")}`));
     }
     if (options.thoughts !== false) {
       initializeWorktreeThoughts(mainRoot, worktreePath);
@@ -3631,7 +3524,7 @@ function getBranchNames() {
   }
 }
 function getAgentNames() {
-  return ["claude-code", "codebuddy", "cursor", "codex", "gemini-cli", "cline"];
+  return ["claude-code", "codebuddy"];
 }
 
 // src/completion/handler.ts