@jaimevalasek/aioson 1.5.1 → 1.7.0

package/src/commands/context-monitor.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const path = require('node:path');
+const {
+  getContextUsage,
+  computeWarningLevel,
+  THRESHOLDS
+} = require('../squad-dashboard/context-monitor');
+const { openRuntimeDb, appendRunEvent } = require('../runtime-store');
+
+const PROJECT_BUDGET_ZONES = {
+  safe: 0.60,
+  warning: 0.80,
+  critical: 1.00
+};
+
+const BAR_WIDTH = 20;
+const LEVEL_ICONS = { normal: ' ', warning: '⚠', critical: '!', overflow: 'X', unknown: '?' };
+
+function renderBar(ratio, width) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const filled = Math.round(clamped * width);
+  const bar = '█'.repeat(filled) + '░'.repeat(width - filled);
+  return `[${bar}] ${Math.round(clamped * 100)}%`;
+}
+
+function formatTokens(n) {
+  if (typeof n !== 'number') return '?';
+  return n.toLocaleString();
+}
+
+function renderAgent(slug, agent) {
+  const used = agent.totalUsed || 0;
+  const win = agent.windowSize || 0;
+  const ratio = win > 0 ? used / win : 0;
+  const level = agent.warningLevel || computeWarningLevel(used, win);
+  const icon = LEVEL_ICONS[level] || '?';
+  const bar = renderBar(ratio, BAR_WIDTH);
+  const line = `  ${icon} ${slug.padEnd(16)} ${bar}  ${formatTokens(used)}/${formatTokens(win)}`;
+  if (level === 'warning' || level === 'critical' || level === 'overflow') {
+    return `${line}  [${level.toUpperCase()}]`;
+  }
+  return line;
+}
+
+async function emitBudgetEvent(cwd, { tokens, budget, pct, zone, agentName }) {
+  const { db } = await openRuntimeDb(cwd, { mustExist: true }).catch(() => ({ db: null }));
+  if (!db) return;
+  try {
+    const run = db.prepare(
+      "SELECT run_key FROM agent_runs WHERE status = 'running' ORDER BY updated_at DESC LIMIT 1"
+    ).get();
+    if (run) {
+      appendRunEvent(db, {
+        runKey: run.run_key,
+        eventType: zone === 'critical' ? 'context_budget_critical' : 'context_budget_warning',
+        phase: 'live',
+        status: 'running',
+        message: `Context at ${pct}% of budget (${tokens.toLocaleString()} tokens)`,
+        payload: { tokens, budget, pct, zone, agentName: agentName || null },
+        createdAt: new Date().toISOString()
+      });
+    }
+  } finally {
+    db.close();
+  }
+}
+
+async function runContextMonitor({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = options.squad || null;
+  const agentSlug = options.agent || null;
+  const budget = options.budget ? Number(options.budget) : null;
+
+  // Project-level budget monitoring (--budget=<tokens>)
+  if (budget && !squadSlug) {
+    const tokens = options.tokens ? Number(options.tokens) : null;
+    if (tokens !== null) {
+      const pct = Math.round((tokens / budget) * 100);
+      const zone = pct >= 100 ? 'overflow'
+        : pct >= PROJECT_BUDGET_ZONES.warning * 100 ? 'critical'
+        : pct >= PROJECT_BUDGET_ZONES.safe * 100 ? 'warning'
+        : 'safe';
+
+      const icon = zone === 'overflow' ? 'X' : zone === 'critical' ? '!' : zone === 'warning' ? '⚠' : '✓';
+
+      if (!options.json) {
+        logger.log(`  ${icon} Context: ${tokens.toLocaleString()} tokens (${pct}%) — ${zone.toUpperCase()}`);
+        if (zone === 'warning') {
+          logger.log(`  Suggestion: /clear before next agent activation`);
+        } else if (zone === 'critical' || zone === 'overflow') {
+          logger.log(`  Run: aioson context:health . for reduction options`);
+        }
+      }
+
+      if (zone === 'warning' || zone === 'critical' || zone === 'overflow') {
+        await emitBudgetEvent(cwd, { tokens, budget, pct, zone, agentName: agentSlug });
+      }
+
+      if (options.json) {
+        return { ok: true, tokens, budget, pct, zone };
+      }
+      return { ok: true, tokens, budget, pct, zone };
+    }
+
+    if (!options.json) {
+      logger.log(`  Budget: ${budget.toLocaleString()} tokens`);
+      logger.log(`  Zones: safe=<${PROJECT_BUDGET_ZONES.safe * 100}%  warning=${PROJECT_BUDGET_ZONES.safe * 100}-${PROJECT_BUDGET_ZONES.warning * 100}%  critical=>=${PROJECT_BUDGET_ZONES.warning * 100}%`);
+      logger.log(`  Use --tokens=<n> to check against budget`);
+    }
+    return { ok: true, budget, zones: PROJECT_BUDGET_ZONES };
+  }
+
+  if (!squadSlug) {
+    logger.log('\n  Context Monitor\n');
+    logger.log('  No squad specified. Use --squad=<slug> to monitor a squad.');
+    logger.log('  Example: aioson context:monitor . --squad=my-squad');
+    logger.log('  Or use --budget=<tokens> --tokens=<current> for project-level monitoring.');
+    logger.log('');
+    return { ok: true, squads: [] };
+  }
+
+  const data = await getContextUsage(cwd, squadSlug, agentSlug || null);
+
+  if (!data) {
+    logger.log(`\n  No context data found for squad: ${squadSlug}`);
+    logger.log('  The squad may not have started yet or context-monitor.json is missing.');
+    logger.log('');
+    return { ok: true, squadSlug, agents: {} };
+  }
+
+  if (options.json) {
+    return { ok: true, ...data };
+  }
+
+  logger.log(`\n  Context Monitor — ${squadSlug}\n`);
+
+  if (agentSlug) {
+    // Single agent
+    const agent = data;
+    logger.log(renderAgent(agentSlug, agent));
+  } else {
+    const agents = data.agents || {};
+    if (Object.keys(agents).length === 0) {
+      logger.log('  No agents tracked yet.');
+    } else {
+      for (const [slug, agent] of Object.entries(agents)) {
+        logger.log(renderAgent(slug, agent));
+      }
+    }
+  }
+
+  logger.log('');
+  logger.log(`  Thresholds: warning=${Math.round(THRESHOLDS.warning * 100)}%  critical=${Math.round(THRESHOLDS.critical * 100)}%`);
+  if (data.updatedAt) {
+    logger.log(`  Updated: ${data.updatedAt}`);
+  }
+  logger.log('');
+
+  return { ok: true, ...data };
+}
+
+module.exports = { runContextMonitor };

package/src/commands/context-search.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const path = require('node:path');
+const { withIndex } = require('../context-search');
+
+async function runContextSearch({ args, options, logger }) {
+  const query = args[0] || options.query || '';
+  const cwd = path.resolve(process.cwd(), options.cwd || '.');
+  const limit = Number(options.limit) || 10;
+
+  if (!query) {
+    logger.log('Usage: aioson context:search <query> [--limit=10] [--cwd=.]');
+    return { ok: false, error: 'missing_query' };
+  }
+
+  const results = await withIndex(async (idx) => {
+    return idx.search(query, { limit, projectDir: cwd });
+  });
+
+  if (options.json) {
+    return { ok: true, results };
+  }
+
+  if (results.length === 0) {
+    logger.log(`No results for: ${query}`);
+    return { ok: true, results: [] };
+  }
+
+  logger.log(`\n  Search results for: "${query}"\n`);
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    logger.log(`  ${i + 1}. ${r.title}`);
+    logger.log(`     ${r.relPath}`);
+    if (r.snippet) {
+      logger.log(`     ${r.snippet.replace(/\n/g, ' ')}`);
+    }
+    logger.log('');
+  }
+
+  return { ok: true, results };
+}
+
+async function runContextSearchIndex({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const force = Boolean(options.force);
+
+  logger.log(`Indexing: ${cwd} ...`);
+
+  const result = await withIndex(async (idx) => {
+    const r = await idx.indexDirectory(cwd, { force });
+    const stats = idx.stats();
+    return { ...r, stats };
+  });
+
+  if (options.json) {
+    return { ok: true, ...result };
+  }
+
+  logger.log(`  Indexed: ${result.indexed} files`);
+  logger.log(`  Skipped: ${result.skipped} files (already indexed)`);
+  logger.log(`  Total in index: ${result.stats.totalDocs} docs`);
+
+  return { ok: true, ...result };
+}
+
+module.exports = { runContextSearch, runContextSearchIndex };

package/src/commands/context-trim.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const CHARS_PER_TOKEN = 4;
+const LARGE_SECTION_BULLETS = 20; // warn if a section has more than this many bullet lines
+
+function estimateTokens(content) {
+  return Math.ceil(content.length / CHARS_PER_TOKEN);
+}
+
+function formatBytes(bytes) {
+  return `${(bytes / 1024).toFixed(1)}KB`;
+}
+
+async function loadFeatureStatuses(contextDir) {
+  const featuresPath = path.join(contextDir, 'features.md');
+  try {
+    const content = await fs.readFile(featuresPath, 'utf8');
+    const done = new Set();
+    for (const line of content.split(/\r?\n/)) {
+      const m = line.match(/[-|]\s*([a-z0-9_-]+)\s*[:|]\s*done/i);
+      if (m) done.add(m[1].toLowerCase());
+    }
+    return done;
+  } catch {
+    return new Set();
+  }
+}
+
+function findLargeSections(content, fileName) {
+  const sections = [];
+  const sectionRe = /^#{2,4}\s+(.+)/gm;
+  let match;
+  const sectionStarts = [];
+
+  while ((match = sectionRe.exec(content)) !== null) {
+    sectionStarts.push({ title: match[1].trim(), start: match.index });
+  }
+
+  for (let i = 0; i < sectionStarts.length; i++) {
+    const { title, start } = sectionStarts[i];
+    const end = i + 1 < sectionStarts.length ? sectionStarts[i + 1].start : content.length;
+    const body = content.slice(start, end);
+    const bulletCount = (body.match(/^[-*]\s/gm) || []).length;
+    if (bulletCount > LARGE_SECTION_BULLETS) {
+      sections.push({
+        file: fileName,
+        section: title,
+        bulletCount,
+        sizeBytes: body.length,
+        tokens: estimateTokens(body)
+      });
+    }
+  }
+  return sections;
+}
+
+async function runContextTrim({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const contextDir = path.join(targetDir, '.aioson', 'context');
+  const archiveDir = path.join(contextDir, 'archive');
+  const dryRun = options['dry-run'] || options.dryRun || false;
+  const force = options.force || false;
+
+  let entries;
+  try {
+    entries = await fs.readdir(contextDir);
+  } catch {
+    if (!options.json) logger.log('No .aioson/context/ directory found.');
+    return { ok: false, reason: 'no_context_dir' };
+  }
+
+  const mdFiles = entries.filter((f) => f.endsWith('.md') && f !== 'archive');
+  const doneFeatures = await loadFeatureStatuses(contextDir);
+
+  const staleSpecs = [];
+  const largeSections = [];
+
+  for (const file of mdFiles) {
+    // Identify stale specs
+    if (file.startsWith('spec-')) {
+      const slug = file.replace(/^spec-/, '').replace(/\.md$/, '');
+      if (doneFeatures.has(slug)) {
+        const stat = await fs.stat(path.join(contextDir, file)).catch(() => null);
+        staleSpecs.push({
+          file,
+          slug,
+          sizeBytes: stat ? stat.size : 0
+        });
+      }
+    }
+
+    // Find large sections in active specs
+    if (file.startsWith('spec-') || file === 'spec.md') {
+      const content = await fs.readFile(path.join(contextDir, file), 'utf8').catch(() => null);
+      if (content) {
+        const found = findLargeSections(content, file);
+        largeSections.push(...found);
+      }
+    }
+  }
+
+  const totalStaleSaved = staleSpecs.reduce((s, r) => s + r.sizeBytes, 0);
+
+  if (options.json) {
+    return {
+      ok: true,
+      staleSpecs,
+      largeSections,
+      totalStaleSavedBytes: totalStaleSaved,
+      dryRun
+    };
+  }
+
+  logger.log('Context Trim Analysis');
+  logger.log('─'.repeat(50));
+
+  if (staleSpecs.length === 0 && largeSections.length === 0) {
+    logger.log('✓ No stale specs or oversized sections found.');
+    logger.log('');
+    return { ok: true, staleSpecs: [], largeSections: [], totalStaleSavedBytes: 0, dryRun };
+  }
+
+  if (staleSpecs.length > 0) {
+    logger.log(`Stale specs (feature: done):`);
+    for (const s of staleSpecs) {
+      logger.log(`  ${s.file.padEnd(30)} — ${s.slug} is done  (${formatBytes(s.sizeBytes)})`);
+    }
+    if (totalStaleSaved > 0) {
+      logger.log(`  → Archiving saves ~${formatBytes(totalStaleSaved)} (~${estimateTokens(totalStaleSaved * CHARS_PER_TOKEN)} tokens) per session`);
+    }
+    logger.log('');
+  }
+
+  if (largeSections.length > 0) {
+    logger.log('Large sections in active specs:');
+    for (const s of largeSections) {
+      logger.log(`  ${s.file} § ${s.section} (${s.bulletCount} entries, ${formatBytes(s.sizeBytes)})`);
+      logger.log(`    → Consider trimming to last ${LARGE_SECTION_BULLETS} entries to save ~${formatBytes(s.sizeBytes - Math.floor(s.sizeBytes * LARGE_SECTION_BULLETS / s.bulletCount))}`);
+    }
+    logger.log('');
+  }
+
+  // Archive stale specs
+  if (staleSpecs.length > 0) {
+    if (force || dryRun) {
+      if (!dryRun) {
+        await fs.mkdir(archiveDir, { recursive: true });
+        for (const s of staleSpecs) {
+          const src = path.join(contextDir, s.file);
+          const dest = path.join(archiveDir, s.file);
+          await fs.rename(src, dest);
+          logger.log(`  Archived: ${s.file} → context/archive/${s.file}`);
+        }
+        logger.log('');
+        logger.log(`${staleSpecs.length} spec(s) archived to .aioson/context/archive/`);
+      } else {
+        logger.log(`[dry-run] Would archive ${staleSpecs.length} stale spec(s) to .aioson/context/archive/`);
+      }
+    } else {
+      logger.log(`Run with --force to archive stale specs, or --dry-run to preview.`);
+    }
+  }
+
+  return {
+    ok: true,
+    staleSpecs,
+    largeSections,
+    totalStaleSavedBytes: totalStaleSaved,
+    archived: force && !dryRun ? staleSpecs.length : 0,
+    dryRun
+  };
+}
+
+module.exports = { runContextTrim };