patchling 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 255BITS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# patchling
+
+<p align="center">
+  <img src="infographic.svg" alt="patchling: Smart Diffs, Applied Intelligently — generateDiff creates a unified diff from your files and goal, smartapply resolves conflicts per-file with LLM, and you iterate until done" width="100%">
+</p>
+
+> _Formerly **gptdiff-js**._
+
+**Natural-language code transformation, browser-first.** Hand patchling an in-memory `{ path: content }` file map plus a plain-English goal; **`generateDiff`** returns a unified git diff, and **`smartapply`** melds that diff into your source — even when `git apply` would reject it (drifted lines, fuzzy hunks, renames, new files, deletions). It's a bounded primitive you embed in your own app, not an open-ended coding agent. Wired to [NanoGPT](https://nano-gpt.com) for completions (including "Sign in with NanoGPT" OAuth PKCE).
+
+Everything runs in the browser (and in Node 18+): no filesystem, no build step, zero runtime dependencies. The diff engine is a faithful port of the Python [gptdiff](https://github.com/255BITS/gptdiff); it operates on an in-memory file map instead of a directory on disk.
+
+See it in action: **[live browser demos →](https://255bits.github.io/gptdiff-js-examples/)**.
+
+> **The family** —
+> [**gptdiff**](https://github.com/255BITS/gptdiff) (Python library + CLI) ·
+> **patchling** (this package — the browser/Node runtime) ·
+> [**nanoodle.com**](https://nanoodle.com) (visual AI workflow editor built on it)
+
+```js
+import { generateDiff, smartapply, buildEnvironment } from 'patchling';
+
+const files = { 'greet.py': 'def greet():\n    print("hello")\n' };
+
+// 1. Ask the model for a unified diff
+const diff = await generateDiff(buildEnvironment(files), 'Say goodbye instead of hello');
+
+// 2. Apply it with AI-powered conflict resolution
+const updated = await smartapply(diff, files);
+console.log(updated['greet.py']);
+```
+
+## Install / run
+
+```bash
+npm install patchling
+```
+
+```js
+import { generateDiff, smartapply } from 'patchling';
+```
+
+**Browser, no build step** — it's zero-dependency ESM, so a CDN import works directly (once the package is published to npm):
+
+```js
+import { generateDiff, smartapply } from 'https://esm.sh/patchling';
+```
+
+**Run from source** — point an import at `src/index.js`, or open `index.html` from a static server:
+
+```bash
+npx serve .        # then visit the printed URL and try the demo
+npm test           # run the unit suite (Node's built-in test runner)
+npm run test:live  # hit NanoGPT for real (requires env vars, see below)
+```
+
+## Configuration
+
+Configuration comes from environment variables (Node) or `setEnv(...)` overrides (browser). OAuth sign-in sets the API key override for you.
+
+| Variable | Purpose | Default |
+| --- | --- | --- |
+| `GPTDIFF_LLM_API_KEY` | NanoGPT API key (`sk-nano-…`) | — (required for live calls) |
+| `GPTDIFF_LLM_BASE_URL` | OpenAI-compatible base URL | `https://nano-gpt.com/api/v1/` |
+| `GPTDIFF_MODEL` | Model id | `xiaomi/mimo-v2.5-pro-ultraspeed` |
+
+```js
+import { setEnv } from 'patchling';
+setEnv('GPTDIFF_LLM_API_KEY', 'sk-nano-…'); // browser, no process.env
+```
+
+## Sign in with NanoGPT (OAuth 2.0 + PKCE)
+
+`src/oauth.js` implements the [NanoGPT OAuth PKCE flow](https://nano-gpt.com/blog/sign-in-with-nanogpt-oauth-pkce) using Web Crypto. In a browser:
+
+```js
+import { registerClient, beginSignIn, completeSignIn } from 'patchling/oauth';
+
+// On page load — finishes the redirect and stores the access token as
+// the GPTDIFF_LLM_API_KEY override automatically:
+await completeSignIn();
+
+// To start sign-in (clientId from a one-time dynamic registration):
+const { client_id } = await registerClient({
+  clientName: 'My App',
+  redirectUri: location.origin + location.pathname,
+});
+await beginSignIn({ clientId: client_id }); // redirects to NanoGPT
+```
+
+Low-level helpers are also exported: `generatePkce`, `buildAuthorizeUrl`, `exchangeCodeForToken`, `generateCodeChallenge`.
+
+## API
+
+### `generateDiff(environment, goal, opts?) → Promise<string>`
+Builds the prompt, calls the LLM, and returns the unified diff extracted from the ` ```diff ` block(s) of the response.
+
+- `opts.model`, `opts.temperature`, `opts.maxTokens`, `opts.apiKey`, `opts.baseUrl`, `opts.prepend`, `opts.images`
+- `opts.onToken` — `(text) => void` streaming callback. When provided, the completion is streamed (SSE) and called once per token as it arrives; the returned promise still resolves to the extracted diff. Tokens are the raw model output, which may include prose around the ` ```diff ` block.
+- `opts.callLlm` — inject a custom/mock completion client (used heavily in tests).
+- `opts.onUsage` — optional callback invoked with `{ promptTokens, completionTokens, totalTokens }` after the LLM call completes, so callers can surface cost/usage without changing the `Promise<string>` return type.
+
+### `smartapply(diffText, files, opts?) → Promise<{ path: content }>`
+Applies a diff to an in-memory file map with per-file, LLM-assisted conflict resolution (runs files concurrently). Handles creation, modification, and deletion; `<think>…</think>` and reasoning preambles are stripped automatically. Returns a **new** map; deleted files are omitted.
+
+- `opts.model`, `opts.apiKey`, `opts.baseUrl`, `opts.maxTokens`
+- `opts.onToken` — `(text, path) => void` streaming callback for LLM-resolved files. Files stream concurrently, so calls for different files interleave; use the `path` argument to demultiplex. Files applied by the deterministic fast path emit no tokens.
+- `opts.callLlmForApply` — inject a custom/mock single-file applier.
+
+### `applyDiff(files, diffText) → { changed, files }`
+Deterministic, no-LLM patch application (the strict "basic" applier). `changed` is `true` iff something was created, modified, or deleted; `files` is the updated map (equal to the input on failure — no partial writes).
+
+### Other exports
+`parseDiffPerFile`, `buildEnvironment`, `colorCodeDiff`, `swallowReasoning`, `stripBadOutput`, `extractDiffBlocks`, `callLlm`, `resolveApiKey`, `resolveBaseUrl`, `getEnv`, `setEnv`, and the `oauth` namespace.
+
+## Differences from the Python package
+
+- **No filesystem.** `applyDiff`/`smartapply` take and return a `{ path: content }` map rather than reading/writing a project directory.
+- **Scope.** Only `generateDiff` + `smartapply` (and their dependencies) are ported — not the `gptdiff`/`gptpatch`/`plangptdiff` CLIs.
+- **Dependency injection** replaces Python's `monkeypatch`: pass `callLlm` / `callLlmForApply` to test without a network.
+- **`fetch` + Web Crypto** replace `openai`/`requests`/`tiktoken`.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "patchling",
+  "version": "0.2.0",
+  "description": "Natural-language code transformation as a browser-first JS primitive: generateDiff turns a plain-English goal into a git diff, and smartapply melds it into your source even when git apply would reject it. Wired to NanoGPT. Formerly gptdiff-js.",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./oauth": {
+      "types": "./src/oauth.d.ts",
+      "default": "./src/oauth.js"
+    },
+    "./llm": {
+      "types": "./src/llm.d.ts",
+      "default": "./src/llm.js"
+    }
+  },
+  "files": [
+    "src"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/255BITS/gptdiff-js.git"
+  },
+  "homepage": "https://github.com/255BITS/gptdiff-js#readme",
+  "bugs": {
+    "url": "https://github.com/255BITS/gptdiff-js/issues"
+  },
+  "scripts": {
+    "prepublishOnly": "npm test",
+    "test": "node --test",
+    "test:live": "GPTDIFF_LIVE=1 node --test test/live.test.js",
+    "benchmark": "node benchmark/run.js",
+    "types": "rm -f src/*.d.ts && tsc -p tsconfig.json"
+  },
+  "keywords": [
+    "patchling",
+    "smartapply",
+    "diff",
+    "patch",
+    "llm",
+    "code-transformation",
+    "nanogpt",
+    "git",
+    "browser",
+    "gptdiff"
+  ],
+  "author": "255labs",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.43",
+    "typescript": "^5.9.3"
+  }
+}

package/src/applydiff.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Parse unified diff text into individual per-file patches.
+ *
+ * Handles file creations (`+++ /dev/null`), deletions (`--- /dev/null` or
+ * "deleted file mode"), standard modifications, headerless LLM diffs, and the
+ * `*** Begin Patch` / `*** Update File:` delimiter style.
+ *
+ * @param {string} diffText
+ * @returns {Array<[string, string]>} list of [filePath, patch] tuples
+ */
+export function parseDiffPerFile(diffText: string): Array<[string, string]>;
+/**
+ * Apply a single-file unified diff patch to `originalContent`.
+ *
+ * Each hunk is located by matching its context+deletion lines against the
+ * original rather than trusting the `@@` line numbers, which LLM-generated
+ * diffs frequently get slightly wrong. The `@@` start line is used only as a
+ * hint to disambiguate between multiple matching positions. The full block of
+ * context and deletion lines must match exactly, so a hunk that does not apply
+ * cleanly returns `null` instead of silently corrupting the file.
+ *
+ * @param {string} originalContent
+ * @param {string} patch
+ * @returns {string | null} the patched content, or null if the patch fails
+ */
+export function applyPatchToFile(originalContent: string, patch: string): string | null;
+/**
+ * Apply a unified diff to an in-memory file map.
+ *
+ * @param {Record<string, string>} files map of path -> content
+ * @param {string} diffText unified diff string
+ * @returns {{ changed: boolean, files: Record<string, string> }}
+ *   `changed` is true iff at least one file was created, modified, or deleted.
+ *   `files` is a new map; on failure it equals the input (no partial changes).
+ */
+export function applyDiff(files: Record<string, string>, diffText: string): {
+    changed: boolean;
+    files: Record<string, string>;
+};

package/src/applydiff.js

@@ -0,0 +1,404 @@
+/**
+ * Diff parsing and in-memory diff application, ported from gptdiff's
+ * applydiff.py. The browser has no filesystem, so `applyDiff` operates on a
+ * plain `{ path: content }` map instead of a project directory on disk.
+ */
+
+import { splitLines } from './text.js';
+
+/**
+ * Parse unified diff text into individual per-file patches.
+ *
+ * Handles file creations (`+++ /dev/null`), deletions (`--- /dev/null` or
+ * "deleted file mode"), standard modifications, headerless LLM diffs, and the
+ * `*** Begin Patch` / `*** Update File:` delimiter style.
+ *
+ * @param {string} diffText
+ * @returns {Array<[string, string]>} list of [filePath, patch] tuples
+ */
+export function parseDiffPerFile(diffText) {
+  /**
+   * @param {Array<[string, string]>} diffs
+   * @returns {Array<[string, string]>}
+   */
+  const dedupDiffs = (diffs) => {
+    const groups = new Map();
+    for (const [key, value] of diffs) {
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key).push(value);
+    }
+    return Array.from(groups.entries()).map(([key, values]) => /** @type {[string, string]} */ ([key, values.join('\n')]));
+  };
+
+  // Special case: handle LLM-style patch delimiters.
+  if (diffText.includes('*** Begin Patch')) {
+    const lines = splitLines(diffText);
+    /** @type {Array<[string, string]>} */
+    const diffs = [];
+    let currentLines = [];
+    let currentFile = null;
+    let inPatch = false;
+    for (const line of lines) {
+      const stripped = line.trim();
+      if (stripped === '*** Begin Patch') {
+        inPatch = true;
+        currentLines = [];
+        currentFile = null;
+      } else if (stripped === '*** End Patch') {
+        if (currentFile !== null) diffs.push([currentFile, currentLines.join('\n')]);
+        inPatch = false;
+      } else if (inPatch) {
+        if (stripped.startsWith('*** Update File:')) {
+          currentFile = stripped.split(':').slice(1).join(':').trim();
+        } else {
+          currentLines.push(line);
+        }
+      }
+    }
+    return dedupDiffs(diffs);
+  }
+
+  const headerRe = /^(?:diff --git\s+)?(a\/[^ ]+)\s+(b\/[^ ]+)\s*$/;
+  const lines = splitLines(diffText);
+
+  // Check if any header line exists.
+  if (!lines.some((line) => headerRe.test(line))) {
+    // Fallback strategy: detect file headers from '---' / '+++' pairs.
+    /** @type {Array<[string, string]>} */
+    const diffs = [];
+    let currentLines = [];
+    let currentFile = null;
+    let deletionMode = false;
+    let fromHeader = null;
+    // File headers tolerate 2-3 markers because LLMs emit malformed `--`/`++`
+    // headers. To avoid misreading a hunk body line that deletes/adds content
+    // starting with `-`/`+` (e.g. a markdown list item `- [ ] ...` appears as
+    // `-- [ ] ...` in the diff) as a new file header, a `---`/`--` line only
+    // counts as a from-header when the *next* line is a `+++`/`++` to-header —
+    // unified diffs always pair them. A real deletion body line is followed by
+    // an ordinary `+`/context line instead, so it stays in the patch body.
+    const headerFromRe = /^-{2,3}\s+(.*)$/;
+    const headerToRe = /^\+{2,3}\s+(.*)$/;
+
+    const stripPrefix = (p) => (p.startsWith('a/') || p.startsWith('b/') ? p.slice(2) : p);
+
+    for (let idx = 0; idx < lines.length; idx++) {
+      const line = lines[idx];
+      const fromMatch = line.match(headerFromRe);
+      const next = idx + 1 < lines.length ? lines[idx + 1] : null;
+      const nextTo = next !== null ? next.match(headerToRe) : null;
+
+      if (fromMatch && nextTo) {
+        if (currentFile !== null && currentLines.length) {
+          if (deletionMode && !currentLines.some((l) => l.startsWith('+++ /dev/null'))) {
+            currentLines.push('+++ /dev/null');
+          }
+          diffs.push([currentFile, currentLines.join('\n')]);
+        }
+        // Start the new file and consume the paired to-header in one step.
+        currentLines = [line, next];
+        deletionMode = false;
+        currentFile = null;
+        fromHeader = fromMatch[1].trim();
+        const fileTo = nextTo[1].trim();
+        if (fileTo === '/dev/null') {
+          deletionMode = true;
+          if (fromHeader && fromHeader !== '/dev/null') {
+            currentFile = stripPrefix(fromHeader);
+          }
+        } else {
+          currentFile = stripPrefix(fileTo);
+        }
+        idx += 1; // skip the to-header line we just consumed
+        continue;
+      }
+
+      currentLines.push(line);
+      if (line.includes('deleted file mode')) deletionMode = true;
+    }
+
+    if (currentFile !== null && currentLines.length) {
+      if (deletionMode && !currentLines.some((l) => l.startsWith('+++ '))) {
+        currentLines.push('+++ /dev/null');
+      }
+      diffs.push([currentFile, currentLines.join('\n')]);
+    }
+    return dedupDiffs(diffs);
+  }
+
+  // Header-based strategy.
+  /** @type {Array<[string, string]>} */
+  const diffs = [];
+  let currentLines = [];
+  let currentFile = null;
+  let deletionMode = false;
+  for (const line of lines) {
+    const m = line.match(headerRe);
+    if (m) {
+      if (currentFile !== null && currentLines.length) {
+        if (deletionMode && !currentLines.some((l) => l.startsWith('+++ '))) {
+          currentLines.push('+++ /dev/null');
+        }
+        diffs.push([currentFile, currentLines.join('\n')]);
+      }
+      currentLines = [line];
+      deletionMode = false;
+      const fileTo = m[2]; // e.g. "b/index.html"
+      currentFile = fileTo.startsWith('b/') ? fileTo.slice(2) : fileTo;
+    } else {
+      currentLines.push(line);
+      if (line.includes('deleted file mode')) deletionMode = true;
+      if (line.startsWith('+++ ')) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 2) {
+          const fileTo = parts[1].trim();
+          if (fileTo !== '/dev/null') {
+            currentFile = fileTo.startsWith('a/') || fileTo.startsWith('b/') ? fileTo.slice(2) : fileTo;
+          }
+        }
+      }
+    }
+  }
+  if (currentFile !== null && currentLines.length) {
+    if (deletionMode && !currentLines.some((l) => l.startsWith('+++ '))) {
+      currentLines.push('+++ /dev/null');
+    }
+    diffs.push([currentFile, currentLines.join('\n')]);
+  }
+  return dedupDiffs(diffs);
+}
+
+const HUNK_HEADER_RE = /^@@(?: -(\d+)(?:,(\d+))?)?(?: \+(\d+)(?:,(\d+))?)? @@/;
+
+/**
+ * Apply a single-file unified diff patch to `originalContent`.
+ *
+ * Each hunk is located by matching its context+deletion lines against the
+ * original rather than trusting the `@@` line numbers, which LLM-generated
+ * diffs frequently get slightly wrong. The `@@` start line is used only as a
+ * hint to disambiguate between multiple matching positions. The full block of
+ * context and deletion lines must match exactly, so a hunk that does not apply
+ * cleanly returns `null` instead of silently corrupting the file.
+ *
+ * @param {string} originalContent
+ * @param {string} patch
+ * @returns {string | null} the patched content, or null if the patch fails
+ */
+export function applyPatchToFile(originalContent, patch) {
+  // Work with newline-free lines and re-join with '\n' at the end. This keeps a
+  // file's last line (which may lack a trailing newline) on equal footing with
+  // the rest, so additions after it do not swallow a blank line.
+  const originalLines = splitLines(originalContent || '');
+  const patchLines = splitLines(patch);
+
+  // Parse the patch into hunks: { hint, ops: [{ kind, text }] } where kind is
+  // 'context' | 'del' | 'add'.
+  const hunks = [];
+  let i = 0;
+  while (i < patchLines.length) {
+    const line = patchLines[i];
+    if (line.replace(/^\s+/, '').startsWith('@@')) {
+      let origStart;
+      let declaredNewCount = null;
+      if (line.trim() === '@@') {
+        origStart = 1;
+      } else {
+        const m = line.trim().match(HUNK_HEADER_RE);
+        if (!m) return null;
+        origStart = m[1] !== undefined ? parseInt(m[1], 10) : 1;
+        if (m[3] !== undefined) {
+          declaredNewCount = m[4] !== undefined ? parseInt(m[4], 10) : 1;
+        }
+      }
+      /** @type {Array<{kind: string, text: string, noNewline?: boolean}>} */
+      const ops = [];
+      i += 1;
+      while (i < patchLines.length && !patchLines[i].replace(/^\s+/, '').startsWith('@@')) {
+        const pline = patchLines[i];
+        if (pline.startsWith('\\')) {
+          // "" marker — record it on the op it
+          // annotates (the previous body line) so the collapse rule below can
+          // recognize git's end-of-file newline-change pattern and the final
+          // assembly step knows not to append a trailing newline there.
+          if (ops.length) ops[ops.length - 1].noNewline = true;
+        } else if (pline.startsWith(' ')) {
+          ops.push({ kind: 'context', text: pline.slice(1) });
+        } else if (pline.startsWith('++') && !pline.startsWith('+++')) {
+          // A `++`-prefixed body line is ambiguous: it may be a malformed
+          // double-plus addition (LLM emitted `++foo` meaning "add foo") or a
+          // legitimate addition of a line whose content itself starts with
+          // `+`. Applying either reading risks silent corruption under the
+          // other, so refuse and let the caller fall back to the LLM.
+          return null;
+        } else if (pline.startsWith('-')) {
+          ops.push({ kind: 'del', text: pline.slice(1) });
+        } else if (pline.startsWith('+')) {
+          ops.push({ kind: 'add', text: pline.slice(1) });
+        } else {
+          // Bare context line without a leading space (LLM-style).
+          ops.push({ kind: 'context', text: pline });
+        }
+        i += 1;
+      }
+
+      // Git's "last line loses its trailing newline" pattern is canonically a
+      // del/add pair with identical text plus `\ No newline` markers. Sloppy
+      // diffs write the old copy as *context* instead, leaving a trailing
+      // `+<line>` that duplicates the last context line:
+      //     ` const Retries = 3`      <- kept line
+      //     `-const Debug = true`     <- 
+      //     `+const Retries = 3`      <- 
+      // Applied literally this duplicates "const Retries = 3". When the final
+      // op is such a no-newline add restating the last context line across
+      // only deletions, and the @@ header's new-line count confirms the
+      // collapsed reading (one line fewer than the literal reading), drop the
+      // redundant add — it only re-states the kept line's newline status.
+      if (declaredNewCount !== null && ops.length) {
+        const last = ops[ops.length - 1];
+        if (last.kind === 'add' && last.noNewline) {
+          let ctxIdx = -1;
+          for (let j = ops.length - 2; j >= 0; j--) {
+            if (ops[j].kind === 'context') {
+              ctxIdx = j;
+              break;
+            }
+            if (ops[j].kind !== 'del') break; // only deletions may intervene
+          }
+          if (ctxIdx !== -1 && ctxIdx < ops.length - 2 && ops[ctxIdx].text === last.text) {
+            const literalNewCount = ops.filter((o) => o.kind !== 'del').length;
+            if (declaredNewCount === literalNewCount - 1) ops.pop();
+          }
+        }
+      }
+
+      hunks.push({ hint: origStart - 1, ops });
+    } else {
+      i += 1;
+    }
+  }
+
+  // The lines that must already exist in the original, in order, for a hunk.
+  const oldBlockOf = (ops) =>
+    ops.filter((o) => o.kind !== 'add').map((o) => o.text);
+
+  // Find where `block` occurs in originalLines at index >= minPos, choosing the
+  // occurrence nearest to `hint`. Returns null if there is no exact match.
+  const findBlock = (block, minPos, hint) => {
+    if (block.length === 0) {
+      // Pure-addition hunk (e.g. new file / append): anchor at the hint.
+      return Math.min(Math.max(hint, minPos), originalLines.length);
+    }
+    let best = null;
+    for (let p = minPos; p + block.length <= originalLines.length; p++) {
+      let matched = true;
+      for (let j = 0; j < block.length; j++) {
+        if (originalLines[p + j] !== block[j]) {
+          matched = false;
+          break;
+        }
+      }
+      if (!matched) continue;
+      if (best === null || Math.abs(p - hint) < Math.abs(best - hint)) best = p;
+    }
+    return best;
+  };
+
+  // Track whether the final line pushed to `newLines` should be left without a
+  // trailing newline in the reassembled output. This is true either because
+  // the patch explicitly marks that line with "",
+  // or because the line is carried over verbatim from the original file's own
+  // unmodified last line and the original file itself had no trailing newline.
+  const originalNoTrailingNewline =
+    !!originalContent && originalContent.length > 0 && !/[\n\r]$/.test(originalContent);
+  let endsWithoutNewline = false;
+
+  const newLines = [];
+  let cursor = 0;
+
+  const pushOriginal = (k) => {
+    newLines.push(originalLines[k]);
+    endsWithoutNewline = k === originalLines.length - 1 && originalNoTrailingNewline;
+  };
+
+  for (const hunk of hunks) {
+    const block = oldBlockOf(hunk.ops);
+    const pos = findBlock(block, cursor, hunk.hint);
+    if (pos === null) return null;
+
+    // Copy untouched lines between the previous hunk and this one.
+    for (let k = cursor; k < pos; k++) pushOriginal(k);
+
+    let idx = pos;
+    for (const op of hunk.ops) {
+      if (op.kind === 'add') {
+        newLines.push(op.text);
+        endsWithoutNewline = !!op.noNewline;
+      } else if (op.kind === 'del') {
+        idx += 1; // consume the original line without emitting it
+      } else {
+        pushOriginal(idx); // context: keep the original line
+        if (op.noNewline) endsWithoutNewline = true;
+        idx += 1;
+      }
+    }
+    cursor = idx;
+  }
+
+  // Append remaining original lines.
+  for (let k = cursor; k < originalLines.length; k++) pushOriginal(k);
+
+  let content = newLines.join('\n');
+  if (content && !endsWithoutNewline) content += '\n';
+  return content;
+}
+
+/**
+ * Apply a unified diff to an in-memory file map.
+ *
+ * @param {Record<string, string>} files map of path -> content
+ * @param {string} diffText unified diff string
+ * @returns {{ changed: boolean, files: Record<string, string> }}
+ *   `changed` is true iff at least one file was created, modified, or deleted.
+ *   `files` is a new map; on failure it equals the input (no partial changes).
+ */
+export function applyDiff(files, diffText) {
+  const filePatches = parseDiffPerFile(diffText);
+  if (!filePatches.length) {
+    return { changed: false, files: { ...files } };
+  }
+
+  const original = { ...files };
+  const working = { ...files };
+
+  for (const [filePath, patch] of filePatches) {
+    if (patch.includes('+++ /dev/null')) {
+      // Deletion patch.
+      delete working[filePath];
+    } else {
+      const result = applyPatchToFile(
+        Object.prototype.hasOwnProperty.call(working, filePath) ? working[filePath] : '',
+        patch,
+      );
+      if (result === null) {
+        return { changed: false, files: { ...original } };
+      }
+      working[filePath] = result;
+    }
+  }
+
+  // Verify that at least one file actually changed.
+  let anyChange = false;
+  for (const [filePath, patch] of filePatches) {
+    if (patch.includes('+++ /dev/null')) {
+      if (!Object.prototype.hasOwnProperty.call(working, filePath)) anyChange = true;
+    } else {
+      const had = Object.prototype.hasOwnProperty.call(original, filePath);
+      if (!had || original[filePath] !== working[filePath]) anyChange = true;
+    }
+  }
+
+  if (!anyChange) {
+    return { changed: false, files: { ...original } };
+  }
+  return { changed: true, files: working };
+}

package/src/env.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Set an environment-style override (used in the browser where there is no
+ * `process.env`). Pass `undefined` to clear an override.
+ * @param {string} name
+ * @param {string | undefined} value
+ */
+export function setEnv(name: string, value: string | undefined): void;
+/**
+ * Read an environment variable. Overrides take precedence over `process.env`.
+ * @param {string} name
+ * @param {string} [fallback]
+ * @returns {string | undefined}
+ */
+export function getEnv(name: string, fallback?: string): string | undefined;
+export const DEFAULT_MODEL: "xiaomi/mimo-v2.5-pro-ultraspeed";
+export const DEFAULT_BASE_URL: "https://nano-gpt.com/api/v1/";