claude-master-toolkit 0.1.2 → 0.1.3

package/dist/cli.js

@@ -679,8 +679,8 @@ function gitChangedCommand() {
 
 // src/cli/commands/find.ts
 import { execFileSync as execFileSync2 } from "child_process";
-function findCommand(query, path) {
-  const searchPath = path ?? ".";
+function findCommand(query, path3) {
+  const searchPath = path3 ?? ".";
   try {
     const result = execFileSync2(
       "rg",
@@ -1751,14 +1751,324 @@ async function dashboardCommand(options) {
   }
 }
 
+// src/cli/commands/install.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execSync as execSync3 } from "child_process";
+var REPO_DIR = process.cwd();
+var CLAUDE_DIR = path.join(os.homedir(), ".claude");
+function say(msg) {
+  console.log("  " + msg);
+}
+function head(msg) {
+  console.log("\n== " + msg + " ==\n");
+}
+function die(msg) {
+  console.error("\u2717 " + msg);
+  process.exit(1);
+  throw new Error(msg);
+}
+function run(cmd) {
+  execSync3(cmd, { stdio: "inherit", cwd: REPO_DIR });
+}
+function linkForce(target, link, type) {
+  fs.mkdirSync(path.dirname(link), { recursive: true });
+  if (fs.existsSync(link) || fs.lstatSync(link, { throwIfNoEntry: false })) {
+    fs.unlinkSync(link);
+  }
+  fs.symlinkSync(target, link, type);
+}
+async function installClaudeCommand(opts) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    die("~/.claude not found \u2014 is Claude Code installed?");
+  }
+  const nodeMajor = Number(process.version.split(".")[0].replace("v", ""));
+  if (nodeMajor < 18) die("Node.js 18+ required");
+  const backupDir = path.join(CLAUDE_DIR, "backups", `cmt-${timestamp}`);
+  head("1. Backup");
+  fs.mkdirSync(backupDir, { recursive: true });
+  const claudeMdPath = path.join(CLAUDE_DIR, "CLAUDE.md");
+  if (fs.existsSync(claudeMdPath) && !fs.lstatSync(claudeMdPath).isSymbolicLink()) {
+    fs.copyFileSync(claudeMdPath, path.join(backupDir, "CLAUDE.md"));
+    say("backed up CLAUDE.md");
+  }
+  const settingsPath = path.join(CLAUDE_DIR, "settings.json");
+  if (fs.existsSync(settingsPath)) {
+    fs.copyFileSync(settingsPath, path.join(backupDir, "settings.json"));
+    say("backed up settings.json");
+  }
+  fs.writeFileSync(path.join(backupDir, "repo-path"), REPO_DIR);
+  if (!opts.skipDeps) {
+    head("2. Install dependencies");
+    run("npm install --legacy-peer-deps");
+    say("dependencies installed");
+  }
+  if (!opts.skipBuild) {
+    head("3. Build");
+    run("npm run build");
+    say("build complete");
+  }
+  head("4. Database migrate");
+  run("npx tsx src/server/db/migrate.ts");
+  say("database migrated");
+  head("5. Sync data");
+  const syncScript = `
+import { syncAll } from './src/server/parser/sync.ts';
+import { importAllMemories } from './src/server/parser/engram-import.ts';
+
+(async () => {
+  const sync = await syncAll();
+  const mem = await importAllMemories();
+  console.log(sync.files + ' files, ' + sync.sessions + ' sessions, ' + mem.imported + ' memories');
+})();
+`;
+  const tmpFile = path.join(REPO_DIR, ".tmp-sync.ts");
+  fs.writeFileSync(tmpFile, syncScript);
+  try {
+    const output2 = execSync3(`npx tsx ${tmpFile}`, {
+      cwd: REPO_DIR,
+      encoding: "utf-8"
+    });
+    say("synced: " + output2.trim());
+  } catch (e) {
+    fs.unlinkSync(tmpFile);
+    die("sync failed");
+  }
+  fs.unlinkSync(tmpFile);
+  head("6. Symlink CLAUDE.md + hooks");
+  const dist = path.join(REPO_DIR, "claude-dist");
+  linkForce(path.join(dist, "CLAUDE.md"), claudeMdPath, "file");
+  for (const hook of ["session-start.sh", "user-prompt-submit.sh"]) {
+    const src = path.join(dist, "hooks", hook);
+    fs.chmodSync(src, 493);
+    linkForce(src, path.join(CLAUDE_DIR, "hooks", hook), "file");
+  }
+  say("linked CLAUDE.md + hooks (2)");
+  head("7. Symlink skills + agents");
+  const skills = ["sdd-new", "sdd-ff", "sdd-continue", "engram-protocol", "delegate"];
+  for (const skill of skills) {
+    linkForce(
+      path.join(dist, "skills", skill),
+      path.join(CLAUDE_DIR, "skills", skill),
+      "dir"
+    );
+  }
+  linkForce(
+    path.join(dist, "agents", "sdd-orchestrator.md"),
+    path.join(CLAUDE_DIR, "agents", "sdd-orchestrator.md"),
+    "file"
+  );
+  say(`linked skills (${skills.length}) + agents (1)`);
+  head("8. Merge settings");
+  const patchPath = path.join(dist, "settings.patch.json");
+  let base = {};
+  if (fs.existsSync(settingsPath)) {
+    base = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+  }
+  const patch = JSON.parse(fs.readFileSync(patchPath, "utf-8"));
+  const merged = { ...base, ...patch };
+  fs.writeFileSync(settingsPath, JSON.stringify(merged, null, 2));
+  say("settings merged");
+  head("9. Model preference");
+  const stateDir = path.join(CLAUDE_DIR, "state", "claude-master-toolkit");
+  fs.mkdirSync(stateDir, { recursive: true });
+  const prefFile = path.join(stateDir, "model-preference");
+  if (!fs.existsSync(prefFile)) {
+    fs.writeFileSync(prefFile, "inherit\n");
+    say("model preference \u2192 inherit");
+  } else {
+    say("model preference already set: " + fs.readFileSync(prefFile, "utf-8").trim());
+  }
+  head("10. PATH setup");
+  const binCtk = path.join(REPO_DIR, "bin", "ctk.js");
+  if (fs.existsSync(binCtk)) fs.chmodSync(binCtk, 493);
+  const bashrc = path.join(os.homedir(), ".bashrc");
+  const markerStart = "# >>> claude-master-toolkit >>>";
+  const markerEnd = "# <<< claude-master-toolkit <<<";
+  if (fs.existsSync(bashrc)) {
+    const content = fs.readFileSync(bashrc, "utf-8");
+    if (!content.includes(markerStart)) {
+      fs.appendFileSync(
+        bashrc,
+        `
+${markerStart}
+export PATH="${REPO_DIR}/bin:$PATH"
+${markerEnd}
+`
+      );
+      say("PATH added to ~/.bashrc");
+    } else {
+      say("PATH already configured");
+    }
+  }
+  head("11. Caveman plugin");
+  try {
+    execSync3("command -v claude", { stdio: "ignore" });
+    try {
+      execSync3("claude plugin marketplace add JuliusBrussee/caveman", { stdio: "ignore" });
+      execSync3("claude plugin install caveman@caveman", { stdio: "ignore" });
+      say("caveman plugin configured");
+    } catch {
+      say("caveman install skipped (already installed or failed)");
+    }
+  } catch {
+    say("caveman skipped (claude CLI not found)");
+  }
+  head("\u2713 Installation complete");
+  console.log(`
+Repo:   ${REPO_DIR}
+Backup: ${backupDir}
+Config: ~/.claude (symlinked)
+State:  ${stateDir}
+
+Next:
+  source ~/.bashrc
+  ctk --help
+  ctk dashboard
+`);
+}
+
+// src/cli/commands/uninstall.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+import { execSync as execSync4 } from "child_process";
+var REPO_DIR2 = process.cwd();
+var CLAUDE_DIR2 = path2.join(os2.homedir(), ".claude");
+function say2(msg) {
+  console.log("  " + msg);
+}
+function head2(msg) {
+  console.log("\n== " + msg + " ==\n");
+}
+function removeSymlink(p) {
+  const stat = fs2.lstatSync(p, { throwIfNoEntry: false });
+  if (stat && stat.isSymbolicLink()) {
+    fs2.unlinkSync(p);
+    return true;
+  }
+  return false;
+}
+async function uninstallClaudeCommand(opts) {
+  head2("1. Remove symlinks");
+  const links = [
+    path2.join(CLAUDE_DIR2, "CLAUDE.md"),
+    path2.join(CLAUDE_DIR2, "hooks", "session-start.sh"),
+    path2.join(CLAUDE_DIR2, "hooks", "user-prompt-submit.sh"),
+    path2.join(CLAUDE_DIR2, "skills", "sdd-new"),
+    path2.join(CLAUDE_DIR2, "skills", "sdd-ff"),
+    path2.join(CLAUDE_DIR2, "skills", "sdd-continue"),
+    path2.join(CLAUDE_DIR2, "skills", "engram-protocol"),
+    path2.join(CLAUDE_DIR2, "skills", "delegate"),
+    path2.join(CLAUDE_DIR2, "agents", "sdd-orchestrator.md")
+  ];
+  let removed = 0;
+  for (const link of links) if (removeSymlink(link)) removed++;
+  say2(`removed symlinks (${removed}/${links.length})`);
+  head2("2. Clean database + state");
+  const stateDir = path2.join(CLAUDE_DIR2, "state", "claude-master-toolkit");
+  if (fs2.existsSync(stateDir)) {
+    for (const f of ["ctk.sqlite", "ctk.sqlite-journal", "model-preference"]) {
+      const p = path2.join(stateDir, f);
+      if (fs2.existsSync(p)) fs2.unlinkSync(p);
+    }
+    say2("cleaned state dir");
+  } else {
+    say2("no state dir found");
+  }
+  head2("3. Restore latest backup");
+  const backupsDir = path2.join(CLAUDE_DIR2, "backups");
+  if (fs2.existsSync(backupsDir)) {
+    const candidates = fs2.readdirSync(backupsDir).filter((n) => n.startsWith("cmt-")).sort();
+    const latest = candidates[candidates.length - 1];
+    if (latest) {
+      const dir = path2.join(backupsDir, latest);
+      for (const f of ["CLAUDE.md", "settings.json"]) {
+        const src = path2.join(dir, f);
+        if (fs2.existsSync(src)) {
+          fs2.copyFileSync(src, path2.join(CLAUDE_DIR2, f));
+          say2(`restored ${f}`);
+        }
+      }
+    } else {
+      say2("no backup found");
+    }
+  } else {
+    say2("no backups dir");
+  }
+  head2("4. Remove PATH block from ~/.bashrc");
+  const bashrc = path2.join(os2.homedir(), ".bashrc");
+  const markerStart = "# >>> claude-master-toolkit >>>";
+  const markerEnd = "# <<< claude-master-toolkit <<<";
+  if (fs2.existsSync(bashrc)) {
+    const content = fs2.readFileSync(bashrc, "utf-8");
+    const lines = content.split("\n");
+    const si = lines.findIndex((l) => l.includes(markerStart));
+    const ei = lines.findIndex((l) => l.includes(markerEnd));
+    if (si !== -1 && ei !== -1 && ei >= si) {
+      lines.splice(si, ei - si + 1);
+      fs2.writeFileSync(bashrc, lines.join("\n"));
+      say2("removed PATH block");
+    } else {
+      say2("no PATH marker found");
+    }
+  }
+  head2("5. node_modules");
+  if (opts.cleanModules) {
+    const nm = path2.join(REPO_DIR2, "node_modules");
+    const lock = path2.join(REPO_DIR2, "package-lock.json");
+    if (fs2.existsSync(nm)) {
+      fs2.rmSync(nm, { recursive: true, force: true });
+      say2("removed node_modules");
+    }
+    if (fs2.existsSync(lock)) {
+      fs2.unlinkSync(lock);
+      say2("removed package-lock.json");
+    }
+  } else {
+    say2("kept (use --clean-modules to remove)");
+  }
+  head2("6. Caveman plugin");
+  if (opts.removeCaveman) {
+    try {
+      execSync4("command -v claude", { stdio: "ignore" });
+      try {
+        execSync4("claude plugin uninstall caveman@caveman", { stdio: "ignore" });
+        say2("caveman uninstalled");
+      } catch {
+        say2("caveman not installed or failed");
+      }
+    } catch {
+      say2("claude CLI not found");
+    }
+  } else {
+    say2("kept (use --remove-caveman to remove)");
+  }
+  head2("\u2713 Uninstalled");
+  console.log(`
+claude-master-toolkit removed.
+
+  Backups: ${path2.join(CLAUDE_DIR2, "backups")}
+  Reinstall: ctk install claude
+
+Reload shell: source ~/.bashrc
+`);
+}
+
 // src/cli/index.ts
-var VERSION = "0.1.2";
+var VERSION = "0.1.3";
 var program = new Command().name("ctk").description(
   "Claude Master Toolkit \u2014 token-efficient CLI + metrics dashboard"
 ).version(VERSION).option("--json", "Output in JSON format (AI-friendly)").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts["json"]) setJsonMode(true);
 });
+var install = program.command("install").description("Install integration stacks (claude, cursor, ...)");
+install.command("claude").description("Install Claude Code stack into ~/.claude").option("--skip-build", "Skip npm build step").option("--skip-deps", "Skip npm install step").action(installClaudeCommand);
+var uninstall = program.command("uninstall").description("Uninstall integration stacks");
+uninstall.command("claude").description("Uninstall Claude Code stack from ~/.claude").option("--clean-modules", "Also remove node_modules + package-lock.json").option("--remove-caveman", "Also uninstall caveman plugin").action(uninstallClaudeCommand);
 program.command("slice <file> <symbol>").description("Extract a symbol block from a file (function/class/type)").action(sliceCommand);
 program.command("model <phase>").description("Print model alias for an SDD phase (respects user preference)").action(modelCommand);
 program.command("model-pref [action] [value]").description("Get/set/clear model selection preference").action(modelPrefCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-master-toolkit",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Token-efficient CLI + metrics dashboard for Claude Code. Measure real cost, cut context bloat, and keep sessions cheap.",
   "type": "module",
   "bin": {