@claudiu.ceia/astkit 0.1.0

package/dist/src/sgrep/isomorphisms/template-ast.js

@@ -0,0 +1,59 @@
+import ts from "typescript";
+import { tokenizeTemplate } from "../../pattern/index.js";
+export function parseTemplateIsomorphismContext(source) {
+    let tokens;
+    try {
+        tokens = tokenizeTemplate(source);
+    }
+    catch {
+        return null;
+    }
+    if (tokens.some((token) => token.kind === "ellipsis")) {
+        // The template ellipsis token ("...") is a matcher wildcard, not JS spread syntax.
+        // Skip AST-based isomorphisms for now to avoid ambiguous rewrites.
+        return null;
+    }
+    const canonicalSource = tokens.map(renderTemplateToken).join("");
+    if (canonicalSource !== source) {
+        return null;
+    }
+    const sanitizedSource = tokens
+        .map((token, index) => {
+        if (token.kind === "text") {
+            return token.value;
+        }
+        const rawToken = renderTemplateToken(token);
+        return buildIdentifierPlaceholder(rawToken.length, index);
+    })
+        .join("");
+    if (sanitizedSource.length !== source.length) {
+        return null;
+    }
+    const ast = ts.createSourceFile("sgrep-pattern.ts", sanitizedSource, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    return { source, ast };
+}
+function renderTemplateToken(token) {
+    if (token.kind === "text") {
+        return token.value;
+    }
+    if (token.kind === "ellipsis") {
+        return "...";
+    }
+    if (token.constraintSource === null) {
+        return `:[${token.name}]`;
+    }
+    return `:[${token.name}~${token.constraintSource}]`;
+}
+function buildIdentifierPlaceholder(length, index) {
+    if (length <= 0) {
+        return "";
+    }
+    if (length === 1) {
+        return "_";
+    }
+    const base = `_${index.toString(36)}_`;
+    if (base.length >= length) {
+        return `_`.repeat(length);
+    }
+    return `${base}${"_".repeat(length - base.length)}`;
+}

package/dist/src/sgrep/isomorphisms/types.d.ts

@@ -0,0 +1,15 @@
+import type ts from "typescript";
+export type IsomorphismContext = {
+    source: string;
+    ast: ts.SourceFile;
+};
+export type IsomorphismRule = {
+    id: string;
+    description: string;
+    apply: (context: IsomorphismContext) => string[];
+};
+export type ExpandIsomorphismsOptions = {
+    enabled?: boolean;
+    maxVariants?: number;
+    rules?: readonly IsomorphismRule[];
+};

package/dist/src/sgrep/phases/output.d.ts

@@ -0,0 +1,9 @@
+import type { SgrepResult } from "../types.ts";
+import type { ParsedSearchSpec } from "./parse.ts";
+import type { SearchPhaseResult } from "./search.ts";
+export type OutputPhaseInput = {
+    search: ParsedSearchSpec;
+    phase: SearchPhaseResult;
+    elapsedMs: number;
+};
+export declare function buildSgrepResult(input: OutputPhaseInput): SgrepResult;

package/dist/src/sgrep/phases/output.js

@@ -0,0 +1,11 @@
+export function buildSgrepResult(input) {
+    return {
+        scope: input.phase.scope,
+        pattern: input.search.pattern,
+        filesScanned: input.phase.filesScanned,
+        filesMatched: input.phase.filesMatched,
+        totalMatches: input.phase.totalMatches,
+        elapsedMs: input.elapsedMs,
+        files: input.phase.files,
+    };
+}

package/dist/src/sgrep/phases/parse.d.ts

@@ -0,0 +1,10 @@
+import type { SgrepOptions } from "../types.ts";
+export type ParsedSearchSpec = {
+    pattern: string;
+};
+export type ParsedSearchInvocation = {
+    search: ParsedSearchSpec;
+    options: SgrepOptions;
+};
+export declare function parseSearchSpec(pattern: string): ParsedSearchSpec;
+export declare function parseSearchInvocation(patternInput: string, options?: SgrepOptions): Promise<ParsedSearchInvocation>;

package/dist/src/sgrep/phases/parse.js

@@ -0,0 +1,11 @@
+import { resolveTextInput } from "../../common/input.js";
+export function parseSearchSpec(pattern) {
+    return { pattern };
+}
+export async function parseSearchInvocation(patternInput, options = {}) {
+    const pattern = await resolveTextInput(patternInput, options);
+    return {
+        search: parseSearchSpec(pattern),
+        options,
+    };
+}

package/dist/src/sgrep/phases/search.d.ts

@@ -0,0 +1,11 @@
+import type { SgrepFileResult, SgrepOptions } from "../types.ts";
+import type { ParsedSearchSpec } from "./parse.ts";
+export type SearchPhaseResult = {
+    cwd: string;
+    scope: string;
+    filesScanned: number;
+    filesMatched: number;
+    totalMatches: number;
+    files: SgrepFileResult[];
+};
+export declare function searchProjectFiles(search: ParsedSearchSpec, options: SgrepOptions): Promise<SearchPhaseResult>;

package/dist/src/sgrep/phases/search.js

@@ -0,0 +1,111 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { compileTemplate, ELLIPSIS_CAPTURE_PREFIX, findTemplateMatches, } from "../../pattern/index.js";
+import { collectPatchableFiles } from "../../spatch/files.js";
+import { createLineStarts, toLineCharacter } from "../../spatch/text.js";
+import { expandPatternIsomorphisms } from "../isomorphisms/index.js";
+export async function searchProjectFiles(search, options) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const scope = options.scope ?? ".";
+    const encoding = options.encoding ?? "utf8";
+    const resolvedScope = path.resolve(cwd, scope);
+    const compiledPatterns = compileSearchPatterns(search.pattern, options.isomorphisms ?? true);
+    const files = await collectPatchableFiles({
+        cwd,
+        scope,
+        extensions: options.extensions,
+        excludedDirectories: options.excludedDirectories,
+    });
+    let filesMatched = 0;
+    let totalMatches = 0;
+    const fileResults = [];
+    for (const filePath of files) {
+        const fileResult = await searchFile({
+            cwd,
+            filePath,
+            compiledPatterns,
+            encoding,
+        });
+        if (!fileResult) {
+            continue;
+        }
+        filesMatched += 1;
+        totalMatches += fileResult.matchCount;
+        fileResults.push(fileResult);
+    }
+    return {
+        cwd,
+        scope: resolvedScope,
+        filesScanned: files.length,
+        filesMatched,
+        totalMatches,
+        files: fileResults,
+    };
+}
+async function searchFile(input) {
+    const sourceText = await readFile(input.filePath, input.encoding);
+    const matches = findFileMatches(sourceText, input.compiledPatterns);
+    if (matches.length === 0) {
+        return null;
+    }
+    const lineStarts = createLineStarts(sourceText);
+    const searchMatches = matches.map((match) => {
+        const { line, character } = toLineCharacter(lineStarts, match.start);
+        return {
+            start: match.start,
+            end: match.end,
+            line,
+            character,
+            matched: match.text,
+            captures: filterPublicCaptures(match.captures),
+        };
+    });
+    return {
+        file: path.relative(input.cwd, input.filePath) || path.basename(input.filePath),
+        matchCount: matches.length,
+        matches: searchMatches,
+    };
+}
+function filterPublicCaptures(captures) {
+    const entries = Object.entries(captures).filter(([name]) => !name.startsWith(ELLIPSIS_CAPTURE_PREFIX));
+    return Object.fromEntries(entries);
+}
+function compileSearchPatterns(pattern, withIsomorphisms) {
+    const variants = expandPatternIsomorphisms(pattern, {
+        enabled: withIsomorphisms,
+    });
+    const compiledPatterns = [];
+    const seen = new Set();
+    for (let index = 0; index < variants.length; index += 1) {
+        const variant = variants[index];
+        if (!variant || seen.has(variant)) {
+            continue;
+        }
+        seen.add(variant);
+        try {
+            compiledPatterns.push(compileTemplate(variant));
+        }
+        catch (error) {
+            if (variant === pattern || index === 0) {
+                throw error;
+            }
+        }
+    }
+    if (compiledPatterns.length === 0) {
+        throw new Error("Unable to compile search pattern.");
+    }
+    return compiledPatterns;
+}
+function findFileMatches(sourceText, compiledPatterns) {
+    const uniqueBySpan = new Map();
+    for (const compiledPattern of compiledPatterns) {
+        const matches = findTemplateMatches(sourceText, compiledPattern);
+        for (const match of matches) {
+            const key = `${match.start}:${match.end}`;
+            if (!uniqueBySpan.has(key)) {
+                uniqueBySpan.set(key, match);
+            }
+        }
+    }
+    return [...uniqueBySpan.values()].sort((left, right) => left.start - right.start || left.end - right.end);
+}

