@slopus/rig 0.0.1

package/dist/tools/utils/file.js

@@ -0,0 +1,331 @@
+import { dirname } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { resolveToolPath, splitLines } from "./path.js";
+export const readFileReturnSchema = Type.Object({
+    path: Type.String(),
+    content: Type.String(),
+    startLine: Type.Number(),
+    totalLines: Type.Number(),
+    returnedLines: Type.Number(),
+    truncated: Type.Boolean(),
+});
+export const writeFileReturnSchema = Type.Object({
+    path: Type.String(),
+    created: Type.Boolean(),
+    bytes: Type.Number(),
+});
+export const editFileReturnSchema = Type.Object({
+    path: Type.String(),
+    replacements: Type.Number(),
+    fuzzy: Type.Boolean(),
+    oldString: Type.String(),
+    newString: Type.String(),
+});
+export async function readTextFile(options, context) {
+    const filePath = resolveToolPath(options.path, options.cwd ?? context.fs.cwd);
+    const stats = await context.fs.stat(filePath);
+    if (stats.isDirectory) {
+        throw new Error(`Path is a directory: ${options.path}`);
+    }
+    const raw = await context.fs.readFile(filePath);
+    const lines = splitLines(raw);
+    const startLine = Math.max(1, options.offset ?? 1);
+    const startIndex = Math.min(lines.length, startLine - 1);
+    const limit = options.limit === undefined ? undefined : Math.max(0, options.limit);
+    const selected = limit === undefined ? lines.slice(startIndex) : lines.slice(startIndex, startIndex + limit);
+    const content = options.numbered
+        ? selected.map((line, index) => `${startLine + index}\t${line}`).join("\n")
+        : selected.join("\n");
+    return {
+        path: filePath,
+        content,
+        startLine,
+        totalLines: lines.length,
+        returnedLines: selected.length,
+        truncated: limit !== undefined && startIndex + selected.length < lines.length,
+    };
+}
+export async function writeTextFile(options, context) {
+    const filePath = resolveToolPath(options.path, options.cwd ?? context.fs.cwd);
+    const created = !(await context.fs.exists(filePath));
+    await context.fs.mkdir(dirname(filePath), { recursive: true });
+    await context.fs.writeFile(filePath, options.content);
+    return {
+        path: filePath,
+        created,
+        bytes: Buffer.byteLength(options.content, "utf8"),
+    };
+}
+export async function editTextFile(options, context) {
+    const plan = await planTextEdit(options, context);
+    await context.fs.writeFile(plan.path, plan.nextContent);
+    return {
+        path: plan.path,
+        replacements: plan.replacements,
+        fuzzy: plan.fuzzy,
+        oldString: options.oldString,
+        newString: options.newString,
+    };
+}
+export async function planTextEdit(options, context) {
+    const filePath = resolveToolPath(options.path, options.cwd ?? context.fs.cwd);
+    const content = await context.fs.readFile(filePath);
+    return planTextEditInContent(content, filePath, options);
+}
+function planTextEditInContent(content, filePath, options) {
+    if (options.oldString === options.newString) {
+        throw new Error("No changes to make: old_string and new_string are identical");
+    }
+    if (options.oldString.length === 0) {
+        throw new Error("old_string must not be empty");
+    }
+    const allExactPositions = findAllOccurrences(content, options.oldString);
+    if (options.replaceAll && allExactPositions.length > 0) {
+        return {
+            path: filePath,
+            nextContent: content.split(options.oldString).join(options.newString),
+            replacements: allExactPositions.length,
+            fuzzy: false,
+        };
+    }
+    const match = findEditMatch(content, options);
+    if (!match) {
+        throw new Error(`old_string was not found in ${options.path}`);
+    }
+    const actualOldString = content.slice(match.start, match.end);
+    const nextString = preserveQuoteStyle(options.oldString, actualOldString, options.newString);
+    return {
+        path: filePath,
+        nextContent: content.slice(0, match.start) + nextString + content.slice(match.end),
+        replacements: match.replacements,
+        fuzzy: match.fuzzy,
+    };
+}
+function findEditMatch(content, options) {
+    const exact = findExactEditMatch(content, options);
+    if (exact) {
+        return exact;
+    }
+    if (options.fuzzy) {
+        return findFuzzyEditMatch(content, options);
+    }
+    return undefined;
+}
+function findExactEditMatch(content, options) {
+    const positions = findAllOccurrences(content, options.oldString);
+    if (positions.length === 0) {
+        return undefined;
+    }
+    if (options.replaceAll) {
+        return {
+            start: positions[0] ?? 0,
+            end: (positions[0] ?? 0) + options.oldString.length,
+            replacements: positions.length,
+            fuzzy: false,
+        };
+    }
+    const selected = selectOccurrenceByLine(content, positions, options);
+    if (selected === undefined) {
+        throw new Error(`old_string appears ${positions.length} times; provide line_number or set replace_all`);
+    }
+    return {
+        start: selected,
+        end: selected + options.oldString.length,
+        replacements: 1,
+        fuzzy: false,
+    };
+}
+function findFuzzyEditMatch(content, options) {
+    const candidates = buildFuzzyCandidates(content, options.oldString);
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const selected = selectOccurrenceByLine(content, candidates.map((candidate) => candidate.start), options);
+    const candidate = selected === undefined
+        ? candidates.length === 1
+            ? candidates[0]
+            : undefined
+        : candidates.find((item) => item.start === selected);
+    if (!candidate) {
+        throw new Error(`old_string has ${candidates.length} fuzzy matches; provide line_number`);
+    }
+    return {
+        start: candidate.start,
+        end: candidate.end,
+        replacements: 1,
+        fuzzy: true,
+    };
+}
+function buildFuzzyCandidates(content, oldString) {
+    const normalizedNeedle = normalizeForEditMatch(oldString);
+    if (normalizedNeedle.length === 0) {
+        return [];
+    }
+    const candidates = [];
+    for (const candidate of candidateWindows(content, oldString)) {
+        if (normalizeForEditMatch(candidate.text) === normalizedNeedle) {
+            candidates.push({
+                start: candidate.start,
+                end: candidate.end,
+                replacements: 1,
+                fuzzy: true,
+            });
+        }
+    }
+    return candidates;
+}
+function* candidateWindows(content, oldString) {
+    const lineCount = splitLines(oldString).length;
+    const ranges = lineRanges(content);
+    for (let i = 0; i < ranges.length; i++) {
+        for (let size = Math.max(1, lineCount - 1); size <= lineCount + 1; size++) {
+            const endLine = i + size - 1;
+            const endRange = ranges[endLine];
+            const startRange = ranges[i];
+            if (!startRange || !endRange) {
+                continue;
+            }
+            yield {
+                start: startRange.start,
+                end: endRange.end,
+                text: content.slice(startRange.start, endRange.end),
+            };
+        }
+    }
+}
+function findAllOccurrences(haystack, needle) {
+    const positions = [];
+    let index = haystack.indexOf(needle);
+    while (index !== -1) {
+        positions.push(index);
+        index = haystack.indexOf(needle, index + Math.max(1, needle.length));
+    }
+    return positions;
+}
+function selectOccurrenceByLine(content, positions, options) {
+    if (positions.length === 1 && options.lineNumber === undefined) {
+        return positions[0];
+    }
+    if (options.lineNumber === undefined) {
+        return undefined;
+    }
+    return positions.find((position) => lineNumberAtOffset(content, position) === options.lineNumber);
+}
+function normalizeForEditMatch(value) {
+    return normalizeQuotes(value)
+        .normalize("NFKC")
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n")
+        .trim();
+}
+function normalizeQuotes(value) {
+    return value
+        .replaceAll("\u2018", "'")
+        .replaceAll("\u2019", "'")
+        .replaceAll("\u201A", "'")
+        .replaceAll("\u201B", "'")
+        .replaceAll("\u201C", '"')
+        .replaceAll("\u201D", '"')
+        .replaceAll("\u201E", '"')
+        .replaceAll("\u201F", '"');
+}
+function preserveQuoteStyle(oldString, actualOldString, newString) {
+    if (oldString === actualOldString) {
+        return newString;
+    }
+    let result = newString;
+    if (actualOldString.includes("\u201C") || actualOldString.includes("\u201D")) {
+        result = replaceStraightQuotes(result, '"', ["\u201C", "\u201D"]);
+    }
+    if (actualOldString.includes("\u2018") || actualOldString.includes("\u2019")) {
+        result = replaceStraightQuotes(result, "'", ["\u2018", "\u2019"]);
+    }
+    return result;
+}
+function replaceStraightQuotes(value, quote, pair) {
+    let opening = true;
+    let out = "";
+    for (const char of value) {
+        if (char === quote) {
+            out += opening ? pair[0] : pair[1];
+            opening = !opening;
+        }
+        else {
+            out += char;
+        }
+    }
+    return out;
+}
+export async function editTextFileBatch(options, context) {
+    if (options.edits.length === 0) {
+        throw new Error("At least one edit is required.");
+    }
+    const filePath = resolveToolPath(options.path, options.cwd ?? context.fs.cwd);
+    const rawContent = await context.fs.readFile(filePath);
+    const matches = options.edits.map((edit, editIndex) => {
+        const editOptions = {
+            path: options.path,
+            oldString: edit.oldText,
+            newString: edit.newText,
+        };
+        if (options.fuzzy !== undefined)
+            editOptions.fuzzy = options.fuzzy;
+        const match = findEditMatch(rawContent, editOptions);
+        if (!match) {
+            throw new Error(options.edits.length === 1
+                ? `Could not find the exact text in ${options.path}. The old text must match exactly including all whitespace and newlines.`
+                : `Could not find the exact text for edit ${editIndex + 1} in ${options.path}.`);
+        }
+        return { ...match, edit };
+    });
+    const sorted = [...matches].sort((left, right) => left.start - right.start);
+    for (let i = 1; i < sorted.length; i++) {
+        const prev = sorted[i - 1];
+        const current = sorted[i];
+        if (prev && current && current.start < prev.end) {
+            throw new Error("Edit ranges overlap. Merge nearby changes into one edit.");
+        }
+    }
+    let nextContent = rawContent;
+    let usedFuzzy = false;
+    for (let i = sorted.length - 1; i >= 0; i--) {
+        const match = sorted[i];
+        if (!match)
+            continue;
+        usedFuzzy ||= match.fuzzy;
+        const actualOldString = rawContent.slice(match.start, match.end);
+        const nextString = preserveQuoteStyle(match.edit.oldText, actualOldString, match.edit.newText);
+        nextContent = nextContent.slice(0, match.start) + nextString + nextContent.slice(match.end);
+    }
+    await context.fs.writeFile(filePath, nextContent);
+    return {
+        path: filePath,
+        replacements: sorted.length,
+        fuzzy: usedFuzzy,
+    };
+}
+function lineRanges(content) {
+    const ranges = [];
+    let start = 0;
+    for (let i = 0; i <= content.length; i++) {
+        if (i === content.length || content[i] === "\n") {
+            ranges.push({ start, end: i });
+            start = i + 1;
+        }
+    }
+    return ranges;
+}
+function lineNumberAtOffset(content, offset) {
+    let line = 1;
+    for (let i = 0; i < offset; i++) {
+        if (content[i] === "\n") {
+            line++;
+        }
+    }
+    return line;
+}

