wingfoil 0.2.1

package/dist/core/loaders.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROLES_YAML_PATH = exports.DIRECTIVES_DIR_PATH = exports.DNA_YAML_PATH = exports.MEMORY_YAML_PATH = void 0;
+exports.loadMemoryYaml = loadMemoryYaml;
+exports.loadMemoryYamlAtHead = loadMemoryYamlAtHead;
+exports.loadDnaYaml = loadDnaYaml;
+exports.loadDnaYamlAtHead = loadDnaYamlAtHead;
+exports.loadWorkflowsYaml = loadWorkflowsYaml;
+exports.loadDirectives = loadDirectives;
+exports.loadDirectivesAtHead = loadDirectivesAtHead;
+exports.loadRolesYaml = loadRolesYaml;
+exports.loadRolesYamlAtHead = loadRolesYamlAtHead;
+/**
+ * Per-pillar loaders (task-004-decoupled-pillars, REQ-SYS-02). `core` exposes exactly one loader
+ * per pillar — `loadMemoryYaml`, `loadDnaYaml`, `loadWorkflowsYaml`, `loadDirectives` — each reading
+ * only its own artifact(s) under `.wingfoil/` (spec-011-storage-layout) through the shared two-pass
+ * validation pipeline (spec-009-validation-strategy): `storage.readDocument` for bytes,
+ * `validation.parseYaml` for the pre-Zod YAML parse, `validation.runValidation` for the Zod
+ * structural pass. No loader imports another pillar's schema module, and no loader reads another
+ * pillar's file(s) — that is what keeps adding a new Memory `type` (say) from ever requiring a
+ * change to `dna.yaml` or `workflows.yaml`, and is the structural guarantee the cross-pillar load
+ * test in `test/core/pillar-isolation.test.ts` exercises.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const schema_1 = require("../directives/schema");
+const schema_2 = require("../dna/schema");
+const schema_3 = require("../memory/schema");
+const storage_1 = require("../storage");
+const validation_1 = require("../validation");
+const schema_4 = require("../workflow/schema");
+/**
+ * Recursively list every `.md` file under `dir`, as paths relative to `dir`, sorted
+ * lexicographically (REQ-SYS-07: no unordered iteration in a context-building path — directory-entry
+ * order from `readdirSync` is not guaranteed stable, so traversal always sorts explicitly, mirroring
+ * `src/storage/snapshot.ts`'s `listFilesSorted`). Returns `[]` if `dir` doesn't exist.
+ */
+function listMarkdownFilesSorted(dir) {
+    if (!(0, fs_1.existsSync)(dir) || !(0, fs_1.statSync)(dir).isDirectory())
+        return [];
+    const out = [];
+    const walk = (current, prefix) => {
+        for (const entry of (0, fs_1.readdirSync)(current).sort()) {
+            const full = (0, path_1.join)(current, entry);
+            const relative = prefix ? `${prefix}/${entry}` : entry;
+            if ((0, fs_1.statSync)(full).isDirectory()) {
+                walk(full, relative);
+            }
+            else if (entry.endsWith('.md')) {
+                out.push(relative);
+            }
+        }
+    };
+    walk(dir, '');
+    return out.sort();
+}
+/** Load and validate `.wingfoil/memory.yaml` in isolation (spec-001-memory-yaml-schema). */
+function loadMemoryYaml(root) {
+    const filePath = (0, path_1.join)(root, '.wingfoil', 'memory.yaml');
+    return parseMemoryYaml((0, storage_1.readDocument)(filePath), filePath);
+}
+/**
+ * Root-relative POSIX path of `memory.yaml` — the form git wants for a revision read
+ * (`<rev>:<path>`), as opposed to the platform `join` every on-disk read uses. Counterpart of
+ * {@link DNA_YAML_PATH} (task-091).
+ */
+exports.MEMORY_YAML_PATH = '.wingfoil/memory.yaml';
+/**
+ * The Memory pillar's two-pass parse, over bytes that may come from anywhere — the working-tree file
+ * ({@link loadMemoryYaml}) or a git revision ({@link loadMemoryYamlAtHead}). `filePath` is a label
+ * only: it rides every issue this raises, so an error names the baseline it came from
+ * (`HEAD:.wingfoil/memory.yaml`, not just a path on disk).
+ */
+function parseMemoryYaml(raw, filePath) {
+    return (0, validation_1.runValidation)(schema_3.MemoryYaml, (0, validation_1.parseYaml)(raw, filePath), filePath);
+}
+/**
+ * Load and validate `.wingfoil/memory.yaml` **as the repository has committed it** — the version at
+ * `HEAD` — returning `null` when no commit of the repository contains that path (an untracked
+ * `memory.yaml`, or a repository with no commits at all). Same schema and same error shapes as
+ * {@link loadMemoryYaml}; only the source of the bytes differs.
+ *
+ * This is the baseline every Memory **state transition** resolves against
+ * (`prepareMemoryTransition`, `./memory-transition.ts`), per
+ * `dl-080-which-baseline-each-command-reads` option (B) — *a read that gates an operation resolves
+ * against the repository as committed at `HEAD`* — closing
+ * `bug-081-memory-yaml-read-from-worktree-fabricates-states`: an uncommitted edit to a type's
+ * `sequence` used to decide what transition a verb performed and what `status` it committed, through
+ * `memory submit`, which needs no authority at all, and left the element in a status the committed
+ * machine rejects, movable by no verb at all.
+ *
+ * `HEAD` rather than the commit being produced: a transition commit changes only the element path
+ * (`verifyCommittedScope`, task-088), so `memory.yaml` at `HEAD` and at the new commit are
+ * byte-identical, and `HEAD` is the one available before that commit exists.
+ */
+function loadMemoryYamlAtHead(root) {
+    const raw = (0, storage_1.readPathAtRev)(root, 'HEAD', exports.MEMORY_YAML_PATH);
+    if (raw === null)
+        return null;
+    return parseMemoryYaml(raw, `HEAD:${exports.MEMORY_YAML_PATH}`);
+}
+/**
+ * `js-yaml`'s `YAMLException#message` always embeds the failure position as `(<line>:<column>)`
+ * (1-indexed) right after the reason text, ahead of the multi-line context snippet — verified across
+ * the common `load()` failure shapes (bad indentation, unclosed flow collection, block-mapping/key
+ * errors, tab-indentation), with a defensive `null` fallback for any that omit it.
+ * `parseYaml` (spec-009-validation-strategy §1) preserves this
+ * raw message verbatim in the single issue of the `E_YAML_PARSE_ERROR` `ValidationError` it throws.
+ * Returns `null` if the position marker isn't found (defensive — no known js-yaml failure omits it).
+ */
+function extractYamlErrorLine(message) {
+    const match = /\((\d+):\d+\)/.exec(message);
+    return match ? Number(match[1]) : null;
+}
+/**
+ * Load and validate `.wingfoil/dna.yaml` in isolation (spec-002-dna-yaml-schema). On top of the
+ * shared two-pass pipeline every pillar loader uses, this re-wraps a YAML-syntax failure into P2.4's
+ * own fit criterion (BDD `P2.4-project-dna-config.feature` "Error - malformed YAML in the DNA file"):
+ * `invalid DNA: YAML parse error at line <n>`, rather than surfacing the generic `E_YAML_PARSE_ERROR`
+ * message every other pillar loader still uses as-is. DNA-scoped only — this does not change
+ * `parseYaml`/`ValidationError`'s shared behavior for `memory.yaml`/`workflows.yaml`/directives.
+ */
+function loadDnaYaml(root) {
+    return parseDnaYaml((0, storage_1.readDocument)((0, path_1.join)(root, '.wingfoil', 'dna.yaml')), (0, path_1.join)(root, '.wingfoil', 'dna.yaml'));
+}
+/**
+ * Root-relative POSIX path of `dna.yaml` — the form git wants for a revision read
+ * (`<rev>:<path>`), as opposed to the platform `join` every on-disk read uses (task-090).
+ */
+exports.DNA_YAML_PATH = '.wingfoil/dna.yaml';
+/**
+ * The DNA pillar's two-pass parse, over bytes that may come from anywhere — the working-tree file
+ * ({@link loadDnaYaml}) or a git revision ({@link loadDnaYamlAtHead}). `filePath` is a label only: it
+ * rides every issue this raises, so an error names the baseline it came from
+ * (`HEAD:.wingfoil/dna.yaml`, not just a path on disk).
+ */
+function parseDnaYaml(raw, filePath) {
+    let data;
+    try {
+        data = (0, validation_1.parseYaml)(raw, filePath);
+    }
+    catch (err) {
+        if (err instanceof validation_1.ValidationError && err.issues[0]?.code === validation_1.E_YAML_PARSE_ERROR) {
+            const line = extractYamlErrorLine(err.issues[0].message);
+            const message = line !== null ? `invalid DNA: YAML parse error at line ${line}` : 'invalid DNA: YAML parse error';
+            throw new validation_1.ValidationError([{ ...err.issues[0], message }], err.exitCode);
+        }
+        throw err;
+    }
+    return (0, validation_1.runValidation)(schema_2.DnaYaml, data, filePath);
+}
+/**
+ * Load and validate `.wingfoil/dna.yaml` **as the repository has committed it** — the version at
+ * `HEAD` — returning `null` when no commit of the repository contains that path (an untracked
+ * `dna.yaml`, or a repository with no commits at all). Same schema and same error shapes as
+ * {@link loadDnaYaml}; only the source of the bytes differs.
+ *
+ * Its caller is `requireApprovalAuthority` (`./approval-authority.ts`, task-090 / `bug-079`) —
+ * joined by `checkAssignable` (`./directive-assign.ts`, task-091 / `bug-082`), which validates
+ * `directive assign`'s `--role` against the same committed catalogue: approval authority is a property of the
+ * repository, not of a working tree, so the roles it reads must be roles someone committed.
+ * `adr-006-git-identity-role-based-authz`'s own Positive consequence — a fresh clone "reproduces the
+ * full audit trail with zero extra infrastructure" — is what fixes the baseline: a clone carries
+ * committed state and nothing else, so an `Approver:` line resting on an uncommitted grant is
+ * evidence no clone can re-derive.
+ *
+ * `HEAD` rather than the produced commit: an approval commit changes only the element path
+ * (`verifyCommittedScope`, task-088), so `dna.yaml` at `HEAD` and at the commit being produced are
+ * byte-identical — the two shapes `bug-079`'s Expected Behavior offers cannot diverge, and `HEAD` is
+ * the one available before the commit exists.
+ *
+ * Deliberately NOT how the working-tree loaders behave — but no longer an exception argued for one
+ * read: `dl-080-which-baseline-each-command-reads` is `ready`, ratified as option (B), and **a read
+ * that gates an operation resolves at `HEAD`** is now the rule this and {@link loadMemoryYamlAtHead}
+ * implement. A read that gates nothing — `dna show`, `paths`, `directives list`, the MCP Resources —
+ * still reports the working tree, which is what those exist to do. (`bug-078` is (B)'s write half:
+ * a write refuses while its target carries modifications it does not own.)
+ */
+function loadDnaYamlAtHead(root) {
+    const raw = (0, storage_1.readPathAtRev)(root, 'HEAD', exports.DNA_YAML_PATH);
+    if (raw === null)
+        return null;
+    return parseDnaYaml(raw, `HEAD:${exports.DNA_YAML_PATH}`);
+}
+/**
+ * Load and validate the Workflow pillar in isolation (spec-003-workflows-yaml-schema): Layer 1
+ * (`.wingfoil/workflows.yaml`), then every file its `include` list names (Layer 2), resolved
+ * relative to `.wingfoil/` per spec-003. Two cross-file Pass-2 checks that need the loaded files
+ * themselves (spec-009 §1 "Cross-file" category) run here, not in the schema module:
+ *
+ * - every `include` path must resolve to a file that actually exists
+ *   (`E_WORKFLOW_FILE_NOT_FOUND`, spec-003);
+ * - at least one loaded workflow must be `kind: main` (REQ-STATE-03 / spec-003 Layer 1 step 3).
+ */
+function loadWorkflowsYaml(root) {
+    const configDir = (0, path_1.join)(root, '.wingfoil');
+    const manifestPath = (0, path_1.join)(configDir, 'workflows.yaml');
+    const manifestRaw = (0, storage_1.readDocument)(manifestPath);
+    const manifestData = (0, validation_1.parseYaml)(manifestRaw, manifestPath);
+    const manifest = (0, validation_1.runValidation)(schema_4.WorkflowsYaml, manifestData, manifestPath);
+    const workflows = [];
+    for (const includePath of manifest.include) {
+        const workflowPath = (0, path_1.join)(configDir, includePath);
+        if (!(0, storage_1.documentExists)(workflowPath)) {
+            throw validation_1.ValidationError.semantic([
+                {
+                    code: 'E_WORKFLOW_FILE_NOT_FOUND',
+                    path: 'include',
+                    file: manifestPath,
+                    message: `included workflow file not found: ${includePath}`,
+                },
+            ]);
+        }
+        const raw = (0, storage_1.readDocument)(workflowPath);
+        const data = (0, validation_1.parseYaml)(raw, workflowPath);
+        workflows.push((0, validation_1.runValidation)(schema_4.Workflow, data, workflowPath));
+    }
+    if (!workflows.some((workflow) => workflow.kind === 'main')) {
+        throw validation_1.ValidationError.semantic([
+            {
+                code: 'E_NO_MAIN_WORKFLOW',
+                path: 'include',
+                file: manifestPath,
+                message: 'at least one included workflow must be `kind: main` (REQ-STATE-03)',
+            },
+        ]);
+    }
+    return { manifest, workflows };
+}
+/**
+ * Root-relative POSIX path of the Directives tree — the form git wants for a revision listing, as
+ * opposed to the platform `join` every on-disk read uses. Counterpart of {@link DNA_YAML_PATH} /
+ * {@link MEMORY_YAML_PATH} for the one pillar whose baseline is a **directory** (task-096).
+ */
+exports.DIRECTIVES_DIR_PATH = '.wingfoil/directives';
+/**
+ * The Directives pillar's per-file parse, over bytes that may come from anywhere — the working-tree
+ * file ({@link loadDirectives}) or a git revision ({@link loadDirectivesAtHead}). `filePath` is a
+ * label only: it rides every issue this raises, so an error names the baseline it came from
+ * (`HEAD:.wingfoil/directives/custom/x.md`, not just a path on disk). Lifted out so the two loaders
+ * cannot drift on what a directive file *is*.
+ *
+ * @param relativePath - The file's path relative to `.wingfoil/directives/`, POSIX-spelled.
+ */
+function parseDirectiveFile(raw, filePath, relativePath) {
+    const frontmatterText = (0, storage_1.extractFrontmatter)(raw);
+    if (frontmatterText === null) {
+        throw validation_1.ValidationError.semantic([
+            {
+                code: 'E_MISSING_FRONTMATTER',
+                path: '',
+                file: filePath,
+                message: 'directive file has no frontmatter block',
+            },
+        ]);
+    }
+    const data = (0, validation_1.parseYaml)(frontmatterText, filePath);
+    const frontmatter = (0, validation_1.runValidation)(schema_1.DirectiveFrontmatter, data, filePath);
+    // `join`, so `DirectiveFile.path` carries the platform separator on both loaders — `requireCustomAsset`
+    // and `selectDirectivesById` see one spelling whichever baseline produced the file.
+    return { path: (0, path_1.join)('directives', ...relativePath.split('/')), frontmatter };
+}
+/**
+ * Load and validate every Directives file in isolation (task-004-decoupled-pillars — see
+ * `src/directives/schema.ts` for why this pillar has no dedicated approved tech-spec yet). Reads
+ * every `.md` file under `.wingfoil/directives/**` (built-in + custom) **in the working tree**,
+ * sorted deterministically (REQ-SYS-07: no unordered iteration in a context-building path), extracts
+ * its frontmatter (`storage.extractFrontmatter`), and validates it against `DirectiveFrontmatter`.
+ *
+ * This is the *report* baseline — what the user has now — and it is what `directives list`, context
+ * assembly and the MCP Resources read. A read that **gates** a mutation reads
+ * {@link loadDirectivesAtHead} instead (`dl-080` (B)).
+ */
+function loadDirectives(root) {
+    const directivesDir = (0, path_1.join)(root, '.wingfoil', 'directives');
+    return listMarkdownFilesSorted(directivesDir).map((relativePath) => parseDirectiveFile((0, storage_1.readDocument)((0, path_1.join)(directivesDir, relativePath)), (0, path_1.join)(directivesDir, relativePath), relativePath));
+}
+/**
+ * Load and validate every Directives file **as the repository has committed it** — the tree at
+ * `HEAD`.
+ *
+ * This is the inventory a read that gates a mutation resolves against
+ * (`checkAssignable`, `./directive-assign.ts`), per `dl-080-which-baseline-each-command-reads` option
+ * (B), closing the `assign` half of `bug-086-directive-inventory-read-from-the-worktree`: an
+ * untracked directive file used to be bindable, and the committed `roles.yaml` then named a directive
+ * present in no commit — a dangling reference by construction, since every other clone gets the
+ * binding without the file (REQ-SYS-08's referential integrity, the same way `bug-082` broke it for
+ * `--role`).
+ *
+ * Unlike every other committed-baseline loader, this one needs a **directory listing at a revision**
+ * (`storage.listPathsAtRev`, task-096) rather than one `readPathAtRev`: the pillar's members are
+ * discovered, not named in advance. That missing primitive is why `task-091` deferred this half.
+ *
+ * Same schema and same error shapes as {@link loadDirectives}; only the source of the bytes differs.
+ *
+ * Returns an **array, never `null`**, unlike its three sibling committed-baseline loaders. They read
+ * one named file, where "not committed" and "committed but empty" are different facts a caller may
+ * need to tell apart; here the two collapse — a `HEAD` that does not resolve (no commits at all) and
+ * a `HEAD` that commits no directive file both mean *the repository records no directive*, and both
+ * produce the same refusal from the only gate that consults this (`checkAssignable`: every id is
+ * unknown). `listPathsAtRev` keeps the distinction for callers that do need it.
+ */
+function loadDirectivesAtHead(root) {
+    const paths = (0, storage_1.listPathsAtRev)(root, 'HEAD', exports.DIRECTIVES_DIR_PATH) ?? [];
+    const files = [];
+    for (const path of paths) {
+        if (!path.endsWith('.md'))
+            continue;
+        const raw = (0, storage_1.readPathAtRev)(root, 'HEAD', path);
+        // Unreachable by construction — git has just listed this blob. Reachable only if the ref moved
+        // between the two calls, and skipping is the fail-closed answer there: a directive nobody can read
+        // is a directive that does not exist, so a binding to it is refused rather than committed.
+        if (raw === null)
+            continue;
+        files.push(parseDirectiveFile(raw, `HEAD:${path}`, path.slice(exports.DIRECTIVES_DIR_PATH.length + 1)));
+    }
+    return files;
+}
+/**
+ * Root-relative POSIX path of `roles.yaml` — the form git wants for a revision read (`<rev>:<path>`),
+ * as opposed to the platform `join` every on-disk read uses. It lived in `./directive-assign.ts` until
+ * task-096 moved it here, beside {@link DNA_YAML_PATH} / {@link MEMORY_YAML_PATH} and beside the
+ * committed-baseline reader that uses it; `./directive-assign.ts` now **imports** it like any other
+ * caller, and `src/core`'s barrel exports it from here.
+ */
+exports.ROLES_YAML_PATH = '.wingfoil/roles.yaml';
+/**
+ * Load and validate `.wingfoil/roles.yaml` in isolation (task-037-role-task-scoped-context,
+ * REQ-STATE-05's `directive-loader`, P3.2/P3.7 role → directive bindings) — the same shared two-pass
+ * pipeline (`readDocument` + `parseYaml` + `runValidation`) every other pillar loader uses, so this
+ * pillar's own validation never depends on another pillar's schema (REQ-SYS-02). Consumed by
+ * `resolveRoleDirectives`/`assembleExecutionContext` (`./context.ts`) to resolve a role's assigned
+ * directives.
+ */
+function loadRolesYaml(root) {
+    const filePath = (0, path_1.join)(root, '.wingfoil', 'roles.yaml');
+    const raw = (0, storage_1.readDocument)(filePath);
+    const data = (0, validation_1.parseYaml)(raw, filePath);
+    return (0, validation_1.runValidation)(schema_1.RolesYaml, data, filePath);
+}
+/**
+ * Load and validate `.wingfoil/roles.yaml` **as the repository has committed it** — the version at
+ * `HEAD` — returning `null` when no commit contains that path (an untracked `roles.yaml`, a committed
+ * deletion of it, or a repository with no commits).
+ *
+ * This is the baseline REQ-SEC-07 clause (b) is answered from (`checkUnreferenced`,
+ * `./directive-assign.ts`), per `dl-080-which-baseline-each-command-reads` option (B), closing the
+ * `remove` half of `bug-086-directive-inventory-read-from-the-worktree`: an **uncommitted** deletion
+ * of the two `- <id>` lines was enough to delete a directive file the committed `roles.yaml` still
+ * bound — on the only verb in the system that destroys an artefact.
+ *
+ * `null` is not an error and does not fail closed there, unlike `loadDnaYamlAtHead`'s: "is anything
+ * still referencing this asset" is a question a missing record *answers*, with "nothing" (which is
+ * also how an absent `roles.yaml` has always been read — "no bindings yet", task-051/task-053). A
+ * committed `roles.yaml` that does not **validate** is the different case, and that one does refuse.
+ */
+function loadRolesYamlAtHead(root) {
+    const raw = (0, storage_1.readPathAtRev)(root, 'HEAD', exports.ROLES_YAML_PATH);
+    if (raw === null)
+        return null;
+    const label = `HEAD:${exports.ROLES_YAML_PATH}`;
+    return (0, validation_1.runValidation)(schema_1.RolesYaml, (0, validation_1.parseYaml)(raw, label), label);
+}
+//# sourceMappingURL=loaders.js.map

