@oscharko-dev/keiko 0.1.6 → 0.1.7

package/dist/tools/patch-parse.js

@@ -1,201 +1,4 @@
-// PURE, ReDoS-free unified-diff parser. Supported subset (documented in ADR-0006):
-//   - file headers `--- a/<path>` / `+++ b/<path>`, with `/dev/null` for create/delete;
-//   - hunk headers `@@ -l,s +l,s @@` (the count `,s` defaults to 1 when omitted);
-//   - body lines beginning with " " (context), "+" (add), "-" (remove), and "\" (no-newline).
-// This is NOT git-apply: no rename detection, no binary patches, no fuzzy matching. The parser
-// is linear (a single pass with bounded per-line regexes) so it cannot backtrack catastrophically.
-// Bounded, anchored hunk-header regex. Each numeric group is `\d+` (linear, no nesting).
-const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
-export class PatchParseError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "PatchParseError";
-    }
-}
-function stripPrefix(raw) {
-    if (raw === "/dev/null") {
-        return raw;
-    }
-    // Drop a leading `a/` or `b/` git prefix; otherwise keep the path verbatim.
-    if (raw.startsWith("a/") || raw.startsWith("b/")) {
-        return raw.slice(2);
-    }
-    return raw;
-}
-// The header path may carry a trailing tab + timestamp (`path\t2024-…`); keep only the path.
-function headerPath(line, marker) {
-    const rest = line.slice(marker.length);
-    const tab = rest.indexOf("\t");
-    const raw = tab === -1 ? rest : rest.slice(0, tab);
-    return stripPrefix(raw.trim());
-}
-function classify(oldPath, newPath) {
-    if (oldPath === "/dev/null") {
-        return { kind: "create", path: newPath };
-    }
-    if (newPath === "/dev/null") {
-        return { kind: "delete", path: oldPath };
-    }
-    return { kind: "modify", path: newPath };
-}
-function toHunk(acc) {
-    return {
-        oldStart: acc.oldStart,
-        oldLines: acc.oldLines,
-        newStart: acc.newStart,
-        newLines: acc.newLines,
-        lines: acc.lines,
-    };
-}
-function parseHunkHeader(line) {
-    const match = HUNK_HEADER.exec(line);
-    if (match === null) {
-        throw new PatchParseError("malformed hunk header");
-    }
-    const oldLines = match[2] === undefined ? 1 : Number(match[2]);
-    const newLines = match[4] === undefined ? 1 : Number(match[4]);
-    return {
-        oldStart: Number(match[1]),
-        oldLines,
-        newStart: Number(match[3]),
-        newLines,
-        lines: [],
-        oldRemaining: oldLines,
-        newRemaining: newLines,
-    };
-}
-function newFileAccumulator() {
-    return {
-        oldPath: undefined,
-        newPath: undefined,
-        hunks: [],
-        current: undefined,
-        added: 0,
-        removed: 0,
-    };
-}
-function finishHunk(file) {
-    if (file.current !== undefined) {
-        if (file.current.oldRemaining !== 0 || file.current.newRemaining !== 0) {
-            throw new PatchParseError("hunk body has fewer lines than declared");
-        }
-        file.hunks.push(toHunk(file.current));
-        file.current = undefined;
-    }
-}
-function finishFile(files, file) {
-    finishHunk(file);
-    if (file.oldPath === undefined || file.newPath === undefined) {
-        return;
-    }
-    const { kind, path } = classify(file.oldPath, file.newPath);
-    files.push({
-        path,
-        kind,
-        hunks: file.hunks,
-        addedLines: file.added,
-        removedLines: file.removed,
-    });
-}
-function countBody(file, line) {
-    if (line.startsWith("+")) {
-        file.added += 1;
-    }
-    else if (line.startsWith("-")) {
-        file.removed += 1;
-    }
-}
-function startNewFile(state, oldPath) {
-    if (state.current !== undefined) {
-        finishFile(state.files, state.current);
-    }
-    const file = newFileAccumulator();
-    file.oldPath = oldPath;
-    state.current = file;
-    return file;
-}
-function isHunkBodyLine(line) {
-    const marker = line.charAt(0);
-    return marker === " " || marker === "+" || marker === "-";
-}
-// A hunk is still consuming body lines while either the old or the new line budget is positive.
-function hunkActive(file) {
-    const hunk = file.current;
-    return hunk !== undefined && (hunk.oldRemaining > 0 || hunk.newRemaining > 0);
-}
-// Draws down the hunk's old/new line budget for a body line (context draws both, `-` old, `+` new).
-function assertBudgetAvailable(hunk, line) {
-    const marker = line.charAt(0);
-    const oldNeeded = marker === " " || marker === "-" ? 1 : 0;
-    const newNeeded = marker === " " || marker === "+" ? 1 : 0;
-    if (hunk.oldRemaining < oldNeeded || hunk.newRemaining < newNeeded) {
-        throw new PatchParseError("hunk body has more lines than declared");
-    }
-}
-function consumeBudget(hunk, line) {
-    const marker = line.charAt(0);
-    if (marker === " ") {
-        hunk.oldRemaining -= 1;
-        hunk.newRemaining -= 1;
-    }
-    else if (marker === "-") {
-        hunk.oldRemaining -= 1;
-    }
-    else if (marker === "+") {
-        hunk.newRemaining -= 1;
-    }
-}
-function handleBodyLine(file, line) {
-    if (file.current === undefined) {
-        return; // lines outside a hunk (e.g. `diff --git`, `index …`) are ignored
-    }
-    if (line.startsWith("\\")) {
-        return; // "" marker
-    }
-    // Only genuine body lines (context/add/remove) belong to the hunk. An empty trailing line
-    // (the split artifact of a final newline) or any other token ends the hunk so it is not
-    // mistaken for a zero-length context line that would never match the file content.
-    if (!isHunkBodyLine(line)) {
-        finishHunk(file);
-        return;
-    }
-    assertBudgetAvailable(file.current, line);
-    file.current.lines.push(line);
-    countBody(file, line);
-    consumeBudget(file.current, line);
-}
-function handleLine(state, line) {
-    // While a hunk still has budget, ` `/`+`/`-` lines are BODY even if they render as `--- `/`+++ `
-    // (C6). Only once the hunk is consumed (or absent) can a `--- ` line open a new file.
-    if (state.current !== undefined && hunkActive(state.current) && isHunkBodyLine(line)) {
-        handleBodyLine(state.current, line);
-        return;
-    }
-    if (line.startsWith("--- ")) {
-        startNewFile(state, headerPath(line, "--- "));
-        return;
-    }
-    if (state.current === undefined) {
-        return; // skip preamble before the first file header
-    }
-    if (line.startsWith("+++ ")) {
-        state.current.newPath = headerPath(line, "+++ ");
-        return;
-    }
-    if (line.startsWith("@@")) {
-        finishHunk(state.current);
-        state.current.current = parseHunkHeader(line);
-        return;
-    }
-    handleBodyLine(state.current, line);
-}
-export function parseUnifiedDiff(diff) {
-    const state = { files: [], current: undefined };
-    for (const line of diff.split("\n")) {
-        handleLine(state, line);
-    }
-    if (state.current !== undefined) {
-        finishFile(state.files, state.current);
-    }
-    return { files: state.files };
-}
+// Re-export shim: the unified-diff parser lives in @oscharko-dev/keiko-tools (issue #162,
+// ADR-0019). All existing import sites (`from "../tools/patch-parse.js"`) keep resolving
+// unchanged via this barrel.
+export { parseUnifiedDiff, PatchParseError } from "@oscharko-dev/keiko-tools";

