@polderlabs/bizar 6.2.5 → 7.0.0

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

@@ -0,0 +1,129 @@
+/**
+ * src/server/routes/distill.mjs
+ *
+ * v6.4.0 — F-033 / ADR-174.
+ *
+ * REST surface for the ReasoningBank distillation pipeline.
+ *
+ *   POST /api/distill
+ *     Triggers a single RETRIEVE → JUDGE → DISTILL → CONSOLIDATE run
+ *     over the current vault. Optional JSON body:
+ *       { "since": "<iso8601>" }
+ *     Returns the consolidation result (same shape as the SDK
+ *     `memory_distill` MCP tool plus the in-file path).
+ *
+ *   GET /api/distill/patterns
+ *     Reads the most recent `.bizar/distilled-patterns.json` and
+ *     returns its `patterns` array (filtered by `?tier=` and
+ *     `?promoted=` query params). 404 if the file does not yet
+ *     exist (a distillation run hasn't happened).
+ *
+ *   GET /api/distill/status
+ *     Returns a small status object:
+ *       { file: "<path or null>", patternCount, promotedCount, byTier, generatedAt }
+ *
+ * Mounted at /api/distill/*. The route itself is `Router()`-style so
+ * it composes with the rest of the v3 dashboard API.
+ */
+
+import { Router } from 'express';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const SERVER_ROOT = join(dirname(new URL(import.meta.url).pathname), '..');
+const memoryConsolidator = await import(`${SERVER_ROOT}/memory-consolidator.mjs`).then((m) => m);
+
+const { wrap } = await import('./_shared.mjs').then((m) => m);
+
+/**
+ * Build the distill router. `projectRoot` is the Bizar repo root — it
+ * defaults to `process.cwd()` so that `bizar dashboard --dev` "just
+ * works" when launched from inside a Bizar project.
+ */
+export function createDistillRouter({ projectRoot } = {}) {
+  const root = projectRoot ?? process.cwd();
+  const router = Router();
+
+  // ---------------------------------------------------------------------
+  // POST /api/distill — run the pipeline.
+  // ---------------------------------------------------------------------
+  router.post('/distill', wrap(async (req, res) => {
+    const since = typeof req.body?.since === 'string' ? req.body.since : undefined;
+    const result = memoryConsolidator.runConsolidation({ projectRoot: root, since });
+
+    // Side-effect: write the machine-readable log so the GET route
+    // can serve it without re-running the pipeline.
+    const filePath = memoryConsolidator.writeDistilledPatternsFile(result, {
+      projectRoot: root,
+    });
+
+    res.json({
+      distilled: result.distilled,
+      promoted: result.promoted,
+      patterns: result.patterns,
+      byTier: result.byTier,
+      written: result.written,
+      file: filePath,
+    });
+  }));
+
+  // ---------------------------------------------------------------------
+  // GET /api/distill/patterns — return the patterns.
+  // ---------------------------------------------------------------------
+  router.get('/distill/patterns', wrap(async (req, res) => {
+    const fp = join(root, memoryConsolidator.DISTILLED_PATTERNS_FILE);
+    if (!existsSync(fp)) {
+      res.status(404).json({ error: 'not_distilled_yet', file: fp });
+      return;
+    }
+    const raw = readFileSync(fp, 'utf-8');
+    let payload;
+    try { payload = JSON.parse(raw); }
+    catch (e) { res.status(500).json({ error: 'corrupt_distill_file', message: String(e) }); return; }
+
+    let patterns = Array.isArray(payload.patterns) ? payload.patterns : [];
+
+    const tier = typeof req.query.tier === 'string' ? req.query.tier : null;
+    if (tier) patterns = patterns.filter((p) => p.provenance_tier === tier);
+
+    const promoted = req.query.promoted === 'true'
+      ? true
+      : req.query.promoted === 'false'
+      ? false
+      : null;
+    if (promoted !== null) patterns = patterns.filter((p) => Boolean(p.promoted) === promoted);
+
+    res.json({
+      generatedAt: payload.generatedAt,
+      byTier: payload.byTier,
+      patterns,
+      count: patterns.length,
+    });
+  }));
+
+  // ---------------------------------------------------------------------
+  // GET /api/distill/status — small status object.
+  // ---------------------------------------------------------------------
+  router.get('/distill/status', wrap(async (_req, res) => {
+    const fp = join(root, memoryConsolidator.DISTILLED_PATTERNS_FILE);
+    if (!existsSync(fp)) {
+      res.json({ file: null, patternCount: 0, promotedCount: 0, byTier: null, generatedAt: null });
+      return;
+    }
+    try {
+      const payload = JSON.parse(readFileSync(fp, 'utf-8'));
+      const patterns = Array.isArray(payload.patterns) ? payload.patterns : [];
+      res.json({
+        file: fp,
+        patternCount: patterns.length,
+        promotedCount: patterns.filter((p) => Boolean(p.promoted)).length,
+        byTier: payload.byTier,
+        generatedAt: payload.generatedAt,
+      });
+    } catch (e) {
+      res.status(500).json({ error: 'corrupt_distill_file', message: String(e) });
+    }
+  }));
+
+  return router;
+}

