looply-cli 0.0.0-stage → 0.2.0

package/dist/project-graph-builder.d.ts

@@ -0,0 +1,81 @@
+import { type ProjectGraphSnapshot, type ProjectIndexSnapshot, type ProjectMemoryRecord } from '@looply/core';
+/**
+ * JOINING FIVE STORES INTO ONE ANSWERABLE SHAPE.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 IT DERIVES. IT NEVER ORIGINATES.
+ *
+ * Every node and every edge here traces to a record some other component
+ * already wrote: a file in the committed tree, a symbol the extractor found, an
+ * Item's own `goalId`, a memory record's own `kind`. Nothing is invented, and
+ * nothing is upgraded — a memory record of kind `inference` becomes a node of
+ * authority `model_inference` because that is what it already was, and there is
+ * no argument to this builder by which it could become anything else.
+ *
+ * That is the whole safety property, and it is achieved by NOT HAVING A KNOB
+ * rather than by validating one: `NODE_AUTHORITY` and `EDGE_AUTHORITY` are
+ * lookups on the type, and the type comes from the source record.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT IT COSTS TO BUILD, AND WHY THAT IS FINE
+ *
+ * Measured on this repository at the freeze: 563 tracked files, 440 TypeScript.
+ * The structural pass is one linear walk of the index's own already-sorted
+ * collections; there is no parsing here at all, because Phase 12 already did it
+ * and this consumes its output. A whole graph is cheaper than the index build
+ * that precedes it, which is why there is no incremental path — see the store.
+ */
+/** What the builder needs from the operational stores. Deliberately narrow. */
+export interface OperationalInput {
+    /**
+     * ⚠️ `text`, NOT `title`. A Goal's field is the user's own wording preserved
+     * verbatim, and naming it `title` here would invite a caller to pass a
+     * summary — which `goal.ts` refuses in the strongest terms it has.
+     */
+    readonly goals: readonly {
+        readonly id: string;
+        readonly text: string;
+        readonly version: number;
+    }[];
+    readonly items: readonly {
+        readonly id: string;
+        readonly title: string;
+        readonly goalId?: string | null;
+        readonly evidence: readonly {
+            readonly path: string;
+        }[];
+    }[];
+}
+export interface BuildGraphInput {
+    readonly projectKey: string;
+    readonly index: ProjectIndexSnapshot;
+    readonly memory: readonly ProjectMemoryRecord[];
+    readonly operational: OperationalInput;
+}
+/**
+ * 🔴 THE ONLY FIELDS OF A MEMORY RECORD THAT REACH THE GRAPH.
+ *
+ * Named as a list, and picked one at a time below rather than spread, because
+ * the failure this prevents is silent and permanent: a `{...record}` would carry
+ * `content` — which the store caps at a thousand characters precisely BECAUSE a
+ * field that long is a field that can hold a secret — into a derived file with
+ * its own lifetime and its own copies.
+ *
+ * The graph holds RELATIONSHIPS. The claims stay in memory, where Phase 11
+ * already bounds them, already redacts them, and already decides what a prompt
+ * may see. A query here returns memory IDS; the context builder resolves them
+ * back through the store. That is one authority for what a claim says, not two.
+ */
+export declare const MEMORY_NODE_FIELDS: readonly ["id", "kind", "subject"];
+/**
+ * Build the whole graph for one project at one moment.
+ *
+ * 🔴 REFUSED PARTS ARE DROPPED, NOT REPAIRED. `admitGraphNode` and
+ * `admitGraphEdge` are the same policy a test and a store can ask, and a builder
+ * that "fixed" a refusal would be a second place the policy lived — the exact
+ * duplication Phase 11 spent a fence on preventing. A dangling edge is dropped
+ * because a graph that names a node it does not have answers a question with an
+ * absence that reads as a finding.
+ */
+export declare function buildProjectGraph(input: BuildGraphInput): ProjectGraphSnapshot;
+//# sourceMappingURL=project-graph-builder.d.ts.map

package/dist/project-graph-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-graph-builder.d.ts","sourceRoot":"","sources":["../src/project-graph-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAsBL,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACpG,QAAQ,CAAC,KAAK,EAAE,SAAS;QACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAChC,QAAQ,CAAC,QAAQ,EAAE,SAAS;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KACzD,EAAE,CAAC;CACL;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAChD,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;CACxC;AAmCD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,oCAAqC,CAAC;AAgCrE;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,oBAAoB,CA6I9E"}

