@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/draft.js

@@ -1,400 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { parseToAST } from "./markdown/parser.js";
-import { extractListItems, renderSectionContent } from "./markdown/render.js";
-import { normalizeSectionTitle } from "./markdown/titles.js";
-import { markdownSourceSections, renderScopeFragment, validateScopeFragmentLines } from "./scope.js";
-import { parseVerificationDeclarations, renderVerificationDeclarations, } from "./verification-declaration.js";
-const KNOWN_SECTIONS = new Map([
-    ["context", "context"],
-    ["objective", "objective"],
-    ["design & approach", "design"],
-    ["scope", "scope"],
-    ["criteria", "criteria"],
-    ["verification", "verification"],
-]);
-const RETIRED_OR_MALFORMED_CORE_SECTIONS = new Set(["title", "name", "design", "checks"]);
-const BIND_DRAFT_SECTION_ORDER = ["title", "context", "objective", "design", "scope", "criteria", "verification"];
-function invalidBindDraft(message) {
-    throw new FlowError("INVALID_KEIYAKU_DRAFT", `INVALID_BIND_DRAFT: ${message}`);
-}
-function normalizeSectionName(name) {
-    return name.trim().toLowerCase();
-}
-/**
- * Canonicalize extension Markdown by dropping only leading/trailing blank
- * physical lines. Retained lines keep every byte (indentation, trailing
- * spaces, fences, internal blanks). Entirely blank input becomes "".
- */
-function normalizeExtensionContent(content) {
-    const lines = content.split(/\r?\n/);
-    let start = 0;
-    while (start < lines.length && lines[start].trim().length === 0) {
-        start += 1;
-    }
-    let end = lines.length;
-    while (end > start && lines[end - 1].trim().length === 0) {
-        end -= 1;
-    }
-    if (start >= end) {
-        return "";
-    }
-    return lines.slice(start, end).join("\n");
-}
-function findUnexpectedListOnlyLine(section) {
-    for (const child of section.children) {
-        if (child.type === "list")
-            continue;
-        if (child.type === "text") {
-            const line = child.lines.find((candidate) => candidate.trim().length > 0);
-            if (line)
-                return line.trim();
-            continue;
-        }
-        if (child.type === "code_block") {
-            return child.lines.find((line) => line.trim().length > 0)?.trim() ?? "```";
-        }
-        const rendered = renderSectionContent({ ...section, children: [child] }).trim();
-        if (rendered)
-            return rendered.split(/\r?\n/)[0] ?? rendered;
-    }
-    return null;
-}
-function extractSingleLineDeclarations(section, heading) {
-    const unexpected = findUnexpectedListOnlyLine(section);
-    if (unexpected) {
-        invalidBindDraft(`${heading} must be a bullet list; found '${unexpected}'`);
-    }
-    const items = extractListItems(section);
-    if (items.length === 0) {
-        const hasListNode = section.children.some((child) => child.type === "list");
-        if (hasListNode) {
-            invalidBindDraft(`empty ${heading.toLowerCase()} declaration in bind draft`);
-        }
-        invalidBindDraft(`${heading} must be a bullet list; found empty ${heading} section`);
-    }
-    return items.map((item) => {
-        const trimmed = item.trim();
-        if (trimmed.length === 0) {
-            invalidBindDraft(`empty ${heading.toLowerCase()} declaration in bind draft`);
-        }
-        if (item.includes("\n") || item.includes("\r")) {
-            invalidBindDraft(`${heading} declarations must be a single line`);
-        }
-        return trimmed;
-    });
-}
-function verificationDeclarations(section, heading) {
-    return parseVerificationDeclarations(renderSectionContent(section), { heading });
-}
-function collectBindDraftNodes(content) {
-    // Scope is parsed from source lines below. Hide its body from the Markdown AST
-    // so fence-like and heading-like payload bytes cannot acquire structure there.
-    let structuralContent = content;
-    const scopeSources = markdownSourceSections(content)
-        .filter((section) => section.level === 2 && normalizeSectionTitle(section.title) === "scope")
-        .sort((left, right) => right.contentStart - left.contentStart);
-    for (const source of scopeSources) {
-        structuralContent = `${structuralContent.slice(0, source.contentStart)}\`\`\`\nscope\n\`\`\`\n${structuralContent.slice(source.end)}`;
-    }
-    const ast = parseToAST(structuralContent);
-    let title;
-    let seenH1 = false;
-    const sections = new Map();
-    const extensions = [];
-    for (const node of ast.children) {
-        if (node.type !== "section")
-            continue;
-        if (node.level === 1) {
-            if (seenH1) {
-                invalidBindDraft("bind draft allows exactly one H1 heading");
-            }
-            seenH1 = true;
-            title = node.title.trim() || undefined;
-            continue;
-        }
-        if (node.level !== 2)
-            continue;
-        const normalized = normalizeSectionName(node.title);
-        if (RETIRED_OR_MALFORMED_CORE_SECTIONS.has(normalized)) {
-            const replacement = normalized === "checks"
-                ? "Criteria and Verification"
-                : normalized === "design"
-                    ? "Design & Approach"
-                    : "the H1 Title";
-            invalidBindDraft(`obsolete or malformed core section '${node.title}'; use ${replacement}`);
-        }
-        const coreSection = KNOWN_SECTIONS.get(normalized);
-        if (coreSection) {
-            if (sections.has(coreSection)) {
-                invalidBindDraft(`duplicate section '${node.title}' in bind draft`);
-            }
-            sections.set(coreSection, node);
-            continue;
-        }
-        extensions.push({
-            title: node.title.trim(),
-            content: normalizeExtensionContent(renderSectionContent(node)),
-        });
-    }
-    return { ...(title === undefined ? {} : { title }), sections, extensions };
-}
-function parseScopeSection(content) {
-    const sourceSections = markdownSourceSections(content).filter((section) => section.level === 2 && normalizeSectionTitle(section.title) === "scope");
-    if (sourceSections.length !== 1)
-        invalidBindDraft("bind draft must contain exactly one Scope section");
-    const source = sourceSections[0];
-    try {
-        return validateScopeFragmentLines(content.slice(source.contentStart, source.end).split(/\r?\n/), {
-            heading: "## Scope",
-            emptyMessage: "Scope must be a gitignore-subset fragment; found empty Scope section",
-        });
-    }
-    catch (error) {
-        if (error instanceof FlowError)
-            throw new FlowError(error.code, `INVALID_BIND_DRAFT: ${error.message}`);
-        throw error;
-    }
-}
-/**
- * Parse any subset of the bind document grammar. Absent sections stay undefined
- * so callers can merge task defaults under stdin overrides.
- */
-export function parsePartialBindDraft(content) {
-    if (content.trim().length === 0)
-        return {};
-    const { title, sections, extensions } = collectBindDraftNodes(content);
-    const partial = {};
-    if (title !== undefined)
-        partial.title = title;
-    for (const sectionName of ["context", "objective", "design"]) {
-        const section = sections.get(sectionName);
-        if (!section)
-            continue;
-        const text = renderSectionContent(section).trim();
-        const heading = sectionName === "design"
-            ? "Design & Approach"
-            : `${sectionName[0].toUpperCase()}${sectionName.slice(1)}`;
-        if (!text)
-            invalidBindDraft(`${heading} section cannot be empty`);
-        partial[sectionName] = text;
-    }
-    const scope = sections.get("scope");
-    if (scope) {
-        partial.scope = parseScopeSection(content);
-    }
-    const criteria = sections.get("criteria");
-    if (criteria)
-        partial.criteria = extractSingleLineDeclarations(criteria, "Criteria");
-    const verification = sections.get("verification");
-    if (verification)
-        partial.verification = verificationDeclarations(verification, "## Verification");
-    if (extensions.length > 0)
-        partial.extensions = extensions;
-    return partial;
-}
-export function mergeBindDraft(base, override) {
-    return {
-        ...(base.title !== undefined ? { title: base.title } : {}),
-        ...(base.context !== undefined ? { context: base.context } : {}),
-        ...(base.objective !== undefined ? { objective: base.objective } : {}),
-        ...(base.design !== undefined ? { design: base.design } : {}),
-        ...(base.scope !== undefined ? { scope: base.scope } : {}),
-        ...(base.criteria !== undefined ? { criteria: base.criteria } : {}),
-        ...(base.verification !== undefined ? { verification: base.verification } : {}),
-        ...(base.extensions !== undefined ? { extensions: base.extensions } : {}),
-        ...(override.title !== undefined ? { title: override.title } : {}),
-        ...(override.context !== undefined ? { context: override.context } : {}),
-        ...(override.objective !== undefined ? { objective: override.objective } : {}),
-        ...(override.design !== undefined ? { design: override.design } : {}),
-        ...(override.scope !== undefined ? { scope: override.scope } : {}),
-        ...(override.criteria !== undefined ? { criteria: override.criteria } : {}),
-        ...(override.verification !== undefined ? { verification: override.verification } : {}),
-        ...(override.extensions !== undefined ? { extensions: override.extensions } : {}),
-    };
-}
-export function missingBindDraftSections(partial) {
-    const missing = [];
-    if (partial.title === undefined || partial.title.trim().length === 0)
-        missing.push("title");
-    if (partial.context === undefined || partial.context.trim().length === 0)
-        missing.push("context");
-    if (partial.objective === undefined || partial.objective.trim().length === 0)
-        missing.push("objective");
-    if (partial.design === undefined || partial.design.trim().length === 0)
-        missing.push("design");
-    if (partial.scope === undefined || partial.scope.length === 0)
-        missing.push("scope");
-    if (partial.criteria === undefined || partial.criteria.length === 0)
-        missing.push("criteria");
-    return missing;
-}
-/** Paste-ready partial markdown for only the missing required sections. */
-export function renderMissingBindSectionsTemplate(missing) {
-    const lines = [];
-    for (const section of BIND_DRAFT_SECTION_ORDER) {
-        if (!missing.includes(section))
-            continue;
-        if (section === "title") {
-            lines.push("# <title>");
-            continue;
-        }
-        if (section === "context") {
-            lines.push("## Context", "<established facts and constraints>");
-            continue;
-        }
-        if (section === "objective") {
-            lines.push("## Objective", "<what the commission should accomplish>");
-            continue;
-        }
-        if (section === "design") {
-            lines.push("## Design & Approach", "<settled owner, boundaries, flow, state, and failure behavior>");
-            continue;
-        }
-        if (section === "scope") {
-            lines.push("## Scope", "~~~", "<pattern>", "<another-pattern>", "~~~");
-            continue;
-        }
-        if (section === "criteria") {
-            lines.push("## Criteria", "- <declarative acceptance criterion>");
-            continue;
-        }
-        lines.push("## Verification", "```bash", "<verification script>", "```");
-    }
-    return lines.join("\n");
-}
-export function describeMissingBindSections(missing) {
-    const labels = {
-        title: "Title",
-        context: "Context",
-        objective: "Objective",
-        design: "Design & Approach",
-        scope: "Scope",
-        criteria: "Criteria",
-        verification: "Verification",
-    };
-    const named = missing.map((section) => labels[section]);
-    if (named.length === 0)
-        return "";
-    if (named.length === 1)
-        return named[0];
-    if (named.length === 2)
-        return `${named[0]} or ${named[1]}`;
-    return `${named.slice(0, -1).join(", ")}, or ${named[named.length - 1]}`;
-}
-export function materializeBindDraft(partial) {
-    const missing = missingBindDraftSections(partial);
-    if (missing.length > 0) {
-        invalidBindDraft(`missing ${describeMissingBindSections(missing)} in bind draft`);
-    }
-    return {
-        title: partial.title.trim(),
-        context: partial.context.trim(),
-        objective: partial.objective.trim(),
-        design: partial.design.trim(),
-        scope: partial.scope,
-        criteria: partial.criteria,
-        verification: partial.verification ?? [],
-        extensions: partial.extensions ?? [],
-    };
-}
-export function parseBindDraft(content) {
-    const { title, sections, extensions } = collectBindDraftNodes(content);
-    if (!title) {
-        invalidBindDraft("missing H1 Title in bind draft; expected '# <title>' followed by Context, Objective, Design & Approach, Scope, and Criteria; Verification is optional");
-    }
-    const context = sections.get("context");
-    const objective = sections.get("objective");
-    const design = sections.get("design");
-    const scope = sections.get("scope");
-    const criteria = sections.get("criteria");
-    const verification = sections.get("verification");
-    if (!context)
-        invalidBindDraft("missing Context section in bind draft");
-    if (!objective)
-        invalidBindDraft("missing Objective section in bind draft");
-    if (!design)
-        invalidBindDraft("missing Design & Approach section in bind draft");
-    if (!scope)
-        invalidBindDraft("missing Scope section in bind draft");
-    const parsedScope = parseScopeSection(content);
-    if (!criteria)
-        invalidBindDraft("missing Criteria section in bind draft");
-    const contextText = renderSectionContent(context).trim();
-    const objectiveText = renderSectionContent(objective).trim();
-    const designText = renderSectionContent(design).trim();
-    if (!contextText)
-        invalidBindDraft("Context section cannot be empty");
-    if (!objectiveText)
-        invalidBindDraft("Objective section cannot be empty");
-    if (!designText)
-        invalidBindDraft("Design & Approach section cannot be empty");
-    return {
-        title,
-        context: contextText,
-        objective: objectiveText,
-        design: designText,
-        scope: parsedScope,
-        criteria: extractSingleLineDeclarations(criteria, "Criteria"),
-        verification: verification ? verificationDeclarations(verification, "## Verification") : [],
-        extensions,
-    };
-}
-export function renderBindDraft(draft) {
-    const sections = [
-        `# ${draft.title}`,
-        `## Context\n${draft.context}`,
-        `## Objective\n${draft.objective}`,
-        `## Design & Approach\n${draft.design}`,
-        `## Scope\n${renderScopeFragment(draft.scope)}`,
-        `## Criteria\n${draft.criteria.map((criterion) => `- ${criterion}`).join("\n")}`,
-    ];
-    if (draft.verification.length > 0) {
-        sections.push(`## Verification\n${renderVerificationDeclarations(draft.verification)}`);
-    }
-    for (const extension of draft.extensions) {
-        const content = normalizeExtensionContent(extension.content);
-        if (content.length > 0) {
-            sections.push(`## ${extension.title}\n${content}`);
-        }
-        else {
-            sections.push(`## ${extension.title}`);
-        }
-    }
-    return `${sections.join("\n\n")}\n`;
-}
-export function compileBindDraftFlags(input) {
-    for (const [flag, value] of [
-        ["--title", input.title],
-        ["--context", input.context],
-        ["--objective", input.objective],
-        ["--design", input.design],
-        ["--criteria", input.criteria],
-        ["--verification", input.verification],
-    ]) {
-        if (value !== undefined && (value.includes("\n") || value.includes("\r"))) {
-            throw new FlowError("EMPTY_PARAM", `${flag} must be a single line`);
-        }
-    }
-    const scope = typeof input.scope === "string" ? [input.scope] : input.scope;
-    for (const pattern of scope ?? []) {
-        if (pattern.includes("\n") || pattern.includes("\r")) {
-            throw new FlowError("EMPTY_PARAM", "--scope must be a single line");
-        }
-    }
-    const sections = [];
-    if (input.title !== undefined)
-        sections.push(`# ${input.title}`);
-    if (input.context !== undefined)
-        sections.push(`## Context\n${input.context}`);
-    if (input.objective !== undefined)
-        sections.push(`## Objective\n${input.objective}`);
-    if (input.design !== undefined)
-        sections.push(`## Design & Approach\n${input.design}`);
-    if (scope !== undefined)
-        sections.push(`## Scope\n~~~\n${scope.join("\n")}\n~~~`);
-    if (input.criteria !== undefined)
-        sections.push(`## Criteria\n- ${input.criteria}`);
-    if (input.verification !== undefined)
-        sections.push(`## Verification\n\`\`\`bash\n${input.verification}\n\`\`\``);
-    return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
-}