package/dist/core/loaders.js.map

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

package/dist/core/memory-add-type.d.ts

@@ -0,0 +1,43 @@
+import type { TemplateConfig } from '../memory';
+import { type CoreResult } from './types';
+/** Everything `memory add` needs about a type, all of it resolved from the same committed baseline. */
+export interface ResolvedAddType {
+    /** The requested type name, as registered in the committed `memory.yaml`. */
+    readonly type: string;
+    /** The type's `path` pattern (e.g. `docs/memory/adr/{id}.md`), from `HEAD`. */
+    readonly pathPattern: string;
+    /** The type's `id_pattern` (e.g. `adr-{n}-{slug}`), from `HEAD`. */
+    readonly idPattern: string;
+    /** The type's `template` block, from `HEAD` — its `frontmatter.required` included. */
+    readonly template: TemplateConfig;
+    /** Root-relative POSIX path of `template.file`, the form git wants for a revision read. */
+    readonly templatePath: string;
+    /** The scaffold's bytes **as committed at `HEAD`**, the text `renderAddDocument` fills in. */
+    readonly scaffold: string;
+}
+/**
+ * Resolve `type` against the `memory.yaml` **committed at `HEAD`** and return its `path`,
+ * `id_pattern`, `template` and the scaffold's committed bytes.
+ *
+ * Refusals, all returned (never thrown) and all exit `1` (`spec-005-cli-command-contract` § 1, as
+ * ruled on `bug-076`: a well-formed invocation failing a repository-state precondition is `1`, never
+ * `2`). Every one of them happens **before** anything is written, so "no file is created"
+ * (P1.3 sc.2) holds by construction:
+ *
+ * - `HEAD` holds no `memory.yaml` → `VALIDATION`, **fail-closed**. With no committed registry there
+ *   is no `path` and no scaffold to create against, and the only fail-open available is the working
+ *   tree, which is the defect. `wingfoil init` commits the registry *and* every scaffold it names in
+ *   the scaffold commit, so no legitimate flow reaches this;
+ * - the committed `memory.yaml` does not parse or validate → `VALIDATION`, same reasoning;
+ * - the type is not registered → `NOT_FOUND` with P1.3 sc.2's pinned sentence
+ *   `unknown memory type '<t>' (not defined in memory.yaml)`, verbatim and first;
+ * - the registered type declares no `id_pattern`/`template` → `VALIDATION`, unchanged wording;
+ * - `template.file` is not committed at `HEAD` → `VALIDATION`. An element copies a scaffold; copying
+ *   one that exists in no commit is how `bug-085` put bytes from an untracked file into a permanent
+ *   commit.
+ *
+ * The last three may carry a second sentence, appended only when the working tree and `HEAD` actually
+ * disagree about *this type* ({@link workingTreeEntry}).
+ */
+export declare function resolveAddType(root: string, type: string): CoreResult<ResolvedAddType>;
+//# sourceMappingURL=memory-add-type.d.ts.map