package/dist/tools/patch.d.ts

@@ -1,18 +1 @@
-import { type WorkspaceFs } from "../workspace/fs.js";
-import type { WorkspaceInfo } from "../workspace/types.js";
-import { type WorkspaceWriter } from "./writer.js";
-import { type PatchApplyResult, type PatchLimits, type PatchValidation } from "./types.js";
-export interface ValidateDeps {
-    readonly fs?: WorkspaceFs | undefined;
-    readonly limits?: PatchLimits | undefined;
-}
-export declare function validatePatch(workspace: WorkspaceInfo, diff: string, deps?: ValidateDeps): PatchValidation;
-export declare function renderDryRun(validation: PatchValidation): string;
-export interface ApplyDeps {
-    readonly applyEnabled: boolean;
-    readonly signal: AbortSignal;
-    readonly fs?: WorkspaceFs | undefined;
-    readonly writer?: WorkspaceWriter | undefined;
-    readonly limits?: PatchLimits | undefined;
-}
-export declare function applyPatch(workspace: WorkspaceInfo, diff: string, deps: ApplyDeps): PatchApplyResult;
+export { applyPatch, renderDryRun, validatePatch, type ApplyDeps, type ValidateDeps, } from "@oscharko-dev/keiko-tools";

package/dist/tools/patch.js