package/dist/tools/utils/getImageProcessor.d.ts

@@ -0,0 +1,3 @@
+import type sharp from "sharp";
+export declare function getImageProcessor(): Promise<typeof sharp>;
+//# sourceMappingURL=getImageProcessor.d.ts.map

package/dist/tools/utils/getImageProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getImageProcessor.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/getImageProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,OAAO,KAAK,CAAC,CAQ/D"}

package/dist/tools/utils/getImageProcessor.js

@@ -0,0 +1,9 @@
+let imageProcessor;
+export async function getImageProcessor() {
+    if (imageProcessor !== undefined) {
+        return imageProcessor;
+    }
+    const imported = await import("sharp");
+    imageProcessor = imported.default;
+    return imageProcessor;
+}

package/dist/tools/utils/image.d.ts

@@ -0,0 +1,2 @@
+export declare function mediaTypeForPath(path: string): string;
+//# sourceMappingURL=image.d.ts.map

package/dist/tools/utils/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/image.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAarD"}

package/dist/tools/utils/image.js

@@ -0,0 +1,15 @@
+import { extname } from "node:path";
+export function mediaTypeForPath(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".png":
+        default:
+            return "image/png";
+    }
+}

package/dist/tools/utils/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./content.js";
+export * from "./countTextLines.js";
+export * from "./file.js";
+export * from "./getImageProcessor.js";
+export * from "./ImageProcessingError.js";
+export * from "./image.js";
+export * from "./patch.js";
+export * from "./prepareImageForPrompt.js";
+export * from "./prepareImageForClaude.js";
+export * from "./promptImageOutputDimensions.js";
+export * from "./path.js";
+export * from "./search.js";
+export * from "./shell.js";
+export * from "./singleLineText.js";
+export * from "./summarizeShellOutput.js";
+export * from "./summarizeTextOutput.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kCAAkC,CAAC;AACjD,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC"}