package/dist/src/sgrep/sgrep.d.ts

@@ -0,0 +1,3 @@
+import type { SgrepOptions, SgrepResult } from "./types.ts";
+export declare function searchProject(patternInput: string, options?: SgrepOptions): Promise<SgrepResult>;
+export declare const sgrep: typeof searchProject;

package/dist/src/sgrep/sgrep.js

@@ -0,0 +1,17 @@
+import { buildSgrepResult } from "./phases/output.js";
+import { parseSearchInvocation, } from "./phases/parse.js";
+import { searchProjectFiles } from "./phases/search.js";
+export async function searchProject(patternInput, options = {}) {
+    const invocation = await parseSearchInvocation(patternInput, options);
+    return runSearchPhases(invocation.search, invocation.options);
+}
+export const sgrep = searchProject;
+async function runSearchPhases(search, options) {
+    const startedAt = Date.now();
+    const phase = await searchProjectFiles(search, options);
+    return buildSgrepResult({
+        search,
+        phase,
+        elapsedMs: Date.now() - startedAt,
+    });
+}

package/dist/src/sgrep/types.d.ts

@@ -0,0 +1,32 @@
+export declare const DEFAULT_SEARCHABLE_EXTENSIONS: readonly [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+export declare const DEFAULT_SEARCH_EXCLUDED_DIRECTORIES: readonly [".git", "node_modules", ".next", ".turbo", "dist", "build", "coverage", "out"];
+export type SgrepOptions = {
+    scope?: string;
+    cwd?: string;
+    extensions?: readonly string[];
+    excludedDirectories?: readonly string[];
+    encoding?: BufferEncoding;
+    isomorphisms?: boolean;
+};
+export type SgrepMatch = {
+    start: number;
+    end: number;
+    line: number;
+    character: number;
+    matched: string;
+    captures: Record<string, string>;
+};
+export type SgrepFileResult = {
+    file: string;
+    matchCount: number;
+    matches: SgrepMatch[];
+};
+export type SgrepResult = {
+    scope: string;
+    pattern: string;
+    filesScanned: number;
+    filesMatched: number;
+    totalMatches: number;
+    elapsedMs: number;
+    files: SgrepFileResult[];
+};

package/dist/src/sgrep/types.js

@@ -0,0 +1,3 @@
+import { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS, } from "../spatch/types.js";
+export const DEFAULT_SEARCHABLE_EXTENSIONS = DEFAULT_PATCHABLE_EXTENSIONS;
+export const DEFAULT_SEARCH_EXCLUDED_DIRECTORIES = DEFAULT_EXCLUDED_DIRECTORIES;

package/dist/src/spatch/files.d.ts

@@ -0,0 +1,7 @@
+export type CollectPatchableFilesOptions = {
+    cwd: string;
+    scope: string;
+    extensions?: readonly string[];
+    excludedDirectories?: readonly string[];
+};
+export declare function collectPatchableFiles(options: CollectPatchableFilesOptions): Promise<string[]>;

package/dist/src/spatch/files.js

@@ -0,0 +1,51 @@
+import { opendir, stat } from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS, } from "./types.js";
+export async function collectPatchableFiles(options) {
+    const scopePath = path.resolve(options.cwd, options.scope);
+    const scopeStats = await stat(scopePath);
+    const extensionSet = new Set((options.extensions ?? DEFAULT_PATCHABLE_EXTENSIONS).map(normalizeExtension));
+    const excludedDirectorySet = new Set(options.excludedDirectories ?? DEFAULT_EXCLUDED_DIRECTORIES);
+    if (scopeStats.isFile()) {
+        return extensionSet.has(path.extname(scopePath).toLowerCase())
+            ? [scopePath]
+            : [];
+    }
+    if (!scopeStats.isDirectory()) {
+        return [];
+    }
+    const files = [];
+    await walkDirectory(scopePath, extensionSet, excludedDirectorySet, files);
+    return files;
+}
+async function walkDirectory(directory, extensions, excludedDirectories, files) {
+    const directoryHandle = await opendir(directory);
+    const entries = [];
+    for await (const entry of directoryHandle) {
+        entries.push(entry);
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        const absolute = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (excludedDirectories.has(entry.name)) {
+                continue;
+            }
+            await walkDirectory(absolute, extensions, excludedDirectories, files);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        if (extensions.has(path.extname(entry.name).toLowerCase())) {
+            files.push(absolute);
+        }
+    }
+}
+function normalizeExtension(extension) {
+    const normalized = extension.trim().toLowerCase();
+    if (normalized.startsWith(".")) {
+        return normalized;
+    }
+    return `.${normalized}`;
+}