package/build/core/execution-coordinate.js

@@ -1,46 +0,0 @@
-import { isCommissionId } from "./ids.js";
-import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
-export function parseExecutionAuthority(value, invalid) {
-    if (!isPlainRecord(value))
-        throw invalid("authority", "must be an object");
-    if (!("kind" in value))
-        throw invalid("authority.kind", "is missing");
-    if (value.kind === "repository") {
-        // repoId is the sole legacy coordinate field accepted on read. It is inert
-        // and deliberately discarded; current writers emit the unit variant.
-        assertExactFields(value, ["kind"], ["repoId"], "authority", invalid);
-        return { kind: "repository" };
-    }
-    if (value.kind === "user") {
-        assertExactFields(value, ["kind"], [], "authority", invalid);
-        return { kind: "user" };
-    }
-    throw invalid("authority.kind", "must be 'repository' or 'user'");
-}
-export function parseExecutionBinding(value, invalid) {
-    if (!isPlainRecord(value))
-        throw invalid("binding", "must be an object");
-    if (!("kind" in value))
-        throw invalid("binding.kind", "is missing");
-    if (value.kind === "commission") {
-        assertExactFields(value, ["kind", "commissionId"], [], "binding", invalid);
-        assertNonBlankString(value.commissionId, "binding.commissionId", invalid);
-        if (!isCommissionId(value.commissionId))
-            throw invalid("binding.commissionId", "must be a full commission ID");
-        return { kind: "commission", commissionId: value.commissionId };
-    }
-    if (value.kind === "bare" || value.kind === "unbound") {
-        assertExactFields(value, ["kind"], [], "binding", invalid);
-        return { kind: value.kind };
-    }
-    throw invalid("binding.kind", "must be 'commission', 'bare', or 'unbound'");
-}
-/** The one durable authority/binding schema used by pacts and response artifacts. */
-export function parseExecutionCoordinates(authorityValue, bindingValue, invalid) {
-    const authority = parseExecutionAuthority(authorityValue, invalid);
-    const binding = parseExecutionBinding(bindingValue, invalid);
-    if (authority.kind === "user" && binding.kind === "commission") {
-        throw invalid("binding.kind", "cannot be 'commission' when authority.kind is 'user'");
-    }
-    return { authority, binding };
-}

