@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/commands/diff-patch/shared.d.ts

@@ -1,54 +1,2 @@
-import { PublicDiagnostic } from "../../diagnostics.js";
-import { type CommandContext, type CommandDefinition, type FileStat } from "../../contracts/index.js";
-export interface DiffPatchOptions {
-    readonly replace?: boolean;
-    readonly maxInputBytes?: number;
-    readonly maxOutputBytes?: number;
-    readonly maxLines?: number;
-    readonly maxWork?: number;
-    readonly maxMatrixCells?: number;
-    readonly maxFiles?: number;
-    readonly maxHunks?: number;
-    readonly maxExcludePatterns?: number;
-    readonly maxExcludePatternBytes?: number;
-}
-export declare class ToolError extends PublicDiagnostic {
-    readonly exitCode: number;
-    constructor(message: string, exitCode?: number);
-}
-export declare class Budget {
-    readonly context: CommandContext;
-    readonly limits: Required<Omit<DiffPatchOptions, "replace">>;
-    readonly inspected: Map<string, FileStat>;
-    private inputBytes;
-    private outputBytes;
-    private lines;
-    private work;
-    private nextYield;
-    private files;
-    private hunks;
-    private signalAborted;
-    private readonly pollSignal;
-    get maxBufferBytes(): number;
-    get remainingWork(): number;
-    get remainingFiles(): number;
-    constructor(context: CommandContext, options: DiffPatchOptions);
-    step(amount?: number): void;
-    checkpoint(): void | Promise<void>;
-    file(): void;
-    hunk(): void;
-    private static readonly utf8Decoder;
-    text(bytes: Uint8Array): string;
-    split(text: string): string[];
-    read(path: string, encoding?: "utf8" | "latin1"): Promise<string>;
-    readDiff(path: string, encoding?: "utf8" | "latin1"): Promise<string>;
-    private chunks;
-    output(text: string, encoding?: "utf8" | "latin1"): void;
-    equal(left: string | undefined, right: string | undefined): boolean;
-}
-export declare function host<Result>(context: CommandContext, operation: () => Promise<Result>): Promise<Result>;
-export declare function sameIdentity(actual: FileStat, wanted: FileStat): boolean;
-export declare function inspect(budget: Budget, path: string, symlinks?: "reject" | "follow" | "compare"): Promise<FileStat | undefined>;
-export declare function integer(value: string, name: string): number;
-export declare function definition(name: string, options: DiffPatchOptions, run: (context: CommandContext, budget: Budget) => Promise<number>): CommandDefinition;
+export * from "../../../safe-bash-diff-engine/shared.js";
 //# sourceMappingURL=shared.d.ts.map

package/dist/safe-bash/commands/diff-patch/shared.js

