@polderlabs/bizar 8.0.0 → 9.0.0

package/.claude/worktrees/kanban-overhaul/cli/commands/install.mjs

@@ -0,0 +1,170 @@
+/**
+ * cli/commands/install.mjs
+ *
+ * install + update command families.
+ * v4.4.11+ — 'bizar install' and 'bizar update' share the same code path.
+ */
+import chalk from 'chalk';
+import { runInstaller } from '../install.mjs';
+import { runUpdate } from '../update.mjs';
+import { runRepair } from '../repair.mjs';
+
+// ── Help texts ──────────────────────────────────────────────────────────────────
+
+export function showInstallHelp() {
+  console.log(`
+  bizar install — Run the unified BizarHarness installer
+
+  Usage:
+    bizar install                       Install (or refresh) every component
+    bizar install --dry-run             Print what would happen, change nothing
+    bizar install --force               Overwrite existing files
+    bizar install --with-mods a,b,c     Opt-in: install specific mods as part of the run
+    bizar install --help                Show this help
+
+  Description:
+    v4.4.7+ — unified installer. Same code path as 'bizar update'; the
+    difference is just mode=install vs mode=update. Every step is
+    idempotent — running this twice is safe.
+
+    1. Installs @polderlabs/bizar via npm (skipped if already current).
+    2. Shells to ./install.sh for platform-specific system deps (uv,
+       python3.12, jq, gh on Linux; brew on macOS) + service registration
+       (systemd / launchd / Task Scheduler).
+    3. Syncs agent files, slash commands, and bundled skills into
+       ~/.claude/ (or $CLAUDE_CONFIG_DIR).
+    4. Registers the Bizar MCP server in ~/.claude/settings.json
+       (skipped if already present; the plugin shim is now an MCP
+       transport, not a Cline plugin).
+    5. Wires Claude Code lifecycle hooks (SessionStart / PreToolUse /
+       PostToolUse / UserPromptSubmit) under ~/.claude/hooks/.
+    6. Runs 'bizar doctor' as a post-install health check.
+
+    No API key collection, no interactive prompts.
+  `);
+}
+
+export function showUpdateHelp() {
+  console.log(`
+  bizar update — Update @anthropic-ai/claude-code + @polderlabs/bizar
+  (which bundles the SDK, dashboard, and plugin shim). Detects what's
+  installed and only touches what's missing or out of date.
+
+  Usage:
+    bizar update                       Update EVERYTHING (default; auto-kills + restarts)
+    bizar update --check               Only print current vs. latest; do not update
+    bizar update --channel=stable|beta Pick the npm dist-tag (default: stable)
+    bizar update --no-restart          Don't auto-restart the dashboard after update
+    bizar update --dry-run             Print what would happen, change nothing
+    bizar update --force               Override .bizar/PRE_PUSH_NOTES.md blockers
+    bizar update --yes                 Same as --force, but named for one-line scripts
+    bizar update --with-mods a,b,c     Opt-in: install specific mods as part of the run
+    bizar update --help                Show this help
+
+  Components updated:
+    @anthropic-ai/claude-code   the Claude Code CLI itself
+    @polderlabs/bizar    this CLI + dashboard + SDK (one package)
+
+  Behavior (v4.4.7+):
+    • Single unified provisioner. 'bizar install' and 'bizar update' are
+      the same code path with different mode flags. Every step is
+      idempotent — re-running is safe.
+    • Detects running Bizar instances (background service daemon, web
+      dashboard) by reading ~/.config/bizar/{service,dashboard}.pid and
+      cleans up any stale or empty PID files.
+    • Auto-kills running instances with a brief notice.
+    • Sends SIGTERM, waits up to 5s, escalates to SIGKILL if needed.
+    • Re-runs the install script so the deployed plugin source matches
+      the just-upgraded npm version (avoids the version-skew trap).
+    • If the dashboard was running and bizar was updated, spawns a
+      fresh detached dashboard process with the new code (skipped with
+      --no-restart).
+    • Runs 'bizar doctor' after a successful update to catch config
+      regressions before claude tries to start.
+    • With --check: prints the version matrix and release-notes excerpt
+      between current and latest, exits non-zero if an update is available.
+
+  Examples:
+    bizar update                       Full auto-update (recommended)
+    bizar update --check               Show version matrix + notes, do nothing
+    bizar update --channel=beta        Upgrade to latest beta build
+    bizar update --dry-run             Preview what would change
+    bizar update plugin --no-restart   Plugin-only, leave dashboard alone
+
+  Errors:
+    Network failures (registry offline / DNS) and npm permission issues
+    are surfaced with the raw npm output. The provisioner never silently
+    swallows them — look for the ✗ marker in the step output.
+  `);
+}
+
+// ── parseWithMods flag ─────────────────────────────────────────────────────────
+
+/**
+ * v4.4.11 — Parse `--with-mods <csv>` from the given subargs slice.
+ * Returns `null` if the flag isn't present (the provisioner's
+ * "don't touch mods" default), or a string[] of mod ids if it is.
+ */
+export function parseWithModsFlag(subargs) {
+  const idx = subargs.indexOf('--with-mods');
+  if (idx === -1) return null;
+  const raw = subargs[idx + 1];
+  if (!raw || raw.startsWith('--')) {
+    console.error('bizar: --with-mods requires a value (e.g. --with-mods a,b,c)');
+    console.error('Usage: bizar install --with-mods <mod-id,mod-id>');
+    process.exit(2);
+  }
+  return raw
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+// ── Command runners ────────────────────────────────────────────────────────────
+
+export async function install(args, isHelpRequest) {
+  if (isHelpRequest) {
+    showInstallHelp();
+    return;
+  }
+  // v4.4.11 — Parse --with-mods <csv> to opt into mod installs during the run.
+  const withMods = parseWithModsFlag(args);
+  await runInstaller({ withMods });
+  // v4.4.3 — After install, repair any stale bin symlinks so the
+  // user picks up the new code.
+  try {
+    const r = await runRepair({});
+    if (r.fixed.length > 0) {
+      console.log(chalk.cyan('\n  Repair: repointed stale bin symlinks:'));
+      for (const f of r.fixed) console.log(`    ${f}`);
+      console.log(chalk.dim('    Re-run your shell or `hash -r` to pick up the new path.'));
+    }
+  } catch (err) {
+    console.log(chalk.dim(`  Repair skipped: ${err.message}`));
+  }
+}
+
+export async function update(args, isHelpRequest) {
+  if (isHelpRequest) {
+    showUpdateHelp();
+    return;
+  }
+  const withMods = parseWithModsFlag(args);
+  // Filter --with-mods <csv> out of subargs since the provisioner takes it via opts.
+  const subargs = args.filter((a, i, arr) => {
+    if (a === '--with-mods') return false;
+    if (arr[i - 1] === '--with-mods') return false;
+    return true;
+  });
+  await runUpdate(subargs, { withMods });
+}
+
+// ── run() entry point (used by bin.mjs dispatcher) ──────────────────────────────
+
+export async function run(name, args, isHelpRequest) {
+  if (name === 'install') {
+    await install(args, isHelpRequest);
+  } else if (name === 'update') {
+    await update(args, isHelpRequest);
+  }
+}

package/.claude/worktrees/kanban-overhaul/cli/commands/lightrag.mjs

@@ -0,0 +1,170 @@
+/**
+ * cli/commands/lightrag.mjs
+ *
+ * v5.x — LightRAG management CLI (issue #6).
+ *
+ * Subcommands:
+ *   autostart          Trigger the dashboard's lightragStartupHook() against
+ *                      the current working directory's project. Used by
+ *                      `install.sh` and by operators who want to manually
+ *                      start LightRAG without opening the dashboard.
+ *   start              Alias for `autostart` (matches `headroom start`).
+ *   status             Print whether the LightRAG server is running.
+ *
+ * The dashboard server already auto-invokes `lightragStartupHook()` on
+ * boot, so this CLI is mostly for ops/debugging. The `autostart` form is
+ * the one called by `install.sh` and `bizar update` flows.
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function showLightragHelp() {
+  console.log(`
+  bizar lightrag — Manage the LightRAG knowledge graph server
+
+  Usage:
+    bizar lightrag status              Show whether LightRAG is running
+    bizar lightrag start               Start LightRAG for the current project
+    bizar lightrag autostart           Same as \`start\` — runs the startup hook
+    bizar lightrag autostart --no-dashboard  Run hook without touching the
+                                            running dashboard (skips status check)
+
+  Description:
+    LightRAG is the knowledge-graph indexer for the project's memory vault.
+    The dashboard server auto-starts LightRAG on boot (when
+    .bizar/memory.json#lightrag.enabled is true). Use this command to:
+      - manually trigger the startup hook against the current project
+      - check whether the LightRAG server is up
+
+  Environment:
+    BIZAR_LIGHTRAG_AUTOSTART=0|false|no   Disable auto-start (default: enabled)
+    BIZAR_MEMORY_VAULT=/path/to/vault     Override the memory vault location
+  `);
+}
+
+/**
+ * Resolve the project root for the lightrag command. We use `process.cwd()`
+ * — the user is expected to run this from inside a Bizar project. If
+ * `.bizar/memory.json` is missing, we still pass the cwd through and let
+ * the hook's `resolveLightRAGConfig` fall back to defaults.
+ */
+function resolveProjectRoot() {
+  return process.cwd();
+}
+
+async function runLightragCommand(lightragArgs) {
+  const sub = lightragArgs[0];
+  const flags = new Set(lightragArgs.slice(1).filter((a) => a.startsWith('-')));
+
+  if (!sub || sub === '--help' || sub === '-h' || flags.has('--help') || flags.has('-h')) {
+    showLightragHelp();
+    return;
+  }
+
+  if (sub === 'autostart' || sub === 'start') {
+    // Lazy import so the help text doesn't pay the cost of pulling in
+    // memory-lightrag (and its transitive deps) on every command.
+    const { lightragStartupHook, isRunning, resolveLightRAGConfig } = await import('../../bizar-dash/src/server/memory-lightrag.mjs');
+    const projectRoot = resolveProjectRoot();
+    console.log(chalk.dim(`  lightrag autostart: project=${projectRoot}`));
+
+    // If the dashboard is running, prefer its endpoint (it owns the
+    // server's lifecycle). Fall back to a direct hook call otherwise.
+    if (!flags.has('--no-dashboard')) {
+      try {
+        const dashboardResult = await callDashboardAutostart();
+        if (dashboardResult && dashboardResult.started) {
+          console.log(chalk.green(`  ✓ lightrag auto-started via dashboard (pid=${dashboardResult.pid || '?'})`));
+          return;
+        }
+        if (dashboardResult && dashboardResult.ok && !dashboardResult.started) {
+          console.log(chalk.dim(`  · lightrag: ${dashboardResult.reason || 'already running'}`));
+          return;
+        }
+      } catch (err) {
+        // Dashboard unreachable — fall through to direct call. Common
+        // case: user ran `bizar lightrag autostart` from a fresh shell
+        // without the dashboard running.
+        console.log(chalk.dim(`  · dashboard not reachable, running hook locally: ${err?.message || err}`));
+      }
+    }
+
+    const r = await lightragStartupHook(projectRoot);
+    if (r.ok && r.started) {
+      console.log(chalk.green(`  ✓ lightrag started (pid=${r.pid || '?'})`));
+    } else if (r.ok) {
+      console.log(chalk.dim(`  · lightrag: ${r.reason || 'not started'}`));
+    } else {
+      console.log(chalk.yellow(`  ! lightrag autostart: ${r.error || r.reason || 'failed'}`));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (sub === 'status') {
+    const { isRunning, resolveLightRAGConfig } = await import('../../bizar-dash/src/server/memory-lightrag.mjs');
+    const projectRoot = resolveProjectRoot();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const running = await isRunning(cfg);
+    console.log('');
+    console.log(chalk.bold('  LightRAG status'));
+    console.log('');
+    console.log(`    ${chalk.dim('running:')}     ${running ? chalk.green('yes') : chalk.yellow('no')}`);
+    console.log(`    ${chalk.dim('host:')}        ${cfg.host}:${cfg.port}`);
+    console.log(`    ${chalk.dim('enabled:')}     ${cfg.enabled ? chalk.green('yes') : chalk.yellow('no')}`);
+    console.log(`    ${chalk.dim('workingDir:')}  ${cfg.workingDir}`);
+    console.log(`    ${chalk.dim('llmBinding:')}  ${cfg.llmBinding} (${cfg.llmModel})`);
+    console.log(`    ${chalk.dim('embedding:')}   ${cfg.embeddingBinding} (${cfg.embeddingModel})`);
+    console.log('');
+    return;
+  }
+
+  console.error(chalk.red(`  ✗ Unknown lightrag subcommand: ${sub}`));
+  showLightragHelp();
+  process.exit(1);
+}
+
+/**
+ * Call the dashboard's startup-hook endpoint if the dashboard is up.
+ * Returns the JSON body on success, null if the dashboard is unreachable
+ * (so the caller can fall back to a direct hook call).
+ */
+async function callDashboardAutostart() {
+  // Read dashboard connection from the same files the other CLI commands use.
+  const HOME = process.env.HOME || '/';
+  const portFile = join(HOME, '.config', 'bizar', 'dashboard.port');
+  const authFile = join(HOME, '.config', 'bizar', 'dash-auth.json');
+  let port = 4321;
+  let secret = '';
+  try {
+    if (existsSync(portFile)) {
+      const parsed = parseInt(readFileSync(portFile, 'utf8').trim(), 10);
+      if (Number.isFinite(parsed) && parsed > 0) port = parsed;
+    }
+  } catch { /* ignore */ }
+  try {
+    if (existsSync(authFile)) {
+      const raw = JSON.parse(readFileSync(authFile, 'utf8'));
+      secret = raw?.password || '';
+    }
+  } catch { /* ignore */ }
+  const url = `http://127.0.0.1:${port}/api/lightrag/autostart`;
+  const headers = { 'content-type': 'application/json', accept: 'application/json' };
+  if (secret) headers.authorization = `Basic ${Buffer.from(`cline:${secret}`).toString('base64')}`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({}),
+    signal: AbortSignal.timeout(2000),
+  });
+  if (!res.ok) {
+    return null;
+  }
+  const text = await res.text();
+  try { return text ? JSON.parse(text) : null; } catch { return null; }
+}
+
+export async function run(name, args, isHelpRequest) {
+  await runLightragCommand(args);
+}

package/.claude/worktrees/kanban-overhaul/cli/commands/marketplace.mjs

@@ -0,0 +1,64 @@
+/**
+ * cli/commands/marketplace.mjs
+ *
+ * v5.0.0 — Thin alias for `bizar marketplace <subcommand>` that
+ * forwards to the plugin command. Keeps the historical marketplace
+ * name alive for users who learned it first.
+ *
+ *   bizar marketplace search <query>   → bizar plugin search <query>
+ *   bizar marketplace install <id>     → bizar plugin install <id>
+ *   bizar marketplace list             → bizar plugin list
+ *   bizar marketplace                  → bizar plugin list
+ *
+ * Anything else falls through to `plugin help` so the user gets the
+ * full subcommand reference.
+ */
+import chalk from 'chalk';
+import { runPluginCommand, showPluginHelp } from './plugin.mjs';
+
+export function showMarketplaceHelp() {
+  console.log(`
+  bizar marketplace — Browse and install plugins from the public marketplace
+
+  Usage:
+    bizar marketplace                    List installed plugins
+    bizar marketplace list               Same as \`bizar plugin list\`
+    bizar marketplace search <query>     Same as \`bizar plugin search <query>\`
+    bizar marketplace install <id>       Same as \`bizar plugin install <id>\`
+
+  Description:
+    The marketplace is the public registry of plugins hosted at
+    ${process.env.BIZAR_REGISTRY_URL ||
+      'https://raw.githubusercontent.com/DrB0rk/bizar-mods/main/registry.json'}.
+
+    This command is a thin alias for the \`plugin\` command — run
+    \`bizar plugin --help\` for the full surface (config, update, invoke, ...).
+  `);
+}
+
+export async function runMarketplaceCommand(marketplaceArgs) {
+  const sub = marketplaceArgs[0];
+  if (!sub || sub === '--help' || sub === '-h') {
+    showMarketplaceHelp();
+    return;
+  }
+  // Only a handful of subcommands are aliased — everything else falls
+  // through to the plugin command's help so the user isn't confused
+  // by a half-implemented alias.
+  const aliased = new Set(['search', 'install', 'list']);
+  if (!aliased.has(sub)) {
+    console.error(chalk.red(`  ✗ Unknown marketplace subcommand: ${sub}`));
+    console.error(chalk.dim('  marketplace is an alias for `plugin`; try one of:'));
+    console.error(chalk.dim('    marketplace search <query>'));
+    console.error(chalk.dim('    marketplace install <id>'));
+    console.error(chalk.dim('    marketplace list'));
+    console.error(chalk.dim('  or run `bizar plugin --help` for the full surface'));
+    showPluginHelp();
+    process.exit(1);
+  }
+  await runPluginCommand(marketplaceArgs);
+}
+
+export async function run(name, args, isHelpRequest) {
+  await runMarketplaceCommand(args);
+}

package/.claude/worktrees/kanban-overhaul/cli/commands/memory.mjs

@@ -0,0 +1,25 @@
+/**
+ * cli/commands/memory.mjs
+ *
+ * Memory subcommand dispatcher — delegates to ../memory.mjs.
+ */
+import { runMemory } from '../memory.mjs';
+
+export function showMemoryHelp() {
+  console.log(`
+  memory <subcommand>   Manage project memory (local-only or Git-shared Obsidian vault)
+                        Subcommands: init, setup, status, link, unlink, write, pull, commit,
+                        push, sync, reindex, conflicts, doctor
+  `);
+}
+
+export async function run(name, args, isHelpRequest) {
+  // Only show parent help if no subcommand given. If --help is for a
+  // specific subcommand, pass it through so runMemory can show the
+  // subcommand's own help (which includes "Usage:").
+  if (!args[0]) {
+    showMemoryHelp();
+    return;
+  }
+  await runMemory(args[0], args.slice(1), { wantJson: false });
+}