@polderlabs/bizar 7.0.4 → 8.1.0

package/bizar-dash/src/server/routes/goals.mjs

@@ -0,0 +1,307 @@
+/**
+ * src/server/routes/goals.mjs
+ *
+ * Sprint S10/S12 — `/api/goals` CRUD over `.bizar/PROGRESS.md`.
+ *
+ * Goals are the long-horizon commitments the v8 dashboard surfaces.
+ * Source-of-truth is `.bizar/PROGRESS.md` so CC's `/goal` and the
+ * dashboard stay in sync — no parallel JSON.
+ *
+ * Endpoints:
+ *   GET    /api/goals                       — parsed goal list
+ *   GET    /api/goals/:id                   — single goal
+ *   POST   /api/goals                       — create
+ *   PATCH  /api/goals/:id                   — rename / due / owner
+ *   PATCH  /api/goals/:id/status            — change status (S10 quick edit)
+ *   POST   /api/goals/:id/key-results       — append KR
+ *   PATCH  /api/goals/:id/key-results/:krId — toggle done / change metric
+ *   DELETE /api/goals/:id/key-results/:krId — remove KR
+ */
+
+import { Router } from 'express';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { wrap } from './_shared.mjs';
+import { projectsStore } from '../projects-store.mjs';
+import { tasksStore } from '../tasks-store.mjs';
+import { parseProgress, serializeProgress } from '../progress-parser.mjs';
+
+const VALID_STATUSES = new Set(['on-track', 'at-risk', 'off-track', 'done', 'blocked', 'active']);
+const HOME = homedir();
+
+function progressPath() {
+  // PROGRESS.md lives in the project root (v6 contract). Falls back
+  // to $HOME so a freshly-cloned dashboard with no active project
+  // doesn't 500 — the response is just an empty goal list.
+  const active = projectsStore.active();
+  const root = active?.cwd ? resolve(active.cwd) : HOME;
+  return join(root, '.bizar', 'PROGRESS.md');
+}
+
+function readRaw() {
+  const p = progressPath();
+  if (!existsSync(p)) return '';
+  try { return readFileSync(p, 'utf8'); } catch { return ''; }
+}
+
+function writeRaw(text) {
+  const p = progressPath();
+  mkdirSync(dirname(p), { recursive: true });
+  const tmp = `${p}.tmp.${process.pid}`;
+  writeFileSync(tmp, text, 'utf8');
+  renameSync(tmp, p);
+}
+
+function broadcast(broadcast, goal) {
+  if (typeof broadcast === 'function') {
+    broadcast({ type: 'goals:change', goal });
+  }
+}
+
+/**
+ * @param {{ broadcast?: Function }} deps
+ */
+export function createGoalsRouter({ broadcast } = {}) {
+  const router = Router();
+
+  router.get('/goals', wrap(async (_req, res) => {
+    const parsed = parseProgress(readRaw());
+    res.json({ goals: parsed.goals, count: parsed.goals.length });
+  }));
+
+  router.get('/goals/:id', wrap(async (req, res) => {
+    const parsed = parseProgress(readRaw());
+    const goal = parsed.goals.find((g) => g.id === req.params.id);
+    if (!goal) {
+      res.status(404).json({ error: 'not_found' });
+      return;
+    }
+    res.json(goal);
+  }));
+
+  router.patch('/goals/:id/status', wrap(async (req, res) => {
+    const status = String((req.body && req.body.status) || '').toLowerCase();
+    if (!VALID_STATUSES.has(status)) {
+      res.status(400).json({
+        error: 'bad_request',
+        message: `invalid status (use: ${[...VALID_STATUSES].join(', ')})`,
+      });
+      return;
+    }
+    const parsed = parseProgress(readRaw());
+    const goal = parsed.goals.find((g) => g.id === req.params.id);
+    if (!goal) { res.status(404).json({ error: 'not_found' }); return; }
+    goal.status = status;
+    writeRaw(serializeProgress(parsed));
+    broadcast(broadcast, goal);
+    res.json(goal);
+  }));
+
+  // S12 — create goal.
+  router.post('/goals', wrap(async (req, res) => {
+    const body = req.body || {};
+    const title = String(body.title || '').trim();
+    if (!title) {
+      res.status(400).json({ error: 'bad_request', message: 'title is required' });
+      return;
+    }
+    const parsed = parseProgress(readRaw());
+    const id = body.id && /^[A-Za-z0-9_-]{1,64}$/.test(String(body.id))
+      ? String(body.id)
+      : `G-${Date.now().toString(36)}`;
+    if (parsed.goals.some((g) => g.id === id)) {
+      res.status(409).json({ error: 'conflict', message: `goal id ${id} already exists` });
+      return;
+    }
+    const goal = {
+      id,
+      title,
+      status: VALID_STATUSES.has(String(body.status || '').toLowerCase())
+        ? String(body.status).toLowerCase()
+        : 'active',
+      description: body.description ? String(body.description) : '',
+      progress: 0,
+      keyResults: [],
+      owner: body.owner ? String(body.owner) : undefined,
+      due: body.due ? String(body.due) : undefined,
+      section: 'in-progress',
+    };
+    parsed.goals.push(goal);
+    writeRaw(serializeProgress(parsed));
+    broadcast(broadcast, goal);
+    res.status(201).json(goal);
+  }));
+
+  // S12 — patch goal metadata.
+  router.patch('/goals/:id', wrap(async (req, res) => {
+    const parsed = parseProgress(readRaw());
+    const goal = parsed.goals.find((g) => g.id === req.params.id);
+    if (!goal) { res.status(404).json({ error: 'not_found' }); return; }
+    const body = req.body || {};
+    if (typeof body.title === 'string' && body.title.trim()) goal.title = body.title.trim();
+    if (typeof body.description === 'string') goal.description = body.description;
+    if (typeof body.owner === 'string') goal.owner = body.owner.trim() || undefined;
+    if (typeof body.due === 'string') goal.due = body.due.trim() || undefined;
+    if (typeof body.status === 'string' && VALID_STATUSES.has(body.status.toLowerCase())) {
+      goal.status = body.status.toLowerCase();
+    }
+    writeRaw(serializeProgress(parsed));
+    broadcast(broadcast, goal);
+    res.json(goal);
+  }));
+
+  // S12 — append KR.
+  router.post('/goals/:id/key-results', wrap(async (req, res) => {
+    const parsed = parseProgress(readRaw());
+    const goal = parsed.goals.find((g) => g.id === req.params.id);
+    if (!goal) { res.status(404).json({ error: 'not_found' }); return; }
+    const title = String((req.body && req.body.title) || '').trim();
+    if (!title) { res.status(400).json({ error: 'bad_request', message: 'title is required' }); return; }
+    const kr = {
+      id: `kr-${goal.id}-${goal.keyResults.length + 1}`,
+      title,
+      done: false,
+      assignee: req.body.assignee ? String(req.body.assignee) : undefined,
+    };
+    goal.keyResults.push(kr);
+    writeRaw(serializeProgress(parsed));
+    broadcast(broadcast, goal);
+    res.status(201).json(kr);
+  }));
+
+  // S12 — toggle / rename KR.
+  router.patch('/goals/:id/key-results/:krId', wrap(async (req, res) => {
+    const parsed = parseProgress(readRaw());
+    const goal = parsed.goals.find((g) => g.id === req.params.id);
+    if (!goal) { res.status(404).json({ error: 'not_found' }); return; }
+    const kr = goal.keyResults.find((k) => k.id === req.params.krId);
+    if (!kr) { res.status(404).json({ error: 'not_found' }); return; }
+    const body = req.body || {};
+    if (typeof body.done === 'boolean') kr.done = body.done;
+    if (typeof body.title === 'string' && body.title.trim()) kr.title = body.title.trim();
+    if (typeof body.assignee === 'string') kr.assignee = body.assignee.trim() || undefined;
+    // Recompute progress.
+    const done = goal.keyResults.filter((k) => k.done).length;
+    goal.progress = goal.keyResults.length > 0 ? done / goal.keyResults.length : 0;
+    writeRaw(serializeProgress(parsed));
+    broadcast(broadcast, goal);
+    res.json(kr);
+  }));
+
+  // S12 — remove KR.
+  router.delete('/goals/:id/key-results/:krId', wrap(async (req, res) => {
+    const parsed = parseProgress(readRaw());
+    const goal = parsed.goals.find((g) => g.id === req.params.id);
+    if (!goal) { res.status(404).json({ error: 'not_found' }); return; }
+    const before = goal.keyResults.length;
+    goal.keyResults = goal.keyResults.filter((k) => k.id !== req.params.krId);
+    if (goal.keyResults.length === before) {
+      res.status(404).json({ error: 'not_found' });
+      return;
+    }
+    const done = goal.keyResults.filter((k) => k.done).length;
+    goal.progress = goal.keyResults.length > 0 ? done / goal.keyResults.length : 0;
+    writeRaw(serializeProgress(parsed));
+    broadcast(broadcast, goal);
+    res.status(204).end();
+  }));
+
+  // S18 — decompose a goal into tasks (one per key-result).
+  // Each task carries metadata.goalId / metadata.krId so progress can
+  // flow back the other way (task done -> KR done -> goal progress%).
+  router.post('/goals/:id/decompose', wrap(async (req, res) => {
+    const parsed = parseProgress(readRaw());
+    const goal = parsed.goals.find((g) => g.id === req.params.id);
+    if (!goal) { res.status(404).json({ error: 'not_found' }); return; }
+    if (!Array.isArray(goal.keyResults) || goal.keyResults.length === 0) {
+      res.status(400).json({ error: 'bad_request', message: 'goal has no key results to decompose' });
+      return;
+    }
+    const active = projectsStore.active();
+    const projectId = active?.id || 'default';
+    const created = [];
+    for (const kr of goal.keyResults) {
+      if (kr.taskId) continue; // already decomposed
+      const task = await tasksStore.create(projectId, {
+        title: kr.title,
+        description: `Auto-created from goal "${goal.title}"`,
+        priority: 'normal',
+        assignee: kr.assignee || null,
+        dueDate: goal.due || null,
+        metadata: { goalId: goal.id, goalTitle: goal.title, krId: kr.id, krTitle: kr.title },
+      });
+      kr.taskId = task.id;
+      created.push({ kr: kr.id, task: task.id });
+    }
+    writeRaw(serializeProgress(parsed));
+    broadcast(broadcast, goal);
+    res.status(201).json({ goalId: goal.id, created });
+  }));
+
+  // S18 — reverse-sync: task status changes propagate to the linked KR
+  // and recompute the goal's progress%. Called by the tasks router when
+  // a task with metadata.goalId moves to 'done'.
+  router.post('/goals/:id/sync-from-tasks', wrap(async (req, res) => {
+    const parsed = parseProgress(readRaw());
+    const goal = parsed.goals.find((g) => g.id === req.params.id);
+    if (!goal) { res.status(404).json({ error: 'not_found' }); return; }
+    const active = projectsStore.active();
+    const projectId = active?.id || 'default';
+    let changed = false;
+    for (const kr of goal.keyResults) {
+      if (!kr.taskId) continue;
+      const task = await tasksStore.getById(projectId, kr.taskId);
+      if (!task) continue;
+      const isDone = task.status === 'done';
+      if (Boolean(kr.done) !== isDone) {
+        kr.done = isDone;
+        changed = true;
+      }
+    }
+    const done = goal.keyResults.filter((k) => k.done).length;
+    const newProgress = goal.keyResults.length > 0 ? done / goal.keyResults.length : 0;
+    if (newProgress !== goal.progress) {
+      goal.progress = newProgress;
+      changed = true;
+    }
+    if (changed) {
+      writeRaw(serializeProgress(parsed));
+      broadcast(broadcast, goal);
+    }
+    res.json({ goal, changed });
+  }));
+
+  return router;
+}
+
+/**
+ * S18 — recompute KR done flags + goal progress% from a task status
+ * change. Called by the tasks router when a goal-linked task moves.
+ * Returns true if anything was persisted, false if no change.
+ */
+export function syncGoalFromTask(
+  goalId, krId, taskDone, broadcast
+) {
+  const parsed = parseProgress(readRaw());
+  const goal = parsed.goals.find((g) => g.id === goalId);
+  if (!goal) return false;
+  const kr = Array.isArray(goal.keyResults)
+    ? goal.keyResults.find((k) => k.id === krId)
+    : null;
+  if (kr && Boolean(kr.done) !== taskDone) kr.done = taskDone;
+  const doneCount = goal.keyResults.filter((k) => k.done).length;
+  const newProgress = goal.keyResults.length > 0 ? doneCount / goal.keyResults.length : 0;
+  if (
+    newProgress !== goal.progress ||
+    (kr && kr.done !== taskDone)
+  ) {
+    goal.progress = newProgress;
+    writeRaw(serializeProgress(parsed));
+    broadcast(broadcast, goal);
+    return true;
+  }
+  return false;
+}
+
+export const _internals = { progressPath, readRaw, writeRaw, VALID_STATUSES, syncGoalFromTask };