@@ -1,268 +1,2 @@
-import { byteLength, concatBytes, decodeBytes, encodeBytes } from "../../byte-encoding.js";
-import { PublicDiagnostic, publicDiagnosticMessage } from "../../diagnostics.js";
-import { writeDiagnostic } from "../../escaping.js";
-import { yieldTurn } from "../../contracts/yield.js";
-import { collectBytes, isFsError, readBytes, } from "../../contracts/index.js";
-import { pathOf } from "../internal.js";
-export class ToolError extends PublicDiagnostic {
-    exitCode;
-    constructor(message, exitCode = 2) {
-        super(message);
-        this.exitCode = exitCode;
-    }
-}
-export class Budget {
-    context;
-    limits;
-    inspected = new Map();
-    inputBytes = 0;
-    outputBytes = 0;
-    lines = 0;
-    work = 0;
-    nextYield = 4096;
-    files = 0;
-    hunks = 0;
-    signalAborted;
-    pollSignal;
-    get maxBufferBytes() { return this.limits.maxInputBytes; }
-    get remainingWork() { return this.limits.maxWork - this.work; }
-    get remainingFiles() { return this.limits.maxFiles - this.files; }
-    constructor(context, options) {
-        this.context = context;
-        this.signalAborted = context.signal.aborted;
-        this.pollSignal = Object.prototype.hasOwnProperty.call(context.signal, "aborted");
-        if (!this.signalAborted && !this.pollSignal) {
-            context.signal.addEventListener("abort", () => { this.signalAborted = true; }, { once: true });
-        }
-        this.limits = {
-            maxInputBytes: options.maxInputBytes ?? Infinity,
-            maxOutputBytes: options.maxOutputBytes ?? Infinity,
-            maxLines: options.maxLines ?? Infinity,
-            maxWork: options.maxWork ?? Infinity,
-            maxMatrixCells: options.maxMatrixCells ?? Infinity,
-            maxFiles: options.maxFiles ?? Infinity,
-            maxHunks: options.maxHunks ?? Infinity,
-            maxExcludePatterns: options.maxExcludePatterns ?? Infinity,
-            maxExcludePatternBytes: options.maxExcludePatternBytes ?? Infinity,
-        };
-        for (const [name, value] of Object.entries(options).filter(([name]) => name !== "replace")) {
-            if (value !== undefined && value !== Infinity && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1))
-                throw new ToolError(`${name} must be a positive safe integer or Infinity`);
-        }
-    }
-    step(amount = 1) {
-        if (this.pollSignal ? this.context.signal.aborted : this.signalAborted)
-            this.context.signal.throwIfAborted();
-        this.work += amount;
-        if (this.work > this.limits.maxWork)
-            throw new ToolError("work limit exceeded");
-    }
-    checkpoint() {
-        if (this.pollSignal ? this.context.signal.aborted : this.signalAborted)
-            this.context.signal.throwIfAborted();
-        if (this.work >= this.nextYield) {
-            this.nextYield = this.work + 4096;
-            return yieldTurn(this.context.signal);
-        }
-    }
-    file() {
-        this.step();
-        if (++this.files > this.limits.maxFiles)
-            throw new ToolError("file/entry limit exceeded");
-    }
-    hunk() {
-        this.step();
-        if (++this.hunks > this.limits.maxHunks)
-            throw new ToolError("hunk limit exceeded");
-    }
-    static utf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-    text(bytes) {
-        if (bytes.includes(0))
-            throw new ToolError("binary input is unsupported (NUL byte)");
-        try {
-            return Budget.utf8Decoder.decode(bytes);
-        }
-        catch {
-            throw new ToolError("binary input is unsupported (invalid UTF-8)");
-        }
-    }
-    split(text) {
-        const result = [];
-        let start = 0;
-        while (start < text.length) {
-            if (++this.lines > this.limits.maxLines)
-                throw new ToolError("line limit exceeded");
-            const newline = text.indexOf("\n", start);
-            const end = newline < 0 ? text.length : newline + 1;
-            result.push(text.slice(start, end));
-            start = end;
-        }
-        return result;
-    }
-    async read(path, encoding = "utf8") {
-        this.context.signal.throwIfAborted();
-        const remaining = this.limits.maxInputBytes - this.inputBytes;
-        const capabilities = path === "-" ? undefined : await host(this.context, async () => await this.context.fs.capabilitiesFor?.(path, { signal: this.context.signal }) ?? this.context.fs.capabilities);
-        const bytes = path === "-"
-            ? await collectBytes(this.chunks(this.context.stdin), { signal: this.context.signal, ...(Number.isFinite(remaining) ? { maxBytes: remaining } : {}) })
-            : this.context.fs.readStream && capabilities?.streamingRead !== false
-                ? await collectBytes(this.chunks(this.context.fs.readStream(path, { signal: this.context.signal })), { signal: this.context.signal, ...(Number.isFinite(remaining) ? { maxBytes: remaining } : {}) })
-                : await host(this.context, () => this.context.fs.readFile(path, { signal: this.context.signal, ...(Number.isFinite(remaining) ? { maxBytes: remaining } : {}) }));
-        this.inputBytes += bytes.byteLength;
-        if (this.inputBytes > this.limits.maxInputBytes)
-            throw new ToolError("input byte limit exceeded");
-        return encoding === "latin1" ? decodeBytes(encodeBytes(bytes), "latin1") : this.text(bytes);
-    }
-    async readDiff(path, encoding = "utf8") {
-        const { fs, signal } = this.context;
-        const expected = this.inspected.get(path);
-        const verifyAncestors = async () => {
-            const parts = path.split("/").filter(Boolean);
-            let current = "";
-            for (let index = -1; index < parts.length - 1; index++) {
-                if (index >= 0)
-                    current += `/${parts[index]}`;
-                const ancestor = current || "/";
-                const wanted = this.inspected.get(ancestor);
-                const actual = await fs.stat(ancestor, { signal });
-                if (!wanted || !sameIdentity(actual, wanted))
-                    throw new ToolError("diff input ancestry changed");
-            }
-        };
-        const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
-        if (!expected || !sameIdentity(expected, expected) || capabilities.retainedRead !== true || !fs.openReadFile)
-            throw new ToolError("diff input requires identity-checked retained reads");
-        await verifyAncestors();
-        const handle = await fs.openReadFile(path, { signal });
-        try {
-            const stat = await handle.stat({ signal });
-            if (!sameIdentity(stat, expected) || stat.size !== expected.size || stat.revision !== expected.revision)
-                throw new ToolError("diff input changed while opening");
-            await verifyAncestors();
-            const remaining = this.limits.maxInputBytes - this.inputBytes;
-            if (stat.size > remaining)
-                throw new ToolError("input byte limit exceeded");
-            const chunks = [];
-            let position = 0;
-            while (position < stat.size) {
-                this.step();
-                {
-                    const c = this.checkpoint();
-                    if (c)
-                        await c;
-                }
-                const size = Math.min(65536, stat.size - position);
-                const chunk = await handle.read(position, size, { signal });
-                if (!chunk.length || chunk.length > size)
-                    throw new ToolError("diff input changed while reading");
-                chunks.push(chunk);
-                position += chunk.length;
-            }
-            const after = await handle.stat({ signal });
-            if (!sameIdentity(after, stat) || after.size !== stat.size || after.revision !== stat.revision)
-                throw new ToolError("diff input changed while reading");
-            const bytes = concatBytes(chunks, position);
-            this.inputBytes += position;
-            return encoding === "latin1" ? decodeBytes(bytes, "latin1") : this.text(bytes);
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    async *chunks(source) {
-        for await (const chunk of readBytes(source, this.context.signal)) {
-            this.step();
-            {
-                const c = this.checkpoint();
-                if (c)
-                    await c;
-            }
-            yield chunk;
-        }
-    }
-    output(text, encoding = "utf8") {
-        this.outputBytes += byteLength(text, encoding);
-        if (this.outputBytes > this.limits.maxOutputBytes)
-            throw new ToolError("output byte limit exceeded");
-    }
-    equal(left, right) {
-        this.step(1 + Math.max(left?.length ?? 0, right?.length ?? 0));
-        return left === right;
-    }
-}
-export async function host(context, operation) {
-    context.signal.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const abort = () => reject(context.signal.reason);
-        context.signal.addEventListener("abort", abort, { once: true });
-        Promise.resolve().then(() => {
-            context.signal.throwIfAborted();
-            return operation();
-        }).then(resolve, reject).finally(() => context.signal.removeEventListener("abort", abort));
-    });
-}
-export function sameIdentity(actual, wanted) {
-    return wanted.identityScope !== undefined && wanted.dev !== undefined && wanted.ino !== undefined
-        && actual.identityScope === wanted.identityScope && actual.dev === wanted.dev && actual.ino === wanted.ino
-        && actual.type === wanted.type;
-}
-export async function inspect(budget, path, symlinks = "reject") {
-    const context = budget.context;
-    const absolute = pathOf(context, path);
-    const parts = absolute.split("/").filter(Boolean);
-    let current = "";
-    for (let index = -1; index < parts.length; index++) {
-        budget.step();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        if (index >= 0)
-            current += `/${parts[index]}`;
-        let stat;
-        try {
-            stat = await host(context, () => context.fs.lstat(current || "/", { signal: context.signal }));
-        }
-        catch (error) {
-            if (isFsError(error, "ENOENT"))
-                return undefined;
-            throw error;
-        }
-        if (stat.type === "symlink") {
-            if (symlinks === "reject")
-                throw new ToolError(`symlink paths are unsupported: ${current}`);
-            if (symlinks === "follow" || index < parts.length - 1)
-                stat = await host(context, () => context.fs.stat(current || "/", { signal: context.signal }));
-        }
-        budget.inspected.set(current || "/", stat);
-        if (index < parts.length - 1 && stat.type !== "directory")
-            throw new ToolError(`not a directory: ${current}`);
-        if (index === parts.length - 1)
-            return stat;
-    }
-    return undefined;
-}
-export function integer(value, name) {
-    if (!/^\d+$/u.test(value) || !Number.isSafeInteger(Number(value)))
-        throw new ToolError(`invalid ${name}: ${value}`);
-    return Number(value);
-}
-export function definition(name, options, run) {
-    return {
-        name,
-        async execute(context) {
-            context.signal.throwIfAborted();
-            try {
-                return { exitCode: await run(context, new Budget(context, options)) };
-            }
-            catch (error) {
-                context.signal.throwIfAborted();
-                const message = publicDiagnosticMessage(error, context.onInternalError);
-                await writeDiagnostic(context.stderr, `${name}: ${message.slice(0, 1000)}${message.length > 1000 ? "…" : ""}\n`, context.signal);
-                return { exitCode: error instanceof ToolError ? error.exitCode : 2 };
-            }
-        },
-    };
-}
+export * from "../../../safe-bash-diff-engine/shared.js";
 //# sourceMappingURL=shared.js.map

