@polderlabs/bizar 8.0.0 → 9.0.0

package/.claude/worktrees/kanban-overhaul/cli/utils.mjs

@@ -0,0 +1,221 @@
+import { access, constants, readFile } from 'node:fs/promises';
+import { spawnSync, execFileSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync, readFileSync } from 'node:fs';
+
+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);
+}
+
+/**
+ * Resolve the Claude Code global config directory.
+ *
+ * v6.3.0 — Bizar is Claude Code-native. The legacy `~/.cline/`
+ * path is kept as a back-compat alias via the wrappers below.
+ *
+ *   1. `process.env.CLAUDE_CONFIG_DIR` (explicit override)
+ *   2. `$HOME/.claude` (Claude Code default)
+ */
+export function claudeConfigDir() {
+  if (process.env.CLAUDE_CONFIG_DIR && process.env.CLAUDE_CONFIG_DIR.trim()) {
+    return process.env.CLAUDE_CONFIG_DIR.trim();
+  }
+  if (isWin) {
+    return process.env.APPDATA
+      ? join(process.env.APPDATA, 'claude')
+      : join(homedir(), '.claude');
+  }
+  return join(homedir(), '.claude');
+}
+
+export function claudeAgentsDir() {
+  return join(claudeConfigDir(), 'agents');
+}
+
+export function claudeSkillsDir() {
+  return join(claudeConfigDir(), 'skills');
+}
+
+export function claudeCommandsDir() {
+  return join(claudeConfigDir(), 'commands');
+}
+
+export function claudeHooksDir() {
+  return join(claudeConfigDir(), 'hooks');
+}
+
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `claudeConfigDir()`.
+ * Thin wrapper so older scripts that haven't been migrated keep working.
+ */
+export function clineConfigDir() {
+  return claudeConfigDir();
+}
+
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `claudeAgentsDir()`.
+ * Thin wrapper so older scripts that haven't been migrated keep working.
+ */
+export function clineAgentsDir() {
+  return claudeAgentsDir();
+}
+
+async function tryReadVersion(filePath) {
+  try {
+    const raw = await readFile(filePath, 'utf8');
+    const pkg = JSON.parse(raw);
+    return typeof pkg.version === 'string' ? pkg.version : '';
+  } catch {
+    return '';
+  }
+}
+
+function commandExists(command) {
+  const probe = process.platform === 'win32'
+    ? spawnSync('where', [command], { stdio: 'ignore' })
+    : spawnSync('which', [command], { stdio: 'ignore' });
+  return probe.status === 0;
+}
+
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `detectClaude()`.
+ * Probe for the legacy Cline CLI to power compat reports.
+ */
+export async function detectCline() {
+  const configDir = claudeConfigDir();
+  const agentsDir = claudeAgentsDir();
+  let exists = false;
+  let version = '';
+  try {
+    await access(configDir, constants.F_OK);
+    exists = true;
+  } catch {
+    exists = false;
+  }
+  return { exists, version, configDir, agentsDir };
+}
+
+/**
+ * Probe for the Claude Code CLI on PATH.
+ * Returns `{ exists, version }`. v6.3.0+ replacement for `detectCline()`.
+ */
+export async function detectClaude() {
+  let exists = false;
+  let version = '';
+  try {
+    const probe = spawnSync('claude', ['--version'], { encoding: 'utf8', timeout: 5000 });
+    if (probe.status === 0) {
+      exists = true;
+      version = (probe.stdout || probe.stderr || '').trim().split('\n')[0];
+    }
+  } catch {
+    exists = false;
+  }
+  return { exists, version, configDir: claudeConfigDir(), agentsDir: claudeAgentsDir() };
+}
+
+export async function detectHeadroom() {
+  return commandExists('headroom');
+}
+
+// Alias for backward-compat during migration
+export const detectRtk = detectHeadroom;
+
+export async function detectSemble() {
+  if (commandExists('semble')) {
+    return true;
+  }
+  if (!commandExists('uv')) return false;
+  const probe = spawnSync('uv', ['tool', 'list'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  if (probe.status !== 0) return false;
+  return /(^|\s)semble(\s|@|$)/m.test(probe.stdout || '');
+}
+
+export async function detectUv() {
+  return commandExists('uv');
+}
+
+export async function detectSkillsCli() {
+  return commandExists('skills');
+}
+
+export async function detectInstalledAgents() {
+  const agentsDir = claudeAgentsDir();
+  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('settings-json')) parts.push('settings.json');
+  if (components.includes('bizar')) parts.push('.bizar/ folder');
+  if (components.includes('mcp-bizar')) parts.push('Bizar MCP server');
+  if (components.includes('rules')) parts.push('rules');
+  if (components.includes('hooks')) parts.push('hooks');
+  if (components.includes('commands')) parts.push('commands');
+  parts.push('Headroom');
+  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,
+  };
+}
+
+// Path helpers
+
+/**
+ * Return the platform-specific Bizar config directory.
+ * Windows: %APPDATA%\bizar
+ * Unix: $XDG_CONFIG_HOME/bizar (default: ~/.config/bizar)
+ */
+export function bizarConfigDir() {
+  if (process.platform === 'win32') {
+    return process.env.APPDATA
+      ? join(process.env.APPDATA, 'bizar')
+      : join(homedir(), '.config', 'bizar');
+  }
+  return process.env.XDG_CONFIG_HOME
+    ? join(process.env.XDG_CONFIG_HOME, 'bizar')
+    : join(homedir(), '.config', 'bizar');
+}
+
+/**
+ * Check if a command exists on PATH.
+ * Returns true if found, false otherwise.
+ */
+export function which(cmd) {
+  const probe = spawnSync('which', [cmd], { stdio: 'ignore' });
+  return probe.status === 0;
+}
+
+/**
+ * Check if a command exists on PATH (bg.mjs variant that returns the path or null).
+ */
+export function whichPath(cmd) {
+  try {
+    const out = execFileSync('which', [cmd], { encoding: 'utf8' });
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}

package/.claude/worktrees/kanban-overhaul/cli/worker-dispatcher.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+/**
+ * cli/worker-dispatcher.mjs
+ *
+ * Bizar Background Workers — trigger-pattern dispatcher.
+ *
+ * Reads `config/trigger-patterns.json` (cached for the lifetime of the
+ * process) and matches user prompts against each worker's `regex` array.
+ * Returns up to `opts.maxSuggestions` (default 3) weighted matches, sorted
+ * by weight desc.
+ *
+ * The hook at `.claude/hooks/worker-suggest.mjs` calls `dispatch()` on
+ * every `UserPromptSubmit` event. Pure JS, no external deps; safe to
+ * import from either Node or Bun.
+ *
+ * Public API
+ * ──────────
+ *   dispatch(text, { maxSuggestions }?) -> Array<{
+ *     workerId: string,
+ *     weight: number,
+ *     skill: string | null,
+ *     agent: string | null,
+ *     description: string | undefined,
+ *     matchedPattern: string,        // the literal regex string that hit
+ *     matchedIndex: number           // the prompt char-offset of the match
+ *   }>
+ *
+ *   listWorkers() -> string[]        // all worker ids (even with no regex)
+ *
+ *   resetCache() -> void             // force re-read of the JSON on next dispatch
+ *
+ *   loadPatterns({ configPath? }?) -> object   // explicit loader for tests
+ *
+ * Honesty note: ruflo's equivalent worker bodies are stubs
+ * (`await new Promise(r => setTimeout(r, …))`); this port is just a
+ * dispatcher — actual work happens in Bizar skills/agents invoked
+ * separately by the model.
+ */
+'use strict';
+
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── Config path resolution ──────────────────────────────────────────────────
+
+/**
+ * Locate `config/trigger-patterns.json`. Resolution order:
+ *   1. opts.configPath (explicit, used by tests)
+ *   2. BIZAR_TRIGGER_PATTERNS env var
+ *   3. <projectRoot>/config/trigger-patterns.json   (projectRoot = parent of cli/)
+ */
+export function defaultConfigPath() {
+  if (process.env.BIZAR_TRIGGER_PATTERNS) {
+    return process.env.BIZAR_TRIGGER_PATTERNS;
+  }
+  const projectRoot = resolve(__dirname, '..');
+  return join(projectRoot, 'config', 'trigger-patterns.json');
+}
+
+// ── Cached patterns + pre-compiled regexes ──────────────────────────────────
+
+/** @type {Array<CompiledWorker> | null} */
+let _cache = null;
+/** @type {string | null} */
+let _cachePath = null;
+
+/**
+ * @typedef CompiledWorker
+ * @property {string} id
+ * @property {number} weight
+ * @property {string|null} skill
+ * @property {string|null} agent
+ * @property {string|undefined} description
+ * @property {Array<{ pattern: string, regex: RegExp }>} compiled
+ */
+
+/**
+ * Load + compile the patterns file. Cached on first call.
+ * @param {{ configPath?: string }=} opts
+ * @returns {Array<CompiledWorker>}
+ */
+export function loadPatterns(opts = {}) {
+  const path = opts.configPath || defaultConfigPath();
+  if (_cache && _cachePath === path) return _cache;
+
+  if (!existsSync(path)) {
+    // Empty dispatcher — no patterns means no suggestions, but the API
+    // remains available (so a missing config never throws at the hook).
+    _cache = [];
+    _cachePath = path;
+    return _cache;
+  }
+
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, 'utf8'));
+  } catch (err) {
+    // Invalid JSON is a config bug, not a runtime bug — log + fall back
+    // to an empty dispatcher so the hook still exits 0.
+    process.stderr.write(
+      `[bizar.workers] WARN: failed to parse ${path}: ${
+        err && err.message ? err.message : String(err)
+      }\n`,
+    );
+    _cache = [];
+    _cachePath = path;
+    return _cache;
+  }
+
+  const workers = Array.isArray(raw && raw.workers) ? raw.workers : [];
+
+  /** @type {Array<CompiledWorker>} */
+  const compiled = [];
+  for (const w of workers) {
+    if (!w || typeof w.id !== 'string') continue;
+    const regexSources = Array.isArray(w.regex) ? w.regex : [];
+    /** @type {Array<{ pattern: string, regex: RegExp }>} */
+    const compiled_ = [];
+    for (const src of regexSources) {
+      if (typeof src !== 'string' || src.length === 0) continue;
+      try {
+        compiled_.push({ pattern: src, regex: new RegExp(src, 'i') });
+      } catch {
+        // Skip invalid regex sources; never throw from the hook path.
+      }
+    }
+    compiled.push({
+      id: w.id,
+      weight: typeof w.weight === 'number' ? w.weight : 0.5,
+      skill: typeof w.skill === 'string' ? w.skill : null,
+      agent: typeof w.agent === 'string' ? w.agent : null,
+      description: typeof w.description === 'string' ? w.description : undefined,
+      compiled: compiled_,
+    });
+  }
+
+  _cache = compiled;
+  _cachePath = path;
+  return _cache;
+}
+
+/** Force re-read of the patterns JSON on the next `dispatch()` call. */
+export function resetCache() {
+  _cache = null;
+  _cachePath = null;
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+const DEFAULT_MAX_SUGGESTIONS = 3;
+
+/**
+ * Match a prompt against all worker patterns and return ranked suggestions.
+ *
+ * @param {string} text
+ * @param {{ maxSuggestions?: number, configPath?: string }=} opts
+ * @returns {Array<{
+ *   workerId: string,
+ *   weight: number,
+ *   skill: string|null,
+ *   agent: string|null,
+ *   description: string|undefined,
+ *   matchedPattern: string,
+ *   matchedIndex: number
+ * }>}
+ */
+export function dispatch(text, opts = {}) {
+  const out = [];
+  const source = typeof text === 'string' ? text : '';
+  if (source.length === 0) return out;
+
+  const workers = loadPatterns(
+    opts.configPath ? { configPath: opts.configPath } : {},
+  );
+  if (workers.length === 0) return out;
+
+  const max = Number.isInteger(opts.maxSuggestions)
+    ? Math.max(0, opts.maxSuggestions)
+    : DEFAULT_MAX_SUGGESTIONS;
+
+  for (const w of workers) {
+    let bestIndex = -1;
+    let bestPattern = null;
+    for (const c of w.compiled) {
+      const m = c.regex.exec(source);
+      if (m && m.index >= 0) {
+        if (bestIndex === -1 || m.index < bestIndex) {
+          bestIndex = m.index;
+          bestPattern = c.pattern;
+        }
+      }
+    }
+    if (bestPattern !== null) {
+      out.push({
+        workerId: w.id,
+        weight: w.weight,
+        skill: w.skill,
+        agent: w.agent,
+        description: w.description,
+        matchedPattern: bestPattern,
+        matchedIndex: bestIndex,
+      });
+    }
+  }
+
+  out.sort((a, b) => {
+    if (b.weight !== a.weight) return b.weight - a.weight;
+    // Tie-break deterministically by workerId so the output is stable
+    // across runs (useful for tests + logs).
+    return a.workerId.localeCompare(b.workerId);
+  });
+
+  return max === 0 ? [] : out.slice(0, max);
+}
+
+/**
+ * Return all worker ids declared in the patterns file. Workers with no
+ * regex are returned too — they simply never surface as suggestions.
+ *
+ * @param {{ configPath?: string }=} opts
+ * @returns {string[]}
+ */
+export function listWorkers(opts = {}) {
+  const workers = loadPatterns(
+    opts.configPath ? { configPath: opts.configPath } : {},
+  );
+  return workers.map((w) => w.id);
+}
+
+// Direct CLI entrypoint for dry-runs / debugging.
+//   node cli/worker-dispatcher.mjs "your prompt here" [--max N] [--list]
+if (
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === process.argv[1]
+) {
+  const argv = process.argv.slice(2);
+  const wantList = argv.includes('--list');
+  const maxIdx = argv.indexOf('--max');
+  const maxVal =
+    maxIdx >= 0 && argv[maxIdx + 1] ? Number.parseInt(argv[maxIdx + 1], 10) : undefined;
+
+  if (wantList) {
+    const ids = listWorkers();
+    process.stdout.write(JSON.stringify(ids, null, 2) + '\n');
+    process.exit(0);
+  }
+
+  // Build the prompt by dropping only `--max` and the value that follows it
+  // (and only when `--max` was actually present).
+  const prompt = argv
+    .filter((a, i) => !(maxIdx >= 0 && (i === maxIdx || i === maxIdx + 1)))
+    .join(' ');
+  const result = dispatch(prompt, { maxSuggestions: maxVal });
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  process.exit(0);
+}