package/dist/src/spatch/index.d.ts

@@ -0,0 +1,3 @@
+export { patchProject, spatch, } from "./spatch.ts";
+export type { SpatchFileResult, SpatchOccurrence, SpatchOptions, SpatchResult, } from "./types.ts";
+export { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS, } from "./types.ts";

package/dist/src/spatch/index.js

@@ -0,0 +1,2 @@
+export { patchProject, spatch, } from "./spatch.js";
+export { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS, } from "./types.js";

package/dist/src/spatch/patch-document.d.ts

@@ -0,0 +1,9 @@
+export type ParsedPatchDocument = {
+    pattern: string;
+    replacement: string;
+    additions: number;
+    deletions: number;
+    contextLines: number;
+    trailingNewline: boolean;
+};
+export declare function parsePatchDocument(source: string): ParsedPatchDocument;

package/dist/src/spatch/patch-document.js

@@ -0,0 +1,64 @@
+import { any, eof, formatErrorCompact, many, map, optional, regex as parseRegex, seq, str, } from "@claudiu-ceia/combine";
+const lineContentParser = parseRegex(/[^\n]*/, "line content");
+const escapedMarkerLineParser = map(seq(str("\\"), any(str("+"), str("-")), lineContentParser), ([, marker, content]) => ({
+    kind: "context",
+    value: `${marker}${content}`,
+}));
+const additionLineParser = map(seq(str("+"), lineContentParser), ([, content]) => ({ kind: "addition", value: content }));
+const deletionLineParser = map(seq(str("-"), lineContentParser), ([, content]) => ({ kind: "deletion", value: content }));
+const contextLineParser = map(lineContentParser, (content) => ({ kind: "context", value: content }));
+const patchLineParser = any(escapedMarkerLineParser, additionLineParser, deletionLineParser, contextLineParser);
+const patchDocumentParser = map(seq(patchLineParser, many(map(seq(str("\n"), patchLineParser), ([, line]) => line)), optional(str("\n")), eof()), ([firstLine, remainingLines, trailingNewline]) => ({
+    lines: [firstLine, ...remainingLines],
+    trailingNewline: trailingNewline !== null,
+}));
+export function parsePatchDocument(source) {
+    if (source.length === 0) {
+        throw new Error("Patch document cannot be empty.");
+    }
+    const normalized = source.replaceAll("\r\n", "\n");
+    const trailingNewline = normalized.endsWith("\n");
+    const parsed = patchDocumentParser({ text: normalized, index: 0 });
+    if (!parsed.success) {
+        throw new Error(`Invalid patch document: ${formatErrorCompact(parsed)}`);
+    }
+    const lines = trailingNewline &&
+        parsed.value.lines.length > 0 &&
+        parsed.value.lines[parsed.value.lines.length - 1]?.kind === "context" &&
+        parsed.value.lines[parsed.value.lines.length - 1]?.value === ""
+        ? parsed.value.lines.slice(0, -1)
+        : parsed.value.lines;
+    const patternLines = [];
+    const replacementLines = [];
+    let additions = 0;
+    let deletions = 0;
+    let contextLines = 0;
+    for (const line of lines) {
+        if (line.kind === "context") {
+            patternLines.push(line.value);
+            replacementLines.push(line.value);
+            contextLines += 1;
+            continue;
+        }
+        if (line.kind === "addition") {
+            replacementLines.push(line.value);
+            additions += 1;
+            continue;
+        }
+        patternLines.push(line.value);
+        deletions += 1;
+    }
+    if (additions === 0 && deletions === 0) {
+        throw new Error("Patch document must contain at least one '+' or '-' line.");
+    }
+    const pattern = patternLines.join("\n");
+    const replacement = replacementLines.join("\n");
+    return {
+        pattern: trailingNewline ? `${pattern}\n` : pattern,
+        replacement: trailingNewline ? `${replacement}\n` : replacement,
+        additions,
+        deletions,
+        contextLines,
+        trailingNewline,
+    };
+}