package/dist/core/memory-add-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-add-type.d.ts","sourceRoot":"","sources":["../../src/core/memory-add-type.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,WAAW,CAAC;AAK5D,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE3D,uGAAuG;AACvG,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,8FAA8F;IAC9F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAmCD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,eAAe,CAAC,CAmEtF"}

package/dist/core/memory-add-type.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAddType = resolveAddType;
+/**
+ * `memory add`'s type resolution, against the repository **as committed at `HEAD`**
+ * (task-095-memory-add-resolves-its-type-at-head, `bug-085`,
+ * `dl-080-which-baseline-each-command-reads` option (B): *a read that gates an operation resolves
+ * against the repository as committed at `HEAD`*).
+ *
+ * `memory add` asks three questions of its configuration before it writes anything — does this type
+ * exist, where do its files land, and which scaffold does it copy — and every one of them used to be
+ * answered from the working tree. An uncommitted `types:` entry was therefore enough to produce a
+ * *committed* element of a type no commit defines, and that element is **unreachable** afterwards:
+ * `memory submit` and `memory deprecate` both answer `document not found` and `memory search --type`
+ * finds nothing, which is indistinguishable from the element never having been created while the
+ * commit sits in the history.
+ *
+ * The shape follows `task-091`'s, by the one move this call site allows. That task removed the
+ * `MemoryYaml` **parameter** from `prepareMemoryTransition` and `checkAssignable`, so no caller could
+ * hand either a working-tree document even by accident. `memoryAddFn` had no such parameter to
+ * remove — the working-tree copy arrived through a `loadMemoryYaml(root)` call the verb made itself
+ * — so the equivalent is to move the whole decision **behind** {@link resolveAddType}, which takes a
+ * root and a type name and nothing else. The verb now holds no `MemoryYaml` at all, and there is no
+ * argument through which a working-tree registry could reach the decision. That property is enforced
+ * by the type checker rather than by a precondition someone must remember to run.
+ *
+ * @see `src/core/memory-transition.ts` for the same rule on the four state-transition verbs.
+ */
+const path_1 = require("path");
+const storage_1 = require("../storage");
+const validation_1 = require("../validation");
+const loaders_1 = require("./loaders");
+const types_1 = require("./types");
+/** The directory every `template.file` path is relative to, matching `MEMORY_YAML_PATH`'s prefix. */
+const WINGFOIL_DIR = '.wingfoil';
+/**
+ * The working tree's entry for `type`, or `undefined` — the **diagnostic** half of this module, never
+ * the deciding half.
+ *
+ * Under a committed baseline a refusal can contradict the file open in the author's editor, and
+ * `memory.yaml` is precisely the file one edits while designing a new type. So when the two copies
+ * genuinely disagree *about this type*, say which one decided (`task-091`'s D5, `task-090`'s
+ * `workingTreeWouldGrant`). Any failure to read or parse the working-tree file is simply "no
+ * disagreement", so this can never change an outcome owned by `HEAD`.
+ *
+ * Note it is keyed on the type, not on the file being dirty: `memory.yaml` carrying an unrelated
+ * uncommitted edit adds nothing to the message.
+ */
+function workingTreeEntry(root, type) {
+    try {
+        return (0, loaders_1.loadMemoryYaml)(root).types[type];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether the scaffold `template.file` names is present on disk — the same disagreement test. */
+function workingTreeHasScaffold(root, templatePath) {
+    try {
+        return (0, storage_1.documentExists)((0, path_1.join)(root, templatePath));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve `type` against the `memory.yaml` **committed at `HEAD`** and return its `path`,
+ * `id_pattern`, `template` and the scaffold's committed bytes.
+ *
+ * Refusals, all returned (never thrown) and all exit `1` (`spec-005-cli-command-contract` § 1, as
+ * ruled on `bug-076`: a well-formed invocation failing a repository-state precondition is `1`, never
+ * `2`). Every one of them happens **before** anything is written, so "no file is created"
+ * (P1.3 sc.2) holds by construction:
+ *
+ * - `HEAD` holds no `memory.yaml` → `VALIDATION`, **fail-closed**. With no committed registry there
+ *   is no `path` and no scaffold to create against, and the only fail-open available is the working
+ *   tree, which is the defect. `wingfoil init` commits the registry *and* every scaffold it names in
+ *   the scaffold commit, so no legitimate flow reaches this;
+ * - the committed `memory.yaml` does not parse or validate → `VALIDATION`, same reasoning;
+ * - the type is not registered → `NOT_FOUND` with P1.3 sc.2's pinned sentence
+ *   `unknown memory type '<t>' (not defined in memory.yaml)`, verbatim and first;
+ * - the registered type declares no `id_pattern`/`template` → `VALIDATION`, unchanged wording;
+ * - `template.file` is not committed at `HEAD` → `VALIDATION`. An element copies a scaffold; copying
+ *   one that exists in no commit is how `bug-085` put bytes from an untracked file into a permanent
+ *   commit.
+ *
+ * The last three may carry a second sentence, appended only when the working tree and `HEAD` actually
+ * disagree about *this type* ({@link workingTreeEntry}).
+ */
+function resolveAddType(root, type) {
+    let committed;
+    try {
+        committed = (0, loaders_1.loadMemoryYamlAtHead)(root);
+    }
+    catch (error) {
+        if (!(error instanceof validation_1.ValidationError))
+            throw error;
+        return (0, types_1.coreErr)({
+            code: 'VALIDATION',
+            message: `cannot resolve the memory type registry: the committed '${loaders_1.MEMORY_YAML_PATH}' (at HEAD) is not readable as a ` +
+                `Memory configuration: ${error.message}. An element is created against the types the repository records ` +
+                '(dl-080), so the committed file must be valid; fix it and commit the fix, then retry.',
+            details: { issues: error.issues },
+        });
+    }
+    if (committed === null) {
+        return (0, types_1.coreErr)({
+            code: 'VALIDATION',
+            message: `cannot resolve the memory type registry: '${loaders_1.MEMORY_YAML_PATH}' is not committed at HEAD. An element is ` +
+                'created against a type the repository records, not one a working tree holds (dl-080); commit ' +
+                `'${loaders_1.MEMORY_YAML_PATH}' first, then retry.`,
+        });
+    }
+    const entry = committed.types[type];
+    if (!entry) {
+        const uncommittedType = workingTreeEntry(root, type) !== undefined
+            ? ` — the working tree's '${loaders_1.MEMORY_YAML_PATH}' defines it, but that change is not committed, and an element ` +
+                `is created against the committed registry (dl-080); commit '${loaders_1.MEMORY_YAML_PATH}' first, then retry`
+            : '';
+        return (0, types_1.coreErr)({
+            code: 'NOT_FOUND',
+            message: `unknown memory type '${type}' (not defined in memory.yaml)${uncommittedType}`,
+        });
+    }
+    const { path: pathPattern, id_pattern: idPattern, template } = entry;
+    if (idPattern === undefined || template === undefined) {
+        const live = workingTreeEntry(root, type);
+        const uncommittedShape = live !== undefined && live.id_pattern !== undefined && live.template !== undefined
+            ? ` — the working tree's '${loaders_1.MEMORY_YAML_PATH}' gives it both, but that change is not committed; commit ` +
+                `'${loaders_1.MEMORY_YAML_PATH}' first, then retry`
+            : '';
+        return (0, types_1.coreErr)({
+            code: 'VALIDATION',
+            message: `memory type '${type}' has no id_pattern/template in memory.yaml${uncommittedShape}`,
+        });
+    }
+    const templatePath = `${WINGFOIL_DIR}/${template.file}`;
+    const scaffold = (0, storage_1.readPathAtRev)(root, 'HEAD', templatePath);
+    if (scaffold === null) {
+        const tail = workingTreeHasScaffold(root, templatePath)
+            ? `; the working tree holds it, but that file is in no commit — commit '${templatePath}' first, then retry`
+            : `; add '${templatePath}' and commit it, then retry`;
+        return (0, types_1.coreErr)({
+            code: 'VALIDATION',
+            message: `cannot read the scaffold for memory type '${type}': '${templatePath}' is not committed at HEAD. An element ` +
+                `copies the scaffold the repository records, not one a working tree holds (dl-080)${tail}.`,
+        });
+    }
+    return (0, types_1.coreOk)({ type, pathPattern, idPattern, template, templatePath, scaffold });
+}
+//# sourceMappingURL=memory-add-type.js.map

package/dist/core/memory-add-type.js.map

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