agentboss 0.1.0

package/server/api/project.js

@@ -0,0 +1,255 @@
+/**
+ * Project detail + project-level AI advice API.
+ *
+ * Routes
+ * ------
+ *   GET  /api/project/:key                         basic meta + sessions in window
+ *   GET  /api/project/:key/advice                  read cached project_advice
+ *   POST /api/project/:key/advice  body { force }  trigger generation
+ *
+ * The `:key` path param is the URL-encoded project path (raw or canonical;
+ * the server canonicalises before any lookup).  Windows-friendly via
+ * encodeURIComponent on the client side.
+ *
+ * Query params on the GET routes select the time window:
+ *   scope=daily|weekly|all                          (default 'all')
+ *   from=YYYY-MM-DD  to=YYYY-MM-DD                  required when scope!=all
+ *
+ * Failure reasons from server/llm/project-advice.js are mapped to
+ * HTTP codes mirroring /api/advice's table.
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const router = require('express').Router();
+
+const {
+  generateProjectAdvice,
+  loadProjectAdvice,
+  listProjectAdviceCaches,
+  resolveProjectSessions,
+  attachSessionAdvice,
+} = require('../llm/project-advice');
+const { canonicalProject } = require('../utils/project');
+const { queryOne } = require('../db/queries');
+
+// ---------------------------------------------------------------------------
+//  Reason → HTTP
+// ---------------------------------------------------------------------------
+
+const REASON_TO_STATUS = {
+  'no-project':         400,
+  'no-window':          400,
+  'no-sessions':        404,
+  'no-session-advice':  409,
+  'llm-disabled':       409,
+  'no-cli':             409,
+  'timeout':            504,
+  'bad-json':           502,
+  'spawn-error':        500,
+  'exit-non-zero':      500,
+  'internal':           500,
+};
+
+const REASON_TO_MESSAGE = {
+  'no-project':        '缺少 project',
+  'no-window':         '该 scope 需要 from/to',
+  'no-sessions':       '该时间段内项目没有任何会话',
+  'no-session-advice': '该项目下没有任何 session 已经生成单会话 advice;请先在 session 详情页生成',
+  'llm-disabled':      'LLM judging is disabled in settings',
+  'no-cli':            'No opencode/claude CLI detected on PATH',
+  'timeout':           'LLM call timed out',
+  'bad-json':          'LLM returned non-JSON output',
+  'spawn-error':       'Failed to spawn LLM CLI',
+  'exit-non-zero':     'LLM CLI exited with a non-zero status',
+  'internal':          'Internal project-advice generation 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.meta) body.meta = extra.meta;
+  return res.status(status).json(body);
+}
+
+// ---------------------------------------------------------------------------
+//  Window resolver — derives a concrete from/to from query string
+// ---------------------------------------------------------------------------
+
+function resolveWindow(query) {
+  const scope = (query.scope || 'all').toLowerCase();
+  if (scope === 'all') return { scope, windowFrom: '', windowTo: '' };
+  const from = query.from || '';
+  const to   = query.to   || '';
+  if (!from || !to) return null;
+  return { scope, windowFrom: from, windowTo: to };
+}
+
+// ---------------------------------------------------------------------------
+//  Routes
+// ---------------------------------------------------------------------------
+
+module.exports = function (db) {
+  // GET /api/project/:key — meta, stats, and session list under this project.
+  router.get('/:key', (req, res) => {
+    const project = canonicalProject(decodeURIComponent(req.params.key || ''));
+    if (!project) return failure(res, 'no-project');
+    const window = resolveWindow(req.query);
+    if (!window) return failure(res, 'no-window');
+
+    const raw = resolveProjectSessions(
+      db, project, window.windowFrom, window.windowTo
+    );
+    const enriched = attachSessionAdvice(db, raw);
+
+    // Stats are computed across the FULL set including subagents — the
+    // money / errors / advice-eligibility numbers should match what the
+    // user actually spent / generated.  The session list rendered to the
+    // UI below filters subagents out.
+    let cost = 0, errors = 0, withAdvice = 0;
+    for (const s of enriched) {
+      cost += Number(s.cost) || 0;
+      errors += Number(s.errorCount) || 0;
+      if (s.advice && s.advice.categories) withAdvice++;
+    }
+    const topLevel = enriched.filter((s) => !s.parentSessionId);
+    const subagentCount = enriched.length - topLevel.length;
+
+    // Earliest/latest dates seen across all unified_session rows for this
+    // project (regardless of the requested window) — used by the UI to show
+    // "项目首次出现 / 最近活跃".
+    const span = queryOne(
+      db,
+      // We can't filter by canonical project in SQL cheaply, so range across
+      // anything LIKE-ish then ignore false positives via canonicalProject
+      // — but for the *summary numbers* it's fine to scope to the same
+      // resolveProjectSessions output.
+      `SELECT MIN(started_at) AS first_at, MAX(started_at) AS last_at
+         FROM unified_session
+        WHERE id IN (${raw.map(() => '?').join(',') || 'NULL'})`,
+      raw.map((r) => r.id)
+    );
+
+    return res.json({
+      ok: true,
+      data: {
+        project,
+        scope: window.scope,
+        windowFrom: window.windowFrom,
+        windowTo: window.windowTo,
+        // sessionCount = full count (incl. subagents) so stats match
+        // up; sessionsCountTopLevel = what the listed table shows.
+        sessionCount: enriched.length,
+        sessionsCountTopLevel: topLevel.length,
+        subagentCount,
+        sessionsWithAdvice: withAdvice,
+        missingAdvice: enriched.length - withAdvice,
+        cost: Math.round(cost * 10000) / 10000,
+        errors,
+        firstActivityAt: span ? span.first_at : null,
+        lastActivityAt:  span ? span.last_at  : null,
+        sessions: topLevel.map((s) => ({
+          id: s.id,
+          title: s.title,
+          model: s.model,
+          date: s.date,
+          cost: Math.round((s.cost || 0) * 10000) / 10000,
+          msgCount: s.msgCount,
+          errorCount: s.errorCount,
+          hasAdvice: !!(s.advice && s.advice.categories),
+        })),
+      },
+      meta: { generated_at: new Date().toISOString() },
+    });
+  });
+
+  // GET /api/project/:key/advice/index
+  //   Compact list of every (scope, window_from, window_to) for which a
+  //   project_advice cache exists.  The UI uses it to pick a default
+  //   window that actually has data (avoids "looks empty after reload"
+  //   when the cached window doesn't match the default).
+  router.get('/:key/advice/index', (req, res) => {
+    const project = canonicalProject(decodeURIComponent(req.params.key || ''));
+    if (!project) return failure(res, 'no-project');
+    const caches = listProjectAdviceCaches(db, project);
+    res.json({
+      ok: true,
+      data: { project, caches },
+      meta: { generated_at: new Date().toISOString() },
+    });
+  });
+
+  // GET /api/project/:key/advice — read cached project_advice; never spawns CLI.
+  router.get('/:key/advice', (req, res) => {
+    const project = canonicalProject(decodeURIComponent(req.params.key || ''));
+    if (!project) return failure(res, 'no-project');
+    const window = resolveWindow(req.query);
+    if (!window) return failure(res, 'no-window');
+
+    const cached = loadProjectAdvice(
+      db, project, window.scope, window.windowFrom, window.windowTo
+    );
+    return res.json({
+      ok: true,
+      data: cached
+        ? {
+            project,
+            scope: window.scope,
+            windowFrom: window.windowFrom,
+            windowTo: window.windowTo,
+            advice: cached.payload,
+            sessionCount: cached.sessionCount,
+            cachedAt: cached.cachedAt,
+            cli: cached.cli,
+            fromCache: true,
+          }
+        : {
+            project,
+            scope: window.scope,
+            windowFrom: window.windowFrom,
+            windowTo: window.windowTo,
+            advice: null,
+            fromCache: false,
+            cachedAt: null,
+            cli: null,
+          },
+      meta: { generated_at: new Date().toISOString() },
+    });
+  });
+
+  // POST /api/project/:key/advice  body { force?: boolean }
+  router.post('/:key/advice', async (req, res) => {
+    const project = canonicalProject(decodeURIComponent(req.params.key || ''));
+    if (!project) return failure(res, 'no-project');
+    const window = resolveWindow(req.query);
+    if (!window) return failure(res, 'no-window');
+    const force = req.body?.force === true || req.body?.force === '1';
+
+    try {
+      const result = await generateProjectAdvice(db, {
+        project,
+        scope: window.scope,
+        windowFrom: window.windowFrom,
+        windowTo: window.windowTo,
+        force,
+      });
+      if (!result.ok) return failure(res, result.reason, result);
+
+      return res.json({
+        ok: true,
+        data: result.data,
+        meta: { generated_at: new Date().toISOString() },
+      });
+    } catch (err) {
+      return failure(res, 'internal', { error: err && err.message });
+    }
+  });
+
+  return router;
+};

package/server/api/reports.js

@@ -0,0 +1,125 @@
+/**
+ * Report API routes for Agent Boss.
+ *
+ * Provides endpoints for yesterday, weekly, monthly, and session-detail
+ * reports built from analyzed boss.db data.
+ *
+ * @author Felix
+ */
+
+const router = require('express').Router();
+
+const {
+  buildYesterdayReport,
+  buildWeeklyReport,
+  buildSessionDetail,
+} = require('../analysis/report-builder');
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Return the Monday (YYYY-MM-DD) of the current ISO week.
+ * @returns {string}
+ */
+function currentWeekMonday() {
+  const d = new Date();
+  const day = d.getDay(); // 0=Sun … 6=Sat
+  const diff = day === 0 ? 6 : day - 1;
+  d.setDate(d.getDate() - diff);
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${dd}`;
+}
+
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+
+/**
+ * Create the reports router with database access.
+ *
+ * @param {object} db  sql.js Database instance
+ * @returns {import('express').Router}
+ */
+module.exports = function (db) {
+  // GET /api/reports/yesterday
+  router.get('/yesterday', (_req, res) => {
+    try {
+      const data = buildYesterdayReport(db);
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from: data.date, to: data.date },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'REPORT_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/reports/weekly?week=YYYY-MM-DD
+  router.get('/weekly', (req, res) => {
+    try {
+      const weekStart = req.query.week || currentWeekMonday();
+      const data = buildWeeklyReport(db, weekStart);
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from: data.weekStart, to: data.weekEnd },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'REPORT_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/reports/monthly?month=YYYY-MM
+  router.get('/monthly', (_req, res) => {
+    res.json({
+      ok: true,
+      data: null,
+      message: 'Coming soon',
+    });
+  });
+
+  // GET /api/reports/session/:id
+  router.get('/session/:id', (req, res) => {
+    try {
+      const data = buildSessionDetail(db, req.params.id);
+      if (!data) {
+        return res.status(404).json({
+          ok: false,
+          error: { code: 'NOT_FOUND', message: 'Session not found' },
+        });
+      }
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from: data.date, to: data.date },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'REPORT_ERROR', message: err.message },
+      });
+    }
+  });
+
+  return router;
+};

package/server/api/sessions.js

@@ -0,0 +1,118 @@
+/**
+ * Session API routes for Agent Boss.
+ *
+ * Provides endpoints for fetching individual session details, messages,
+ * and tool calls.
+ *
+ * @author Felix
+ */
+
+const router = require('express').Router();
+
+const {
+  getSessionById,
+  getAnalysisBySession,
+  getMessagesBySession,
+  getToolCallsBySession,
+} = require('../db/queries');
+
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+
+/**
+ * Create the sessions router with database access.
+ *
+ * @param {object} db  sql.js Database instance
+ * @returns {import('express').Router}
+ */
+module.exports = function (db) {
+  // GET /api/sessions/:id
+  router.get('/:id', (req, res) => {
+    try {
+      const session = getSessionById(db, req.params.id);
+      if (!session) {
+        return res.status(404).json({
+          ok: false,
+          error: { code: 'NOT_FOUND', message: 'Session not found' },
+        });
+      }
+
+      const analysis = getAnalysisBySession(db, req.params.id);
+
+      res.json({
+        ok: true,
+        data: { session, analysis },
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from: session.date, to: session.date },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'SESSION_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/sessions/:id/messages
+  router.get('/:id/messages', (req, res) => {
+    try {
+      const session = getSessionById(db, req.params.id);
+      if (!session) {
+        return res.status(404).json({
+          ok: false,
+          error: { code: 'NOT_FOUND', message: 'Session not found' },
+        });
+      }
+
+      const data = getMessagesBySession(db, req.params.id);
+
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from: session.date, to: session.date },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'SESSION_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/sessions/:id/tools
+  router.get('/:id/tools', (req, res) => {
+    try {
+      const session = getSessionById(db, req.params.id);
+      if (!session) {
+        return res.status(404).json({
+          ok: false,
+          error: { code: 'NOT_FOUND', message: 'Session not found' },
+        });
+      }
+
+      const data = getToolCallsBySession(db, req.params.id);
+
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from: session.date, to: session.date },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'SESSION_ERROR', message: err.message },
+      });
+    }
+  });
+
+  return router;
+};

package/server/api/settings.js

@@ -0,0 +1,119 @@
+/**
+ * Settings API routes for Agent Boss.
+ *
+ * Provides endpoints for reading/writing user settings and listing
+ * tool configurations (data source status).
+ *
+ * @author Felix
+ */
+
+const router = require('express').Router();
+
+const {
+  getAllSettings,
+  setSetting,
+  getAllToolConfigs,
+} = require('../db/queries');
+const { diagnose: diagnoseLlm, invalidateSettingsCache } = require('../llm/judge');
+
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+
+/**
+ * Create the settings router with database access.
+ *
+ * @param {object} db  sql.js Database instance
+ * @returns {import('express').Router}
+ */
+module.exports = function (db) {
+  // GET /api/settings
+  router.get('/', (_req, res) => {
+    try {
+      const settings = getAllSettings(db);
+      const tools = getAllToolConfigs(db);
+
+      res.json({
+        ok: true,
+        data: { settings, tools },
+        meta: {
+          generated_at: new Date().toISOString(),
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'SETTINGS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // PUT /api/settings
+  router.put('/', (req, res) => {
+    try {
+      const body = req.body;
+      if (!body || typeof body !== 'object') {
+        return res.status(400).json({
+          ok: false,
+          error: { code: 'BAD_REQUEST', message: 'Request body must be a JSON object of {key: value} pairs' },
+        });
+      }
+
+      const keys = Object.keys(body);
+      for (const key of keys) {
+        setSetting(db, key, String(body[key]));
+      }
+
+      // v2: invalidate the LLM-judge settings cache so the toggle takes
+      // effect on the very next analysis pass.
+      if (keys.includes('enable_llm_judge')) invalidateSettingsCache();
+
+      const settings = getAllSettings(db);
+
+      res.json({
+        ok: true,
+        data: { settings, updated: keys },
+        meta: {
+          generated_at: new Date().toISOString(),
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'SETTINGS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/settings/llm/diagnose — detect available CLI for LLM judge.
+  router.get('/llm/diagnose', async (_req, res) => {
+    try {
+      const info = await diagnoseLlm();
+      res.json({ ok: true, data: info, meta: { generated_at: new Date().toISOString() } });
+    } catch (err) {
+      res.status(500).json({ ok: false, error: { code: 'LLM_DIAGNOSE_ERROR', message: err.message } });
+    }
+  });
+
+  // GET /api/settings/tools
+  router.get('/tools', (_req, res) => {
+    try {
+      const data = getAllToolConfigs(db);
+
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'SETTINGS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  return router;
+};