@bahulam/code 2.6.0

package/src/ui/markdown.mjs

@@ -0,0 +1,278 @@
+/**
+ * Terminal Markdown Renderer — parse markdown to ANSI-styled text.
+ *
+ * Supports:
+ * - **bold** -> bold text
+ * - *italic* -> italic text
+ * - `code` -> inverse/cyan
+ * - ```code block``` -> bordered box
+ * - - list item -> bullet
+ * - # heading -> bold + underline
+ * - [link](url) -> blue underline
+ * - | table | -> formatted table
+ */
+
+const ANSI = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    italic: '\x1b[3m',
+    underline: '\x1b[4m',
+    inverse: '\x1b[7m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+};
+
+const noColor = process.env.NO_COLOR === '1';
+
+function a(codes, text) {
+    if (noColor) return text;
+    const prefix = Array.isArray(codes) ? codes.join('') : codes;
+    return `${prefix}${text}${ANSI.reset}`;
+}
+
+/**
+ * Render inline markdown formatting within a single line.
+ * @param {string} line
+ * @returns {string}
+ */
+export function renderInline(line) {
+    if (noColor) return line;
+    let result = line;
+
+    // Bold: **text**
+    result = result.replace(/\*\*(.+?)\*\*/g, (_, t) => a(ANSI.bold, t));
+
+    // Italic: *text* (not preceded/followed by *)
+    result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, t) => a(ANSI.italic, t));
+
+    // Inline code: `text`
+    result = result.replace(/`([^`]+)`/g, (_, t) => a(ANSI.cyan, t));
+
+    // Links: [text](url)
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text, url) => {
+        return `${a([ANSI.blue, ANSI.underline], text)} ${a(ANSI.dim, `(${url})`)}`;
+    });
+
+    return result;
+}
+
+/**
+ * Highlight syntax within a code line (basic keyword/string/number/comment coloring).
+ * @param {string} line
+ * @param {string} lang
+ * @returns {string}
+ */
+export function highlightSyntax(line, lang) {
+    if (noColor) return line;
+    let result = line;
+
+    // Strings
+    result = result.replace(/(["'`])(.*?)\1/g, (m, q, s) => a(ANSI.green, `${q}${s}${q}`));
+
+    // Keywords
+    const kw = /\b(const|let|var|function|return|if|else|for|while|class|import|export|from|async|await|try|catch|throw|new|this|def|fn|pub|use|mod|struct|enum|impl|match|type|interface)\b/g;
+    result = result.replace(kw, (m) => a(ANSI.magenta, m));
+
+    // Numbers
+    result = result.replace(/\b(\d+\.?\d*)\b/g, (m) => a(ANSI.yellow, m));
+
+    // Comments
+    result = result.replace(/(\/\/.*|#.*)$/, (m) => a(ANSI.gray, m));
+
+    return result;
+}
+
+/**
+ * Render a full markdown string to ANSI terminal output.
+ * Handles block-level elements (headings, code blocks, lists, tables)
+ * and inline formatting.
+ *
+ * @param {string} text - raw markdown
+ * @returns {string} - ANSI-formatted string
+ */
+export function renderMarkdown(text) {
+    if (!text) return '';
+    const lines = text.split('\n');
+    const output = [];
+    let inCodeBlock = false;
+    let codeLang = '';
+    let codeLines = [];
+    let inTable = false;
+    let tableRows = [];
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Code block start/end
+        if (line.trimStart().startsWith('```')) {
+            if (inCodeBlock) {
+                // End code block - render it
+                output.push(formatCodeBlock(codeLines, codeLang));
+                inCodeBlock = false;
+                codeLines = [];
+                codeLang = '';
+                continue;
+            }
+            // Start code block
+            inCodeBlock = true;
+            codeLang = line.trimStart().slice(3).trim();
+            continue;
+        }
+
+        if (inCodeBlock) {
+            codeLines.push(line);
+            continue;
+        }
+
+        // Table detection
+        if (line.trim().startsWith('|') && line.trim().endsWith('|')) {
+            // Check if separator row
+            if (/^\|[\s\-:|]+\|$/.test(line.trim())) {
+                // Table separator, skip
+                continue;
+            }
+            tableRows.push(line);
+            // Check if next line is NOT a table row
+            const nextLine = lines[i + 1];
+            if (!nextLine || (!nextLine.trim().startsWith('|') || !nextLine.trim().endsWith('|'))) {
+                // Flush table
+                if (tableRows.length > 0) {
+                    output.push(formatTable(tableRows));
+                    tableRows = [];
+                }
+            }
+            continue;
+        }
+
+        // Flush any pending table rows
+        if (tableRows.length > 0) {
+            output.push(formatTable(tableRows));
+            tableRows = [];
+        }
+
+        // Headings
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const text = headingMatch[2];
+            if (level === 1) {
+                output.push(a([ANSI.bold, ANSI.underline], text));
+            } else if (level === 2) {
+                output.push(a(ANSI.bold, text));
+            } else {
+                output.push(a(ANSI.bold, text));
+            }
+            continue;
+        }
+
+        // Unordered list
+        const listMatch = line.match(/^(\s*)([-*+])\s+(.*)/);
+        if (listMatch) {
+            const indent = listMatch[1];
+            const content = renderInline(listMatch[3]);
+            output.push(`${indent}  * ${content}`);
+            continue;
+        }
+
+        // Ordered list
+        const olMatch = line.match(/^(\s*)(\d+)\.\s+(.*)/);
+        if (olMatch) {
+            const indent = olMatch[1];
+            const num = olMatch[2];
+            const content = renderInline(olMatch[3]);
+            output.push(`${indent}  ${num}. ${content}`);
+            continue;
+        }
+
+        // Horizontal rule
+        if (/^[-*_]{3,}\s*$/.test(line)) {
+            const cols = process.stdout.columns || 80;
+            output.push(a(ANSI.dim, '\u2500'.repeat(Math.min(cols, 60))));
+            continue;
+        }
+
+        // Blockquote
+        const bqMatch = line.match(/^>\s?(.*)/);
+        if (bqMatch) {
+            output.push(a(ANSI.dim, `  | ${renderInline(bqMatch[1])}`));
+            continue;
+        }
+
+        // Normal line with inline formatting
+        output.push(renderInline(line));
+    }
+
+    // Flush remaining
+    if (inCodeBlock && codeLines.length > 0) {
+        output.push(formatCodeBlock(codeLines, codeLang));
+    }
+    if (tableRows.length > 0) {
+        output.push(formatTable(tableRows));
+    }
+
+    return output.join('\n');
+}
+
+/**
+ * Format a code block with a border.
+ * @param {string[]} lines
+ * @param {string} lang
+ * @returns {string}
+ */
+function formatCodeBlock(lines, lang) {
+    if (noColor) {
+        return lines.map(l => `  ${l}`).join('\n');
+    }
+
+    const maxLen = Math.max(...lines.map(l => l.length), 20);
+    const width = Math.min(maxLen + 4, (process.stdout.columns || 80) - 4);
+    const top = a(ANSI.gray, `  \u250C${'─'.repeat(width)}\u2510${lang ? ` ${lang}` : ''}`);
+    const bot = a(ANSI.gray, `  \u2514${'─'.repeat(width)}\u2518`);
+    const body = lines.map(l => {
+        const highlighted = highlightSyntax(l, lang);
+        return `  ${a(ANSI.gray, '\u2502')} ${highlighted}`;
+    });
+
+    return [top, ...body, bot].join('\n');
+}
+
+/**
+ * Format a markdown table.
+ * @param {string[]} rows
+ * @returns {string}
+ */
+function formatTable(rows) {
+    const parsed = rows.map(r =>
+        r.split('|').slice(1, -1).map(c => c.trim())
+    );
+
+    if (parsed.length === 0) return '';
+
+    // Calculate column widths
+    const colCount = parsed[0].length;
+    const widths = [];
+    for (let c = 0; c < colCount; c++) {
+        widths.push(Math.max(...parsed.map(r => (r[c] || '').length)));
+    }
+
+    const formatted = parsed.map((row, ri) => {
+        const cells = row.map((cell, ci) => cell.padEnd(widths[ci] || 0));
+        const line = `  ${cells.join('  ')}`;
+        return ri === 0 ? a(ANSI.bold, line) : line;
+    });
+
+    // Add separator after header
+    if (formatted.length > 1) {
+        const sep = widths.map(w => '─'.repeat(w)).join('──');
+        formatted.splice(1, 0, a(ANSI.dim, `  ${sep}`));
+    }
+
+    return formatted.join('\n');
+}

