claude-master-toolkit 0.1.2 → 0.1.4

package/README.md

@@ -1,4 +1,4 @@
-# workctl
+# claude-master-toolkit
 
 **Token-efficient CLI + metrics dashboard for [Claude Code](https://claude.ai/code).**
 
@@ -15,7 +15,7 @@ Opens a local dashboard at `http://localhost:3200` backed by SQLite. Reads your
 
 ## Why
 
-Claude Code stores every session as JSONL under `~/.claude/projects/`. That's the source of truth for real token usage and cost — but there's no good way to see it. `workctl` parses those files into SQLite and gives you:
+Claude Code stores every session as JSONL under `~/.claude/projects/`. That's the source of truth for real token usage and cost — but there's no good way to see it. `claude-master-toolkit` parses those files into SQLite and gives you:
 
 - **Realized cost** per session, per project, per day — using the actual Claude 4.6 / 4.5 pricing table.
 - **Context window telemetry** — know when you're about to hit the 200k wall before the warning.
@@ -27,7 +27,7 @@ Think of it as the missing `/cost` page for Claude Code.
 ## Install
 
 ```bash
-npm install -g workctl
+npm install -g claude-master-toolkit
 ```
 
 Requires Node 18+. The database auto-initializes on first run at `~/.claude/state/claude-master-toolkit/ctk.sqlite`.
@@ -37,9 +37,9 @@ Requires Node 18+. The database auto-initializes on first run at `~/.claude/stat
 ### Dashboard
 
 ```bash
-workctl dashboard              # http://localhost:3200
-workctl dashboard -p 4000      # custom port
-workctl dashboard --no-open    # don't auto-open browser
+ctk dashboard              # http://localhost:3200
+ctk dashboard -p 4000      # custom port
+ctk dashboard --no-open    # don't auto-open browser
 ```
 
 The server watches `~/.claude/projects/` and syncs new session events in real time.
@@ -48,19 +48,19 @@ The server watches `~/.claude/projects/` and syncs new session events in real ti
 
 All commands are designed to return **compact, Claude-friendly output** — ideal for the `Bash` tool in agent loops.
 
-| Command                         | What it does                                                                |
-| ------------------------------- | --------------------------------------------------------------------------- |
-| `workctl cost [--quiet]`        | Realized cost of the current session (reads session JSONL, applies pricing) |
-| `workctl context`               | Current window usage, cumulative totals, cost, threshold advice             |
-| `workctl tokens [file]`         | Rough token count for a file or stdin (`chars / 4`)                         |
-| `workctl estimate <file>`       | Faithful pre-flight count via Anthropic `count_tokens` API                  |
-| `workctl slice <file> <symbol>` | Extract just one function / class / type from a file                        |
-| `workctl find <query> [path]`   | Ranked ripgrep, top 20 results                                              |
-| `workctl git-log [N]`           | One-line log for last N commits                                             |
-| `workctl git-changed`           | Files changed vs main branch with line counts                               |
-| `workctl test-summary [cmd]`    | Run a test command, print only pass/fail summary                            |
-| `workctl model <phase>`         | Model alias recommendation per SDD phase                                    |
-| `workctl dashboard`             | Launch the local metrics dashboard                                          |
+| Command                     | What it does                                                                |
+| --------------------------- | --------------------------------------------------------------------------- |
+| `ctk cost [--quiet]`        | Realized cost of the current session (reads session JSONL, applies pricing) |
+| `ctk context`               | Current window usage, cumulative totals, cost, threshold advice             |
+| `ctk tokens [file]`         | Rough token count for a file or stdin (`chars / 4`)                         |
+| `ctk estimate <file>`       | Faithful pre-flight count via Anthropic `count_tokens` API                  |
+| `ctk slice <file> <symbol>` | Extract just one function / class / type from a file                        |
+| `ctk find <query> [path]`   | Ranked ripgrep, top 20 results                                              |
+| `ctk git-log [N]`           | One-line log for last N commits                                             |
+| `ctk git-changed`           | Files changed vs main branch with line counts                               |
+| `ctk test-summary [cmd]`    | Run a test command, print only pass/fail summary                            |
+| `ctk model <phase>`         | Model alias recommendation per SDD phase                                    |
+| `ctk dashboard`             | Launch the local metrics dashboard                                          |
 
 Every command supports `--json` for machine-readable output.
 
@@ -80,7 +80,7 @@ Pricing table is hard-coded in `src/shared/pricing.ts` for the Claude 4.6 / 4.5
 
 ## Context window vs cumulative cost
 
-These are **different metrics** and `workctl` reports both:
+These are **different metrics** and `ctk` reports both:
 
 - **Context window** = what Claude sees right now. Equals the last turn's `input + cache_read + output`. Not a running sum — summing double-counts cache reads.
 - **Cumulative cost** = every turn's tokens weighted by per-model prices. This is what `/cost` shows.

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,231 @@ 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";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname2 = path.dirname(__filename);
+var PKG_ROOT = path.resolve(__dirname2, "..");
+var CLAUDE_DIST = path.join(PKG_ROOT, "claude-dist");
+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 linkForce(target, link, type) {
+  fs.mkdirSync(path.dirname(link), { recursive: true });
+  const stat = fs.lstatSync(link, { throwIfNoEntry: false });
+  if (stat) fs.unlinkSync(link);
+  fs.symlinkSync(target, link, type);
+}
+async function installClaudeCommand(opts) {
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    die("~/.claude not found \u2014 is Claude Code installed?");
+  }
+  if (!fs.existsSync(CLAUDE_DIST)) {
+    die(`claude-dist not found at ${CLAUDE_DIST} \u2014 broken package?`);
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupDir = path.join(CLAUDE_DIR, "backups", `cmt-${timestamp}`);
+  head("1. Backup existing config");
+  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, "pkg-root"), PKG_ROOT);
+  head("2. Symlink CLAUDE.md + hooks");
+  linkForce(path.join(CLAUDE_DIST, "CLAUDE.md"), claudeMdPath, "file");
+  for (const hook of ["session-start.sh", "user-prompt-submit.sh"]) {
+    const src = path.join(CLAUDE_DIST, "hooks", hook);
+    try {
+      fs.chmodSync(src, 493);
+    } catch {
+    }
+    linkForce(src, path.join(CLAUDE_DIR, "hooks", hook), "file");
+  }
+  say("linked CLAUDE.md + hooks (2)");
+  head("3. Symlink skills + agents");
+  const skills = ["sdd-new", "sdd-ff", "sdd-continue", "engram-protocol", "delegate"];
+  for (const skill of skills) {
+    linkForce(
+      path.join(CLAUDE_DIST, "skills", skill),
+      path.join(CLAUDE_DIR, "skills", skill),
+      "dir"
+    );
+  }
+  linkForce(
+    path.join(CLAUDE_DIST, "agents", "sdd-orchestrator.md"),
+    path.join(CLAUDE_DIR, "agents", "sdd-orchestrator.md"),
+    "file"
+  );
+  say(`linked skills (${skills.length}) + agents (1)`);
+  head("4. Merge settings.json");
+  const patchPath = path.join(CLAUDE_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("5. 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: " + fs.readFileSync(prefFile, "utf-8").trim());
+  }
+  head("6. Caveman plugin");
+  if (opts.skipCaveman) {
+    say("skipped (--skip-caveman)");
+  } else {
+    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 Claude stack installed");
+  console.log(`
+Package: ${PKG_ROOT}
+Backup:  ${backupDir}
+Config:  ~/.claude (symlinked)
+
+To remove: ctk uninstall claude
+`);
+}
+
+// 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 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 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. 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 Claude stack removed");
+  console.log(`
+Backups: ${path2.join(CLAUDE_DIR2, "backups")}
+Reinstall: ctk install claude
+`);
+}
+
 // src/cli/index.ts
-var VERSION = "0.1.2";
+var VERSION = "0.1.4";
 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 (symlinks + settings)").option("--skip-caveman", "Skip caveman plugin install").action(installClaudeCommand);
+var uninstall = program.command("uninstall").description("Uninstall integration stacks");
+uninstall.command("claude").description("Uninstall Claude Code stack from ~/.claude (restore backup)").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.4",
   "description": "Token-efficient CLI + metrics dashboard for Claude Code. Measure real cost, cut context bloat, and keep sessions cheap.",
   "type": "module",
   "bin": {