@polderlabs/bizar 8.0.0 → 9.0.0

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/yaml.mjs

@@ -0,0 +1,238 @@
+/**
+ * src/server/yaml.mjs
+ *
+ * Hand-rolled line-oriented YAML parser for Markdown frontmatter.
+ * Supports a safe subset of YAML: scalars (strings, integers, floats,
+ * booleans, dates), inline lists, block lists, comments, and multi-line
+ * literal blocks. No external dependencies.
+ */
+
+/**
+ * Parse a frontmatter block (the text between the opening `---` and
+ * closing `---`). Returns { frontmatter: object, body: string }.
+ *
+ * @param {string} raw — raw file contents
+ * @returns {{ frontmatter: Record<string, unknown>, body: string }}
+ */
+export function parseFrontmatter(raw) {
+  if (!raw.startsWith('---')) return { frontmatter: {}, body: raw };
+  const end = raw.indexOf('\n---', 3);
+  if (end === -1) return { frontmatter: {}, body: raw };
+  const fmBlock = raw.slice(3, end).trim();
+  const body = raw.slice(end + 4).replace(/^\n+/, '');
+  const frontmatter = parseBlock(fmBlock);
+  return { frontmatter, body };
+}
+
+/**
+ * Serialize a frontmatter object to a YAML string (without the surrounding
+ * `---` fences). Used to build the frontmatter portion of a markdown file.
+ *
+ * @param {Record<string, unknown>} fm
+ * @returns {string}
+ */
+export function serializeFrontmatter(fm) {
+  return serializeBlock(fm);
+}
+
+/**
+ * Parse a single YAML block string (no document markers). Returns a plain
+ * object of parsed key-value pairs.
+ *
+ * @param {string} text — raw YAML block (no --- delimiters)
+ * @returns {Record<string, unknown>}
+ */
+export function parseBlock(text) {
+  const result = {};
+  if (!text) return result;
+
+  // Strip comments (lines that are ONLY a comment)
+  const lines = text.split('\n').filter((l) => !/^\s*#/.test(l));
+
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // Blank / empty line
+    if (/^\s*$/.test(line)) { i++; continue; }
+
+    // Inline list: `key: [a, b, c]`
+    const inlineListMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*\[(.*?)\]\s*$/);
+    if (inlineListMatch) {
+      result[inlineListMatch[1]] = inlineListMatch[2]
+        .split(',')
+        .map((v) => v.trim())
+        .filter((v) => v.length > 0);
+      i++;
+      continue;
+    }
+
+    // Block list key start: `key:`
+    const blockListKeyMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*$/);
+    if (blockListKeyMatch) {
+      const key = blockListKeyMatch[1];
+      const items = [];
+      i++;
+      while (i < lines.length && /^\s+-\s*/.test(lines[i])) {
+        const item = lines[i].replace(/^\s+-\s*/, '').trim();
+        items.push(item);
+        i++;
+      }
+      result[key] = items;
+      continue;
+    }
+
+    // Multi-line literal block scalar: `body: |` or `body: |+` or `body: |-`
+    const literalMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*\|[+-]?\s*$/);
+    if (literalMatch) {
+      const key = literalMatch[1];
+      const lines2 = [];
+      i++;
+      // First content line determines the common indent to strip
+      let firstContentIdx = i;
+      let baseIndent = null;
+      while (i < lines.length) {
+        const l = lines[i];
+        if (l === undefined) break;
+        // Stop at the next top-level key (no indent)
+        if (/^[A-Za-z0-9_-]+\s*:/.test(l) && !l.startsWith(' ')) break;
+        if (l.trim() === '') { lines2.push(''); i++; continue; }
+        if (baseIndent === null && l.trim() !== '') {
+          baseIndent = l.match(/^(\s*)/)[1].length;
+        }
+        if (baseIndent !== null) {
+          const stripped = l.length > baseIndent ? l.slice(baseIndent) : l;
+          lines2.push(stripped);
+        } else {
+          lines2.push(l);
+        }
+        i++;
+      }
+      result[key] = lines2.join('\n');
+      continue;
+    }
+
+    // Regular key-value: `key: value`
+    const kvMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+    if (kvMatch) {
+      const key = kvMatch[1];
+      const rawVal = kvMatch[2].trim();
+      result[key] = parseScalar(rawVal);
+      i++;
+      continue;
+    }
+
+    // Continuation of a multi-line value (indented, no key)
+    // Only handle bare continuation lines (simple unquoted strings)
+    if (/^\s+\S/.test(line) && !/^\s+-\s*/.test(line)) {
+      // Fold continuation as part of last array item or string
+      const lastKey = Object.keys(result).at(-1);
+      if (lastKey !== undefined) {
+        const lastVal = result[lastKey];
+        if (typeof lastVal === 'string') {
+          result[lastKey] = lastVal + '\n' + line.trim();
+        }
+      }
+      i++;
+      continue;
+    }
+
+    // Unknown line — skip
+    i++;
+  }
+
+  return result;
+}
+
+/**
+ * Serialize a plain object to a YAML block string (no --- markers).
+ *
+ * @param {Record<string, unknown>} obj
+ * @returns {string}
+ */
+export function serializeBlock(obj) {
+  const lines = [];
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === undefined || v === null) continue;
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        lines.push(`${k}: []`);
+      } else if (v.every((item) => typeof item === 'string' && !item.includes('\n') && !item.includes(',') && !item.includes('[') && !item.includes(']'))) {
+        // Inline list
+        lines.push(`${k}: [${v.map((item) => scalarToString(item)).join(', ')}]`);
+      } else {
+        // Block list
+        lines.push(`${k}:`);
+        for (const item of v) {
+          lines.push(`  - ${item}`);
+        }
+      }
+    } else if (typeof v === 'object') {
+      // Nested object — skip (not supported in frontmatter)
+      continue;
+    } else if (typeof v === 'string' && (v.includes('\n') || v.length > 80)) {
+      // Multi-line literal block
+      const escaped = v.replace(/\n$/, '') + '\n';
+      lines.push(`${k}: |`);
+      for (const ln of escaped.split('\n')) {
+        lines.push(`  ${ln}`);
+      }
+    } else {
+      lines.push(`${k}: ${scalarToString(v)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Parse a scalar value string into a native JS value.
+ *
+ * @param {string} s
+ * @returns {unknown}
+ */
+function parseScalar(s) {
+  // Quoted strings
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+
+  // Boolean
+  if (s === 'true' || s === 'yes') return true;
+  if (s === 'false' || s === 'no') return false;
+
+  // Null
+  if (s === 'null' || s === '~') return null;
+
+  // Integer
+  if (/^-?[0-9]+$/.test(s)) return parseInt(s, 10);
+
+  // Float
+  if (/^-?[0-9]+\.[0-9]+$/.test(s)) return parseFloat(s);
+
+  // ISO-8601 date — keep as string
+  if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/.test(s)) {
+    return s;
+  }
+
+  return s;
+}
+
+/**
+ * Convert a JS value to a YAML scalar string.
+ *
+ * @param {unknown} v
+ * @returns {string}
+ */
+function scalarToString(v) {
+  if (typeof v === 'string') {
+    if (v.includes(':') || v.includes('#') || v.includes('"') || v.includes("'") || /^\s/.test(v) || /\s$/.test(v)) {
+      return `"${v.replace(/"/g, '\\"')}"`;
+    }
+    return v;
+  }
+  if (typeof v === 'boolean') return v ? 'true' : 'false';
+  if (typeof v === 'number') return String(v);
+  if (v === null || v === undefined) return 'null';
+  return String(v);
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/web/v8/App.tsx

