@sean.holung/minicode 0.1.0

package/dist/src/model/client.js

@@ -0,0 +1,374 @@
+import process from "node:process";
+import { setTimeout as sleep } from "node:timers/promises";
+import Anthropic from "@anthropic-ai/sdk";
+function toAnthropicMessages(messages) {
+    const converted = [];
+    for (const message of messages) {
+        if (message.role === "user") {
+            converted.push({
+                role: "user",
+                content: message.content,
+            });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const content = [];
+            if (message.content.trim().length > 0) {
+                content.push({
+                    type: "text",
+                    text: message.content,
+                });
+            }
+            for (const toolCall of message.toolCalls ?? []) {
+                content.push({
+                    type: "tool_use",
+                    id: toolCall.id,
+                    name: toolCall.name,
+                    input: toolCall.input,
+                });
+            }
+            converted.push({
+                role: "assistant",
+                content: content.length > 0 ? content : "",
+            });
+            continue;
+        }
+        converted.push({
+            role: "user",
+            content: [
+                {
+                    type: "tool_result",
+                    tool_use_id: message.toolCallId,
+                    content: message.content,
+                },
+            ],
+        });
+    }
+    return converted;
+}
+function parseResponse(response) {
+    const textParts = [];
+    const toolCalls = [];
+    for (const block of response.content) {
+        if (block.type === "text") {
+            textParts.push(block.text);
+            continue;
+        }
+        if (block.type === "tool_use") {
+            toolCalls.push({
+                id: block.id,
+                name: block.name,
+                input: block.input,
+            });
+        }
+    }
+    return {
+        text: textParts.join("\n").trim(),
+        toolCalls,
+        stopReason: response.stop_reason === "tool_use"
+            ? "tool_use"
+            : response.stop_reason === "max_tokens"
+                ? "max_tokens"
+                : "end_turn",
+        usage: {
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+        },
+    };
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+async function withRetry(fn, attempts = 3) {
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (isAbortError(error)) {
+                throw error;
+            }
+            if (attempt === attempts) {
+                break;
+            }
+            const delayMs = 500 * 2 ** (attempt - 1);
+            await sleep(delayMs);
+        }
+    }
+    throw lastError;
+}
+function toOpenAICompatibleMessages(system, messages) {
+    const converted = [
+        {
+            role: "system",
+            content: system,
+        },
+    ];
+    for (const message of messages) {
+        if (message.role === "user") {
+            converted.push({
+                role: "user",
+                content: message.content,
+            });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const toolCalls = message.toolCalls?.map((toolCall) => ({
+                id: toolCall.id,
+                type: "function",
+                function: {
+                    name: toolCall.name,
+                    arguments: JSON.stringify(toolCall.input),
+                },
+            }));
+            converted.push({
+                role: "assistant",
+                content: message.content.length > 0 ? message.content : null,
+                ...(toolCalls ? { tool_calls: toolCalls } : {}),
+            });
+            continue;
+        }
+        converted.push({
+            role: "tool",
+            tool_call_id: message.toolCallId,
+            content: message.content,
+        });
+    }
+    return converted;
+}
+function toOpenAICompatibleTools(tools) {
+    return tools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema,
+        },
+    }));
+}
+function parseOpenAICompatibleToolArguments(rawArguments) {
+    try {
+        const parsed = JSON.parse(rawArguments);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Fall back to empty object when model emits malformed function arguments.
+    }
+    return {};
+}
+function parseOpenAICompatibleResponse(response) {
+    const firstChoice = response.choices?.[0];
+    const message = firstChoice?.message;
+    if (!message) {
+        throw new Error("OpenAI-compatible response missing choices[0].message.");
+    }
+    const toolCalls = message.tool_calls?.map((toolCall, index) => ({
+        id: toolCall.id || `tool-call-${index + 1}`,
+        name: toolCall.function.name,
+        input: parseOpenAICompatibleToolArguments(toolCall.function.arguments),
+    })) ?? [];
+    const finishReason = firstChoice?.finish_reason ?? null;
+    const stopReason = finishReason === "tool_calls" || finishReason === "function_call"
+        ? "tool_use"
+        : finishReason === "length"
+            ? "max_tokens"
+            : toolCalls.length > 0
+                ? "tool_use"
+                : "end_turn";
+    return {
+        text: (message.content ?? "").trim(),
+        toolCalls,
+        stopReason,
+        usage: {
+            inputTokens: response.usage?.prompt_tokens ?? 0,
+            outputTokens: response.usage?.completion_tokens ?? 0,
+        },
+    };
+}
+function normalizeBaseUrl(baseUrl) {
+    const trimmed = baseUrl.trim().replace(/\/+$/, "");
+    if (trimmed.length === 0) {
+        throw new Error("OPENAI_BASE_URL cannot be empty.");
+    }
+    return trimmed;
+}
+export class AnthropicModelClient {
+    client;
+    constructor(apiKey = process.env.ANTHROPIC_API_KEY) {
+        if (!apiKey) {
+            throw new Error("Missing ANTHROPIC_API_KEY. Copy .env.example to .env and set a key.");
+        }
+        this.client = new Anthropic({ apiKey });
+    }
+    async chat(params) {
+        const response = await withRetry(() => this.client.messages.create({
+            model: params.model,
+            max_tokens: params.maxTokens,
+            system: params.system,
+            messages: toAnthropicMessages(params.messages),
+            tools: params.tools,
+            stream: false,
+        }));
+        return parseResponse(response);
+    }
+}
+async function parseOpenAIStream(reader, onStream) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let content = "";
+    const toolCallsAcc = [];
+    const usage = { prompt_tokens: 0, completion_tokens: 0 };
+    let finishReason = null;
+    const processLines = (lines) => {
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data: "))
+                continue;
+            const data = trimmed.slice(6).trim();
+            if (data === "[DONE]")
+                continue;
+            try {
+                const chunk = JSON.parse(data);
+                const choice = chunk.choices?.[0];
+                if (!choice)
+                    continue;
+                const delta = choice.delta;
+                if (delta?.content) {
+                    content += delta.content;
+                    onStream?.(delta.content);
+                }
+                if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = tc.index ?? 0;
+                        if (!toolCallsAcc[idx]) {
+                            toolCallsAcc[idx] = { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: tc.function?.arguments ?? "" };
+                        }
+                        else {
+                            if (tc.id)
+                                toolCallsAcc[idx].id = tc.id;
+                            if (tc.function?.name)
+                                toolCallsAcc[idx].name = tc.function.name;
+                            if (tc.function?.arguments)
+                                toolCallsAcc[idx].arguments += tc.function.arguments;
+                        }
+                    }
+                }
+                if (choice.finish_reason)
+                    finishReason = choice.finish_reason;
+                if (chunk.usage) {
+                    usage.prompt_tokens = chunk.usage.prompt_tokens ?? 0;
+                    usage.completion_tokens = chunk.usage.completion_tokens ?? 0;
+                }
+            }
+            catch {
+                // skip malformed chunks
+            }
+        }
+    };
+    while (true) {
+        const { done, value } = await reader.read();
+        if (value) {
+            buffer += decoder.decode(value, { stream: true });
+        }
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        processLines(lines);
+        if (done) {
+            if (buffer.trim())
+                processLines([buffer]);
+            break;
+        }
+    }
+    const toolCalls = toolCallsAcc
+        .filter((tc) => tc.id || tc.name)
+        .map((tc, i) => ({
+        id: tc.id || `tool-call-${i + 1}`,
+        name: tc.name,
+        input: parseOpenAICompatibleToolArguments(tc.arguments),
+    }));
+    const stopReason = finishReason === "tool_calls" || finishReason === "function_call"
+        ? "tool_use"
+        : finishReason === "length"
+            ? "max_tokens"
+            : toolCalls.length > 0
+                ? "tool_use"
+                : "end_turn";
+    return {
+        text: content.trim(),
+        toolCalls,
+        stopReason,
+        usage: { inputTokens: usage.prompt_tokens, outputTokens: usage.completion_tokens },
+    };
+}
+export class OpenAICompatibleModelClient {
+    baseUrl;
+    apiKey;
+    fetchImpl;
+    constructor(params) {
+        this.baseUrl = normalizeBaseUrl(params?.baseUrl ?? process.env.OPENAI_BASE_URL ?? "http://localhost:1234/v1");
+        const isOpenRouter = this.baseUrl.includes("openrouter");
+        this.apiKey =
+            params?.apiKey ??
+                (isOpenRouter
+                    ? process.env.OPENROUTER_API_KEY ?? process.env.OPENAI_API_KEY
+                    : process.env.OPENAI_API_KEY);
+        this.fetchImpl = params?.fetchImpl ?? fetch;
+    }
+    async chat(params) {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        const apiKey = this.apiKey?.trim();
+        if (apiKey && apiKey.length > 0) {
+            if (this.baseUrl.includes("openrouter") &&
+                apiKey.startsWith("sk-proj-")) {
+                throw new Error("OpenRouter requires an OpenRouter API key (sk-or-v1-...), not an OpenAI key (sk-proj-...). Get one at https://openrouter.ai/keys");
+            }
+            headers.Authorization = `Bearer ${apiKey}`;
+        }
+        else if (this.baseUrl.includes("openrouter")) {
+            throw new Error("Missing OpenRouter API key. Set OPENAI_API_KEY or OPENROUTER_API_KEY in .env. Get one at https://openrouter.ai/keys");
+        }
+        const useStream = params.onStream !== undefined;
+        const response = await withRetry(async () => {
+            const httpResponse = await this.fetchImpl(`${this.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    model: params.model,
+                    messages: toOpenAICompatibleMessages(params.system, params.messages),
+                    tools: toOpenAICompatibleTools(params.tools),
+                    tool_choice: "auto",
+                    max_tokens: params.maxTokens,
+                    stream: useStream,
+                }),
+                ...(params.signal && { signal: params.signal }),
+            });
+            if (!httpResponse.ok) {
+                const bodyText = await httpResponse.text();
+                throw new Error(`OpenAI-compatible request failed (${httpResponse.status}): ${bodyText}`);
+            }
+            if (useStream && httpResponse.body) {
+                return parseOpenAIStream(httpResponse.body.getReader(), params.onStream);
+            }
+            const payload = (await httpResponse.json());
+            return parseOpenAICompatibleResponse(payload);
+        });
+        return response;
+    }
+}
+export function createModelClient(config) {
+    if (config.modelProvider === "openai-compatible") {
+        return new OpenAICompatibleModelClient({
+            baseUrl: config.openAiBaseUrl,
+            ...(config.openAiApiKey !== undefined
+                ? { apiKey: config.openAiApiKey }
+                : {}),
+        });
+    }
+    return new AnthropicModelClient();
+}

package/dist/src/prompt/system-prompt.js

@@ -0,0 +1,91 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+function detectProjectType(workspaceRoot) {
+    const checks = [
+        { file: "package.json", type: "Node.js / TypeScript" },
+        { file: "pyproject.toml", type: "Python" },
+        { file: "requirements.txt", type: "Python" },
+        { file: "go.mod", type: "Go" },
+        { file: "Cargo.toml", type: "Rust" },
+        { file: "pom.xml", type: "Java (Maven)" },
+    ];
+    for (const check of checks) {
+        if (existsSync(path.join(workspaceRoot, check.file))) {
+            return check.type;
+        }
+    }
+    return "Unknown";
+}
+function renderToolList(tools) {
+    return tools
+        .map((tool) => `- ${tool.name}: ${tool.description}`)
+        .join("\n");
+}
+function hasTool(tools, name) {
+    return tools.some((t) => t.name === name);
+}
+export function buildSystemPrompt(config, tools, codeMapResult) {
+    const projectType = detectProjectType(config.workspaceRoot);
+    const sections = [
+        "[Identity]",
+        "You are a coding agent. You help developers read, understand, and modify code in their projects.",
+        "",
+        "[Workspace Context]",
+        `Working directory: ${config.workspaceRoot}`,
+        `Project type: ${projectType}`,
+        "",
+    ];
+    const hasSearchCodeMap = hasTool(tools, "search_code_map");
+    if (codeMapResult && codeMapResult.text.length > 0) {
+        sections.push("[Project Code Map]", codeMapResult.text, "");
+        const truncated = codeMapResult.totalCount > 0 &&
+            codeMapResult.shownCount < codeMapResult.totalCount;
+        if (truncated) {
+            const hint = hasSearchCodeMap
+                ? " Use search_code_map to find symbols not listed above."
+                : "";
+            sections.push(`Showing ${codeMapResult.shownCount} of ${codeMapResult.totalCount} symbols.${hint}`, "");
+        }
+    }
+    const hasReadSymbol = hasTool(tools, "read_symbol");
+    const hasFindRefs = hasTool(tools, "find_references");
+    const hasGetDeps = hasTool(tools, "get_dependencies");
+    const hasSpecializedTools = hasReadSymbol || hasFindRefs || hasGetDeps || hasSearchCodeMap;
+    const toolGuidelines = [
+        "[Tool Usage Guidelines]",
+        "- Always read a file before editing it.",
+        "- Prefer edit_file over write_file for existing files.",
+        "- Run tests or lint after code changes when applicable.",
+        "- Default to using preferred tools when doing planning, code exploration, or investigation."
+    ];
+    if (hasSpecializedTools) {
+        toolGuidelines.push("", "[Code exploration PREFERRED TOOLS — prefer these over read_file and search]", ...(hasReadSymbol
+            ? [
+                "- PREFER read_symbol over read_file for .ts/.tsx/.js/.jsx when you need a function or class. The code map lists all symbols; use read_symbol(name) for targeted reads — it returns only the relevant code and avoids bloating context.",
+                "- Use read_file only for config files, small files, non-code files, or when the symbol name is unknown.",
+            ]
+            : []), ...(hasFindRefs
+            ? [
+                "- Use find_references to see what calls or uses a symbol — essential for understanding impact before changes.",
+            ]
+            : []), ...(hasGetDeps
+            ? [
+                "- Use get_dependencies to see what a symbol depends on — essential for understanding implementation and data flow.",
+            ]
+            : []), "- Use search only when you don't know the symbol name; once you find a symbol in the code map or search results, use read_symbol (not read_file) to read it.", "- When tracing code: use get_dependencies to go inward (what does X call?), find_references to go outward (what calls X?).", ...(hasSearchCodeMap
+            ? [
+                "- PREFER search_code_map over search. When the code map is truncated, use search_code_map to find symbols by name or substring — then use read_symbol with the result.",
+            ]
+            : []));
+    }
+    else {
+        toolGuidelines.push("", "- Use read_file with offset and limit for large files to read only needed portions.", "- Use search to find relevant code before making changes.");
+    }
+    sections.push("[Tool Descriptions]", "You have the following tools available:", renderToolList(tools), "", ...toolGuidelines, "", "[Code Reading Strategy]", "- Start with entry points (e.g. index.ts, main) and follow the flow.", ...(hasSpecializedTools
+        ? [
+            "- Use find_references to see who uses a symbol; use get_dependencies to see what it calls.",
+            "- Trace usage outward (find_references) or implementation inward (get_dependencies) as needed.",
+        ]
+        : ["- Use search to locate relevant code, then read_file to inspect it."]), "", "[Termination Policy]", "- When the user asks you to do something (edit code, search, run commands, etc.), you MUST use the appropriate tools first. Do not conclude until you have actually performed the work.", "- When the task is complete, respond with a concise summary of what you changed.", "- If you cannot complete the task, explain what is blocking you.", "- Do not respond with empty text. Always provide a summary or explanation.", "- Do not continue exploring once the task is done.", "", "[Safety Rules]", "- Never modify files outside the workspace directory.", "- Never run destructive commands without explicit user confirmation.", "- Ask for clarification if user intent is ambiguous.", "- When asked to perform a task, communicate your execution plan to the user and ask for their confirmation before proceeding with any modifications.");
+    return sections.join("\n");
+}

package/dist/src/safety/guardrails.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+const DESTRUCTIVE_COMMAND_PATTERNS = [
+    /\brm\s+-rf\b/i,
+    /\bmv\b.+\s+\/dev\/null\b/i,
+    /\bgit\s+reset\s+--hard\b/i,
+    /\bgit\s+clean\s+-fdx?\b/i,
+];
+export function normalizeWorkspaceRoot(workspaceRoot) {
+    return path.resolve(workspaceRoot);
+}
+export function resolveWorkspacePath(requestedPath, workspaceRoot) {
+    const normalizedRoot = normalizeWorkspaceRoot(workspaceRoot);
+    const absolutePath = path.resolve(normalizedRoot, requestedPath);
+    if (!isWithinWorkspacePath(absolutePath, normalizedRoot)) {
+        throw new Error(`Path "${requestedPath}" resolves outside workspace root "${normalizedRoot}".`);
+    }
+    return absolutePath;
+}
+export function isWithinWorkspacePath(absolutePath, workspaceRoot) {
+    const normalizedRoot = normalizeWorkspaceRoot(workspaceRoot);
+    const relative = path.relative(normalizedRoot, absolutePath);
+    if (relative === "") {
+        return true;
+    }
+    return !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+export function validatePath(requestedPath, workspaceRoot) {
+    try {
+        resolveWorkspacePath(requestedPath, workspaceRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function validateCommand(command, denylist) {
+    for (const pattern of denylist) {
+        if (pattern.test(command)) {
+            throw new Error(`Command "${command}" blocked by safety denylist (${pattern}).`);
+        }
+    }
+}
+export function isDestructiveCommand(command) {
+    return DESTRUCTIVE_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+}
+export function ensureStepWithinLimit(step, maxSteps) {
+    if (step >= maxSteps) {
+        throw new Error(`Reached maximum step limit (${maxSteps}). Stopping tool loop.`);
+    }
+}
+export function validateFileReadSize(actualSizeBytes, maxFileSizeBytes) {
+    if (actualSizeBytes > maxFileSizeBytes) {
+        throw new Error(`File too large to read (${actualSizeBytes} bytes). Limit is ${maxFileSizeBytes} bytes.`);
+    }
+}

package/dist/src/session/session.js

@@ -0,0 +1,95 @@
+import { randomUUID } from "node:crypto";
+function estimateMessageTokens(message) {
+    if (message.role === "tool") {
+        return Math.ceil((message.toolName.length + message.content.length) / 4);
+    }
+    const toolCallTokens = message.role === "assistant" && message.toolCalls?.length
+        ? Math.ceil(JSON.stringify(message.toolCalls).length / 4)
+        : 0;
+    return Math.ceil(message.content.length / 4) + toolCallTokens;
+}
+export class Session {
+    id;
+    createdAt;
+    messages;
+    constructor(id = randomUUID()) {
+        this.id = id;
+        this.createdAt = new Date();
+        this.messages = [];
+    }
+    addMessage(message) {
+        this.messages.push(message);
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    getTokenEstimate() {
+        return this.messages.reduce((total, message) => total + estimateMessageTokens(message), 0);
+    }
+    trim(maxTokens, keepRecentMessages) {
+        if (keepRecentMessages < 0) {
+            return;
+        }
+        while (this.getTokenEstimate() > maxTokens &&
+            this.messages.length > keepRecentMessages) {
+            const protectedStart = this.getProtectedStart(keepRecentMessages);
+            if (protectedStart <= 0) {
+                return;
+            }
+            const removed = this.removeOldestChunk(protectedStart);
+            if (!removed) {
+                return;
+            }
+        }
+    }
+    getProtectedStart(keepRecentMessages) {
+        let protectedStart = Math.max(0, this.messages.length - keepRecentMessages);
+        const boundaryMessage = this.messages[protectedStart];
+        if (!boundaryMessage || boundaryMessage.role !== "tool") {
+            return protectedStart;
+        }
+        while (protectedStart > 0 &&
+            this.messages[protectedStart - 1]?.role === "tool") {
+            protectedStart -= 1;
+        }
+        const potentialToolCallMessage = this.messages[protectedStart - 1];
+        if (potentialToolCallMessage?.role === "assistant" &&
+            potentialToolCallMessage.toolCalls?.length) {
+            protectedStart -= 1;
+        }
+        return protectedStart;
+    }
+    removeOldestChunk(removableCount) {
+        if (removableCount <= 0 || this.messages.length === 0) {
+            return false;
+        }
+        const first = this.messages[0];
+        if (!first) {
+            return false;
+        }
+        if (first.role === "assistant" && first.toolCalls?.length) {
+            let removeCount = 1;
+            while (this.messages[removeCount]?.role === "tool") {
+                removeCount += 1;
+            }
+            if (removeCount > removableCount) {
+                return false;
+            }
+            this.messages.splice(0, removeCount);
+            return true;
+        }
+        if (first.role === "tool") {
+            let removeCount = 1;
+            while (this.messages[removeCount]?.role === "tool") {
+                removeCount += 1;
+            }
+            if (removeCount > removableCount) {
+                return false;
+            }
+            this.messages.splice(0, removeCount);
+            return true;
+        }
+        this.messages.splice(0, 1);
+        return true;
+    }
+}

package/dist/src/tools/edit-file.js

@@ -0,0 +1,73 @@
+import path from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { resolveWorkspacePath } from "../safety/guardrails.js";
+import { expectNonEmptyString } from "./helpers.js";
+function expectString(input, key) {
+    const value = input[key];
+    if (typeof value !== "string") {
+        throw new Error(`Input "${key}" must be a string.`);
+    }
+    return value;
+}
+function countOccurrences(haystack, needle) {
+    if (needle.length === 0) {
+        return 0;
+    }
+    let count = 0;
+    let index = 0;
+    while (true) {
+        const found = haystack.indexOf(needle, index);
+        if (found === -1) {
+            break;
+        }
+        count += 1;
+        index = found + needle.length;
+    }
+    return count;
+}
+export function createEditFileTool(config, projectIndex) {
+    return {
+        name: "edit_file",
+        description: "Replace exactly one instance of old_string with new_string in a file.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Path to file relative to workspace root.",
+                },
+                old_string: {
+                    type: "string",
+                    description: "Exact text to replace (must match once).",
+                },
+                new_string: {
+                    type: "string",
+                    description: "Replacement text.",
+                },
+            },
+            required: ["path", "old_string", "new_string"],
+            additionalProperties: false,
+        },
+        execute: async (input) => {
+            const requestedPath = expectNonEmptyString(input, "path");
+            const oldString = expectNonEmptyString(input, "old_string");
+            const newString = expectString(input, "new_string");
+            const filePath = resolveWorkspacePath(requestedPath, config.workspaceRoot);
+            const current = await readFile(filePath, "utf8");
+            const occurrences = countOccurrences(current, oldString);
+            if (occurrences === 0) {
+                throw new Error(`old_string was not found in "${requestedPath}".`);
+            }
+            if (occurrences > 1) {
+                throw new Error(`old_string matched ${occurrences} times in "${requestedPath}". It must be unique.`);
+            }
+            const updated = current.replace(oldString, newString);
+            await writeFile(filePath, updated, "utf8");
+            if (projectIndex) {
+                const relPath = path.relative(config.workspaceRoot, filePath);
+                projectIndex.reindexFile(relPath, updated);
+            }
+            return `Updated "${requestedPath}" successfully.`;
+        },
+    };
+}