package/bizar-dash/src/server/routes/tasks.mjs

@@ -33,6 +33,9 @@ import { agentsStore } from '../agents-store.mjs';
 import { notificationsStore } from '../notifications-store.mjs';
 import { projectsStore } from '../projects-store.mjs';
 import { artifactsStore } from '../artifacts-store.mjs';
+// S18 — reverse-sync from the goals router (recompute KR done
+// + goal progress from a task status change and persist to PROGRESS.md).
+import { syncGoalFromTask } from './goals.mjs';
 import {
   listClaudeMessages,
   normalizeClaudeMessage,
@@ -191,6 +194,14 @@ export function createTasksRouter({ state, broadcast, projectRoot }) {
         }, { broadcast });
       } catch { /* best-effort */ }
     }
+    // S18 — reverse-sync linked goal KR. If the task came from a goal
+    // decompose (metadata.goalId), update the goal's PROGRESS.md and
+    // broadcast the change. Best-effort: ignore failures.
+    if (task?.metadata?.goalId && task.metadata.krId) {
+      try {
+        syncGoalFromTask(task.metadata.goalId, task.metadata.krId, status === 'done', broadcast);
+      } catch { /* best-effort */ }
+    }
     res.json(task);
   }));
 

package/bizar-dash/src/server/server.mjs

