loopgraph 0.1.0

package/dist/query/slice.js

@@ -0,0 +1,124 @@
+import { getNode } from "../loader/model-graph.js";
+import { resolveApplicableScenarios, scenarioApplies } from "./effective-constraints.js";
+/** Every related node id (forward + relevant reverse edges), deduped, kind-tagged. */
+function neighbors(graph, node) {
+    const out = [];
+    const add = (id, kind) => out.push({ id, kind });
+    switch (node.kind) {
+        case "feature":
+            for (const f of node.contains)
+                add(f, "flow");
+            break;
+        case "flow":
+            for (const l of node.traverses)
+                add(l, "loop");
+            for (const l of node.guarded_by)
+                add(l, "loop");
+            for (const j of node.crosses)
+                add(j, "junction");
+            for (const f of node.references)
+                add(f, "flow");
+            break;
+        case "loop": {
+            if (node.parent)
+                add(node.parent, "loop");
+            for (const s of node.scenarios)
+                add(s, "scenario");
+            // reverse: junctions this loop sits between, flows that traverse/guard it
+            for (const j of graph.byKind.junction.values())
+                if (j.between.includes(node.id))
+                    add(j.id, "junction");
+            for (const f of graph.byKind.flow.values())
+                if (f.traverses.includes(node.id) || f.guarded_by.includes(node.id))
+                    add(f.id, "flow");
+            // effective constraints: invariant scenarios that apply via applies_to
+            for (const s of resolveApplicableScenarios(graph, node.id))
+                add(s.id, "scenario");
+            break;
+        }
+        case "junction":
+            for (const l of node.between)
+                add(l, "loop");
+            for (const s of node.scenarios)
+                add(s, "scenario");
+            break;
+        case "scenario": {
+            for (const targetId of node.applies_to?.nodes ?? []) {
+                const target = getNode(graph, targetId);
+                if (target)
+                    add(targetId, target.kind);
+            }
+            // reverse: nodes that list this scenario, plus loops it applies to via owner_match
+            for (const l of graph.byKind.loop.values()) {
+                if (l.scenarios.includes(node.id))
+                    add(l.id, "loop");
+                else if (scenarioApplies(node, l.id, graph))
+                    add(l.id, "loop");
+            }
+            for (const j of graph.byKind.junction.values())
+                if (j.scenarios.includes(node.id))
+                    add(j.id, "junction");
+            break;
+        }
+        case "debt":
+            break;
+    }
+    const seen = new Set();
+    return out.filter((n) => (seen.has(n.id) ? false : seen.add(n.id)));
+}
+/**
+ * Depth-limited breadth-first slice from `rootId`. Returns undefined if the
+ * root id isn't a node in the graph (the CLI turns that into an "unknown id"
+ * error).
+ *
+ * Standard mark-at-enqueue BFS: a node is added to `enqueued` the moment it's
+ * first discovered, so (a) each node is enqueued exactly once and recorded at
+ * its shortest distance from the root, and (b) any node reachable within
+ * `maxDepth` is marked (via its shallower parent, which the depth-ordered FIFO
+ * dequeues first) before a depth==maxDepth sibling could add it to the
+ * frontier — so `frontierPointers` and the in-slice node set never overlap by
+ * construction, no post-hoc reconciliation needed.
+ */
+export function sliceModel(graph, rootId, maxDepth) {
+    const root = getNode(graph, rootId);
+    if (!root)
+        return undefined;
+    const enqueued = new Set([rootId]);
+    const nodesById = new Map();
+    const frontier = new Map();
+    const queue = [{ id: rootId, depth: 0 }];
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (!item)
+            break; // queue.length>0 guarantees this; guard, not assertion
+        const { id, depth } = item;
+        const node = getNode(graph, id);
+        if (!node)
+            continue; // dangling reference — T0's referential-integrity check owns reporting it
+        const sliceNode = { id, kind: node.kind, depth, node };
+        if (node.kind === "loop") {
+            sliceNode.effectiveConstraints = resolveApplicableScenarios(graph, id).map((s) => s.id);
+        }
+        nodesById.set(id, sliceNode);
+        for (const nb of neighbors(graph, node)) {
+            if (enqueued.has(nb.id))
+                continue; // already in-slice (or queued to be) — never a frontier pointer
+            if (depth < maxDepth) {
+                enqueued.add(nb.id);
+                queue.push({ id: nb.id, depth: depth + 1 });
+            }
+            else if (!frontier.has(nb.id)) {
+                frontier.set(nb.id, { id: nb.id, kind: nb.kind, fromId: id });
+            }
+        }
+    }
+    const nodes = [...nodesById.values()].sort((a, b) => a.depth - b.depth || a.id.localeCompare(b.id));
+    return {
+        rootId,
+        rootKind: root.kind,
+        maxDepth,
+        nodes,
+        frontierPointers: [...frontier.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    };
+}
+//# sourceMappingURL=slice.js.map