@@ -1,403 +1,3 @@
-// Patch workflow: validate (all checks, structured report), renderDryRun (preview, never
-// writes), and applyPatch (fail-closed, atomic with multi-file rollback). Every target path is
-// validated via resolveWithinWorkspace + isDenied; the validated absolute path is the ONLY value
-// handed to the WorkspaceWriter, so a static analyser's path sanitizer sits on this boundary
-// (ADR-0006 D4). node:fs is never imported here — reads go through WorkspaceFs, writes through
-// WorkspaceWriter, both injected.
-import { isDenied } from "../workspace/ignore.js";
-import { resolveWithinWorkspace } from "../workspace/paths.js";
-import { containedRealPathInfo } from "../workspace/realpath.js";
-import { PathDeniedError, PathEscapeError } from "../workspace/errors.js";
-import { nodeWorkspaceFs } from "../workspace/fs.js";
-import { CommandCancelledError, PatchApplyDisabledError, PatchApplyError, PatchValidationError, } from "./errors.js";
-import { computeFileContent } from "./patch-content.js";
-import { normalizeUnifiedDiffHunks } from "./patch-normalize.js";
-import { parseUnifiedDiff, PatchParseError } from "./patch-parse.js";
-import { nodeWorkspaceWriter } from "./writer.js";
-import { DEFAULT_PATCH_LIMITS, } from "./types.js";
-function containsNul(value) {
-    return value.includes("\u0000");
-}
-function isBinaryDiff(diff) {
-    return (diff.includes("GIT binary patch") || /^Binary files .* differ$/m.test(diff) || containsNul(diff));
-}
-function hasEscapedDiffLineBreak(diff) {
-    return diff.includes("\\n+") || diff.includes("\\n-") || diff.includes("\\n ");
-}
-function enforcePath(workspace, fs, path) {
-    let resolved;
-    try {
-        resolved = resolveWithinWorkspace(workspace.root, path);
-    }
-    catch (error) {
-        if (error instanceof PathEscapeError) {
-            throw error;
-        }
-        throw error;
-    }
-    const rel = resolved.slice(workspace.root.length).replace(/^[/\\]/, "");
-    if (isDenied(rel === "" ? path : rel)) {
-        throw new PathDeniedError("path matches an always-on deny pattern", path);
-    }
-    const info = containedRealPathInfo(fs, workspace.root, resolved);
-    if (!realPathMatchesLexicalTarget(fs, resolved, rel, info.realRelative)) {
-        throw new PathDeniedError("path resolves through an in-workspace alias", path);
-    }
-    if (fs.exists(resolved) && (fs.stat(resolved).hardLinkCount ?? 1) > 1) {
-        throw new PathDeniedError("path resolves through a hard-linked alias", path);
-    }
-    if (isDenied(info.realRelative)) {
-        throw new PathDeniedError("path matches an always-on deny pattern", path);
-    }
-    return resolved;
-}
-function realPathMatchesLexicalTarget(fs, absolutePath, rel, realRelative) {
-    if (fs.exists(absolutePath)) {
-        return realRelative === rel;
-    }
-    return realRelative === "" || rel === realRelative || rel.startsWith(`${realRelative}/`);
-}
-function safePath(workspace, fs, path) {
-    try {
-        enforcePath(workspace, fs, path);
-        return undefined;
-    }
-    catch (error) {
-        if (error instanceof PathEscapeError) {
-            return { code: "path-unsafe", message: "path escapes the workspace", path };
-        }
-        if (error instanceof PathDeniedError) {
-            return { code: "path-denied", message: "path matches an always-on deny pattern", path };
-        }
-        throw error;
-    }
-}
-function collectPathReasons(workspace, fs, files) {
-    const reasons = [];
-    for (const file of files) {
-        const rejection = safePath(workspace, fs, file.path);
-        if (rejection !== undefined) {
-            reasons.push(rejection);
-        }
-    }
-    return reasons;
-}
-function readCurrent(workspace, fs, path) {
-    const absolute = resolveWithinWorkspace(workspace.root, path);
-    if (!fs.exists(absolute)) {
-        return undefined;
-    }
-    return fs.readFileUtf8(absolute);
-}
-function toLines(content) {
-    if (content.length === 0) {
-        return [];
-    }
-    const lines = content.split("\n");
-    if (lines.at(-1) === "") {
-        lines.pop();
-    }
-    return lines;
-}
-function hunkPreimageLines(file, hunkIndex) {
-    const hunk = file.hunks[hunkIndex];
-    if (hunk === undefined) {
-        return [];
-    }
-    return hunk.lines
-        .filter((line) => line.startsWith(" ") || line.startsWith("-"))
-        .map((line) => line.slice(1));
-}
-function startsWithSequence(lines, index, needle) {
-    return needle.every((line, offset) => lines[index + offset] === line);
-}
-function uniqueSequenceIndex(lines, needle) {
-    if (needle.length === 0 || needle.length > lines.length) {
-        return undefined;
-    }
-    let found;
-    for (let index = 0; index <= lines.length - needle.length; index += 1) {
-        if (!startsWithSequence(lines, index, needle)) {
-            continue;
-        }
-        if (found !== undefined) {
-            return undefined;
-        }
-        found = index;
-    }
-    return found;
-}
-function alignFileHunks(file, current) {
-    if (file.kind !== "modify") {
-        return file;
-    }
-    if (current === undefined) {
-        return isCreateOnlyModify(file) ? { ...file, kind: "create" } : file;
-    }
-    const currentLines = toLines(current);
-    const hunks = file.hunks.map((hunk, index) => {
-        const preimage = hunkPreimageLines(file, index);
-        if (hunk.oldStart > 0 && startsWithSequence(currentLines, hunk.oldStart - 1, preimage)) {
-            return hunk;
-        }
-        const anchor = uniqueSequenceIndex(currentLines, preimage);
-        if (anchor === undefined) {
-            return hunk;
-        }
-        const start = anchor + 1;
-        return { ...hunk, oldStart: start, newStart: start };
-    });
-    if (hunks.every((hunk, index) => hunk === file.hunks[index])) {
-        return file;
-    }
-    return { ...file, hunks };
-}
-function isCreateOnlyModify(file) {
-    return (file.hunks.length > 0 &&
-        file.hunks.every((hunk) => hunk.oldLines === 0 && hunk.lines.every((line) => line.startsWith("+"))));
-}
-function alignHunksToCurrentContent(workspace, fs, files) {
-    return files.map((file) => alignFileHunks(file, readCurrent(workspace, fs, file.path)));
-}
-function unanchoredModifyReasons(files) {
-    return files
-        .filter((file) => file.kind === "modify" && file.hunks.some((hunk) => hunk.oldStart <= 0))
-        .map((file) => ({
-        code: "malformed",
-        message: "modify hunk has no unique anchor",
-        path: file.path,
-    }));
-}
-function collectConflicts(workspace, fs, files) {
-    const conflicts = [];
-    for (const file of files) {
-        const current = readCurrent(workspace, fs, file.path);
-        const outcome = computeFileContent(file, current);
-        for (const conflict of outcome.conflicts) {
-            conflicts.push({ path: file.path, hunkIndex: conflict.hunkIndex, reason: conflict.reason });
-        }
-    }
-    return conflicts;
-}
-function sizeAndCountReasons(diff, files, totalChangedLines, limits, totalBytes) {
-    const reasons = [];
-    if (diff.trim().length > 0 && files.length === 0) {
-        reasons.push({ code: "malformed", message: "diff does not contain any file changes" });
-    }
-    if (totalBytes > limits.maxPatchBytes) {
-        reasons.push({
-            code: "size-limit",
-            message: `patch exceeds ${String(limits.maxPatchBytes)} bytes`,
-        });
-    }
-    if (isBinaryDiff(diff)) {
-        reasons.push({ code: "binary", message: "binary patches are not supported" });
-    }
-    if (hasEscapedDiffLineBreak(diff)) {
-        reasons.push({
-            code: "malformed",
-            message: "diff contains escaped newline markers; use real line breaks",
-        });
-    }
-    if (totalChangedLines > limits.maxChangedLines) {
-        reasons.push({
-            code: "line-limit",
-            message: `changed lines exceed ${String(limits.maxChangedLines)}`,
-        });
-    }
-    if (files.length > limits.maxFilesChanged) {
-        reasons.push({
-            code: "file-limit",
-            message: `files changed exceed ${String(limits.maxFilesChanged)}`,
-        });
-    }
-    return reasons;
-}
-function renderHeader(file) {
-    if (file.kind === "create") {
-        return ["--- /dev/null", `+++ b/${file.path}`];
-    }
-    if (file.kind === "delete") {
-        return [`--- a/${file.path}`, "+++ /dev/null"];
-    }
-    return [`--- a/${file.path}`, `+++ b/${file.path}`];
-}
-function renderParsedPatch(files) {
-    const lines = [];
-    for (const file of files) {
-        lines.push(...renderHeader(file));
-        for (const hunk of file.hunks) {
-            lines.push(`@@ -${String(hunk.oldStart)},${String(hunk.oldLines)} +${String(hunk.newStart)},${String(hunk.newLines)} @@`, ...hunk.lines);
-        }
-    }
-    return lines.join("\n");
-}
-function parseDiffForValidation(diff) {
-    try {
-        return { files: parseUnifiedDiff(diff).files, effectiveDiff: diff, normalized: false };
-    }
-    catch (error) {
-        if (!(error instanceof PatchParseError)) {
-            throw error;
-        }
-        const normalizedDiff = normalizeUnifiedDiffHunks(diff);
-        if (normalizedDiff === diff) {
-            throw error;
-        }
-        return {
-            files: parseUnifiedDiff(normalizedDiff).files,
-            effectiveDiff: normalizedDiff,
-            normalized: true,
-        };
-    }
-}
-function malformedValidation(diff, error) {
-    const message = error instanceof PatchParseError ? error.message : "unparseable diff";
-    return {
-        ok: false,
-        files: [],
-        totalChangedLines: 0,
-        totalBytes: Buffer.byteLength(diff, "utf8"),
-        reasons: [{ code: "malformed", message }],
-        conflicts: [],
-    };
-}
-function completeValidation(workspace, fs, limits, diff, parsed) {
-    const files = parsed.files;
-    const totalBytes = Buffer.byteLength(parsed.effectiveDiff, "utf8");
-    const totalChangedLines = files.reduce((sum, f) => sum + f.addedLines + f.removedLines, 0);
-    const pathAndSizeReasons = [
-        ...sizeAndCountReasons(parsed.effectiveDiff, files, totalChangedLines, limits, totalBytes),
-        ...collectPathReasons(workspace, fs, files),
-    ];
-    const alignedFiles = pathAndSizeReasons.length === 0 ? alignHunksToCurrentContent(workspace, fs, files) : files;
-    const aligned = alignedFiles.some((file, index) => file !== files[index]);
-    const effectiveDiff = parsed.normalized || aligned ? renderParsedPatch(alignedFiles) : diff;
-    const reasons = [...pathAndSizeReasons, ...unanchoredModifyReasons(alignedFiles)];
-    const conflicts = reasons.length === 0 ? collectConflicts(workspace, fs, alignedFiles) : [];
-    return {
-        ok: reasons.length === 0 && conflicts.length === 0,
-        files: alignedFiles,
-        totalChangedLines,
-        totalBytes: Buffer.byteLength(effectiveDiff, "utf8"),
-        ...(effectiveDiff === diff ? {} : { normalizedDiff: effectiveDiff }),
-        reasons,
-        conflicts,
-    };
-}
-export function validatePatch(workspace, diff, deps = {}) {
-    const fs = deps.fs ?? nodeWorkspaceFs;
-    const limits = deps.limits ?? DEFAULT_PATCH_LIMITS;
-    try {
-        return completeValidation(workspace, fs, limits, diff, parseDiffForValidation(diff));
-    }
-    catch (error) {
-        return malformedValidation(diff, error);
-    }
-}
-function renderFileLine(file) {
-    return `${file.kind} ${file.path} (+${String(file.addedLines)} -${String(file.removedLines)})`;
-}
-// Human-readable preview returned by propose_patch. NEVER writes. Lists per-file +/- counts,
-// any rejection reasons, and any conflicts so the reviewer sees exactly what apply would do.
-export function renderDryRun(validation) {
-    const header = validation.ok
-        ? `PATCH OK — ${String(validation.files.length)} file(s), ${String(validation.totalChangedLines)} changed line(s)`
-        : "PATCH REJECTED";
-    const fileLines = validation.files.map(renderFileLine);
-    const reasonLines = validation.reasons.map((r) => `reject[${r.code}]: ${r.message}${r.path === undefined ? "" : ` (${r.path})`}`);
-    const conflictLines = validation.conflicts.map((c) => `conflict: ${c.path} hunk#${String(c.hunkIndex)}: ${c.reason}`);
-    return [header, ...fileLines, ...reasonLines, ...conflictLines].join("\n");
-}
-function planWrites(workspace, fs, signal, files) {
-    const plans = [];
-    for (const file of files) {
-        if (signal.aborted) {
-            throw new CommandCancelledError("apply cancelled before write planning completed");
-        }
-        const absolute = enforcePath(workspace, fs, file.path);
-        const original = readCurrent(workspace, fs, file.path);
-        const outcome = computeFileContent(file, original);
-        plans.push({
-            path: file.path,
-            absolute,
-            kind: file.kind,
-            newContent: outcome.content,
-            original,
-        });
-    }
-    return plans;
-}
-function applyOne(writer, plan) {
-    if (plan.kind === "delete") {
-        writer.remove(plan.absolute);
-        return;
-    }
-    const dir = plan.absolute.replace(/[/\\][^/\\]*$/, "");
-    writer.mkdirp(dir);
-    writer.writeFileUtf8(plan.absolute, plan.newContent ?? "");
-}
-function rollback(writer, done) {
-    for (const plan of done) {
-        if (plan.original === undefined) {
-            writer.remove(plan.absolute);
-        }
-        else {
-            writer.writeFileUtf8(plan.absolute, plan.original);
-        }
-    }
-}
-function commit(writer, plans, signal) {
-    const done = [];
-    for (const plan of plans) {
-        if (isAbortRequested(signal)) {
-            rollback(writer, done);
-            throw new CommandCancelledError("apply cancelled during write phase");
-        }
-        try {
-            applyOne(writer, plan);
-            done.push(plan);
-        }
-        catch (error) {
-            rollback(writer, done);
-            const message = error instanceof Error ? error.message : "write failed";
-            throw new PatchApplyError(`apply failed, rolled back: ${message}`, plan.path);
-        }
-        if (isAbortRequested(signal)) {
-            rollback(writer, done);
-            throw new CommandCancelledError("apply cancelled during write phase");
-        }
-    }
-}
-function isAbortRequested(signal) {
-    return signal.aborted;
-}
-function summarize(plans) {
-    return {
-        changedFiles: plans.map((p) => p.path),
-        created: plans.filter((p) => p.kind === "create").map((p) => p.path),
-        deleted: plans.filter((p) => p.kind === "delete").map((p) => p.path),
-    };
-}
-// Applies a validated patch atomically. Fail-closed: no write unless applyEnabled === true.
-// Order: gate → validate → abort check → plan (pure) → write with multi-file rollback.
-export function applyPatch(workspace, diff, deps) {
-    if (!deps.applyEnabled) {
-        throw new PatchApplyDisabledError("apply is disabled (applyEnabled is false)");
-    }
-    const fs = deps.fs ?? nodeWorkspaceFs;
-    const writer = deps.writer ?? nodeWorkspaceWriter;
-    const validation = validatePatch(workspace, diff, {
-        fs,
-        ...(deps.limits ? { limits: deps.limits } : {}),
-    });
-    if (!validation.ok) {
-        throw new PatchValidationError("patch failed validation", validation.reasons, validation.conflicts);
-    }
-    if (deps.signal.aborted) {
-        throw new CommandCancelledError("apply cancelled before write phase");
-    }
-    const plans = planWrites(workspace, fs, deps.signal, validation.files);
-    commit(writer, plans, deps.signal);
-    return summarize(plans);
-}
+// Re-export shim: the patch workflow lives in @oscharko-dev/keiko-tools (issue #162, ADR-0019).
+// All existing import sites (`from "../tools/patch.js"`) keep resolving unchanged via this barrel.
+export { applyPatch, renderDryRun, validatePatch, } from "@oscharko-dev/keiko-tools";