package/dist/project-graph-builder.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORY_NODE_FIELDS = void 0;
+exports.buildProjectGraph = buildProjectGraph;
+const core_1 = require("@looply/core");
+/**
+ * A file path a knowledge or work record refers to, normalised the ONE way.
+ *
+ * ⚠️ THROUGH `canonicalPath`'s RULES, NOT A SECOND OPINION. An Item's evidence
+ * and a memory record's `scope.path` are written by other components which do
+ * not necessarily agree with the index on a leading `./` or a backslash. Two
+ * spellings of one file would produce two nodes, and the whole join would come
+ * apart quietly — half the edges pointing at a path the index never emitted.
+ */
+function samePathAs(index) {
+    const known = new Set(index.files.map((f) => f.path));
+    return (raw) => {
+        const p = raw.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+        return known.has(p) ? p : null;
+    };
+}
+/** The memory kinds that become nodes, and the node type each becomes. */
+const MEMORY_NODE_TYPE = {
+    fact: 'fact',
+    decision: 'decision',
+    inference: 'inference',
+    attempt: 'attempt',
+};
+/** The edge a memory node hangs on, by kind. */
+const MEMORY_EDGE_TYPE = {
+    fact: 'fact_about',
+    decision: 'decision_about',
+    inference: 'inference_about',
+    attempt: 'attempt_on',
+};
+/**
+ * 🔴 THE ONLY FIELDS OF A MEMORY RECORD THAT REACH THE GRAPH.
+ *
+ * Named as a list, and picked one at a time below rather than spread, because
+ * the failure this prevents is silent and permanent: a `{...record}` would carry
+ * `content` — which the store caps at a thousand characters precisely BECAUSE a
+ * field that long is a field that can hold a secret — into a derived file with
+ * its own lifetime and its own copies.
+ *
+ * The graph holds RELATIONSHIPS. The claims stay in memory, where Phase 11
+ * already bounds them, already redacts them, and already decides what a prompt
+ * may see. A query here returns memory IDS; the context builder resolves them
+ * back through the store. That is one authority for what a claim says, not two.
+ */
+exports.MEMORY_NODE_FIELDS = ['id', 'kind', 'subject'];
+function truncateLabel(s) {
+    return s.length <= core_1.MAX_NODE_LABEL_CHARS ? s : s.slice(0, core_1.MAX_NODE_LABEL_CHARS);
+}
+function makeNode(type, sourceId, label, presence) {
+    return {
+        id: (0, core_1.nodeId)(type, sourceId),
+        type,
+        sourceId,
+        // From the table, never from an argument. See the header.
+        authority: core_1.NODE_AUTHORITY[type],
+        presence,
+        label: truncateLabel(label),
+    };
+}
+function makeEdge(type, from, to, provenance) {
+    return { id: (0, core_1.edgeId)(type, from, to), type, from, to, authority: core_1.EDGE_AUTHORITY[type], provenance };
+}
+/**
+ * Build the whole graph for one project at one moment.
+ *
+ * 🔴 REFUSED PARTS ARE DROPPED, NOT REPAIRED. `admitGraphNode` and
+ * `admitGraphEdge` are the same policy a test and a store can ask, and a builder
+ * that "fixed" a refusal would be a second place the policy lived — the exact
+ * duplication Phase 11 spent a fence on preventing. A dangling edge is dropped
+ * because a graph that names a node it does not have answers a question with an
+ * absence that reads as a finding.
+ */
+function buildProjectGraph(input) {
+    const nodes = new Map();
+    const edges = new Map();
+    const resolvePath = samePathAs(input.index);
+    const add = (n) => {
+        if ((0, core_1.admitGraphNode)(n).ok !== true)
+            return null;
+        /**
+         * First writer wins, which makes this pass ORDER-INDEPENDENT rather than
+         * protecting anything today.
+         *
+         * ⚠️ AND A MUTATION PROVED THAT DISTINCTION. Removing this guard changed no
+         * observable behaviour, because the only `historical` node is minted after
+         * `resolvePath` returned null — for a path the index does not have — so
+         * there can be no `current` node with that id to protect. The guard is
+         * cheap insurance against the structural and knowledge passes being
+         * reordered, and it is NOT the reason a current file stays current.
+         *
+         * Recorded rather than deleted, and recorded rather than left claiming a
+         * protection it does not perform: a comment that overstates what a line does
+         * is the defect this codebase keeps finding in its own docblocks.
+         */
+        if (!nodes.has(n.id))
+            nodes.set(n.id, n);
+        return n.id;
+    };
+    const link = (type, from, to, p) => {
+        if (from === null || to === null)
+            return;
+        const e = makeEdge(type, from, to, p);
+        if ((0, core_1.admitGraphEdge)(e, nodes).ok === true)
+            edges.set(e.id, e);
+    };
+    /* ── the project itself, so `contains` has a root ── */
+    const project = add(makeNode('project', input.projectKey, input.projectKey, 'current'));
+    /* ── structural: everything the committed tree establishes ── */
+    const indexRef = { via: 'project-index', refs: [input.index.treeSha] };
+    for (const name of input.index.packages) {
+        const pkg = add(makeNode('package', name, name, 'current'));
+        link('contains', project, pkg, indexRef);
+    }
+    for (const f of input.index.files) {
+        const file = add(makeNode('file', f.path, f.path, 'current'));
+        if (f.packageName !== null) {
+            link('contains', (0, core_1.nodeId)('package', f.packageName), file, indexRef);
+        }
+    }
+    for (const s of input.index.symbols) {
+        const sym = add(makeNode('symbol', s.id, s.name, 'current'));
+        link('declares', (0, core_1.nodeId)('file', s.file), sym, indexRef);
+    }
+    for (const i of input.index.imports) {
+        if (i.resolved === null)
+            continue;
+        const from = (0, core_1.nodeId)('file', i.from);
+        const to = (0, core_1.nodeId)('file', i.resolved);
+        link('imports', from, to, indexRef);
+        /**
+         * ⚠️ AND SEPARATELY, IF THE IMPORTER IS A TEST. Not instead of `imports` —
+         * as well. A planner asking "what depends on this" wants the test in the
+         * answer, and one asking "what should I run" wants only the test. Two
+         * questions, so two edges, rather than one edge and a filter somebody has
+         * to remember to apply.
+         */
+        if ((0, core_1.isTestPath)(i.from))
+            link('structurally_tests', from, to, indexRef);
+    }
+    /* ── operational: what Looply is working on ── */
+    for (const g of input.operational.goals) {
+        add(makeNode('goal', g.id, g.text, 'current'));
+    }
+    for (const it of input.operational.items) {
+        const item = add(makeNode('item', it.id, it.title, 'current'));
+        if (it.goalId !== undefined && it.goalId !== null) {
+            link('goal_has_item', (0, core_1.nodeId)('goal', it.goalId), item, { via: 'goal-store', refs: [it.goalId] });
+        }
+        for (const e of it.evidence) {
+            const path = resolvePath(e.path);
+            /**
+             * An Item naming a path the tree does not have is ordinary — the work may
+             * be to CREATE it. It becomes a historical file node rather than a current
+             * one, so the join survives and nothing tells a planner the file is there.
+             */
+            const target = path !== null
+                ? (0, core_1.nodeId)('file', path)
+                : add(makeNode('file', canonicalise(e.path), canonicalise(e.path), 'historical'));
+            link('item_touches', item, target, { via: 'queue-store', refs: [it.id] });
+        }
+    }
+    /* ── knowledge: what memory holds, at the authority memory gave it ── */
+    for (const r of input.memory) {
+        /**
+         * 🔴 ANOTHER PROJECT'S CLAIM IS NOT THIS PROJECT'S CLAIM.
+         *
+         * `ProjectMemoryStore.parse` already refuses to LOAD a foreign record, so
+         * production cannot reach this line. It is here because the phase requires
+         * isolation to hold at the graph's own boundary rather than be inherited
+         * from a caller — and because `memory` is an injected array, so the only
+         * thing standing between two projects would otherwise be that every future
+         * caller remembered.
+         *
+         * The dangerous case is not the obvious one. A foreign record scoped to a
+         * path that also exists HERE would attach to this project's file node and
+         * be returned by `decisionsFor` as though a person had said it about this
+         * code.
+         */
+        if (r.scope.projectKey !== input.projectKey)
+            continue;
+        /**
+         * A withdrawal is not a claim. Phase 11 refuses to render one and so does
+         * this: a node for it would be a decision-shaped thing whose whole content
+         * is that another decision stopped applying.
+         */
+        if (r.withdrawn === true)
+            continue;
+        const type = MEMORY_NODE_TYPE[r.kind];
+        // Picked field by field. See MEMORY_NODE_FIELDS — never a spread.
+        const known = add(makeNode(type, r.id, r.subject, 'current'));
+        if (known === null)
+            continue;
+        const target = subjectTarget(r, resolvePath, add);
+        if (target === null)
+            continue;
+        link(MEMORY_EDGE_TYPE[r.kind], known, target, { via: 'project-memory', refs: [r.id] });
+    }
+    const built = {
+        revision: {
+            schema: core_1.PROJECT_GRAPH_SCHEMA,
+            builder: core_1.GRAPH_BUILDER_VERSION,
+            treeSha: input.index.treeSha,
+            // The dormant assurance, given a caller. See `GraphRevision`.
+            indexDigest: (0, core_1.indexDigest)(input.index),
+            memoryCursor: (0, core_1.memoryCursor)(input.memory.map((r) => r.id)),
+            operationalCursor: (0, core_1.operationalCursor)(input.operational.goals.map((g) => ({ id: g.id, version: g.version }))),
+        },
+        projectKey: input.projectKey,
+        nodes: (0, core_1.sortNodes)([...nodes.values()]),
+        edges: (0, core_1.sortEdges)([...edges.values()]),
+    };
+    return built;
+}
+/** The one path normalisation, applied to a path the index does not have. */
+function canonicalise(raw) {
+    return raw.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+}
+/**
+ * What a memory record is ABOUT, as a node.
+ *
+ * 🔴 THE `historical` BRANCH IS §2.11, AND IT IS THE WHOLE REASON THIS IS NOT
+ * THREE LINES. A person's decision about `src/auth.ts` must survive that file
+ * being deleted — dropping it loses a constraint because of a rename, which is
+ * C0-13-7 — and it must not be attached to a node claiming the file is there,
+ * which is PSG-N24. So the target is minted as `historical`, the edge is kept,
+ * and every structural query filters on presence.
+ *
+ * A record scoped to no path at all is about the PROJECT. That is the common
+ * case for a decision ("never force-push"), and attaching it to the project root
+ * is what makes it findable without pretending it is about a file.
+ */
+function subjectTarget(r, resolvePath, add) {
+    if (r.scope.path === undefined)
+        return (0, core_1.nodeId)('project', r.scope.projectKey);
+    const path = resolvePath(r.scope.path);
+    if (path !== null)
+        return (0, core_1.nodeId)('file', path);
+    const gone = canonicalise(r.scope.path);
+    return add(makeNode('file', gone, gone, 'historical'));
+}
+//# sourceMappingURL=project-graph-builder.js.map