package/dist/tools/utils/index.js

@@ -0,0 +1,16 @@
+export * from "./content.js";
+export * from "./countTextLines.js";
+export * from "./file.js";
+export * from "./getImageProcessor.js";
+export * from "./ImageProcessingError.js";
+export * from "./image.js";
+export * from "./patch.js";
+export * from "./prepareImageForPrompt.js";
+export * from "./prepareImageForClaude.js";
+export * from "./promptImageOutputDimensions.js";
+export * from "./path.js";
+export * from "./search.js";
+export * from "./shell.js";
+export * from "./singleLineText.js";
+export * from "./summarizeShellOutput.js";
+export * from "./summarizeTextOutput.js";

package/dist/tools/utils/patch.d.ts

@@ -0,0 +1,7 @@
+import type { AgentContext } from "../../agent/context/AgentContext.js";
+export interface ApplyPatchResult {
+    applied: boolean;
+    summary: string;
+}
+export declare function applyPatchText(patch: string, cwd: string, context: AgentContext): Promise<ApplyPatchResult>;
+//# sourceMappingURL=patch.d.ts.map

package/dist/tools/utils/patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/patch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAGxE,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,cAAc,CAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,CAAC,CA0D3B"}

package/dist/tools/utils/patch.js

@@ -0,0 +1,107 @@
+import { dirname } from "node:path";
+import { resolveToolPath } from "./path.js";
+export async function applyPatchText(patch, cwd, context) {
+    const lines = patch.replace(/\r\n/g, "\n").split("\n");
+    if (lines[0] !== "*** Begin Patch") {
+        throw new Error("Invalid patch: missing Begin Patch header");
+    }
+    if (!lines.some((line) => line === "*** End Patch")) {
+        throw new Error("Invalid patch: missing End Patch footer");
+    }
+    const summaries = [];
+    let index = 1;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line === "*** End Patch") {
+            break;
+        }
+        if (line?.startsWith("*** Add File: ")) {
+            const filename = line.slice("*** Add File: ".length);
+            const body = [];
+            index++;
+            while (index < lines.length && !lines[index]?.startsWith("*** ")) {
+                const addLine = lines[index];
+                if (!addLine?.startsWith("+")) {
+                    throw new Error(`Invalid add-file line in ${filename}`);
+                }
+                body.push(addLine.slice(1));
+                index++;
+            }
+            const target = resolveToolPath(filename, cwd);
+            await context.fs.mkdir(dirname(target), { recursive: true });
+            await context.fs.writeFile(target, body.join("\n"));
+            summaries.push(`A ${filename}`);
+            continue;
+        }
+        if (line?.startsWith("*** Delete File: ")) {
+            const filename = line.slice("*** Delete File: ".length);
+            await context.fs.rm(resolveToolPath(filename, cwd));
+            summaries.push(`D ${filename}`);
+            index++;
+            continue;
+        }
+        if (line?.startsWith("*** Update File: ")) {
+            const filename = line.slice("*** Update File: ".length);
+            index = await applyUpdateFilePatch(lines, index + 1, filename, cwd, context);
+            summaries.push(`M ${filename}`);
+            continue;
+        }
+        throw new Error(`Invalid patch directive: ${line ?? ""}`);
+    }
+    return {
+        applied: true,
+        summary: ["Success. Updated the following files:", ...summaries].join("\n"),
+    };
+}
+async function applyUpdateFilePatch(lines, index, filename, cwd, context) {
+    const source = resolveToolPath(filename, cwd);
+    let target = source;
+    if (lines[index]?.startsWith("*** Move to: ")) {
+        target = resolveToolPath(lines[index]?.slice("*** Move to: ".length) ?? "", cwd);
+        index++;
+    }
+    const existing = await context.fs.readFile(source);
+    let content = existing;
+    while (index < lines.length && !lines[index]?.startsWith("*** ")) {
+        if (lines[index] === "@@" || lines[index]?.startsWith("@@ ")) {
+            index++;
+            const remove = [];
+            const add = [];
+            while (index < lines.length &&
+                !lines[index]?.startsWith("@@") &&
+                !lines[index]?.startsWith("*** ")) {
+                const patchLine = lines[index] ?? "";
+                const marker = patchLine[0];
+                const text = patchLine.slice(1);
+                if (marker === " ") {
+                    remove.push(text);
+                    add.push(text);
+                }
+                else if (marker === "-") {
+                    remove.push(text);
+                }
+                else if (marker === "+") {
+                    add.push(text);
+                }
+                else {
+                    throw new Error(`Invalid update line for ${filename}`);
+                }
+                index++;
+            }
+            const oldText = remove.join("\n");
+            const newText = add.join("\n");
+            if (!content.includes(oldText)) {
+                throw new Error(`Invalid patch: hunk did not match ${filename}`);
+            }
+            content = content.replace(oldText, newText);
+            continue;
+        }
+        throw new Error(`Invalid update hunk for ${filename}`);
+    }
+    await context.fs.mkdir(dirname(target), { recursive: true });
+    await context.fs.writeFile(target, content);
+    if (target !== source) {
+        await context.fs.rm(source);
+    }
+    return index;
+}

