@jaimevalasek/aioson 1.4.0 → 1.5.1

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 };

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
+};