@@ -79,7 +79,6 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // server.mjs lives at src/server/ — dist/ is at the package root
 const DIST_DIR = join(__dirname, '..', '..', 'dist');
 const WS_BACKPRESSURE_LIMIT_BYTES = 1024 * 1024;
-const MOBILE_UA_RE = /Android.+Mobile|iPhone|iPod|Windows Phone|webOS|BlackBerry|Opera Mini|IEMobile/i;
 
 let currentBroadcast = () => {};
 
@@ -113,30 +112,6 @@ export function getV2Auth() {
   };
 }
 
-function shouldRedirectToMobile(req) {
-  if (req.method !== 'GET') return false;
-  if (req.path !== '/') return false;
-  if (req.query?.desktop === '1') return false;
-  const accept = req.headers.accept || '';
-  if (typeof accept === 'string' && !accept.includes('text/html')) return false;
-  const ua = req.headers['user-agent'] || '';
-  return typeof ua === 'string' && MOBILE_UA_RE.test(ua);
-}
-
-function mobileRedirectTarget(req) {
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(req.query || {})) {
-    if (key === 'desktop') continue;
-    if (Array.isArray(value)) {
-      for (const item of value) params.append(key, String(item));
-    } else if (value != null) {
-      params.set(key, String(value));
-    }
-  }
-  const qs = params.toString();
-  return qs ? `/m?${qs}` : '/m';
-}
-
 /**
  * @param {object} opts
  * @param {number} opts.port
@@ -647,43 +622,12 @@ export async function createServer({
         '/assets',
         express.static(assetsDir, { maxAge: '1y', immutable: true, index: false }),
       );
-      // v3.23.0 — Serve the mobile CSS at a stable /mobile.css URL so the
-      // desktop index.html can link to it without needing to know the hash.
-      // MobileApp renders the mobile shell; without its CSS the user sees
-      // unformatted HTML. The actual file is named mobile-<hash>.css; we
-      // resolve it at startup so the URL is stable.
-      try {
-        const mobileCss = readdirSync(assetsDir).find((f) => /^mobile-.*\.css$/.test(f));
-        if (mobileCss) {
-          app.get('/mobile.css', (_req, res) => {
-            res.setHeader('Cache-Control', 'no-cache');
-            res.sendFile(join(assetsDir, mobileCss));
-          });
-        }
-      } catch { /* ignore — mobile.css won't be served, fine */ }
     }