package/dist/tools/utils/path.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveToolPath(path: string, cwd: string): string;
+export declare function splitLines(content: string): string[];
+export declare function temporaryFilePath(prefix: string): string;
+//# sourceMappingURL=path.d.ts.map

package/dist/tools/utils/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/path.ts"],"names":[],"mappings":"AAGA,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAMjE;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAKpD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/dist/tools/utils/path.js

@@ -0,0 +1,17 @@
+import { tmpdir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+export function resolveToolPath(path, cwd) {
+    if (path.startsWith("~/")) {
+        return resolve(process.env.HOME ?? cwd, path.slice(2));
+    }
+    return isAbsolute(path) ? path : resolve(cwd, path);
+}
+export function splitLines(content) {
+    if (content.length === 0) {
+        return [];
+    }
+    return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+}
+export function temporaryFilePath(prefix) {
+    return join(tmpdir(), `${prefix}-${process.pid}-${Date.now()}`);
+}

package/dist/tools/utils/prepareImageForClaude.d.ts

@@ -0,0 +1,7 @@
+import { type PreparedPromptImage } from "./prepareImageForPrompt.js";
+export declare const CLAUDE_IMAGE_MAX_BASE64_BYTES: number;
+export declare const CLAUDE_IMAGE_MAX_RAW_BYTES: number;
+export declare const CLAUDE_IMAGE_MAX_DIMENSION = 2000;
+/** Prepare an image using the same size and dimension policy as Claude Code. */
+export declare function prepareImageForClaude(bytes: Uint8Array): Promise<PreparedPromptImage>;
+//# sourceMappingURL=prepareImageForClaude.d.ts.map

package/dist/tools/utils/prepareImageForClaude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareImageForClaude.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/prepareImageForClaude.ts"],"names":[],"mappings":"AAMA,OAAO,EAEH,KAAK,mBAAmB,EAE3B,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAM,6BAA6B,QAAkB,CAAC;AAC7D,eAAO,MAAM,0BAA0B,QAA0C,CAAC;AAClF,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAS/C,gFAAgF;AAChF,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAqM3F"}