@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/squad-dashboard/hunk-review.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+// Valid hunk states
+const HUNK_STATES = { PENDING: 'pending', APPROVED: 'approved', REJECTED: 'rejected', REVISED: 'revised' };
+
+/**
+ * Parse a unified diff string into individual hunks.
+ * Each hunk includes its header, lines, and a stable id.
+ *
+ * @param {string} diff  — full unified diff text
+ * @returns {Array<{id, fileHeader, header, lines, additions, deletions}>}
+ */
+function parseDiffHunks(diff) {
+  if (!diff || typeof diff !== 'string') return [];
+
+  const hunks = [];
+  let currentFile = '';
+  let currentHunk = null;
+  let hunkIndex = 0;
+
+  for (const rawLine of diff.split('\n')) {
+    // File header lines
+    if (rawLine.startsWith('--- ') || rawLine.startsWith('+++ ')) {
+      if (rawLine.startsWith('+++ ')) {
+        // Strip b/ prefix from git diffs
+        currentFile = rawLine.slice(4).replace(/^b\//, '').trim();
+      }
+      if (currentHunk) {
+        hunks.push(finalizeHunk(currentHunk));
+        currentHunk = null;
+      }
+      continue;
+    }
+
+    // Hunk header: @@ -a,b +c,d @@
+    if (rawLine.startsWith('@@ ')) {
+      if (currentHunk) {
+        hunks.push(finalizeHunk(currentHunk));
+      }
+      currentHunk = {
+        id: `hunk-${hunkIndex++}`,
+        fileHeader: currentFile,
+        header: rawLine,
+        lines: [],
+        additions: 0,
+        deletions: 0
+      };
+      continue;
+    }
+
+    if (currentHunk) {
+      currentHunk.lines.push(rawLine);
+      if (rawLine.startsWith('+') && !rawLine.startsWith('+++')) currentHunk.additions++;
+      if (rawLine.startsWith('-') && !rawLine.startsWith('---')) currentHunk.deletions++;
+    }
+  }
+
+  if (currentHunk) hunks.push(finalizeHunk(currentHunk));
+  return hunks;
+}
+
+function finalizeHunk(hunk) {
+  return {
+    id: hunk.id,
+    fileHeader: hunk.fileHeader,
+    header: hunk.header,
+    lines: hunk.lines,
+    additions: hunk.additions,
+    deletions: hunk.deletions
+  };
+}
+
+/**
+ * Resolve the hunk-review state file path for a task.
+ */
+function hunkStatePath(projectDir, squadSlug, taskId) {
+  return path.join(projectDir, SQUADS_DIR, squadSlug, 'tasks', taskId, 'hunk-review.json');
+}
+
+/**
+ * Load hunk review state for a task. Returns null if not found.
+ */
+async function loadHunkState(projectDir, squadSlug, taskId) {
+  try {
+    const raw = await fs.readFile(hunkStatePath(projectDir, squadSlug, taskId), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save hunk review state for a task.
+ */
+async function saveHunkState(projectDir, squadSlug, taskId, state) {
+  const p = hunkStatePath(projectDir, squadSlug, taskId);
+  await fs.mkdir(path.dirname(p), { recursive: true });
+  await fs.writeFile(p, JSON.stringify(state, null, 2), 'utf8');
+}
+
+/**
+ * Initialize hunk review state from a diff string.
+ * Returns the initial state object (persisted to disk).
+ */
+async function initHunkReview(projectDir, squadSlug, taskId, diff) {
+  const hunks = parseDiffHunks(diff);
+  const state = {
+    taskId,
+    squadSlug,
+    diff,
+    hunks: hunks.map(h => ({
+      id: h.id,
+      fileHeader: h.fileHeader,
+      header: h.header,
+      lines: h.lines,
+      additions: h.additions,
+      deletions: h.deletions,
+      status: HUNK_STATES.PENDING,
+      comment: null,
+      reviewedAt: null
+    })),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  await saveHunkState(projectDir, squadSlug, taskId, state);
+  return state;
+}
+
+/**
+ * Get current hunk review state (or init from diff if missing).
+ */
+async function getHunks(projectDir, squadSlug, taskId, diff) {
+  let state = await loadHunkState(projectDir, squadSlug, taskId);
+  if (!state && diff) {
+    state = await initHunkReview(projectDir, squadSlug, taskId, diff);
+  }
+  return state;
+}
+
+/**
+ * Update the status of a single hunk.
+ * @param {string} newStatus  — one of HUNK_STATES values
+ * @param {string|null} comment
+ * @returns {{ state, dispatch: string|null }}
+ *   dispatch is 'task_done' | 'task_needs_revision' | null based on overall state after update
+ */
+async function updateHunk(projectDir, squadSlug, taskId, hunkId, newStatus, comment) {
+  const state = await loadHunkState(projectDir, squadSlug, taskId);
+  if (!state) return { ok: false, error: 'No hunk review state found' };
+
+  const hunk = state.hunks.find(h => h.id === hunkId);
+  if (!hunk) return { ok: false, error: `Hunk "${hunkId}" not found` };
+
+  hunk.status = newStatus;
+  if (comment !== undefined && comment !== null) hunk.comment = comment;
+  hunk.reviewedAt = new Date().toISOString();
+  state.updatedAt = new Date().toISOString();
+
+  await saveHunkState(projectDir, squadSlug, taskId, state);
+
+  const dispatch = computeDispatch(state.hunks);
+  return { ok: true, hunk, dispatch, state };
+}
+
+/**
+ * Compute the dispatch event based on all hunk statuses.
+ * Returns: 'task_done' if all approved, 'task_needs_revision' if any rejected,
+ *          null if still pending.
+ */
+function computeDispatch(hunks) {
+  const allReviewed = hunks.every(h => h.status !== HUNK_STATES.PENDING);
+  if (!allReviewed) return null;
+
+  const rejectedHunks = hunks.filter(h => h.status === HUNK_STATES.REJECTED);
+  if (rejectedHunks.length > 0) {
+    return { event: 'task_needs_revision', rejectedHunks: rejectedHunks.map(h => h.id) };
+  }
+
+  return { event: 'task_done' };
+}
+
+/**
+ * Get a summary of review progress: total, approved, rejected, pending.
+ */
+function getReviewProgress(hunks) {
+  return {
+    total: hunks.length,
+    approved: hunks.filter(h => h.status === HUNK_STATES.APPROVED).length,
+    rejected: hunks.filter(h => h.status === HUNK_STATES.REJECTED).length,
+    revised: hunks.filter(h => h.status === HUNK_STATES.REVISED).length,
+    pending: hunks.filter(h => h.status === HUNK_STATES.PENDING).length
+  };
+}
+
+module.exports = {
+  parseDiffHunks,
+  initHunkReview,
+  getHunks,
+  updateHunk,
+  loadHunkState,
+  computeDispatch,
+  getReviewProgress,
+  HUNK_STATES
+};

package/src/squad-dashboard/metrics.js

@@ -0,0 +1,133 @@
+'use strict';
+
+function countContentItems(db, squadSlug) {
+  const row = db.prepare('SELECT COUNT(*) AS cnt FROM content_items WHERE squad_slug = ?').get(squadSlug);
+  return row ? row.cnt : 0;
+}
+
+function countSessions(db, squadSlug) {
+  const row = db.prepare(
+    "SELECT COUNT(*) AS cnt FROM tasks WHERE meta_json LIKE ? AND task_kind = 'live_session'"
+  ).get(`%${squadSlug}%`);
+  return row ? row.cnt : 0;
+}
+
+function countLearnings(db, squadSlug) {
+  const row = db.prepare('SELECT COUNT(*) AS cnt FROM squad_learnings WHERE squad_slug = ?').get(squadSlug);
+  return row ? row.cnt : 0;
+}
+
+function calcDeliveryRate(db, squadSlug) {
+  const total = db.prepare('SELECT COUNT(*) AS cnt FROM delivery_log WHERE squad_slug = ?').get(squadSlug);
+  if (!total || total.cnt === 0) return null;
+  const success = db.prepare(
+    'SELECT COUNT(*) AS cnt FROM delivery_log WHERE squad_slug = ? AND status_code >= 200 AND status_code < 300'
+  ).get(squadSlug);
+  return Math.round(((success ? success.cnt : 0) / total.cnt) * 100);
+}
+
+function getRecentDeliveries(db, squadSlug, limit = 20) {
+  return db.prepare(
+    'SELECT * FROM delivery_log WHERE squad_slug = ? ORDER BY created_at DESC LIMIT ?'
+  ).all(squadSlug, limit);
+}
+
+function getRecentContent(db, squadSlug, limit = 20) {
+  return db.prepare(
+    'SELECT content_key, title, content_type, layout_type, status, created_at, updated_at FROM content_items WHERE squad_slug = ? ORDER BY updated_at DESC LIMIT ?'
+  ).all(squadSlug, limit);
+}
+
+function getLearnings(db, squadSlug, statusFilter = null) {
+  if (statusFilter) {
+    return db.prepare(
+      'SELECT * FROM squad_learnings WHERE squad_slug = ? AND status = ? ORDER BY updated_at DESC'
+    ).all(squadSlug, statusFilter);
+  }
+  return db.prepare(
+    'SELECT * FROM squad_learnings WHERE squad_slug = ? ORDER BY updated_at DESC'
+  ).all(squadSlug);
+}
+
+function getLearningStats(db, squadSlug) {
+  const rows = db.prepare(
+    'SELECT status, COUNT(*) AS cnt FROM squad_learnings WHERE squad_slug = ? GROUP BY status'
+  ).all(squadSlug);
+  const stats = { active: 0, stale: 0, archived: 0, promoted: 0 };
+  for (const row of rows) {
+    if (Object.prototype.hasOwnProperty.call(stats, row.status)) {
+      stats[row.status] = row.cnt;
+    }
+  }
+  return stats;
+}
+
+function getExecutionPlan(db, squadSlug) {
+  const plan = db.prepare(
+    'SELECT * FROM squad_execution_plans WHERE squad_slug = ? ORDER BY updated_at DESC LIMIT 1'
+  ).get(squadSlug);
+  if (!plan) return null;
+  const rounds = db.prepare(
+    'SELECT * FROM squad_plan_rounds WHERE plan_slug = ? ORDER BY round_number ASC'
+  ).all(plan.plan_slug);
+  return { ...plan, rounds };
+}
+
+function getPipelineInfo(db, squadSlug) {
+  const node = db.prepare(
+    'SELECT * FROM pipeline_nodes WHERE squad_slug = ?'
+  ).get(squadSlug);
+  if (!node) return null;
+  const pipeline = db.prepare(
+    'SELECT * FROM squad_pipelines WHERE pipeline_slug = ?'
+  ).get(node.pipeline_slug);
+  const handoffs = db.prepare(
+    'SELECT * FROM squad_handoffs WHERE (from_squad = ? OR to_squad = ?) ORDER BY created_at DESC LIMIT 20'
+  ).all(squadSlug, squadSlug);
+  return { pipeline, node, handoffs };
+}
+
+function getSquadMetrics(db, squadSlug) {
+  try {
+    return db.prepare(
+      'SELECT * FROM squad_metrics WHERE squad_slug = ? ORDER BY period DESC, metric_key ASC'
+    ).all(squadSlug);
+  } catch {
+    return [];
+  }
+}
+
+function getRecentEvents(db, squadSlug, limit = 30) {
+  return db.prepare(
+    "SELECT * FROM execution_events WHERE run_key LIKE ? ORDER BY created_at DESC LIMIT ?"
+  ).all(`%${squadSlug}%`, limit);
+}
+
+function getSquadOverview(db, squadSlug) {
+  return {
+    contentItems: countContentItems(db, squadSlug),
+    sessions: countSessions(db, squadSlug),
+    learnings: countLearnings(db, squadSlug),
+    deliveryRate: calcDeliveryRate(db, squadSlug),
+    learningStats: getLearningStats(db, squadSlug),
+    executionPlan: getExecutionPlan(db, squadSlug),
+    pipelineInfo: getPipelineInfo(db, squadSlug),
+    customMetrics: getSquadMetrics(db, squadSlug)
+  };
+}
+
+module.exports = {
+  countContentItems,
+  countSessions,
+  countLearnings,
+  calcDeliveryRate,
+  getRecentDeliveries,
+  getRecentContent,
+  getLearnings,
+  getLearningStats,
+  getExecutionPlan,
+  getPipelineInfo,
+  getSquadMetrics,
+  getRecentEvents,
+  getSquadOverview
+};

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

@@ -0,0 +1,125 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+async function readProcessFile(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get all active processes across all squads (or for a specific squad).
+ * Reads from .aioson/squads/{slug}/processes/*.json
+ * Each file: { pid, squadSlug, agentSlug, startedAt, url, lastActivity, contextPct }
+ */
+async function getActiveProcesses(projectDir, squadSlug) {
+  const squadsDir = path.join(projectDir, SQUADS_DIR);
+  const processes = [];
+
+  let squadNames;
+  try {
+    const entries = await fs.readdir(squadsDir, { withFileTypes: true });
+    squadNames = entries
+      .filter(e => e.isDirectory() && (!squadSlug || e.name === squadSlug))
+      .map(e => e.name);
+  } catch {
+    return [];
+  }
+
+  for (const slug of squadNames) {
+    const processesDir = path.join(squadsDir, slug, 'processes');
+    let files;
+    try {
+      files = await fs.readdir(processesDir);
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+      const proc = await readProcessFile(path.join(processesDir, file));
+      if (!proc) continue;
+
+      const alive = isProcessAlive(proc.pid);
+      const startedAt = proc.startedAt ? new Date(proc.startedAt) : null;
+      const elapsedSeconds = startedAt ? Math.floor((Date.now() - startedAt.getTime()) / 1000) : null;
+
+      processes.push({
+        pid: proc.pid,
+        squadSlug: proc.squadSlug || slug,
+        agentSlug: proc.agentSlug || file.replace('.json', ''),
+        startedAt: proc.startedAt || null,
+        elapsedSeconds,
+        url: proc.url || null,
+        lastActivity: proc.lastActivity || null,
+        contextPct: proc.contextPct != null ? proc.contextPct : null,
+        alive,
+        _file: path.join(processesDir, file)
+      });
+    }
+  }
+
+  processes.sort((a, b) => {
+    if (!a.startedAt) return 1;
+    if (!b.startedAt) return -1;
+    return b.startedAt.localeCompare(a.startedAt);
+  });
+
+  return processes;
+}
+
+/**
+ * Stop a process by PID (SIGTERM) and remove its process file.
+ */
+async function stopProcess(projectDir, pid) {
+  const processes = await getActiveProcesses(projectDir, null);
+  const proc = processes.find(p => String(p.pid) === String(pid));
+
+  if (!proc) {
+    return { ok: false, error: 'Process not found' };
+  }
+  if (!proc.alive) {
+    // Clean up stale file anyway
+    try { await fs.unlink(proc._file); } catch { /* ignore */ }
+    return { ok: false, error: 'Process is not running' };
+  }
+
+  try {
+    process.kill(Number(proc.pid), 'SIGTERM');
+    try { await fs.unlink(proc._file); } catch { /* ignore */ }
+    return { ok: true, pid: proc.pid };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Stop all processes for a squad.
+ */
+async function stopSquadProcesses(projectDir, squadSlug) {
+  const processes = await getActiveProcesses(projectDir, squadSlug);
+  const results = [];
+  for (const proc of processes) {
+    results.push(await stopProcess(projectDir, proc.pid));
+  }
+  return results;
+}
+
+module.exports = { getActiveProcesses, stopProcess, stopSquadProcesses, isProcessAlive };