flowfig 0.7.0 → 0.8.0

package/dist/verify.d.ts

@@ -1,7 +1,29 @@
-import type { FlowProps } from './model.ts';
+import { type FlowProps } from './model.ts';
 import type { Finding } from './scene.ts';
+import { type Read } from './code.ts';
 export { parseSource, headingSlug, owners, links, type Link } from './source.ts';
+export type Coverage = {
+    boxes: number;
+    boxesDefined: number;
+    found: number;
+    notFound: number;
+    unsure: number;
+    notChecked: number;
+    unsureEdges: {
+        id: string;
+        reason: string;
+    }[];
+};
+export declare const coverageLine: (figure: string, c: Coverage) => string;
+export declare const unsureLines: (c: Coverage) => string[];
 /** The links against the files under `root`. A path outside `root` counts as a missing file. */
-export declare function verify(fig: FlowProps, { root }?: {
+export declare function verifyReport(fig: FlowProps, { root, read }?: {
     root?: string;
-}): Finding[];
+    read?: Read;
+}): {
+    findings: Finding[];
+    coverage: Coverage;
+};
+export declare const verify: (fig: FlowProps, opts?: {
+    root?: string;
+}) => Finding[];

package/dist/verify.js

@@ -1,40 +1,85 @@
-import { readFileSync, statSync } from 'node:fs';
-import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { resolve } from 'node:path';
+import { edgeId, nodes, toBeat } from './model.js';
 import { headingSlug, links } from './source.js';
+import { codeFile, isDefined, outside, readFile } from './code.js';
+import { edgeResult } from './edges.js';
 export { parseSource, headingSlug, owners, links } from './source.js';
 const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-function read(full) {
-    try {
-        return statSync(full).isFile() ? readFileSync(full, 'utf8') : null;
-    }
-    catch {
-        return null;
-    }
-}
 const hasHeading = (text, slug) => text.split('\n').some((line) => {
     const m = /^#{1,6}\s+(.*?)\s*#*\s*$/.exec(line);
     return m != null && headingSlug(m[1]) === slug;
 });
+const emptyCoverage = () => ({ boxes: 0, boxesDefined: 0, found: 0, notFound: 0, unsure: 0, notChecked: 0, unsureEdges: [] });
+export const coverageLine = (figure, c) => `${figure}: ${c.boxesDefined} of ${c.boxes} boxes defined` +
+    (c.found + c.notFound + c.unsure + c.notChecked
+        ? `; edges: ${c.found} found, ${c.notFound} not found, ${c.unsure} unsure, ${c.notChecked} not checked`
+        : '');
+export const unsureLines = (c) => c.unsureEdges.map((e) => `unsure   edge "${e.id}": ${e.reason}`);
 /** The links against the files under `root`. A path outside `root` counts as a missing file. */
-export function verify(fig, { root = process.cwd() } = {}) {
-    const out = [];
+export function verifyReport(fig, { root = process.cwd(), read = readFile } = {}) {
+    const findings = [];
+    const coverage = emptyCoverage();
     const all = links(fig);
     if (!all.length)
-        return [{ rule: 'no-source', severity: 'warning', ids: [], message: 'no box, edge or hop has a source' }];
+        return {
+            findings: [{ rule: 'no-source', severity: 'warning', ids: [], message: 'no box, edge or hop has a source' }],
+            coverage,
+        };
     const files = new Map();
+    const parsed = new Map();
     for (const l of all) {
         const full = resolve(root, l.path);
-        const rel = relative(root, full);
-        const outside = isAbsolute(l.path) || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel);
         if (!files.has(full))
-            files.set(full, outside ? null : read(full));
+            files.set(full, outside(root, l.path) ? null : read(full));
         const text = files.get(full);
+        const before = findings.length;
+        const fail = (rule, what) => findings.push({ rule, severity: 'error', ids: [], message: `${l.owner} -> ${l.source}: ${what}` });
         if (text == null)
-            out.push({ rule: 'missing-file', severity: 'error', ids: [], message: `${l.owner} -> ${l.source}: file not found` });
-        else if (l.symbol &&
-            !new RegExp(`(^|[^\\w$])${escape(l.symbol)}(?![\\w$])`).test(text) &&
-            !(/\.(md|markdown)$/i.test(l.path) && hasHeading(text, l.symbol)))
-            out.push({ rule: 'missing-symbol', severity: 'error', ids: [], message: `${l.owner} -> ${l.source}: symbol not found` });
+            fail('missing-file', 'file not found');
+        else if (l.symbol) {
+            const code = codeFile(root, l.path, read, parsed);
+            if (code) {
+                if (!isDefined(code, l.symbol))
+                    fail('missing-symbol', 'symbol not defined');
+            }
+            else if (!new RegExp(`(^|[^\\w$])${escape(l.symbol)}(?![\\w$])`).test(text) &&
+                !(/\.(md|markdown)$/i.test(l.path) && hasHeading(text, l.symbol)))
+                fail('missing-symbol', 'symbol not found');
+        }
+        if (l.owner.startsWith('box "')) {
+            coverage.boxes++;
+            if (findings.length === before)
+                coverage.boxesDefined++;
+        }
     }
-    return out;
+    const source = new Map(nodes(fig.layout).map((n) => [n.id, n.source]));
+    const check = (who, id, caller, callee, via) => {
+        const { result, reason } = caller ? edgeResult(root, caller, callee, via, read, parsed) : { result: 'not-checked', reason: '' };
+        if (result === 'found')
+            coverage.found++;
+        else if (result === 'not-found') {
+            coverage.notFound++;
+            findings.push({ rule: 'edge-not-found', severity: 'warning', ids: [id], message: `${who}: ${reason}` });
+        }
+        else if (result === 'unsure') {
+            coverage.unsure++;
+            coverage.unsureEdges.push({ id, reason });
+        }
+        else
+            coverage.notChecked++;
+    };
+    for (const e of fig.edges)
+        check(`edge "${edgeId(e)}"`, edgeId(e), e.source ?? source.get(e.from), source.get(e.to), e.via);
+    const byId = new Map(fig.edges.map((e) => [edgeId(e), e]));
+    for (const step of fig.steps ?? [])
+        for (const beat of step.flow)
+            for (const h of toBeat(beat).hops) {
+                const e = byId.get(h.edge);
+                if (!e || (h.source == null && h.via == null))
+                    continue;
+                const [a, b] = h.back ? [e.to, e.from] : [e.from, e.to];
+                check(`hop on "${h.edge}"`, h.edge, h.source ?? (h.back ? undefined : e.source) ?? source.get(a), source.get(b), h.via);
+            }
+    return { findings, coverage };
 }
+export const verify = (fig, opts = {}) => verifyReport(fig, opts).findings;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.7.0";
+export declare const VERSION = "0.8.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 // The release list bumps this with package.json.
-export const VERSION = '0.7.0';
+export const VERSION = '0.8.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowfig",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Your coding agent draws animated diagrams from your code, and flowfig checks them. One animated SVG for a GitHub README, PR or issue, and a React player. Set up Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, Windsurf and Kiro with npx flowfig init.",
   "license": "MIT",
   "repository": {