thought-cabinet 0.0.2

package/dist/index.js

@@ -0,0 +1,2113 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/thoughts/init.ts
+import fs4 from "fs";
+import path6 from "path";
+import { execSync as execSync2 } from "child_process";
+import chalk2 from "chalk";
+import * as p from "@clack/prompts";
+
+// src/config.ts
+import dotenv from "dotenv";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+dotenv.config();
+var _ConfigResolver = class _ConfigResolver {
+  constructor(options = {}) {
+    this.configFile = this.loadConfigFile(options.configFile);
+    this.configFilePath = this.getConfigFilePath(options.configFile);
+  }
+  loadConfigFile(configFile) {
+    if (configFile) {
+      const configContent = fs.readFileSync(configFile, "utf8");
+      return JSON.parse(configContent);
+    }
+    const configPaths = [_ConfigResolver.DEFAULT_CONFIG_FILE, getDefaultConfigPath()];
+    for (const configPath of configPaths) {
+      try {
+        if (fs.existsSync(configPath)) {
+          const configContent = fs.readFileSync(configPath, "utf8");
+          return JSON.parse(configContent);
+        }
+      } catch (error) {
+        console.error(chalk.yellow(`Warning: Could not parse config file ${configPath}: ${error}`));
+      }
+    }
+    return {};
+  }
+  getConfigFilePath(configFile) {
+    if (configFile) return configFile;
+    const configPaths = [_ConfigResolver.DEFAULT_CONFIG_FILE, getDefaultConfigPath()];
+    for (const configPath of configPaths) {
+      try {
+        if (fs.existsSync(configPath)) {
+          return configPath;
+        }
+      } catch {
+      }
+    }
+    return getDefaultConfigPath();
+  }
+};
+_ConfigResolver.DEFAULT_CONFIG_FILE = "config.json";
+var ConfigResolver = _ConfigResolver;
+function saveConfigFile(config, configFile) {
+  const configPath = configFile || getDefaultConfigPath();
+  console.log(chalk.yellow(`Writing config to ${configPath}`));
+  const configDir = path.dirname(configPath);
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(chalk.green("Config saved successfully"));
+}
+function getDefaultConfigPath() {
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(process.env.HOME || "", ".config");
+  return path.join(xdgConfigHome, "thought-cabinet", ConfigResolver.DEFAULT_CONFIG_FILE);
+}
+
+// src/commands/thoughts/utils/config.ts
+function loadThoughtsConfig(options = {}) {
+  const resolver = new ConfigResolver(options);
+  return resolver.configFile.thoughts || null;
+}
+function saveThoughtsConfig(thoughtsConfig, options = {}) {
+  const resolver = new ConfigResolver(options);
+  resolver.configFile.thoughts = thoughtsConfig;
+  saveConfigFile(resolver.configFile, options.configFile);
+}
+
+// src/commands/thoughts/utils/paths.ts
+import path2 from "path";
+import os from "os";
+function getDefaultThoughtsRepo() {
+  return path2.join(os.homedir(), "thoughts");
+}
+function expandPath(filePath) {
+  if (filePath.startsWith("~/")) {
+    return path2.join(os.homedir(), filePath.slice(2));
+  }
+  return path2.resolve(filePath);
+}
+function getCurrentRepoPath() {
+  return process.cwd();
+}
+function getRepoNameFromPath(repoPath) {
+  const parts = repoPath.split(path2.sep);
+  return parts[parts.length - 1] || "unnamed_repo";
+}
+function getRepoThoughtsPath(thoughtsRepoOrConfig, reposDirOrRepoName, repoName) {
+  if (typeof thoughtsRepoOrConfig === "string") {
+    return path2.join(expandPath(thoughtsRepoOrConfig), reposDirOrRepoName, repoName);
+  }
+  const config = thoughtsRepoOrConfig;
+  return path2.join(expandPath(config.thoughtsRepo), config.reposDir, reposDirOrRepoName);
+}
+function getGlobalThoughtsPath(thoughtsRepoOrConfig, globalDir) {
+  if (typeof thoughtsRepoOrConfig === "string") {
+    return path2.join(expandPath(thoughtsRepoOrConfig), globalDir);
+  }
+  const config = thoughtsRepoOrConfig;
+  return path2.join(expandPath(config.thoughtsRepo), config.globalDir);
+}
+
+// src/commands/thoughts/utils/repository.ts
+import fs2 from "fs";
+import path4 from "path";
+import { execSync } from "child_process";
+
+// src/templates/gitignore.ts
+function generateGitignore() {
+  return `# OS files
+.DS_Store
+Thumbs.db
+
+# Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Temporary files
+*.tmp
+*.bak
+`;
+}
+
+// src/templates/readme.ts
+function generateRepoReadme({ repoName, user }) {
+  return `# ${repoName} Thoughts
+
+This directory contains thoughts and notes specific to the ${repoName} repository.
+
+- \`${user}/\` - Your personal notes for this repository
+- \`shared/\` - Team-shared notes for this repository
+`;
+}
+function generateGlobalReadme({ user }) {
+  return `# Global Thoughts
+
+This directory contains thoughts and notes that apply across all repositories.
+
+- \`${user}/\` - Your personal cross-repository notes
+- \`shared/\` - Team-shared cross-repository notes
+`;
+}
+
+// src/templates/agentMd.ts
+import path3 from "path";
+import os2 from "os";
+function generateAgentMd({
+  thoughtsRepo,
+  reposDir,
+  repoName,
+  user,
+  productName
+}) {
+  const reposPath = path3.join(thoughtsRepo, reposDir, repoName).replace(os2.homedir(), "~");
+  const globalPath = path3.join(thoughtsRepo, "global").replace(os2.homedir(), "~");
+  return `# Thoughts Directory Structure
+
+This directory contains developer thoughts and notes for the ${repoName} repository.
+It is managed by the ThoughtCabinet thoughts system and should not be committed to the code repository.
+
+## Structure
+
+- \`${user}/\` \u2192 Your personal notes for this repository (symlink to ${reposPath}/${user})
+- \`shared/\` \u2192 Team-shared notes for this repository (symlink to ${reposPath}/shared)
+- \`global/\` \u2192 Cross-repository thoughts (symlink to ${globalPath})
+  - \`${user}/\` - Your personal notes that apply across all repositories
+  - \`shared/\` - Team-shared notes that apply across all repositories
+- \`searchable/\` \u2192 Hard links for search tools (auto-generated)
+
+## Searching in Thoughts
+
+The \`searchable/\` directory contains hard links to all thoughts files accessible in this repository. This allows search tools to find content without following symlinks.
+
+**IMPORTANT**:
+- Files in \`thoughts/searchable/\` are hard links to the original files (editing either updates both)
+- For clarity and consistency, always reference files by their canonical path (e.g., \`thoughts/${user}/todo.md\`, not \`thoughts/searchable/${user}/todo.md\`)
+- The \`searchable/\` directory is automatically updated when you run \`thoughtcabinet sync\`
+
+This design ensures that:
+1. Search tools can find all your thoughts content easily
+2. The symlink structure remains intact for git operations
+3. Files remain editable while maintaining consistent path references
+
+## Usage
+
+Create markdown files in these directories to document:
+
+- Architecture decisions
+- Design notes
+- TODO items
+- Investigation results
+- Any other development thoughts
+
+Quick access:
+
+- \`thoughts/${user}/\` for your repo-specific notes (most common)
+- \`thoughts/global/${user}/\` for your cross-repo notes
+
+These files will be automatically synchronized with your thoughts repository when you commit code changes (when using ${productName}).
+
+## Important
+
+- Never commit the thoughts/ directory to your code repository
+- The git pre-commit hook will prevent accidental commits
+- Use \`thoughtcabinet sync\` to manually sync changes
+- Use \`thoughtcabinet status\` to see sync status
+`;
+}
+function generateClaudeMd(params) {
+  return generateAgentMd({ ...params, productName: "Claude Code" });
+}
+
+// src/templates/gitHooks.ts
+var HOOK_VERSION = "1";
+function generatePreCommitHook({ hookPath }) {
+  return `#!/bin/bash
+# ThoughtCabinet thoughts protection - prevent committing thoughts directory
+# Version: ${HOOK_VERSION}
+
+if git diff --cached --name-only | grep -q "^thoughts/"; then
+    echo "\u274C Cannot commit thoughts/ to code repository"
+    echo "The thoughts directory should only exist in your separate thoughts repository."
+    git reset HEAD -- thoughts/
+    exit 1
+fi
+
+# Call any existing pre-commit hook
+if [ -f "${hookPath}.old" ]; then
+    "${hookPath}.old" "$@"
+fi
+`;
+}
+function generatePostCommitHook({ hookPath }) {
+  return `#!/bin/bash
+# ThoughtCabinet thoughts auto-sync
+# Version: ${HOOK_VERSION}
+
+# Check if we're in a worktree
+if [ -f .git ]; then
+    # Skip auto-sync in worktrees to avoid repository boundary confusion
+    exit 0
+fi
+
+# Get the commit message
+COMMIT_MSG=$(git log -1 --pretty=%B)
+
+# Auto-sync thoughts after each commit (only in non-worktree repos)
+thoughtcabinet sync --message "Auto-sync with commit: $COMMIT_MSG" >/dev/null 2>&1 &
+
+# Call any existing post-commit hook
+if [ -f "${hookPath}.old" ]; then
+    "${hookPath}.old" "$@"
+fi
+`;
+}
+
+// src/commands/thoughts/utils/repository.ts
+function ensureThoughtsRepoExists(configOrThoughtsRepo, reposDir, globalDir) {
+  let thoughtsRepo;
+  let effectiveReposDir;
+  let effectiveGlobalDir;
+  if (typeof configOrThoughtsRepo === "string") {
+    thoughtsRepo = configOrThoughtsRepo;
+    effectiveReposDir = reposDir;
+    effectiveGlobalDir = globalDir;
+  } else {
+    thoughtsRepo = configOrThoughtsRepo.thoughtsRepo;
+    effectiveReposDir = configOrThoughtsRepo.reposDir;
+    effectiveGlobalDir = configOrThoughtsRepo.globalDir;
+  }
+  const expandedRepo = expandPath(thoughtsRepo);
+  if (!fs2.existsSync(expandedRepo)) {
+    fs2.mkdirSync(expandedRepo, { recursive: true });
+  }
+  const expandedRepos = path4.join(expandedRepo, effectiveReposDir);
+  const expandedGlobal = path4.join(expandedRepo, effectiveGlobalDir);
+  if (!fs2.existsSync(expandedRepos)) {
+    fs2.mkdirSync(expandedRepos, { recursive: true });
+  }
+  if (!fs2.existsSync(expandedGlobal)) {
+    fs2.mkdirSync(expandedGlobal, { recursive: true });
+  }
+  const gitPath = path4.join(expandedRepo, ".git");
+  const isGitRepo = fs2.existsSync(gitPath) && (fs2.statSync(gitPath).isDirectory() || fs2.statSync(gitPath).isFile());
+  if (!isGitRepo) {
+    execSync("git init", { cwd: expandedRepo });
+    const gitignore = generateGitignore();
+    fs2.writeFileSync(path4.join(expandedRepo, ".gitignore"), gitignore);
+    execSync("git add .gitignore", { cwd: expandedRepo });
+    execSync('git commit -m "Initial thoughts repository setup"', { cwd: expandedRepo });
+  }
+}
+function createThoughtsDirectoryStructure(configOrThoughtsRepo, reposDirOrRepoName, globalDirOrUser, repoName, user) {
+  let resolvedConfig;
+  let effectiveRepoName;
+  let effectiveUser;
+  if (typeof configOrThoughtsRepo === "string") {
+    resolvedConfig = {
+      thoughtsRepo: configOrThoughtsRepo,
+      reposDir: reposDirOrRepoName,
+      globalDir: globalDirOrUser
+    };
+    effectiveRepoName = repoName;
+    effectiveUser = user;
+  } else {
+    resolvedConfig = configOrThoughtsRepo;
+    effectiveRepoName = reposDirOrRepoName;
+    effectiveUser = globalDirOrUser;
+  }
+  const repoThoughtsPath = getRepoThoughtsPath(
+    resolvedConfig.thoughtsRepo,
+    resolvedConfig.reposDir,
+    effectiveRepoName
+  );
+  const repoUserPath = path4.join(repoThoughtsPath, effectiveUser);
+  const repoSharedPath = path4.join(repoThoughtsPath, "shared");
+  const globalPath = getGlobalThoughtsPath(resolvedConfig.thoughtsRepo, resolvedConfig.globalDir);
+  const globalUserPath = path4.join(globalPath, effectiveUser);
+  const globalSharedPath = path4.join(globalPath, "shared");
+  for (const dir of [repoUserPath, repoSharedPath, globalUserPath, globalSharedPath]) {
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+  }
+  const repoReadme = generateRepoReadme({
+    repoName: effectiveRepoName,
+    user: effectiveUser
+  });
+  const globalReadme = generateGlobalReadme({
+    user: effectiveUser
+  });
+  if (!fs2.existsSync(path4.join(repoThoughtsPath, "README.md"))) {
+    fs2.writeFileSync(path4.join(repoThoughtsPath, "README.md"), repoReadme);
+  }
+  if (!fs2.existsSync(path4.join(globalPath, "README.md"))) {
+    fs2.writeFileSync(path4.join(globalPath, "README.md"), globalReadme);
+  }
+}
+
+// src/commands/thoughts/utils/symlinks.ts
+import fs3 from "fs";
+import path5 from "path";
+function updateSymlinksForNewUsers(currentRepoPath, configOrThoughtsRepo, reposDirOrRepoName, repoNameOrCurrentUser, currentUser) {
+  let resolvedConfig;
+  let effectiveRepoName;
+  let effectiveUser;
+  if (typeof configOrThoughtsRepo === "string") {
+    resolvedConfig = {
+      thoughtsRepo: configOrThoughtsRepo,
+      reposDir: reposDirOrRepoName
+    };
+    effectiveRepoName = repoNameOrCurrentUser;
+    effectiveUser = currentUser;
+  } else {
+    resolvedConfig = configOrThoughtsRepo;
+    effectiveRepoName = reposDirOrRepoName;
+    effectiveUser = repoNameOrCurrentUser;
+  }
+  const thoughtsDir = path5.join(currentRepoPath, "thoughts");
+  const repoThoughtsPath = getRepoThoughtsPath(
+    resolvedConfig.thoughtsRepo,
+    resolvedConfig.reposDir,
+    effectiveRepoName
+  );
+  const addedSymlinks = [];
+  if (!fs3.existsSync(thoughtsDir) || !fs3.existsSync(repoThoughtsPath)) {
+    return addedSymlinks;
+  }
+  const entries = fs3.readdirSync(repoThoughtsPath, { withFileTypes: true });
+  const userDirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "shared" && !entry.name.startsWith(".")).map((entry) => entry.name);
+  for (const userName of userDirs) {
+    const symlinkPath = path5.join(thoughtsDir, userName);
+    const targetPath = path5.join(repoThoughtsPath, userName);
+    if (!fs3.existsSync(symlinkPath) && userName !== effectiveUser) {
+      try {
+        fs3.symlinkSync(targetPath, symlinkPath, "dir");
+        addedSymlinks.push(userName);
+      } catch {
+      }
+    }
+  }
+  return addedSymlinks;
+}
+
+// src/commands/thoughts/profile/utils.ts
+function resolveProfileForRepo(config, repoPath) {
+  const mapping = config.repoMappings[repoPath];
+  if (typeof mapping === "string") {
+    return {
+      thoughtsRepo: config.thoughtsRepo,
+      reposDir: config.reposDir,
+      globalDir: config.globalDir,
+      profileName: void 0
+    };
+  }
+  if (mapping && typeof mapping === "object") {
+    const profileName = mapping.profile;
+    if (profileName && config.profiles && config.profiles[profileName]) {
+      const profile = config.profiles[profileName];
+      return {
+        thoughtsRepo: profile.thoughtsRepo,
+        reposDir: profile.reposDir,
+        globalDir: profile.globalDir,
+        profileName
+      };
+    }
+    return {
+      thoughtsRepo: config.thoughtsRepo,
+      reposDir: config.reposDir,
+      globalDir: config.globalDir,
+      profileName: void 0
+    };
+  }
+  return {
+    thoughtsRepo: config.thoughtsRepo,
+    reposDir: config.reposDir,
+    globalDir: config.globalDir,
+    profileName: void 0
+  };
+}
+function getRepoNameFromMapping(mapping) {
+  if (!mapping) return void 0;
+  if (typeof mapping === "string") return mapping;
+  return mapping.repo;
+}
+function getProfileNameFromMapping(mapping) {
+  if (!mapping) return void 0;
+  if (typeof mapping === "string") return void 0;
+  return mapping.profile;
+}
+function validateProfile(config, profileName) {
+  return !!(config.profiles && config.profiles[profileName]);
+}
+function sanitizeProfileName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+// src/commands/thoughts/init.ts
+function sanitizeDirectoryName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function checkExistingSetup(config) {
+  const thoughtsDir = path6.join(process.cwd(), "thoughts");
+  if (!fs4.existsSync(thoughtsDir)) {
+    return { exists: false, isValid: false };
+  }
+  if (!fs4.lstatSync(thoughtsDir).isDirectory()) {
+    return { exists: true, isValid: false, message: "thoughts exists but is not a directory" };
+  }
+  if (!config) {
+    return {
+      exists: true,
+      isValid: false,
+      message: "thoughts directory exists but configuration is missing"
+    };
+  }
+  const userPath = path6.join(thoughtsDir, config.user);
+  const sharedPath = path6.join(thoughtsDir, "shared");
+  const globalPath = path6.join(thoughtsDir, "global");
+  const hasUser = fs4.existsSync(userPath) && fs4.lstatSync(userPath).isSymbolicLink();
+  const hasShared = fs4.existsSync(sharedPath) && fs4.lstatSync(sharedPath).isSymbolicLink();
+  const hasGlobal = fs4.existsSync(globalPath) && fs4.lstatSync(globalPath).isSymbolicLink();
+  if (!hasUser || !hasShared || !hasGlobal) {
+    return {
+      exists: true,
+      isValid: false,
+      message: "thoughts directory exists but symlinks are missing or broken"
+    };
+  }
+  return { exists: true, isValid: true };
+}
+function setupGitHooks(repoPath) {
+  const updated = [];
+  let gitCommonDir;
+  try {
+    gitCommonDir = execSync2("git rev-parse --git-common-dir", {
+      cwd: repoPath,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+    if (!path6.isAbsolute(gitCommonDir)) {
+      gitCommonDir = path6.join(repoPath, gitCommonDir);
+    }
+  } catch (error) {
+    throw new Error(`Failed to find git common directory: ${error}`);
+  }
+  const hooksDir = path6.join(gitCommonDir, "hooks");
+  if (!fs4.existsSync(hooksDir)) {
+    fs4.mkdirSync(hooksDir, { recursive: true });
+  }
+  const preCommitPath = path6.join(hooksDir, "pre-commit");
+  const preCommitContent = generatePreCommitHook({ hookPath: preCommitPath });
+  const postCommitPath = path6.join(hooksDir, "post-commit");
+  const postCommitContent = generatePostCommitHook({ hookPath: postCommitPath });
+  const hookNeedsUpdate = (hookPath) => {
+    if (!fs4.existsSync(hookPath)) return true;
+    const content = fs4.readFileSync(hookPath, "utf8");
+    if (!content.includes("ThoughtCabinet thoughts")) return false;
+    const versionMatch = content.match(/# Version: (\d+)/);
+    if (!versionMatch) return true;
+    const currentVersion = parseInt(versionMatch[1]);
+    return currentVersion < parseInt(HOOK_VERSION);
+  };
+  if (fs4.existsSync(preCommitPath)) {
+    const content = fs4.readFileSync(preCommitPath, "utf8");
+    if (!content.includes("ThoughtCabinet thoughts") || hookNeedsUpdate(preCommitPath)) {
+      if (!content.includes("ThoughtCabinet thoughts")) {
+        fs4.renameSync(preCommitPath, `${preCommitPath}.old`);
+      } else {
+        fs4.unlinkSync(preCommitPath);
+      }
+    }
+  }
+  if (fs4.existsSync(postCommitPath)) {
+    const content = fs4.readFileSync(postCommitPath, "utf8");
+    if (!content.includes("ThoughtCabinet thoughts") || hookNeedsUpdate(postCommitPath)) {
+      if (!content.includes("ThoughtCabinet thoughts")) {
+        fs4.renameSync(postCommitPath, `${postCommitPath}.old`);
+      } else {
+        fs4.unlinkSync(postCommitPath);
+      }
+    }
+  }
+  if (!fs4.existsSync(preCommitPath) || hookNeedsUpdate(preCommitPath)) {
+    fs4.writeFileSync(preCommitPath, preCommitContent);
+    fs4.chmodSync(preCommitPath, "755");
+    updated.push("pre-commit");
+  }
+  if (!fs4.existsSync(postCommitPath) || hookNeedsUpdate(postCommitPath)) {
+    fs4.writeFileSync(postCommitPath, postCommitContent);
+    fs4.chmodSync(postCommitPath, "755");
+    updated.push("post-commit");
+  }
+  return { updated };
+}
+async function thoughtsInitCommand(options) {
+  try {
+    if (!options.directory && !process.stdin.isTTY) {
+      p.log.error("Not running in interactive terminal.");
+      p.log.info("Use --directory flag to specify the repository directory name.");
+      process.exit(1);
+    }
+    const currentRepo = getCurrentRepoPath();
+    try {
+      execSync2("git rev-parse --git-dir", { stdio: "pipe" });
+    } catch {
+      p.log.error("Not in a git repository");
+      process.exit(1);
+    }
+    let config = loadThoughtsConfig(options);
+    if (!config) {
+      p.intro(chalk2.blue("Initial Thoughts Setup"));
+      p.log.info("First, let's configure your global thoughts system.");
+      const defaultRepo = getDefaultThoughtsRepo();
+      p.log.message(
+        chalk2.gray("This is where all your thoughts across all projects will be stored.")
+      );
+      const thoughtsRepoInput = await p.text({
+        message: "Thoughts repository location:",
+        initialValue: defaultRepo,
+        placeholder: defaultRepo
+      });
+      if (p.isCancel(thoughtsRepoInput)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const thoughtsRepo = thoughtsRepoInput || defaultRepo;
+      p.log.message(chalk2.gray("Your thoughts will be organized into two main directories:"));
+      p.log.message(chalk2.gray("- Repository-specific thoughts (one subdirectory per project)"));
+      p.log.message(chalk2.gray("- Global thoughts (shared across all projects)"));
+      const reposDirInput = await p.text({
+        message: "Directory name for repository-specific thoughts:",
+        initialValue: "repos",
+        placeholder: "repos"
+      });
+      if (p.isCancel(reposDirInput)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const reposDir2 = reposDirInput || "repos";
+      const globalDirInput = await p.text({
+        message: "Directory name for global thoughts:",
+        initialValue: "global",
+        placeholder: "global"
+      });
+      if (p.isCancel(globalDirInput)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const globalDir = globalDirInput || "global";
+      const defaultUser = process.env.USER || "user";
+      let user = "";
+      while (!user || user.toLowerCase() === "global") {
+        const userInput = await p.text({
+          message: "Your username:",
+          initialValue: defaultUser,
+          placeholder: defaultUser,
+          validate: (value) => {
+            if (value.toLowerCase() === "global") {
+              return `Username cannot be "global" as it's reserved for cross-project thoughts.`;
+            }
+            return void 0;
+          }
+        });
+        if (p.isCancel(userInput)) {
+          p.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        user = userInput || defaultUser;
+      }
+      config = {
+        thoughtsRepo,
+        reposDir: reposDir2,
+        globalDir,
+        user,
+        repoMappings: {}
+      };
+      p.note(
+        `${chalk2.cyan(thoughtsRepo)}/
+  \u251C\u2500\u2500 ${chalk2.cyan(reposDir2)}/     ${chalk2.gray("(project-specific thoughts)")}
+  \u2514\u2500\u2500 ${chalk2.cyan(globalDir)}/    ${chalk2.gray("(cross-project thoughts)")}`,
+        "Creating thoughts structure"
+      );
+      ensureThoughtsRepoExists(thoughtsRepo, reposDir2, globalDir);
+      saveThoughtsConfig(config, options);
+      p.log.success("Global thoughts configuration created");
+    }
+    if (options.profile) {
+      if (!validateProfile(config, options.profile)) {
+        p.log.error(`Profile "${options.profile}" does not exist.`);
+        p.log.message(chalk2.gray("Available profiles:"));
+        if (config.profiles) {
+          Object.keys(config.profiles).forEach((name) => {
+            p.log.message(chalk2.gray(`  - ${name}`));
+          });
+        } else {
+          p.log.message(chalk2.gray("  (none)"));
+        }
+        p.log.warn("Create a profile first:");
+        p.log.message(chalk2.gray(`  thoughtcabinet profile create ${options.profile}`));
+        process.exit(1);
+      }
+    }
+    const tempProfileConfig = options.profile && config.profiles && config.profiles[options.profile] ? {
+      thoughtsRepo: config.profiles[options.profile].thoughtsRepo,
+      reposDir: config.profiles[options.profile].reposDir,
+      globalDir: config.profiles[options.profile].globalDir,
+      profileName: options.profile
+    } : {
+      thoughtsRepo: config.thoughtsRepo,
+      reposDir: config.reposDir,
+      globalDir: config.globalDir,
+      profileName: void 0
+    };
+    const setupStatus = checkExistingSetup(config);
+    if (setupStatus.exists && !options.force) {
+      if (setupStatus.isValid) {
+        p.log.warn("Thoughts directory already configured for this repository.");
+        const reconfigure = await p.confirm({
+          message: "Do you want to reconfigure?",
+          initialValue: false
+        });
+        if (p.isCancel(reconfigure) || !reconfigure) {
+          p.cancel("Setup cancelled.");
+          return;
+        }
+      } else {
+        p.log.warn(setupStatus.message || "Thoughts setup is incomplete");
+        const fix = await p.confirm({
+          message: "Do you want to fix the setup?",
+          initialValue: true
+        });
+        if (p.isCancel(fix) || !fix) {
+          p.cancel("Setup cancelled.");
+          return;
+        }
+      }
+    }
+    const expandedRepo = expandPath(tempProfileConfig.thoughtsRepo);
+    if (!fs4.existsSync(expandedRepo)) {
+      p.log.error(`Thoughts repository not found at ${tempProfileConfig.thoughtsRepo}`);
+      p.log.warn("The thoughts repository may have been moved or deleted.");
+      const recreate = await p.confirm({
+        message: "Do you want to recreate it?",
+        initialValue: true
+      });
+      if (p.isCancel(recreate) || !recreate) {
+        p.log.info("Please update your configuration or restore the thoughts repository.");
+        process.exit(1);
+      }
+      ensureThoughtsRepoExists(
+        tempProfileConfig.thoughtsRepo,
+        tempProfileConfig.reposDir,
+        tempProfileConfig.globalDir
+      );
+    }
+    const reposDir = path6.join(expandedRepo, tempProfileConfig.reposDir);
+    if (!fs4.existsSync(reposDir)) {
+      fs4.mkdirSync(reposDir, { recursive: true });
+    }
+    const existingRepos = fs4.readdirSync(reposDir).filter((name) => {
+      const fullPath = path6.join(reposDir, name);
+      return fs4.statSync(fullPath).isDirectory() && !name.startsWith(".");
+    });
+    const existingMapping = config.repoMappings[currentRepo];
+    let mappedName = getRepoNameFromMapping(existingMapping);
+    if (!mappedName) {
+      if (options.directory) {
+        const sanitizedDir = sanitizeDirectoryName(options.directory);
+        if (!existingRepos.includes(sanitizedDir)) {
+          p.log.error(`Directory "${sanitizedDir}" not found in thoughts repository.`);
+          p.log.error("In non-interactive mode (--directory), you must specify a directory");
+          p.log.error("name that already exists in the thoughts repository.");
+          p.log.warn("Available directories:");
+          existingRepos.forEach((repo) => p.log.message(chalk2.gray(`  - ${repo}`)));
+          process.exit(1);
+        }
+        mappedName = sanitizedDir;
+        p.log.success(
+          `Using existing: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/${mappedName}`
+        );
+      } else {
+        p.intro(chalk2.blue("Repository Setup"));
+        p.log.info(`Setting up thoughts for: ${chalk2.cyan(currentRepo)}`);
+        p.log.message(
+          chalk2.gray(
+            `This will create a subdirectory in ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/`
+          )
+        );
+        p.log.message(chalk2.gray("to store thoughts specific to this repository."));
+        if (existingRepos.length > 0) {
+          const selectOptions = [
+            ...existingRepos.map((repo) => ({ value: repo, label: `Use existing: ${repo}` })),
+            { value: "__create_new__", label: "Create new directory" }
+          ];
+          const selection = await p.select({
+            message: "Select or create a thoughts directory for this repository:",
+            options: selectOptions
+          });
+          if (p.isCancel(selection)) {
+            p.cancel("Operation cancelled.");
+            process.exit(0);
+          }
+          if (selection === "__create_new__") {
+            const defaultName = getRepoNameFromPath(currentRepo);
+            p.log.message(
+              chalk2.gray(
+                `This name will be used for the directory: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/[name]`
+              )
+            );
+            const nameInput = await p.text({
+              message: "Directory name for this project's thoughts:",
+              initialValue: defaultName,
+              placeholder: defaultName
+            });
+            if (p.isCancel(nameInput)) {
+              p.cancel("Operation cancelled.");
+              process.exit(0);
+            }
+            mappedName = nameInput || defaultName;
+            mappedName = sanitizeDirectoryName(mappedName);
+            p.log.success(
+              `Will create: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/${mappedName}`
+            );
+          } else {
+            mappedName = selection;
+            p.log.success(
+              `Will use existing: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/${mappedName}`
+            );
+          }
+        } else {
+          const defaultName = getRepoNameFromPath(currentRepo);
+          p.log.message(
+            chalk2.gray(
+              `This name will be used for the directory: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/[name]`
+            )
+          );
+          const nameInput = await p.text({
+            message: "Directory name for this project's thoughts:",
+            initialValue: defaultName,
+            placeholder: defaultName
+          });
+          if (p.isCancel(nameInput)) {
+            p.cancel("Operation cancelled.");
+            process.exit(0);
+          }
+          mappedName = nameInput || defaultName;
+          mappedName = sanitizeDirectoryName(mappedName);
+          p.log.success(
+            `Will create: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/${mappedName}`
+          );
+        }
+      }
+      if (options.profile) {
+        config.repoMappings[currentRepo] = {
+          repo: mappedName,
+          profile: options.profile
+        };
+      } else {
+        config.repoMappings[currentRepo] = mappedName;
+      }
+      saveThoughtsConfig(config, options);
+    }
+    if (!mappedName) {
+      mappedName = getRepoNameFromMapping(config.repoMappings[currentRepo]);
+    }
+    const profileConfig = resolveProfileForRepo(config, currentRepo);
+    createThoughtsDirectoryStructure(profileConfig, mappedName, config.user);
+    const thoughtsDir = path6.join(currentRepo, "thoughts");
+    if (fs4.existsSync(thoughtsDir)) {
+      const searchableDir = path6.join(thoughtsDir, "searchable");
+      if (fs4.existsSync(searchableDir)) {
+        try {
+          execSync2(`chmod -R 755 "${searchableDir}"`, { stdio: "pipe" });
+        } catch {
+        }
+      }
+      fs4.rmSync(thoughtsDir, { recursive: true, force: true });
+    }
+    fs4.mkdirSync(thoughtsDir);
+    const repoTarget = getRepoThoughtsPath(profileConfig, mappedName);
+    const globalTarget = getGlobalThoughtsPath(profileConfig);
+    fs4.symlinkSync(path6.join(repoTarget, config.user), path6.join(thoughtsDir, config.user), "dir");
+    fs4.symlinkSync(path6.join(repoTarget, "shared"), path6.join(thoughtsDir, "shared"), "dir");
+    fs4.symlinkSync(globalTarget, path6.join(thoughtsDir, "global"), "dir");
+    const otherUsers = updateSymlinksForNewUsers(
+      currentRepo,
+      profileConfig,
+      mappedName,
+      config.user
+    );
+    if (otherUsers.length > 0) {
+      p.log.success(`Added symlinks for other users: ${otherUsers.join(", ")}`);
+    }
+    try {
+      execSync2("git remote get-url origin", { cwd: expandedRepo, stdio: "pipe" });
+      try {
+        execSync2("git pull --rebase", {
+          stdio: "pipe",
+          cwd: expandedRepo
+        });
+        p.log.success("Pulled latest thoughts from remote");
+      } catch (error) {
+        p.log.warn(`Could not pull latest thoughts: ${error.message}`);
+      }
+    } catch {
+    }
+    const claudeMd = generateClaudeMd({
+      thoughtsRepo: profileConfig.thoughtsRepo,
+      reposDir: profileConfig.reposDir,
+      repoName: mappedName,
+      user: config.user
+    });
+    fs4.writeFileSync(path6.join(thoughtsDir, "CLAUDE.md"), claudeMd);
+    const hookResult = setupGitHooks(currentRepo);
+    if (hookResult.updated.length > 0) {
+      p.log.step(`Updated git hooks: ${hookResult.updated.join(", ")}`);
+    }
+    p.log.success("Thoughts setup complete!");
+    const structureText = `${chalk2.cyan(currentRepo)}/
+  \u2514\u2500\u2500 thoughts/
+       \u251C\u2500\u2500 ${config.user}/     ${chalk2.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.reposDir}/${mappedName}/${config.user}/`)}
+       \u251C\u2500\u2500 shared/      ${chalk2.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.reposDir}/${mappedName}/shared/`)}
+       \u2514\u2500\u2500 global/      ${chalk2.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.globalDir}/`)}
+           \u251C\u2500\u2500 ${config.user}/     ${chalk2.gray("(your cross-repo notes)")}
+           \u2514\u2500\u2500 shared/  ${chalk2.gray("(team cross-repo notes)")}`;
+    p.note(structureText, "Repository structure created");
+    p.note(
+      `${chalk2.green("\u2713")} Pre-commit hook: Prevents committing thoughts/
+${chalk2.green("\u2713")} Post-commit hook: Auto-syncs thoughts after commits`,
+      "Protection enabled"
+    );
+    p.outro(
+      chalk2.gray("Next steps:\n") + chalk2.gray(
+        `  1. Run ${chalk2.cyan("thoughtcabinet sync")} to create the searchable index
+`
+      ) + chalk2.gray(
+        `  2. Create markdown files in ${chalk2.cyan(`thoughts/${config.user}/`)} for your notes
+`
+      ) + chalk2.gray(`  3. Your thoughts will sync automatically when you commit code
+`) + chalk2.gray(`  4. Run ${chalk2.cyan("thoughtcabinet status")} to check sync status`)
+    );
+  } catch (error) {
+    p.log.error(`Error during thoughts init: ${error}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/destroy.ts
+import fs5 from "fs";
+import path7 from "path";
+import { execSync as execSync3 } from "child_process";
+import chalk3 from "chalk";
+async function thoughtsDestoryCommand(options) {
+  try {
+    const currentRepo = getCurrentRepoPath();
+    const thoughtsDir = path7.join(currentRepo, "thoughts");
+    if (!fs5.existsSync(thoughtsDir)) {
+      console.error(chalk3.red("Error: Thoughts not initialized for this repository."));
+      process.exit(1);
+    }
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      console.error(chalk3.red("Error: Thoughts configuration not found."));
+      process.exit(1);
+    }
+    const mapping = config.repoMappings[currentRepo];
+    const mappedName = getRepoNameFromMapping(mapping);
+    const profileName = getProfileNameFromMapping(mapping);
+    if (!mappedName && !options.force) {
+      console.error(chalk3.red("Error: This repository is not in the thoughts configuration."));
+      console.error(chalk3.yellow("Use --force to remove the thoughts directory anyway."));
+      process.exit(1);
+    }
+    console.log(chalk3.blue("Removing thoughts setup from current repository..."));
+    const searchableDir = path7.join(thoughtsDir, "searchable");
+    if (fs5.existsSync(searchableDir)) {
+      console.log(chalk3.gray("Removing searchable directory..."));
+      try {
+        execSync3(`chmod -R 755 "${searchableDir}"`, { stdio: "pipe" });
+      } catch {
+      }
+      fs5.rmSync(searchableDir, { recursive: true, force: true });
+    }
+    console.log(chalk3.gray("Removing thoughts directory (symlinks only)..."));
+    try {
+      fs5.rmSync(thoughtsDir, { recursive: true, force: true });
+    } catch (error) {
+      console.error(chalk3.red(`Error removing thoughts directory: ${error}`));
+      console.error(chalk3.yellow("You may need to manually remove: " + thoughtsDir));
+      process.exit(1);
+    }
+    if (mappedName) {
+      console.log(chalk3.gray("Removing repository from thoughts configuration..."));
+      delete config.repoMappings[currentRepo];
+      saveThoughtsConfig(config, options);
+    }
+    console.log(chalk3.green("\u2705 Thoughts removed from repository"));
+    if (mappedName) {
+      console.log("");
+      console.log(chalk3.gray("Note: Your thoughts content remains safe in:"));
+      if (profileName && config.profiles && config.profiles[profileName]) {
+        const profile = config.profiles[profileName];
+        console.log(chalk3.gray(`  ${profile.thoughtsRepo}/${profile.reposDir}/${mappedName}`));
+        console.log(chalk3.gray(`  (profile: ${profileName})`));
+      } else {
+        console.log(chalk3.gray(`  ${config.thoughtsRepo}/${config.reposDir}/${mappedName}`));
+      }
+      console.log(chalk3.gray("Only the local symlinks and configuration were removed."));
+    }
+  } catch (error) {
+    console.error(chalk3.red(`Error during thoughts destroy: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/sync.ts
+import fs6 from "fs";
+import path8 from "path";
+import { execSync as execSync4, execFileSync } from "child_process";
+import chalk4 from "chalk";
+function checkGitStatus(repoPath) {
+  try {
+    const status = execSync4("git status --porcelain", {
+      cwd: repoPath,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    return status.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function syncThoughts(thoughtsRepo, message) {
+  const expandedRepo = expandPath(thoughtsRepo);
+  try {
+    execSync4("git add -A", { cwd: expandedRepo, stdio: "pipe" });
+    const hasChanges = checkGitStatus(expandedRepo);
+    if (hasChanges) {
+      const commitMessage = message || `Sync thoughts - ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      execFileSync("git", ["commit", "-m", commitMessage], { cwd: expandedRepo, stdio: "pipe" });
+      console.log(chalk4.green("\u2705 Thoughts synchronized"));
+    } else {
+      console.log(chalk4.gray("No changes to commit"));
+    }
+    try {
+      execSync4("git pull --rebase", {
+        stdio: "pipe",
+        cwd: expandedRepo
+      });
+    } catch (error) {
+      const errorStr = error.toString();
+      if (errorStr.includes("CONFLICT (") || errorStr.includes("Automatic merge failed") || errorStr.includes("Patch failed at") || errorStr.includes('When you have resolved this problem, run "git rebase --continue"')) {
+        console.error(chalk4.red("Error: Merge conflict detected in thoughts repository"));
+        console.error(chalk4.red("Please resolve conflicts manually in:"), expandedRepo);
+        console.error(chalk4.red('Then run "git rebase --continue" and "thoughtcabinet sync" again'));
+        process.exit(1);
+      } else {
+        console.warn(chalk4.yellow("Warning: Could not pull latest changes:"), error.message);
+      }
+    }
+    try {
+      execSync4("git remote get-url origin", { cwd: expandedRepo, stdio: "pipe" });
+      console.log(chalk4.gray("Pushing to remote..."));
+      try {
+        execSync4("git push", { cwd: expandedRepo, stdio: "pipe" });
+        console.log(chalk4.green("\u2705 Pushed to remote"));
+      } catch {
+        console.log(chalk4.yellow("\u26A0\uFE0F  Could not push to remote. You may need to push manually."));
+      }
+    } catch {
+      console.log(chalk4.yellow("\u2139\uFE0F  No remote configured for thoughts repository"));
+    }
+  } catch (error) {
+    console.error(chalk4.red(`Error syncing thoughts: ${error}`));
+    process.exit(1);
+  }
+}
+function createSearchDirectory(thoughtsDir) {
+  const searchDir = path8.join(thoughtsDir, "searchable");
+  if (fs6.existsSync(searchDir)) {
+    try {
+      execSync4(`chmod -R 755 "${searchDir}"`, { stdio: "pipe" });
+    } catch {
+    }
+    fs6.rmSync(searchDir, { recursive: true, force: true });
+  }
+  fs6.mkdirSync(searchDir, { recursive: true });
+  function findFilesFollowingSymlinks(dir, baseDir = dir, visited = /* @__PURE__ */ new Set()) {
+    const files = [];
+    const realPath = fs6.realpathSync(dir);
+    if (visited.has(realPath)) {
+      return files;
+    }
+    visited.add(realPath);
+    const entries = fs6.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(dir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        files.push(...findFilesFollowingSymlinks(fullPath, baseDir, visited));
+      } else if (entry.isSymbolicLink() && !entry.name.startsWith(".")) {
+        try {
+          const stat = fs6.statSync(fullPath);
+          if (stat.isDirectory()) {
+            files.push(...findFilesFollowingSymlinks(fullPath, baseDir, visited));
+          } else if (stat.isFile() && path8.basename(fullPath) !== "CLAUDE.md") {
+            files.push(path8.relative(baseDir, fullPath));
+          }
+        } catch {
+        }
+      } else if (entry.isFile() && !entry.name.startsWith(".") && entry.name !== "CLAUDE.md") {
+        files.push(path8.relative(baseDir, fullPath));
+      }
+    }
+    return files;
+  }
+  const allFiles = findFilesFollowingSymlinks(thoughtsDir);
+  let linkedCount = 0;
+  for (const relPath of allFiles) {
+    const sourcePath = path8.join(thoughtsDir, relPath);
+    const targetPath = path8.join(searchDir, relPath);
+    const targetDir = path8.dirname(targetPath);
+    if (!fs6.existsSync(targetDir)) {
+      fs6.mkdirSync(targetDir, { recursive: true });
+    }
+    try {
+      const realSourcePath = fs6.realpathSync(sourcePath);
+      fs6.linkSync(realSourcePath, targetPath);
+      linkedCount++;
+    } catch {
+    }
+  }
+  console.log(chalk4.gray(`Created ${linkedCount} hard links in searchable directory`));
+}
+async function thoughtsSyncCommand(options) {
+  try {
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      console.error(chalk4.red('Error: Thoughts not configured. Run "thoughtcabinet init" first.'));
+      process.exit(1);
+    }
+    const currentRepo = getCurrentRepoPath();
+    const thoughtsDir = path8.join(currentRepo, "thoughts");
+    if (!fs6.existsSync(thoughtsDir)) {
+      console.error(chalk4.red("Error: Thoughts not initialized for this repository."));
+      console.error('Run "thoughtcabinet init" to set up thoughts.');
+      process.exit(1);
+    }
+    const mapping = config.repoMappings[currentRepo];
+    const mappedName = getRepoNameFromMapping(mapping);
+    const profileConfig = resolveProfileForRepo(config, currentRepo);
+    if (mappedName) {
+      const newUsers = updateSymlinksForNewUsers(
+        currentRepo,
+        profileConfig,
+        mappedName,
+        config.user
+      );
+      if (newUsers.length > 0) {
+        console.log(chalk4.green(`\u2713 Added symlinks for new users: ${newUsers.join(", ")}`));
+      }
+    }
+    console.log(chalk4.blue("Creating searchable index..."));
+    createSearchDirectory(thoughtsDir);
+    console.log(chalk4.blue("Syncing thoughts..."));
+    syncThoughts(profileConfig.thoughtsRepo, options.message || "");
+  } catch (error) {
+    console.error(chalk4.red(`Error during thoughts sync: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/status.ts
+import fs7 from "fs";
+import path9 from "path";
+import { execSync as execSync5 } from "child_process";
+import chalk5 from "chalk";
+function getGitStatus(repoPath) {
+  try {
+    return execSync5("git status -sb", {
+      cwd: repoPath,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+  } catch {
+    return "Not a git repository";
+  }
+}
+function getUncommittedChanges(repoPath) {
+  try {
+    const output = execSync5("git status --porcelain", {
+      cwd: repoPath,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    return output.split("\n").filter((line) => line.trim()).map((line) => {
+      const status = line.substring(0, 2);
+      const file = line.substring(3);
+      let statusText = "";
+      if (status[0] === "M" || status[1] === "M") statusText = "modified";
+      else if (status[0] === "A") statusText = "added";
+      else if (status[0] === "D") statusText = "deleted";
+      else if (status[0] === "?") statusText = "untracked";
+      else if (status[0] === "R") statusText = "renamed";
+      return `  ${chalk5.yellow(statusText.padEnd(10))} ${file}`;
+    });
+  } catch {
+    return [];
+  }
+}
+function getLastCommit(repoPath) {
+  try {
+    return execSync5('git log -1 --pretty=format:"%h %s (%cr)"', {
+      cwd: repoPath,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+  } catch {
+    return "No commits yet";
+  }
+}
+function getRemoteStatus(repoPath) {
+  try {
+    execSync5("git remote get-url origin", { cwd: repoPath, stdio: "pipe" });
+    try {
+      execSync5("git fetch", { cwd: repoPath, stdio: "pipe" });
+    } catch {
+    }
+    const status = execSync5("git status -sb", {
+      cwd: repoPath,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    if (status.includes("ahead")) {
+      const ahead = status.match(/ahead (\d+)/)?.[1] || "?";
+      return chalk5.yellow(`${ahead} commits ahead of remote`);
+    } else if (status.includes("behind")) {
+      const behind = status.match(/behind (\d+)/)?.[1] || "?";
+      try {
+        execSync5("git pull --rebase", {
+          stdio: "pipe",
+          cwd: repoPath
+        });
+        console.log(chalk5.green("\u2713 Automatically pulled latest changes"));
+        const newStatus = execSync5("git status -sb", {
+          encoding: "utf8",
+          cwd: repoPath,
+          stdio: "pipe"
+        });
+        if (newStatus.includes("behind")) {
+          const newBehind = newStatus.match(/behind (\d+)/)?.[1] || "?";
+          return chalk5.yellow(`${newBehind} commits behind remote (after pull)`);
+        } else {
+          return chalk5.green("Up to date with remote (after pull)");
+        }
+      } catch {
+        return chalk5.yellow(`${behind} commits behind remote`);
+      }
+    } else {
+      return chalk5.green("Up to date with remote");
+    }
+  } catch {
+    return chalk5.gray("No remote configured");
+  }
+}
+async function thoughtsStatusCommand(options) {
+  try {
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      console.error(chalk5.red('Error: Thoughts not configured. Run "thoughtcabinet init" first.'));
+      process.exit(1);
+    }
+    console.log(chalk5.blue("Thoughts Repository Status"));
+    console.log(chalk5.gray("=".repeat(50)));
+    console.log("");
+    console.log(chalk5.yellow("Configuration:"));
+    console.log(`  Repository: ${chalk5.cyan(config.thoughtsRepo)}`);
+    console.log(`  Repos directory: ${chalk5.cyan(config.reposDir)}`);
+    console.log(`  Global directory: ${chalk5.cyan(config.globalDir)}`);
+    console.log(`  User: ${chalk5.cyan(config.user)}`);
+    console.log(`  Mapped repos: ${chalk5.cyan(Object.keys(config.repoMappings).length)}`);
+    console.log("");
+    const currentRepo = getCurrentRepoPath();
+    const currentMapping = config.repoMappings[currentRepo];
+    const mappedName = getRepoNameFromMapping(currentMapping);
+    const profileName = getProfileNameFromMapping(currentMapping);
+    const profileConfig = resolveProfileForRepo(config, currentRepo);
+    if (mappedName) {
+      console.log(chalk5.yellow("Current Repository:"));
+      console.log(`  Path: ${chalk5.cyan(currentRepo)}`);
+      console.log(`  Thoughts directory: ${chalk5.cyan(`${profileConfig.reposDir}/${mappedName}`)}`);
+      if (profileName) {
+        console.log(`  Profile: ${chalk5.cyan(profileName)}`);
+      } else {
+        console.log(`  Profile: ${chalk5.gray("(default)")}`);
+      }
+      const thoughtsDir = path9.join(currentRepo, "thoughts");
+      if (fs7.existsSync(thoughtsDir)) {
+        console.log(`  Status: ${chalk5.green("\u2713 Initialized")}`);
+      } else {
+        console.log(`  Status: ${chalk5.red("\u2717 Not initialized")}`);
+      }
+    } else {
+      console.log(chalk5.yellow("Current repository not mapped to thoughts"));
+    }
+    console.log("");
+    const expandedRepo = expandPath(profileConfig.thoughtsRepo);
+    console.log(chalk5.yellow("Thoughts Repository Git Status:"));
+    if (profileName) {
+      console.log(chalk5.gray(`  (using profile: ${profileName})`));
+    }
+    console.log(`  ${getGitStatus(expandedRepo)}`);
+    console.log(`  Remote: ${getRemoteStatus(expandedRepo)}`);
+    console.log(`  Last commit: ${getLastCommit(expandedRepo)}`);
+    console.log("");
+    const changes = getUncommittedChanges(expandedRepo);
+    if (changes.length > 0) {
+      console.log(chalk5.yellow("Uncommitted changes:"));
+      changes.forEach((change) => console.log(change));
+      console.log("");
+      console.log(chalk5.gray('Run "thoughtcabinet sync" to commit these changes'));
+    } else {
+      console.log(chalk5.green("\u2713 No uncommitted changes"));
+    }
+  } catch (error) {
+    console.error(chalk5.red(`Error checking thoughts status: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/config.ts
+import { spawn } from "child_process";
+import chalk6 from "chalk";
+async function thoughtsConfigCommand(options) {
+  try {
+    const configPath = options.configFile || getDefaultConfigPath();
+    if (options.edit) {
+      const editor = process.env.EDITOR || "vi";
+      spawn(editor, [configPath], { stdio: "inherit" });
+      return;
+    }
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      console.error(chalk6.red("No thoughts configuration found."));
+      console.error('Run "thoughtcabinet init" to create one.');
+      process.exit(1);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+    console.log(chalk6.blue("Thoughts Configuration"));
+    console.log(chalk6.gray("=".repeat(50)));
+    console.log("");
+    console.log(chalk6.yellow("Settings:"));
+    console.log(`  Config file: ${chalk6.cyan(configPath)}`);
+    console.log(`  Thoughts repository: ${chalk6.cyan(config.thoughtsRepo)}`);
+    console.log(`  Repos directory: ${chalk6.cyan(config.reposDir)}`);
+    console.log(`  Global directory: ${chalk6.cyan(config.globalDir)}`);
+    console.log(`  User: ${chalk6.cyan(config.user)}`);
+    console.log("");
+    console.log(chalk6.yellow("Repository Mappings:"));
+    const mappings = Object.entries(config.repoMappings);
+    if (mappings.length === 0) {
+      console.log(chalk6.gray("  No repositories mapped yet"));
+    } else {
+      mappings.forEach(([repo, mapping]) => {
+        const repoName = getRepoNameFromMapping(mapping);
+        const profileName = getProfileNameFromMapping(mapping);
+        console.log(`  ${chalk6.cyan(repo)}`);
+        console.log(`    \u2192 ${chalk6.green(`${config.reposDir}/${repoName}`)}`);
+        if (profileName) {
+          console.log(`    Profile: ${chalk6.yellow(profileName)}`);
+        } else {
+          console.log(`    Profile: ${chalk6.gray("(default)")}`);
+        }
+      });
+    }
+    console.log("");
+    console.log(chalk6.yellow("Profiles:"));
+    if (!config.profiles || Object.keys(config.profiles).length === 0) {
+      console.log(chalk6.gray("  No profiles configured"));
+    } else {
+      Object.keys(config.profiles).forEach((name) => {
+        console.log(`  ${chalk6.cyan(name)}`);
+      });
+    }
+    console.log("");
+    console.log(chalk6.gray("To edit configuration, run: thoughtcabinet config --edit"));
+  } catch (error) {
+    console.error(chalk6.red(`Error showing thoughts config: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/profile/create.ts
+import chalk7 from "chalk";
+import * as p2 from "@clack/prompts";
+async function profileCreateCommand(profileName, options) {
+  try {
+    if (!options.repo || !options.reposDir || !options.globalDir) {
+      if (!process.stdin.isTTY) {
+        p2.log.error("Not running in interactive terminal.");
+        p2.log.info("Provide all options: --repo, --repos-dir, --global-dir");
+        process.exit(1);
+      }
+    }
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      p2.log.error("Thoughts not configured.");
+      p2.log.info('Run "thoughtcabinet init" first to set up the base configuration.');
+      process.exit(1);
+    }
+    const sanitizedName = sanitizeProfileName(profileName);
+    if (sanitizedName !== profileName) {
+      p2.log.warn(`Profile name sanitized: "${profileName}" \u2192 "${sanitizedName}"`);
+    }
+    p2.intro(chalk7.blue(`Creating Profile: ${sanitizedName}`));
+    if (validateProfile(config, sanitizedName)) {
+      p2.log.error(`Profile "${sanitizedName}" already exists.`);
+      p2.log.info("Use a different name or delete the existing profile first.");
+      process.exit(1);
+    }
+    let thoughtsRepo;
+    let reposDir;
+    let globalDir;
+    if (options.repo && options.reposDir && options.globalDir) {
+      thoughtsRepo = options.repo;
+      reposDir = options.reposDir;
+      globalDir = options.globalDir;
+    } else {
+      const defaultRepo = getDefaultThoughtsRepo() + `-${sanitizedName}`;
+      p2.log.info("Specify the thoughts repository location for this profile.");
+      const repoInput = await p2.text({
+        message: "Thoughts repository:",
+        initialValue: defaultRepo,
+        placeholder: defaultRepo
+      });
+      if (p2.isCancel(repoInput)) {
+        p2.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      thoughtsRepo = repoInput || defaultRepo;
+      const reposDirInput = await p2.text({
+        message: "Repository-specific thoughts directory:",
+        initialValue: "repos",
+        placeholder: "repos"
+      });
+      if (p2.isCancel(reposDirInput)) {
+        p2.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      reposDir = reposDirInput || "repos";
+      const globalDirInput = await p2.text({
+        message: "Global thoughts directory:",
+        initialValue: "global",
+        placeholder: "global"
+      });
+      if (p2.isCancel(globalDirInput)) {
+        p2.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      globalDir = globalDirInput || "global";
+    }
+    const profileConfig = {
+      thoughtsRepo,
+      reposDir,
+      globalDir
+    };
+    if (!config.profiles) {
+      config.profiles = {};
+    }
+    config.profiles[sanitizedName] = profileConfig;
+    saveThoughtsConfig(config, options);
+    p2.log.step("Initializing profile thoughts repository...");
+    ensureThoughtsRepoExists(profileConfig);
+    p2.log.success(`Profile "${sanitizedName}" created successfully!`);
+    p2.note(
+      `Name: ${chalk7.cyan(sanitizedName)}
+Thoughts repository: ${chalk7.cyan(thoughtsRepo)}
+Repos directory: ${chalk7.cyan(reposDir)}
+Global directory: ${chalk7.cyan(globalDir)}`,
+      "Profile Configuration"
+    );
+    p2.outro(
+      chalk7.gray("Next steps:\n") + chalk7.gray(`  1. Run "thoughtcabinet init --profile ${sanitizedName}" in a repository
+`) + chalk7.gray(`  2. Your thoughts will sync to the profile's repository`)
+    );
+  } catch (error) {
+    p2.log.error(`Error creating profile: ${error}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/profile/list.ts
+import chalk8 from "chalk";
+async function profileListCommand(options) {
+  try {
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      console.error(chalk8.red("Error: Thoughts not configured."));
+      process.exit(1);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(config.profiles || {}, null, 2));
+      return;
+    }
+    console.log(chalk8.blue("Thoughts Profiles"));
+    console.log(chalk8.gray("=".repeat(50)));
+    console.log("");
+    console.log(chalk8.yellow("Default Configuration:"));
+    console.log(`  Thoughts repository: ${chalk8.cyan(config.thoughtsRepo)}`);
+    console.log(`  Repos directory: ${chalk8.cyan(config.reposDir)}`);
+    console.log(`  Global directory: ${chalk8.cyan(config.globalDir)}`);
+    console.log("");
+    if (!config.profiles || Object.keys(config.profiles).length === 0) {
+      console.log(chalk8.gray("No profiles configured."));
+      console.log("");
+      console.log(chalk8.gray("Create a profile with: thoughtcabinet profile create <name>"));
+    } else {
+      console.log(chalk8.yellow(`Profiles (${Object.keys(config.profiles).length}):`));
+      console.log("");
+      Object.entries(config.profiles).forEach(([name, profile]) => {
+        console.log(chalk8.cyan(`  ${name}:`));
+        console.log(`    Thoughts repository: ${profile.thoughtsRepo}`);
+        console.log(`    Repos directory: ${profile.reposDir}`);
+        console.log(`    Global directory: ${profile.globalDir}`);
+        console.log("");
+      });
+    }
+  } catch (error) {
+    console.error(chalk8.red(`Error listing profiles: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/profile/show.ts
+import chalk9 from "chalk";
+async function profileShowCommand(profileName, options) {
+  try {
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      console.error(chalk9.red("Error: Thoughts not configured."));
+      process.exit(1);
+    }
+    if (!validateProfile(config, profileName)) {
+      console.error(chalk9.red(`Error: Profile "${profileName}" not found.`));
+      console.error("");
+      console.error(chalk9.gray("Available profiles:"));
+      if (config.profiles) {
+        Object.keys(config.profiles).forEach((name) => {
+          console.error(chalk9.gray(`  - ${name}`));
+        });
+      } else {
+        console.error(chalk9.gray("  (none)"));
+      }
+      process.exit(1);
+    }
+    const profile = config.profiles[profileName];
+    if (options.json) {
+      console.log(JSON.stringify(profile, null, 2));
+      return;
+    }
+    console.log(chalk9.blue(`Profile: ${profileName}`));
+    console.log(chalk9.gray("=".repeat(50)));
+    console.log("");
+    console.log(chalk9.yellow("Configuration:"));
+    console.log(`  Thoughts repository: ${chalk9.cyan(profile.thoughtsRepo)}`);
+    console.log(`  Repos directory: ${chalk9.cyan(profile.reposDir)}`);
+    console.log(`  Global directory: ${chalk9.cyan(profile.globalDir)}`);
+    console.log("");
+    let repoCount = 0;
+    Object.values(config.repoMappings).forEach((mapping) => {
+      if (typeof mapping === "object" && mapping.profile === profileName) {
+        repoCount++;
+      }
+    });
+    console.log(chalk9.yellow("Usage:"));
+    console.log(`  Repositories using this profile: ${chalk9.cyan(repoCount)}`);
+  } catch (error) {
+    console.error(chalk9.red(`Error showing profile: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/profile/delete.ts
+import chalk10 from "chalk";
+import * as p3 from "@clack/prompts";
+async function profileDeleteCommand(profileName, options) {
+  try {
+    if (!options.force && !process.stdin.isTTY) {
+      p3.log.error("Not running in interactive terminal.");
+      p3.log.info("Use --force flag to delete without confirmation.");
+      process.exit(1);
+    }
+    p3.intro(chalk10.blue(`Delete Profile: ${profileName}`));
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      p3.log.error("Thoughts not configured.");
+      process.exit(1);
+    }
+    if (!validateProfile(config, profileName)) {
+      p3.log.error(`Profile "${profileName}" not found.`);
+      process.exit(1);
+    }
+    const usingRepos = [];
+    Object.entries(config.repoMappings).forEach(([repoPath, mapping]) => {
+      if (typeof mapping === "object" && mapping.profile === profileName) {
+        usingRepos.push(repoPath);
+      }
+    });
+    if (usingRepos.length > 0 && !options.force) {
+      p3.log.error(`Profile "${profileName}" is in use by ${usingRepos.length} repository(ies):`);
+      usingRepos.forEach((repo) => {
+        p3.log.message(chalk10.gray(`  - ${repo}`));
+      });
+      p3.log.warn("Options:");
+      p3.log.message(chalk10.gray('  1. Run "thoughtcabinet destroy" in each repository'));
+      p3.log.message(
+        chalk10.gray("  2. Use --force to delete anyway (repos will fall back to default config)")
+      );
+      process.exit(1);
+    }
+    if (!options.force) {
+      p3.log.warn(`You are about to delete profile: ${chalk10.cyan(profileName)}`);
+      p3.log.message(chalk10.gray("This will remove the profile configuration."));
+      p3.log.message(chalk10.gray("The thoughts repository files will NOT be deleted."));
+      const confirmDelete = await p3.confirm({
+        message: `Delete profile "${profileName}"?`,
+        initialValue: false
+      });
+      if (p3.isCancel(confirmDelete) || !confirmDelete) {
+        p3.cancel("Deletion cancelled.");
+        return;
+      }
+    }
+    delete config.profiles[profileName];
+    if (Object.keys(config.profiles).length === 0) {
+      delete config.profiles;
+    }
+    saveThoughtsConfig(config, options);
+    p3.log.success(`Profile "${profileName}" deleted`);
+    if (usingRepos.length > 0) {
+      p3.log.warn("Repositories using this profile will fall back to default config");
+    }
+    p3.outro(chalk10.green("Done"));
+  } catch (error) {
+    p3.log.error(`Error deleting profile: ${error}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts.ts
+function thoughtsCommand(program2) {
+  const cmd = program2;
+  cmd.command("init").description("Initialize thoughts for current repository").option("--force", "Force reconfiguration even if already set up").option("--config-file <path>", "Path to config file").option(
+    "--directory <name>",
+    "Specify the repository directory name (skips interactive prompt)"
+  ).option("--profile <name>", "Use a specific thoughts profile").action(thoughtsInitCommand);
+  cmd.command("destroy").description("Remove thoughts setup from current repository").option("--force", "Force removal even if not in configuration").option("--config-file <path>", "Path to config file").action(thoughtsDestoryCommand);
+  cmd.command("sync").description("Manually sync thoughts to thoughts repository").option("-m, --message <message>", "Commit message for sync").option("--config-file <path>", "Path to config file").action(thoughtsSyncCommand);
+  cmd.command("status").description("Show status of thoughts repository").option("--config-file <path>", "Path to config file").action(thoughtsStatusCommand);
+  cmd.command("config").description("View or edit thoughts configuration").option("--edit", "Open configuration in editor").option("--json", "Output configuration as JSON").option("--config-file <path>", "Path to config file").action(thoughtsConfigCommand);
+  const profile = cmd.command("profile").description("Manage thoughts profiles");
+  profile.command("create <name>").description("Create a new thoughts profile").option("--repo <path>", "Thoughts repository path").option("--repos-dir <name>", "Repos directory name").option("--global-dir <name>", "Global directory name").option("--config-file <path>", "Path to config file").action(profileCreateCommand);
+  profile.command("list").description("List all thoughts profiles").option("--json", "Output as JSON").option("--config-file <path>", "Path to config file").action(profileListCommand);
+  profile.command("show <name>").description("Show details of a specific profile").option("--json", "Output as JSON").option("--config-file <path>", "Path to config file").action(profileShowCommand);
+  profile.command("delete <name>").description("Delete a thoughts profile").option("--force", "Force deletion even if in use").option("--config-file <path>", "Path to config file").action(profileDeleteCommand);
+}
+
+// src/commands/agent/init.ts
+import fs8 from "fs";
+import path10 from "path";
+import chalk11 from "chalk";
+import * as p4 from "@clack/prompts";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function ensureGitignoreEntry(targetDir, entry, productName) {
+  const gitignorePath = path10.join(targetDir, ".gitignore");
+  let gitignoreContent = "";
+  if (fs8.existsSync(gitignorePath)) {
+    gitignoreContent = fs8.readFileSync(gitignorePath, "utf8");
+  }
+  const lines = gitignoreContent.split("\n");
+  if (lines.some((line) => line.trim() === entry)) {
+    return;
+  }
+  const newContent = gitignoreContent + (gitignoreContent && !gitignoreContent.endsWith("\n") ? "\n" : "") + "\n# " + productName + " local settings\n" + entry + "\n";
+  fs8.writeFileSync(gitignorePath, newContent);
+}
+function copyDirectoryRecursive(sourceDir, targetDir) {
+  let filesCopied = 0;
+  fs8.mkdirSync(targetDir, { recursive: true });
+  const entries = fs8.readdirSync(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path10.join(sourceDir, entry.name);
+    const targetPath = path10.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      filesCopied += copyDirectoryRecursive(sourcePath, targetPath);
+    } else {
+      fs8.copyFileSync(sourcePath, targetPath);
+      filesCopied++;
+    }
+  }
+  return filesCopied;
+}
+async function agentInitCommand(options) {
+  const { product } = options;
+  try {
+    p4.intro(chalk11.blue(`Initialize ${product.name} Configuration`));
+    if (!process.stdin.isTTY && !options.all) {
+      p4.log.error("Not running in interactive terminal.");
+      p4.log.info("Use --all flag to copy all files without prompting.");
+      process.exit(1);
+    }
+    const targetDir = process.cwd();
+    const agentTargetDir = path10.join(targetDir, product.dirName);
+    const possiblePaths = [
+      // When installed via npm: package root is one level up from dist
+      path10.resolve(__dirname2, "..", product.sourceDirName),
+      // When running from repo: repo root is two levels up from dist
+      path10.resolve(__dirname2, "../..", product.sourceDirName)
+    ];
+    let sourceAgentDir = null;
+    for (const candidatePath of possiblePaths) {
+      if (fs8.existsSync(candidatePath)) {
+        sourceAgentDir = candidatePath;
+        break;
+      }
+    }
+    if (!sourceAgentDir) {
+      p4.log.error(`Source ${product.dirName} directory not found in expected locations`);
+      p4.log.info("Searched paths:");
+      possiblePaths.forEach((candidatePath) => {
+        p4.log.info(`  - ${candidatePath}`);
+      });
+      p4.log.info("Are you running from the thoughtcabinet repository or npm package?");
+      process.exit(1);
+    }
+    if (fs8.existsSync(agentTargetDir) && !options.force) {
+      const overwrite = await p4.confirm({
+        message: `${product.dirName} directory already exists. Overwrite?`,
+        initialValue: false
+      });
+      if (p4.isCancel(overwrite) || !overwrite) {
+        p4.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+    let selectedCategories;
+    if (options.all) {
+      selectedCategories = ["commands", "agents", "skills", "settings"];
+    } else {
+      let commandsCount = 0;
+      let agentsCount = 0;
+      const commandsDir = path10.join(sourceAgentDir, "commands");
+      const agentsDir = path10.join(sourceAgentDir, "agents");
+      if (fs8.existsSync(commandsDir)) {
+        commandsCount = fs8.readdirSync(commandsDir).length;
+      }
+      if (fs8.existsSync(agentsDir)) {
+        agentsCount = fs8.readdirSync(agentsDir).length;
+      }
+      let skillsCount = 0;
+      const skillsDir = path10.join(sourceAgentDir, "skills");
+      if (fs8.existsSync(skillsDir)) {
+        skillsCount = fs8.readdirSync(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).length;
+      }
+      p4.note(
+        "Use \u2191/\u2193 to move, press Space to select/deselect, press A to select/deselect all, press Enter to confirm. (Subsequent multi-selects apply; Ctrl+C to exit)",
+        "Multi-select instructions"
+      );
+      const selection = await p4.multiselect({
+        message: "What would you like to copy?",
+        options: [
+          {
+            value: "commands",
+            label: "Commands",
+            hint: `${commandsCount} workflow commands (planning, CI, research, etc.)`
+          },
+          {
+            value: "agents",
+            label: "Agents",
+            hint: `${agentsCount} specialized sub-agents for code analysis`
+          },
+          {
+            value: "skills",
+            label: "Skills",
+            hint: `${skillsCount} specialized skill packages for extended capabilities`
+          },
+          {
+            value: "settings",
+            label: "Settings",
+            hint: "Project permissions configuration"
+          }
+        ],
+        initialValues: ["commands", "agents", "skills", "settings"],
+        required: false
+      });
+      if (p4.isCancel(selection)) {
+        p4.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      selectedCategories = selection;
+      if (selectedCategories.length === 0) {
+        p4.cancel("No items selected.");
+        process.exit(0);
+      }
+    }
+    fs8.mkdirSync(agentTargetDir, { recursive: true });
+    let filesCopied = 0;
+    let filesSkipped = 0;
+    const filesToCopyByCategory = {};
+    if (!options.all) {
+      if (selectedCategories.includes("commands")) {
+        const sourceDir = path10.join(sourceAgentDir, "commands");
+        if (fs8.existsSync(sourceDir)) {
+          const allFiles = fs8.readdirSync(sourceDir);
+          const fileSelection = await p4.multiselect({
+            message: "Select command files to copy:",
+            options: allFiles.map((file) => ({
+              value: file,
+              label: file
+            })),
+            initialValues: allFiles,
+            required: false
+          });
+          if (p4.isCancel(fileSelection)) {
+            p4.cancel("Operation cancelled.");
+            process.exit(0);
+          }
+          filesToCopyByCategory["commands"] = fileSelection;
+          if (filesToCopyByCategory["commands"].length === 0) {
+            filesSkipped += allFiles.length;
+          }
+        }
+      }
+      if (selectedCategories.includes("agents")) {
+        const sourceDir = path10.join(sourceAgentDir, "agents");
+        if (fs8.existsSync(sourceDir)) {
+          const allFiles = fs8.readdirSync(sourceDir);
+          const fileSelection = await p4.multiselect({
+            message: "Select agent files to copy:",
+            options: allFiles.map((file) => ({
+              value: file,
+              label: file
+            })),
+            initialValues: allFiles,
+            required: false
+          });
+          if (p4.isCancel(fileSelection)) {
+            p4.cancel("Operation cancelled.");
+            process.exit(0);
+          }
+          filesToCopyByCategory["agents"] = fileSelection;
+          if (filesToCopyByCategory["agents"].length === 0) {
+            filesSkipped += allFiles.length;
+          }
+        }
+      }
+      if (selectedCategories.includes("skills")) {
+        const sourceDir = path10.join(sourceAgentDir, "skills");
+        if (fs8.existsSync(sourceDir)) {
+          const allSkills = fs8.readdirSync(sourceDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+          if (allSkills.length > 0) {
+            const skillSelection = await p4.multiselect({
+              message: "Select skills to copy:",
+              options: allSkills.map((skill) => ({
+                value: skill,
+                label: skill
+              })),
+              initialValues: allSkills,
+              required: false
+            });
+            if (p4.isCancel(skillSelection)) {
+              p4.cancel("Operation cancelled.");
+              process.exit(0);
+            }
+            filesToCopyByCategory["skills"] = skillSelection;
+          }
+        }
+      }
+    }
+    let maxThinkingTokens = options.maxThinkingTokens;
+    if (!options.all && selectedCategories.includes("settings")) {
+      if (maxThinkingTokens === void 0) {
+        const tokensPrompt = await p4.text({
+          message: "Maximum thinking tokens:",
+          initialValue: "32000",
+          validate: (value) => {
+            const num = parseInt(value, 10);
+            if (isNaN(num) || num < 1e3) {
+              return "Please enter a valid number (minimum 1000)";
+            }
+            return void 0;
+          }
+        });
+        if (p4.isCancel(tokensPrompt)) {
+          p4.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        maxThinkingTokens = parseInt(tokensPrompt, 10);
+      }
+    } else if (selectedCategories.includes("settings")) {
+      if (maxThinkingTokens === void 0) {
+        maxThinkingTokens = 32e3;
+      }
+    }
+    for (const category of selectedCategories) {
+      if (category === "commands" || category === "agents") {
+        const sourceDir = path10.join(sourceAgentDir, category);
+        const targetCategoryDir = path10.join(agentTargetDir, category);
+        if (!fs8.existsSync(sourceDir)) {
+          p4.log.warn(`${category} directory not found in source, skipping`);
+          continue;
+        }
+        const allFiles = fs8.readdirSync(sourceDir);
+        let filesToCopy = allFiles;
+        if (!options.all && filesToCopyByCategory[category]) {
+          filesToCopy = filesToCopyByCategory[category];
+        }
+        if (filesToCopy.length === 0) {
+          continue;
+        }
+        fs8.mkdirSync(targetCategoryDir, { recursive: true });
+        for (const file of filesToCopy) {
+          const sourcePath = path10.join(sourceDir, file);
+          const targetPath = path10.join(targetCategoryDir, file);
+          fs8.copyFileSync(sourcePath, targetPath);
+          filesCopied++;
+        }
+        filesSkipped += allFiles.length - filesToCopy.length;
+        p4.log.success(`Copied ${filesToCopy.length} ${category} file(s)`);
+      } else if (category === "settings") {
+        const settingsPath = path10.join(sourceAgentDir, "settings.template.json");
+        const targetSettingsPath = path10.join(agentTargetDir, "settings.json");
+        if (fs8.existsSync(settingsPath)) {
+          const settingsContent = fs8.readFileSync(settingsPath, "utf8");
+          const settings = JSON.parse(settingsContent);
+          if (maxThinkingTokens !== void 0) {
+            if (!settings.env) {
+              settings.env = {};
+            }
+            settings.env.MAX_THINKING_TOKENS = maxThinkingTokens.toString();
+          }
+          if (!settings.env) {
+            settings.env = {};
+          }
+          for (const [key, value] of Object.entries(product.defaultEnvVars)) {
+            settings.env[key] = value;
+          }
+          fs8.writeFileSync(targetSettingsPath, JSON.stringify(settings, null, 2) + "\n");
+          filesCopied++;
+          p4.log.success(`Copied settings.json (maxTokens: ${maxThinkingTokens})`);
+        } else {
+          p4.log.warn("settings.json not found in source, skipping");
+        }
+      } else if (category === "skills") {
+        const sourceDir = path10.join(sourceAgentDir, "skills");
+        const targetCategoryDir = path10.join(agentTargetDir, "skills");
+        if (!fs8.existsSync(sourceDir)) {
+          p4.log.warn("skills directory not found in source, skipping");
+          continue;
+        }
+        const allSkills = fs8.readdirSync(sourceDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+        let skillsToCopy = allSkills;
+        if (!options.all && filesToCopyByCategory["skills"]) {
+          skillsToCopy = filesToCopyByCategory["skills"];
+        }
+        if (skillsToCopy.length === 0) {
+          continue;
+        }
+        fs8.mkdirSync(targetCategoryDir, { recursive: true });
+        let skillFilesCopied = 0;
+        for (const skill of skillsToCopy) {
+          const sourceSkillPath = path10.join(sourceDir, skill);
+          const targetSkillPath = path10.join(targetCategoryDir, skill);
+          skillFilesCopied += copyDirectoryRecursive(sourceSkillPath, targetSkillPath);
+        }
+        filesCopied += skillFilesCopied;
+        filesSkipped += allSkills.length - skillsToCopy.length;
+        p4.log.success(`Copied ${skillsToCopy.length} skill(s) (${skillFilesCopied} files)`);
+      }
+    }
+    if (selectedCategories.includes("settings")) {
+      ensureGitignoreEntry(targetDir, product.gitignoreEntry, product.name);
+      p4.log.info("Updated .gitignore to exclude settings.local.json");
+    }
+    let message = `Successfully copied ${filesCopied} file(s) to ${agentTargetDir}`;
+    if (filesSkipped > 0) {
+      message += chalk11.gray(`
+   Skipped ${filesSkipped} file(s)`);
+    }
+    message += chalk11.gray(`
+   You can now use these commands in ${product.name}.`);
+    p4.outro(message);
+  } catch (error) {
+    p4.log.error(`Error during ${product.name} init: ${error}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/agent/registry.ts
+var AGENT_PRODUCTS = {
+  claude: {
+    id: "claude",
+    name: "Claude Code",
+    dirName: ".claude",
+    sourceDirName: "src/agent-assets",
+    envVarPrefix: "CLAUDE",
+    defaultEnvVars: {
+      MAX_THINKING_TOKENS: "32000",
+      CLAUDE_BASH_MAINTAIN_WORKING_DIR: "1"
+    },
+    gitignoreEntry: ".claude/settings.local.json"
+  },
+  codebuddy: {
+    id: "codebuddy",
+    name: "CodeBuddy Code",
+    dirName: ".codebuddy",
+    sourceDirName: "src/agent-assets",
+    envVarPrefix: "CODEBUDDY",
+    defaultEnvVars: {
+      MAX_THINKING_TOKENS: "32000",
+      // Note: Current not implemented in CodeBuddy
+      CODEBUDDY_BASH_MAINTAIN_PROJECT_WORKING_DIR: "1"
+    },
+    gitignoreEntry: ".codebuddy/settings.local.json"
+  }
+};
+function getAgentProduct(id) {
+  const product = AGENT_PRODUCTS[id];
+  if (!product) {
+    const validIds = Object.keys(AGENT_PRODUCTS).join(", ");
+    throw new Error(`Unknown agent product: ${id}. Valid options: ${validIds}`);
+  }
+  return product;
+}
+
+// src/commands/agent.ts
+function agentCommand(program2) {
+  const agent = program2.command("agent").description("Manage coding agent configuration");
+  agent.command("init").description("Initialize coding agent configuration in current directory").option("--force", "Force overwrite of existing agent directory").option("--all", "Copy all files without prompting").option(
+    "--max-thinking-tokens <number>",
+    "Maximum thinking tokens (default: 32000)",
+    (value) => parseInt(value, 10)
+  ).option("--name <name>", "Agent name to configure (claude|codebuddy)", "claude").action(async (options) => {
+    const product = getAgentProduct(options.name);
+    await agentInitCommand({ ...options, product });
+  });
+}
+
+// src/commands/metadata/metadata.ts
+import { execSync as execSync6 } from "child_process";
+function getGitInfo() {
+  try {
+    execSync6("git rev-parse --is-inside-work-tree", {
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    const repoRoot = execSync6("git rev-parse --show-toplevel", {
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+    const repoName = repoRoot.split("/").pop() || "";
+    let branch = "";
+    try {
+      branch = execSync6("git branch --show-current", {
+        encoding: "utf8",
+        stdio: "pipe"
+      }).trim();
+    } catch {
+      try {
+        branch = execSync6("git rev-parse --abbrev-ref HEAD", {
+          encoding: "utf8",
+          stdio: "pipe"
+        }).trim();
+      } catch {
+        branch = "";
+      }
+    }
+    let commit = "";
+    try {
+      commit = execSync6("git rev-parse HEAD", {
+        encoding: "utf8",
+        stdio: "pipe"
+      }).trim();
+    } catch {
+      commit = "";
+    }
+    return { repoRoot, repoName, branch, commit };
+  } catch {
+    return null;
+  }
+}
+function formatDate(date) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds} ${tz}`;
+}
+function formatFilenameTimestamp(date) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
+}
+async function specMetadataCommand() {
+  const now = /* @__PURE__ */ new Date();
+  console.log(`Current Date/Time (TZ): ${formatDate(now)}`);
+  const gitInfo = getGitInfo();
+  if (gitInfo) {
+    if (gitInfo.commit) {
+      console.log(`Current Git Commit Hash: ${gitInfo.commit}`);
+    }
+    if (gitInfo.branch) {
+      console.log(`Current Branch Name: ${gitInfo.branch}`);
+    }
+    if (gitInfo.repoName) {
+      console.log(`Repository Name: ${gitInfo.repoName}`);
+    }
+  }
+  console.log(`Timestamp For Filename: ${formatFilenameTimestamp(now)}`);
+}
+
+// src/commands/metadata.ts
+function metadataCommand(program2) {
+  const metadata = program2.description("Metadata utilities for current repository");
+  metadata.command("metadata").description("Output metadata for current repository (branch, commit, timestamp, etc.)").action(specMetadataCommand);
+}
+
+// src/index.ts
+import dotenv2 from "dotenv";
+import { createRequire } from "module";
+dotenv2.config();
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("thoughtcabinet").description(
+  "Thought Cabinet (thc) - thoughts management CLI for developer notes and documentation"
+).version(version);
+thoughtsCommand(program);
+agentCommand(program);
+metadataCommand(program);
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map