package/dist/src/spatch/phases/output.d.ts

@@ -0,0 +1,9 @@
+import type { SpatchResult } from "../types.ts";
+import type { ParsedPatchSpec } from "./parse.ts";
+import type { RewritePhaseResult } from "./rewrite.ts";
+export type OutputPhaseInput = {
+    patch: ParsedPatchSpec;
+    rewrite: RewritePhaseResult;
+    elapsedMs: number;
+};
+export declare function buildSpatchResult(input: OutputPhaseInput): SpatchResult;

package/dist/src/spatch/phases/output.js

@@ -0,0 +1,15 @@
+export function buildSpatchResult(input) {
+    return {
+        dryRun: input.rewrite.dryRun,
+        scope: input.rewrite.scope,
+        pattern: input.patch.pattern,
+        replacement: input.patch.replacement,
+        filesScanned: input.rewrite.filesScanned,
+        filesMatched: input.rewrite.filesMatched,
+        filesChanged: input.rewrite.filesChanged,
+        totalMatches: input.rewrite.totalMatches,
+        totalReplacements: input.rewrite.totalReplacements,
+        elapsedMs: input.elapsedMs,
+        files: input.rewrite.files,
+    };
+}

package/dist/src/spatch/phases/parse.d.ts

@@ -0,0 +1,11 @@
+import type { SpatchOptions } from "../types.ts";
+export type ParsedPatchSpec = {
+    pattern: string;
+    replacement: string;
+};
+export type ParsedPatchInvocation = {
+    patch: ParsedPatchSpec;
+    options: SpatchOptions;
+};
+export declare function parsePatchSpec(patchDocument: string): ParsedPatchSpec;
+export declare function parsePatchInvocation(patchInput: string, options?: SpatchOptions): Promise<ParsedPatchInvocation>;