package/build/core/execution-pact.js

@@ -1,126 +0,0 @@
-import * as path from "node:path";
-import { ProjectionStateError } from "./atomic-publish.js";
-import { parseExecutionBinding as parseCanonicalExecutionBinding, parseExecutionCoordinates, } from "./execution-coordinate.js";
-import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
-const TOP_LEVEL_FIELDS = [
-    "version",
-    "pid",
-    "akuma",
-    "provider",
-    "authority",
-    "binding",
-    "mintedAt",
-    "workspaceRoot",
-];
-const TOP_LEVEL_OPTIONAL_FIELDS = ["effectivePolicy"];
-const PACT_FIELD_NAMES = TOP_LEVEL_FIELDS.filter((field) => field !== "authority");
-function pactError(pactPath, field, reason) {
-    return new ProjectionStateError(`invalid projection pact at ${pactPath}: field '${field}' ${reason}`);
-}
-function pactInvalid(pactPath) {
-    return (field, reason) => pactError(pactPath, field, reason);
-}
-/** Parse the pre-publication authority choice without inventing a durable identity. */
-export function parseExecutionAuthoritySelection(value, pactPath = "projection identity", expectedKind) {
-    if (!isPlainRecord(value))
-        throw pactError(pactPath, "authority", "must be an object");
-    assertExactFields(value, ["kind"], [], "authority", pactInvalid(pactPath));
-    if (value.kind !== "repository" && value.kind !== "user") {
-        throw pactError(pactPath, "authority.kind", "must be 'repository' or 'user'");
-    }
-    if (expectedKind !== undefined && value.kind !== expectedKind) {
-        throw pactError(pactPath, "authority.kind", `must be '${expectedKind}' for this projection mint`);
-    }
-    return { kind: value.kind };
-}
-/** Parse and validate an execution binding without inventing authority identity. */
-export function parseExecutionBinding(value, pactPath = "projection identity") {
-    return parseCanonicalExecutionBinding(value, (field, reason) => pactError(pactPath, field, reason));
-}
-export function assertExecutionPactCoordinates(authorityValue, bindingValue, pactPath = "projection identity") {
-    return parseExecutionCoordinates(authorityValue, bindingValue, (field, reason) => pactError(pactPath, field, reason));
-}
-function parseEffectivePolicy(value, pactPath) {
-    if (!isPlainRecord(value))
-        throw pactError(pactPath, "effectivePolicy", "must be an object");
-    assertExactFields(value, [], ["access", "network", "webSearch"], "effectivePolicy", pactInvalid(pactPath));
-    if (value.access !== undefined && value.access !== "read" && value.access !== "write" && value.access !== "auto") {
-        throw pactError(pactPath, "effectivePolicy.access", "must be 'read', 'write', or 'auto'");
-    }
-    if (value.network !== undefined && value.network !== "disabled" && value.network !== "enabled") {
-        throw pactError(pactPath, "effectivePolicy.network", "must be 'disabled' or 'enabled'");
-    }
-    if (value.webSearch !== undefined && !["disabled", "cached", "live"].includes(String(value.webSearch))) {
-        throw pactError(pactPath, "effectivePolicy.webSearch", "must be 'disabled', 'cached', or 'live'");
-    }
-    return value;
-}
-function parseExecutionPactFieldsRecord(value, pactPath) {
-    if (value.version !== 1)
-        throw pactError(pactPath, "version", "must equal 1");
-    if (!Number.isInteger(value.pid) || value.pid < 0) {
-        throw pactError(pactPath, "pid", "must be a non-negative integer");
-    }
-    const invalid = pactInvalid(pactPath);
-    assertNonBlankString(value.akuma, "akuma", invalid);
-    assertNonBlankString(value.provider, "provider", invalid);
-    assertNonBlankString(value.mintedAt, "mintedAt", invalid);
-    const mintedAtMs = Date.parse(value.mintedAt);
-    if (!Number.isFinite(mintedAtMs) || new Date(mintedAtMs).toISOString() !== value.mintedAt) {
-        throw pactError(pactPath, "mintedAt", "must be an ISO-8601 timestamp");
-    }
-    assertNonBlankString(value.workspaceRoot, "workspaceRoot", invalid);
-    if (!path.isAbsolute(value.workspaceRoot)) {
-        throw pactError(pactPath, "workspaceRoot", "must be an absolute path");
-    }
-    const binding = parseExecutionBinding(value.binding, pactPath);
-    return {
-        version: 1,
-        pid: value.pid,
-        akuma: value.akuma,
-        provider: value.provider,
-        binding,
-        mintedAt: value.mintedAt,
-        workspaceRoot: value.workspaceRoot,
-        ...(value.effectivePolicy !== undefined
-            ? { effectivePolicy: parseEffectivePolicy(value.effectivePolicy, pactPath) }
-            : {}),
-    };
-}
-/** Validate every pact field that exists before a repository identity is minted. */
-export function parseExecutionPactFields(value, pactPath = "projection identity") {
-    if (!isPlainRecord(value))
-        throw pactError(pactPath, "$", "must be an object");
-    assertExactFields(value, PACT_FIELD_NAMES, TOP_LEVEL_OPTIONAL_FIELDS, "", pactInvalid(pactPath));
-    return parseExecutionPactFieldsRecord(value, pactPath);
-}
-export function parseExecutionPact(value, pactPath = "projection identity") {
-    if (!isPlainRecord(value))
-        throw pactError(pactPath, "$", "must be an object");
-    assertExactFields(value, TOP_LEVEL_FIELDS, TOP_LEVEL_OPTIONAL_FIELDS, "", pactInvalid(pactPath));
-    const fields = parseExecutionPactFieldsRecord(value, pactPath);
-    const { authority, binding } = assertExecutionPactCoordinates(value.authority, fields.binding, pactPath);
-    return {
-        version: fields.version,
-        pid: fields.pid,
-        akuma: fields.akuma,
-        provider: fields.provider,
-        authority,
-        binding,
-        mintedAt: fields.mintedAt,
-        workspaceRoot: fields.workspaceRoot,
-        ...(fields.effectivePolicy !== undefined ? { effectivePolicy: fields.effectivePolicy } : {}),
-    };
-}
-export function parseExecutionPactJson(raw, pactPath = "projection identity") {
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new ProjectionStateError(`invalid projection pact at ${pactPath}: field '$' contains malformed JSON`, {
-            cause: error,
-        });
-    }
-    return parseExecutionPact(value, pactPath);
-}