nolo-cli 0.1.23 → 0.1.29

package/server/handlers/applyEditHandler.ts

@@ -0,0 +1,544 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { file as bunFile, write as bunWrite } from "bun";
+import { diffLines } from "diff";
+
+import {
+    buildTypeCheckFailureResponse,
+    ensurePositiveInt,
+    performTypeCheck,
+    resolveSafePath,
+} from "./applyLineEditsHandler";
+
+type EditMatchOptions = {
+    occurrence?: number;
+    expectedMatches?: number;
+    replaceAll?: boolean;
+};
+
+type ReplaceEdit = EditMatchOptions & {
+    type: "replace";
+    oldText: string;
+    newText: string;
+};
+
+type InsertBeforeEdit = EditMatchOptions & {
+    type: "insertBefore";
+    anchor: string;
+    content: string;
+    newText?: string;
+};
+
+type InsertAfterEdit = EditMatchOptions & {
+    type: "insertAfter";
+    anchor: string;
+    content: string;
+    newText?: string;
+};
+
+type DeleteEdit = EditMatchOptions & {
+    type: "delete";
+    oldText: string;
+};
+
+type TextEdit = ReplaceEdit | InsertBeforeEdit | InsertAfterEdit | DeleteEdit;
+type LegacyReplaceEdit = EditMatchOptions & {
+    type?: undefined;
+    oldText: string;
+    newText: string;
+};
+type IncomingTextEdit = TextEdit | LegacyReplaceEdit;
+
+interface ApplyEditRequestBody {
+    filePath: string;
+    edits: IncomingTextEdit[];
+}
+
+type EditApplicationSummary = {
+    type: TextEdit["type"];
+    matchCount: number;
+    appliedCount: number;
+};
+
+const JSON_HEADERS = {
+    "Content-Type": "application/json; charset=utf-8",
+    "Access-Control-Allow-Origin": "*",
+};
+const MAX_DIFF_PREVIEW_PARTS = 12;
+
+function createValidationError(message: string): Error {
+    return Object.assign(new Error(message), { isValidation: true });
+}
+
+function normalizeText(text: string): string {
+    return text.indexOf("\r\n") >= 0 ? text.replace(/\r\n/g, "\n") : text;
+}
+
+function ensureNonEmptyString(value: unknown, name: string): string {
+    if (typeof value !== "string" || value.length === 0) {
+        throw createValidationError(`${name} must be a non-empty string`);
+    }
+    return value;
+}
+
+function ensureString(value: unknown, name: string): string {
+    if (typeof value !== "string") {
+        throw createValidationError(`${name} must be a string`);
+    }
+    return value;
+}
+
+function summarizeDiff(diff: ReturnType<typeof diffLines>) {
+    let addedLines = 0;
+    let removedLines = 0;
+    const preview = diff.slice(0, MAX_DIFF_PREVIEW_PARTS).map((part) => {
+        const lineCount = part.value.split("\n").filter(Boolean).length;
+        if (part.added) addedLines += lineCount;
+        if (part.removed) removedLines += lineCount;
+        return {
+            type: part.added ? "added" : part.removed ? "removed" : "context",
+            lineCount,
+            preview: part.value.slice(0, 240),
+        };
+    });
+
+    return {
+        addedLines,
+        removedLines,
+        preview,
+        truncated: diff.length > MAX_DIFF_PREVIEW_PARTS,
+    };
+}
+
+function findExactMatchIndexes(text: string, needle: string): number[] {
+    const matches: number[] = [];
+    let fromIndex = 0;
+
+    while (fromIndex <= text.length) {
+        const index = text.indexOf(needle, fromIndex);
+        if (index === -1) break;
+        matches.push(index);
+        fromIndex = index + needle.length;
+    }
+
+    return matches;
+}
+
+function selectMatchIndexes(
+    allMatches: number[],
+    options: EditMatchOptions,
+    label: string
+): number[] {
+    const matchCount = allMatches.length;
+    if (matchCount === 0) {
+        throw createValidationError(`${label} was not found in file`);
+    }
+
+    const expectedMatches =
+        options.expectedMatches == null
+            ? undefined
+            : ensurePositiveInt(options.expectedMatches, "expectedMatches");
+    if (expectedMatches != null && matchCount !== expectedMatches) {
+        throw createValidationError(
+            `${label} matched ${matchCount} times, expected ${expectedMatches}`
+        );
+    }
+
+    if (options.replaceAll === true) {
+        return allMatches;
+    }
+
+    if (options.occurrence != null) {
+        const occurrence = ensurePositiveInt(options.occurrence, "occurrence");
+        const chosen = allMatches[occurrence - 1];
+        if (chosen == null) {
+            throw createValidationError(
+                `${label} occurrence ${occurrence} is out of range; only ${matchCount} matches found`
+            );
+        }
+        return [chosen];
+    }
+
+    if (matchCount > 1) {
+        throw createValidationError(
+            `${label} matched ${matchCount} times. Please provide more context, set occurrence, or use replaceAll`
+        );
+    }
+
+    return [allMatches[0]];
+}
+
+function normalizeIncomingEdit(edit: IncomingTextEdit): TextEdit {
+    if (edit && typeof edit === "object") {
+        const rawEdit = edit as any;
+        if (
+            typeof rawEdit.originalSnippet === "string" &&
+            typeof rawEdit.newText === "string" &&
+            (rawEdit.replaceRange || rawEdit.replaceAll === true)
+        ) {
+            return {
+                ...edit,
+                type: "replace",
+                oldText: rawEdit.originalSnippet,
+                replaceAll: rawEdit.replaceAll === true,
+            } as TextEdit;
+        }
+        if (
+            typeof rawEdit.insertAfter === "string" &&
+            typeof rawEdit.newText === "string"
+        ) {
+            return {
+                ...edit,
+                type: "insertAfter",
+                anchor: rawEdit.insertAfter,
+                content: rawEdit.newText,
+            } as TextEdit;
+        }
+        if (
+            typeof rawEdit.insertBefore === "string" &&
+            typeof rawEdit.newText === "string"
+        ) {
+            return {
+                ...edit,
+                type: "insertBefore",
+                anchor: rawEdit.insertBefore,
+                content: rawEdit.newText,
+            } as TextEdit;
+        }
+    }
+
+    if (edit && typeof edit === "object" && typeof edit.type === "string") {
+        if (
+            edit.type === "replaceRange" &&
+            typeof (edit as any).oldText === "string" &&
+            typeof (edit as any).newText === "string"
+        ) {
+            return {
+                ...edit,
+                type: "replace",
+            } as TextEdit;
+        }
+        if (
+            edit.type === "deleteRange" &&
+            typeof (edit as any).oldText === "string"
+        ) {
+            return {
+                ...edit,
+                type: "delete",
+            } as TextEdit;
+        }
+        if (
+            (edit.type === "insertBefore" || edit.type === "insertAfter") &&
+            typeof (edit as any).content !== "string" &&
+            typeof (edit as any).newText === "string"
+        ) {
+            return {
+                ...edit,
+                content: (edit as any).newText,
+            } as TextEdit;
+        }
+        return edit;
+    }
+
+    if (
+        edit &&
+        typeof edit === "object" &&
+        typeof (edit as LegacyReplaceEdit).oldText === "string" &&
+        typeof (edit as LegacyReplaceEdit).newText === "string"
+    ) {
+        return {
+            ...edit,
+            type: "replace",
+        };
+    }
+
+    throw createValidationError(
+        `Unsupported edit type: ${(edit as { type?: string } | null | undefined)?.type}`
+    );
+}
+
+function applySingleTextEdit(
+    text: string,
+    incomingEdit: IncomingTextEdit
+): { text: string; summary: EditApplicationSummary } {
+    const edit = normalizeIncomingEdit(incomingEdit);
+
+    switch (edit.type) {
+        case "replace": {
+            const oldText = normalizeText(ensureNonEmptyString(edit.oldText, "oldText"));
+            const newText = normalizeText(ensureString(edit.newText, "newText"));
+            const matches = findExactMatchIndexes(text, oldText);
+            const selected = selectMatchIndexes(matches, edit, "oldText");
+
+            let nextText = text;
+            for (let i = selected.length - 1; i >= 0; i--) {
+                const start = selected[i];
+                nextText =
+                    nextText.slice(0, start) +
+                    newText +
+                    nextText.slice(start + oldText.length);
+            }
+
+            return {
+                text: nextText,
+                summary: {
+                    type: edit.type,
+                    matchCount: matches.length,
+                    appliedCount: selected.length,
+                },
+            };
+        }
+        case "insertBefore": {
+            const anchor = normalizeText(ensureNonEmptyString(edit.anchor, "anchor"));
+            const content = normalizeText(ensureString(edit.content, "content"));
+            const matches = findExactMatchIndexes(text, anchor);
+            const selected = selectMatchIndexes(matches, edit, "anchor");
+
+            let nextText = text;
+            for (let i = selected.length - 1; i >= 0; i--) {
+                const start = selected[i];
+                nextText =
+                    nextText.slice(0, start) +
+                    content +
+                    nextText.slice(start);
+            }
+
+            return {
+                text: nextText,
+                summary: {
+                    type: edit.type,
+                    matchCount: matches.length,
+                    appliedCount: selected.length,
+                },
+            };
+        }
+        case "insertAfter": {
+            const anchor = normalizeText(ensureNonEmptyString(edit.anchor, "anchor"));
+            const content = normalizeText(ensureString(edit.content, "content"));
+            const matches = findExactMatchIndexes(text, anchor);
+            const selected = selectMatchIndexes(matches, edit, "anchor");
+
+            let nextText = text;
+            for (let i = selected.length - 1; i >= 0; i--) {
+                const start = selected[i] + anchor.length;
+                nextText =
+                    nextText.slice(0, start) +
+                    content +
+                    nextText.slice(start);
+            }
+
+            return {
+                text: nextText,
+                summary: {
+                    type: edit.type,
+                    matchCount: matches.length,
+                    appliedCount: selected.length,
+                },
+            };
+        }
+        case "delete": {
+            const oldText = normalizeText(ensureNonEmptyString(edit.oldText, "oldText"));
+            const matches = findExactMatchIndexes(text, oldText);
+            const selected = selectMatchIndexes(matches, edit, "oldText");
+
+            let nextText = text;
+            for (let i = selected.length - 1; i >= 0; i--) {
+                const start = selected[i];
+                nextText =
+                    nextText.slice(0, start) +
+                    nextText.slice(start + oldText.length);
+            }
+
+            return {
+                text: nextText,
+                summary: {
+                    type: edit.type,
+                    matchCount: matches.length,
+                    appliedCount: selected.length,
+                },
+            };
+        }
+        default: {
+            throw createValidationError(
+                `Unsupported edit type: ${(edit as { type?: string }).type}`
+            );
+        }
+    }
+}
+
+export function applyTextEditsToText(
+    original: string,
+    edits: IncomingTextEdit[]
+): { text: string; summaries: EditApplicationSummary[] } {
+    let text = original;
+    const summaries: EditApplicationSummary[] = [];
+
+    for (const edit of edits) {
+        const result = applySingleTextEdit(text, edit);
+        text = result.text;
+        summaries.push(result.summary);
+    }
+
+    return { text, summaries };
+}
+
+export async function handleApplyEdit(req: Request): Promise<Response> {
+    try {
+        let body: Partial<ApplyEditRequestBody>;
+        try {
+            body = (await req.json()) as Partial<ApplyEditRequestBody>;
+        } catch {
+            return new Response(
+                JSON.stringify({
+                    error: "Request body must be valid JSON",
+                }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        if (!body.filePath || !Array.isArray(body.edits) || body.edits.length === 0) {
+            return new Response(
+                JSON.stringify({
+                    error: "filePath and non-empty edits are required",
+                }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        const filePath = body.filePath;
+        const edits = body.edits as TextEdit[];
+
+        let targetPath: string;
+        try {
+            targetPath = resolveSafePath(filePath);
+        } catch (error: any) {
+            return new Response(
+                JSON.stringify({
+                    error: error?.message || "Invalid filePath",
+                }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        let originalRaw: string;
+        try {
+            originalRaw = await bunFile(targetPath).text();
+        } catch (error: any) {
+            const code = error?.code || error?.errno || error?.name;
+            const msg = String(error?.message || "");
+            if (code === "ENOENT" || /ENOENT|no such file|not exist/i.test(msg)) {
+                return new Response(
+                    JSON.stringify({
+                        error: `File does not exist: ${filePath}`,
+                    }),
+                    { status: 404, headers: JSON_HEADERS }
+                );
+            }
+
+            console.error("[handleApplyEdit] read file error:", error, "targetPath:", targetPath);
+            return new Response(
+                JSON.stringify({
+                    error: `File cannot be read: ${filePath}`,
+                }),
+                { status: 500, headers: JSON_HEADERS }
+            );
+        }
+
+        const hadCRLF = originalRaw.indexOf("\r\n") >= 0;
+        const originalText = normalizeText(originalRaw);
+
+        let application;
+        try {
+            application = applyTextEditsToText(originalText, edits);
+        } catch (error: any) {
+            if (error?.isValidation) {
+                return new Response(
+                    JSON.stringify({
+                        success: false,
+                        filePath,
+                        error: error.message,
+                    }),
+                    { status: 400, headers: JSON_HEADERS }
+                );
+            }
+            throw error;
+        }
+
+        const { text: newText, summaries } = application;
+        const editSummary = summaries
+            .map((item) => `${item.type}(matched=${item.matchCount},applied=${item.appliedCount})`)
+            .join(", ");
+        console.log(`[applyEdit] file=${filePath} edits=[${editSummary}]`);
+
+        if (newText === originalText) {
+            return new Response(
+                JSON.stringify({
+                    success: true,
+                    filePath,
+                    editCount: edits.length,
+                    changed: false,
+                    appliedEdits: summaries,
+                    message: "Edits applied but content is identical to original.",
+                    contentLength: newText.length,
+                    diffSummary: {
+                        addedLines: 0,
+                        removedLines: 0,
+                        preview: [],
+                        truncated: false,
+                    },
+                }),
+                { status: 200, headers: JSON_HEADERS }
+            );
+        }
+
+        if (/\.(ts|tsx)$/i.test(filePath)) {
+            console.log(`[applyEdit] validate:start file=${filePath}`);
+            const typeCheckResult = await performTypeCheck(
+                targetPath,
+                newText,
+                originalText
+            );
+            console.log(
+                `[applyEdit] validate:done file=${filePath} success=${typeCheckResult.success} kind=${typeCheckResult.kind}`
+            );
+            if (!typeCheckResult.success) {
+                const failure = buildTypeCheckFailureResponse(
+                    filePath,
+                    typeCheckResult
+                );
+                return new Response(
+                    JSON.stringify(failure.body),
+                    { status: failure.status, headers: JSON_HEADERS }
+                );
+            }
+        }
+
+        console.log(`[applyEdit] write:start file=${filePath}`);
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        const finalText = hadCRLF ? newText.replace(/\n/g, "\r\n") : newText;
+        await bunWrite(targetPath, finalText);
+        console.log(`[applyEdit] write:done file=${filePath}`);
+
+        const diff = diffLines(originalText, newText);
+        return new Response(
+            JSON.stringify({
+                success: true,
+                filePath,
+                editCount: edits.length,
+                changed: true,
+                appliedEdits: summaries,
+                contentLength: newText.length,
+                diffSummary: summarizeDiff(diff),
+            }),
+            { status: 200, headers: JSON_HEADERS }
+        );
+    } catch (error: any) {
+        console.error("[applyEdit] Error:", error);
+        return new Response(
+            JSON.stringify({
+                error: `applyEdit failed: ${error?.message || String(error)}`,
+            }),
+            { status: 500, headers: JSON_HEADERS }
+        );
+    }
+}