@@ -0,0 +1,200 @@
+import { Suspense, useEffect, useMemo, useRef, useState } from 'react';
+import { AppShell } from './shell/AppShell.js';
+import { Topbar } from './shell/Topbar.js';
+import { Sidebar, type SidebarSection } from './shell/Sidebar.js';
+import { Box } from './ui/primitives/Box.js';
+import { Inline } from './ui/primitives/Inline.js';
+import { useViewForId } from './views/Router.js';
+import { AppCommandPalette } from './views/CommandPalette/AppCommandPalette.js';
+import { useCommandPaletteHotkey } from './ui/navigation/CommandPalette.js';
+import { useTheme } from './ui/theme/useTheme.js';
+import { useDensity } from './ui/theme/useDensity.js';
+import { PageSkeleton } from './shell/PageSkeleton.js';
+import { useFetch } from './data/useFetch.js';
+import {
+  Activity,
+  Bot,
+  CheckSquare,
+  Cpu,
+  type LucideIcon,
+  Layers,
+  Library,
+  Settings,
+  Target,
+  Goal,
+} from 'lucide-react';
+
+/**
+ * v8 root App component.
+ *
+ * Wires the providers (Theme + Density), the shell (Topbar + Sidebar),
+ * the view router (state-based, see Router.tsx), and the app-level
+ * ⌘K command palette.
+ */
+
+function iconFor(id: string): LucideIcon {
+  switch (id) {
+    case 'overview':
+      return Layers;
+    case 'tasks':
+      return CheckSquare;
+    case 'goals':
+      return Target;
+    case 'agents':
+      return Bot;
+    case 'activity':
+      return Activity;
+    case 'memory':
+      return Cpu;
+    case 'skills':
+      return Goal;
+    case 'mcps':
+      return Library;
+    case 'hooks':
+      return Layers;
+    case 'settings':
+      return Settings;
+    default:
+      return Layers;
+  }
+}
+
+export function App(): JSX.Element {
+  const [activeId, setActiveId] = useState<string>('overview');
+  const theme = useTheme();
+  const density = useDensity();
+
+  // Live tasks count for the sidebar. Pulled from /api/snapshot so we
+  // don't double-fetch when the user lands on the Tasks view.
+  const snapshot = useFetch<{
+    overview?: { tasks?: { active?: number; queued?: number; done?: number; blocked?: number } };
+  }>('/api/snapshot');
+  const tasksCount = useMemo(() => {
+    const t = snapshot.data?.overview?.tasks;
+    if (!t) return undefined;
+    return (t.active ?? 0) + (t.queued ?? 0) + (t.blocked ?? 0) + (t.done ?? 0);
+  }, [snapshot.data]);
+
+  // Single source of truth for palette open/close. Both the hotkey hook
+  // and the topbar button drive the same setter — no race between them.
+  const [paletteOpen, setPaletteOpen] = useCommandPaletteHotkey();
+
+  // When the route changes, move focus to <main> so screen-reader users
+  // hear the new view announced and keyboard users land somewhere
+  // predictable (the new view header is now tabIndex=0 inside main).
+  const mainRef = useRef<HTMLElement>(null);
+  useEffect(() => {
+    mainRef.current?.focus({ preventScroll: true });
+  }, [activeId]);
+
+  const sections: SidebarSection[] = [
+    {
+      id: 'workspace',
+      label: 'Workspace',
+      items: [
+        { id: 'overview', label: 'Overview', icon: iconFor('overview') },
+        { id: 'tasks', label: 'Tasks', icon: iconFor('tasks'), count: tasksCount },
+        { id: 'goals', label: 'Goals', icon: iconFor('goals'), count: 3 },
+      ],
+    },
+    {
+      id: 'operations',
+      label: 'Operations',
+      items: [
+        { id: 'agents', label: 'Agents', icon: iconFor('agents'), count: '8/16' },
+        { id: 'activity', label: 'Activity', icon: iconFor('activity'), live: true },
+        { id: 'memory', label: 'Memory', icon: iconFor('memory') },
+      ],
+    },
+    {
+      id: 'libraries',
+      label: 'Libraries',
+      items: [
+        { id: 'skills', label: 'Skills', icon: iconFor('skills'), count: 18 },
+        { id: 'mcps', label: 'MCPs', icon: iconFor('mcps'), count: 3 },
+        { id: 'hooks', label: 'Hooks', icon: iconFor('hooks'), count: 5 },
+      ],
+    },
+    {
+      id: 'system',
+      label: 'System',
+      items: [{ id: 'settings', label: 'Settings', icon: iconFor('settings') }],
+    },
+  ];
+
+  const handleNavigate = (id: string): void => {
+    if (id === '__theme') {
+      const next = theme.mode === 'dark' ? 'light' : 'dark';
+      theme.setMode(next);
+      return;
+    }
+    if (id === '__density') {
+      const next = density.density === 'comfortable' ? 'compact' : 'comfortable';
+      density.setDensity(next);
+      return;
+    }
+    setActiveId(id);
+  };
+
+  const view = useViewForId(activeId);
+
+  return (
+    <AppShell
+      ref={mainRef}
+      topbar={
+        <Topbar
+          center={
+            <Inline align="center" gap={2}>
+              <button
+                type="button"
+                onClick={() => setPaletteOpen(true)}
+                style={{
+                  display: 'inline-flex',
+                  alignItems: 'center',
+                  gap: 'var(--space-2)',
+                  padding: '6px var(--space-3)',
+                  background: 'var(--surface-1)',
+                  border: '1px solid var(--border)',
+                  borderRadius: 'var(--radius)',
+                  color: 'var(--fg-muted)',
+                  fontSize: 'var(--fs-13)',
+                  width: 360,
+                  maxWidth: '100%',
+                  justifyContent: 'space-between',
+                }}
+                aria-label="Open command palette"
+              >
+                <span>Type a command, page, or setting…</span>
+                <Box
+                  as="kbd"
+                  style={{
+                    fontFamily: 'var(--font-mono)',
+                    fontSize: 'var(--fs-12)',
+                    color: 'var(--fg-muted)',
+                  }}
+                >
+                  ⌘K
+                </Box>
+              </button>
+            </Inline>
+          }
+        />
+      }
+      sidebar={
+        <Sidebar
+          sections={sections}
+          defaultSections={false}
+          activeId={activeId}
+          onItemSelect={handleNavigate}
+        />
+      }
+    >
+      <Suspense fallback={<PageSkeleton />}>{view}</Suspense>
+      <AppCommandPalette
+        open={paletteOpen}
+        onOpenChange={setPaletteOpen}
+        onNavigate={handleNavigate}
+      />
+    </AppShell>
+  );
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/web/v8/data/fetcher.ts

@@ -0,0 +1,59 @@
+/**
+ * v8/data/fetcher.ts — tiny fetch wrapper for the v8 dashboard.
+ *
+ * Thin layer over `fetch` with AbortController support. The dashboard
+ * sits behind the same origin as the API (vite dev proxies /api → :PORT,
+ * prod serves from the same host), so the URL is always relative.
+ *
+ * `useFetch` is React-side; `fetchJson` is the vanilla helper that the
+ * hook uses. Both go through here so we have one place to add
+ * auth headers, retry, etc.
+ */
+
+export class FetchError extends Error {
+  status: number;
+  body: unknown;
+  constructor(status: number, message: string, body: unknown) {
+    super(message);
+    this.name = 'FetchError';
+    this.status = status;
+    this.body = body;
+  }
+}
+
+export interface FetchJsonOptions {
+  signal?: AbortSignal;
+  method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+  body?: unknown;
+  headers?: Record<string, string>;
+  /** Override the base URL. Default = '' (same-origin). */
+  base?: string;
+}
+
+export async function fetchJson<T>(url: string, opts: FetchJsonOptions = {}): Promise<T> {
+  const init: RequestInit = {
+    method: opts.method || 'GET',
+    headers: {
+      Accept: 'application/json',
+      ...(opts.body ? { 'Content-Type': 'application/json' } : {}),
+      ...(opts.headers || {}),
+    },
+    signal: opts.signal,
+  };
+  if (opts.body !== undefined) init.body = JSON.stringify(opts.body);
+  const fullUrl = (opts.base || '') + url;
+  const res = await fetch(fullUrl, init);
+  const text = await res.text();
+  let parsed: unknown = null;
+  if (text) {
+    try { parsed = JSON.parse(text); } catch { parsed = text; }
+  }
+  if (!res.ok) {
+    const message =
+      (parsed && typeof parsed === 'object' && 'message' in parsed && typeof (parsed as { message: unknown }).message === 'string')
+        ? (parsed as { message: string }).message
+        : `HTTP ${res.status}`;
+    throw new FetchError(res.status, message, parsed);
+  }
+  return parsed as T;
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/web/v8/data/types.ts

@@ -0,0 +1,168 @@
+/**
+ * v8/data/types.ts — Wire types for the dashboard's REST + WS surface.
+ *
+ * Single source of truth for the shapes that flow between the
+ * `bizar-dash` backend and the v8 views. Each interface corresponds to
+ * a route in `src/server/routes/*.mjs`. Keep them narrow — optional
+ * fields stay optional; the backend may emit more keys than the
+ * dashboard needs and that's fine (we ignore them).
+ */
+
+/** `GET /api/snapshot` — top-level dashboard counts. */
+export interface Snapshot {
+  overview: {
+    tasks?: { active?: number; queued?: number; done?: number; blocked?: number };
+    agents?: { running?: number; idle?: number; error?: number; total?: number };
+    goals?: { total?: number; atRisk?: number; done?: number };
+    tokens?: { last24h?: number; trend?: 'up' | 'down' | 'flat' };
+    needsAttention?: Array<{ label: string; value: string; hint?: string }>;
+    recentActivity?: Array<ActivityEvent>;
+  };
+  agents: BizarAgent[];
+  projects: Array<{ id: string; cwd?: string; name?: string }>;
+  activeProject?: { id: string; cwd?: string; name?: string } | null;
+}
+
+/** `GET /api/agents` — Bizar agent roster (frontmatter + runtime status). */
+export interface BizarAgent {
+  name: string;
+  description?: string;
+  model?: string;
+  mode?: string;
+  color?: string;
+  tools?: string[];
+  tags?: string[];
+  category?: string;
+  status?: 'idle' | 'working' | 'error' | 'stuck';
+  currentTaskId?: string | null;
+  currentTaskStartedAt?: number;
+  lastSeen?: number;
+  heartbeat?: number;
+  lastError?: { ts: number; message: string } | null;
+  lastTask?: { id: string; finishedAt: number; status: string } | null;
+  successRate?: number;
+  tasksTotal?: number;
+  tasksSucceeded?: number;
+  tasksFailed?: number;
+  isStuck?: boolean;
+  level?: number;
+  parent?: string | null;
+  role?: string;
+}
+
+/** `GET /api/cc-agents` — Claude Code background agent roster. */
+export interface CCAgent {
+  id?: string;
+  pid?: number;
+  cwd?: string;
+  kind?: 'background' | 'interactive';
+  startedAt?: number;
+  sessionId?: string;
+  name?: string;
+  status?: string;
+  state?: string;
+  lastMessageAt?: number;
+  messageCount?: number;
+  lastMessageSnippet?: string;
+}
+
+/** `GET /api/goals` — long-horizon goals parsed from `.bizar/PROGRESS.md`. */
+export interface Goal {
+  id: string;
+  title: string;
+  status: 'on-track' | 'at-risk' | 'off-track' | 'done' | 'blocked' | 'active';
+  description?: string;
+  progress: number;
+  keyResults: Array<{
+    id: string;
+    title: string;
+    done: boolean;
+    assignee?: string;
+  }>;
+  owner?: string;
+  due?: string;
+  section?: string;
+}
+
+/** `GET /api/tasks` — kanban tasks. */
+export interface Task {
+  id: string;
+  title: string;
+  status?: 'backlog' | 'queued' | 'doing' | 'done' | 'blocked' | 'archived';
+  priority?: 'low' | 'medium' | 'high' | 'urgent';
+  description?: string;
+  branch?: string;
+  due?: string;
+  comments?: number;
+  attachments?: number;
+  assignee?: string;
+  /** Free-form tags the server accepts (string array). */
+  tags?: string[];
+  /** Ids of subtasks owned by this task. */
+  subtasks?: string[];
+  /** Ids of tasks that must finish before this one. */
+  dependencies?: string[];
+  /** Recurring rule (server-typed, varies). */
+  recurring?: unknown;
+  /** Server-tracked metadata bag (progress lives here). */
+  metadata?: Record<string, unknown>;
+  /** Activity log (server-typed). */
+  activity?: Array<{ id?: string; type?: string; ts?: string; data?: unknown }>;
+  /** Internal server timer (used by `POST /api/tasks/:id/timer`). */
+  _timerStart?: number;
+  /** Comments count (server convenience field). */
+  createdAt?: number;
+  updatedAt?: number;
+}
+
+/** `GET /api/memory` — memo entries. */
+export interface MemoryEntry {
+  id: string;
+  content: string;
+  tags?: string[];
+  scope?: 'project' | 'global';
+  updatedAt?: string;
+  /** Optional references the renderer surfaces as chips. */
+  refs?: Array<{ kind: string; value: string }>;
+}
+
+/** `GET /api/skills`, `/api/mcps`, `/api/hooks` — library items. */
+export interface LibraryItem {
+  id: string;
+  name: string;
+  slug?: string;
+  status?: 'enabled' | 'disabled' | 'error';
+  description?: string;
+  meta?: string;
+  source?: string;
+  path?: string;
+  version?: string;
+  scope?: 'project' | 'global' | 'shipped' | 'user';
+  badges?: string[];
+}
+
+/** Activity event from `/api/activity` (paged) or WS. */
+export interface ActivityEvent {
+  id?: string;
+  kind?: string;
+  title?: string;
+  description?: string;
+  meta?: string;
+  ts?: number;
+  tone?: 'info' | 'success' | 'warning' | 'danger';
+  agent?: string;
+  iconKey?: string;
+  slug?: string;
+}
+
+/** A single WebSocket message from `/ws`. */
+export type WsMessage =
+  | { type: 'tasks:change'; task?: Task }
+  | { type: 'agents:change'; source?: string; digest?: string }
+  | { type: 'agent:status'; agent?: BizarAgent }
+  | { type: 'goals:change'; goal?: Goal }
+  | { type: 'background:change'; id?: string; status?: string }
+  | { type: 'background:syncError'; taskId?: string; instanceId?: string; fails?: number }
+  | { type: 'artifact:new'; artifact?: { id?: string; title?: string } }
+  | { type: 'activity:new'; event?: ActivityEvent }
+  | { type: string; [key: string]: unknown };