package/dist/project-graph-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-graph-builder.js","sourceRoot":"","sources":["../src/project-graph-builder.ts"],"names":[],"mappings":"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"}

package/dist/project-graph-runtime.d.ts

@@ -0,0 +1,86 @@
+import { type GraphStaleness, type ProjectGraphSnapshot, type ProjectIndexSnapshot, type ProjectMemoryRecord } from '@looply/core';
+import { type OperationalInput } from './project-graph-builder';
+/**
+ * THE ONE PLACE A CURRENT GRAPH COMES FROM.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THERE IS NO GRAPH STORE, AND THAT IS A DECISION WITH A MEASUREMENT BEHIND IT
+ *
+ * The obvious shape was a sibling of `ProjectIndexStore`: content-addressed
+ * files under `.looply/state`, loaded on a hit, rebuilt on a miss. It was not
+ * built, for three reasons that all point the same way.
+ *
+ *   1. THE BUILD IS ALREADY FREE. Phase 12 does the expensive part — reading
+ *      blobs, extracting symbols — and this consumes its OUTPUT. Building a whole
+ *      graph is one linear walk of collections already sorted and already in
+ *      memory. Caching a walk behind a filesystem is slower than the walk.
+ *
+ *   2. A STORE IS A PROMISE. This phase's own audit found that
+ *      `MAX_SNAPSHOTS = 4` in the index store documents a retention policy that
+ *      NOTHING implements — no prune, no eviction, and the `readDir` capability
+ *      the constructor accepts is never called. Shipping a second store beside
+ *      it would have meant either repeating that or fixing it as a side effect of
+ *      an unrelated phase.
+ *
+ *   3. LOSS MUST BE RECOVERABLE ANYWAY. The graph is derived. With nothing
+ *      persisted, "recoverable" is not a property to be tested — it is the only
+ *      thing that can happen.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 AND THE FRESHNESS GUARD IS STILL LOAD-BEARING — MORE SO
+ *
+ * The worry about dropping the store is that `graphFreshness` becomes the
+ * `agrees()` of this phase: correct, tested, and unreachable. It does not,
+ * because the world moves DURING a run.
+ *
+ * Measured: the index is built once, at `run-cmd.ts` before the round loop, and
+ * `round-runner.ts` commits inside that loop. So the committed tree changes
+ * mid-run, every run that lands anything. Phase 12 already meets this and loses:
+ * index-derived facts carry the tree they were observed at, `currencyOf` marks
+ * them `stale-revision` after the first commit, and the model's structural
+ * knowledge goes dark for the rest of the run — precisely when it has begun
+ * changing the repository and needs it most.
+ *
+ * This asks the question every time it is consulted, and REBUILDS rather than
+ * going quiet. The guard fires on the common path, not on a contrived one.
+ */
+export interface GraphRuntimeDeps {
+    readonly projectKey: string;
+    /** The committed tree, now. Throwing is treated as "could not look". */
+    readonly headTreeSha: () => Promise<string>;
+    /** The index for a tree — cached or freshly built; this does not care which. */
+    readonly indexFor: (treeSha: string) => Promise<ProjectIndexSnapshot | null>;
+    /** Every memory record held for this project. Bounding happens downstream. */
+    readonly memory: () => readonly ProjectMemoryRecord[];
+    readonly operational: () => OperationalInput;
+}
+/**
+ * Holds at most one graph and will not hand out a stale one.
+ *
+ * ⚠️ NOT A CACHE WITH A CORRECTNESS CHECK BOLTED ON. The check IS the interface:
+ * `current()` has no path that returns a graph without having just established
+ * that its revision agrees with the world, and the post-condition below asserts
+ * it rather than trusting the branch above to have been written correctly.
+ */
+export declare class ProjectGraphRuntime {
+    private readonly deps;
+    private held;
+    private lastRefusal;
+    private builds;
+    constructor(deps: GraphRuntimeDeps);
+    /** Why the last call could not produce a graph, or null if it could. */
+    refusal(): GraphStaleness | null;
+    /** How many times a graph has actually been built. For tests and diagnosis. */
+    buildCount(): number;
+    /**
+     * A graph that speaks for the present, or null.
+     *
+     * 🔴 NULL IS A REFUSAL, NOT AN EMPTY GRAPH. A caller handed an empty graph
+     * would render "nothing depends on this file", which is a finding. Handed
+     * null, it renders nothing at all — which is the truth: Looply could not
+     * establish the structure this time.
+     */
+    current(): Promise<ProjectGraphSnapshot | null>;
+    private refuse;
+}
+//# sourceMappingURL=project-graph-runtime.d.ts.map

