@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/library/repo.js

@@ -0,0 +1,76 @@
+import { currentBranchOperation, NoGitWorldError, reconcileAllOperation, scopeOperation, } from "../protocol/operations.js";
+import { settleAll } from "../settlement/settle.js";
+import { optionalNonblank, requireInput } from "./input.js";
+import { worktreeHooksOption } from "./configuration.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { projectContractWorktree } from "../contract-worktree.js";
+export { NoGitWorldError };
+const REPO_SCOPES = new WeakMap();
+function resolvePinnedScope(path) {
+    return scopeOperation({ coordinate: path === undefined ? process.cwd() : path });
+}
+export function reconcileInput(input) {
+    const values = input === undefined ? undefined : requireInput(input, "reconcile input");
+    if (values?.retryHooks !== undefined && typeof values.retryHooks !== "boolean") {
+        throw new TypeError("retryHooks must be a boolean");
+    }
+    return {
+        hooks: worktreeHooksOption(values?.hooks),
+        retryHooks: values?.retryHooks ?? false,
+    };
+}
+export class Repo {
+    root;
+    constructor(scope) {
+        this.root = scope.primaryWorktree;
+        REPO_SCOPES.set(this, scope);
+    }
+    static at(input) {
+        const values = input === undefined ? undefined : requireInput(input, "Repo.at input");
+        return new Repo(resolvePinnedScope(optionalNonblank(values?.path, "repository path")));
+    }
+    async currentBranch() {
+        return currentBranchOperation({ scope: scopeForRepo(this) });
+    }
+    async reconcile(input) {
+        const scope = scopeForRepo(this);
+        return withGitDecodeChannel(scope, async (channel) => {
+            const options = reconcileInput(input);
+            const retained = await reconcileAllOperation({ scope, channel, ...options, retainTerminalWorktree: true });
+            const settlements = await settleAll({
+                repository: scope,
+                channel,
+                contracts: retained.contracts.map((contract) => ({
+                    state: contract.state,
+                    effects: contract.report.effects,
+                })),
+            });
+            const deferRemoval = retained.contracts.some((contract) => contract.state !== null && contract.state.terminal !== null
+                && contract.state.coordinates.workspace === "worktree");
+            const cleanup = deferRemoval ? await reconcileAllOperation({ scope, channel, ...options }) : null;
+            const later = cleanup === null ? null : new Map(cleanup.contracts.map((contract) => [contract.contractId, contract.report]));
+            return {
+                contracts: retained.contracts.map((contract, index) => {
+                    const report = later?.get(contract.contractId);
+                    const projection = projectContractWorktree(scope, contract.state);
+                    return {
+                        contractId: contract.contractId,
+                        report: {
+                            effects: [...contract.report.effects, ...projection.effects, ...(report?.effects ?? [])],
+                            lag: [...contract.report.lag, ...projection.lag, ...(report?.lag ?? [])],
+                            settlement: settlements[index],
+                        },
+                    };
+                }),
+            };
+        });
+    }
+}
+export function scopeForRepo(value) {
+    if (!(value instanceof Repo))
+        throw new TypeError("repo must be a Repo");
+    const scope = REPO_SCOPES.get(value);
+    if (scope === undefined)
+        throw new TypeError("repo must be a Repo");
+    return scope;
+}

package/build/src/markdown/diff.d.ts

@@ -0,0 +1 @@
+export declare function documentDiff(beforePath: string, afterPath: string, before: string, after: string): string;

package/build/src/markdown/diff.js

@@ -0,0 +1,4 @@
+import { createTwoFilesPatch } from "diff";
+export function documentDiff(beforePath, afterPath, before, after) {
+    return before === after ? "" : createTwoFilesPatch(beforePath, afterPath, before, after, "", "", { context: 3 });
+}

package/build/src/markdown/lex.d.ts

