agentboss 0.1.0

package/server/api/analysis.js

@@ -0,0 +1,141 @@
+/**
+ * Analysis Job API routes for Agent Boss.
+ *
+ * Provides endpoints for checking analysis status and manually triggering
+ * the analysis job.
+ *
+ * @author Felix
+ */
+
+const router = require('express').Router();
+
+const { getAnalysisState, getSessionById } = require('../db/queries');
+const { runAnalysisJob, analyzeAndStoreSession } = require('../analysis/job');
+const { loadAdvice } = require('../llm/advice');
+const { saveDb } = require('../db/connection');
+
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+
+/**
+ * Create the analysis router with database access.
+ *
+ * @param {object} db  sql.js Database instance
+ * @returns {import('express').Router}
+ */
+module.exports = function (db) {
+  // GET /api/analysis/status
+  router.get('/status', (_req, res) => {
+    try {
+      const data = getAnalysisState(db);
+
+      res.json({
+        ok: true,
+        data: data || {
+          status: 'idle',
+          current_date: null,
+          analyzed_count: 0,
+          total_count: 0,
+          last_analyzed_at: null,
+        },
+        meta: {
+          generated_at: new Date().toISOString(),
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'ANALYSIS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // POST /api/analysis/trigger
+  // Body (optional): { force: boolean, days: number, dates: string[] }
+  //   force — reanalyze sessions that already have an analysis row
+  //   days  — how far back to scan (default 7); ignored when dates is given
+  //   dates — explicit YYYY-MM-DD list to analyze (overrides days)
+  router.post('/trigger', (req, res) => {
+    try {
+      // Check if already running
+      const state = getAnalysisState(db);
+      if (state && state.status === 'running') {
+        return res.status(409).json({
+          ok: false,
+          error: { code: 'ALREADY_RUNNING', message: 'Analysis job is already running' },
+        });
+      }
+
+      const force = req.body?.force === true || req.body?.force === '1';
+      const days = Number.isFinite(Number(req.body?.days)) && Number(req.body.days) > 0
+        ? Math.min(Number(req.body.days), 365)
+        : 7;
+
+      // Optional explicit date list (YYYY-MM-DD). Filter out anything that
+      // doesn't match the format to keep the job loop honest.
+      const dateRe = /^\d{4}-\d{2}-\d{2}$/;
+      const dates = Array.isArray(req.body?.dates)
+        ? req.body.dates.filter((d) => typeof d === 'string' && dateRe.test(d))
+        : null;
+
+      const opts = { forceReanalyze: force, days };
+      if (dates && dates.length > 0) opts.dates = dates;
+
+      // Start analysis in the background (fire-and-forget)
+      runAnalysisJob(db, opts).catch(() => {
+        // Error handling is internal to the job; analysis_state will reflect
+        // final status regardless.
+      });
+
+      res.json({
+        ok: true,
+        data: { status: 'started', force, days: dates ? null : days, dates },
+        meta: {
+          generated_at: new Date().toISOString(),
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'ANALYSIS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // POST /api/analysis/session/:id
+  // Re-analyze ONE session with the combined LLM call (scores + advice),
+  // bypassing the analyzer cache.  Returns both halves so the session
+  // detail page can refresh the radar and the advice in one round-trip.
+  router.post('/session/:id', async (req, res) => {
+    const session = getSessionById(db, req.params.id);
+    if (!session) {
+      return res.status(404).json({
+        ok: false,
+        error: { code: 'NOT_FOUND', message: 'Session not found' },
+      });
+    }
+    try {
+      const v2 = await analyzeAndStoreSession(db, session, { force: true });
+      try { saveDb(); } catch (_) { /* auto-save will catch up */ }
+      return res.json({
+        ok: true,
+        data: {
+          difficulty:  v2 ? v2.difficulty.bucket : null,
+          scores:      v2 ? v2.scores : null,
+          levels:      v2 ? v2.levels : null,
+          judgeSource: v2 ? v2.judgeSource : null,
+          advice:      loadAdvice(db, session.id) || null,
+        },
+        meta: { generated_at: new Date().toISOString() },
+      });
+    } catch (err) {
+      return res.status(500).json({
+        ok: false,
+        error: { code: 'ANALYSIS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  return router;
+};

package/server/api/execution.js

@@ -0,0 +1,330 @@
+/**
+ * Advice execution API.
+ *
+ *   POST   /api/execution/start              { sessionId, adviceKey, executor?, ephemeral? }
+ *   POST   /api/execution/project/start      { project, scope, from?, to?, adviceKey, executor?, ephemeral? }
+ *   POST   /api/execution/cancel/:runId
+ *   GET    /api/execution/:runId             ?full=1 → return full stdout/stderr
+ *   GET    /api/execution/advice/:sessionId
+ *   GET    /api/execution/project/advice     ?project=&scope=&from=&to=
+ *   GET    /api/execution/whitelist
+ *   POST   /api/execution/whitelist          { path }
+ *   DELETE /api/execution/whitelist          { path }
+ *
+ * Spec: docs/superpowers/specs/2026-06-13-advice-execution-design.md §9
+ *       (project-level extension: see 2026-06-15 project-advice-execution note)
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const router = require('express').Router();
+const path = require('path');
+
+const job = require('../execution/job');
+const { extractJson } = require('../llm/cli-runner');
+
+// ---------------------------------------------------------------------------
+//  Constants
+// ---------------------------------------------------------------------------
+
+const LOG_PREVIEW_BYTES = 8 * 1024;       // 8 KB returned by default
+const VALID_EXECUTORS  = ['opencode', 'claude'];
+
+// ---------------------------------------------------------------------------
+//  Error mapping
+// ---------------------------------------------------------------------------
+
+const REASON_TO_STATUS = {
+  'already-running':       409,
+  'no-session':            404,
+  'no-project':            400,
+  'no-window':             400,
+  'no-advice':             404,
+  'no-advice-item':        404,
+  'not-actionable':        409,
+  'invalid-project-path':  409,
+  'not-whitelisted':       409,
+  'no-cli':                409,
+  'not-running':           409,
+  'internal':              500,
+};
+
+const REASON_TO_MESSAGE = {
+  'already-running':       'Another execution is already in flight',
+  'no-session':            'Session not found',
+  'no-project':            'project required',
+  'no-window':             'scope=daily|weekly requires from/to',
+  'no-advice':             'No cached advice for this entity — generate it first',
+  'no-advice-item':        'AdviceItem not found at given adviceKey',
+  'not-actionable':        'AdviceItem is not marked actionable',
+  'invalid-project-path':  'Project path does not exist or is not a directory',
+  'not-whitelisted':       'Project path is not in the execution whitelist',
+  'no-cli':                'Requested executor CLI is not on PATH',
+  'not-running':           'No active run with that id',
+  'internal':              'Internal execution error',
+};
+
+function failure(res, reason, extra) {
+  const status = REASON_TO_STATUS[reason] || 500;
+  const message = (extra && extra.error) || REASON_TO_MESSAGE[reason] || reason;
+  const body = { ok: false, error: { code: reason.toUpperCase().replace(/-/g, '_'), message } };
+  if (extra && extra.extra) body.error.details = extra.extra;
+  return res.status(status).json(body);
+}
+
+// ---------------------------------------------------------------------------
+//  Row → API shape
+// ---------------------------------------------------------------------------
+
+function projectRun(row, { full = false } = {}) {
+  if (!row) return null;
+  const stdoutFull = row.stdout || '';
+  const stderrFull = row.stderr || '';
+  let stdout = stdoutFull, stderr = stderrFull;
+  let stdoutTruncated = false, stderrTruncated = false;
+  if (!full) {
+    if (stdoutFull.length > LOG_PREVIEW_BYTES) {
+      stdout = stdoutFull.slice(0, LOG_PREVIEW_BYTES);
+      stdoutTruncated = true;
+    }
+    if (stderrFull.length > LOG_PREVIEW_BYTES) {
+      stderr = stderrFull.slice(0, LOG_PREVIEW_BYTES);
+      stderrTruncated = true;
+    }
+  }
+
+  // Derive summary / files_changed / notes from the JSON the executor was
+  // asked to emit at the end of its stdout.  Tolerate non-JSON / missing.
+  let summary = null, filesChanged = null, notes = null, ok = null;
+  const parsed = extractJson(stdoutFull);
+  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+    if (typeof parsed.ok === 'boolean') ok = parsed.ok;
+    if (typeof parsed.summary === 'string') summary = parsed.summary;
+    if (Array.isArray(parsed.files_changed)) {
+      filesChanged = parsed.files_changed.filter((x) => typeof x === 'string');
+    }
+    if (typeof parsed.notes === 'string') notes = parsed.notes;
+  }
+
+  let adviceSnapshot = null;
+  if (row.advice_snapshot) {
+    try { adviceSnapshot = JSON.parse(row.advice_snapshot); }
+    catch { adviceSnapshot = null; }
+  }
+
+  // Scope info (new in the project-execution extension).  Older rows
+  // default to scope='session' so the API shape stays consistent across
+  // pre-/post-migration data.
+  let scopeMeta = null;
+  if (row.scope_meta) {
+    try { scopeMeta = JSON.parse(row.scope_meta); }
+    catch { scopeMeta = null; }
+  }
+
+  return {
+    id: row.id,
+    scope: row.scope || 'session',
+    scopeId: row.scope_id || row.session_id,
+    scopeMeta,
+    sessionId: row.session_id || null,
+    adviceKey: row.advice_key,
+    project: row.project,
+    executor: row.executor,
+    status: row.status,
+    startedAt: row.started_at,
+    endedAt: row.ended_at,
+    durationMs: row.duration_ms,
+    exitCode: row.exit_code,
+    error: row.error,
+    stdout,
+    stderr,
+    stdoutTruncated,
+    stderrTruncated,
+    summary,
+    filesChanged,
+    notes,
+    reportedOk: ok,
+    adviceSnapshot,
+  };
+}
+
+// ---------------------------------------------------------------------------
+//  Routes
+// ---------------------------------------------------------------------------
+
+module.exports = function (db) {
+  // -------------------------------------------------------------------------
+  //  Whitelist
+  // -------------------------------------------------------------------------
+
+  router.get('/whitelist', (_req, res) => {
+    res.json({ ok: true, data: { paths: job.getWhitelist(db) } });
+  });
+
+  router.post('/whitelist', (req, res) => {
+    const p = req.body?.path;
+    if (typeof p !== 'string' || !p.trim()) {
+      return res.status(400).json({
+        ok: false, error: { code: 'BAD_REQUEST', message: 'path required' },
+      });
+    }
+    const resolved = path.resolve(p.trim());
+    const paths = job.addToWhitelist(db, resolved);
+    res.json({ ok: true, data: { paths, added: resolved } });
+  });
+
+  router.delete('/whitelist', (req, res) => {
+    const p = req.body?.path;
+    if (typeof p !== 'string' || !p.trim()) {
+      return res.status(400).json({
+        ok: false, error: { code: 'BAD_REQUEST', message: 'path required' },
+      });
+    }
+    const paths = job.removeFromWhitelist(db, path.resolve(p.trim()));
+    res.json({ ok: true, data: { paths } });
+  });
+
+  // -------------------------------------------------------------------------
+  //  Start
+  // -------------------------------------------------------------------------
+
+  router.post('/start', async (req, res) => {
+    const { sessionId, adviceKey, executor, ephemeral } = req.body || {};
+    if (typeof sessionId !== 'string' || typeof adviceKey !== 'string') {
+      return res.status(400).json({
+        ok: false,
+        error: { code: 'BAD_REQUEST', message: 'sessionId and adviceKey required' },
+      });
+    }
+    if (executor !== undefined && !VALID_EXECUTORS.includes(executor)) {
+      return res.status(400).json({
+        ok: false,
+        error: { code: 'BAD_REQUEST', message: 'executor must be opencode or claude' },
+      });
+    }
+    const result = await job.startExecution(db, {
+      sessionId,
+      adviceKey,
+      executor,
+      ephemeral: ephemeral === true || ephemeral === '1',
+    });
+    if (!result.ok) return failure(res, result.reason, result);
+    return res.status(201).json({
+      ok: true,
+      data: { runId: result.runId, run: projectRun(result.run) },
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  //  Cancel
+  // -------------------------------------------------------------------------
+
+  router.post('/cancel/:runId', async (req, res) => {
+    const runId = req.params.runId;
+    const result = await job.cancelRun(db, runId);
+    if (!result.ok) return failure(res, result.reason);
+    const row = job.getRun(db, runId);
+    res.json({ ok: true, data: { run: projectRun(row) } });
+  });
+
+  // -------------------------------------------------------------------------
+  //  Project-level start + list
+  //
+  //  POST /api/execution/project/start
+  //    body: { project, scope, from?, to?, adviceKey, executor?, ephemeral? }
+  //
+  //  GET  /api/execution/project/advice
+  //    query: project, scope, from?, to?
+  //    response: { runsByAdviceKey: { 'cost.0': [run, …], … } }
+  // -------------------------------------------------------------------------
+
+  router.post('/project/start', async (req, res) => {
+    const { project, scope, from, to, adviceKey, executor, ephemeral } = req.body || {};
+    if (typeof project !== 'string' || !project.trim()) {
+      return res.status(400).json({
+        ok: false, error: { code: 'BAD_REQUEST', message: 'project required' },
+      });
+    }
+    if (typeof scope !== 'string' || !['daily', 'weekly', 'all'].includes(scope)) {
+      return res.status(400).json({
+        ok: false, error: { code: 'BAD_REQUEST', message: 'scope must be daily|weekly|all' },
+      });
+    }
+    if (typeof adviceKey !== 'string') {
+      return res.status(400).json({
+        ok: false, error: { code: 'BAD_REQUEST', message: 'adviceKey required' },
+      });
+    }
+    if (executor !== undefined && !VALID_EXECUTORS.includes(executor)) {
+      return res.status(400).json({
+        ok: false, error: { code: 'BAD_REQUEST', message: 'executor must be opencode or claude' },
+      });
+    }
+    const result = await job.startProjectExecution(db, {
+      project,
+      scope,
+      windowFrom: from || '',
+      windowTo:   to   || '',
+      adviceKey,
+      executor,
+      ephemeral: ephemeral === true || ephemeral === '1',
+    });
+    if (!result.ok) return failure(res, result.reason, result);
+    return res.status(201).json({
+      ok: true,
+      data: { runId: result.runId, run: projectRun(result.run) },
+    });
+  });
+
+  router.get('/project/advice', (req, res) => {
+    const project = req.query.project;
+    const scope   = req.query.scope;
+    const from    = req.query.from || '';
+    const to      = req.query.to   || '';
+    if (typeof project !== 'string' || !project.trim()) {
+      return res.status(400).json({
+        ok: false, error: { code: 'BAD_REQUEST', message: 'project required' },
+      });
+    }
+    if (typeof scope !== 'string' || !['daily', 'weekly', 'all'].includes(scope)) {
+      return res.status(400).json({
+        ok: false, error: { code: 'BAD_REQUEST', message: 'scope must be daily|weekly|all' },
+      });
+    }
+    const map = job.listRunsForProjectAdvice(db, project, scope, from, to);
+    const out = {};
+    for (const k of Object.keys(map)) {
+      out[k] = map[k].map((r) => projectRun(r));
+    }
+    res.json({ ok: true, data: { runsByAdviceKey: out } });
+  });
+
+  // -------------------------------------------------------------------------
+  //  Read one
+  // -------------------------------------------------------------------------
+
+  router.get('/advice/:sessionId', (req, res) => {
+    const sessionId = req.params.sessionId;
+    const map = job.listRunsForAdvice(db, sessionId);
+    const out = {};
+    for (const k of Object.keys(map)) {
+      out[k] = map[k].map((r) => projectRun(r));
+    }
+    res.json({ ok: true, data: { runsByAdviceKey: out } });
+  });
+
+  router.get('/:runId', (req, res) => {
+    const full = req.query.full === '1' || req.query.full === 'true';
+    const row = job.getRun(db, req.params.runId);
+    if (!row) {
+      return res.status(404).json({
+        ok: false, error: { code: 'NOT_FOUND', message: 'Run not found' },
+      });
+    }
+    res.json({ ok: true, data: { run: projectRun(row, { full }) } });
+  });
+
+  return router;
+};