package/dist/project-graph-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-graph-runtime.d.ts","sourceRoot":"","sources":["../src/project-graph-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IAC7E,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,mBAAmB,EAAE,CAAC;IACtD,QAAQ,CAAC,WAAW,EAAE,MAAM,gBAAgB,CAAC;CAC9C;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAKlB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJjC,OAAO,CAAC,IAAI,CAAqC;IACjD,OAAO,CAAC,WAAW,CAA+B;IAClD,OAAO,CAAC,MAAM,CAAK;gBAEU,IAAI,EAAE,gBAAgB;IAEnD,wEAAwE;IACxE,OAAO,IAAI,cAAc,GAAG,IAAI;IAIhC,+EAA+E;IAC/E,UAAU,IAAI,MAAM;IAIpB;;;;;;;OAOG;IACG,OAAO,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAkErD,OAAO,CAAC,MAAM;CAUf"}

package/dist/project-graph-runtime.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectGraphRuntime = void 0;
+const core_1 = require("@looply/core");
+const project_graph_builder_1 = require("./project-graph-builder");
+/**
+ * Holds at most one graph and will not hand out a stale one.
+ *
+ * ⚠️ NOT A CACHE WITH A CORRECTNESS CHECK BOLTED ON. The check IS the interface:
+ * `current()` has no path that returns a graph without having just established
+ * that its revision agrees with the world, and the post-condition below asserts
+ * it rather than trusting the branch above to have been written correctly.
+ */
+class ProjectGraphRuntime {
+    deps;
+    held = null;
+    lastRefusal = null;
+    builds = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Why the last call could not produce a graph, or null if it could. */
+    refusal() {
+        return this.lastRefusal;
+    }
+    /** How many times a graph has actually been built. For tests and diagnosis. */
+    buildCount() {
+        return this.builds;
+    }
+    /**
+     * A graph that speaks for the present, or null.
+     *
+     * 🔴 NULL IS A REFUSAL, NOT AN EMPTY GRAPH. A caller handed an empty graph
+     * would render "nothing depends on this file", which is a finding. Handed
+     * null, it renders nothing at all — which is the truth: Looply could not
+     * establish the structure this time.
+     */
+    async current() {
+        let treeSha;
+        try {
+            treeSha = await this.deps.headTreeSha();
+        }
+        catch {
+            return this.refuse('unconfirmable');
+        }
+        let index;
+        try {
+            index = await this.deps.indexFor(treeSha);
+        }
+        catch {
+            return this.refuse('unconfirmable');
+        }
+        if (index === null)
+            return this.refuse('unconfirmable');
+        /**
+         * ⚠️ AND THE INDEX MUST BE FOR THE TREE WE ASKED ABOUT. `ProjectIndexStore`
+         * already refuses a snapshot filed under the wrong name, but this does not
+         * inherit that: `indexFor` is an injected function, and a caller that built
+         * one from a different revision would otherwise have it silently signed into
+         * a graph revision claiming the tree we measured.
+         */
+        if (index.treeSha !== treeSha)
+            return this.refuse('stale-index');
+        const memory = this.deps.memory();
+        const operational = this.deps.operational();
+        const world = {
+            currentTreeSha: treeSha,
+            currentIndexDigest: (0, core_1.indexDigest)(index),
+            currentMemoryCursor: (0, core_1.memoryCursor)(memory.map((r) => r.id)),
+            currentOperationalCursor: (0, core_1.operationalCursor)(operational.goals.map((g) => ({ id: g.id, version: g.version }))),
+        };
+        if (this.held !== null && (0, core_1.graphFreshness)(this.held.revision, world).current) {
+            this.lastRefusal = null;
+            return this.held;
+        }
+        const built = (0, project_graph_builder_1.buildProjectGraph)({
+            projectKey: this.deps.projectKey,
+            index,
+            memory,
+            operational,
+        });
+        this.builds += 1;
+        /**
+         * 🔴 THE POST-CONDITION, ASSERTED RATHER THAN ASSUMED.
+         *
+         * A graph is only ever returned after this passes, so there is no ordering
+         * of the branches above — and no future edit to them — that can hand out one
+         * whose revision does not agree with the world it was just measured against.
+         * If the builder and the cursor functions ever disagree, this says so
+         * immediately instead of shipping a graph that lies about which world it
+         * describes.
+         */
+        const check = (0, core_1.graphFreshness)(built.revision, world);
+        if (!check.current)
+            return this.refuse(check.because);
+        this.held = built;
+        this.lastRefusal = null;
+        return built;
+    }
+    refuse(because) {
+        this.lastRefusal = because;
+        /**
+         * The held graph is DROPPED, not kept for a luckier moment. Keeping it would
+         * mean a later call could return a graph built against a world nobody
+         * re-checked, which is the whole failure this class exists to prevent.
+         */
+        this.held = null;
+        return null;
+    }
+}
+exports.ProjectGraphRuntime = ProjectGraphRuntime;
+//# sourceMappingURL=project-graph-runtime.js.map