@@ -0,0 +1,3 @@
+import { type FenceState, type MarkdownToken } from "./types.js";
+export declare function fenceClosing(line: string, fence: FenceState): boolean;
+export declare function lexMarkdown(source: string): readonly MarkdownToken[];

package/build/src/markdown/lex.js

@@ -0,0 +1,221 @@
+import { MarkdownParseError } from "./types.js";
+import { isAlias, isMap, isScalar, isSeq, parseDocument } from "yaml";
+function leadingSpaces(line) {
+    let index = 0;
+    while (line[index] === " ")
+        index += 1;
+    return index;
+}
+function fenceOpening(line) {
+    const spaces = leadingSpaces(line);
+    if (spaces > 3)
+        return null;
+    const value = line.slice(spaces);
+    const delimiter = value.startsWith("```") ? "`" : value.startsWith("~~~") ? "~" : null;
+    if (delimiter === null)
+        return null;
+    let length = 0;
+    while (value[length] === delimiter)
+        length += 1;
+    const info = value.slice(length).trim();
+    if (delimiter === "`" && info.includes("`"))
+        return null;
+    return { delimiter, length, leadingSpaces: spaces, info };
+}
+export function fenceClosing(line, fence) {
+    const spaces = leadingSpaces(line);
+    if (spaces > 3)
+        return false;
+    const value = line.slice(spaces);
+    let length = 0;
+    while (value[length] === fence.delimiter)
+        length += 1;
+    return length >= fence.length && /^[ \t]*$/.test(value.slice(length));
+}
+function sourceLines(source, start) {
+    const lines = [];
+    let cursor = start;
+    while (cursor < source.length) {
+        const newline = source.indexOf("\n", cursor);
+        const end = newline === -1 ? source.length : newline + 1;
+        const raw = source.slice(cursor, end);
+        const withoutNewline = raw.endsWith("\n") ? raw.slice(0, -1) : raw;
+        const text = withoutNewline.endsWith("\r") ? withoutNewline.slice(0, -1) : withoutNewline;
+        lines.push({ text, raw, span: { start: cursor, end } });
+        cursor = end;
+    }
+    return lines;
+}
+function header(line) {
+    let level = 0;
+    while (line[level] === "#")
+        level += 1;
+    if (level === 0 || (line[level] !== " " && line[level] !== "\t"))
+        return null;
+    const text = line.slice(level).trim().replace(/[ \t]+#+[ \t]*$/, "").trimEnd();
+    return text.length === 0 ? null : { level, text };
+}
+function listMarker(line) {
+    const indent = leadingSpaces(line);
+    let end = indent;
+    let ordered = false;
+    const first = line[end];
+    if (first === "-" || first === "*" || first === "+") {
+        end += 1;
+    }
+    else if (first !== undefined && first >= "0" && first <= "9") {
+        while (line[end] !== undefined && line[end] >= "0" && line[end] <= "9")
+            end += 1;
+        if (line[end] !== "." && line[end] !== ")")
+            return null;
+        end += 1;
+        ordered = true;
+    }
+    else {
+        return null;
+    }
+    if (line[end] !== " " && line[end] !== "\t")
+        return null;
+    const marker = line.slice(indent, end);
+    while (line[end] === " " || line[end] === "\t")
+        end += 1;
+    return { indent, marker, ordered, body: line.slice(end), bodyStart: end };
+}
+function blockquote(line) {
+    const spaces = leadingSpaces(line);
+    if (spaces > 3 || line[spaces] !== ">")
+        return null;
+    let end = spaces + 1;
+    if (line[end] === " ")
+        end += 1;
+    return { marker: line.slice(0, end), body: line.slice(end) };
+}
+function validateFrontmatterNode(node) {
+    if (node == null)
+        return;
+    if (isAlias(node) || ("anchor" in node && Boolean(node.anchor)) || ("tag" in node && Boolean(node.tag))) {
+        throw new MarkdownParseError("frontmatter aliases, anchors, and explicit tags are not supported");
+    }
+    if (isMap(node)) {
+        for (const item of node.items) {
+            const pair = item;
+            validateFrontmatterNode(pair.key);
+            validateFrontmatterNode(pair.value);
+        }
+        return;
+    }
+    if (isSeq(node)) {
+        for (const item of node.items)
+            validateFrontmatterNode(item);
+        return;
+    }
+    if (!isScalar(node))
+        throw new MarkdownParseError("unsupported frontmatter value");
+}
+function frontmatterValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (Array.isArray(value))
+        return value.map(frontmatterValue);
+    if (typeof value === "object" && value !== null) {
+        const record = {};
+        for (const [key, item] of Object.entries(value))
+            record[key] = frontmatterValue(item);
+        return record;
+    }
+    throw new MarkdownParseError("unsupported frontmatter value");
+}
+function parseFrontmatter(source) {
+    const parsed = parseDocument(source, { merge: false, prettyErrors: false, strict: true, uniqueKeys: true });
+    if (parsed.errors.length > 0)
+        throw new MarkdownParseError(parsed.errors[0].message);
+    validateFrontmatterNode(parsed.contents);
+    if (!isMap(parsed.contents))
+        throw new MarkdownParseError("frontmatter must be a mapping");
+    for (const item of parsed.contents.items) {
+        if (!isScalar(item.key) || typeof item.key.value !== "string") {
+            throw new MarkdownParseError("frontmatter keys must be strings");
+        }
+    }
+    return frontmatterValue(parsed.toJS({ mapAsMap: false }));
+}
+function frontmatter(lines) {
+    if (lines[0]?.text.trim() !== "---")
+        return null;
+    let closing = 1;
+    while (closing < lines.length && lines[closing].text.trim() !== "---")
+        closing += 1;
+    if (closing >= lines.length)
+        return null;
+    const yaml = lines.slice(1, closing).map((line) => line.text).join("\n");
+    const entries = parseFrontmatter(yaml);
+    const selected = lines.slice(0, closing + 1);
+    return {
+        token: {
+            type: "frontmatter",
+            raw: selected.map((line) => line.raw).join(""),
+            span: { start: selected[0].span.start, end: selected.at(-1).span.end },
+            entries,
+        },
+        next: closing + 1,
+    };
+}
+export function lexMarkdown(source) {
+    const bomLength = source.startsWith("\uFEFF") ? 1 : 0;
+    const lines = sourceLines(source, bomLength);
+    const tokens = [];
+    let index = 0;
+    const metadata = frontmatter(lines);
+    if (metadata !== null) {
+        tokens.push(metadata.token);
+        index = metadata.next;
+    }
+    let activeFence;
+    for (; index < lines.length; index += 1) {
+        const line = lines[index];
+        const spaces = leadingSpaces(line.text);
+        if (activeFence !== undefined) {
+            if (fenceClosing(line.text, activeFence)) {
+                const opening = fenceOpening(line.text);
+                tokens.push({ type: "fence", raw: line.raw, span: line.span, ...opening });
+                activeFence = undefined;
+            }
+            else {
+                tokens.push({ type: "text", raw: line.raw, span: line.span, leadingSpaces: spaces });
+            }
+            continue;
+        }
+        const opening = fenceOpening(line.text);
+        if (opening !== null) {
+            tokens.push({ type: "fence", raw: line.raw, span: line.span, ...opening });
+            activeFence = { delimiter: opening.delimiter, length: opening.length };
+            continue;
+        }
+        const parsedHeader = spaces === 0 ? header(line.text) : null;
+        if (parsedHeader !== null) {
+            tokens.push({ type: "header", raw: line.raw, span: line.span, leadingSpaces: spaces, ...parsedHeader });
+            continue;
+        }
+        const parsedList = listMarker(line.text);
+        if (parsedList !== null) {
+            tokens.push({
+                type: "list_marker",
+                raw: line.raw,
+                span: line.span,
+                leadingSpaces: spaces,
+                ...parsedList,
+                bodyStart: line.span.start + parsedList.bodyStart,
+            });
+            continue;
+        }
+        const parsedQuote = blockquote(line.text);
+        if (parsedQuote !== null) {
+            tokens.push({ type: "blockquote", raw: line.raw, span: line.span, leadingSpaces: spaces, ...parsedQuote });
+            continue;
+        }
+        tokens.push({ type: "text", raw: line.raw, span: line.span, leadingSpaces: spaces });
+    }
+    return tokens;
+}

