@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/scope.js

@@ -1,416 +0,0 @@
-import { FlowError } from "../flow-error.js";
-export class ScopePatternError extends Error {
-    code = "INVALID_SCOPE_PATTERN";
-    constructor(message) {
-        super(message);
-        this.name = "ScopePatternError";
-    }
-}
-/**
- * Gitignore trailing spaces are ignored unless escaped with a backslash.
- * Preserve `\ ` (and longer odd-backslash runs) while stripping only unescaped
- * trailing SPACE characters. Tabs and other trailing whitespace stay as written.
- */
-function stripUnescapedTrailingSpaces(value) {
-    let end = value.length;
-    while (end > 0 && value[end - 1] === " ") {
-        let backslashes = 0;
-        for (let index = end - 2; index >= 0 && value[index] === "\\"; index -= 1) {
-            backslashes += 1;
-        }
-        if (backslashes % 2 === 1)
-            break;
-        end -= 1;
-    }
-    return value.slice(0, end);
-}
-/**
- * Drop cosmetic framing whitespace without destroying escaped trailing spaces.
- * Leading whitespace is always cosmetic for scope entry; trailing SPACE follows
- * gitignore escape rules.
- */
-function canonicalizeScopePatternInput(pattern) {
-    return stripUnescapedTrailingSpaces(pattern.replace(/^\s+/, ""));
-}
-/** True when a raw scope line has no pattern after gitignore blank rules. */
-export function isBlankScopePatternLine(line) {
-    return canonicalizeScopePatternInput(line).length === 0;
-}
-/** Parse Keiyaku's source-line Scope opener, not a normalized Markdown node. */
-export function parseScopeFenceOpening(line) {
-    const match = line.match(/^(`{3,}|~{3,})$/);
-    return match ? { delimiter: match[1][0], length: match[1].length } : null;
-}
-/** Keiyaku closer: matching column-zero delimiter, at least opener length, then whitespace. */
-export function isScopeFenceClosing(line, fence) {
-    const match = line.match(/^(`+|~+)[ \t]*$/);
-    return Boolean(match && match[1][0] === fence.delimiter && match[1].length >= fence.length);
-}
-function fencedScopeError(heading, detail) {
-    return new FlowError("INVALID_KEIYAKU_DRAFT", `${heading} must contain exactly one fenced gitignore-subset block; ${detail}. ` +
-        `Paste-ready canonical example:\n\n${heading}\n~~~\nfoo\nbar\n~~~`);
-}
-/** Validate and normalize the one fenced block that constitutes a Scope body. */
-export function validateScopeFragmentLines(lines, options) {
-    const first = lines.findIndex((line) => line.trim().length > 0);
-    if (first === -1)
-        throw fencedScopeError(options.heading, "found no fenced block");
-    const fence = parseScopeFenceOpening(lines[first]);
-    if (!fence)
-        throw fencedScopeError(options.heading, `offending line '${lines[first]}'`);
-    let close = -1;
-    for (let index = first + 1; index < lines.length; index += 1) {
-        if (isScopeFenceClosing(lines[index], fence)) {
-            close = index;
-            break;
-        }
-    }
-    if (close === -1)
-        throw fencedScopeError(options.heading, "the fenced block is not closed");
-    const outside = lines.slice(close + 1).find((line) => line.trim().length > 0);
-    if (outside !== undefined) {
-        throw fencedScopeError(options.heading, `offending line '${outside}' appears outside the fenced block`);
-    }
-    const patterns = [];
-    for (const line of lines.slice(first + 1, close)) {
-        if (isBlankScopePatternLine(line))
-            continue;
-        try {
-            patterns.push(normalizeScopePattern(line));
-        }
-        catch (error) {
-            if (error instanceof ScopePatternError) {
-                throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message);
-            }
-            throw error;
-        }
-    }
-    if (patterns.length === 0)
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", options.emptyMessage);
-    return patterns;
-}
-function sourceFenceOpening(line) {
-    const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
-    if (!match)
-        return null;
-    const marker = match[1];
-    if (marker[0] === "`" && match[2].includes("`"))
-        return null;
-    return { delimiter: marker[0], length: marker.length };
-}
-function sourceFenceClosing(line, fence) {
-    const match = line.match(/^ {0,3}(`+|~+)[ \t]*$/);
-    return Boolean(match && match[1][0] === fence.delimiter && match[1].length >= fence.length);
-}
-/** Locate structural H1/H2 source ranges while leaving fenced headings inert. */
-export function markdownSourceSections(markdown) {
-    const lines = [];
-    let start = 0;
-    while (start < markdown.length) {
-        const newline = markdown.indexOf("\n", start);
-        const end = newline === -1 ? markdown.length : newline;
-        const next = newline === -1 ? markdown.length : newline + 1;
-        const raw = markdown.slice(start, end);
-        lines.push({ text: raw.endsWith("\r") ? raw.slice(0, -1) : raw, start, next });
-        start = next;
-    }
-    let frontMatterEnd = -1;
-    if (lines[0]?.text.trim() === "---") {
-        frontMatterEnd = lines.findIndex((line, index) => index > 0 && line.text.trim() === "---");
-    }
-    const headings = [];
-    let fence = null;
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (index <= frontMatterEnd)
-            continue;
-        if (fence) {
-            if (sourceFenceClosing(line.text, fence))
-                fence = null;
-            continue;
-        }
-        const opening = sourceFenceOpening(line.text);
-        if (opening) {
-            fence = opening;
-            continue;
-        }
-        // Column-0 only: indented ATX-looking lines inside list items remain content.
-        const heading = line.text.match(/^(#{1,2})(?!#)[ \t]+(.+)$/);
-        if (!heading)
-            continue;
-        headings.push({
-            level: heading[1].length,
-            title: heading[2],
-            start: line.start,
-            contentStart: line.next,
-        });
-    }
-    return headings.map((heading, index) => {
-        const next = heading.level === 2
-            ? headings.slice(index + 1).find((candidate) => candidate.level === 2)
-            : headings[index + 1];
-        return { ...heading, end: next?.start ?? markdown.length };
-    });
-}
-/** Render canonical Scope bytes with a tilde fence that content cannot close. */
-export function renderScopeFragment(patterns) {
-    let longestRun = 0;
-    for (const pattern of patterns) {
-        for (const run of pattern.match(/~+/g) ?? [])
-            longestRun = Math.max(longestRun, run.length);
-    }
-    const fence = "~".repeat(Math.max(3, longestRun + 1));
-    return `${fence}\n${patterns.join("\n")}\n${fence}`;
-}
-/**
- * Canonicalize a scope Gitignore-like pattern for matching and persistence.
- * Strips only a cosmetic leading `./` (including after `!`); preserves meaningful
- * leading `/` anchoring, supported backslash escapes, and escaped trailing spaces.
- */
-export function normalizeScopePattern(pattern) {
-    if (pattern.includes("\0") || pattern.includes("\n") || pattern.includes("\r")) {
-        throw new ScopePatternError("scope pattern must fit on one line and cannot contain NUL");
-    }
-    const trimmed = canonicalizeScopePatternInput(pattern);
-    if (!trimmed)
-        throw new ScopePatternError("scope pattern cannot be empty");
-    const negative = trimmed.startsWith("!");
-    let body = negative ? trimmed.slice(1) : trimmed;
-    while (body.startsWith("./")) {
-        body = body.slice(2);
-    }
-    if (!body)
-        throw new ScopePatternError("scope pattern cannot be empty");
-    return negative ? `!${body}` : body;
-}
-/**
- * Normalize a path to Git diff form for matcher comparison:
- * either slash convention, collapse separators, and strip cosmetic `./` or `/`.
- * Leading and trailing spaces are significant path bytes and must remain unchanged.
- */
-export function normalizeScopePath(filePath) {
-    let normalized = filePath.replace(/\\/g, "/").replace(/\/+/g, "/");
-    while (normalized.startsWith("./")) {
-        normalized = normalized.slice(2);
-    }
-    normalized = normalized.replace(/^\/+/, "");
-    if (!normalized || normalized === ".")
-        throw new ScopePatternError("scope path cannot be empty");
-    if (normalized.includes("\0"))
-        throw new ScopePatternError("scope path cannot contain NUL");
-    return normalized;
-}
-function splitPatternComponents(pattern) {
-    const components = [];
-    let component = "";
-    let escaped = false;
-    for (const character of pattern) {
-        if (escaped) {
-            component += `\\${character}`;
-            escaped = false;
-        }
-        else if (character === "\\") {
-            escaped = true;
-        }
-        else if (character === "/") {
-            components.push(component);
-            component = "";
-        }
-        else {
-            component += character;
-        }
-    }
-    if (escaped)
-        component += "\\\\";
-    components.push(component);
-    return components;
-}
-function parseScopePattern(pattern) {
-    const normalized = normalizeScopePattern(pattern);
-    const escapedLeading = normalized.startsWith("\\!") || normalized.startsWith("\\#");
-    const negative = normalized.startsWith("!");
-    const body = negative ? normalized.slice(1) : normalized;
-    const comment = !escapedLeading && body.startsWith("#");
-    const anchored = body.startsWith("/");
-    const unanchored = anchored ? body.slice(1) : body;
-    const directory = unanchored.endsWith("/");
-    const source = directory ? unanchored.slice(0, -1) : unanchored;
-    const segments = splitPatternComponents(source);
-    return { negative, comment, directory, segments, componentOnly: !anchored && !source.includes("/") };
-}
-function componentMatches(pattern, value) {
-    let expression = "^";
-    for (let index = 0; index < pattern.length; index += 1) {
-        const character = pattern[index];
-        if (character === "\\") {
-            index += 1;
-            expression += escapeRegex(pattern[index] ?? "\\");
-        }
-        else if (character === "*") {
-            if (pattern[index + 1] === "*") {
-                expression += ".*";
-                index += 1;
-            }
-            else
-                expression += "[^/]*";
-        }
-        else if (character === "?")
-            expression += "[^/]";
-        else if (character === "[") {
-            const close = pattern.indexOf("]", index + 1);
-            if (close === -1)
-                expression += "\\[";
-            else {
-                const rawClass = pattern.slice(index + 1, close);
-                const classBody = rawClass.startsWith("!") ? `^${rawClass.slice(1)}` : rawClass;
-                expression += `[${classBody.replace(/\\/g, "\\\\")}]`;
-                index = close;
-            }
-        }
-        else
-            expression += escapeRegex(character);
-    }
-    return new RegExp(`${expression}$`).test(value);
-}
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function patternMatchesPath(parsed, filePath) {
-    if (parsed.comment)
-        return false;
-    const pathSegments = filePath.split("/");
-    if (parsed.componentOnly) {
-        const lastMatchIndex = parsed.directory ? pathSegments.length - 1 : pathSegments.length;
-        return pathSegments.slice(0, lastMatchIndex).some((segment) => componentMatches(parsed.segments[0], segment));
-    }
-    const memo = new Map();
-    const matchesFrom = (patternIndex, pathIndex) => {
-        const key = `${patternIndex}:${pathIndex}`;
-        const cached = memo.get(key);
-        if (cached !== undefined)
-            return cached;
-        let matched;
-        if (patternIndex === parsed.segments.length) {
-            matched = parsed.directory ? pathIndex < pathSegments.length : pathIndex === pathSegments.length;
-            memo.set(key, matched);
-            return matched;
-        }
-        const segment = parsed.segments[patternIndex];
-        if (segment === "**") {
-            matched = false;
-            for (let nextPathIndex = pathIndex; nextPathIndex <= pathSegments.length; nextPathIndex += 1) {
-                if (matchesFrom(patternIndex + 1, nextPathIndex)) {
-                    matched = true;
-                    break;
-                }
-            }
-        }
-        else {
-            matched = pathIndex < pathSegments.length
-                && componentMatches(segment, pathSegments[pathIndex])
-                && matchesFrom(patternIndex + 1, pathIndex + 1);
-        }
-        memo.set(key, matched);
-        return matched;
-    };
-    return matchesFrom(0, 0);
-}
-/**
- * Evaluate the settled ordered Gitignore-like scope subset without invoking Git.
- */
-export async function scopePathEvidence(_cwd, patterns, filePaths) {
-    const normalizedPatterns = patterns.map(normalizeScopePattern);
-    const normalizedPaths = filePaths.map(normalizeScopePath);
-    const parsedPatterns = normalizedPatterns.map(parseScopePattern);
-    return normalizedPaths.map((normalizedPath) => {
-        const pathDecisions = parsedPatterns.flatMap((parsed, index) => {
-            if (!patternMatchesPath(parsed, normalizedPath))
-                return [];
-            const effect = parsed.negative ? "exclude" : "include";
-            return [{ index, pattern: normalizedPatterns[index], effect, matchedAfter: effect === "include" }];
-        });
-        const decisivePattern = pathDecisions.at(-1);
-        const hasPositiveMatch = pathDecisions.some((decision) => decision.effect === "include");
-        const matched = decisivePattern?.matchedAfter ?? false;
-        return {
-            path: normalizedPath,
-            patterns: pathDecisions,
-            matched,
-            outcome: matched ? "matched" : hasPositiveMatch ? "excluded" : "no-positive-match",
-            ...(decisivePattern ? { decisivePattern } : {}),
-        };
-    });
-}
-export async function pathsMatchingScope(cwd, patterns, filePaths) {
-    const evidence = await scopePathEvidence(cwd, patterns, filePaths);
-    return new Set(evidence.filter((item) => item.matched).map((item) => item.path));
-}
-export function isNegativeScopePattern(pattern) {
-    return normalizeScopePattern(pattern).startsWith("!");
-}
-/**
- * Parse only the positive subset whose path language can be proved statically:
- * literal segments, `*` segments, and `**` segments.
- */
-function staticScopeSegments(pattern) {
-    const positive = normalizeScopePattern(pattern);
-    if (positive.startsWith("!") || positive.startsWith("#"))
-        return null;
-    const body = positive.startsWith("/") ? positive.slice(1) : positive;
-    if (!body || body.endsWith("/"))
-        return null;
-    const parsed = [];
-    for (const segment of body.split("/")) {
-        if (!segment || segment === "." || segment === "..")
-            return null;
-        if (segment === "*")
-            parsed.push({ kind: "one" });
-        else if (segment === "**")
-            parsed.push({ kind: "many" });
-        else if (/[*?\[\]\\]/.test(segment))
-            return null;
-        else
-            parsed.push({ kind: "literal", value: segment });
-    }
-    return parsed;
-}
-function ordinarySegmentsIntersect(a, b) {
-    if (a.kind === "many" || b.kind === "many")
-        return true;
-    if (a.kind === "one" || b.kind === "one")
-        return true;
-    return a.value === b.value;
-}
-/** Exact non-empty intersection for the finite segment-language subset above. */
-function staticSegmentLanguagesOverlap(a, b) {
-    const pending = [[0, 0]];
-    const seen = new Set();
-    while (pending.length > 0) {
-        const [aIndex, bIndex] = pending.pop();
-        const key = `${aIndex}:${bIndex}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        if (aIndex === a.length && bIndex === b.length)
-            return true;
-        const aSegment = a[aIndex];
-        const bSegment = b[bIndex];
-        if (aSegment?.kind === "many")
-            pending.push([aIndex + 1, bIndex]);
-        if (bSegment?.kind === "many")
-            pending.push([aIndex, bIndex + 1]);
-        if (!aSegment || !bSegment || !ordinarySegmentsIntersect(aSegment, bSegment))
-            continue;
-        pending.push([
-            aSegment.kind === "many" ? aIndex : aIndex + 1,
-            bSegment.kind === "many" ? bIndex : bIndex + 1,
-        ]);
-    }
-    return false;
-}
-/** Advisory only: negative patterns are exclusions, and are intentionally ignored here. */
-export function patternsOverlap(a, b) {
-    const aSegments = staticScopeSegments(a);
-    const bSegments = staticScopeSegments(b);
-    return aSegments !== null && bSegments !== null && staticSegmentLanguagesOverlap(aSegments, bSegments);
-}