package/dist/project-graph-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-graph-runtime.js","sourceRoot":"","sources":["../src/project-graph-runtime.ts"],"names":[],"mappings":"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"}

package/dist/project-index-builder.d.ts

@@ -0,0 +1,96 @@
+import { type IndexedImport, type IndexedSymbol, type ProjectIndexSnapshot } from '@looply/core';
+import type { GitDriver } from './git-driver';
+/**
+ * BUILDING THE INDEX FROM WHAT GIT ALREADY KNOWS.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 NO PARSER, AND THAT IS A SHIPPING CONSTRAINT RATHER THAN A PREFERENCE
+ *
+ * `typescript` is NOT a dependency of this package. It resolves inside this
+ * monorepo only because the root has a hoisted dev copy — the published
+ * `looply-cli` declares three runtime dependencies and TypeScript is not among
+ * them. A `require('typescript')` here would pass every test in this repository
+ * and throw MODULE_NOT_FOUND for every real `npx looply-cli` user, and the
+ * committed-tree certifier could not catch it either: it borrows `node_modules`
+ * from the working tree, which HAS the hoisted copy.
+ *
+ * So extraction is dependency-free and deliberately CONSERVATIVE. It finds what
+ * it can state plainly and records everything else as unparsed WITH A REASON.
+ * A guessed symbol would be structural truth invented by pattern-matching,
+ * which is precisely what a deterministic index exists not to contain.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT IT FINDS, AND WHAT IT DOES NOT
+ *
+ *   finds       top-level `export` declarations and static import specifiers
+ *   does not    private symbols, re-export chains, dynamic imports, anything
+ *               inside a namespace or a conditional block
+ *
+ * The boundary is chosen so that a false POSITIVE is nearly impossible: every
+ * pattern is anchored to the start of a line, so a match is a real top-level
+ * declaration or nothing. Missing something is recoverable — a later phase can
+ * widen it. Inventing something is not, because a graph built on it looks
+ * exactly like a graph built on evidence.
+ */
+/**
+ * Files above this are recorded as `unparsed`, not read.
+ *
+ * A megabyte of source is a generated file or a vendored blob, and reading it
+ * would spend the whole budget on something no dependency question is about.
+ * Recorded rather than skipped, so a reader knows the index HAS an opinion
+ * about that path and the opinion is "I did not look".
+ */
+export declare const MAX_INDEXED_BYTES: number;
+/** Where a workspace package's files live, and what the package is called. */
+export interface PackageRoot {
+    readonly name: string;
+    /** Canonical, no trailing slash. e.g. `packages/core`. */
+    readonly dir: string;
+}
+export interface BuildIndexInput {
+    readonly git: Pick<GitDriver, 'listTree' | 'readBlob' | 'headTreeSha'>;
+    readonly packages: readonly PackageRoot[];
+    /** Defaults to the committed tree at HEAD. */
+    readonly treeSha?: string;
+}
+/**
+ * The package a file belongs to.
+ *
+ * Longest prefix wins, so a nested package inside another is attributed to the
+ * nearer one rather than to whichever happened to be checked first — an order
+ * dependence would be exactly the kind of non-determinism this phase is about.
+ */
+export declare function packageFor(path: string, packages: readonly PackageRoot[]): string | null;
+export interface Extraction {
+    readonly symbols: readonly IndexedSymbol[];
+    readonly imports: readonly IndexedImport[];
+}
+/**
+ * Read one TypeScript file's exported declarations and imports.
+ *
+ * Line-anchored on purpose: a pattern that could match mid-line would find
+ * `export` inside a string or a comment and invent a symbol from it.
+ */
+export declare function extractFrom(path: string, source: string): Extraction;
+/**
+ * Where a specifier points, when that can be answered without guessing.
+ *
+ * 🔴 RELATIVE SPECIFIERS ONLY. A bare specifier may be a package OR a path
+ * alias configured in a tsconfig this extractor does not read, and inventing a
+ * target would put a relationship in the index that nothing established.
+ * `null` means NOT RESOLVED — it does not mean external.
+ *
+ * ⚠️ THE EXTENSION IS NOT GUESSED EITHER. `./foo` could be `foo.ts`, `foo.tsx`
+ * or `foo/index.ts`, and choosing one would be right most of the time, which is
+ * the worst possible property for a fact somebody builds on. The caller
+ * resolves against the real file list; this reports the normalised path only.
+ */
+export declare function resolveSpecifier(from: string, specifier: string): string | null;
+/**
+ * Build the whole index for a revision.
+ *
+ * Every collection is sorted before it is returned, so the caller cannot
+ * accidentally depend on the order git happened to emit.
+ */
+export declare function buildProjectIndex(input: BuildIndexInput): Promise<ProjectIndexSnapshot>;
+//# sourceMappingURL=project-index-builder.d.ts.map

package/dist/project-index-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-index-builder.d.ts","sourceRoot":"","sources":["../src/project-index-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAUL,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,QAAa,CAAC;AAE5C,8EAA8E;AAC9E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,aAAa,CAAC,CAAC;IACvE,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,GAAG,IAAI,CAQxF;AAuED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;CAC5C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAyDpE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAe/E;AAuBD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAuD7F"}