@polderlabs/bizar 2.3.0

package/cli/bin.mjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { runInstaller, runPostInstall } from './install.mjs';
+import { runAudit } from './audit.mjs';
+import { runInit } from './init.mjs';
+import { runExport } from './export.mjs';
+import runPlan from './plan.mjs';
+import { runUpdate } from './update.mjs';
+
+const args = process.argv.slice(2);
+
+function showHelp() {
+  console.log(`
+  Bizar — Norse Pantheon Agent System for opencode
+
+  Usage:
+    bizar                       Run interactive installer
+    bizar audit                 Run security audit on agent configuration
+    bizar init                  Initialize .bizar/ in current project
+    bizar export [target]       Export agents/rules to another harness (claude|cursor|opencode)
+    bizar plan <subcommand>     Manage visual plans (new, open, list, delete, export, templates)
+    bizar test-gate             Detect & run the project's test suite
+    bizar update                Update opencode, bizar, and/or bizar-plugin
+    bizar --help                Show this help
+
+  Install:
+    npm install -g @polderlabs/bizar          Install globally, then run 'bizar'
+    npm install -g @polderlabs/bizar-plugin   Install the Bizar opencode plugin
+    npx @polderlabs/bizar                     Run without installing
+  `);
+}
+
+function showAuditHelp() {
+  console.log(`
+  bizar audit — Run security audit on agent configuration
+
+  Usage:
+    bizar audit
+
+  Description:
+    Scans opencode agent definitions for security issues:
+    - Agents with read/edit/bash permission conflicts
+    - Agents lacking mode or model definitions
+    - Suspicious tool access patterns
+  `);
+}
+
+function showInitHelp() {
+  console.log(`
+  bizar init — Initialize .bizar/ in current project
+
+  Usage:
+    bizar init
+
+  Description:
+    Creates a .bizar/ directory in the current project with:
+    - PROJECT.md (living project description)
+    - AGENTS_SELF_IMPROVEMENT.md (lesson log)
+  `);
+}
+
+function showExportHelp() {
+  console.log(`
+  bizar export — Export agents/rules to another harness
+
+  Usage:
+    bizar export --target <harness>
+
+  Targets:
+    claude     Export to Claude Code format
+    cursor     Export to Cursor format
+    opencode   Export to OpenCode format (default)
+
+  Description:
+    Converts Bizar agent definitions and rules
+    to the target harness's native format.
+  `);
+}
+
+function showTestGateHelp() {
+  console.log(`
+  bizar test-gate — Detect & run the project's test suite
+
+  Usage:
+    bizar test-gate
+
+  Description:
+    Auto-detects the project's test framework (npm test, pytest,
+    cargo test, go test) and runs it. Exits with non-zero on failure.
+  `);
+}
+
+function showUpdateHelp() {
+  console.log(`
+  bizar update — Update opencode, bizar, and/or bizar-plugin
+
+  Usage:
+    bizar update                Interactive: ask which components to update
+    bizar update --all          Update everything non-interactively
+    bizar update opencode       Update only opencode
+    bizar update bizar          Update only the bizar CLI package
+    bizar update plugin         Update only the @polderlabs/bizar-plugin package
+
+  Description:
+    By default, prompts for each component (opencode, @polderlabs/bizar,
+    @polderlabs/bizar-plugin) before running its update. With --all, runs
+    every update without prompting. With explicit subcommands, runs only
+    the named update.
+
+    "opencode" here means the underlying opencode CLI on $PATH — the
+    update uses the opencode installer's own update command.
+    "@polderlabs/bizar" and "@polderlabs/bizar-plugin" are updated via
+    'npm install -g <pkg>@latest'.
+  `);
+}
+
+async function runTestGate() {
+  console.log(chalk.bold.hex('#a855f7')('\n  ᚦ TEST GATE ᚦ\n'));
+  const { execSync } = await import('node:child_process');
+
+  const cwd = process.cwd();
+  const possible = [
+    { cmd: 'npm test', check: 'package.json' },
+    { cmd: 'pytest', check: 'pyproject.toml' },
+    { cmd: 'cargo test', check: 'Cargo.toml' },
+    { cmd: 'go test ./...', check: 'go.mod' },
+  ];
+
+  for (const suite of possible) {
+    try {
+      if (existsSync(join(cwd, suite.check))) {
+        console.log(`  Running: ${suite.cmd}`);
+        execSync(suite.cmd, { stdio: 'inherit', timeout: 120000, cwd });
+        console.log('\n  ✓ Test gate passed\n');
+        return true;
+      }
+    } catch {
+      console.log(`\n  ✗ Test gate failed: ${suite.cmd}\n`);
+      process.exit(1);
+    }
+  }
+
+  console.log('  No test suite detected. Install one to use the test gate.\n');
+  return false;
+}
+
+function parseFlag(name) {
+  const idx = args.indexOf(name);
+  if (idx === -1) return null;
+  return args[idx + 1] || null;
+}
+
+if (args.includes('--postinstall')) {
+  await runPostInstall();
+} else if (args[0] === 'audit') {
+  if (args.includes('--help') || args.includes('-h')) showAuditHelp();
+  else await runAudit();
+} else if (args[0] === 'init') {
+  if (args.includes('--help') || args.includes('-h')) showInitHelp();
+  else await runInit(process.cwd());
+} else if (args[0] === 'export') {
+  if (args.includes('--help') || args.includes('-h')) showExportHelp();
+  else {
+    const target = parseFlag('--target');
+    await runExport(target);
+  }
+} else if (args[0] === 'test-gate') {
+  if (args.includes('--help') || args.includes('-h')) showTestGateHelp();
+  else await runTestGate();
+} else if (args[0] === 'update') {
+  if (args.includes('--help') || args.includes('-h')) {
+    showUpdateHelp();
+  } else {
+    await runUpdate(args.slice(1));
+  }
+} else if (args[0] === 'plan') {
+  const planArgs = args.slice(1);
+  await runPlan(planArgs, {});
+} else if (args.includes('--help') || args.includes('-h')) {
+  showHelp();
+} else {
+  await runInstaller();
+}