package/dist/safe-bash/commands/diff-patch/unified.d.ts

@@ -1,53 +1,2 @@
-import { Budget } from "./shared.js";
-export interface PatchLine {
-    readonly kind: " " | "+" | "-";
-    text: string;
-}
-export interface Hunk {
-    readonly oldStart: number;
-    readonly oldCount: number;
-    readonly newStart: number;
-    readonly newCount: number;
-    readonly lines: PatchLine[];
-    readonly section?: string;
-}
-export interface FilePatch {
-    readonly oldPath: string;
-    readonly newPath: string;
-    readonly oldEpoch: boolean;
-    readonly newEpoch: boolean;
-    readonly hunks: Hunk[];
-    readonly oldHeader?: string;
-    readonly newHeader?: string;
-    readonly indexPath?: string;
-    readonly unlocated?: boolean;
-    readonly format?: "unified" | "normal" | "context";
-}
-export declare function startIndex(start: number, count: number): number;
-export interface UnifiedCursor {
-    readonly lines: readonly string[];
-    index: number;
-}
-export declare function parseUnified(text: string, budget: Budget): Promise<FilePatch[]>;
-export declare function parseUnifiedSection(cursor: UnifiedCursor, budget: Budget): Promise<FilePatch[]>;
-export declare function reversePatch(patch: FilePatch): FilePatch;
-export interface HunkOutcome {
-    readonly hunk: Hunk;
-    readonly index: number;
-    readonly failed: boolean;
-    readonly mergeRange?: readonly [number, number];
-    readonly misordered: boolean;
-    readonly line: number;
-    readonly outputOffset: number;
-    readonly offset: number;
-    readonly fuzz: number;
-}
-export interface HunkApplication {
-    readonly ifdef?: string;
-    readonly merge?: "merge" | "diff3";
-    readonly partial?: boolean;
-    readonly rejectAll?: boolean;
-    readonly outcomes?: HunkOutcome[];
-}
-export declare function applyHunks(original: string, patch: FilePatch, fuzz: number, budget: Budget, ignoreWhitespace?: boolean, application?: HunkApplication): Promise<string>;
+export * from "../../../safe-bash-command-patch/unified.js";
 //# sourceMappingURL=unified.d.ts.map