package/build/src/markdown/parse.d.ts

@@ -0,0 +1,2 @@
+import { type DocumentNode } from "./types.js";
+export declare function parseToAST(source: string): DocumentNode;

package/build/src/markdown/parse.js

@@ -0,0 +1,221 @@
+import { fenceClosing, lexMarkdown } from "./lex.js";
+import { MarkdownParseError, } from "./types.js";
+function spanFrom(first, last) {
+    return { start: first.start, end: last.end };
+}
+function isSection(token) {
+    return token?.type === "header" && token.leadingSpaces === 0 && (token.level === 1 || token.level === 2);
+}
+function withoutTrailingLineEnding(value) {
+    return value.endsWith("\r\n") ? value.slice(0, -2) : value.endsWith("\n") ? value.slice(0, -1) : value;
+}
+class Parser {
+    tokens;
+    options;
+    index = 0;
+    constructor(tokens, options) {
+        this.tokens = tokens;
+        this.options = options;
+    }
+    parseDocument(source, span, bomLength) {
+        const frontmatter = this.parseFrontmatter();
+        return {
+            type: "document",
+            source,
+            span,
+            bomLength,
+            ...(frontmatter === undefined ? {} : { frontmatter }),
+            children: this.parseBlocks(() => false),
+        };
+    }
+    parseFrontmatter() {
+        const token = this.peek();
+        if (token?.type !== "frontmatter")
+            return undefined;
+        this.consume();
+        return { type: "frontmatter", span: token.span, entries: token.entries };
+    }
+    parseBlocks(stop) {
+        const blocks = [];
+        while (!this.done() && !stop()) {
+            const token = this.peek();
+            if (token === undefined)
+                break;
+            if (this.options.mode === "document" && isSection(token))
+                blocks.push(this.parseSection());
+            else if (token.type === "fence")
+                blocks.push(this.parseCodeBlock());
+            else if (token.type === "header")
+                blocks.push(this.parseHeading());
+            else if (token.type === "list_marker" && (this.options.mode === "item" || token.indent <= 3))
+                blocks.push(this.parseList(token.indent, token.ordered));
+            else if (token.type === "blockquote")
+                blocks.push(this.parseBlockquote());
+            else if (token.type === "frontmatter")
+                this.consume();
+            else
+                blocks.push(this.parseText(stop));
+        }
+        return blocks;
+    }
+    parseSection() {
+        const header = this.consume();
+        if (!isSection(header))
+            throw new MarkdownParseError("invalid parser state: expected section");
+        const children = this.parseBlocks(() => this.options.mode === "document" && isSection(this.peek()));
+        return {
+            type: "section",
+            level: header.level,
+            title: header.text,
+            contentStart: header.span.end,
+            span: { start: header.span.start, end: children.at(-1)?.span.end ?? header.span.end },
+            children,
+        };
+    }
+    parseCodeBlock() {
+        const opener = this.consume();
+        if (opener?.type !== "fence")
+            throw new MarkdownParseError("invalid parser state: expected fence");
+        const state = { delimiter: opener.delimiter, length: opener.length };
+        const lines = [withoutTrailingLineEnding(opener.raw)];
+        let end = opener.span.end;
+        let closed = false;
+        while (!this.done()) {
+            const token = this.consume();
+            if (token === undefined)
+                break;
+            lines.push(withoutTrailingLineEnding(token.raw));
+            end = token.span.end;
+            if (token.type === "fence" && fenceClosing(withoutTrailingLineEnding(token.raw), state)) {
+                closed = true;
+                break;
+            }
+        }
+        return {
+            type: "code_block",
+            span: { start: opener.span.start, end },
+            delimiter: opener.delimiter,
+            fenceLength: opener.length,
+            info: opener.info,
+            closed,
+            lines,
+        };
+    }
+    parseHeading() {
+        const token = this.consume();
+        if (token?.type !== "header")
+            throw new MarkdownParseError("invalid parser state: expected heading");
+        return { type: "heading", span: token.span, level: token.level, text: token.text };
+    }
+    parseBlockquote() {
+        const first = this.peek();
+        if (first?.type !== "blockquote")
+            throw new MarkdownParseError("invalid parser state: expected blockquote");
+        const lines = [];
+        let last = first;
+        while (this.peek()?.type === "blockquote") {
+            const token = this.consume();
+            lines.push(token.body);
+            last = token;
+        }
+        return {
+            type: "blockquote",
+            span: spanFrom(first.span, last.span),
+            marker: first.marker,
+            lines,
+            value: lines.join("\n"),
+        };
+    }
+    parseList(indent, ordered) {
+        const items = [];
+        let first;
+        while (true) {
+            const token = this.peek();
+            if (token?.type !== "list_marker" || token.indent !== indent || token.ordered !== ordered)
+                break;
+            first ??= token;
+            this.consume();
+            items.push(this.parseListItem(token, indent));
+        }
+        if (first === undefined || items.length === 0)
+            throw new MarkdownParseError("invalid parser state: expected list");
+        return {
+            type: "list",
+            span: spanFrom(first.span, items.at(-1).span),
+            ordered,
+            indent,
+            items,
+        };
+    }
+    parseListItem(marker, indent) {
+        const bodyOffset = marker.bodyStart - marker.span.start;
+        const itemTokens = [{
+                type: "text",
+                raw: marker.raw.slice(bodyOffset),
+                span: { start: marker.bodyStart, end: marker.span.end },
+                leadingSpaces: 0,
+            }];
+        let end = marker.span.end;
+        while (!this.done()) {
+            const token = this.peek();
+            if (token === undefined)
+                break;
+            if (this.options.mode === "document" && isSection(token))
+                break;
+            if (token.type === "header" && token.leadingSpaces <= indent)
+                break;
+            if (token.type === "fence" && token.leadingSpaces <= indent)
+                break;
+            if (token.type === "list_marker" && token.indent <= indent)
+                break;
+            this.consume();
+            itemTokens.push(token);
+            end = token.span.end;
+        }
+        const childSpan = { start: itemTokens[0].span.start, end: itemTokens.at(-1).span.end };
+        const children = new Parser(itemTokens, { mode: "item" })
+            .parseDocument("", childSpan, 0).children;
+        return { type: "list_item", span: { start: marker.span.start, end }, marker: marker.marker, indent, children };
+    }
+    parseText(stop) {
+        const tokens = [];
+        while (!this.done() && !stop()) {
+            const token = this.peek();
+            if (token === undefined || token.type === "fence" || token.type === "header" || token.type === "blockquote" || token.type === "frontmatter")
+                break;
+            if (token.type === "list_marker" && (this.options.mode === "item" || token.indent <= 3))
+                break;
+            tokens.push(token);
+            this.consume();
+        }
+        if (tokens.length === 0) {
+            const fallback = this.consume();
+            if (fallback === undefined)
+                throw new MarkdownParseError("invalid parser state: expected text");
+            tokens.push(fallback);
+        }
+        const raw = tokens.map((token) => token.raw).join("");
+        return {
+            type: "text",
+            span: spanFrom(tokens[0].span, tokens.at(-1).span),
+            lines: raw.split(/\r?\n/),
+            value: withoutTrailingLineEnding(raw),
+        };
+    }
+    peek() {
+        return this.tokens[this.index];
+    }
+    consume() {
+        const token = this.tokens[this.index];
+        this.index += 1;
+        return token;
+    }
+    done() {
+        return this.index >= this.tokens.length;
+    }
+}
+export function parseToAST(source) {
+    const bomLength = source.startsWith("\uFEFF") ? 1 : 0;
+    return new Parser(lexMarkdown(source), { mode: "document" })
+        .parseDocument(source, { start: 0, end: source.length }, bomLength);
+}