package/dist/query/summary.d.ts

@@ -0,0 +1,9 @@
+import type { ModelSlice } from "./slice.js";
+/**
+ * Compact stdout summary. `outputPath` is named so the truncation hint can
+ * point the reader at the full side-channel file.
+ */
+export declare function summarizeSlice(slice: ModelSlice, outputPath: string): string;
+/** Full side-channel body: banner + every node's complete detail, nothing truncated. */
+export declare function renderSliceMarkdown(slice: ModelSlice, banner: string): string;
+//# sourceMappingURL=summary.d.ts.map

package/dist/query/summary.js

@@ -0,0 +1,180 @@
+/**
+ * Summary + full-render for a ModelSlice (Proposal 006 A5), factored out
+ * alongside sliceModel so the Phase 2 query family shares one truncation
+ * policy. Two outputs:
+ *  - `summarizeSlice`: compact stdout digest. Keeps EVERY node's skeleton
+ *    (id/title/risk_class/status + child counts); truncates only the
+ *    evidence/scenario prose, with an explicit "full detail in <file>" hint.
+ *  - `renderSliceMarkdown`: the full side-channel body (nothing truncated).
+ */
+const KIND_ORDER = ["feature", "flow", "loop", "junction", "scenario", "debt"];
+/** A short, single-line human label for a node — its "skeleton" identity. */
+function label(node) {
+    switch (node.kind) {
+        case "feature":
+        case "flow":
+        case "loop":
+            return node.title;
+        case "junction":
+            return node.title ?? "(untitled junction)";
+        case "scenario":
+            return truncate(node.given, 60);
+        case "debt":
+            return node.subject;
+    }
+}
+/** Bracketed status/classification tag for the skeleton line. */
+function tag(node) {
+    switch (node.kind) {
+        case "feature":
+        case "flow":
+        case "loop":
+            return node.status;
+        case "junction":
+            return `${node.risk_class}/${node.status}`;
+        case "scenario":
+            return node.level;
+        case "debt":
+            return node.category;
+    }
+}
+/** Child-count suffix shown on the skeleton line (the counts, never the prose). */
+function counts(sn) {
+    const n = sn.node;
+    switch (n.kind) {
+        case "flow":
+            return `loops:${n.traverses.length + n.guarded_by.length} junctions:${n.crosses.length}`;
+        case "loop":
+            return `scenarios:${n.scenarios.length} eff:${sn.effectiveConstraints?.length ?? 0}`;
+        case "junction":
+            return `evidence:${n.evidence.length} scenarios:${n.scenarios.length}`;
+        case "scenario":
+            return `verified:${n.verified_by.length}`;
+        default:
+            return "";
+    }
+}
+function truncate(s, max) {
+    const oneLine = s.replace(/\s+/g, " ").trim();
+    return oneLine.length <= max ? oneLine : `${oneLine.slice(0, max - 1)}…`;
+}
+function groupByKind(nodes) {
+    const groups = new Map();
+    for (const sn of nodes) {
+        const list = groups.get(sn.kind) ?? [];
+        list.push(sn);
+        groups.set(sn.kind, list);
+    }
+    return groups;
+}
+/**
+ * Compact stdout summary. `outputPath` is named so the truncation hint can
+ * point the reader at the full side-channel file.
+ */
+export function summarizeSlice(slice, outputPath) {
+    const groups = groupByKind(slice.nodes);
+    const lines = [
+        `inspect ${slice.rootId} (${slice.rootKind}) — depth ${slice.maxDepth}, ${slice.nodes.length} node(s)`,
+    ];
+    for (const kind of KIND_ORDER) {
+        const list = groups.get(kind);
+        if (!list || list.length === 0)
+            continue;
+        lines.push(`  ${kind} (${list.length}):`);
+        for (const sn of list) {
+            const c = counts(sn);
+            lines.push(`    ${sn.id}  ${label(sn.node)}  [${tag(sn.node)}]${c ? `  ${c}` : ""}`);
+        }
+    }
+    if (slice.frontierPointers.length > 0) {
+        lines.push(`  → ${slice.frontierPointers.length} node(s) beyond depth ${slice.maxDepth} not expanded (use --depth to go deeper):`);
+        lines.push(`    ${slice.frontierPointers.map((p) => `${p.id}(${p.kind})`).join(", ")}`);
+    }
+    // The one place details are truncated: evidence notes and scenario
+    // given/when/then never appear above — they live in the side-channel file.
+    lines.push(`  (evidence/scenario detail truncated — full slice written to ${outputPath})`);
+    return lines.join("\n");
+}
+function renderNodeDetail(sn) {
+    const n = sn.node;
+    const out = [`### ${n.id} — ${label(n)}  [${tag(n)}]  (depth ${sn.depth})`];
+    switch (n.kind) {
+        case "flow":
+            if (n.traverses.length)
+                out.push(`- traverses: ${n.traverses.join(", ")}`);
+            if (n.guarded_by.length)
+                out.push(`- guarded_by: ${n.guarded_by.join(", ")}`);
+            if (n.crosses.length)
+                out.push(`- crosses: ${n.crosses.join(", ")}`);
+            if (n.references.length)
+                out.push(`- references: ${n.references.join(", ")}`);
+            break;
+        case "loop":
+            out.push(`- boundary: ${n.boundary}`);
+            out.push(`- owner: ${n.owner ?? "(none — dormant)"}`);
+            if (n.anchors.length)
+                out.push(`- anchors: ${n.anchors.join(", ")}`);
+            if (n.scenarios.length)
+                out.push(`- scenarios: ${n.scenarios.join(", ")}`);
+            if (sn.effectiveConstraints?.length)
+                out.push(`- effective constraints (applies_to): ${sn.effectiveConstraints.join(", ")}`);
+            if (n.notes)
+                out.push(`- notes: ${n.notes}`);
+            break;
+        case "junction":
+            out.push(`- between: ${n.between.join(" → ")}`);
+            if (n.scenarios.length)
+                out.push(`- scenarios: ${n.scenarios.join(", ")}`);
+            for (const e of n.evidence)
+                out.push(`- evidence [${e.kind}] ${e.anchor}${e.note ? ` — ${e.note}` : ""}`);
+            break;
+        case "scenario":
+            out.push(`- given: ${n.given}`);
+            out.push(`- when: ${n.when}`);
+            out.push(`- then: ${n.then}`);
+            out.push(`- verified_by: ${n.verified_by.length ? n.verified_by.join(", ") : "(none)"}`);
+            if (n.applies_to)
+                out.push(`- applies_to: nodes=[${n.applies_to.nodes.join(", ")}]${n.applies_to.owner_match ? ` owner_match="${n.applies_to.owner_match}"` : ""}`);
+            break;
+        case "debt":
+            out.push(`- reality: ${n.reality}`);
+            if (n.claim)
+                out.push(`- claim: ${n.claim}`);
+            break;
+        case "feature":
+            if (n.contains.length)
+                out.push(`- contains: ${n.contains.join(", ")}`);
+            break;
+    }
+    return out;
+}
+/** Full side-channel body: banner + every node's complete detail, nothing truncated. */
+export function renderSliceMarkdown(slice, banner) {
+    const groups = groupByKind(slice.nodes);
+    const lines = [
+        banner,
+        "",
+        `# inspect ${slice.rootId} (${slice.rootKind}) — depth ${slice.maxDepth}`,
+        "",
+        `${slice.nodes.length} node(s) reached; ${slice.frontierPointers.length} pointer(s) at the frontier.`,
+        "",
+    ];
+    for (const kind of KIND_ORDER) {
+        const list = groups.get(kind);
+        if (!list || list.length === 0)
+            continue;
+        lines.push(`## ${kind} (${list.length})`, "");
+        for (const sn of list) {
+            lines.push(...renderNodeDetail(sn), "");
+        }
+    }
+    if (slice.frontierPointers.length > 0) {
+        lines.push(`## frontier (beyond depth ${slice.maxDepth} — re-run with --depth to expand)`, "");
+        for (const p of slice.frontierPointers) {
+            lines.push(`- ${p.id} (${p.kind}) — referenced by ${p.fromId}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=summary.js.map

package/dist/schema/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./status.js";
+export * from "./model.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.js

@@ -0,0 +1,3 @@
+export * from "./status.js";
+export * from "./model.js";
+//# sourceMappingURL=index.js.map