codecruise 0.1.0

package/src/report.js

@@ -0,0 +1,310 @@
+/**
+ * codecruise report - Generate dogfood analysis report
+ *
+ * Answers Boris & Peter's questions:
+ * 1. Which agents are actually used?
+ * 2. How many enforcement blocks?
+ * 3. Is OODA meaningful?
+ * 4. Which commands matter?
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+
+function readJsonl(filepath) {
+  if (!existsSync(filepath)) return [];
+  try {
+    return readFileSync(filepath, 'utf-8')
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function countByField(records, field) {
+  const counts = {};
+  for (const record of records) {
+    const value = record[field] || 'unknown';
+    counts[value] = (counts[value] || 0) + 1;
+  }
+  return Object.entries(counts)
+    .sort((a, b) => b[1] - a[1])
+    .map(([key, count]) => ({ key, count }));
+}
+
+function formatTable(data, total) {
+  if (data.length === 0) return '*No data recorded yet.*';
+
+  let result = '| Item | Count | % |\n|------|-------|---|\n';
+  for (const { key, count } of data) {
+    const pct = total > 0 ? ((count / total) * 100).toFixed(1) : '0';
+    result += `| ${key} | ${count} | ${pct}% |\n`;
+  }
+  return result;
+}
+
+function getDateRange(records) {
+  if (records.length === 0) return 'N/A';
+  const timestamps = records
+    .map(r => r.timestamp)
+    .filter(Boolean)
+    .sort();
+  if (timestamps.length === 0) return 'N/A';
+  const first = timestamps[0].split('T')[0];
+  const last = timestamps[timestamps.length - 1].split('T')[0];
+  return `${first} to ${last}`;
+}
+
+function getProjects(records) {
+  const projects = new Set();
+  for (const record of records) {
+    if (record.project) projects.add(record.project);
+  }
+  return Array.from(projects).join(', ') || '(unknown)';
+}
+
+export async function runReport(projectDirs) {
+  console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                 codecruise report                          ║
+╚═══════════════════════════════════════════════════════════╝
+`);
+
+  // Find metrics directories
+  const metricsDirs = [];
+
+  if (projectDirs.length === 0) {
+    // Check current directory
+    if (existsSync('.codecruise/metrics')) {
+      metricsDirs.push('.codecruise/metrics');
+    }
+  } else {
+    for (const dir of projectDirs) {
+      const metricsPath = join(dir, '.codecruise/metrics');
+      if (existsSync(metricsPath)) {
+        metricsDirs.push(metricsPath);
+      } else {
+        console.log(`⚠ No metrics found in ${dir}`);
+      }
+    }
+  }
+
+  if (metricsDirs.length === 0) {
+    console.log(`✗ No metrics found.
+
+To collect metrics during dogfooding:
+  1. npx codecruise install
+  2. cd your-project && claude
+  3. /init && /run
+  4. Metrics are collected automatically
+
+Then run:
+  npx codecruise report /path/to/project1 /path/to/project2
+`);
+    process.exit(1);
+  }
+
+  console.log(`Analyzing metrics from ${metricsDirs.length} project(s)...\n`);
+
+  // Aggregate all data
+  let enforcement = [];
+  let agents = [];
+  let commands = [];
+  let ooda = [];
+  let events = [];
+
+  for (const dir of metricsDirs) {
+    enforcement = enforcement.concat(readJsonl(join(dir, 'enforcement.jsonl')));
+    agents = agents.concat(readJsonl(join(dir, 'agents.jsonl')));
+    commands = commands.concat(readJsonl(join(dir, 'commands.jsonl')));
+    ooda = ooda.concat(readJsonl(join(dir, 'ooda.jsonl')));
+    events = events.concat(readJsonl(join(dir, 'events.jsonl')));
+  }
+
+  const allRecords = [...enforcement, ...agents, ...commands, ...ooda, ...events];
+
+  // Analysis
+  const agentBreakdown = countByField(agents, 'agent');
+  const commandBreakdown = countByField(commands, 'command');
+  const enforcementBreakdown = countByField(enforcement, 'event');
+  const oodaPhases = countByField(ooda, 'phase');
+  const confidenceLevels = countByField(ooda.filter(r => r.confidence), 'confidence');
+
+  // Counts
+  const tddBlocks = enforcement.filter(r => r.event === 'tdd_block').length;
+  const rationalizationCaught = enforcement.filter(r => r.event === 'rationalization_caught').length;
+  const qualityBlocks = enforcement.filter(r => r.event === 'quality_block').length;
+  const stateBlocks = enforcement.filter(r => r.event === 'state_block').length;
+  const totalEnforcement = tddBlocks + rationalizationCaught + qualityBlocks + stateBlocks;
+
+  const testPasses = events.filter(r => r.event === 'test_pass').length;
+  const testFails = events.filter(r => r.event === 'test_fail').length;
+  const commits = events.filter(r => r.event === 'commit').length;
+
+  // Generate report
+  const dateRange = getDateRange(allRecords);
+  const projects = getProjects(allRecords);
+  const timestamp = new Date().toISOString();
+
+  let verdict = '';
+  if (totalEnforcement > 10) {
+    verdict = `The enforcement layer is **working**. ${totalEnforcement} violations were blocked, preventing sloppy work from shipping.`;
+  } else if (totalEnforcement > 0) {
+    verdict = `Enforcement is active (${totalEnforcement} blocks). Need more data to draw strong conclusions.`;
+  } else {
+    verdict = `**Insufficient data** to draw conclusions. Run more sessions with /run to collect metrics.`;
+  }
+
+  const report = `# Codecruise Dogfood Report
+
+**Generated**: ${timestamp}
+**Projects**: ${projects}
+**Period**: ${dateRange}
+
+---
+
+## Executive Summary
+
+${verdict}
+
+---
+
+## 1. Agent Usage
+
+*Boris Q1: "Are 12 agents actually used? Or do 3-4 do 90% of the work?"*
+
+**Total delegations**: ${agents.length}
+
+${formatTable(agentBreakdown, agents.length)}
+
+**Verdict**: ${agents.length < 10 ? 'Need more data' : agentBreakdown.length <= 4 ? `Only ${agentBreakdown.length} agents used — consider trimming` : 'Multiple agents in use'}
+
+---
+
+## 2. Enforcement Effectiveness
+
+*Peter Q1: "How many false dones were caught? How many TDD violations blocked?"*
+
+| Enforcement Type | Count |
+|-----------------|-------|
+| TDD violations blocked | ${tddBlocks} |
+| Rationalizations caught | ${rationalizationCaught} |
+| Quality gate blocks | ${qualityBlocks} |
+| State machine blocks | ${stateBlocks} |
+| **Total** | **${totalEnforcement}** |
+
+**Value**: ${totalEnforcement > 5 ? 'HIGH — These would have been bugs or incomplete work' : totalEnforcement > 0 ? 'MODERATE — Some catches' : 'Unknown — No violations recorded'}
+
+---
+
+## 3. OODA Reality
+
+*Boris Q2, Peter Q2: "Is OODA's ORIENT phase doing meaningful confidence calculation?"*
+
+**OODA phases logged**: ${ooda.length}
+
+${formatTable(oodaPhases, ooda.length)}
+
+**Confidence distribution**:
+${formatTable(confidenceLevels, ooda.filter(r => r.confidence).length)}
+
+**Verdict**: ${ooda.length === 0 ? 'No OODA data recorded — may not be emitting phase markers' : confidenceLevels.length > 1 ? 'OODA is calculating varied confidence levels' : 'Need more data to assess OODA value'}
+
+---
+
+## 4. Command Usage
+
+*Boris Q2: "Which of the 34 commands actually get used?"*
+
+**Total invocations**: ${commands.length}
+
+${formatTable(commandBreakdown, commands.length)}
+
+**Verdict**: ${commands.length < 10 ? 'Need more data' : commandBreakdown.length <= 5 ? `Only ${commandBreakdown.length} commands used — consider trimming` : 'Multiple commands in use'}
+
+---
+
+## 5. Activity Summary
+
+| Metric | Count |
+|--------|-------|
+| Test passes | ${testPasses} |
+| Test failures | ${testFails} |
+| Commits | ${commits} |
+
+---
+
+## 6. Overall Verdict
+
+${totalEnforcement > 10 ? `**Complexity justified**: PARTIALLY
+
+**Evidence**:
+- Enforcement layer is clearly valuable (${totalEnforcement} violations blocked)
+- Agent/command usage: ${agentBreakdown.length} agents, ${commandBreakdown.length} commands actively used
+- OODA: ${ooda.length > 0 ? 'Recording data' : 'No data yet'}
+
+**Recommendations**:
+1. ${agentBreakdown.length < 5 ? 'Trim unused agents' : 'Keep agents, they are being used'}
+2. ${commandBreakdown.length < 10 ? 'Trim unused commands' : 'Keep commands, they are being used'}
+3. ${ooda.length === 0 ? 'Add OODA phase markers to /run output' : 'Continue monitoring OODA effectiveness'}` : `**Complexity justified**: INSUFFICIENT DATA
+
+Run more dogfooding sessions with /run to collect meaningful metrics.
+
+**Minimum needed**:
+- 3+ projects
+- 20+ TODOs completed
+- Multiple sessions over several days`}
+
+---
+
+*Report generated by \`npx codecruise report\`*
+`;
+
+  // Save report to ~/.claude/reports/
+  const reportsDir = join(homedir(), '.claude', 'reports');
+  mkdirSync(reportsDir, { recursive: true });
+
+  const reportPath = join(reportsDir, 'DOGFOOD-REPORT.md');
+  writeFileSync(reportPath, report);
+
+  console.log(`✓ Report saved to: ${reportPath}
+
+Summary:
+  - Enforcement blocks: ${totalEnforcement}
+  - Agent delegations: ${agents.length}
+  - Command invocations: ${commands.length}
+  - OODA phases logged: ${ooda.length}
+
+View report:
+  cat ${reportPath}
+  # or
+  npx codecruise report --show
+`);
+}
+
+export async function showReport() {
+  const reportPath = join(homedir(), '.claude', 'reports', 'DOGFOOD-REPORT.md');
+
+  if (!existsSync(reportPath)) {
+    console.log(`No report found at ${reportPath}
+
+Generate one first:
+  npx codecruise report ~/project1 ~/project2
+`);
+    process.exit(1);
+  }
+
+  const content = readFileSync(reportPath, 'utf-8');
+  console.log(content);
+}