@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/commands/status.js

@@ -0,0 +1,654 @@
+/**
+ * unerr status — check repo/proxy/graph/drift/ledger state.
+ *
+ * Renders a rich Ink dashboard to stderr with:
+ *   - Repo info, branch, commits ahead/behind
+ *   - Proxy state (running/stopped, PID)
+ *   - Graph stats (entity count, edge count, age)
+ *   - Health grade with progress bar
+ *   - Drift summary
+ *   - Live session latency if proxy is running
+ *
+ * All output to stderr to protect MCP stdout stream.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import React from "react";
+import { getRemoteUrl } from "../utils/git.js";
+/**
+ * Contextual suggestions engine.
+ * Surfaces actionable next steps based on current state.
+ */
+function buildSuggestions(data) {
+    const suggestions = [];
+    if (data.byoLlmStatus === "not_configured") {
+        suggestions.push("Configure BYO-LLM for semantic search: edit ~/.unerr/settings.json");
+    }
+    if (data.byoLlmStatus === "unreachable") {
+        suggestions.push("LLM is unreachable. Start Ollama: ollama serve");
+    }
+    if (!data.lastIndexed) {
+        suggestions.push("No index yet. Run 'unerr' to start indexing.");
+    }
+    if (data.conventionCount === 0 || data.conventionCount == null) {
+        suggestions.push("Run 'unerr' to detect conventions and generate rules");
+    }
+    if (data.byoLlmStatus === "connected") {
+        suggestions.push("Run 'unerr enrich' to generate business context with your LLM");
+    }
+    suggestions.push("Run 'unerr chat' to talk to your codebase interactively");
+    if (data.skillCount === 0 || data.skillCount == null) {
+        suggestions.push("No skills installed. Run 'unerr' to install agent skills.");
+    }
+    if (!data.proxyRunning) {
+        suggestions.push("Run 'unerr' to start the proxy.");
+    }
+    return suggestions;
+}
+export function registerStatusCommand(program) {
+    program
+        .command("status")
+        .description("Check repo, proxy, graph, drift, and ledger state")
+        .action(async () => {
+        const cwd = process.cwd();
+        // ── Git Check ──────────────────────────────────────────────
+        const { isGitRepo } = await import("../utils/git.js");
+        if (!(await isGitRepo(cwd))) {
+            process.stderr.write("[unerr] Error: not inside a git repository.\n" +
+                "  Run unerr from a project directory that has been initialized with git.\n");
+            process.exit(1);
+        }
+        const unerrDir = join(cwd, ".unerr");
+        const localDataDir = join(cwd, ".unerr");
+        // ── Repo Info ──────────────────────────────────────────────
+        let repoId = "";
+        const configPath = join(unerrDir, "config.json");
+        if (existsSync(configPath)) {
+            try {
+                const config = JSON.parse(readFileSync(configPath, "utf-8"));
+                repoId = config.repoId ?? "";
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // ── Git Context ────────────────────────────────────────────
+        let currentBranch = "unknown";
+        let commitsAhead = 0;
+        let commitsBehind = null;
+        try {
+            const { computeBranchContext } = await import("../tracking/branch-context.js");
+            const ctx = await computeBranchContext(cwd);
+            currentBranch = ctx.currentBranch;
+            commitsAhead = ctx.commitsAhead;
+            commitsBehind = ctx.commitsBehind;
+        }
+        catch {
+            /* ignore */
+        }
+        const branchDetail = commitsBehind !== null
+            ? `${currentBranch} (${commitsAhead} ahead, ${commitsBehind} behind)`
+            : `${currentBranch} (${commitsAhead} ahead)`;
+        // ── Repo Name ──────────────────────────────────────────────
+        let repoFullName = repoId;
+        const remote = await getRemoteUrl(cwd);
+        if (remote) {
+            const sshMatch = remote.match(/git@[^:]+:(.+?)(?:\.git)?$/);
+            const httpMatch = remote.match(/(?:https?:\/\/)?(?:www\.)?[^/]+\/(.+?)(?:\.git)?$/);
+            repoFullName = sshMatch?.[1] ?? httpMatch?.[1] ?? repoId;
+        }
+        // ── Proxy Status ───────────────────────────────────────────
+        let proxyStatus = "Not running";
+        let proxyRunning = false;
+        const pidPath = join(unerrDir, "state", "proxy.pid");
+        if (existsSync(pidPath)) {
+            try {
+                const pidStr = readFileSync(pidPath, "utf-8").trim();
+                const pid = Number.parseInt(pidStr, 10);
+                process.kill(pid, 0);
+                proxyStatus = `Running (PID ${pid})`;
+                proxyRunning = true;
+            }
+            catch {
+                proxyStatus = "Not running (stale PID)";
+            }
+        }
+        // ── Graph Stats ────────────────────────────────────────────
+        let graphInfo = "No local graph";
+        const manifestsDir = join(localDataDir, "manifests");
+        if (repoId && existsSync(join(manifestsDir, `${repoId}.json`))) {
+            try {
+                const manifest = JSON.parse(readFileSync(join(manifestsDir, `${repoId}.json`), "utf-8"));
+                const entityCount = manifest.entityCount ?? 0;
+                const edgeCount = manifest.edgeCount ?? 0;
+                const pulledAt = manifest.pulledAt;
+                let ageStr = "";
+                if (pulledAt) {
+                    const ageMs = Date.now() - new Date(pulledAt).getTime();
+                    const ageHours = Math.floor(ageMs / 3_600_000);
+                    if (ageHours < 1)
+                        ageStr = "indexed <1h ago";
+                    else if (ageHours < 24)
+                        ageStr = `indexed ${ageHours}h ago`;
+                    else
+                        ageStr = `indexed ${Math.floor(ageHours / 24)}d ago`;
+                }
+                graphInfo = `${entityCount.toLocaleString()} entities, ${edgeCount.toLocaleString()} edges${ageStr ? ` (${ageStr})` : ""}`;
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // ── Drift Stats ────────────────────────────────────────────
+        let drift;
+        const driftSummaryPath = join(unerrDir, "drift", "drift_summary.json");
+        if (existsSync(driftSummaryPath)) {
+            try {
+                const summary = JSON.parse(readFileSync(driftSummaryPath, "utf-8"));
+                drift = {
+                    modified: summary.modified ?? 0,
+                    added: summary.added ?? 0,
+                    deleted: summary.deleted ?? 0,
+                };
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // ── Health Grade ───────────────────────────────────────────
+        let healthGrade;
+        let healthScore;
+        const graphVersionPath = join(unerrDir, "state", "graph_version.json");
+        if (existsSync(graphVersionPath)) {
+            try {
+                const gv = JSON.parse(readFileSync(graphVersionPath, "utf-8"));
+                healthGrade = gv.health_grade;
+                healthScore = gv.health_score;
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // ── Rule Health ───────────────────────────────────────────
+        let ruleHealth;
+        if (repoId) {
+            try {
+                const snapshotsDir = join(localDataDir, "snapshots");
+                let snapshotPath = join(snapshotsDir, "graph.msgpack.gz");
+                if (!existsSync(snapshotPath)) {
+                    snapshotPath = join(snapshotsDir, "graph.msgpack");
+                }
+                if (existsSync(snapshotPath)) {
+                    const { gunzipSync } = await import("node:zlib");
+                    const { unpack } = await import("msgpackr");
+                    const { default: CozoDbConstructor } = await import("cozo-node");
+                    const { CozoGraphStore } = await import("../intelligence/local-graph.js");
+                    const raw = readFileSync(snapshotPath);
+                    let buffer;
+                    try {
+                        buffer = gunzipSync(raw);
+                    }
+                    catch {
+                        buffer = raw;
+                    }
+                    const db = new CozoDbConstructor();
+                    const graph = await CozoGraphStore.create(db);
+                    const envelope = unpack(buffer);
+                    await graph.loadSnapshot(envelope);
+                    ruleHealth = await graph.getRuleHealthSummary();
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // ── Live Session Stats + Latency ───────────────────────────
+        let liveToolCalls;
+        let latency;
+        const statsPath = join(unerrDir, "state", "session_stats.json");
+        if (existsSync(statsPath) && proxyRunning) {
+            try {
+                const liveStats = JSON.parse(readFileSync(statsPath, "utf-8"));
+                const localCalls = liveStats.toolCallsLocal ?? 0;
+                if (localCalls > 0) {
+                    liveToolCalls = { local: localCalls };
+                }
+                const localL = liveStats.latency?.local;
+                if (localL) {
+                    latency = {
+                        localP50: localL.p50,
+                        localP99: localL.p99,
+                        localBudgetExceeded: localL.p99 > 5,
+                    };
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // ── Local Mode Status ────────────────────────────────────
+        // Firewall status
+        let firewallStatus = "Not active (proxy not running)";
+        let firewallBlocked;
+        if (proxyRunning) {
+            firewallStatus = "Sealed (active)";
+        }
+        try {
+            const firewallStatsPath = join(unerrDir, "state", "firewall_stats.json");
+            if (existsSync(firewallStatsPath)) {
+                const fs = JSON.parse(readFileSync(firewallStatsPath, "utf-8"));
+                firewallBlocked = fs.blocked ?? 0;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        // BYO-LLM
+        let byoLlm;
+        let byoLlmStatus = "not_configured";
+        const { loadSettings } = await import("../config/settings.js");
+        const settings = loadSettings();
+        if (settings.localLlm) {
+            const { resolveEmbeddingEndpoint, resolveInferenceEndpoint } = await import("../config/settings.js");
+            const embEp = resolveEmbeddingEndpoint(settings.localLlm);
+            const infEp = resolveInferenceEndpoint(settings.localLlm);
+            const embDesc = embEp.baseUrl
+                ? `${embEp.provider} at ${embEp.baseUrl}`
+                : embEp.provider;
+            byoLlm = `embed: ${embDesc} (${embEp.model})`;
+            const infDesc = infEp.baseUrl
+                ? `${infEp.provider} at ${infEp.baseUrl}`
+                : infEp.provider;
+            byoLlm += `, chat: ${infDesc} (${infEp.model})`;
+            // Health check against the embedding endpoint
+            if (embEp.baseUrl) {
+                try {
+                    const stripped = embEp.baseUrl.replace(/\/+$/, "");
+                    const healthUrl = embEp.provider === "ollama"
+                        ? `${stripped}/api/tags`
+                        : `${stripped}/v1/models`;
+                    const headers = {};
+                    if (embEp.apiKey)
+                        headers.Authorization = `Bearer ${embEp.apiKey}`;
+                    const hc = await fetch(healthUrl, {
+                        headers,
+                        signal: AbortSignal.timeout(2000),
+                    });
+                    byoLlmStatus = hc.ok ? "connected" : "unreachable";
+                }
+                catch {
+                    byoLlmStatus = "unreachable";
+                }
+            }
+        }
+        else {
+            byoLlm = "Not configured";
+        }
+        // Last indexed
+        let lastIndexed;
+        const snapshotMetaPath = join(unerrDir, "state", "snapshot_meta.json");
+        if (existsSync(snapshotMetaPath)) {
+            try {
+                const meta = JSON.parse(readFileSync(snapshotMetaPath, "utf-8"));
+                if (meta.indexedAt) {
+                    const ageMs = Date.now() - new Date(meta.indexedAt).getTime();
+                    const ageHours = Math.floor(ageMs / 3_600_000);
+                    const ageStr = ageHours < 1
+                        ? "<1h ago"
+                        : ageHours < 24
+                            ? `${ageHours}h ago`
+                            : `${Math.floor(ageHours / 24)}d ago`;
+                    lastIndexed = ageStr;
+                    if (meta.fileCount)
+                        lastIndexed += ` (${meta.fileCount} files`;
+                    if (meta.elapsedMs)
+                        lastIndexed += ` in ${(meta.elapsedMs / 1000).toFixed(1)}s`;
+                    if (meta.fileCount)
+                        lastIndexed += ")";
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // Corrections count
+        let corrections;
+        try {
+            const corrPath = join(unerrDir, "state", "corrections_count.json");
+            if (existsSync(corrPath)) {
+                const cc = JSON.parse(readFileSync(corrPath, "utf-8"));
+                corrections = cc.count;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        // Community, convention, rule counts from graph_version.json
+        let communityCount;
+        let conventionCount;
+        let ruleCount;
+        try {
+            if (existsSync(graphVersionPath)) {
+                const gv = JSON.parse(readFileSync(graphVersionPath, "utf-8"));
+                communityCount = gv.community_count;
+                conventionCount = gv.convention_count;
+                ruleCount = gv.rule_count;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        // ── Hook Status (S6.6) ─────────────────────────────────────
+        let hookStatus;
+        try {
+            const { isClaudeHookInstalled } = await import("../config/hook-installer.js");
+            const { isConfigured } = await import("../config/mcp-config-writer.js");
+            const { detectTools } = await import("../config/tool-detector.js");
+            const tools = detectTools(cwd);
+            const parts = [];
+            if (isClaudeHookInstalled(cwd)) {
+                parts.push("Claude hook: installed");
+            }
+            for (const tool of tools) {
+                if (isConfigured(cwd, tool.ide)) {
+                    const name = tool.ide === "claude-code"
+                        ? "Claude Code"
+                        : tool.ide === "vscode"
+                            ? "VS Code"
+                            : tool.ide.charAt(0).toUpperCase() + tool.ide.slice(1);
+                    parts.push(`${name} MCP: configured`);
+                }
+            }
+            if (parts.length > 0) {
+                hookStatus = parts.join(", ");
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        // Installed skills
+        let skillCount;
+        let skillNames;
+        try {
+            const { detectIde } = await import("../utils/detect.js");
+            const { listInstalledSkills } = await import("../skills/resolver.js");
+            const ide = await detectIde(cwd);
+            const skills = listInstalledSkills(ide, cwd);
+            skillCount = skills.length;
+            skillNames = skills.map((s) => s.name);
+        }
+        catch {
+            /* ignore */
+        }
+        // Ledger entry count
+        let ledgerEntryCount;
+        try {
+            const ledgerPath = join(unerrDir, "ledger", "shadow.jsonl");
+            if (existsSync(ledgerPath)) {
+                const content = readFileSync(ledgerPath, "utf-8");
+                ledgerEntryCount = content
+                    .split("\n")
+                    .filter((l) => l.trim().length > 0).length;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        // Log file path (latest log)
+        let logPath;
+        try {
+            const logsDir = join(unerrDir, "logs");
+            if (existsSync(logsDir)) {
+                const { readdirSync, statSync } = await import("node:fs");
+                const logs = readdirSync(logsDir)
+                    .filter((f) => f.startsWith("session-") && f.endsWith(".log"))
+                    .map((f) => ({
+                    name: f,
+                    mtime: statSync(join(logsDir, f)).mtimeMs,
+                }))
+                    .sort((a, b) => b.mtime - a.mtime);
+                if (logs[0]) {
+                    logPath = `.unerr/logs/${logs[0].name}`;
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        // Cumulative local stats
+        let cumulative;
+        try {
+            const { loadCumulativeLocalStats } = await import("../proxy/session-stats.js");
+            const cls = loadCumulativeLocalStats();
+            if (cls.totalSessions > 0) {
+                cumulative = {
+                    sessions: cls.totalSessions,
+                    toolCalls: cls.totalToolCalls,
+                    tokensSaved: cls.totalTokensSaved,
+                    violations: cls.totalViolationsCaught,
+                    corrections: cls.totalCorrectionsApplied,
+                };
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        // Last session summary (when proxy is NOT running)
+        let lastSession;
+        if (!proxyRunning) {
+            try {
+                const statsPath2 = join(unerrDir, "state", "session_stats.json");
+                if (existsSync(statsPath2)) {
+                    const raw = JSON.parse(readFileSync(statsPath2, "utf-8"));
+                    const totalCalls = raw.toolCallsLocal ?? 0;
+                    if (totalCalls > 0) {
+                        const endTime = raw.updatedAt
+                            ? new Date(raw.updatedAt)
+                            : new Date();
+                        const startTime = raw.sessionStartedAt
+                            ? new Date(raw.sessionStartedAt)
+                            : endTime;
+                        const durationMin = Math.round((endTime.getTime() - startTime.getTime()) / 60_000);
+                        const ageMs = Date.now() - endTime.getTime();
+                        const ageHours = Math.floor(ageMs / 3_600_000);
+                        const endedAtStr = ageHours < 1
+                            ? "<1h ago"
+                            : ageHours < 24
+                                ? `${ageHours}h ago`
+                                : `${Math.floor(ageHours / 24)}d ago`;
+                        lastSession = {
+                            endedAt: endedAtStr,
+                            durationMin: durationMin > 0 ? durationMin : 1,
+                            toolCalls: totalCalls,
+                            violationsCaught: raw.violationsCaught ?? 0,
+                            tokensSaved: totalCalls * 3200,
+                        };
+                    }
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // Suggestions engine
+        const suggestions = buildSuggestions({
+            byoLlmStatus,
+            lastIndexed,
+            conventionCount,
+            skillCount,
+            proxyRunning,
+            healthGrade,
+        });
+        let shellCompression;
+        let preBashHookConfigured = false;
+        try {
+            const sp = join(cwd, ".claude", "settings.json");
+            if (existsSync(sp)) {
+                const raw = readFileSync(sp, "utf8");
+                preBashHookConfigured =
+                    raw.includes("unerr hook pre-bash") ||
+                        raw.includes('"unerr hook pre-bash"');
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        const { readShellCompressionAggregate } = await import("../proxy/shell-stats.js");
+        const shellAgg = readShellCompressionAggregate(cwd);
+        if (shellAgg || preBashHookConfigured) {
+            shellCompression = {
+                events: shellAgg?.totalEvents ?? 0,
+                tokensSavedApprox: shellAgg?.tokensSavedApprox ?? 0,
+                preBashHookConfigured,
+            };
+        }
+        // Read recent compression events for detailed display
+        const { readRecentCompressionLogs, readRecentFileReadLogs } = await import("../proxy/shell-compression-log.js");
+        const recentCompressionEvents = readRecentCompressionLogs(cwd, 10);
+        if (shellCompression && recentCompressionEvents.length > 0) {
+            shellCompression.recentEvents = recentCompressionEvents;
+        }
+        // Read recent file-read optimization events
+        const recentFileReadEvents = readRecentFileReadLogs(cwd, 10);
+        const localModeData = {
+            mode: "local",
+            firewallStatus,
+            firewallBlocked,
+            byoLlm,
+            byoLlmStatus,
+            lastIndexed,
+            corrections,
+            communityCount,
+            conventionCount,
+            ruleCount,
+            hookStatus,
+            shellCompression,
+            recentFileReadEvents: recentFileReadEvents.length > 0 ? recentFileReadEvents : undefined,
+            skillCount,
+            skillNames,
+            logPath,
+            ledgerEntryCount,
+            suggestions,
+            cumulative,
+            lastSession,
+        };
+        // ── Render Ink Dashboard ───────────────────────────────────
+        // Layer 10: Read token flow data for status display
+        let tokenFlowData = undefined;
+        try {
+            const { readTokenFlowEvents, aggregateSession: aggSession } = await import("../tracking/token-flow.js");
+            const events = readTokenFlowEvents(unerrDir);
+            if (events.length > 0) {
+                const latestSessionId = events[events.length - 1]?.session_id ?? "";
+                const summary = aggSession(events, latestSessionId);
+                if (summary.total_tokens_saved > 0) {
+                    tokenFlowData = {
+                        tokensSaved: summary.total_tokens_saved,
+                        tokensDelivered: summary.total_tokens_with,
+                        efficiencyPct: summary.efficiency_pct,
+                        byMechanism: Object.entries(summary.by_mechanism)
+                            .sort(([, a], [, b]) => b.tokens_saved - a.tokens_saved)
+                            .map(([mechanism, data]) => ({
+                            mechanism,
+                            tokensSaved: data.tokens_saved,
+                            pctOfTotal: data.pct_of_total,
+                        })),
+                        topTurn: summary.top_turns[0]
+                            ? {
+                                tool: summary.top_turns[0].tool,
+                                tokensSaved: summary.top_turns[0].tokens_saved,
+                            }
+                            : undefined,
+                    };
+                }
+            }
+        }
+        catch {
+            /* non-critical */
+        }
+        const statusData = {
+            repoName: repoFullName || "(no repo)",
+            repoId: repoId || undefined,
+            branch: currentBranch,
+            branchDetail,
+            proxyStatus,
+            proxyRunning,
+            graphInfo,
+            drift,
+            healthGrade,
+            healthScore,
+            latency,
+            liveToolCalls,
+            ruleHealth,
+            localMode: localModeData,
+            tokenFlow: tokenFlowData,
+        };
+        try {
+            const { StatusDashboard } = await import("../components/StatusDashboard.js");
+            const { ThemeProvider } = await import("../components/Theme.js");
+            const { renderToStderr } = await import("../components/render.js");
+            const el = React.createElement(ThemeProvider, null, React.createElement(StatusDashboard, { data: statusData }));
+            const inst = renderToStderr(el);
+            inst.unmount();
+        }
+        catch {
+            // Fallback to plain text
+            const lm = statusData.localMode;
+            let output = `
+  Repo:     ${statusData.repoName}${statusData.repoId ? ` (${statusData.repoId})` : ""}
+  Branch:   ${statusData.branchDetail}
+  Mode:     Local (offline)
+  Proxy:    ${statusData.proxyStatus}
+  Graph:    ${statusData.graphInfo}
+`;
+            if (lm) {
+                output += `  Firewall: ${lm.firewallStatus}${lm.firewallBlocked != null ? ` (${lm.firewallBlocked} blocked)` : ""}\n`;
+                if (lm.byoLlm)
+                    output += `  BYO-LLM:  ${lm.byoLlm}\n`;
+                if (lm.lastIndexed)
+                    output += `  Indexed:  ${lm.lastIndexed}\n`;
+                if (lm.communityCount)
+                    output += `  Communities: ${lm.communityCount} clusters\n`;
+                if (lm.conventionCount)
+                    output += `  Conventions: ${lm.conventionCount} detected\n`;
+                if (lm.ruleCount)
+                    output += `  Rules:    ${lm.ruleCount} active\n`;
+                if (lm.hookStatus)
+                    output += `  Hooks:    ${lm.hookStatus}\n`;
+                if (lm.skillCount != null) {
+                    output += `  Skills:   ${lm.skillCount} installed\n`;
+                    if (lm.skillNames) {
+                        for (const n of lm.skillNames)
+                            output += `    ${n}\n`;
+                    }
+                }
+                if (lm.ledgerEntryCount)
+                    output += `  Ledger:   ${lm.ledgerEntryCount} entries\n`;
+                if (lm.logPath)
+                    output += `  Logs:     ${lm.logPath}\n`;
+                if (!statusData.proxyRunning && lm.lastSession) {
+                    output += `\n  Last session (${lm.lastSession.endedAt}, ${lm.lastSession.durationMin} min):\n`;
+                    output += `    Tool calls: ${lm.lastSession.toolCalls} (all local)\n`;
+                    if (lm.lastSession.violationsCaught > 0)
+                        output += `    Violations: ${lm.lastSession.violationsCaught} caught\n`;
+                    if (lm.lastSession.tokensSaved > 0)
+                        output += `    Tokens:     ~${lm.lastSession.tokensSaved.toLocaleString()} saved\n`;
+                }
+                if (lm.cumulative && lm.cumulative.sessions > 0) {
+                    const c = lm.cumulative;
+                    output += "\n  This Week (Local Mode):\n";
+                    output += `    Sessions:     ${c.sessions}\n`;
+                    output += `    Tool calls:   ${c.toolCalls.toLocaleString()}\n`;
+                    output += `    Tokens saved: ~${c.tokensSaved.toLocaleString()}\n`;
+                    output += `    Violations:   ${c.violations} caught\n`;
+                }
+                if (lm.suggestions && lm.suggestions.length > 0) {
+                    output += "\n  Suggestions:\n";
+                    for (const s of lm.suggestions)
+                        output += `    · ${s}\n`;
+                }
+            }
+            process.stderr.write(output);
+        }
+    });
+}