@polderlabs/bizar 2.3.0

package/cli/prompts.mjs

@@ -0,0 +1,163 @@
+import inquirer from 'inquirer';
+
+const AGENTS_LIST = [
+  { name: 'Odin ᛟ  — MiniMax-M3 (Router)', value: 'odin.md', checked: true },
+  { name: 'Frigg ᚠ  — DeepSeek (Codebase Q&A, read-only)', value: 'frigg.md', checked: true },
+  { name: 'Vör ᚡ  — DeepSeek (Clarification)', value: 'vor.md', checked: true },
+  { name: 'Mimir ᛗ — DeepSeek (Research)', value: 'mimir.md', checked: true },
+  { name: 'Heimdall ᚹ — DeepSeek (Simple tasks)', value: 'heimdall.md', checked: true },
+  { name: 'Hermod ᚱ — MiniMax-M2.7 (Git ops)', value: 'hermod.md', checked: true },
+  { name: 'Thor ᚦ  — MiniMax-M2.7 (Mid impl.)', value: 'thor.md', checked: true },
+  { name: 'Baldr ᛒ  — MiniMax-M2.7 (Design)', value: 'baldr.md', checked: true },
+  { name: 'Tyr ᛏ  — MiniMax-M3 (Complex impl.)', value: 'tyr.md', checked: true },
+  { name: 'Vidarr ᛉ — GPT-5.5 (Last resort)', value: 'vidarr.md', checked: false },
+  { name: 'Forseti ᚨ — MiniMax-M3 (Plan audit)', value: 'forseti.md', checked: true },
+];
+
+export async function promptComponents() {
+  const { components } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'components',
+    message: 'What would you like to install?',
+    choices: [
+      { name: 'Agent definitions (all 11 agents)', value: 'agents', checked: true },
+      { name: 'AGENTS.md routing table', value: 'agents-md', checked: true },
+      new inquirer.Separator(),
+      { name: 'BizarHarness skill', value: 'skill-bizar', checked: true },
+      { name: 'Self-improvement skill', value: 'skill-improve', checked: true },
+      { name: 'C++ coding standards skill', value: 'skill-cpp-std', checked: false },
+      { name: 'C++ testing skill', value: 'skill-cpp-test', checked: false },
+      { name: 'Embedded ESP-IDF skill', value: 'skill-esp-idf', checked: true },
+      new inquirer.Separator(),
+      { name: 'Always-on rules (5 rule files)', value: 'rules', checked: true },
+      { name: 'Hook system (behavioral hooks)', value: 'hooks', checked: true },
+      { name: 'Slash commands (/explain, /audit, /learn, /pr-review, /init)', value: 'commands', checked: true },
+      new inquirer.Separator(),
+      { name: 'opencode.json (provider + MCP config)', value: 'opencode-json', checked: true },
+      { name: '.bizar/ folder (self-improvement log)', value: 'bizar', checked: true },
+      new inquirer.Separator(),
+      { name: 'Bizar plugin (loop guard, status, handoff signal)', value: 'plugin-bizar', checked: true },
+    ],
+    pageSize: 18,
+    validate(answer) {
+      if (answer.length === 0) return 'Select at least one component.';
+      return true;
+    },
+  }]);
+  return components;
+}
+
+export async function promptInstallMode() {
+  const { mode } = await inquirer.prompt([{
+    type: 'list',
+    name: 'mode',
+    message: 'Installation mode:',
+    choices: [
+      { name: 'Fresh install  — overwrite existing config files', value: 'fresh' },
+      { name: 'Merge  — keep your existing config, add missing files only', value: 'merge' },
+    ],
+  }]);
+  return mode;
+}
+
+export async function promptAgents() {
+  const { agents } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'agents',
+    message: 'Select agents to install:',
+    choices: AGENTS_LIST,
+    pageSize: 12,
+    validate(answer) {
+      if (answer.length === 0) return 'Select at least one agent.';
+      return true;
+    },
+  }]);
+  return agents;
+}
+
+export async function promptApiKeys() {
+  const { setup } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setup',
+    message: 'Configure API keys now?',
+    default: false,
+  }]);
+  if (!setup) return {};
+
+  const keys = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'opencodeZen',
+      message: 'OpenCode Zen API key (DeepSeek V4 Flash Free):',
+      validate: v => v.length > 0 || 'Required for free-tier agents (Mimir, Heimdall, Vör)',
+    },
+    {
+      type: 'input',
+      name: 'minimax',
+      message: 'MiniMax API key (M2.7 + M3):',
+      validate: v => v.length > 0 || 'Required for Odin, Thor, Hermod, Baldr, Tyr, Forseti',
+    },
+    {
+      type: 'input',
+      name: 'openai',
+      message: 'OpenAI API key (GPT-5.5 — optional for Vidarr):',
+    },
+    {
+      type: 'input',
+      name: 'hindsight',
+      message: 'Hindsight API key (memory persistence):',
+      validate: v => v.length > 0 || 'Required for cross-session memory',
+    },
+    {
+      type: 'input',
+      name: 'semble',
+      message: 'Semble API key (code search — or leave blank for local only):',
+    },
+  ]);
+  return keys;
+}
+
+export async function promptConfirmInstall(summary) {
+  const { ok } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'ok',
+    message: `Install ${summary.components} ${summary.agents} into ${summary.target}?`,
+    default: true,
+  }]);
+  return ok;
+}
+
+export async function promptRestartOpenCode() {
+  const { restart } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'restart',
+    message: 'Restart opencode now to pick up changes?',
+    default: true,
+  }]);
+  return restart;
+}
+
+export async function promptSkillPacks() {
+  const { usePacks } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'usePacks',
+    message: 'Install curated skills from skills.sh ecosystem? (find-skills, React, Supabase, TDD, design, etc.)',
+    default: true,
+  }]);
+  if (!usePacks) return [];
+
+  const { packs } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'packs',
+    message: 'Select skill packs to install:',
+    choices: [
+      { name: 'Core — find-skills, skill-creator, write-a-skill', value: 'core', checked: true },
+      { name: 'Frontend — React, web-design, composition, a11y, shadcn/ui', value: 'frontend', checked: false },
+      { name: 'Backend — Supabase, Postgres, API patterns, auth', value: 'backend', checked: false },
+      { name: 'Testing — TDD, E2E, Playwright, test patterns', value: 'testing', checked: false },
+      { name: 'Design — frontend-design, UI/UX, taste skills', value: 'design', checked: false },
+    ],
+    pageSize: 8,
+  }]);
+  return packs;
+}

