@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/squad-dashboard/api.js

@@ -0,0 +1,223 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {
+  getSquadOverview,
+  getRecentContent,
+  getLearnings,
+  getRecentDeliveries,
+  getRecentEvents,
+  getSquadMetrics
+} = require('./metrics');
+const { getContextUsage } = require('./context-monitor');
+const { getTokenUsage } = require('./token-tracker');
+const { getActiveProcesses, stopProcess } = require('./process-monitor');
+const { getHunks, updateHunk, getReviewProgress, HUNK_STATES } = require('./hunk-review');
+const { generateRecovery, readRecovery } = require('../squad/recovery-context');
+const { getLogsForTask, getSessionLog } = require('./execution-logs');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+async function loadSquadList(projectDir) {
+  const squadsDir = path.join(projectDir, SQUADS_DIR);
+  let entries;
+  try {
+    entries = await fs.readdir(squadsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const squads = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const manifestPath = path.join(squadsDir, entry.name, 'squad.manifest.json');
+    try {
+      const raw = await fs.readFile(manifestPath, 'utf8');
+      const manifest = JSON.parse(raw);
+      squads.push({
+        slug: entry.name,
+        name: manifest.name || entry.name,
+        mode: manifest.mode || 'mixed',
+        goal: manifest.goal || '',
+        status: manifest.status || 'active',
+        executorCount: (manifest.executors || []).length,
+        manifest
+      });
+    } catch {
+      squads.push({
+        slug: entry.name,
+        name: entry.name,
+        mode: 'unknown',
+        goal: '',
+        status: 'unknown',
+        executorCount: 0,
+        manifest: null
+      });
+    }
+  }
+  return squads;
+}
+
+function detectPanels(manifest) {
+  const panels = ['overview', 'content', 'learnings', 'logs'];
+
+  if (manifest) {
+    if (manifest.mode === 'content') panels.push('content-preview');
+    if (manifest.mode === 'software') panels.push('tasks');
+
+    const hasWebhooks = manifest.outputStrategy &&
+      manifest.outputStrategy.delivery &&
+      Array.isArray(manifest.outputStrategy.delivery.webhooks) &&
+      manifest.outputStrategy.delivery.webhooks.length > 0;
+    const hasMcps = Array.isArray(manifest.mcps) && manifest.mcps.length > 0;
+    if (hasWebhooks || hasMcps) panels.push('integrations');
+
+    const channelMcps = (manifest.mcps || []).filter(function (m) {
+      return ['whatsapp', 'telegram', 'sms', 'voice'].some(function (ch) {
+        return (m.slug || '').includes(ch);
+      });
+    });
+    if (channelMcps.length > 0) panels.push('channels');
+  }
+
+  panels.push('metrics');
+  panels.push('processes');
+  return panels;
+}
+
+function loadSquadData(db, squadSlug) {
+  const overview = getSquadOverview(db, squadSlug);
+  const content = getRecentContent(db, squadSlug);
+  const learnings = getLearnings(db, squadSlug);
+  const deliveries = getRecentDeliveries(db, squadSlug);
+  const events = getRecentEvents(db, squadSlug);
+  const customMetrics = getSquadMetrics(db, squadSlug);
+
+  return {
+    overview,
+    content,
+    learnings,
+    deliveries,
+    events,
+    customMetrics,
+    pipelineInfo: overview.pipelineInfo,
+    metrics: {
+      content_items: overview.contentItems,
+      sessions: overview.sessions,
+      learnings: overview.learnings,
+      delivery_rate: overview.deliveryRate
+    }
+  };
+}
+
+/**
+ * GET /api/squads/:slug/context
+ * Returns context usage with warning levels for all agents in a squad.
+ */
+async function getContextData(projectDir, squadSlug, agentSlug) {
+  return getContextUsage(projectDir, squadSlug, agentSlug || null);
+}
+
+/**
+ * GET /api/squads/:slug/tokens?breakdown=true
+ * Returns token usage with cost estimates and waste flags.
+ */
+async function getTokenData(projectDir, squadSlug, breakdown) {
+  return getTokenUsage(projectDir, squadSlug, breakdown);
+}
+
+/**
+ * GET /api/processes[?squad=:slug]
+ * Returns active agent processes across all squads (or filtered by squad).
+ */
+async function getProcesses(projectDir, squadSlug) {
+  return getActiveProcesses(projectDir, squadSlug || null);
+}
+
+/**
+ * POST /api/processes/:pid/stop
+ * Sends SIGTERM to the process and removes its process file.
+ */
+async function stopProcessById(projectDir, pid) {
+  return stopProcess(projectDir, pid);
+}
+
+/**
+ * GET /api/tasks/:id/hunks
+ * Returns hunk review state for a task.
+ * Requires squadSlug and optionally diff (to init on first call).
+ */
+async function getTaskHunks(projectDir, squadSlug, taskId, diff) {
+  return getHunks(projectDir, squadSlug, taskId, diff || null);
+}
+
+/**
+ * POST /api/tasks/:id/hunks/:hunkId/approve
+ */
+async function approveHunk(projectDir, squadSlug, taskId, hunkId) {
+  return updateHunk(projectDir, squadSlug, taskId, hunkId, HUNK_STATES.APPROVED, null);
+}
+
+/**
+ * POST /api/tasks/:id/hunks/:hunkId/reject
+ */
+async function rejectHunk(projectDir, squadSlug, taskId, hunkId, comment) {
+  return updateHunk(projectDir, squadSlug, taskId, hunkId, HUNK_STATES.REJECTED, comment || null);
+}
+
+/**
+ * POST /api/tasks/:id/hunks/:hunkId/comment
+ */
+async function commentHunk(projectDir, squadSlug, taskId, hunkId, comment) {
+  return updateHunk(projectDir, squadSlug, taskId, hunkId, HUNK_STATES.REVISED, comment || null);
+}
+
+/**
+ * GET /api/squads/:slug/agents/:agent/recovery
+ * Returns the recovery-context.md for an agent (generates if missing).
+ */
+async function getAgentRecovery(projectDir, squadSlug, agentSlug) {
+  // Try to read existing first
+  const existing = await readRecovery(projectDir, squadSlug);
+  if (existing) return { ok: true, content: existing, squadSlug, agentSlug };
+  // Generate on demand
+  const result = await generateRecovery(projectDir, squadSlug, agentSlug);
+  if (!result.ok) return result;
+  const content = await readRecovery(projectDir, squadSlug);
+  return { ok: true, content, squadSlug, agentSlug, tokens: result.tokens };
+}
+
+/**
+ * GET /api/squads/:slug/tasks/:taskId/logs
+ * Returns all session logs for a task, sorted oldest-first.
+ */
+async function getTaskLogs(projectDir, squadSlug, taskId) {
+  return getLogsForTask(projectDir, squadSlug, taskId);
+}
+
+/**
+ * GET /api/squads/:slug/tasks/:taskId/logs/:sessionId
+ * Returns a single session log by sessionId.
+ */
+async function getTaskSessionLog(projectDir, squadSlug, taskId, sessionId) {
+  return getSessionLog(projectDir, squadSlug, taskId, sessionId);
+}
+
+module.exports = {
+  loadSquadList,
+  detectPanels,
+  loadSquadData,
+  getContextData,
+  getTokenData,
+  getProcesses,
+  stopProcessById,
+  getTaskHunks,
+  approveHunk,
+  rejectHunk,
+  commentHunk,
+  getAgentRecovery,
+  getReviewProgress,
+  getTaskLogs,
+  getTaskSessionLog
+};

package/src/squad-dashboard/attachment-handler.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg']);
+
+const MIME_MAP = {
+  '.png':  'image/png',
+  '.jpg':  'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif':  'image/gif',
+  '.webp': 'image/webp',
+  '.svg':  'image/svg+xml',
+  '.pdf':  'application/pdf',
+  '.txt':  'text/plain',
+  '.md':   'text/markdown',
+  '.json': 'application/json'
+};
+
+function attachmentsDir(projectDir, squadSlug) {
+  return path.join(projectDir, SQUADS_DIR, squadSlug, 'attachments');
+}
+
+function safeName(filename) {
+  return path.basename(filename).replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+
+/**
+ * Save a Buffer or string as an attachment.
+ * Returns { ok, filename, filePath, isImage }.
+ */
+async function saveAttachment(projectDir, squadSlug, filename, buffer) {
+  const dir = attachmentsDir(projectDir, squadSlug);
+  await fs.mkdir(dir, { recursive: true });
+  const safe = safeName(filename);
+  const dest = path.join(dir, safe);
+  await fs.writeFile(dest, buffer);
+  const ext = path.extname(safe).toLowerCase();
+  return { ok: true, filePath: dest, filename: safe, isImage: IMAGE_EXTS.has(ext) };
+}
+
+/**
+ * List all attachments for a squad.
+ * Returns array of { filename, filePath, isImage, mime, size }.
+ */
+async function listAttachments(projectDir, squadSlug) {
+  const dir = attachmentsDir(projectDir, squadSlug);
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const result = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const ext = path.extname(entry.name).toLowerCase();
+    let size = 0;
+    try {
+      const stat = await fs.stat(path.join(dir, entry.name));
+      size = stat.size;
+    } catch { /* ignore */ }
+    result.push({
+      filename: entry.name,
+      filePath: path.join(dir, entry.name),
+      isImage: IMAGE_EXTS.has(ext),
+      mime: MIME_MAP[ext] || 'application/octet-stream',
+      size
+    });
+  }
+  return result;
+}
+
+/**
+ * Read an attachment file for serving (e.g. inline image preview).
+ * Returns { ok, buffer, mime, filename } or { ok: false }.
+ */
+async function readAttachment(projectDir, squadSlug, filename) {
+  const safe = safeName(filename);
+  const filePath = path.join(attachmentsDir(projectDir, squadSlug), safe);
+  try {
+    const buffer = await fs.readFile(filePath);
+    const ext = path.extname(safe).toLowerCase();
+    return { ok: true, buffer, mime: MIME_MAP[ext] || 'application/octet-stream', filename: safe };
+  } catch {
+    return { ok: false };
+  }
+}
+
+module.exports = { saveAttachment, listAttachments, readAttachment, IMAGE_EXTS, MIME_MAP };

package/src/squad-dashboard/context-monitor.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { generateRecovery, shouldRefreshOnEvent } = require('../squad/recovery-context');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+// Minimum ratio drop between consecutive measurements to be considered a compact
+const COMPACT_DROP_THRESHOLD = 0.30;
+
+// Warning level thresholds (ratio of used/windowSize)
+const THRESHOLDS = { warning: 0.85, critical: 0.95 };
+
+// Notification event types (dispatched by caller when notification system is available)
+const EVENTS = {
+  CONTEXT_WARNING: 'context_warning',
+  CONTEXT_CRITICAL: 'context_critical'
+};
+
+// Context categories (6) — order determines donut segment order
+const CATEGORIES = [
+  'system_prompt',
+  'conversation_history',
+  'tool_outputs',
+  'files_loaded',
+  'inline_data',
+  'other'
+];
+
+function computeWarningLevel(used, windowSize) {
+  if (!windowSize || windowSize <= 0) return 'unknown';
+  const ratio = used / windowSize;
+  if (ratio >= 1.0) return 'overflow';
+  if (ratio >= THRESHOLDS.critical) return 'critical';
+  if (ratio >= THRESHOLDS.warning) return 'warning';
+  return 'normal';
+}
+
+/**
+ * Read context-monitor.json for a squad and compute warning levels.
+ * @param {string} projectDir
+ * @param {string} squadSlug
+ * @param {string|null} agentSlug  — if set, return only that agent
+ * @returns {object|null}
+ */
+async function getContextUsage(projectDir, squadSlug, agentSlug) {
+  const filePath = path.join(projectDir, SQUADS_DIR, squadSlug, 'context-monitor.json');
+  let data;
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+
+  const agents = data.agents || {};
+
+  if (agentSlug) {
+    const agent = agents[agentSlug];
+    if (!agent) return null;
+    const warningLevel = computeWarningLevel(agent.totalUsed || 0, agent.windowSize || 0);
+    return { squadSlug, agentSlug, ...agent, warningLevel };
+  }
+
+  const enrichedAgents = {};
+  for (const [slug, agent] of Object.entries(agents)) {
+    enrichedAgents[slug] = {
+      ...agent,
+      warningLevel: computeWarningLevel(agent.totalUsed || 0, agent.windowSize || 0)
+    };
+  }
+  return { squadSlug, agents: enrichedAgents, updatedAt: data.updatedAt };
+}
+
+/**
+ * Return pending notification events for a context snapshot.
+ * Caller dispatches these once the notification system exists.
+ */
+function checkNotificationEvents(squadSlug, contextData) {
+  if (!contextData || !contextData.agents) return [];
+  const events = [];
+  for (const [agentSlug, agent] of Object.entries(contextData.agents)) {
+    if (agent.warningLevel === 'critical' || agent.warningLevel === 'overflow') {
+      events.push({ type: EVENTS.CONTEXT_CRITICAL, squadSlug, agentSlug, warningLevel: agent.warningLevel });
+    } else if (agent.warningLevel === 'warning') {
+      events.push({ type: EVENTS.CONTEXT_WARNING, squadSlug, agentSlug, warningLevel: agent.warningLevel });
+    }
+  }
+  return events;
+}
+
+/**
+ * Detect if a context compact occurred between two consecutive measurements.
+ * A compact is inferred when totalUsed drops by > 30% from the previous snapshot.
+ * @param {number} prevUsed   — previous totalUsed value
+ * @param {number} currUsed   — current totalUsed value
+ * @returns {boolean}
+ */
+function isCompactDetected(prevUsed, currUsed) {
+  if (!prevUsed || prevUsed <= 0) return false;
+  const drop = (prevUsed - currUsed) / prevUsed;
+  return drop > COMPACT_DROP_THRESHOLD;
+}
+
+/**
+ * Compare two context-monitor snapshots and trigger recovery injection if a
+ * compact is detected for any agent.
+ *
+ * @param {string} projectDir
+ * @param {string} squadSlug
+ * @param {object} prevData   — previous result from getContextUsage (or null)
+ * @param {object} currData   — current result from getContextUsage
+ * @returns {Array<{agentSlug, recovery}>}  list of recovery results triggered
+ */
+async function checkAndInjectRecovery(projectDir, squadSlug, prevData, currData) {
+  if (!prevData || !currData) return [];
+  const prevAgents = prevData.agents || {};
+  const currAgents = currData.agents || {};
+  const triggered = [];
+
+  for (const [agentSlug, curr] of Object.entries(currAgents)) {
+    const prev = prevAgents[agentSlug];
+    if (!prev) continue;
+    if (isCompactDetected(prev.totalUsed || 0, curr.totalUsed || 0)) {
+      const recovery = await generateRecovery(projectDir, squadSlug, agentSlug);
+      triggered.push({ agentSlug, recovery });
+    }
+  }
+
+  return triggered;
+}
+
+/**
+ * Optionally trigger a recovery refresh when a specific runtime event fires.
+ * @param {string} projectDir
+ * @param {string} squadSlug
+ * @param {string} agentSlug
+ * @param {string} eventType
+ */
+async function onRuntimeEvent(projectDir, squadSlug, agentSlug, eventType) {
+  if (!shouldRefreshOnEvent(eventType)) return null;
+  return generateRecovery(projectDir, squadSlug, agentSlug);
+}
+
+module.exports = {
+  getContextUsage,
+  computeWarningLevel,
+  checkNotificationEvents,
+  isCompactDetected,
+  checkAndInjectRecovery,
+  onRuntimeEvent,
+  CATEGORIES,
+  EVENTS,
+  THRESHOLDS,
+  COMPACT_DROP_THRESHOLD
+};

package/src/squad-dashboard/execution-logs.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+const ENTRY_TYPES = {
+  TOOL_CALL:  'tool_call',
+  REASONING:  'reasoning',
+  MILESTONE:  'milestone',
+  ERROR:      'error'
+};
+
+/**
+ * Session log file schema:
+ * {
+ *   agentSlug: string,
+ *   taskId: string,
+ *   startedAt: ISO string,
+ *   summary: string | null,
+ *   entries: Array<{
+ *     type: 'tool_call' | 'reasoning' | 'milestone' | 'error',
+ *     timestamp: ISO string,
+ *     // tool_call
+ *     toolName?: string,
+ *     input?: any,
+ *     output?: any,
+ *     durationMs?: number,
+ *     // reasoning
+ *     text?: string,
+ *     // milestone
+ *     label?: string,
+ *     // error
+ *     message?: string,
+ *     stack?: string
+ *   }>
+ * }
+ *
+ * File path: .aioson/squads/{slug}/logs/{task-id}/session-{timestamp}.json
+ */
+
+function logsDir(projectDir, squadSlug, taskId) {
+  return path.join(projectDir, SQUADS_DIR, squadSlug, 'logs', taskId);
+}
+
+async function listSessionFiles(projectDir, squadSlug, taskId) {
+  const dir = logsDir(projectDir, squadSlug, taskId);
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return [];
+  }
+  return entries
+    .filter(f => f.startsWith('session-') && f.endsWith('.json'))
+    .map(f => {
+      const ts = f.replace(/^session-/, '').replace(/\.json$/, '');
+      return { sessionId: f.replace('.json', ''), filename: f, timestamp: ts, filePath: path.join(dir, f) };
+    })
+    .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+
+/**
+ * Returns all sessions (with entries) for a given task, sorted oldest-first.
+ */
+async function getLogsForTask(projectDir, squadSlug, taskId) {
+  const files = await listSessionFiles(projectDir, squadSlug, taskId);
+  const sessions = [];
+  for (const file of files) {
+    try {
+      const raw = await fs.readFile(file.filePath, 'utf8');
+      const session = JSON.parse(raw);
+      sessions.push({
+        sessionId: file.sessionId,
+        timestamp: file.timestamp,
+        taskId,
+        squadSlug,
+        agentSlug: session.agentSlug || null,
+        startedAt: session.startedAt || file.timestamp,
+        summary: session.summary || null,
+        entries: session.entries || []
+      });
+    } catch {
+      sessions.push({
+        sessionId: file.sessionId,
+        timestamp: file.timestamp,
+        taskId,
+        squadSlug,
+        agentSlug: null,
+        startedAt: file.timestamp,
+        summary: null,
+        entries: [],
+        parseError: true
+      });
+    }
+  }
+  return sessions;
+}
+
+/**
+ * Returns a single session log by sessionId (filename without .json).
+ */
+async function getSessionLog(projectDir, squadSlug, taskId, sessionId) {
+  const dir = logsDir(projectDir, squadSlug, taskId);
+  const filePath = path.join(dir, `${sessionId}.json`);
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { ENTRY_TYPES, getLogsForTask, getSessionLog };