litclaude-ai 0.2.2

package/bin/litclaude-ai.js

@@ -0,0 +1,643 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { HUD_ACCENT_THEMES, normalizeHudAccent, themeForAccent } from "../plugins/litclaude/lib/hud-accent-palette.mjs";
+import { runStartWorkContinuationCli } from "../plugins/litclaude/lib/start-work-continuation.mjs";
+import { runLitgoalCli } from "../plugins/litclaude/lib/litgoal/cli.mjs";
+import { runWorkflowCheckCli } from "../plugins/litclaude/lib/workflow-check.mjs";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+const version = packageJson.version;
+
+const usage = `Usage: litclaude-ai [--dry-run] <install|doctor|path|run|update|uninstall|litgoal|workflow-check|start-work-next> [...args]
+       litclaude-ai --version
+
+Commands:
+  install       Register the packaged LitClaude plugin in Claude Code.
+  doctor        Validate the installed LitClaude plugin path.
+  path          Print the installed Claude plugin path.
+  run -- ...    Run Claude Code after the global plugin install.
+  litgoal       Manage litgoal runtime state and evidence.
+  workflow-check Verify Dynamic workflow, /goal, and subagent delegation readiness.
+  start-work-next Print the next active start-work continuation directive.
+  update        Reinstall this package version and refresh the Claude plugin registry.
+  uninstall     Remove LitClaude-managed install state.
+`;
+
+const parseArgs = (argv) => {
+  const args = [...argv];
+  const wantsVersion = args[0] === "--version" || args[0] === "-v";
+  if (wantsVersion) return { dryRun: false, command: "version", rest: [] };
+  const dryRun = args[0] === "--dry-run";
+  if (dryRun) args.shift();
+  return { dryRun, command: args[0], rest: args.slice(1) };
+};
+
+const litHome = () => resolve(process.env.LITCLAUDE_HOME ?? join(homedir(), ".litclaude"));
+const claudeHome = () => resolve(process.env.CLAUDE_CONFIG_DIR ?? process.env.CLAUDE_HOME ?? join(homedir(), ".claude"));
+const versionRoot = (home = litHome()) => join(home, "litclaude-ai", version);
+const currentRoot = (home = litHome()) => join(home, "current");
+const pluginPathForRoot = (installRoot) => join(installRoot, "plugins", "litclaude");
+const claudePluginRoot = (home = claudeHome()) => join(home, "plugins", "cache", "litclaude-ai", "litclaude", version);
+const installedPluginsPath = (home = claudeHome()) => join(home, "plugins", "installed_plugins.json");
+const knownMarketplacesPath = (home = claudeHome()) => join(home, "plugins", "known_marketplaces.json");
+const claudeSettingsPath = (home = claudeHome()) => join(home, "settings.json");
+const pluginKey = "litclaude@litclaude-ai";
+const marketplaceName = "litclaude-ai";
+const intendedPluginPath = (home = claudeHome()) => claudePluginRoot(home);
+const marketplaceRoot = (home = litHome()) => join(home, "marketplaces", marketplaceName);
+const marketplacePluginPath = (home = litHome()) => join(marketplaceRoot(home), "plugins", "litclaude");
+const sourcePluginPath = () => join(root, "plugins", "litclaude");
+const litClaudeSettingsKey = "litclaude";
+const knownExternalLspPlugins = {
+  "typescript-lsp@claude-plugins-official": ["typescript-language-server"],
+  "rust-analyzer-lsp@claude-plugins-official": ["rust-analyzer"],
+  "pyright-lsp@claude-plugins-official": ["pyright-langserver", "pyright"],
+  "gopls-lsp@claude-plugins-official": ["gopls"],
+};
+const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const hudAccentThemes = HUD_ACCENT_THEMES;
+
+const printUsage = () => {
+  process.stderr.write(usage);
+};
+
+const fail = (message, status = 1) => {
+  process.stderr.write(`${message}\n`);
+  process.exit(status);
+};
+
+const shouldAnimateInstall = () => {
+  if (process.env.LITCLAUDE_SPINNER === "1") return true;
+  if (process.env.LITCLAUDE_SPINNER === "0") return false;
+  return Boolean(process.stdout.isTTY && !process.env.CI);
+};
+
+const installStepTheme = (label) => {
+  if (/registry|HUD/iu.test(label)) return { code: 215, tag: "registry" };
+  if (/plugin/iu.test(label)) return { code: 141, tag: "plugin" };
+  if (/marketplace/iu.test(label)) return { code: 111, tag: "market" };
+  if (/cache/iu.test(label)) return { code: 179, tag: "cache" };
+  return { code: 81, tag: "setup" };
+};
+
+const color256 = (code, text) => `\x1b[38;5;${code}m${text}\x1b[0m`;
+
+const formatInstallStep = (label) => {
+  const theme = installStepTheme(label);
+  return `${color256(theme.code, theme.tag)} \x1b[1m${label}\x1b[0m`;
+};
+
+const createInstallProgress = () => {
+  const animated = shouldAnimateInstall();
+  let frameIndex = 0;
+  return {
+    step(label) {
+      if (!animated) {
+        process.stdout.write(`INSTALL_STEP: ${label}\n`);
+        return;
+      }
+      const frame = spinnerFrames[frameIndex % spinnerFrames.length];
+      frameIndex += 1;
+      process.stdout.write(`${color256(81, frame)} ${formatInstallStep(label)}\n`);
+    },
+    done(label) {
+      if (!animated) {
+        process.stdout.write(`INSTALL_STEP: ${label}\n`);
+        return;
+      }
+      process.stdout.write(`${color256(119, "✔")} \x1b[1m${label}\x1b[0m\n`);
+    },
+  };
+};
+
+const currentExists = (home = claudeHome()) => existsSync(claudePluginRoot(home));
+
+const readInstalledPlugins = (home = claudeHome()) => {
+  const registryPath = installedPluginsPath(home);
+  if (!existsSync(registryPath)) return { version: 2, plugins: {} };
+  const parsed = JSON.parse(readFileSync(registryPath, "utf8"));
+  return {
+    ...parsed,
+    version: parsed.version ?? 2,
+    plugins: parsed.plugins ?? {},
+  };
+};
+
+const writeInstalledPlugins = (registry, home = claudeHome()) => {
+  const registryPath = installedPluginsPath(home);
+  mkdirSync(dirname(registryPath), { recursive: true });
+  writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`);
+};
+
+const readClaudeSettings = (home = claudeHome()) => {
+  const settingsPath = claudeSettingsPath(home);
+  if (!existsSync(settingsPath)) return {};
+  return JSON.parse(readFileSync(settingsPath, "utf8"));
+};
+
+const writeClaudeSettings = (settings, home = claudeHome()) => {
+  const settingsPath = claudeSettingsPath(home);
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+};
+
+const hudAccentPreview = (theme) =>
+  `\x1b[1m\x1b[38;5;201m[🔥LITCLAUDE v${version}]\x1b[0m\x1b[38;5;${theme.code}m | O4.8 │ ctx [▌░░] 18%/1000k │ 5h [▏░] 4%\x1b[0m`;
+
+const shouldPromptHudAccent = () => {
+  if (process.env.LITCLAUDE_HUD_ACCENT_PROMPT === "1") return true;
+  if (process.env.LITCLAUDE_HUD_ACCENT_PROMPT === "0") return false;
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+};
+
+const chooseHudAccent = async () => {
+  const envAccent = process.env.LITCLAUDE_HUD_ACCENT;
+  if (envAccent && process.env.LITCLAUDE_HUD_ACCENT_PROMPT !== "1") {
+    return normalizeHudAccent(envAccent);
+  }
+  if (!shouldPromptHudAccent()) return normalizeHudAccent(envAccent);
+
+  process.stdout.write("Choose LitClaude HUD brand color:\n");
+  for (const [index, theme] of hudAccentThemes.entries()) {
+    process.stdout.write(`  ${index + 1}) ${theme.name.padEnd(8)} ${hudAccentPreview(theme)}  ${theme.mood}\n`);
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question("Color 1-10 or name [cyan]: ");
+    const trimmed = answer.trim().toLowerCase();
+    const byIndex = hudAccentThemes[Number.parseInt(trimmed, 10) - 1]?.name;
+    const selected = byIndex ?? normalizeHudAccent(trimmed);
+    if (trimmed && selected === "cyan" && trimmed !== "cyan" && byIndex === undefined) {
+      process.stdout.write("HUD_COLOR_WARNING: unknown color; using cyan\n");
+    }
+    process.stdout.write(`HUD_COLOR_SELECTED: ${selected} ${hudAccentPreview(themeForAccent(selected))}\n`);
+    return selected;
+  } finally {
+    rl.close();
+  }
+};
+
+const hudCommandForPlugin = (pluginPath, accent = "cyan") =>
+  `LITCLAUDE_HUD_ACCENT=${normalizeHudAccent(accent)} node "${join(pluginPath, "bin", "litclaude-hud.js")}"`;
+
+const readKnownMarketplaces = (home = claudeHome()) => {
+  const path = knownMarketplacesPath(home);
+  if (!existsSync(path)) return {};
+  return JSON.parse(readFileSync(path, "utf8"));
+};
+
+const writeKnownMarketplaces = (knownMarketplaces, home = claudeHome()) => {
+  const path = knownMarketplacesPath(home);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(knownMarketplaces, null, 2)}\n`);
+};
+
+const marketplaceSource = (marketplacePath) => ({
+  source: "directory",
+  path: marketplacePath,
+});
+
+const writeLocalMarketplace = (home = litHome()) => {
+  const rootPath = marketplaceRoot(home);
+  const targetPlugin = marketplacePluginPath(home);
+  rmSync(rootPath, { recursive: true, force: true });
+  mkdirSync(dirname(targetPlugin), { recursive: true });
+  cpSync(sourcePluginPath(), targetPlugin, { recursive: true });
+  const marketplaceManifestPath = join(rootPath, ".claude-plugin", "marketplace.json");
+  mkdirSync(dirname(marketplaceManifestPath), { recursive: true });
+  writeFileSync(
+    marketplaceManifestPath,
+    `${JSON.stringify(
+      {
+        $schema: "https://anthropic.com/claude-code/marketplace.schema.json",
+        name: marketplaceName,
+        description: "Local LitClaude npm-installed marketplace.",
+        owner: {
+          name: "LitClaude contributors",
+        },
+        plugins: [
+          {
+            name: "litclaude",
+            displayName: "LitClaude",
+            version,
+            description: packageJson.description,
+            author: {
+              name: "LitClaude contributors",
+            },
+            source: "./plugins/litclaude",
+            category: "development",
+            homepage: "https://github.com/wjgoarxiv/litclaude",
+          },
+        ],
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  return rootPath;
+};
+
+const registerMarketplace = (marketplacePath, home = claudeHome()) => {
+  const settings = readClaudeSettings(home);
+  settings.enabledPlugins = settings.enabledPlugins ?? {};
+  settings.enabledPlugins[pluginKey] = true;
+  settings.extraKnownMarketplaces = settings.extraKnownMarketplaces ?? {};
+  settings.extraKnownMarketplaces[marketplaceName] = {
+    source: marketplaceSource(marketplacePath),
+  };
+  writeClaudeSettings(settings, home);
+
+  const knownMarketplaces = readKnownMarketplaces(home);
+  knownMarketplaces[marketplaceName] = {
+    source: marketplaceSource(marketplacePath),
+    installLocation: marketplacePath,
+    lastUpdated: new Date().toISOString(),
+  };
+  writeKnownMarketplaces(knownMarketplaces, home);
+};
+
+const installHudStatusLine = (pluginPath, home = claudeHome(), accent = "cyan") => {
+  const settings = readClaudeSettings(home);
+  const hudAccent = normalizeHudAccent(accent);
+  const command = hudCommandForPlugin(pluginPath, hudAccent);
+  const existingLitClaude = settings[litClaudeSettingsKey] ?? {};
+  const now = new Date().toISOString();
+  const previousStatusLine =
+    existingLitClaude.statusLineManaged === true
+      ? existingLitClaude.previousStatusLine
+      : settings.statusLine;
+
+  settings.statusLine = {
+    type: "command",
+    command,
+  };
+  settings[litClaudeSettingsKey] = {
+    ...existingLitClaude,
+    statusLineManaged: true,
+    statusLineCommand: command,
+    statusLineVersion: version,
+    hudAccent,
+    statusLineInstalledAt: existingLitClaude.statusLineInstalledAt ?? now,
+    statusLineUpdatedAt: now,
+    previousStatusLine: previousStatusLine ?? null,
+  };
+  writeClaudeSettings(settings, home);
+};
+
+const uninstallHudStatusLine = (home = claudeHome()) => {
+  const settingsPath = claudeSettingsPath(home);
+  if (!existsSync(settingsPath)) return;
+
+  const settings = readClaudeSettings(home);
+  const litClaude = settings[litClaudeSettingsKey];
+  if (litClaude?.statusLineManaged !== true) return;
+
+  if (settings.statusLine?.command === litClaude.statusLineCommand) {
+    if (litClaude.previousStatusLine) {
+      settings.statusLine = litClaude.previousStatusLine;
+    } else {
+      delete settings.statusLine;
+    }
+  } else if (settings.statusLine?.command) {
+    process.stdout.write("HUD_WARNING: statusLine changed by user; leaving it untouched\n");
+  }
+
+  const remainingLitClaude = { ...litClaude };
+  for (const key of [
+    "statusLineManaged",
+    "statusLineCommand",
+    "statusLineVersion",
+    "hudAccent",
+    "statusLineInstalledAt",
+    "statusLineUpdatedAt",
+    "previousStatusLine",
+  ]) {
+    delete remainingLitClaude[key];
+  }
+
+  if (Object.keys(remainingLitClaude).length > 0) {
+    settings[litClaudeSettingsKey] = remainingLitClaude;
+  } else {
+    delete settings[litClaudeSettingsKey];
+  }
+  writeClaudeSettings(settings, home);
+};
+
+const unregisterMarketplace = (home = claudeHome()) => {
+  const settingsPath = claudeSettingsPath(home);
+  if (existsSync(settingsPath)) {
+    const settings = readClaudeSettings(home);
+    if (settings.enabledPlugins) delete settings.enabledPlugins[pluginKey];
+    if (settings.extraKnownMarketplaces) delete settings.extraKnownMarketplaces[marketplaceName];
+    writeClaudeSettings(settings, home);
+  }
+
+  const knownPath = knownMarketplacesPath(home);
+  if (existsSync(knownPath)) {
+    const knownMarketplaces = readKnownMarketplaces(home);
+    delete knownMarketplaces[marketplaceName];
+    writeKnownMarketplaces(knownMarketplaces, home);
+  }
+};
+
+const registerClaudePlugin = (installRoot, marketplacePath, home = claudeHome(), hudAccent = "cyan") => {
+  const registry = readInstalledPlugins(home);
+  const now = new Date().toISOString();
+  const existing = registry.plugins[pluginKey]?.[0] ?? {};
+  registry.plugins[pluginKey] = [
+    {
+      scope: "user",
+      installPath: installRoot,
+      version,
+      installedAt: existing.installedAt ?? now,
+      lastUpdated: now,
+      installedBy: "litclaude-ai",
+      enabled: true,
+    },
+  ];
+  writeInstalledPlugins(registry, home);
+  registerMarketplace(marketplacePath, home);
+  installHudStatusLine(installRoot, home, hudAccent);
+};
+
+const unregisterClaudePlugin = (home = claudeHome()) => {
+  const registryPath = installedPluginsPath(home);
+  if (!existsSync(registryPath)) return;
+  const registry = readInstalledPlugins(home);
+  delete registry.plugins[pluginKey];
+  writeInstalledPlugins(registry, home);
+};
+
+const requireInstalledPluginPath = (home = claudeHome()) => {
+  if (!currentExists(home)) {
+    fail("LitClaude is not installed. Run `litclaude install` first.");
+  }
+  const path = intendedPluginPath(home);
+  if (!existsSync(join(path, ".claude-plugin", "plugin.json"))) {
+    fail("LitClaude install is incomplete. Run `litclaude install` again.");
+  }
+  return path;
+};
+
+const commandExists = (command) => {
+  const result = spawnSync(command, ["--version"], {
+    encoding: "utf8",
+    stdio: "ignore",
+  });
+  return !result.error;
+};
+
+const printLspDiagnostics = (pluginPath, registry) => {
+  const lspPath = join(pluginPath, ".lsp.json");
+  const config = JSON.parse(readFileSync(lspPath, "utf8"));
+  const litClaudeServers = Object.keys(config);
+  process.stdout.write(`LITCLAUDE_LSP_SERVERS: ${litClaudeServers.join(", ") || "none"}\n`);
+
+  for (const server of litClaudeServers) {
+    const command = config[server]?.command?.[0];
+    if (command && !commandExists(command)) {
+      process.stdout.write(`LITCLAUDE_LSP_WARNING: ${server} requires ${command}; install it or remove that server from .lsp.json\n`);
+    }
+  }
+
+  const externalWarnings = [];
+  for (const [key, commands] of Object.entries(knownExternalLspPlugins)) {
+    if (!registry.plugins[key]?.length) continue;
+    if (commands.some(commandExists)) continue;
+    externalWarnings.push({ key, command: commands[0] });
+    process.stdout.write(`EXTERNAL_LSP_WARNING: ${key} requires ${commands[0]}\n`);
+  }
+
+  if (externalWarnings.length > 0) {
+    process.stdout.write("These warnings are not emitted by LitClaude's .lsp.json; they come from other installed Claude Code LSP plugins.\n");
+  }
+};
+
+const resetCurrentPointer = (home, target) => {
+  const current = currentRoot(home);
+  rmSync(current, { recursive: true, force: true });
+  try {
+    symlinkSync(target, current, "dir");
+  } catch {
+    mkdirSync(current, { recursive: true });
+    cpSync(target, current, { recursive: true });
+  }
+};
+
+const install = async ({ dryRun }) => {
+  const home = claudeHome();
+  const litClaudeHome = litHome();
+  const targetPlugin = claudePluginRoot(home);
+  const sourcePlugin = sourcePluginPath();
+  const targetMarketplace = marketplaceRoot(litClaudeHome);
+  const progress = createInstallProgress();
+
+  if (dryRun) {
+    process.stdout.write(`DRY_RUN: install LitClaude ${version}\n`);
+    process.stdout.write(`Would copy: ${sourcePlugin} -> ${targetPlugin}\n`);
+    process.stdout.write(`Would create local marketplace: ${targetMarketplace}\n`);
+    process.stdout.write(`Would register Claude plugin: ${pluginKey}\n`);
+    process.stdout.write(`Would set Claude statusLine HUD: ${hudCommandForPlugin(targetPlugin)}\n`);
+    process.stdout.write("Launch with: claude\n");
+    return;
+  }
+
+  if (!existsSync(sourcePlugin)) {
+    fail(`Packaged LitClaude plugin payload is missing: ${sourcePlugin}`);
+  }
+
+  const hudAccent = await chooseHudAccent();
+  progress.step(`Installing LitClaude ${version}`);
+  progress.step("Plugin payload: copying Claude Code plugin");
+  rmSync(targetPlugin, { recursive: true, force: true });
+  mkdirSync(dirname(targetPlugin), { recursive: true });
+  cpSync(sourcePlugin, targetPlugin, { recursive: true });
+  progress.step("Marketplace: writing local Claude marketplace");
+  const localMarketplace = writeLocalMarketplace(litClaudeHome);
+  progress.step("Claude registry: enabling plugin and HUD");
+  registerClaudePlugin(targetPlugin, localMarketplace, home, hudAccent);
+
+  progress.step("Compatibility cache: refreshing local current pointer");
+  const litRoot = versionRoot(litClaudeHome);
+  rmSync(litRoot, { recursive: true, force: true });
+  mkdirSync(dirname(pluginPathForRoot(litRoot)), { recursive: true });
+  cpSync(sourcePlugin, pluginPathForRoot(litRoot), { recursive: true });
+  resetCurrentPointer(litClaudeHome, litRoot);
+
+  progress.done("LitClaude install complete");
+  process.stdout.write(`INSTALL_PASS: LitClaude ${version} installed\n`);
+  process.stdout.write(`Claude plugin: ${pluginKey}\n`);
+  process.stdout.write(`Marketplace: ${localMarketplace}\n`);
+  process.stdout.write(`Plugin path: ${intendedPluginPath(home)}\n`);
+  process.stdout.write(`HUD: LitClaude statusLine installed (${hudAccent})\n`);
+  process.stdout.write("Launch with: claude\n");
+};
+
+const doctor = ({ dryRun }) => {
+  if (dryRun) {
+    const pluginPath = intendedPluginPath();
+    process.stdout.write("DRY_RUN: doctor LitClaude install\n");
+    process.stdout.write(`Would check plugin files under: ${pluginPath}\n`);
+    process.stdout.write(`Would run: claude plugin validate ${pluginPath}\n`);
+    process.stdout.write(`Would check Claude plugin registry: ${pluginKey}\n`);
+    process.stdout.write(`Would check Claude statusLine HUD: ${hudCommandForPlugin(pluginPath)}\n`);
+    return;
+  }
+
+  const pluginPath = requireInstalledPluginPath();
+  const registry = readInstalledPlugins();
+  const registryEntry = registry.plugins[pluginKey]?.[0];
+  if (!registryEntry) fail(`LitClaude is missing from Claude plugin registry: ${pluginKey}`);
+  const requiredFiles = [
+    ".claude-plugin/plugin.json",
+    ".mcp.json",
+    ".lsp.json",
+    "hooks/hooks.json",
+    "bin/litclaude-hook.js",
+    "bin/litclaude-mcp.js",
+    "skills/lit-loop/SKILL.md",
+    "skills/lit-plan/SKILL.md",
+  ];
+
+  for (const file of requiredFiles) {
+    const path = join(pluginPath, file);
+    if (!existsSync(path)) fail(`LitClaude install is missing ${file}. Run \`litclaude install\` again.`);
+  }
+
+  printLspDiagnostics(pluginPath, registry);
+
+  const claude = spawnSync("claude", ["--version"], { encoding: "utf8" });
+  if (claude.error) {
+    process.stdout.write("CLAUDE_WARNING: claude executable not found in PATH\n");
+  } else {
+    process.stdout.write(`CLAUDE_VERSION: ${(claude.stdout || claude.stderr).trim()}\n`);
+    const validation = spawnSync("claude", ["plugin", "validate", pluginPath], { encoding: "utf8" });
+    if (validation.status !== 0) {
+      if (validation.stdout) process.stderr.write(validation.stdout);
+      if (validation.stderr) process.stderr.write(validation.stderr);
+      fail("Claude plugin validation failed.");
+    }
+    process.stdout.write("CLAUDE_PLUGIN_VALIDATE_PASS\n");
+    const details = spawnSync("claude", ["plugin", "details", pluginKey], { encoding: "utf8" });
+    if (details.status !== 0) {
+      if (details.stdout) process.stderr.write(details.stdout);
+      if (details.stderr) process.stderr.write(details.stderr);
+      fail("Claude plugin details failed.");
+    }
+    process.stdout.write("CLAUDE_PLUGIN_DETAILS_PASS\n");
+  }
+
+  process.stdout.write(`Plugin path: ${pluginPath}\n`);
+  const settings = readClaudeSettings();
+  if (settings.statusLine?.command === hudCommandForPlugin(pluginPath, settings[litClaudeSettingsKey]?.hudAccent)) {
+    process.stdout.write("HUD_STATUSLINE_PASS\n");
+  } else {
+    process.stdout.write("HUD_STATUSLINE_WARNING: LitClaude HUD is not the active Claude statusLine\n");
+  }
+  process.stdout.write("Launch with: claude\n");
+  process.stdout.write("DOCTOR_PASS\n");
+};
+
+const printPath = () => {
+  process.stdout.write(`${requireInstalledPluginPath()}\n`);
+};
+
+const printVersion = () => {
+  process.stdout.write(`${version}\n`);
+};
+
+const runClaude = ({ dryRun, rest }) => {
+  const separatorIndex = rest.indexOf("--");
+  const claudeArgs = separatorIndex === -1 ? rest : rest.slice(separatorIndex + 1);
+  if (!dryRun) requireInstalledPluginPath();
+  const command = ["claude", ...claudeArgs];
+
+  if (dryRun) {
+    process.stdout.write(command.join(" "));
+    process.stdout.write("\n");
+    return;
+  }
+
+  const result = spawnSync(command[0], command.slice(1), { stdio: "inherit" });
+  if (result.error) fail(`failed to start claude: ${result.error.message}`);
+  process.exit(result.status ?? 1);
+};
+
+const uninstall = ({ dryRun }) => {
+  const home = litHome();
+  const pluginCacheRoot = join(claudeHome(), "plugins", "cache", "litclaude-ai");
+  if (dryRun) {
+    process.stdout.write(`DRY_RUN: remove ${join(home, "litclaude-ai")}, ${currentRoot(home)}, ${marketplaceRoot(home)}, ${pluginCacheRoot}, ${pluginKey}, and its marketplace/settings entries\n`);
+    return;
+  }
+  rmSync(currentRoot(home), { recursive: true, force: true });
+  rmSync(join(home, "litclaude-ai"), { recursive: true, force: true });
+  rmSync(marketplaceRoot(home), { recursive: true, force: true });
+  unregisterClaudePlugin();
+  unregisterMarketplace();
+  uninstallHudStatusLine();
+  rmSync(pluginCacheRoot, { recursive: true, force: true });
+  process.stdout.write("UNINSTALL_PASS\n");
+};
+
+const main = async () => {
+  const parsed = parseArgs(process.argv.slice(2));
+  const { command } = parsed;
+
+  if (!command) {
+    printUsage();
+    process.exit(64);
+  }
+
+  switch (command) {
+    case "install":
+    case "update":
+      await install(parsed);
+      break;
+    case "doctor":
+      doctor(parsed);
+      break;
+    case "path":
+      printPath(parsed);
+      break;
+    case "version":
+      printVersion();
+      break;
+    case "run":
+      runClaude(parsed);
+      break;
+    case "litgoal":
+      process.exit(runLitgoalCli(parsed.rest));
+      break;
+    case "workflow-check":
+      process.exit(runWorkflowCheckCli(root, version, parsed.rest));
+      break;
+    case "start-work-next":
+      process.exit(runStartWorkContinuationCli(root, parsed.rest));
+      break;
+    case "uninstall":
+      uninstall(parsed);
+      break;
+    default:
+      printUsage();
+      fail(`Unknown command: ${command}`, 64);
+  }
+};
+
+main().catch((error) => fail(error.message));