package/cli/update.mjs

@@ -0,0 +1,273 @@
+/**
+ * update.mjs — `bizar update` subcommand.
+ *
+ * Updates the opencode CLI, the @polderlabs/bizar package, and/or the
+ * @polderlabs/bizar-plugin package. By default, prompts for each
+ * component individually. With `--all`, updates everything without
+ * prompting. With explicit subcommands (`opencode`, `bizar`, `plugin`),
+ * runs only the named update.
+ *
+ * Each update is a thin wrapper around the underlying installer:
+ *   - opencode:    `opencode upgrade` (or `npm install -g opencode-ai@latest` as a fallback)
+ *   - bizar:       `npm install -g @polderlabs/bizar@latest`
+ *   - plugin:      `npm install -g @polderlabs/bizar-plugin@latest`
+ *
+ * After the package updates, re-runs the install script so the locally
+ * deployed plugin source matches the just-upgraded npm version. Without
+ * this, the plugin in `~/.config/opencode/plugins/bizar/` would be one
+ * version behind the npm registry, and the BUGS.md "version skew"
+ * trap would bite.
+ *
+ * Exit codes:
+ *   0 — all requested updates succeeded (or none were requested)
+ *   1 — at least one update failed
+ */
+
+import chalk from 'chalk';
+import { execSync, spawnSync } from 'node:child_process';
+
+const PKG_MAIN = '@polderlabs/bizar';
+const PKG_PLUGIN = '@polderlabs/bizar-plugin';
+
+// ---------------------------------------------------------------------------
+// Version helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the currently installed version of an npm package.
+ * Returns `null` if not installed globally.
+ */
+function currentVersion(pkg) {
+  try {
+    const out = execSync(`npm ls -g ${pkg} --depth=0 --json`, { stdio: ['ignore', 'pipe', 'ignore'] })
+      .toString();
+    const parsed = JSON.parse(out);
+    const deps = parsed.dependencies ?? {};
+    return deps[pkg]?.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read the latest version of an npm package from the registry.
+ * Returns `null` if the registry is unreachable or the package is not published.
+ */
+function latestVersion(pkg) {
+  try {
+    const out = execSync(`npm view ${pkg} version`, { stdio: ['ignore', 'pipe', 'ignore'] })
+      .toString()
+      .trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Update actions
+// ---------------------------------------------------------------------------
+
+/**
+ * Update opencode. Tries `opencode upgrade` first (the upstream installer's
+ * own command); falls back to `npm install -g opencode-ai@latest`.
+ * Returns `{ ok: boolean, message: string }`.
+ */
+function updateOpencode() {
+  // Try `opencode upgrade` first — that's the canonical updater.
+  const r1 = spawnSync('opencode', ['upgrade'], { stdio: 'inherit' });
+  if (r1.status === 0) {
+    return { ok: true, message: 'opencode updated via `opencode upgrade`' };
+  }
+  // Fall back to npm. `opencode-ai` is the npm package name.
+  console.log(chalk.dim('  opencode upgrade not available; falling back to npm'));
+  const r2 = spawnSync('npm', ['install', '-g', 'opencode-ai@latest'], { stdio: 'inherit' });
+  if (r2.status === 0) {
+    return { ok: true, message: 'opencode updated via npm' };
+  }
+  return { ok: false, message: 'opencode update failed — try `opencode upgrade` manually' };
+}
+
+/**
+ * Update @polderlabs/bizar globally. Returns `{ ok, message }`.
+ */
+function updateBizar() {
+  const r = spawnSync('npm', ['install', '-g', `${PKG_MAIN}@latest`], { stdio: 'inherit' });
+  if (r.status !== 0) {
+    return { ok: false, message: `${PKG_MAIN} update failed` };
+  }
+  return { ok: true, message: `${PKG_MAIN} updated` };
+}
+
+/**
+ * Update @polderlabs/bizar-plugin globally. Returns `{ ok, message }`.
+ */
+function updateBizarPlugin() {
+  const r = spawnSync('npm', ['install', '-g', `${PKG_PLUGIN}@latest`], { stdio: 'inherit' });
+  if (r.status !== 0) {
+    return { ok: false, message: `${PKG_PLUGIN} update failed` };
+  }
+  return { ok: true, message: `${PKG_PLUGIN} updated` };
+}
+
+// ---------------------------------------------------------------------------
+// Re-run the install script so the locally deployed plugin matches npm
+// ---------------------------------------------------------------------------
+
+/**
+ * After updating the npm packages, re-run the install script so the
+ * plugin source on disk matches the just-installed version. This is the
+ * fix for the BUGS.md "version skew" trap.
+ */
+function rerunInstallScript() {
+  // Find the package root via `npm root -g` + package name. This works
+  // whether the user installed via `npm install -g` or `npx`.
+  let globalRoot;
+  try {
+    globalRoot = execSync('npm root -g', { stdio: ['ignore', 'pipe', 'ignore'] })
+      .toString()
+      .trim();
+  } catch {
+    return { ok: false, message: 'could not locate npm global root; skipping install-script rerun' };
+  }
+  const pkgRoot = `${globalRoot}/${PKG_MAIN}`;
+  const installSh = `${pkgRoot}/install.sh`;
+  console.log(chalk.dim(`\n  Re-running install script at ${installSh}...`));
+  const r = spawnSync('bash', [installSh], { stdio: 'inherit' });
+  if (r.status !== 0) {
+    return { ok: false, message: 'install script rerun failed' };
+  }
+  return { ok: true, message: 'install script re-run' };
+}
+
+// ---------------------------------------------------------------------------
+// Prompt helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Interactive prompt for which components to update. Uses inquirer.
+ * Returns a Set of `opencode`, `bizar`, `plugin` strings.
+ */
+async function promptForUpdates(forceAll) {
+  if (forceAll) {
+    return new Set(['opencode', 'bizar', 'plugin']);
+  }
+  // Dynamic import so the rest of the file can be loaded even if
+  // inquirer is unavailable for some reason.
+  const inquirer = await import('inquirer');
+  const { selections } = await inquirer.default.prompt([
+    {
+      type: 'checkbox',
+      name: 'selections',
+      message: 'Which components do you want to update?',
+      choices: [
+        { name: 'opencode (the opencode CLI itself)', value: 'opencode', checked: true },
+        { name: `bizar (${PKG_MAIN})`, value: 'bizar', checked: true },
+        { name: `plugin (${PKG_PLUGIN})`, value: 'plugin', checked: true },
+      ],
+    },
+  ]);
+  return new Set(selections);
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+/**
+ * Run the update subcommand.
+ *
+ * @param {string[]} subargs - arguments after `bizar update`
+ */
+export async function runUpdate(subargs = []) {
+  console.log(chalk.bold.hex('#a855f7')('\n  ᚦ BIZAR UPDATE ᚦ\n'));
+
+  // Show what we know before asking.
+  const cur = {
+    opencode: currentVersion('opencode-ai'),
+    bizar: currentVersion(PKG_MAIN),
+    plugin: currentVersion(PKG_PLUGIN),
+  };
+  const latest = {
+    opencode: latestVersion('opencode-ai'),
+    bizar: latestVersion(PKG_MAIN),
+    plugin: latestVersion(PKG_PLUGIN),
+  };
+
+  console.log('  Installed vs. latest:');
+  for (const k of Object.keys(cur)) {
+    const label = k === 'plugin' ? PKG_PLUGIN : k === 'bizar' ? PKG_MAIN : 'opencode-ai';
+    const c = cur[k] ?? '(not installed)';
+    const l = latest[k] ?? '(unknown)';
+    const same = c === l;
+    console.log(`    ${label.padEnd(28)} ${c.padEnd(15)} → ${l}${same ? '  ✓ up to date' : '  ⤵ update available'}`);
+  }
+  console.log('');
+
+  // Decide what to update.
+  let selected;
+  if (subargs.includes('--all')) {
+    selected = new Set(['opencode', 'bizar', 'plugin']);
+  } else if (subargs.length === 0) {
+    selected = await promptForUpdates(false);
+  } else {
+    // Explicit subcommands.
+    const valid = new Set(['opencode', 'bizar', 'plugin']);
+    selected = new Set(subargs.filter((a) => valid.has(a)));
+    if (selected.size === 0) {
+      console.log(chalk.yellow(`  No valid components selected from: ${subargs.join(' ')}`));
+      console.log(chalk.dim('  Valid components: opencode, bizar, plugin'));
+      console.log(chalk.dim('  Run `bizar update --help` for usage.'));
+      process.exit(1);
+    }
+  }
+
+  if (selected.size === 0) {
+    console.log(chalk.dim('  Nothing to update.'));
+    return;
+  }
+
+  console.log(chalk.cyan(`  Updating: ${[...selected].join(', ')}\n`));
+
+  const results = [];
+  if (selected.has('opencode')) {
+    console.log(chalk.bold('  → opencode'));
+    results.push(['opencode', updateOpencode()]);
+  }
+  if (selected.has('bizar')) {
+    console.log(chalk.bold(`  → ${PKG_MAIN}`));
+    results.push(['bizar', updateBizar()]);
+  }
+  if (selected.has('plugin')) {
+    console.log(chalk.bold(`  → ${PKG_PLUGIN}`));
+    results.push(['plugin', updateBizarPlugin()]);
+  }
+
+  // Re-run the install script if anything was updated, so the deployed
+  // plugin source matches the registry.
+  const anySuccess = results.some(([, r]) => r.ok);
+  if (anySuccess && (selected.has('bizar') || selected.has('plugin'))) {
+    console.log('');
+    const rerun = rerunInstallScript();
+    if (rerun.ok) {
+      console.log(chalk.green(`\n  ✓ ${rerun.message}`));
+    } else {
+      console.log(chalk.yellow(`\n  ⚠ ${rerun.message}`));
+      console.log(chalk.dim('    Run `bash install.sh` from the Bizar repo manually.'));
+    }
+  }
+
+  console.log('');
+  console.log('  Summary:');
+  for (const [name, r] of results) {
+    const marker = r.ok ? chalk.green('✓') : chalk.red('✗');
+    console.log(`    ${marker} ${name.padEnd(10)} ${r.message}`);
+  }
+
+  const anyFail = results.some(([, r]) => !r.ok);
+  if (anyFail) {
+    console.log(chalk.yellow('\n  Some updates failed. See messages above.'));
+    process.exit(1);
+  }
+  console.log(chalk.green('\n  ✓ Update complete\n'));
+}

package/cli/utils.mjs

@@ -0,0 +1,153 @@
+import { access, constants } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const REPO_ROOT = join(__dirname, '..');
+
+const isWin = process.platform === 'win32';
+
+export function repoPath(...parts) {
+  return join(REPO_ROOT, ...parts);
+}
+
+export function opencodeConfigDir() {
+  if (isWin) {
+    return process.env.APPDATA
+      ? join(process.env.APPDATA, 'opencode')
+      : join(homedir(), '.config', 'opencode');
+  }
+  return process.env.XDG_CONFIG_HOME
+    ? join(process.env.XDG_CONFIG_HOME, 'opencode')
+    : join(homedir(), '.config', 'opencode');
+}
+
+export function opencodeAgentsDir() {
+  return join(opencodeConfigDir(), 'agents');
+}
+
+async function tryReadVersion(filePath) {
+  try {
+    const pkg = await import(filePath);
+    return pkg.version || '';
+  } catch {
+    return '';
+  }
+}
+
+export async function detectOpenCode() {
+  const configDir = opencodeConfigDir();
+  const agentsDir = opencodeAgentsDir();
+
+  let exists = false;
+  let version = '';
+
+  try {
+    await access(configDir, constants.F_OK);
+    exists = true;
+
+    if (isWin) {
+      const winPaths = [
+        join(process.env.APPDATA || homedir(), 'npm', 'node_modules', 'opencode', 'package.json'),
+        join(process.env.APPDATA || homedir(), 'npm-global', 'node_modules', 'opencode', 'package.json'),
+        join(homedir(), 'node_modules', 'opencode', 'package.json'),
+      ];
+      for (const p of winPaths) {
+        version = await tryReadVersion(p);
+        if (version) break;
+      }
+    } else {
+      const posixPaths = [
+        join(homedir(), '.local', 'share', 'opencode', 'package.json'),
+        '/usr/local/lib/node_modules/opencode/package.json',
+        '/usr/lib/node_modules/opencode/package.json',
+        join(homedir(), '.npm-global', 'lib', 'node_modules', 'opencode', 'package.json'),
+        join(homedir(), 'node_modules', 'opencode', 'package.json'),
+      ];
+      for (const p of posixPaths) {
+        version = await tryReadVersion(p);
+        if (version) break;
+      }
+    }
+  } catch {
+    exists = false;
+  }
+
+  return { exists, version, configDir, agentsDir };
+}
+
+export async function detectRtk() {
+  const { execSync } = await import('node:child_process');
+  try {
+    execSync('rtk --version', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function detectSemble() {
+  const { execSync } = await import('node:child_process');
+  try {
+    execSync('uvx --from "semble[mcp]" semble --help', { stdio: 'pipe', timeout: 15000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function detectUv() {
+  const { execSync } = await import('node:child_process');
+  try {
+    execSync('uv --version', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function detectSkillsCli() {
+  const { execSync } = await import('node:child_process');
+  try {
+    execSync('npx --yes skills --help', { stdio: 'pipe', timeout: 30000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function detectInstalledAgents() {
+  const agentsDir = opencodeAgentsDir();
+  try {
+    await access(agentsDir, constants.F_OK);
+    return agentsDir;
+  } catch {
+    return null;
+  }
+}
+
+export function buildSummary(components, agents, target, skillPacks = []) {
+  const parts = [];
+  if (components.includes('agents')) parts.push(`${agents.length} agents`);
+  if (components.includes('agents-md')) parts.push('AGENTS.md');
+  if (components.includes('skill-bizar')) parts.push('bizar skill');
+  if (components.includes('skill-improve')) parts.push('self-improvement skill');
+  if (components.includes('opencode-json')) parts.push('opencode.json');
+  if (components.includes('bizar')) parts.push('.bizar/ folder');
+  if (components.includes('plugin-bizar')) parts.push('Bizar plugin');
+  if (components.includes('rules')) parts.push('rules');
+  if (components.includes('hooks')) parts.push('hooks');
+  if (components.includes('commands')) parts.push('commands');
+  parts.push('RTK');
+  parts.push('Semble');
+  parts.push('Skills CLI');
+  if (skillPacks.length > 0) parts.push(`skills: ${skillPacks.join(', ')}`);
+
+  return {
+    components: parts.join(', '),
+    agents: agents.length === 11 ? '(all 11)' : `(${agents.length} selected)`,
+    target,
+    parts,
+  };
+}