@maggit/claude-workspace 0.1.1

package/dist/bin.js

@@ -0,0 +1,888 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command5 } from "commander";
+
+// src/constants.ts
+var VERSION = "0.1.0";
+var CLAUDE_DIR = ".claude";
+var CLAUDE_EXAMPLE_FILE = "CLAUDE.example.md";
+var CLAUDE_MD_FILE = "CLAUDE.md";
+var CONFIG_FILE = "config.json";
+var ACTIVE_PROFILE_FILE = "active.json";
+var CLAUDE_SUBDIRS = [
+  "skills",
+  "templates",
+  "snippets",
+  "logs",
+  "profiles"
+];
+var VAULT_FOLDERS = [
+  "00_inbox",
+  "01_specs",
+  "02_architecture",
+  "03_decisions",
+  "04_knowledge",
+  "05_prompts",
+  "06_agents",
+  "07_diagrams",
+  "08_todos"
+];
+var DEFAULT_VAULT_NAME = "ContextDB";
+var DEFAULT_PROFILE = "default";
+var PROFILES = [
+  "default",
+  "engineering-exec",
+  "indie-maker",
+  "marketing"
+];
+
+// src/commands/init.ts
+import { Command } from "commander";
+
+// src/actions/init.ts
+import path9 from "path";
+import ora from "ora";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var log = {
+  info(msg) {
+    console.log(chalk.blue("\u2139"), msg);
+  },
+  success(msg) {
+    console.log(chalk.green("\u2714"), msg);
+  },
+  warn(msg) {
+    console.log(chalk.yellow("\u26A0"), msg);
+  },
+  error(msg) {
+    console.error(chalk.red("\u2716"), msg);
+  },
+  step(msg) {
+    console.log(chalk.cyan("\u2192"), msg);
+  },
+  dryRun(msg) {
+    console.log(chalk.magenta("[dry-run]"), msg);
+  },
+  pass(msg) {
+    console.log(chalk.green("PASS"), msg);
+  },
+  fail(msg) {
+    console.log(chalk.red("FAIL"), msg);
+  },
+  plain(msg) {
+    console.log(msg);
+  }
+};
+
+// src/utils/fs.ts
+import fs from "fs-extra";
+import crypto from "crypto";
+import path from "path";
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hashFile(filePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  return hashString(content);
+}
+function hashString(content) {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+async function backupFile(filePath) {
+  const timestamp = Date.now();
+  const ext = path.extname(filePath);
+  const base = ext ? filePath.slice(0, -ext.length) : filePath;
+  const backupPath = `${base}.bak.${timestamp}${ext}`;
+  await fs.copy(filePath, backupPath);
+  return backupPath;
+}
+async function safeWriteFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function safeReadFile(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// src/services/prompts.ts
+import prompts from "prompts";
+async function runInitPrompts(opts) {
+  if (opts.yes) {
+    return {
+      profile: opts.profile,
+      vault: opts.vault
+    };
+  }
+  const response = await prompts(
+    [
+      {
+        type: "select",
+        name: "profile",
+        message: "Which profile would you like to use?",
+        choices: PROFILES.map((p) => ({ title: p, value: p })),
+        initial: PROFILES.indexOf(
+          opts.profile
+        )
+      },
+      {
+        type: "text",
+        name: "vault",
+        message: "Vault folder name?",
+        initial: opts.vault || DEFAULT_VAULT_NAME
+      }
+    ],
+    {
+      onCancel: () => {
+        process.exit(1);
+      }
+    }
+  );
+  return {
+    profile: response.profile || DEFAULT_PROFILE,
+    vault: response.vault || DEFAULT_VAULT_NAME
+  };
+}
+
+// src/services/profiles.ts
+import path3 from "path";
+import fs2 from "fs-extra";
+
+// src/utils/paths.ts
+import path2 from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+function getAssetsDir() {
+  const inSrc = __dirname.includes(path2.sep + "src");
+  const cliRoot = inSrc ? path2.resolve(__dirname, "..", "..") : path2.resolve(__dirname, "..");
+  const assetsDir = path2.join(cliRoot, "assets");
+  return assetsDir;
+}
+function getSkillsDir() {
+  return path2.join(getAssetsDir(), "skills");
+}
+function getTemplatesDir() {
+  return path2.join(getAssetsDir(), "templates");
+}
+function getProfilesDir() {
+  return path2.join(getAssetsDir(), "profiles");
+}
+function getClaudeMdTemplatesDir() {
+  return path2.join(getAssetsDir(), "claude-md");
+}
+function getVaultTemplatesDir() {
+  return path2.join(getAssetsDir(), "vault");
+}
+
+// src/services/profiles.ts
+async function loadProfile(name) {
+  if (!PROFILES.includes(name)) {
+    throw new Error(
+      `Unknown profile "${name}". Available profiles: ${PROFILES.join(", ")}`
+    );
+  }
+  const profilePath = path3.join(getProfilesDir(), `${name}.json`);
+  const content = await fs2.readFile(profilePath, "utf-8");
+  return JSON.parse(content);
+}
+
+// src/services/scaffold-claude-dir.ts
+import path4 from "path";
+import fs3 from "fs-extra";
+async function scaffoldClaudeDir(targetDir, profile, options, existingActive) {
+  const claudeDir = path4.join(targetDir, CLAUDE_DIR);
+  const managedFiles = [];
+  for (const subdir of CLAUDE_SUBDIRS) {
+    const dir = path4.join(claudeDir, subdir);
+    if (options.dryRun) {
+      if (!await fileExists(dir)) {
+        log.dryRun(`Would create directory: ${CLAUDE_DIR}/${subdir}/`);
+      }
+    } else {
+      await fs3.ensureDir(dir);
+    }
+  }
+  const existingHashes = buildExistingHashes(existingActive);
+  for (const skillName of profile.skills) {
+    const result = await installSingleSkill(
+      targetDir,
+      skillName,
+      existingHashes,
+      options
+    );
+    if (result) {
+      managedFiles.push(result);
+    }
+  }
+  const templatesSrcDir = getTemplatesDir();
+  for (const templateFile of profile.templates) {
+    const srcPath = path4.join(templatesSrcDir, templateFile);
+    const destPath = path4.join(claudeDir, "templates", templateFile);
+    const relativePath = path4.join(CLAUDE_DIR, "templates", templateFile);
+    const result = await copyManagedFile(
+      srcPath,
+      destPath,
+      relativePath,
+      existingHashes,
+      options
+    );
+    if (result) {
+      managedFiles.push(result);
+    }
+  }
+  return { managedFiles };
+}
+async function installSingleSkill(targetDir, skillName, existingHashes, options) {
+  const claudeDir = path4.join(targetDir, CLAUDE_DIR);
+  const skillsSrcDir = getSkillsDir();
+  const srcPath = path4.join(skillsSrcDir, skillName, "SKILL.md");
+  const destDir = path4.join(claudeDir, "skills", skillName);
+  const destPath = path4.join(destDir, "SKILL.md");
+  const relativePath = path4.join(CLAUDE_DIR, "skills", skillName, "SKILL.md");
+  if (options.dryRun) {
+    if (!await fileExists(destDir)) {
+      log.dryRun(`Would create directory: ${CLAUDE_DIR}/skills/${skillName}/`);
+    }
+  } else {
+    await fs3.ensureDir(destDir);
+  }
+  return copyManagedFile(srcPath, destPath, relativePath, existingHashes, options);
+}
+function buildExistingHashes(existingActive) {
+  const hashes = /* @__PURE__ */ new Map();
+  if (existingActive) {
+    for (const mf of existingActive.managedFiles) {
+      hashes.set(mf.path, mf.hash);
+    }
+  }
+  return hashes;
+}
+async function copyManagedFile(srcPath, destPath, relativePath, existingHashes, options) {
+  const srcContent = await fs3.readFile(srcPath, "utf-8");
+  const srcHash = hashString(srcContent);
+  if (await fileExists(destPath)) {
+    const destHash = await hashFile(destPath);
+    const previousHash = existingHashes.get(relativePath);
+    if (destHash === srcHash) {
+      return { path: relativePath, hash: srcHash };
+    }
+    if (!previousHash && !options.force) {
+      log.warn(
+        `Skipping ${relativePath} (already exists, not managed). Delete it and re-run to reinstall, or use --force to overwrite.`
+      );
+      return null;
+    }
+    if (previousHash && destHash !== previousHash && !options.force) {
+      log.warn(`Skipping ${relativePath} (modified by user). Use --force to overwrite.`);
+      return { path: relativePath, hash: destHash };
+    }
+    if (options.dryRun) {
+      log.dryRun(`Would update: ${relativePath}`);
+    } else {
+      const backupPath = await backupFile(destPath);
+      log.step(`Backed up ${relativePath} \u2192 ${path4.basename(backupPath)}`);
+      await safeWriteFile(destPath, srcContent);
+      log.success(`Updated ${relativePath}`);
+    }
+  } else {
+    if (options.dryRun) {
+      log.dryRun(`Would create: ${relativePath}`);
+    } else {
+      await safeWriteFile(destPath, srcContent);
+      log.success(`Created ${relativePath}`);
+    }
+  }
+  return { path: relativePath, hash: srcHash };
+}
+
+// src/services/scaffold-vault.ts
+import path5 from "path";
+import fs4 from "fs-extra";
+async function scaffoldVault(targetDir, vaultName, options) {
+  const vaultDir = path5.join(targetDir, vaultName);
+  if (options.dryRun) {
+    if (!await fileExists(vaultDir)) {
+      log.dryRun(`Would create vault: ${vaultName}/`);
+    }
+  } else {
+    await fs4.ensureDir(vaultDir);
+  }
+  for (const folder of VAULT_FOLDERS) {
+    const folderPath = path5.join(vaultDir, folder);
+    const gitkeepPath = path5.join(folderPath, ".gitkeep");
+    if (options.dryRun) {
+      if (!await fileExists(folderPath)) {
+        log.dryRun(`Would create: ${vaultName}/${folder}/`);
+      }
+    } else {
+      await fs4.ensureDir(folderPath);
+      if (!await fileExists(gitkeepPath)) {
+        await safeWriteFile(gitkeepPath, "");
+      }
+    }
+  }
+  const vaultTemplatesDir = getVaultTemplatesDir();
+  const readmeSrc = path5.join(vaultTemplatesDir, "README.md");
+  const readmeDest = path5.join(vaultDir, "README.md");
+  if (!await fileExists(readmeDest)) {
+    if (options.dryRun) {
+      log.dryRun(`Would create: ${vaultName}/README.md`);
+    } else {
+      const content = await fs4.readFile(readmeSrc, "utf-8");
+      await safeWriteFile(readmeDest, content);
+      log.success(`Created ${vaultName}/README.md`);
+    }
+  }
+  const indexSrc = path5.join(vaultTemplatesDir, "_index.md");
+  const indexDest = path5.join(vaultDir, "_index.md");
+  if (!await fileExists(indexDest)) {
+    if (options.dryRun) {
+      log.dryRun(`Would create: ${vaultName}/_index.md`);
+    } else {
+      const content = await fs4.readFile(indexSrc, "utf-8");
+      await safeWriteFile(indexDest, content);
+      log.success(`Created ${vaultName}/_index.md`);
+    }
+  }
+}
+
+// src/services/claude-md.ts
+import path6 from "path";
+import fs5 from "fs-extra";
+async function generateClaudeMdContent(profile, vaultName) {
+  const templateDir = getClaudeMdTemplatesDir();
+  const templatePath = path6.join(templateDir, profile.claudeMdTemplate);
+  const template = await fs5.readFile(templatePath, "utf-8");
+  const folderList = VAULT_FOLDERS.map(
+    (f) => `- \`${vaultName}/${f}/\``
+  ).join("\n");
+  const skillInstructions = profile.skills.length > 0 ? `Available skills:
+${profile.skills.map((s) => `- \`${s}\` \u2014 see \`.claude/skills/${s}\` for usage`).join("\n")}` : "No skills installed for this profile.";
+  const namingConvention = [
+    "- Use lowercase with hyphens: `my-feature-spec.md`",
+    "- Prefix with date when chronology matters: `2026-02-07-auth-decision.md`",
+    "- Keep filenames descriptive and specific",
+    "- One topic per file"
+  ].join("\n");
+  const content = template.replace(/\{\{vaultPath\}\}/g, vaultName).replace(/\{\{folderList\}\}/g, folderList).replace(/\{\{skillInstructions\}\}/g, skillInstructions).replace(/\{\{namingConvention\}\}/g, namingConvention);
+  return content;
+}
+async function writeClaudeExampleMd(targetDir, content, options) {
+  const examplePath = path6.join(targetDir, CLAUDE_EXAMPLE_FILE);
+  if (options.dryRun) {
+    log.dryRun(`Would write ${CLAUDE_EXAMPLE_FILE}`);
+    return;
+  }
+  await safeWriteFile(examplePath, content);
+  log.success(`Wrote ${CLAUDE_EXAMPLE_FILE}`);
+}
+
+// src/services/config.ts
+import path7 from "path";
+function createConfig(profile, vaultPath) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: VERSION,
+    profile,
+    vaultPath,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function writeConfig(targetDir, config, options) {
+  const configPath = path7.join(targetDir, CLAUDE_DIR, CONFIG_FILE);
+  if (options.dryRun) {
+    log.dryRun(`Would write ${CLAUDE_DIR}/${CONFIG_FILE}`);
+    return;
+  }
+  const existing = await readConfig(targetDir);
+  if (existing) {
+    config.createdAt = existing.createdAt;
+  }
+  await safeWriteFile(configPath, JSON.stringify(config, null, 2) + "\n");
+  log.success(`Wrote ${CLAUDE_DIR}/${CONFIG_FILE}`);
+}
+async function readConfig(targetDir) {
+  const configPath = path7.join(targetDir, CLAUDE_DIR, CONFIG_FILE);
+  const content = await safeReadFile(configPath);
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// src/services/active-profile.ts
+import path8 from "path";
+async function writeActiveProfile(targetDir, profile, managedFiles, options) {
+  const activePath = path8.join(
+    targetDir,
+    CLAUDE_DIR,
+    "profiles",
+    ACTIVE_PROFILE_FILE
+  );
+  const activeProfile = {
+    profile,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    managedFiles
+  };
+  if (options.dryRun) {
+    log.dryRun(
+      `Would write ${CLAUDE_DIR}/profiles/${ACTIVE_PROFILE_FILE}`
+    );
+    return;
+  }
+  await safeWriteFile(
+    activePath,
+    JSON.stringify(activeProfile, null, 2) + "\n"
+  );
+  log.success(`Wrote ${CLAUDE_DIR}/profiles/${ACTIVE_PROFILE_FILE}`);
+}
+async function readActiveProfile(targetDir) {
+  const activePath = path8.join(
+    targetDir,
+    CLAUDE_DIR,
+    "profiles",
+    ACTIVE_PROFILE_FILE
+  );
+  const content = await safeReadFile(activePath);
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// src/actions/init.ts
+async function initAction(opts) {
+  const targetDir = path9.resolve(opts.dir);
+  if (opts.dryRun) {
+    log.info("Dry run mode \u2014 no changes will be made.\n");
+  }
+  const answers = await runInitPrompts(opts);
+  const profileName = answers.profile;
+  const vaultName = answers.vault;
+  const spinner = ora("Loading profile...").start();
+  let profile;
+  try {
+    profile = await loadProfile(profileName);
+    spinner.succeed(`Profile: ${profile.name} \u2014 ${profile.description}`);
+  } catch (err) {
+    spinner.fail("Failed to load profile");
+    log.error(err.message);
+    process.exit(1);
+  }
+  const existingActive = await readActiveProfile(targetDir);
+  log.step("Scaffolding .claude/ directory...");
+  const { managedFiles } = await scaffoldClaudeDir(targetDir, profile, {
+    force: opts.force,
+    dryRun: opts.dryRun
+  }, existingActive);
+  log.step(`Scaffolding vault: ${vaultName}/...`);
+  await scaffoldVault(targetDir, vaultName, { dryRun: opts.dryRun });
+  log.step(`Generating ${CLAUDE_EXAMPLE_FILE}...`);
+  const claudeMdContent = await generateClaudeMdContent(profile, vaultName);
+  await writeClaudeExampleMd(targetDir, claudeMdContent, {
+    dryRun: opts.dryRun
+  });
+  const config = createConfig(profileName, vaultName);
+  await writeConfig(targetDir, config, { dryRun: opts.dryRun });
+  await writeActiveProfile(targetDir, profileName, managedFiles, {
+    dryRun: opts.dryRun
+  });
+  console.log("");
+  log.success(`Workspace initialized with profile "${profileName}"!`);
+  log.info(`  Vault: ${vaultName}/`);
+  log.info(`  Skills: ${profile.skills.length} installed`);
+  log.info(`  Templates: ${profile.templates.length} installed`);
+  const hasClaudeMd = await fileExists(path9.join(targetDir, CLAUDE_MD_FILE));
+  console.log("");
+  if (hasClaudeMd) {
+    log.info(`  ${CLAUDE_EXAMPLE_FILE} has been written.`);
+    log.info(`  You already have a ${CLAUDE_MD_FILE} \u2014 merge the example content into it as needed.`);
+  } else {
+    log.info(`  ${CLAUDE_EXAMPLE_FILE} has been written.`);
+    log.info(`  Rename it to ${CLAUDE_MD_FILE} to activate: mv ${CLAUDE_EXAMPLE_FILE} ${CLAUDE_MD_FILE}`);
+  }
+  console.log("");
+  log.info("Run 'cws doctor' to verify your workspace.");
+}
+
+// src/commands/init.ts
+function createInitCommand() {
+  return new Command("init").description("Scaffold a Claude workspace into a project directory").option("-d, --dir <path>", "Target directory", process.cwd()).option(
+    `-p, --profile <name>`,
+    `Profile to use (${PROFILES.join(", ")})`,
+    DEFAULT_PROFILE
+  ).option("--vault <name>", "Vault folder name", DEFAULT_VAULT_NAME).option(
+    "--force",
+    "Overwrite user-modified managed files (with backup)",
+    false
+  ).option("--dry-run", "Show what would be done without making changes", false).option("-y, --yes", "Skip interactive prompts, use defaults", false).action(async (opts) => {
+    await initAction({
+      dir: opts.dir,
+      profile: opts.profile,
+      vault: opts.vault,
+      force: opts.force,
+      dryRun: opts.dryRun,
+      yes: opts.yes
+    });
+  });
+}
+
+// src/commands/doctor.ts
+import { Command as Command2 } from "commander";
+
+// src/actions/doctor.ts
+import path10 from "path";
+async function doctorAction(opts) {
+  const targetDir = path10.resolve(opts.dir);
+  const checks = [];
+  log.info(`Checking workspace: ${targetDir}
+`);
+  const claudeDir = path10.join(targetDir, CLAUDE_DIR);
+  const claudeDirExists = await fileExists(claudeDir);
+  checks.push({
+    name: ".claude/ directory",
+    passed: claudeDirExists,
+    message: claudeDirExists ? ".claude/ directory exists" : ".claude/ directory not found",
+    fix: "Run 'cws init' to create the workspace"
+  });
+  const config = await readConfig(targetDir);
+  checks.push({
+    name: "config.json",
+    passed: config !== null,
+    message: config ? `config.json valid (profile: ${config.profile})` : "config.json missing or invalid",
+    fix: "Run 'cws init' to regenerate config"
+  });
+  const active = await readActiveProfile(targetDir);
+  checks.push({
+    name: "active.json",
+    passed: active !== null,
+    message: active ? `active.json present (profile: ${active.profile})` : "active.json missing",
+    fix: "Run 'cws init' to regenerate active profile"
+  });
+  if (config && active) {
+    try {
+      const profile = await loadProfile(config.profile);
+      let allSkillsPresent = true;
+      for (const skill of profile.skills) {
+        const skillPath = path10.join(claudeDir, "skills", skill, "SKILL.md");
+        if (!await fileExists(skillPath)) {
+          allSkillsPresent = false;
+          checks.push({
+            name: `skill: ${skill}`,
+            passed: false,
+            message: `Missing skill: .claude/skills/${skill}/SKILL.md`,
+            fix: `Run 'cws init --force' to restore missing files`
+          });
+        }
+      }
+      if (allSkillsPresent) {
+        checks.push({
+          name: "skill files",
+          passed: true,
+          message: `All ${profile.skills.length} skills present`
+        });
+      }
+      let allTemplatesPresent = true;
+      for (const tmpl of profile.templates) {
+        const tmplPath = path10.join(claudeDir, "templates", tmpl);
+        if (!await fileExists(tmplPath)) {
+          allTemplatesPresent = false;
+          checks.push({
+            name: `template: ${tmpl}`,
+            passed: false,
+            message: `Missing template file: .claude/templates/${tmpl}`,
+            fix: `Run 'cws init --force' to restore missing files`
+          });
+        }
+      }
+      if (allTemplatesPresent) {
+        checks.push({
+          name: "template files",
+          passed: true,
+          message: `All ${profile.templates.length} template files present`
+        });
+      }
+    } catch {
+      checks.push({
+        name: "profile validation",
+        passed: false,
+        message: `Could not load profile "${config.profile}"`,
+        fix: "Check config.json profile name is valid"
+      });
+    }
+  }
+  if (config) {
+    const vaultDir = path10.join(targetDir, config.vaultPath);
+    const vaultExists = await fileExists(vaultDir);
+    checks.push({
+      name: "vault directory",
+      passed: vaultExists,
+      message: vaultExists ? `Vault directory exists: ${config.vaultPath}/` : `Vault directory missing: ${config.vaultPath}/`,
+      fix: "Run 'cws init' to create vault"
+    });
+    if (vaultExists) {
+      let allFoldersPresent = true;
+      for (const folder of VAULT_FOLDERS) {
+        const folderPath = path10.join(vaultDir, folder);
+        if (!await fileExists(folderPath)) {
+          allFoldersPresent = false;
+          checks.push({
+            name: `vault: ${folder}`,
+            passed: false,
+            message: `Missing vault folder: ${config.vaultPath}/${folder}/`,
+            fix: "Run 'cws init' to restore vault structure"
+          });
+        }
+      }
+      if (allFoldersPresent) {
+        checks.push({
+          name: "vault subfolders",
+          passed: true,
+          message: `All ${VAULT_FOLDERS.length} vault subfolders present`
+        });
+      }
+    }
+  }
+  const examplePath = path10.join(targetDir, CLAUDE_EXAMPLE_FILE);
+  const claudeMdPath = path10.join(targetDir, CLAUDE_MD_FILE);
+  const exampleExists = await fileExists(examplePath);
+  const claudeMdExists = await fileExists(claudeMdPath);
+  if (claudeMdExists) {
+    checks.push({
+      name: CLAUDE_MD_FILE,
+      passed: true,
+      message: `${CLAUDE_MD_FILE} present`
+    });
+  } else if (exampleExists) {
+    checks.push({
+      name: CLAUDE_MD_FILE,
+      passed: true,
+      message: `${CLAUDE_EXAMPLE_FILE} present \u2014 rename to ${CLAUDE_MD_FILE} to activate`,
+      fix: `mv ${CLAUDE_EXAMPLE_FILE} ${CLAUDE_MD_FILE}`
+    });
+  } else {
+    checks.push({
+      name: CLAUDE_MD_FILE,
+      passed: false,
+      message: `Neither ${CLAUDE_MD_FILE} nor ${CLAUDE_EXAMPLE_FILE} found`,
+      fix: "Run 'cws init' to generate CLAUDE.example.md"
+    });
+  }
+  console.log("");
+  let failCount = 0;
+  for (const check of checks) {
+    if (check.passed) {
+      log.pass(check.message);
+    } else {
+      log.fail(check.message);
+      if (check.fix) {
+        log.plain(`       ${check.fix}`);
+      }
+      failCount++;
+    }
+  }
+  console.log("");
+  if (failCount === 0) {
+    log.success("All checks passed!");
+  } else {
+    log.warn(`${failCount} check(s) failed.`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/doctor.ts
+function createDoctorCommand() {
+  return new Command2("doctor").description("Validate Claude workspace configuration and files").option("-d, --dir <path>", "Target directory", process.cwd()).action(async (opts) => {
+    await doctorAction({ dir: opts.dir });
+  });
+}
+
+// src/commands/print-claude-md.ts
+import { Command as Command3 } from "commander";
+
+// src/actions/print-claude-md.ts
+async function printClaudeMdAction(opts) {
+  try {
+    const profile = await loadProfile(opts.profile);
+    const content = await generateClaudeMdContent(profile, opts.vault);
+    process.stdout.write(content);
+  } catch (err) {
+    log.error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/print-claude-md.ts
+function createPrintClaudeMdCommand() {
+  return new Command3("print-claude-md").description("Print the generated CLAUDE.md content to stdout").option(
+    `-p, --profile <name>`,
+    `Profile to use (${PROFILES.join(", ")})`,
+    DEFAULT_PROFILE
+  ).option("--vault <name>", "Vault folder name", DEFAULT_VAULT_NAME).action(async (opts) => {
+    await printClaudeMdAction({
+      profile: opts.profile,
+      vault: opts.vault
+    });
+  });
+}
+
+// src/commands/add-skill.ts
+import { Command as Command4 } from "commander";
+
+// src/actions/add-skill.ts
+import path12 from "path";
+import fs7 from "fs-extra";
+
+// src/services/skills.ts
+import path11 from "path";
+import fs6 from "fs-extra";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    return { name: "", description: "" };
+  }
+  const frontmatter = match[1];
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  const descMatch = frontmatter.match(/^description:\s*"?(.+?)"?\s*$/m);
+  return {
+    name: nameMatch ? nameMatch[1].trim() : "",
+    description: descMatch ? descMatch[1].trim() : ""
+  };
+}
+async function getAvailableSkillNames() {
+  const skillsDir = getSkillsDir();
+  const entries = await fs6.readdir(skillsDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+}
+async function validateSkillName(name) {
+  const skillPath = path11.join(getSkillsDir(), name, "SKILL.md");
+  try {
+    await fs6.access(skillPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listAvailableSkills() {
+  const skillsDir = getSkillsDir();
+  const names = await getAvailableSkillNames();
+  const skills = [];
+  for (const name of names) {
+    const content = await fs6.readFile(
+      path11.join(skillsDir, name, "SKILL.md"),
+      "utf-8"
+    );
+    const fm = parseFrontmatter(content);
+    skills.push({
+      name,
+      description: fm.description || "(no description)"
+    });
+  }
+  return skills;
+}
+
+// src/actions/add-skill.ts
+async function addSkillAction(skillName, opts) {
+  if (opts.list) {
+    const skills = await listAvailableSkills();
+    log.info(`Available skills (${skills.length}):
+`);
+    const maxName = Math.max(...skills.map((s) => s.name.length));
+    for (const skill of skills) {
+      log.plain(`  ${skill.name.padEnd(maxName + 2)}${skill.description}`);
+    }
+    return;
+  }
+  if (!skillName) {
+    log.error("Please specify a skill name. Use --list to see available skills.");
+    process.exit(1);
+  }
+  const targetDir = path12.resolve(opts.dir);
+  if (opts.dryRun) {
+    log.info("Dry run mode \u2014 no changes will be made.\n");
+  }
+  const isValid = await validateSkillName(skillName);
+  if (!isValid) {
+    log.error(
+      `Unknown skill "${skillName}". Use --list to see available skills.`
+    );
+    process.exit(1);
+  }
+  const claudeDir = path12.join(targetDir, CLAUDE_DIR);
+  if (!opts.dryRun) {
+    await fs7.ensureDir(path12.join(claudeDir, "skills"));
+    await fs7.ensureDir(path12.join(claudeDir, "profiles"));
+  }
+  const existingActive = await readActiveProfile(targetDir);
+  const existingHashes = buildExistingHashes(existingActive);
+  const result = await installSingleSkill(
+    targetDir,
+    skillName,
+    existingHashes,
+    { force: opts.force, dryRun: opts.dryRun }
+  );
+  if (!result) {
+    return;
+  }
+  if (!opts.dryRun) {
+    const existingFiles = existingActive?.managedFiles ?? [];
+    const merged = existingFiles.filter((mf) => mf.path !== result.path);
+    merged.push(result);
+    await writeActiveProfile(
+      targetDir,
+      existingActive?.profile ?? "custom",
+      merged,
+      { dryRun: false }
+    );
+  }
+  console.log("");
+  log.success(`Skill "${skillName}" installed!`);
+}
+
+// src/commands/add-skill.ts
+function createAddSkillCommand() {
+  return new Command4("add-skill").description("Install a single skill into the workspace").argument("[skill-name]", "Name of the skill to install").option("-d, --dir <path>", "Target directory", process.cwd()).option(
+    "--force",
+    "Overwrite existing skill (with backup)",
+    false
+  ).option("--dry-run", "Show what would be done without making changes", false).option("-l, --list", "List all available skills", false).action(async (skillName, opts) => {
+    await addSkillAction(skillName, {
+      dir: opts.dir,
+      force: opts.force,
+      dryRun: opts.dryRun,
+      list: opts.list
+    });
+  });
+}
+
+// src/cli.ts
+function createProgram() {
+  const program2 = new Command5();
+  program2.name("cws").description("Dotfiles for Claude \u2014 scaffold Claude workspaces into any project").version(VERSION);
+  program2.addCommand(createInitCommand());
+  program2.addCommand(createDoctorCommand());
+  program2.addCommand(createPrintClaudeMdCommand());
+  program2.addCommand(createAddSkillCommand());
+  return program2;
+}
+
+// src/bin.ts
+var program = createProgram();
+program.parse();
+//# sourceMappingURL=bin.js.map