package/dist/src/spatch/phases/parse.js

@@ -0,0 +1,16 @@
+import { resolveTextInput } from "../../common/input.js";
+import { parsePatchDocument } from "../patch-document.js";
+export function parsePatchSpec(patchDocument) {
+    const parsed = parsePatchDocument(patchDocument);
+    return {
+        pattern: parsed.pattern,
+        replacement: parsed.replacement,
+    };
+}
+export async function parsePatchInvocation(patchInput, options = {}) {
+    const patchDocument = await resolveTextInput(patchInput, options);
+    return {
+        patch: parsePatchSpec(patchDocument),
+        options,
+    };
+}

package/dist/src/spatch/phases/rewrite.d.ts

@@ -0,0 +1,14 @@
+import type { SpatchFileResult, SpatchOptions } from "../types.ts";
+import type { ParsedPatchSpec } from "./parse.ts";
+export type RewritePhaseResult = {
+    cwd: string;
+    scope: string;
+    dryRun: boolean;
+    filesScanned: number;
+    filesMatched: number;
+    filesChanged: number;
+    totalMatches: number;
+    totalReplacements: number;
+    files: SpatchFileResult[];
+};
+export declare function rewriteProject(patch: ParsedPatchSpec, options: SpatchOptions): Promise<RewritePhaseResult>;

package/dist/src/spatch/phases/rewrite.js