-    app.get('/', (req, res, next) => {
-      if (!shouldRedirectToMobile(req)) {
-        next();
-        return;
-      }
-      res.redirect(302, mobileRedirectTarget(req));
-    });
-    // v3.5.0 — Mobile dashboard at /m
-    app.get('/m', (_req, res) => {
-      res.sendFile(join(DIST_DIR, 'mobile.html'));
-    });
-    // SPA fallback for /m/* — but ONLY for HTML navigation requests
-    // The negative lookahead (?!assets/) excludes asset paths so they fall
-    // through to the static /assets/* handler above
-    app.get(/^\/m\/(?!assets\/)/, (_req, res) => {
-      res.sendFile(join(DIST_DIR, 'mobile.html'));
-    });
     app.use(
       express.static(DIST_DIR, {
         extensions: ['html'],
         setHeaders: (res, filePath) => {
-          if (filePath.endsWith('index.html') || filePath.endsWith('mobile.html')) {
+          if (filePath.endsWith('index.html')) {
             res.setHeader('Cache-Control', 'no-cache');
           }
         },

package/bizar-dash/src/web/v8/App.tsx

@@ -0,0 +1,188 @@
+import { Suspense, useEffect, 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 {
+  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();
+
+  // 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: 47 },
+        { 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>
+  );
+}