@howaboua/opencode-chat 0.1.0

package/dist/tools/skill.js

@@ -0,0 +1,106 @@
+/**
+ * chat_skill tool implementation.
+ * Load skills from the repo's .opencode/skill directory only.
+ */
+import * as path from "path";
+import * as fs from "fs/promises";
+import { tool } from "@opencode-ai/plugin";
+// Simple YAML frontmatter parser
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!match)
+        return { data: {}, content };
+    const frontmatter = match[1];
+    const body = match[2];
+    const data = {};
+    for (const line of frontmatter.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx > 0) {
+            const key = line.slice(0, colonIdx).trim();
+            const value = line.slice(colonIdx + 1).trim();
+            data[key] = value;
+        }
+    }
+    return { data, content: body };
+}
+export function createChatSkill(baseDir) {
+    const skillDir = path.join(baseDir, ".opencode", "skill");
+    // Scan for skills in the repo's .opencode/skill directory
+    async function scanSkills() {
+        const skills = [];
+        try {
+            const entries = await fs.readdir(skillDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const skillPath = path.join(skillDir, entry.name, "SKILL.md");
+                try {
+                    const content = await fs.readFile(skillPath, "utf-8");
+                    const { data } = parseFrontmatter(content);
+                    if (data.name && data.description) {
+                        skills.push({
+                            name: data.name,
+                            description: data.description,
+                            location: skillPath,
+                        });
+                    }
+                }
+                catch {
+                    // Skip if SKILL.md doesn't exist or can't be read
+                }
+            }
+        }
+        catch {
+            // Skill directory doesn't exist
+        }
+        return skills;
+    }
+    // Get a specific skill by name
+    async function getSkill(name) {
+        const skills = await scanSkills();
+        return skills.find((s) => s.name === name);
+    }
+    const run = async (args) => {
+        const skill = await getSkill(args.name);
+        if (!skill) {
+            const skills = await scanSkills();
+            const available = skills.map((s) => s.name).join(", ");
+            throw new Error(`Skill "${args.name}" not found. Available skills: ${available || "none"}`);
+        }
+        const content = await fs.readFile(skill.location, "utf-8");
+        const parsed = parseFrontmatter(content);
+        const dir = path.dirname(skill.location);
+        return [`## Skill: ${skill.name}`, "", `**Base directory**: ${dir}`, "", parsed.content.trim()].join("\n");
+    };
+    // Build description with available skills
+    const buildDescription = async () => {
+        const skills = await scanSkills();
+        const skillList = skills.flatMap((skill) => [
+            `  <skill>`,
+            `    <name>${skill.name}</name>`,
+            `    <description>${skill.description}</description>`,
+            `  </skill>`,
+        ]);
+        return [
+            "Load a skill to get detailed instructions for a specific task.",
+            "Skills provide specialized knowledge and step-by-step guidance.",
+            "<available_skills>",
+            ...skillList,
+            "</available_skills>",
+        ].join("\n");
+    };
+    return {
+        id: "chat_skill",
+        run,
+        buildDescription,
+        tool: tool({
+            description: "Load a skill for step-by-step guidance. Call without args to see available skills.",
+            args: {
+                name: tool.schema.string().describe("The skill name to load"),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/tools/todo.d.ts

@@ -0,0 +1,62 @@
+import { TodoItem } from "../util/types";
+export declare const todoSchema: import("zod").ZodObject<{
+    content: import("zod").ZodString;
+    status: import("zod").ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+        cancelled: "cancelled";
+    }>;
+    priority: import("zod").ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    id: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare function createChatTodo(todoPath: string): {
+    write: {
+        id: string;
+        run: (args: {
+            todos: TodoItem[];
+        }) => Promise<string>;
+        tool: {
+            description: string;
+            args: {
+                todos: import("zod").ZodArray<import("zod").ZodObject<{
+                    content: import("zod").ZodString;
+                    status: import("zod").ZodEnum<{
+                        pending: "pending";
+                        in_progress: "in_progress";
+                        completed: "completed";
+                        cancelled: "cancelled";
+                    }>;
+                    priority: import("zod").ZodEnum<{
+                        high: "high";
+                        medium: "medium";
+                        low: "low";
+                    }>;
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+            };
+            execute(args: {
+                todos: {
+                    content: string;
+                    status: "pending" | "in_progress" | "completed" | "cancelled";
+                    priority: "high" | "medium" | "low";
+                    id: string;
+                }[];
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
+    };
+    read: {
+        id: string;
+        run: () => Promise<string>;
+        tool: {
+            description: string;
+            args: {};
+            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
+    };
+};
+//# sourceMappingURL=todo.d.ts.map

package/dist/tools/todo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo.d.ts","sourceRoot":"","sources":["../../tools/todo.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAGxC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;gCAOrB,CAAA;AAEF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM;;;oBAClB;YAAE,KAAK,EAAE,QAAQ,EAAE,CAAA;SAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CjD"}

package/dist/tools/todo.js

@@ -0,0 +1,62 @@
+/**
+ * chat_todowrite and chat_todoread tool implementations.
+ * Stores todos in a repo-level todo.md file with embedded JSON.
+ * Deletes the file when all tasks are completed.
+ */
+import { tool } from "@opencode-ai/plugin";
+import { readTodoFile, writeTodoFile } from "../util/todo";
+export const todoSchema = tool.schema.object({
+    content: tool.schema.string().describe("Brief description of the task"),
+    status: tool.schema
+        .enum(["pending", "in_progress", "completed", "cancelled"])
+        .describe("Current status of the task: pending, in_progress, completed, cancelled"),
+    priority: tool.schema.enum(["high", "medium", "low"]).describe("Priority level of the task: high, medium, low"),
+    id: tool.schema.string().describe("Unique identifier for the todo item"),
+});
+export function createChatTodo(todoPath) {
+    const write = async (args) => {
+        const message = await writeTodoFile(todoPath, args.todos);
+        return message + "\n" + JSON.stringify(args.todos, null, 2);
+    };
+    const read = async () => {
+        const todos = await readTodoFile(todoPath);
+        return JSON.stringify(todos, null, 2);
+    };
+    return {
+        write: {
+            id: "chat_todowrite",
+            run: write,
+            tool: tool({
+                description: `Manage task list.
+
+Usage:
+- Use for multi-step tasks (3+ steps)
+- Only one task in_progress at a time
+- Mark tasks complete immediately after finishing
+- Skip for simple, single-step requests`,
+                args: {
+                    todos: tool.schema.array(todoSchema).describe("The updated todo list"),
+                },
+                async execute(args) {
+                    return await write(args);
+                },
+            }),
+        },
+        read: {
+            id: "chat_todoread",
+            run: read,
+            tool: tool({
+                description: `Read task list.
+
+Usage:
+- Check at start of conversations
+- Use before starting new tasks
+- Review after completing work`,
+                args: {},
+                async execute() {
+                    return await read();
+                },
+            }),
+        },
+    };
+}

package/dist/tools/write.d.ts

@@ -0,0 +1,19 @@
+export declare function createChatWrite(baseDir: string, repoRoot: string): {
+    id: string;
+    run: (args: {
+        content: string;
+        filePath: string;
+    }) => Promise<string>;
+    tool: {
+        description: string;
+        args: {
+            content: import("zod").ZodString;
+            filePath: import("zod").ZodString;
+        };
+        execute(args: {
+            content: string;
+            filePath: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=write.d.ts.map

package/dist/tools/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../tools/write.ts"],"names":[],"mappings":"AAUA,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;gBACtC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;EA2B/D"}

package/dist/tools/write.js

@@ -0,0 +1,37 @@
+/**
+ * chat_write tool implementation.
+ * Writes or overwrites files within the working directory.
+ * Creates parent directories when needed.
+ */
+import * as fs from "fs/promises";
+import path from "path";
+import { tool } from "@opencode-ai/plugin";
+import { resolvePath } from "../util/paths";
+export function createChatWrite(baseDir, repoRoot) {
+    const run = async (args) => {
+        const filePath = resolvePath(baseDir, args.filePath);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, args.content, "utf-8");
+        const title = path.relative(repoRoot, filePath);
+        return `Wrote ${title}`;
+    };
+    return {
+        id: "chat_write",
+        run,
+        tool: tool({
+            description: `Write file contents.
+
+Usage:
+- Overwrites existing files completely
+- Creates parent directories if needed
+- Use Edit tool for partial modifications`,
+            args: {
+                content: tool.schema.string().describe("The content to write to the file"),
+                filePath: tool.schema.string().describe("The absolute path to the file to write"),
+            },
+            async execute(args) {
+                return await run(args);
+            },
+        }),
+    };
+}

package/dist/util/constants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared constants for the chatifier plugin.
+ * Centralizes limits and defaults so tool modules stay consistent.
+ * Keep these values in sync with tool behavior as it evolves.
+ */
+export declare const DEFAULT_READ_LIMIT = 2000;
+export declare const MAX_LINE_LENGTH = 2000;
+export declare const LIST_LIMIT = 100;
+export declare const MAX_GREP_MATCHES = 100;
+export declare const MAX_OUTPUT_LENGTH = 30000;
+export declare const MAX_RESPONSE_SIZE: number;
+export declare const DEFAULT_WEBFETCH_TIMEOUT_MS = 30000;
+export declare const MAX_WEBFETCH_TIMEOUT_MS = 120000;
+export declare const TODO_FILENAME = "todo.md";
+export declare const IGNORE_DIRS: Set<string>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/util/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../util/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAA;AACtC,eAAO,MAAM,eAAe,OAAO,CAAA;AACnC,eAAO,MAAM,UAAU,MAAM,CAAA;AAC7B,eAAO,MAAM,gBAAgB,MAAM,CAAA;AACnC,eAAO,MAAM,iBAAiB,QAAS,CAAA;AACvC,eAAO,MAAM,iBAAiB,QAAkB,CAAA;AAChD,eAAO,MAAM,2BAA2B,QAAS,CAAA;AACjD,eAAO,MAAM,uBAAuB,SAAU,CAAA;AAC9C,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC,eAAO,MAAM,WAAW,aAwBtB,CAAA"}

package/dist/util/constants.js

@@ -0,0 +1,39 @@
+/**
+ * Shared constants for the chatifier plugin.
+ * Centralizes limits and defaults so tool modules stay consistent.
+ * Keep these values in sync with tool behavior as it evolves.
+ */
+export const DEFAULT_READ_LIMIT = 2000;
+export const MAX_LINE_LENGTH = 2000;
+export const LIST_LIMIT = 100;
+export const MAX_GREP_MATCHES = 100;
+export const MAX_OUTPUT_LENGTH = 30_000;
+export const MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+export const DEFAULT_WEBFETCH_TIMEOUT_MS = 30_000;
+export const MAX_WEBFETCH_TIMEOUT_MS = 120_000;
+export const TODO_FILENAME = "todo.md";
+export const IGNORE_DIRS = new Set([
+    "node_modules",
+    "__pycache__",
+    ".git",
+    "dist",
+    "build",
+    "target",
+    "vendor",
+    "bin",
+    "obj",
+    ".idea",
+    ".vscode",
+    ".zig-cache",
+    "zig-out",
+    ".coverage",
+    "coverage",
+    "tmp",
+    "temp",
+    ".cache",
+    "cache",
+    "logs",
+    ".venv",
+    "venv",
+    "env",
+]);

package/dist/util/patch.d.ts

@@ -0,0 +1,32 @@
+export type AddHunk = {
+    type: "add";
+    path: string;
+    contents: string;
+};
+export type DeleteHunk = {
+    type: "delete";
+    path: string;
+};
+export type UpdateHunk = {
+    type: "update";
+    path: string;
+    move_path?: string;
+    chunks: UpdateChunk[];
+};
+export type Hunk = AddHunk | DeleteHunk | UpdateHunk;
+export type UpdateChunk = {
+    old_lines: string[];
+    new_lines: string[];
+    change_context?: string;
+    is_end_of_file?: boolean;
+};
+export type AffectedPaths = {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+};
+export declare function parsePatch(patchText: string): {
+    hunks: Hunk[];
+};
+export declare function applyHunksToFiles(hunks: Hunk[]): Promise<AffectedPaths>;
+//# sourceMappingURL=patch.d.ts.map

package/dist/util/patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../../util/patch.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,OAAO,GAAG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AACrE,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AACzD,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,CAAA;AACpG,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAA;AAEpD,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AA+FD,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM;;EAqC3C;AAkGD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAqC7E"}

package/dist/util/patch.js

@@ -0,0 +1,240 @@
+/**
+ * Patch parsing and application utilities.
+ * Handles the *** Begin/End Patch format for file operations.
+ */
+import * as path from "path";
+import * as fs from "fs/promises";
+import * as fsSync from "fs";
+function parsePatchHeader(lines, idx) {
+    const line = lines[idx];
+    if (line.startsWith("*** Add File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        return filePath ? { filePath, nextIdx: idx + 1 } : null;
+    }
+    if (line.startsWith("*** Delete File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        return filePath ? { filePath, nextIdx: idx + 1 } : null;
+    }
+    if (line.startsWith("*** Update File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        let movePath;
+        let nextIdx = idx + 1;
+        if (nextIdx < lines.length && lines[nextIdx].startsWith("*** Move to:")) {
+            movePath = lines[nextIdx].split(":", 2)[1]?.trim();
+            nextIdx++;
+        }
+        return filePath ? { filePath, movePath, nextIdx } : null;
+    }
+    return null;
+}
+function parseUpdateChunks(lines, startIdx) {
+    const chunks = [];
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith("***")) {
+        if (lines[i].startsWith("@@")) {
+            const contextLine = lines[i].substring(2).trim();
+            i++;
+            const oldLines = [];
+            const newLines = [];
+            let isEndOfFile = false;
+            while (i < lines.length && !lines[i].startsWith("@@") && !lines[i].startsWith("***")) {
+                const changeLine = lines[i];
+                if (changeLine === "*** End of File") {
+                    isEndOfFile = true;
+                    i++;
+                    break;
+                }
+                if (changeLine.startsWith(" ")) {
+                    const content = changeLine.substring(1);
+                    oldLines.push(content);
+                    newLines.push(content);
+                }
+                else if (changeLine.startsWith("-")) {
+                    oldLines.push(changeLine.substring(1));
+                }
+                else if (changeLine.startsWith("+")) {
+                    newLines.push(changeLine.substring(1));
+                }
+                i++;
+            }
+            chunks.push({
+                old_lines: oldLines,
+                new_lines: newLines,
+                change_context: contextLine || undefined,
+                is_end_of_file: isEndOfFile || undefined,
+            });
+        }
+        else {
+            i++;
+        }
+    }
+    return { chunks, nextIdx: i };
+}
+function parseAddContent(lines, startIdx) {
+    let content = "";
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith("***")) {
+        if (lines[i].startsWith("+")) {
+            content += lines[i].substring(1) + "\n";
+        }
+        i++;
+    }
+    if (content.endsWith("\n"))
+        content = content.slice(0, -1);
+    return { content, nextIdx: i };
+}
+export function parsePatch(patchText) {
+    const lines = patchText.split("\n");
+    const hunks = [];
+    const beginIdx = lines.findIndex((line) => line.trim() === "*** Begin Patch");
+    const endIdx = lines.findIndex((line) => line.trim() === "*** End Patch");
+    if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
+        throw new Error("Invalid patch format: missing Begin/End markers");
+    }
+    let i = beginIdx + 1;
+    while (i < endIdx) {
+        const header = parsePatchHeader(lines, i);
+        if (!header) {
+            i++;
+            continue;
+        }
+        if (lines[i].startsWith("*** Add File:")) {
+            const { content, nextIdx } = parseAddContent(lines, header.nextIdx);
+            hunks.push({ type: "add", path: header.filePath, contents: content });
+            i = nextIdx;
+        }
+        else if (lines[i].startsWith("*** Delete File:")) {
+            hunks.push({ type: "delete", path: header.filePath });
+            i = header.nextIdx;
+        }
+        else if (lines[i].startsWith("*** Update File:")) {
+            const { chunks, nextIdx } = parseUpdateChunks(lines, header.nextIdx);
+            hunks.push({ type: "update", path: header.filePath, move_path: header.movePath, chunks });
+            i = nextIdx;
+        }
+        else {
+            i++;
+        }
+    }
+    return { hunks };
+}
+function seekSequence(lines, pattern, startIndex) {
+    if (pattern.length === 0)
+        return -1;
+    for (let i = startIndex; i <= lines.length - pattern.length; i++) {
+        let matches = true;
+        for (let j = 0; j < pattern.length; j++) {
+            if (lines[i + j] !== pattern[j]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return i;
+    }
+    return -1;
+}
+function computeReplacements(originalLines, filePath, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        let contextIdx = -1;
+        if (chunk.change_context) {
+            contextIdx = seekSequence(originalLines, [chunk.change_context], lineIndex);
+            if (contextIdx === -1) {
+                throw new Error(`Failed to find context '${chunk.change_context}' in ${filePath}`);
+            }
+            lineIndex = contextIdx;
+        }
+        if (chunk.old_lines.length === 0) {
+            if (chunk.change_context && contextIdx !== -1) {
+                replacements.push([contextIdx, 1, chunk.new_lines]);
+            }
+            else {
+                replacements.push([originalLines.length, 0, chunk.new_lines]);
+            }
+            continue;
+        }
+        let pattern = chunk.old_lines;
+        let newSlice = chunk.new_lines;
+        let found = seekSequence(originalLines, pattern, lineIndex);
+        if (found === -1 && pattern.length > 0 && pattern[pattern.length - 1] === "") {
+            pattern = pattern.slice(0, -1);
+            if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
+                newSlice = newSlice.slice(0, -1);
+            }
+            found = seekSequence(originalLines, pattern, lineIndex);
+        }
+        if (found !== -1) {
+            replacements.push([found, pattern.length, newSlice]);
+            lineIndex = found + pattern.length;
+        }
+        else {
+            throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.old_lines.join("\n")}`);
+        }
+    }
+    replacements.sort((a, b) => a[0] - b[0]);
+    return replacements;
+}
+function applyReplacements(lines, replacements) {
+    const result = [...lines];
+    for (let i = replacements.length - 1; i >= 0; i--) {
+        const [startIdx, oldLen, newSegment] = replacements[i];
+        result.splice(startIdx, oldLen);
+        for (let j = 0; j < newSegment.length; j++) {
+            result.splice(startIdx + j, 0, newSegment[j]);
+        }
+    }
+    return result;
+}
+function deriveNewContents(filePath, chunks) {
+    const originalContent = fsSync.readFileSync(filePath, "utf-8");
+    let originalLines = originalContent.split("\n");
+    if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
+        originalLines.pop();
+    }
+    const replacements = computeReplacements(originalLines, filePath, chunks);
+    const newLines = applyReplacements(originalLines, replacements);
+    if (newLines.length === 0 || newLines[newLines.length - 1] !== "") {
+        newLines.push("");
+    }
+    return newLines.join("\n");
+}
+export async function applyHunksToFiles(hunks) {
+    if (hunks.length === 0)
+        throw new Error("No files were modified.");
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    for (const hunk of hunks) {
+        if (hunk.type === "add") {
+            const dir = path.dirname(hunk.path);
+            if (dir !== "." && dir !== "/") {
+                await fs.mkdir(dir, { recursive: true });
+            }
+            await fs.writeFile(hunk.path, hunk.contents, "utf-8");
+            added.push(hunk.path);
+        }
+        else if (hunk.type === "delete") {
+            await fs.unlink(hunk.path);
+            deleted.push(hunk.path);
+        }
+        else if (hunk.type === "update") {
+            const content = deriveNewContents(hunk.path, hunk.chunks);
+            if (hunk.move_path) {
+                const dir = path.dirname(hunk.move_path);
+                if (dir !== "." && dir !== "/") {
+                    await fs.mkdir(dir, { recursive: true });
+                }
+                await fs.writeFile(hunk.move_path, content, "utf-8");
+                await fs.unlink(hunk.path);
+                modified.push(hunk.move_path);
+            }
+            else {
+                await fs.writeFile(hunk.path, content, "utf-8");
+                modified.push(hunk.path);
+            }
+        }
+    }
+    return { added, modified, deleted };
+}

package/dist/util/paths.d.ts

@@ -0,0 +1,6 @@
+export declare function resolvePath(baseDir: string, inputPath: string): string;
+export declare function isBlockedEnvPath(filePath: string): boolean;
+export declare function isBinaryExtension(filePath: string): boolean;
+export declare function isImageExtension(filePath: string): boolean;
+export declare function isBinaryFile(filePath: string): Promise<boolean>;
+//# sourceMappingURL=paths.d.ts.map

package/dist/util/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../util/paths.ts"],"names":[],"mappings":"AAOA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAO7D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,WAGhD;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,WAgCjD;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,WAGhD;AAED,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,oBAelD"}