package/cli/copy.mjs

@@ -0,0 +1,508 @@
+import { mkdir, writeFile, readFile, copyFile, access, constants } from 'node:fs/promises';
+import { join, dirname, basename } from 'node:path';
+import { homedir } from 'node:os';
+import ora from 'ora';
+import chalk from 'chalk';
+import { repoPath, opencodeConfigDir, opencodeAgentsDir, detectRtk, detectSemble, detectUv, detectSkillsCli } from './utils.mjs';
+
+async function fileExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function installAgents(agentFiles, mode) {
+  const spinner = ora({ text: 'Installing agent definitions...', color: 'magenta' }).start();
+  const destDir = opencodeAgentsDir();
+  await mkdir(destDir, { recursive: true });
+
+  let count = 0;
+  for (const file of agentFiles) {
+    const src = repoPath('config', 'agents', file);
+    const dest = join(destDir, file);
+    if (mode === 'merge' && await fileExists(dest)) {
+      spinner.text = `  Skipping ${file} (already exists)`;
+      continue;
+    }
+    await copyFile(src, dest);
+    count++;
+  }
+
+  spinner.succeed(chalk.green(`Installed ${count} agent${count !== 1 ? 's' : ''}`));
+  return count;
+}
+
+export async function installAgentsMd(mode) {
+  const spinner = ora({ text: 'Installing AGENTS.md routing table...', color: 'magenta' }).start();
+  const src = repoPath('config', 'AGENTS.md');
+  const dest = join(opencodeConfigDir(), 'AGENTS.md');
+
+  if (mode === 'merge' && await fileExists(dest)) {
+    spinner.warn(chalk.yellow('AGENTS.md already exists — skipping (use fresh mode to overwrite)'));
+    return false;
+  }
+
+  await mkdir(opencodeConfigDir(), { recursive: true });
+  await copyFile(src, dest);
+  spinner.succeed(chalk.green('AGENTS.md installed'));
+  return true;
+}
+
+export async function installSkill(name) {
+  const spinner = ora({ text: `Installing ${name} skill...`, color: 'cyan' }).start();
+  const srcDir = repoPath('config', 'skills', name);
+
+  try {
+    await access(srcDir, constants.F_OK);
+  } catch {
+    spinner.warn(chalk.yellow(`Skill ${name} not found — skipping`));
+    return false;
+  }
+
+  const skillsDir = join(homedir(), '.opencode', 'skills');
+  const dstDir = join(skillsDir, name);
+  await mkdir(dstDir, { recursive: true });
+
+  const entries = await readdirRecursive(srcDir);
+  for (const entry of entries) {
+    const src = join(srcDir, entry);
+    const dst = join(dstDir, entry);
+    const dstParent = dirname(dst);
+    await mkdir(dstParent, { recursive: true });
+    await copyFile(src, dst);
+  }
+
+  spinner.succeed(chalk.green(`${name} skill installed`));
+  return true;
+}
+
+async function readdirRecursive(dir) {
+  const { readdir, stat } = await import('node:fs/promises');
+  const { join, relative } = await import('node:path');
+  const files = [];
+  async function walk(d) {
+    const entries = await readdir(d, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(d, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else {
+        files.push(relative(dir, full));
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+
+export async function installOpencodeJson(mode) {
+  const spinner = ora({ text: 'Configuring opencode.json...', color: 'yellow' }).start();
+  const template = repoPath('config', 'opencode.json');
+  const dest = join(opencodeConfigDir(), 'opencode.json');
+  await mkdir(opencodeConfigDir(), { recursive: true });
+
+  const templateRaw = await readFile(template, 'utf-8');
+  let templateObj;
+  try { templateObj = JSON.parse(templateRaw); } catch {
+    spinner.fail(chalk.red('Invalid opencode.json template'));
+    return false;
+  }
+
+  if (mode === 'fresh' || !(await fileExists(dest))) {
+    await writeFile(dest, JSON.stringify(templateObj, null, 2));
+    spinner.succeed(chalk.green('opencode.json configured'));
+    return true;
+  }
+
+  // Merge mode: deep merge with existing
+  try {
+    const existingRaw = await readFile(dest, 'utf-8');
+    const existing = JSON.parse(existingRaw);
+    const merged = deepMerge(existing, templateObj);
+    await writeFile(dest, JSON.stringify(merged, null, 2));
+    spinner.succeed(chalk.green('opencode.json merged (existing keys preserved)'));
+    return true;
+  } catch {
+    // If existing is invalid JSON, backup and overwrite
+    const backup = dest + '.bak';
+    await copyFile(dest, backup);
+    await writeFile(dest, JSON.stringify(templateObj, null, 2));
+    spinner.succeed(chalk.green('opencode.json written (backup at opencode.json.bak)'));
+    return true;
+  }
+}
+
+/**
+ * The 7 BizarHarness tool keys that must be enabled in the user's opencode.json.
+ * These are merged idempotently — existing tool keys are never overwritten.
+ */
+const BIZAR_TOOLS = {
+  bizar_plan_action: true,
+  bizar_get_plan_comments: true,
+  bizar_wait_for_feedback: true,
+  bizar_spawn_background: true,
+  bizar_status: true,
+  bizar_collect: true,
+  bizar_kill: true,
+};
+
+/**
+ * Idempotently merge the 7 BizarHarness tool keys into the user's
+ * `~/.config/opencode/opencode.json` (or the platform-equivalent config dir).
+ * Does NOT overwrite any other user config.
+ * Logs a diff of what was added.
+ */
+export async function mergeToolsIntoUserConfig() {
+  const dest = join(opencodeConfigDir(), 'opencode.json');
+
+  // If user has no config yet, nothing to merge into
+  if (!(await fileExists(dest))) {
+    return { merged: false, reason: 'no-existing-config' };
+  }
+
+  try {
+    const existingRaw = await readFile(dest, 'utf-8');
+    const existing = JSON.parse(existingRaw);
+
+    const tools = existing.tools || {};
+    const added = [];
+    for (const [key, value] of Object.entries(BIZAR_TOOLS)) {
+      if (!(key in tools)) {
+        tools[key] = value;
+        added.push(key);
+      }
+    }
+
+    if (added.length === 0) {
+      return { merged: false, reason: 'all-keys-present' };
+    }
+
+    const merged = { ...existing, tools };
+    await writeFile(dest, JSON.stringify(merged, null, 2));
+
+    console.log(chalk.dim(`  [tools] added: ${added.join(', ')}`));
+    return { merged: true, added };
+  } catch (err) {
+    return { merged: false, reason: 'error', error: err.message };
+  }
+}
+
+function deepMerge(target, source) {
+  const out = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      out[key] = deepMerge(out[key] || {}, value);
+    } else if (!(key in out)) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+export async function installBizarFolder() {
+  const spinner = ora({ text: 'Setting up .bizar/ folder...', color: 'cyan' }).start();
+  const srcDir = repoPath('.bizar');
+  try {
+    await access(srcDir, constants.F_OK);
+  } catch {
+    spinner.warn(chalk.yellow('.bizar/ not found in repo — skipping'));
+    return false;
+  }
+
+  const cwd = process.cwd();
+  const destDir = join(cwd, '.bizar');
+  await mkdir(destDir, { recursive: true });
+
+  const files = await readdirRecursive(srcDir);
+  for (const file of files) {
+    const src = join(srcDir, file);
+    const dst = join(destDir, file);
+    await copyFile(src, dst);
+  }
+
+  spinner.succeed(chalk.green('.bizar/ folder created in current directory'));
+  return true;
+}
+
+/**
+ * Install the Bizar plugin into a project's .opencode/ directory.
+ *
+ * Per spec §9.2:
+ *   - Copies plugins/bizar/ → <project>/.opencode/plugins/bizar/
+ *   - Excludes: node_modules/, dist/, *.log, .DS_Store
+ *   - Returns { copied: number, errors: string[] }
+ *
+ * INSTALL PATH CONCLUSION (step 5 of the Heimdall wiring task):
+ * The install target is INSIDE the project at <project>/.opencode/plugins/bizar/,
+ * NOT in the system config dir (~/.config/opencode/plugins/bizar/).
+ * Rationale:
+ *   1. Per-project isolation — each project pins its own plugin version
+ *      (spec §9.1: "Per-project isolation (each project can pin its own
+ *      plugin version)").
+ *   2. Follows opencode's project-local config convention — the config file
+ *      is at <project>/.opencode/opencode.json and the plugin ref is
+ *      `./plugins/bizar/index.ts` relative to that config dir.
+ *   3. Mirrors the .bizar/ folder pattern (project-local, not system-wide).
+ *   4. Not "polluting" — the .opencode/ directory is the standard location
+ *      for project-local opencode config (analogous to .vscode/).
+ *   5. In the Docker sandbox (BizarHarness-dev), the host project is mounted
+ *      at /project, so /project/.opencode/plugins/bizar/ resolves correctly
+ *      relative to /project/.opencode/opencode.json.
+ *
+ * The source (<repo>/plugins/bizar/) is copied FROM the harness repo INTO
+ * the project's .opencode/ directory. After install, the harness repo is no
+ * longer the authoritative source — the project has its own copy.
+ *
+ * See spec §9.1 for the canonical layout diagram.
+ *
+ * @param {string} [projectRoot] - Project root directory (defaults to cwd)
+ * @returns {Promise<{copied: number, errors: string[]}>}
+ */
+export async function installPluginBizar(projectRoot) {
+  if (!projectRoot) projectRoot = process.cwd();
+  const spinner = ora({ text: 'Installing Bizar plugin...', color: 'cyan' }).start();
+  const srcDir = repoPath('plugins', 'bizar');
+
+  try {
+    await access(srcDir, constants.F_OK);
+  } catch {
+    spinner.warn(chalk.yellow('Bizar plugin source not found — skipping'));
+    return { copied: 0, errors: ['Source not found: ' + srcDir] };
+  }
+
+  const destDir = join(projectRoot, '.opencode', 'plugins', 'bizar');
+  await mkdir(destDir, { recursive: true });
+
+  // Exclude patterns per spec §9.2
+  const isExcluded = (entry) => {
+    const parts = entry.split('/');
+    return parts.some(part =>
+      part === 'node_modules' ||
+      part === 'dist' ||
+      part === '.DS_Store' ||
+      part.endsWith('.log')
+    );
+  };
+
+  const files = await readdirRecursive(srcDir);
+  const errors = [];
+  let copied = 0;
+
+  for (const file of files) {
+    if (isExcluded(file)) continue;
+    const src = join(srcDir, file);
+    const dst = join(destDir, file);
+    const dstParent = dirname(dst);
+    try {
+      await mkdir(dstParent, { recursive: true });
+      await copyFile(src, dst);
+      copied++;
+    } catch (err) {
+      errors.push(`Failed to copy ${file}: ${err.message}`);
+    }
+  }
+
+  if (errors.length === 0) {
+    spinner.succeed(chalk.green(`Installed Bizar plugin (${copied} files)`));
+  } else {
+    spinner.warn(chalk.yellow(`Installed Bizar plugin (${copied} files, ${errors.length} errors)`));
+  }
+  return { copied, errors };
+}
+
+export async function installRtk() {
+  const { execSync } = await import('node:child_process');
+
+  const already = await detectRtk();
+  if (already) {
+    const spinner = ora({ text: 'Configuring RTK for opencode...', color: 'magenta' }).start();
+    try {
+      execSync('rtk init -g --opencode', { stdio: 'pipe' });
+      spinner.succeed(chalk.green('RTK configured for opencode'));
+    } catch {
+      spinner.warn(chalk.yellow('Could not auto-configure RTK — run `rtk init -g --opencode` manually'));
+    }
+    return true;
+  }
+
+  const spinner = ora({ text: 'Installing RTK (Rust Token Killer)...', color: 'magenta' }).start();
+
+  if (process.platform === 'win32') {
+    spinner.fail(chalk.red('Automatic RTK install not supported on Windows. Install manually from https://github.com/rtk-ai/rtk'));
+    return false;
+  }
+
+  try {
+    execSync(
+      'curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh',
+      { stdio: 'pipe', timeout: 60000 },
+    );
+    spinner.text = 'Configuring RTK for opencode...';
+    execSync('rtk init -g --opencode', { stdio: 'pipe' });
+    spinner.succeed(chalk.green('RTK installed and configured for opencode'));
+    return true;
+  } catch {
+    spinner.fail(chalk.red('RTK install failed. Install manually from https://github.com/rtk-ai/rtk'));
+    return false;
+  }
+}
+
+export async function installSemble() {
+  const { execSync } = await import('node:child_process');
+
+  const already = await detectSemble();
+  if (already) {
+    const spinner = ora({ text: 'Checking Semble code search...', color: 'cyan' }).start();
+    spinner.succeed(chalk.green('Semble ready'));
+    return true;
+  }
+
+  const spinner = ora({ text: 'Setting up Semble (code search)...', color: 'cyan' }).start();
+
+  const hasUv = await detectUv();
+  if (!hasUv) {
+    spinner.text = 'Installing uv (Python package manager)...';
+    try {
+      if (process.platform === 'win32') {
+        spinner.fail(chalk.red('Automatic uv install not supported on Windows. Install from https://docs.astral.sh/uv'));
+        return false;
+      }
+      execSync(
+        'curl -LsSf https://astral.sh/uv/install.sh | sh',
+        { stdio: 'pipe', timeout: 60000 },
+      );
+      spinner.text = 'Setting up Semble...';
+    } catch {
+      spinner.fail(chalk.red('uv install failed. Install manually from https://docs.astral.sh/uv'));
+      return false;
+    }
+  }
+
+  try {
+    execSync('uv tool install "semble[mcp]"', { stdio: 'pipe', timeout: 60000 });
+    spinner.succeed(chalk.green('Semble installed (code search)'));
+    return true;
+  } catch {
+    spinner.warn(chalk.yellow('Semble install failed. Run `uv tool install "semble[mcp]"` manually'));
+    return false;
+  }
+}
+
+export async function installSkillsCli() {
+  const { execSync } = await import('node:child_process');
+
+  const already = await detectSkillsCli();
+  if (already) {
+    const spinner = ora({ text: 'Checking Skills CLI...', color: 'yellow' }).start();
+    spinner.succeed(chalk.green('Skills CLI ready'));
+    return true;
+  }
+
+  const spinner = ora({ text: 'Installing Skills CLI (skill discovery)...', color: 'yellow' }).start();
+
+  try {
+    execSync('npm install -g skills', { stdio: 'pipe', timeout: 30000 });
+    spinner.succeed(chalk.green('Skills CLI installed'));
+    return true;
+  } catch {
+    spinner.warn(chalk.yellow('Skills CLI install failed. Run `npm install -g skills` manually'));
+    return false;
+  }
+}
+
+export const SKILL_PACKS = {
+  core: {
+    label: 'Core — find-skills, skill-creator, write-a-skill',
+    repos: ['vercel-labs/skills'],
+  },
+  frontend: {
+    label: 'Frontend — React, web-design, composition, a11y, shadcn/ui',
+    repos: ['vercel-labs/agent-skills', 'shadcn/ui'],
+  },
+  backend: {
+    label: 'Backend — Supabase, Postgres, API patterns, auth',
+    repos: ['supabase/agent-skills'],
+  },
+  testing: {
+    label: 'Testing — TDD, E2E, Playwright, test patterns',
+    repos: ['mattpocock/skills', 'microsoft/playwright-cli'],
+  },
+  design: {
+    label: 'Design — frontend-design, UI/UX, taste skills',
+    repos: ['anthropics/skills', 'leonxlnx/taste-skill'],
+  },
+};
+
+export async function installCuratedSkills(packs) {
+  const { execSync } = await import('node:child_process');
+
+  const hasCli = await detectSkillsCli();
+  if (!hasCli) {
+    console.log(chalk.yellow('  ⚠ Skills CLI not available — skipping skill install'));
+    return false;
+  }
+
+  let total = 0;
+  for (const key of packs) {
+    const pack = SKILL_PACKS[key];
+    if (!pack) continue;
+
+    const spinner = ora({ text: `Installing ${key} skills...`, color: 'yellow' }).start();
+    for (const repo of pack.repos) {
+      try {
+        execSync(`skills add ${repo} --all -y`, { stdio: 'pipe', timeout: 60000 });
+        total++;
+      } catch {
+        spinner.warn(chalk.yellow(`  ${repo} — some skills skipped or already installed`));
+      }
+    }
+    spinner.succeed(chalk.green(`${key}: ${pack.label}`));
+  }
+
+  if (total > 0) {
+    console.log(chalk.dim(`  Installed from ${total} skill repositories`));
+  }
+  return true;
+}
+
+export async function installRules() {
+  const src = repoPath('config', 'rules');
+  const dest = join(opencodeConfigDir(), 'rules');
+  const { mkdirSync, readdirSync, copyFileSync } = await import('node:fs');
+  mkdirSync(dest, { recursive: true });
+  let count = 0;
+  for (const file of readdirSync(src).filter(f => f.endsWith('.md'))) {
+    copyFileSync(join(src, file), join(dest, file));
+    count++;
+  }
+  return count;
+}
+
+export async function installHooks() {
+  const src = repoPath('config', 'hooks');
+  const dest = join(opencodeConfigDir(), 'hooks');
+  const { mkdirSync, readdirSync, copyFileSync } = await import('node:fs');
+  mkdirSync(dest, { recursive: true });
+  let count = 0;
+  for (const file of readdirSync(src).filter(f => f.endsWith('.md'))) {
+    copyFileSync(join(src, file), join(dest, file));
+    count++;
+  }
+  return count;
+}
+
+export async function installCommands() {
+  const src = repoPath('config', 'commands');
+  const dest = join(opencodeConfigDir(), 'commands');
+  const { mkdirSync, readdirSync, copyFileSync } = await import('node:fs');
+  mkdirSync(dest, { recursive: true });
+  let count = 0;
+  for (const file of readdirSync(src).filter(f => f.endsWith('.md'))) {
+    copyFileSync(join(src, file), join(dest, file));
+    count++;
+  }
+  return count;
+}