@@ -0,0 +1,111 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { collectPatchableFiles } from "../files.js";
+import { compileTemplate, ELLIPSIS_CAPTURE_PREFIX, findTemplateMatches, renderTemplate, } from "../../pattern/index.js";
+import { createLineStarts, toLineCharacter } from "../text.js";
+export async function rewriteProject(patch, options) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const scope = options.scope ?? ".";
+    const dryRun = options.dryRun ?? false;
+    const encoding = options.encoding ?? "utf8";
+    const resolvedScope = path.resolve(cwd, scope);
+    const compiledPattern = compileTemplate(patch.pattern);
+    const files = await collectPatchableFiles({
+        cwd,
+        scope,
+        extensions: options.extensions,
+        excludedDirectories: options.excludedDirectories,
+    });
+    let filesMatched = 0;
+    let filesChanged = 0;
+    let totalMatches = 0;
+    let totalReplacements = 0;
+    const fileResults = [];
+    for (const filePath of files) {
+        const fileResult = await rewriteFile({
+            cwd,
+            filePath,
+            replacementTemplate: patch.replacement,
+            compiledPattern,
+            encoding,
+            dryRun,
+        });
+        if (!fileResult) {
+            continue;
+        }
+        filesMatched += 1;
+        totalMatches += fileResult.matchCount;
+        totalReplacements += fileResult.replacementCount;
+        if (fileResult.changed) {
+            filesChanged += 1;
+        }
+        fileResults.push(fileResult);
+    }
+    return {
+        cwd,
+        scope: resolvedScope,
+        dryRun,
+        filesScanned: files.length,
+        filesMatched,
+        filesChanged,
+        totalMatches,
+        totalReplacements,
+        files: fileResults,
+    };
+}
+async function rewriteFile(input) {
+    const originalText = await readFile(input.filePath, input.encoding);
+    const matches = findTemplateMatches(originalText, input.compiledPattern);
+    if (matches.length === 0) {
+        return null;
+    }
+    const lineStarts = createLineStarts(originalText);
+    const occurrences = matches.map((match) => {
+        const rendered = renderTemplate(input.replacementTemplate, match.captures);
+        const { line, character } = toLineCharacter(lineStarts, match.start);
+        return {
+            start: match.start,
+            end: match.end,
+            line,
+            character,
+            matched: match.text,
+            replacement: rendered,
+            captures: filterPublicCaptures(match.captures),
+        };
+    });
+    const replacementCount = occurrences.reduce((count, occurrence) => count + (occurrence.matched === occurrence.replacement ? 0 : 1), 0);
+    const rewrittenText = applyOccurrences(originalText, occurrences);
+    const changed = rewrittenText !== originalText;
+    if (changed && !input.dryRun) {
+        await writeFile(input.filePath, rewrittenText, input.encoding);
+    }
+    return {
+        file: path.relative(input.cwd, input.filePath) || path.basename(input.filePath),
+        matchCount: matches.length,
+        replacementCount,
+        changed,
+        byteDelta: changed
+            ? Buffer.byteLength(rewrittenText, input.encoding) -
+                Buffer.byteLength(originalText, input.encoding)
+            : 0,
+        occurrences,
+    };
+}
+function filterPublicCaptures(captures) {
+    const entries = Object.entries(captures).filter(([name]) => !name.startsWith(ELLIPSIS_CAPTURE_PREFIX));
+    return Object.fromEntries(entries);
+}
+function applyOccurrences(source, occurrences) {
+    if (occurrences.length === 0) {
+        return source;
+    }
+    const parts = [];
+    let cursor = 0;
+    for (const occurrence of occurrences) {
+        parts.push(source.slice(cursor, occurrence.start));
+        parts.push(occurrence.replacement);
+        cursor = occurrence.end;
+    }
+    parts.push(source.slice(cursor));
+    return parts.join("");
+}

package/dist/src/spatch/spatch.d.ts

@@ -0,0 +1,3 @@
+import type { SpatchOptions, SpatchResult } from "./types.ts";
+export declare function patchProject(patchInput: string, options?: SpatchOptions): Promise<SpatchResult>;
+export declare const spatch: typeof patchProject;

package/dist/src/spatch/spatch.js

@@ -0,0 +1,17 @@
+import { buildSpatchResult } from "./phases/output.js";
+import { parsePatchInvocation, } from "./phases/parse.js";
+import { rewriteProject } from "./phases/rewrite.js";
+export async function patchProject(patchInput, options = {}) {
+    const invocation = await parsePatchInvocation(patchInput, options);
+    return runPatchPhases(invocation.patch, invocation.options);
+}
+export const spatch = patchProject;
+async function runPatchPhases(patch, options) {
+    const startedAt = Date.now();
+    const rewrite = await rewriteProject(patch, options);
+    return buildSpatchResult({
+        patch,
+        rewrite,
+        elapsedMs: Date.now() - startedAt,
+    });
+}

package/dist/src/spatch/template.d.ts

@@ -0,0 +1,2 @@
+export { compileTemplate, findTemplateMatches, renderTemplate } from "../pattern/index.ts";
+export type { CompiledTemplate, TemplateMatch } from "../pattern/index.ts";