package/dist/tools/registry.d.ts

@@ -1,36 +1 @@
-import type { ToolDefinition } from "../gateway/types.js";
-import type { ToolCallRequest, ToolCallResult, ToolPort } from "../harness/ports.js";
-import { type WorkspaceFs } from "../workspace/fs.js";
-import type { WorkspaceInfo } from "../workspace/types.js";
-import { type ExecutableResolver, type SpawnFn } from "./exec.js";
-import { type WorkspaceWriter } from "./writer.js";
-import { type ToolHostConfigInput } from "./types.js";
-export declare class WorkspaceToolHost implements ToolPort {
-    private readonly workspace;
-    private readonly fs;
-    private readonly writer;
-    private readonly spawn;
-    private readonly resolveExecutable;
-    private readonly config;
-    private readonly processEnv;
-    private readonly now;
-    constructor(deps: {
-        readonly workspace: WorkspaceInfo;
-        readonly fs?: WorkspaceFs | undefined;
-        readonly writer?: WorkspaceWriter | undefined;
-        readonly spawn?: SpawnFn | undefined;
-        readonly resolveExecutable?: ExecutableResolver | undefined;
-        readonly config?: ToolHostConfigInput | undefined;
-        readonly processEnv?: NodeJS.ProcessEnv | undefined;
-        readonly now?: (() => number) | undefined;
-    });
-    listTools(): readonly ToolDefinition[];
-    execute(request: ToolCallRequest): Promise<ToolCallResult>;
-    private dispatch;
-    private readFile;
-    private listFiles;
-    private inspectScripts;
-    private runCommandTool;
-    private proposePatch;
-    private applyPatchTool;
-}
+export { WorkspaceToolHost } from "@oscharko-dev/keiko-tools";