package/build/src/markdown/query.d.ts

@@ -0,0 +1,21 @@
+import type { DocumentNode, HeadingNode, MarkdownBlockNode, MarkdownNode, SectionNode, SourceSpan } from "./types.js";
+type HeadingLike = SectionNode | HeadingNode;
+type DocumentIndex = Readonly<{
+    byLevel: ReadonlyMap<number, readonly HeadingLike[]>;
+    byTitle: ReadonlyMap<string, readonly HeadingLike[]>;
+}>;
+export declare function normalizeTitle(value: string): string;
+export declare function indexDocument(document: DocumentNode): DocumentIndex;
+export declare function rawSlice(document: DocumentNode, span: SourceSpan): string;
+export declare function sectionContent(document: DocumentNode, section: SectionNode): string;
+export declare function indexedHeadings(index: DocumentIndex, query: Readonly<{
+    title?: string;
+    level?: number;
+}>): readonly HeadingLike[];
+type NodeByType<Type extends MarkdownBlockNode["type"]> = Extract<MarkdownBlockNode, {
+    type: Type;
+}>;
+export declare function directChildren<Type extends MarkdownBlockNode["type"]>(node: Extract<MarkdownNode, {
+    children: readonly MarkdownBlockNode[];
+}>, type: Type): readonly NodeByType<Type>[];
+export {};