package/bizar-dash/src/server/routes/goal-planner.mjs

@@ -0,0 +1,236 @@
+/**
+ * src/server/routes/goal-planner.mjs
+ *
+ * v6.4.0 — F-036 (Goal Planner UI).
+ *
+ * Single endpoint:
+ *   POST /api/goal-planner/plan { goal } -> Plan
+ *
+ * The planner logic is duplicated here in pure JS so the route
+ * runs without a Vite build step. The canonical implementation
+ * lives in `bizar-dash/src/web/lib/goapPlanner.ts` and produces
+ * the same shape.
+ */
+import { Router } from 'express';
+import { wrap } from './_shared.mjs';
+
+const VERB_TO_ACTION = {
+  research: { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Gather context, examples, and prior art.' },
+  investigate: { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Probe the unknown regions of the problem.' },
+  explore: { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Map the solution space.' },
+  find: { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Locate references and prior work.' },
+  analyze: { name: 'analyze', cost: 1, agent: 'Odin', effect: 'goal_analyzed', preconditions: ['context_gathered'], description: 'Decompose the goal into measurable sub-objectives.' },
+  plan: { name: 'plan', cost: 1, agent: 'Odin', effect: 'plan_drafted', preconditions: ['goal_analyzed'], description: 'Sequence the work into milestones.' },
+  design: { name: 'design', cost: 2, agent: 'Tyr', effect: 'design_drafted', preconditions: ['plan_drafted'], description: 'Sketch the architecture and contracts.' },
+  architect: { name: 'design', cost: 2, agent: 'Tyr', effect: 'design_drafted', preconditions: ['plan_drafted'], description: 'Lay out the system structure.' },
+  build: { name: 'build', cost: 3, agent: 'Thor', effect: 'artifact_built', preconditions: ['design_drafted'], description: 'Construct the artifact end-to-end.' },
+  implement: { name: 'implement', cost: 3, agent: 'Thor', effect: 'artifact_built', preconditions: ['design_drafted'], description: 'Wire up the code path.' },
+  create: { name: 'implement', cost: 3, agent: 'Thor', effect: 'artifact_built', preconditions: ['design_drafted'], description: 'Stand up the new module.' },
+  add: { name: 'implement', cost: 2, agent: 'Thor', effect: 'artifact_built', preconditions: ['design_drafted'], description: 'Layer the new capability onto an existing surface.' },
+  write: { name: 'implement', cost: 2, agent: 'Thor', effect: 'artifact_built', description: 'Author the requested artifact.' },
+  fix: { name: 'implement', cost: 2, agent: 'Thor', effect: 'artifact_built', description: 'Repair the reported defect.' },
+  refactor: { name: 'implement', cost: 2, agent: 'Thor', effect: 'artifact_built', description: 'Improve the structure without changing behavior.' },
+  test: { name: 'test', cost: 2, agent: 'Forseti', effect: 'tests_passing', preconditions: ['artifact_built'], description: 'Exercise the artifact against acceptance criteria.' },
+  verify: { name: 'test', cost: 1, agent: 'Forseti', effect: 'tests_passing', preconditions: ['artifact_built'], description: 'Validate against the original goal statement.' },
+  validate: { name: 'test', cost: 1, agent: 'Forseti', effect: 'tests_passing', preconditions: ['artifact_built'], description: 'Cross-check the result against acceptance criteria.' },
+  review: { name: 'review', cost: 1, agent: 'Forseti', effect: 'review_passed', preconditions: ['artifact_built'], description: 'Audit the change for quality and regressions.' },
+  document: { name: 'document', cost: 1, agent: 'Bragi', effect: 'docs_written', preconditions: ['artifact_built'], description: 'Capture the new knowledge in docs.' },
+  deploy: { name: 'deploy', cost: 2, agent: 'Heimdall', effect: 'deployed', preconditions: ['tests_passing', 'review_passed'], description: 'Promote the artifact to production.' },
+  ship: { name: 'deploy', cost: 2, agent: 'Heimdall', effect: 'deployed', preconditions: ['tests_passing', 'review_passed'], description: 'Release the change to users.' },
+  release: { name: 'deploy', cost: 2, agent: 'Heimdall', effect: 'deployed', preconditions: ['tests_passing', 'review_passed'], description: 'Tag and publish a new version.' },
+  publish: { name: 'deploy', cost: 1, agent: 'Heimdall', effect: 'deployed', preconditions: ['tests_passing'], description: 'Make the artifact externally available.' },
+  commit: { name: 'commit', cost: 1, agent: 'Hermod', effect: 'committed', description: 'Land the change in version control.' },
+  save: { name: 'commit', cost: 1, agent: 'Hermod', effect: 'committed', description: 'Persist the work.' },
+};
+
+const DURATION_MS = {
+  research: 30000, analyze: 20000, plan: 25000, design: 60000,
+  build: 120000, implement: 90000, test: 60000, review: 30000,
+  document: 30000, deploy: 60000, commit: 10000,
+};
+
+const FALLBACK = { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Investigate the goal.' };
+
+function splitClauses(text) {
+  // Split on terminal punctuation, conjunctions (then/after/before/and
+  // then), AND commas / the word "and" so that "Design, build, test,
+  // and deploy" produces 4 clauses.
+  const parts = text.split(/[.;!?\n]|\bthen\b|\bafter that\b|\bafter\b|\bbefore\b|\band then\b|\s*,\s*|\band\b/gi);
+  const out = [];
+  for (const part of parts) {
+    const t = part.trim();
+    if (!t) continue;
+    if (!/^[a-zA-Z]+\b/.test(t) && t.includes(',')) {
+      for (const sub of t.split(',')) {
+        const s = sub.trim();
+        if (s) out.push(s);
+      }
+    } else {
+      out.push(t);
+    }
+  }
+  return out;
+}
+
+function stripPolite(body) {
+  let out = body;
+  for (let i = 0; i < 4; i++) {
+    const before = out;
+    out = out.replace(/^(?:please\s+|kindly\s+)/i, '');
+    out = out.replace(/^(?:we should|let's|lets|i want to|i need to|i'd like to|i would like to|can you|could you|would you|help me|help us|make sure to|please)\s+/i, '');
+    if (out === before) break;
+  }
+  return out;
+}
+
+function extractVerb(clause) {
+  const body = stripPolite(clause.trim());
+  const first = (body.split(/\s+/)[0] || '').toLowerCase().replace(/[^a-z]/g, '');
+  return first;
+}
+
+function clauseSubject(clause) {
+  const body = stripPolite(clause.trim());
+  const stripped = body.replace(/^[a-zA-Z]+\s+/, '').trim();
+  return stripped.length > 0 ? stripped : clause;
+}
+
+function aStar(actions, goals) {
+  const goalSet = new Set(goals);
+  if (goalSet.size === 0) return actions.slice(0, 1);
+  const heur = (s) => {
+    let u = 0;
+    for (const g of goalSet) if (!s.has(g)) u++;
+    return u;
+  };
+  const keyOf = (s) => Array.from(s).sort().join('|') || 'empty';
+  const start = { sat: new Set(), path: [], cost: 0 };
+  const open = [start];
+  const closed = new Set();
+  let best = start;
+  while (open.length) {
+    open.sort((a, b) => (a.cost + heur(a.sat)) - (b.cost + heur(b.sat)));
+    const node = open.shift();
+    if (heur(node.sat) === 0) return node.path;
+    if (heur(node.sat) < heur(best.sat)) best = node;
+    const k = keyOf(node.sat);
+    if (closed.has(k)) continue;
+    closed.add(k);
+    for (const a of actions) {
+      const pre = a.preconditions || [];
+      if (!pre.every((p) => node.sat.has(p))) continue;
+      const next = new Set(node.sat);
+      next.add(a.effect);
+      open.push({ sat: next, path: [...node.path, a], cost: node.cost + a.cost });
+    }
+  }
+  return best.path;
+}
+
+function inlinePlan(goalText) {
+  const id = `plan_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  const clauses = splitClauses(goalText);
+  const effective = clauses.length > 0 ? clauses : [(goalText || 'Investigate the goal').trim()];
+  const rawTemplates = effective.map((c) => VERB_TO_ACTION[extractVerb(c)] || FALLBACK);
+  const subjects = effective.map(clauseSubject);
+  const seen = new Set();
+  const dedup = [];
+  for (let i = 0; i < rawTemplates.length; i++) {
+    const t = rawTemplates[i];
+    const s = subjects[i] || `step ${i + 1}`;
+    const sig = `${t.name}::${s.toLowerCase().slice(0, 40)}`;
+    if (seen.has(sig)) continue;
+    seen.add(sig);
+    dedup.push({ template: t, subject: s });
+  }
+  const trimmed = dedup.slice(0, 8);
+  const goalEffects = trimmed.map((d) => d.template.effect);
+  const sequence = aStar(trimmed.map((d) => d.template), goalEffects);
+  const idByEffect = new Map();
+  const steps = [];
+  let n = 0;
+  for (const tpl of sequence) {
+    const match = trimmed.find((s) => s.template === tpl);
+    if (!match) continue;
+    n += 1;
+    const sid = `s${n}`;
+    const deps = [];
+    for (const p of tpl.preconditions || []) {
+      const pid = idByEffect.get(p);
+      if (pid) deps.push(pid);
+    }
+    const title = match.subject.charAt(0).toUpperCase() + match.subject.slice(1);
+    steps.push({
+      id: sid,
+      action: tpl.name,
+      title: title.length > 0 ? title : tpl.name,
+      agent: tpl.agent,
+      description: tpl.description,
+      effects: [tpl.effect],
+      deps,
+      status: 'pending',
+      estimatedCost: tpl.cost,
+      estimatedDurationMs: DURATION_MS[tpl.name] || 30000,
+    });
+    idByEffect.set(tpl.effect, sid);
+  }
+  if (steps.length === 0 && trimmed.length > 0) {
+    let idx = 0;
+    for (const { template, subject } of trimmed) {
+      idx += 1;
+      const sid = `s${idx}`;
+      const deps = [];
+      for (const p of template.preconditions || []) {
+        const pid = idByEffect.get(p);
+        if (pid) deps.push(pid);
+      }
+      const title = subject.charAt(0).toUpperCase() + subject.slice(1);
+      steps.push({
+        id: sid,
+        action: template.name,
+        title: title.length > 0 ? title : template.name,
+        agent: template.agent,
+        description: template.description,
+        effects: [template.effect],
+        deps,
+        status: 'pending',
+        estimatedCost: template.cost,
+        estimatedDurationMs: DURATION_MS[template.name] || 30000,
+      });
+      idByEffect.set(template.effect, sid);
+    }
+  }
+  const totalCost = steps.reduce((sum, s) => sum + s.estimatedCost, 0);
+  const totalDurationMs = steps.reduce((sum, s) => sum + s.estimatedDurationMs, 0);
+  return { id, goal: goalText, steps, totalCost, totalDurationMs, goalEffects };
+}
+
+function readGoal(body) {
+  const raw = body && body.goal;
+  if (typeof raw !== 'string' || !raw.trim()) {
+    const err = new Error('goal (non-empty string) is required');
+    err.status = 400;
+    err.code = 'bad_request';
+    throw err;
+  }
+  if (raw.length > 4000) {
+    const err = new Error('goal must be 4000 chars or fewer');
+    err.status = 400;
+    err.code = 'bad_request';
+    throw err;
+  }
+  return raw.trim();
+}
+
+export function createGoalPlannerRouter({ broadcast } = {}) {
+  const router = Router();
+  router.post('/goal-planner/plan', wrap(async (req, res) => {
+    const goal = readGoal(req.body);
+    const plan = inlinePlan(goal);
+    if (broadcast) {
+      try { broadcast({ type: 'goal:planned', planId: plan.id, goal }); } catch { /* best-effort */ }
+    }
+    res.json(plan);
+  }));
+  return router;
+}

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

@@ -10,7 +10,7 @@
  * /api/tasks/:id/start (POST)             — trigger dispatch of a queued task
  * /api/tasks/:id/status (PATCH)           — move status (queued|doing|done|blocked|archived)
  * /api/tasks/:id/comments (POST)          — append comment
- * /api/tasks/:id/chat (GET)               — cline messages for the task's bg instance
+ * /api/tasks/:id/chat (GET)               — claude messages for the task's bg instance
  * /api/tasks/:id/artifacts (GET)          — list artifacts for this task
  * /api/tasks/:id/artifacts (POST)         — attach artifact + link to task
  * /api/tasks/:id/timer (POST)             — toggle timer
@@ -34,10 +34,9 @@ import { notificationsStore } from '../notifications-store.mjs';
 import { projectsStore } from '../projects-store.mjs';
 import { artifactsStore } from '../artifacts-store.mjs';
 import {
-  readServeInfo,
-  listClineMessages,
-  normalizeClineMessage,
-} from '../serve-info.mjs';
+  listClaudeMessages,
+  normalizeClaudeMessage,
+} from '../claude-info.mjs';
 import { readActiveProjectId, wrap } from './_shared.mjs';
 import { ALLOWED_TASK_STATUSES } from '../tasks-store.mjs';
 
@@ -207,10 +206,15 @@ export function createTasksRouter({ state, broadcast, projectRoot }) {
   }));
 
   // v3.5.5 — Chat-task linkage. Given a task id, return the
-  // cline session's messages so the chat UI can open a thread
-  // for an in-progress or completed task. The task must have a
-  // `bgInstanceId` (or `sessionId`) in its metadata — the delegator
-  // writes that when the cline session is created.
+  // Claude Code session's messages so the chat UI can open a
+  // thread for an in-progress or completed task. The task must
+  // have a `bgInstanceId` (or `sessionId`) in its metadata — the
+  // delegator writes that when the Claude Code session is created.
+  //
+  // v6.3.0 — Reads from `~/.claude/sessions/<id>/messages.jsonl`
+  // via `claude-info.listClaudeMessages()` instead of the old
+  // cline serve HTTP endpoint. The 503 "plugin offline" path is
+  // gone — Claude Code is just a CLI on PATH.
   //
   // Response shape:
   //   { taskId, bgInstanceId, sessionId, agent, messages: [{id,role,content,ts}, ...] }
@@ -218,8 +222,7 @@ export function createTasksRouter({ state, broadcast, projectRoot }) {
   // Status codes:
   //   200 — messages returned (may be empty)
   //   404 — task not found, or no bg instance / session id
-  //   503 — plugin offline
-  //   502 — cline listMessages call failed
+  //   502 — claude listMessages call failed
   router.get('/tasks/:id/chat', wrap(async (req, res) => {
     const projectId = req.query.projectId || readActiveProjectId();
     const task = await tasksStore.getById(projectId, req.params.id);
@@ -246,41 +249,30 @@ export function createTasksRouter({ state, broadcast, projectRoot }) {
     if (!bgInstanceId && !sessionId) {
       return res.status(404).json({
         error: 'no_bg_instance',
-        message: 'task has no bg instance or cline session id',
-        taskId: task.id,
-      });
-    }
-
-    const serveInfo = readServeInfo();
-    if (!serveInfo) {
-      return res.status(503).json({
-        error: 'plugin_offline',
-        message: 'cline plugin is not running',
+        message: 'task has no bg instance or claude session id',
         taskId: task.id,
       });
     }
     if (!sessionId) {
       return res.status(404).json({
         error: 'no_session',
-        message: 'bg instance has no cline session id',
+        message: 'bg instance has no claude session id',
         taskId: task.id,
         bgInstanceId,
       });
     }
 
-    const active = projectsStore.active();
-    const directory = (active && active.path) || serveInfo.worktree || '';
-    const result = await listClineMessages(serveInfo, sessionId, directory);
+    const result = listClaudeMessages(sessionId);
     if (!result.ok) {
       return res.status(502).json({
-        error: 'cline_error',
-        message: result.error || 'listClineMessages failed',
+        error: 'claude_error',
+        message: result.error || 'listClaudeMessages failed',
         taskId: task.id,
         sessionId,
       });
     }
     const messages = Array.isArray(result.messages)
-      ? result.messages.map(normalizeClineMessage)
+      ? result.messages.map(normalizeClaudeMessage)
       : [];
     res.json({
       taskId: task.id,