@whenlabs/when 0.9.0 → 0.9.1

package/dist/index.js

@@ -596,7 +596,7 @@ function createWatchCommand() {
 var program = new Command5();
 program.name("when").version("0.1.0").description("The WhenLabs developer toolkit \u2014 6 tools, one install");
 program.command("install").description("Install all WhenLabs tools globally (MCP server + CLAUDE.md instructions)").option("--cursor", "Install MCP servers into Cursor (~/.cursor/mcp.json)").option("--vscode", "Install MCP servers into VS Code (settings.json)").option("--windsurf", "Install MCP servers into Windsurf (~/.codeium/windsurf/mcp_config.json)").option("--all", "Install MCP servers into all supported editors").action(async (options) => {
-  const { install } = await import("./install-HPF26YW2.js");
+  const { install } = await import("./install-TFEGFWJ5.js");
   await install(options);
 });
 program.command("uninstall").description("Remove all WhenLabs tools").option("--cursor", "Remove MCP servers from Cursor").option("--vscode", "Remove MCP servers from VS Code").option("--windsurf", "Remove MCP servers from Windsurf").option("--all", "Remove MCP servers from all supported editors").action(async (options) => {

package/dist/install-TFEGFWJ5.js

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+import {
+  ALL_EDITORS,
+  installForEditor,
+  registerMcpServer
+} from "./chunk-3PDLNC63.js";
+import {
+  injectBlock
+} from "./chunk-NYUYV3UL.js";
+
+// src/commands/install.ts
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "fs";
+var CLAUDE_MD_PATH = join(homedir(), ".claude", "CLAUDE.md");
+var SCRIPTS_DIR = join(homedir(), ".claude", "scripts");
+var STATUSLINE_PATH = join(SCRIPTS_DIR, "statusline.py");
+var SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+var OLD_START_MARKER = "<!-- velocity-mcp:start -->";
+var OLD_END_MARKER = "<!-- velocity-mcp:end -->";
+var CLAUDE_MD_CONTENT = `# WhenLabs Toolkit
+
+## Task Timing (velocity-mcp)
+
+Velocity tools are part of the unified \`whenlabs\` MCP server. Follow these rules for EVERY session:
+
+1. **Before starting any discrete coding task**, call \`velocity_start_task\` with:
+   - Appropriate \`category\` (scaffold, implement, refactor, debug, test, config, docs, deploy)
+   - Relevant \`tags\` (e.g. typescript, react, sqlite, api)
+   - Clear \`description\` of what you're about to do
+   - \`estimated_files\` if you know how many files you'll touch
+   - \`project\` set to the current project name (auto-detected from git remote or directory name)
+
+2. **After completing each task**, call \`velocity_end_task\` with:
+   - The \`task_id\` from the start call
+   - \`status\`: completed, failed, or abandoned
+   - \`actual_files\`: how many files were actually modified
+   - \`notes\`: any useful context about what happened
+
+3. **When creating a multi-step plan**, call \`velocity_estimate\` to provide the user with a time estimate before starting work.
+
+4. **If the user asks about speed or performance**, call \`velocity_stats\` to show aggregate data.
+
+### Guidelines
+- Every discrete unit of work should be tracked \u2014 don't batch multiple unrelated changes into one task
+- If a task is abandoned or fails, still call \`velocity_end_task\` with the appropriate status
+- Use consistent tags across sessions so the similarity matching can find comparable historical tasks
+- Keep descriptions concise but specific enough to be useful for future matching
+
+## WhenLabs MCP Tools (ALWAYS prefer these over shell commands)
+
+All six tools (including velocity) are available through the unified \`whenlabs\` MCP server. **ALWAYS use these MCP tools instead of running shell commands like lsof, grep, or manual checks.** These tools are purpose-built and give better results:
+
+| When to use | Call this tool | NOT this |
+|-------------|---------------|----------|
+| Check ports or port conflicts | \`berth_status\` or \`berth_check\` | \`lsof\`, \`netstat\`, \`ss\` |
+| Scan dependency licenses | \`vow_scan\` or \`vow_check\` | manual \`npm ls\`, \`license-checker\` |
+| Check if docs are stale | \`stale_scan\` | manual file comparison |
+| Validate .env files | \`envalid_validate\` or \`envalid_detect\` | manual .env inspection |
+| Generate AI context files | \`aware_init\` or \`aware_doctor\` | manual CLAUDE.md creation |
+
+### Tool Reference
+- \`berth_status\` \u2014 Show all active ports, Docker ports, and configured ports
+- \`berth_check\` \u2014 Scan a project directory for port conflicts
+- \`stale_scan\` \u2014 Detect documentation drift in the codebase
+- \`envalid_validate\` \u2014 Validate .env files against their schema
+- \`envalid_detect\` \u2014 Find undocumented env vars in codebase
+- \`aware_init\` \u2014 Auto-detect stack and generate AI context files
+- \`aware_doctor\` \u2014 Diagnose project health and config issues
+- \`vow_scan\` \u2014 Scan and summarize all dependency licenses
+- \`vow_check\` \u2014 Validate licenses against a policy file
+
+### Proactive Background Scans
+WhenLabs tools run automatically in the background on a schedule. The status line shows findings:
+- \`stale:N\` \u2014 N docs have drifted from code. Run \`stale_scan\` and fix the drift.
+- \`env:N\` \u2014 N .env issues found. Run \`envalid_validate\` and help the user fix them.
+- \`ports:N\` \u2014 N port conflicts. Run \`berth_status\` and suggest resolution.
+- \`lic:N?\` \u2014 N packages with unknown licenses. Run \`vow_scan\` for details.
+- \`aware:stale\` \u2014 AI context files are outdated. Run \`aware_init\` to regenerate.
+
+**When you see any of these in the status line, proactively tell the user and offer to fix the issue.** Do not wait for the user to ask.`;
+var STATUSLINE_SCRIPT = `#!/usr/bin/env python3
+"""WhenLabs status line for Claude Code \u2014 with proactive background tool scans."""
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+CACHE_DIR = Path.home() / ".whenlabs" / "cache"
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+# Scan intervals in seconds
+INTERVALS = {
+    "berth":   900,   # 15 min
+    "stale":   1800,  # 30 min
+    "envalid": 1800,  # 30 min
+    "vow":     3600,  # 60 min
+    "aware":   3600,  # 60 min
+}
+
+
+class C:
+    AMBER = "\\033[38;2;196;106;26m"
+    BLUE = "\\033[38;2;59;130;246m"
+    CYAN = "\\033[38;2;34;211;238m"
+    GREEN = "\\033[38;2;34;197;94m"
+    RED = "\\033[38;2;239;68;68m"
+    YELLOW = "\\033[38;2;234;179;8m"
+    GRAY = "\\033[38;2;156;163;175m"
+    DIM = "\\033[2m"
+    RESET = "\\033[0m"
+    SEP = f"\\033[38;2;107;114;128m \\u30fb \\033[0m"
+
+
+def git_info(cwd):
+    try:
+        subprocess.run(["git", "rev-parse", "--git-dir"], cwd=cwd, capture_output=True, check=True, timeout=1)
+        branch = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd, capture_output=True, text=True, timeout=1).stdout.strip()
+        status = subprocess.run(["git", "status", "--porcelain"], cwd=cwd, capture_output=True, text=True, timeout=1).stdout
+        clean = len([l for l in status.strip().split("\\n") if l]) == 0
+        color = C.GREEN if clean else C.YELLOW
+        icon = "\\u2713" if clean else "\\u00b1"
+        return f"{color}{branch} {icon}{C.RESET}"
+    except Exception:
+        return None
+
+
+def mcp_servers(data):
+    servers = []
+    try:
+        cfg = Path.home() / ".claude.json"
+        if cfg.exists():
+            with open(cfg) as f:
+                servers.extend(json.load(f).get("mcpServers", {}).keys())
+    except Exception:
+        pass
+    cwd = data.get("workspace", {}).get("current_dir", "")
+    if cwd:
+        for p in [Path(cwd) / ".mcp.json", Path(cwd) / ".claude" / ".mcp.json"]:
+            try:
+                if p.exists():
+                    with open(p) as f:
+                        servers.extend(json.load(f).get("mcpServers", {}).keys())
+            except Exception:
+                pass
+    seen = set()
+    return [s for s in servers if not (s in seen or seen.add(s))]
+
+
+def context_pct(data):
+    try:
+        cw = data["context_window"]
+        size = cw["context_window_size"]
+        usage = cw.get("current_usage", {})
+        tokens = usage.get("input_tokens", 0) + usage.get("cache_creation_input_tokens", 0) + usage.get("cache_read_input_tokens", 0)
+        pct = (tokens * 100) // size
+        color = C.GREEN if pct < 40 else C.YELLOW if pct < 70 else C.RED
+        return f"{C.DIM}{color}{pct}%{C.RESET}"
+    except Exception:
+        return None
+
+
+def cost_info(data):
+    try:
+        cfg = Path.home() / ".claude.json"
+        if cfg.exists():
+            with open(cfg) as f:
+                if json.load(f).get("oauthAccount", {}).get("accountUuid"):
+                    return None
+    except Exception:
+        pass
+    try:
+        cost = data.get("cost", {}).get("total_cost_usd")
+        if cost:
+            color = C.GREEN if cost < 1 else C.YELLOW if cost < 5 else C.RED
+            return f"{color}\${cost:.2f}{C.RESET}"
+    except Exception:
+        pass
+    return None
+
+
+# --- Background tool scanning ---
+
+def cache_path(tool, cwd):
+    project = Path(cwd).name if cwd else "global"
+    return CACHE_DIR / f"{tool}_{project}.json"
+
+
+def should_run(tool, cwd):
+    cp = cache_path(tool, cwd)
+    if not cp.exists():
+        return True
+    try:
+        cached = json.loads(cp.read_text())
+        return (time.time() - cached.get("timestamp", 0)) > INTERVALS[tool]
+    except Exception:
+        return True
+
+
+def run_bg(tool, args, cwd):
+    cp = cache_path(tool, cwd)
+    snippet = (
+        "import subprocess, json, time, os; "
+        f"args = {args!r}; "
+        f"cwd = {cwd!r}; "
+        f"out_path = {str(cp)!r}; "
+        "env = {**os.environ, 'FORCE_COLOR': '0', 'NO_COLOR': '1'}; "
+        "r = subprocess.run(args, cwd=cwd, capture_output=True, text=True, env=env, timeout=60); "
+        "cache = {'timestamp': time.time(), 'output': r.stdout + r.stderr, 'code': r.returncode}; "
+        "open(out_path, 'w').write(json.dumps(cache))"
+    )
+    try:
+        subprocess.Popen(
+            [sys.executable, "-c", snippet],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    except Exception:
+        pass
+
+
+def read_cache(tool, cwd):
+    cp = cache_path(tool, cwd)
+    if not cp.exists():
+        return None
+    try:
+        return json.loads(cp.read_text())
+    except Exception:
+        return None
+
+
+def parse_stale(cached):
+    if not cached or cached["code"] != 0:
+        return None
+    out = cached["output"]
+    drifted = out.count("\\u2717")
+    if drifted > 0:
+        return f"{C.RED}stale:{drifted}{C.RESET}"
+    if "\\u2713" in out or "No drift" in out.lower() or "clean" in out.lower():
+        return f"{C.GREEN}stale:ok{C.RESET}"
+    return None
+
+
+def parse_envalid(cached):
+    if not cached:
+        return None
+    out = cached["output"]
+    if cached["code"] != 0:
+        errors = sum(1 for line in out.split("\\n") if "\\u2717" in line or "error" in line.lower() or "missing" in line.lower())
+        if errors > 0:
+            return f"{C.RED}env:{errors}{C.RESET}"
+        return f"{C.YELLOW}env:?{C.RESET}"
+    return f"{C.GREEN}env:ok{C.RESET}"
+
+
+def parse_berth(cached):
+    if not cached:
+        return None
+    out = cached["output"]
+    conflicts = out.lower().count("conflict")
+    if conflicts > 0:
+        return f"{C.RED}ports:{conflicts}{C.RESET}"
+    return None
+
+
+def parse_vow(cached):
+    if not cached:
+        return None
+    out = cached["output"]
+    unknown = 0
+    for line in out.split("\\n"):
+        low = line.lower()
+        if "unknown" in low or "unlicensed" in low:
+            for word in line.split():
+                if word.isdigit():
+                    unknown += int(word)
+                    break
+            else:
+                unknown += 1
+    if unknown > 0:
+        return f"{C.YELLOW}lic:{unknown}?{C.RESET}"
+    return None
+
+
+def parse_aware(cached):
+    if not cached:
+        return None
+    out = cached["output"]
+    if cached["code"] != 0 or "stale" in out.lower() or "outdated" in out.lower() or "drift" in out.lower():
+        return f"{C.YELLOW}aware:stale{C.RESET}"
+    return None
+
+
+def run_scans(cwd):
+    if not cwd:
+        return []
+
+    scans = {
+        "stale":   (["npx", "--yes", "@whenlabs/stale", "scan"], parse_stale),
+        "envalid": (["npx", "--yes", "@whenlabs/envalid", "validate"], parse_envalid),
+        "berth":   (["npx", "--yes", "@whenlabs/berth", "check", "."], parse_berth),
+        "vow":     (["npx", "--yes", "@whenlabs/vow", "scan"], parse_vow),
+        "aware":   (["npx", "--yes", "@whenlabs/aware", "doctor"], parse_aware),
+    }
+
+    for tool, (args, _) in scans.items():
+        if should_run(tool, cwd):
+            run_bg(tool, args, cwd)
+            break
+
+    results = []
+    for tool, (_, parser) in scans.items():
+        cached = read_cache(tool, cwd)
+        if cached:
+            parsed = parser(cached)
+            if parsed:
+                results.append(parsed)
+
+    return results
+
+
+def main():
+    try:
+        data = json.loads(sys.stdin.read())
+    except Exception:
+        return
+
+    parts = []
+
+    cwd = data.get("workspace", {}).get("current_dir", "")
+    if cwd:
+        parts.append(f"{C.BLUE}{Path(cwd).name}{C.RESET}")
+
+    if cwd:
+        g = git_info(cwd)
+        if g:
+            parts.append(g)
+
+    servers = mcp_servers(data)
+    if servers:
+        names = " ".join(servers)
+        parts.append(f"{C.AMBER}{C.DIM}{names}{C.RESET}")
+
+    c = cost_info(data)
+    if c:
+        parts.append(c)
+
+    model = data.get("model", {}).get("display_name", "")
+    if model:
+        short = "".join(ch for ch in model if ch.isalpha()).lower()
+        parts.append(f"{C.GRAY}{short}{C.RESET}")
+
+    ctx = context_pct(data)
+    if ctx:
+        parts.append(ctx)
+
+    ver = data.get("version")
+    if ver:
+        parts.append(f"{C.DIM}{C.GRAY}v{ver}{C.RESET}")
+
+    scan_results = run_scans(cwd)
+
+    print(C.SEP.join(parts))
+
+    if scan_results:
+        print(f"{C.DIM}{C.GRAY}  tools:{C.RESET} {f' {C.DIM}|{C.RESET} '.join(scan_results)}")
+
+
+if __name__ == "__main__":
+    main()
+`;
+function installStatusLine() {
+  try {
+    mkdirSync(SCRIPTS_DIR, { recursive: true });
+    writeFileSync(STATUSLINE_PATH, STATUSLINE_SCRIPT, "utf-8");
+    chmodSync(STATUSLINE_PATH, 493);
+    let settings = {};
+    if (existsSync(SETTINGS_PATH)) {
+      try {
+        settings = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    const statuslineCmd = `python3 ${STATUSLINE_PATH}`;
+    const currentCmd = settings.statusLine?.command;
+    if (currentCmd !== statuslineCmd) {
+      settings.statusLine = { type: "command", command: statuslineCmd };
+      writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+    return { installed: true, message: "Status line installed (proactive background scans)" };
+  } catch (err) {
+    return { installed: false, message: `Status line install failed: ${err.message}` };
+  }
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasOldBlock(filePath) {
+  if (!existsSync(filePath)) return false;
+  const content = readFileSync(filePath, "utf-8");
+  return content.includes(OLD_START_MARKER) && content.includes(OLD_END_MARKER);
+}
+function removeOldBlock(filePath) {
+  if (!existsSync(filePath)) return;
+  let content = readFileSync(filePath, "utf-8");
+  const pattern = new RegExp(
+    `\\n?${escapeRegex(OLD_START_MARKER)}[\\s\\S]*?${escapeRegex(OLD_END_MARKER)}\\n?`,
+    "g"
+  );
+  content = content.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+  writeFileSync(filePath, content, "utf-8");
+}
+async function install(options = {}) {
+  console.log("\n\u{1F527} WhenLabs toolkit installer\n");
+  const editorFlags = options.all ? ALL_EDITORS : [
+    options.cursor && "cursor",
+    options.vscode && "vscode",
+    options.windsurf && "windsurf"
+  ].filter(Boolean);
+  const claudeOnly = editorFlags.length === 0;
+  if (claudeOnly) {
+    const mcpResult = registerMcpServer();
+    console.log(mcpResult.success ? `  \u2713 ${mcpResult.message}` : `  \u2717 ${mcpResult.message}`);
+    injectBlock(CLAUDE_MD_PATH, CLAUDE_MD_CONTENT);
+    console.log(`  \u2713 CLAUDE.md instructions written to ${CLAUDE_MD_PATH}`);
+    const slResult = installStatusLine();
+    console.log(slResult.installed ? `  \u2713 ${slResult.message}` : `  \u2717 ${slResult.message}`);
+    if (hasOldBlock(CLAUDE_MD_PATH)) {
+      removeOldBlock(CLAUDE_MD_PATH);
+      console.log("  \u2713 Removed legacy velocity-mcp markers (migrated to whenlabs block)");
+    }
+  } else {
+    for (const editor of editorFlags) {
+      const result = installForEditor(editor);
+      console.log(result.success ? `  \u2713 ${result.message}` : `  \u2717 ${result.message}`);
+    }
+  }
+  console.log("\nInstallation complete. Run `when status` to verify.\n");
+}
+export {
+  install
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whenlabs/when",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "The WhenLabs developer toolkit — 6 tools, one install",
   "type": "module",
   "main": "dist/index.js",

package/dist/install-HPF26YW2.js

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-import {
-  ALL_EDITORS,
-  installForEditor,
-  registerMcpServer
-} from "./chunk-3PDLNC63.js";
-import {
-  injectBlock
-} from "./chunk-NYUYV3UL.js";
-
-// src/commands/install.ts
-import { join } from "path";
-import { homedir } from "os";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-var CLAUDE_MD_PATH = join(homedir(), ".claude", "CLAUDE.md");
-var OLD_START_MARKER = "<!-- velocity-mcp:start -->";
-var OLD_END_MARKER = "<!-- velocity-mcp:end -->";
-var CLAUDE_MD_CONTENT = `# WhenLabs Toolkit
-
-## Task Timing (velocity-mcp)
-
-Velocity tools are part of the unified \`whenlabs\` MCP server. Follow these rules for EVERY session:
-
-1. **Before starting any discrete coding task**, call \`velocity_start_task\` with:
-   - Appropriate \`category\` (scaffold, implement, refactor, debug, test, config, docs, deploy)
-   - Relevant \`tags\` (e.g. typescript, react, sqlite, api)
-   - Clear \`description\` of what you're about to do
-   - \`estimated_files\` if you know how many files you'll touch
-   - \`project\` set to the current project name (auto-detected from git remote or directory name)
-
-2. **After completing each task**, call \`velocity_end_task\` with:
-   - The \`task_id\` from the start call
-   - \`status\`: completed, failed, or abandoned
-   - \`actual_files\`: how many files were actually modified
-   - \`notes\`: any useful context about what happened
-
-3. **When creating a multi-step plan**, call \`velocity_estimate\` to provide the user with a time estimate before starting work.
-
-4. **If the user asks about speed or performance**, call \`velocity_stats\` to show aggregate data.
-
-### Guidelines
-- Every discrete unit of work should be tracked \u2014 don't batch multiple unrelated changes into one task
-- If a task is abandoned or fails, still call \`velocity_end_task\` with the appropriate status
-- Use consistent tags across sessions so the similarity matching can find comparable historical tasks
-- Keep descriptions concise but specific enough to be useful for future matching
-
-## WhenLabs MCP Tools (ALWAYS prefer these over shell commands)
-
-All six tools (including velocity) are available through the unified \`whenlabs\` MCP server. **ALWAYS use these MCP tools instead of running shell commands like lsof, grep, or manual checks.** These tools are purpose-built and give better results:
-
-| When to use | Call this tool | NOT this |
-|-------------|---------------|----------|
-| Check ports or port conflicts | \`berth_status\` or \`berth_check\` | \`lsof\`, \`netstat\`, \`ss\` |
-| Scan dependency licenses | \`vow_scan\` or \`vow_check\` | manual \`npm ls\`, \`license-checker\` |
-| Check if docs are stale | \`stale_scan\` | manual file comparison |
-| Validate .env files | \`envalid_validate\` or \`envalid_detect\` | manual .env inspection |
-| Generate AI context files | \`aware_init\` or \`aware_doctor\` | manual CLAUDE.md creation |
-
-### Tool Reference
-- \`berth_status\` \u2014 Show all active ports, Docker ports, and configured ports
-- \`berth_check\` \u2014 Scan a project directory for port conflicts
-- \`stale_scan\` \u2014 Detect documentation drift in the codebase
-- \`envalid_validate\` \u2014 Validate .env files against their schema
-- \`envalid_detect\` \u2014 Find undocumented env vars in codebase
-- \`aware_init\` \u2014 Auto-detect stack and generate AI context files
-- \`aware_doctor\` \u2014 Diagnose project health and config issues
-- \`vow_scan\` \u2014 Scan and summarize all dependency licenses
-- \`vow_check\` \u2014 Validate licenses against a policy file
-
-### Proactive Background Scans
-WhenLabs tools run automatically in the background on a schedule. The status line shows findings:
-- \`stale:N\` \u2014 N docs have drifted from code. Run \`stale_scan\` and fix the drift.
-- \`env:N\` \u2014 N .env issues found. Run \`envalid_validate\` and help the user fix them.
-- \`ports:N\` \u2014 N port conflicts. Run \`berth_status\` and suggest resolution.
-- \`lic:N?\` \u2014 N packages with unknown licenses. Run \`vow_scan\` for details.
-- \`aware:stale\` \u2014 AI context files are outdated. Run \`aware_init\` to regenerate.
-
-**When you see any of these in the status line, proactively tell the user and offer to fix the issue.** Do not wait for the user to ask.`;
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function hasOldBlock(filePath) {
-  if (!existsSync(filePath)) return false;
-  const content = readFileSync(filePath, "utf-8");
-  return content.includes(OLD_START_MARKER) && content.includes(OLD_END_MARKER);
-}
-function removeOldBlock(filePath) {
-  if (!existsSync(filePath)) return;
-  let content = readFileSync(filePath, "utf-8");
-  const pattern = new RegExp(
-    `\\n?${escapeRegex(OLD_START_MARKER)}[\\s\\S]*?${escapeRegex(OLD_END_MARKER)}\\n?`,
-    "g"
-  );
-  content = content.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
-  writeFileSync(filePath, content, "utf-8");
-}
-async function install(options = {}) {
-  console.log("\n\u{1F527} WhenLabs toolkit installer\n");
-  const editorFlags = options.all ? ALL_EDITORS : [
-    options.cursor && "cursor",
-    options.vscode && "vscode",
-    options.windsurf && "windsurf"
-  ].filter(Boolean);
-  const claudeOnly = editorFlags.length === 0;
-  if (claudeOnly) {
-    const mcpResult = registerMcpServer();
-    console.log(mcpResult.success ? `  \u2713 ${mcpResult.message}` : `  \u2717 ${mcpResult.message}`);
-    injectBlock(CLAUDE_MD_PATH, CLAUDE_MD_CONTENT);
-    console.log(`  \u2713 CLAUDE.md instructions written to ${CLAUDE_MD_PATH}`);
-    if (hasOldBlock(CLAUDE_MD_PATH)) {
-      removeOldBlock(CLAUDE_MD_PATH);
-      console.log("  \u2713 Removed legacy velocity-mcp markers (migrated to whenlabs block)");
-    }
-  } else {
-    for (const editor of editorFlags) {
-      const result = installForEditor(editor);
-      console.log(result.success ? `  \u2713 ${result.message}` : `  \u2717 ${result.message}`);
-    }
-  }
-  console.log("\nInstallation complete. Run `when status` to verify.\n");
-}
-export {
-  install
-};