package/build/src/markdown/query.js

@@ -0,0 +1,51 @@
+export function normalizeTitle(value) {
+    return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function headings(node) {
+    const result = [];
+    if (node.type === "section" || node.type === "heading")
+        result.push(node);
+    if (node.type === "document" || node.type === "section") {
+        for (const child of node.children)
+            result.push(...headings(child));
+    }
+    else if (node.type === "list") {
+        for (const item of node.items) {
+            for (const child of item.children)
+                result.push(...headings(child));
+        }
+    }
+    return result;
+}
+export function indexDocument(document) {
+    const byLevel = new Map();
+    const byTitle = new Map();
+    for (const node of headings(document)) {
+        const level = byLevel.get(node.level) ?? [];
+        level.push(node);
+        byLevel.set(node.level, level);
+        const title = normalizeTitle(node.type === "section" ? node.title : node.text);
+        const matches = byTitle.get(title) ?? [];
+        matches.push(node);
+        byTitle.set(title, matches);
+    }
+    return { byLevel, byTitle };
+}
+export function rawSlice(document, span) {
+    if (span.start < 0 || span.end < span.start || span.end > document.source.length) {
+        throw new RangeError("source span is outside the parsed document");
+    }
+    return document.source.slice(span.start, span.end);
+}
+export function sectionContent(document, section) {
+    return rawSlice(document, { start: section.contentStart, end: section.span.end });
+}
+export function indexedHeadings(index, query) {
+    const candidates = query.title === undefined
+        ? query.level === undefined ? [] : index.byLevel.get(query.level) ?? []
+        : index.byTitle.get(normalizeTitle(query.title)) ?? [];
+    return query.level === undefined ? candidates : candidates.filter((node) => node.level === query.level);
+}
+export function directChildren(node, type) {
+    return node.children.filter((child) => child.type === type);
+}