package/src/ui/mission-report.mjs

@@ -0,0 +1,296 @@
+/**
+ * Mission report — Mission Control (PRD-055 §11).
+ *
+ * Replaces the trailing "Done" message at the end of a session with a
+ * structured summary:
+ *
+ *   ───────────────────────────────────────────────────
+ *   ✓ done
+ *   ───────────────────────────────────────────────────
+ *   📂 Files       auth.py, tests/test_auth.py
+ *   🛠️ Tools read(4)  edit(2)  shell(1)  test(1) · ⏱ Time 2m 18s
+ *   🛰️ Sub-agents  explore(1)  plan(1) · saved ≈ $0.08
+ *   ✅ Health      24/24 tests pass
+ *   ───────────────────────────────────────────────────
+ *
+ *
+ * Failure variant uses "held" and lists blockers.
+ *
+ * `renderMissionReport(state)` returns the ANSI block; `toMarkdown(state)`
+ * returns the plain-markdown version saved by `/report`.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { paint, width as visibleWidth } from './palette.mjs';
+import { icons } from './icons.mjs';
+import { toolFamily } from './icons.mjs';
+
+const WIDTH = 56;
+
+// ── Public API ─────────────────────────────────────────────────────────
+
+/**
+ * Render the ANSI mission-report block.
+ *
+ * @param {object} state
+ *   task         — string (the user's prompt for this session)
+ *   success      — boolean (overall outcome)
+ *   filesChanged — string[]
+ *   filesRead    — string[]
+ *   toolCounts   — { [tool]: count } or array of {tool}
+ *   subAgents    — array of { type, costUsd?, tokens? } or { explore:1, plan:1 }
+ *   costUsd      — number
+ *   durationS    — number
+ *   testsPass    — { passed: number, total: number } | null
+ *   blockers     — string[] (for failure variant)
+ *   nextActions  — string[] (slash-command hints)
+ *   cwd          — string (used to derive git repo + author metadata)
+ */
+export function renderMissionReport(state) {
+  const success = state.success !== false;
+  const lines = [];
+  const rule  = paint.text.dim('─'.repeat(WIDTH));
+
+  const statusIcon = success ? paint.state.success('✓') : paint.state.danger('✗');
+  const statusText = success ? paint.state.success('done') : paint.state.danger('held');
+  const headerTask = state.task ? paint.text.dim(' · ') + paint.text.primary(truncate(state.task, 60)) : '';
+
+  lines.push('');
+  lines.push(rule);
+  lines.push(`${statusIcon} ${statusText}${headerTask}`);
+  lines.push(rule);
+
+  if (Array.isArray(state.filesChanged) && state.filesChanged.length) {
+    lines.push(row('📂', 'Files',      formatFiles(state.filesChanged)));
+  }
+  if (Array.isArray(state.filesRead) && state.filesRead.length) {
+    lines.push(row('📖', 'Read',       formatFiles(state.filesRead)));
+  }
+
+  const toolSummary = formatToolCounts(state.toolCounts);
+  const time = state.durationS != null ? paint.brand.data(formatDuration(state.durationS)) : '';
+  const metricSegments = [];
+  if (toolSummary) metricSegments.push(`${icons.write} ${paint.text.dim('Tools')} ${toolSummary}`);
+  if (time) metricSegments.push(`${paint.text.dim('⏱ Time')} ${time}`);
+  if (metricSegments.length) lines.push('  ' + metricSegments.join(paint.text.dim(' · ')));
+
+  if (state.subAgents) {
+    const subSummary = formatSubAgents(state.subAgents);
+    if (subSummary) lines.push(row(icons.subAgent, 'Sub-agents', subSummary));
+  }
+
+  // Test health.
+  if (state.testsPass && typeof state.testsPass.total === 'number' && state.testsPass.total > 0) {
+    const { passed = 0, total = 0 } = state.testsPass;
+    const allGreen = passed === total;
+    const icon = allGreen ? paint.state.success('✅') : paint.state.danger('❌');
+    const text = allGreen
+      ? `${passed}/${total} tests pass`
+      : `${passed}/${total} tests pass · ${paint.state.danger((total - passed) + ' failing')}`;
+    lines.push(row(icon, allGreen ? 'Health' : 'Tests', text, /*alreadyIcon*/ true));
+  }
+
+  lines.push(rule);
+
+  if (!success && Array.isArray(state.blockers) && state.blockers.length) {
+    lines.push('');
+    lines.push('  ' + paint.bold(paint.state.danger('Blocked by:')));
+    for (const b of state.blockers.slice(0, 6)) {
+      lines.push('    ' + paint.text.dim('•') + ' ' + paint.text.primary(truncate(b, WIDTH * 2)));
+    }
+    if (state.blockers.length > 6) {
+      lines.push('    ' + paint.text.dim(`… ${state.blockers.length - 6} more`));
+    }
+  }
+
+  if (Array.isArray(state.nextActions) && state.nextActions.length) {
+    lines.push('');
+    const next = state.nextActions.map(a => paint.brand.data(a)).join(paint.text.dim('   '));
+    lines.push('  ' + paint.text.dim('Next:  ') + next);
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Same content as renderMissionReport, but as plain markdown so callers
+ * can persist it under `.bahulam/reports/`.
+ */
+export function toMarkdown(state) {
+  const success = state.success !== false;
+  const meta = resolveReportMeta(state);
+  const out = [];
+  out.push(`# ${success ? 'Done' : 'Held'}${state.task ? ' — ' + state.task : ''}`);
+  out.push('');
+  out.push('**Repo**: ' + meta.repo);
+  out.push('**Author**: ' + meta.author);
+  if (Array.isArray(state.filesChanged) && state.filesChanged.length) {
+    out.push('**Files**: ' + state.filesChanged.join(', '));
+  }
+  if (Array.isArray(state.filesRead) && state.filesRead.length) {
+    out.push('**Read**: ' + state.filesRead.join(', '));
+  }
+  const toolSummary = stripAnsi(formatToolCounts(state.toolCounts) || '');
+  if (toolSummary) out.push('**Tools**: ' + toolSummary);
+  if (state.subAgents) {
+    const sub = stripAnsi(formatSubAgents(state.subAgents) || '');
+    if (sub) out.push('**Sub-agents**: ' + sub);
+  }
+  if (state.costUsd != null) out.push('**Cost**: ' + stripAnsi(formatCost(state.costUsd)));
+  if (state.durationS != null) out.push('**Time**: ' + formatDuration(state.durationS));
+  if (state.testsPass) {
+    const { passed = 0, total = 0 } = state.testsPass;
+    out.push(`**Tests**: ${passed}/${total} ${passed === total ? 'pass' : 'pass · ' + (total - passed) + ' failing'}`);
+  }
+  if (!success && Array.isArray(state.blockers) && state.blockers.length) {
+    out.push('');
+    out.push('## Blocked by');
+    for (const b of state.blockers) out.push('- ' + b);
+  }
+  if (Array.isArray(state.nextActions) && state.nextActions.length) {
+    out.push('');
+    out.push('**Next**: ' + state.nextActions.join('  '));
+  }
+  out.push('');
+  return out.join('\n');
+}
+
+/**
+ * Save a markdown copy of the report to `.bahulam/reports/<timestamp>.md`
+ * inside the working directory. Returns the absolute path.
+ */
+export function saveReport(state, { cwd = process.cwd(), timestamp } = {}) {
+  const dir = path.join(cwd, '.bahulam', 'reports');
+  fs.mkdirSync(dir, { recursive: true });
+  const stamp = timestamp || new Date().toISOString().replace(/[:.]/g, '-');
+  const out = path.join(dir, `${stamp}.md`);
+  fs.writeFileSync(out, toMarkdown(state));
+  return out;
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function row(icon, label, value, alreadyIcon = false) {
+  const i = alreadyIcon ? icon : icon;
+  const labelText = paint.text.dim(label.padEnd(11));
+  return `  ${i} ${labelText} ${value}`;
+}
+
+function resolveReportMeta(state = {}) {
+  const cwd = state.cwd || process.cwd();
+  return {
+    repo: state.repo || gitValue(cwd, ['remote', 'get-url', 'origin']) ||
+      gitValue(cwd, ['rev-parse', '--show-toplevel'], value => path.basename(value)) ||
+      path.basename(cwd),
+    author: state.author || gitAuthor(cwd) || 'unknown',
+  };
+}
+
+function gitAuthor(cwd) {
+  const name = gitValue(cwd, ['config', '--get', 'user.name']);
+  const email = gitValue(cwd, ['config', '--get', 'user.email']);
+  if (name && email) return `${name} <${email}>`;
+  return name || email || '';
+}
+
+function gitValue(cwd, args, transform = value => value) {
+  try {
+    const value = execFileSync('git', args, {
+      cwd,
+      encoding: 'utf-8',
+      timeout: 1500,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    return value ? transform(value) : '';
+  } catch {
+    return '';
+  }
+}
+
+function formatFiles(files) {
+  const shortened = files.map(f => paint.text.primary(path.basename(f)));
+  if (shortened.length <= 4) return shortened.join(paint.text.dim(', '));
+  return shortened.slice(0, 4).join(paint.text.dim(', ')) + paint.text.dim(`, +${files.length - 4} more`);
+}
+
+/**
+ * Render `read(4)  edit(2)  shell(1)  test(1)` from a counts object/array.
+ * Buckets by tool family so the line stays compact.
+ */
+function formatToolCounts(counts) {
+  if (!counts) return '';
+  const entries = Array.isArray(counts)
+    ? counts
+    : Object.entries(counts).map(([tool, n]) => ({ tool, count: n }));
+  if (!entries.length) return '';
+
+  const buckets = { read: 0, edit: 0, shell: 0, test: 0, other: 0 };
+  for (const { tool, count } of entries) {
+    const c = Number(count) || 0;
+    if (!c) continue;
+    const fam = toolFamily(tool);
+    if (tool === 'run_tests' || tool === 'validate_build') buckets.test += c;
+    else if (fam === 'write') buckets.edit += c;
+    else if (fam === 'shell') buckets.shell += c;
+    else if (fam === 'search') buckets.read += c;
+    else buckets.other += c;
+  }
+  const parts = [];
+  if (buckets.read)  parts.push(`${paint.brand.data('read')}(${buckets.read})`);
+  if (buckets.edit)  parts.push(`${paint.brand.primary('edit')}(${buckets.edit})`);
+  if (buckets.shell) parts.push(`${paint.state.warn('shell')}(${buckets.shell})`);
+  if (buckets.test)  parts.push(`${paint.state.success('test')}(${buckets.test})`);
+  if (buckets.other) parts.push(`${paint.text.muted('tool')}(${buckets.other})`);
+  return parts.join(paint.text.dim('  '));
+}
+
+function formatSubAgents(subAgents) {
+  // Accepts either a flat counts object { explore: 1, plan: 1, savedUsd: 0.08 }
+  // or an array of { type, costUsd, tokens }.
+  if (!subAgents) return '';
+  let counts = {};
+  let savedUsd = 0;
+  if (Array.isArray(subAgents)) {
+    for (const s of subAgents) {
+      counts[s.type] = (counts[s.type] || 0) + 1;
+      if (typeof s.savedUsd === 'number') savedUsd += s.savedUsd;
+    }
+  } else {
+    counts = { ...subAgents };
+    savedUsd = subAgents.savedUsd || 0;
+    delete counts.savedUsd;
+  }
+  const entries = Object.entries(counts).filter(([, n]) => Number(n) > 0);
+  if (!entries.length) return '';
+  const list = entries.map(([type, n]) => `${paint.brand.data(type)}(${n})`).join(paint.text.dim('  '));
+  if (savedUsd > 0) {
+    return list + paint.text.dim(` · saved ≈ ${formatCost(savedUsd)}`);
+  }
+  return list;
+}
+
+function formatCost(usd) {
+  if (typeof usd !== 'number' || !Number.isFinite(usd)) return '$0.00';
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(2)}`;
+}
+
+function formatDuration(s) {
+  if (typeof s !== 'number' || !Number.isFinite(s)) return '0s';
+  if (s < 60)  return `${s.toFixed(1)}s`;
+  const m = Math.floor(s / 60);
+  const rem = Math.round(s - m * 60);
+  return `${m}m ${rem}s`;
+}
+
+function truncate(s, n) {
+  const str = String(s || '');
+  return str.length <= n ? str : str.slice(0, n - 1) + '…';
+}
+
+function stripAnsi(s) {
+  return String(s || '').replace(/\x1b\[[0-9;]*m/g, '');
+}