patchling 0.2.0 → 0.3.0

package/src/gptdiff.d.ts

@@ -1,9 +1,26 @@
 /**
  * Rebuild the environment string from a `{ path: content }` map.
+ *
+ * Opt-in relevance filter: pass `{ decisions }` from `filterRelevant` and
+ * only files whose decision is `"yes"` are included. An array of those
+ * decisions is also accepted as the second argument. Omit it and every file
+ * is included, in insertion order. Every other file stays out of the
+ * string that `generateDiff` sees.
+ *
  * @param {Record<string, string>} filesDict
+ * @param {{ decisions?: Array<{ path?: string, decision?: string }> } | Array<{ path?: string, decision?: string }>} [opts]
+ *   `{ decisions }` from `filterRelevant`, or that array itself.
  * @returns {string}
  */
-export function buildEnvironment(filesDict: Record<string, string>): string;
+export function buildEnvironment(filesDict: Record<string, string>, opts?: {
+    decisions?: Array<{
+        path?: string;
+        decision?: string;
+    }>;
+} | Array<{
+    path?: string;
+    decision?: string;
+}>): string;
 /**
  * Build the prompt, call the LLM, and extract the unified diff from the
  * ```diff fenced blocks of the response.
@@ -134,6 +151,16 @@ export function callLlmForApplyWithThink(filePath: string, originalContent: stri
  * resolution. Set `opts.forceLlm` to skip the deterministic fast path and send
  * every file to the LLM.
  *
+ * When the diff's context lines are not in the file, the model result is
+ * checked against the diff's `+`/`-` lines. An indentation shift, or a hunk
+ * that matches somewhere other than its `@@` line, still counts as context.
+ * A diff name that pairs with a different name already in the file
+ * (`user_id` beside `uid`) is rewritten onto the file's name before any
+ * model call. A result that copies stale context, deletes any other line,
+ * or is empty is discarded. The same edit is then replayed from the `+`/`-`
+ * lines (at the file's indent, with those names); if that cannot be done
+ * without guessing, this throws instead of writing the file.
+ *
  * @param {string} diffText
  * @param {Record<string, string>} files
  * @param {object} [opts]

package/src/gptdiff.js

@@ -6,7 +6,13 @@
  * the logic is fully unit-testable without network access.
  */
 
-import { parseDiffPerFile, applyPatchToFile } from './applydiff.js';
+import {
+  parseDiffPerFile,
+  applyPatchToFile,
+  applyAdaptedIdentifiers,
+  applyIntentIgnoringBadContext,
+  diffOutputViolatesIntent,
+} from './applydiff.js';
 import {
   swallowReasoning,
   stripBadOutput,
@@ -33,21 +39,53 @@ a/file.py b/file.py
 You must include the '--- file' and/or '+++ file' part of the diff. File modifications should include both.
 `;
 
-const APPLY_SYSTEM_PROMPT = `Please apply the diff to this file. Return the result in a block. Write the entire file.
+const APPLY_SYSTEM_PROMPT = `Please apply the diff to this file. Return the full file contents.
 
-1. Carefully apply all changes from the diff
-2. Preserve surrounding context that isn't changed
-3. Only return the final file content, do not add any additional markup and do not add a code block
-4. You must return the entire file. It overwrites the existing file.`;
+1. Apply ONLY the changed lines. A line beginning with '-' is removed and a line beginning with '+' is inserted. Those are the only edits you may make.
+2. Context lines (a leading space, or a bare line that is not '+' or '-') are location hints and are often wrong: wrong whitespace, stale values, or ellipsis ("..."). Never copy a context line from the diff into the file. If a context line does not already match the file exactly, keep the file's original line character for character.
+3. Do not delete, rewrite, reorder, or drop any line the diff does not remove with a '-' line. Lines the diff never mentions, including lines before and after the hunk, must be preserved verbatim.
+4. Only return the final file content. Do not add any additional markup and do not add a code block.
+5. You must return the entire file. It overwrites the existing file.`;
+
+/**
+ * Decisions from `filterRelevant`, or a bare array of them.
+ * `null` means "include every file" (the default).
+ * @param {object | Array<{ path?: string, decision?: string }> | undefined} opts
+ * @returns {Array<{ path?: string, decision?: string }> | null}
+ */
+function decisionsFrom(opts) {
+  if (!opts) return null;
+  if (Array.isArray(opts)) return opts;
+  if (Array.isArray(opts.decisions)) return opts.decisions;
+  return null;
+}
 
 /**
  * Rebuild the environment string from a `{ path: content }` map.
+ *
+ * Opt-in relevance filter: pass `{ decisions }` from `filterRelevant` and
+ * only files whose decision is `"yes"` are included. An array of those
+ * decisions is also accepted as the second argument. Omit it and every file
+ * is included, in insertion order. Every other file stays out of the
+ * string that `generateDiff` sees.
+ *
  * @param {Record<string, string>} filesDict
+ * @param {{ decisions?: Array<{ path?: string, decision?: string }> } | Array<{ path?: string, decision?: string }>} [opts]
+ *   `{ decisions }` from `filterRelevant`, or that array itself.
  * @returns {string}
  */
-export function buildEnvironment(filesDict) {
+export function buildEnvironment(filesDict, opts) {
+  let entries = Object.entries(filesDict || {});
+  const decisions = decisionsFrom(opts);
+  if (decisions) {
+    const yes = new Set();
+    for (const decision of decisions) {
+      if (decision && decision.decision === 'yes' && decision.path) yes.add(decision.path);
+    }
+    entries = entries.filter(([path]) => yes.has(path));
+  }
   const env = [];
-  for (const [path, content] of Object.entries(filesDict)) {
+  for (const [path, content] of entries) {
     env.push(`File: ${path}`);
     env.push('Content:');
     env.push(content);
@@ -244,6 +282,9 @@ Diff to apply:
 \`\`\`diff
 ${fileDiff}
 \`\`\``;
+  userPrompt += `
+
+Apply only the '-' and '+' lines. Context lines may be wrong; never copy them into the file, and do not delete or rewrite any line the diff does not remove.`;
   if (extraPrompt) userPrompt += `\n\n${extraPrompt}`;
   if (model && model.includes('gemini')) {
     userPrompt = APPLY_SYSTEM_PROMPT + '\n' + userPrompt;
@@ -294,6 +335,16 @@ export async function callLlmForApplyWithThink(filePath, originalContent, fileDi
  * resolution. Set `opts.forceLlm` to skip the deterministic fast path and send
  * every file to the LLM.
  *
+ * When the diff's context lines are not in the file, the model result is
+ * checked against the diff's `+`/`-` lines. An indentation shift, or a hunk
+ * that matches somewhere other than its `@@` line, still counts as context.
+ * A diff name that pairs with a different name already in the file
+ * (`user_id` beside `uid`) is rewritten onto the file's name before any
+ * model call. A result that copies stale context, deletes any other line,
+ * or is empty is discarded. The same edit is then replayed from the `+`/`-`
+ * lines (at the file's indent, with those names); if that cannot be done
+ * without guessing, this throws instead of writing the file.
+ *
  * @param {string} diffText
  * @param {Record<string, string>} files
  * @param {object} [opts]
@@ -330,8 +381,12 @@ export async function smartapply(diffText, files, opts = {}) {
         return;
       }
       // Fast path: try to apply the patch deterministically, no LLM call.
+      // A clean hunk wins first. A rename that the diff's context already
+      // reveals (`user_id` in the hunk, `uid` in the file) is applied from
+      // the +/- lines alone, so the model cannot leave the diff's name behind.
       if (!opts.forceLlm) {
-        const deterministic = applyPatchToFile(original, patch);
+        const deterministic = applyPatchToFile(original, patch)
+          ?? applyAdaptedIdentifiers(original, patch);
         if (deterministic !== null) {
           result[path] = deterministic;
           return;
@@ -344,7 +399,20 @@ export async function smartapply(diffText, files, opts = {}) {
         ? { ...applyOpts, onToken: (text) => opts.onToken(text, path) }
         : applyOpts;
       const updated = await callLlmForApplyWithThink(path, original, patch, model, fileOpts);
-      result[path] = stripBadOutput(updated, original);
+      const cleaned = stripBadOutput(updated, original);
+      if (!diffOutputViolatesIntent(original, cleaned, patch)) {
+        result[path] = cleaned;
+        return;
+      }
+      // The model copied stale context or edited a line the diff did not
+      // add or remove. Replay only the +/- lines, or refuse the write.
+      const intent = applyIntentIgnoringBadContext(original, patch);
+      if (intent == null || diffOutputViolatesIntent(original, intent, patch)) {
+        throw new Error(
+          `smartapply: refusing to write ${JSON.stringify(path)}: the model changed lines the diff did not add or remove`,
+        );
+      }
+      result[path] = intent;
     }),
   );
 

package/src/index.d.ts

@@ -1,5 +1,8 @@
 export * as oauth from "./oauth.js";
+export type RelevanceDecision = import("./filter.js").RelevanceDecision;
+export type FilterRelevantResult = import("./filter.js").FilterRelevantResult;
 export { generateDiff, smartapply, buildEnvironment, callLlmForDiff, callLlmForApply, callLlmForApplyWithThink } from "./gptdiff.js";
+export { filterRelevant, RelevanceCache, createMemoryCache, parseRelevanceAnswer, isBinaryContent, isIgnoredPath, countTokens, formatFilterSummary, dumpDecisions, DEFAULT_FILTER_MODEL, DEFAULT_FILTER_MAX_BYTES, DEFAULT_FILTER_MAX_TOKENS, DEFAULT_FILTER_MAX_OUTPUT_TOKENS, DEFAULT_FILTER_REASONING_EFFORT, DEFAULT_FILTER_CONCURRENCY, FILTER_PROMPT_VERSION, PROMPT_VERSION, DEFAULT_IGNORE_PATTERNS } from "./filter.js";
 export { parseDiffPerFile, applyDiff, applyPatchToFile } from "./applydiff.js";
 export { colorCodeDiff, swallowReasoning, stripBadOutput, extractDiffBlocks, stripThinkTags } from "./text.js";
 export { callLlm, resolveApiKey, resolveBaseUrl } from "./llm.js";

package/src/index.js

@@ -6,6 +6,31 @@
  */
 
 export { generateDiff, smartapply, buildEnvironment, callLlmForDiff, callLlmForApply, callLlmForApplyWithThink } from './gptdiff.js';
+export {
+  filterRelevant,
+  RelevanceCache,
+  createMemoryCache,
+  parseRelevanceAnswer,
+  isBinaryContent,
+  isIgnoredPath,
+  countTokens,
+  formatFilterSummary,
+  dumpDecisions,
+  DEFAULT_FILTER_MODEL,
+  DEFAULT_FILTER_MAX_BYTES,
+  DEFAULT_FILTER_MAX_TOKENS,
+  DEFAULT_FILTER_MAX_OUTPUT_TOKENS,
+  DEFAULT_FILTER_REASONING_EFFORT,
+  DEFAULT_FILTER_CONCURRENCY,
+  FILTER_PROMPT_VERSION,
+  PROMPT_VERSION,
+  DEFAULT_IGNORE_PATTERNS,
+} from './filter.js';
+
+/**
+ * @typedef {import('./filter.js').RelevanceDecision} RelevanceDecision
+ * @typedef {import('./filter.js').FilterRelevantResult} FilterRelevantResult
+ */
 export { parseDiffPerFile, applyDiff, applyPatchToFile } from './applydiff.js';
 export { colorCodeDiff, swallowReasoning, stripBadOutput, extractDiffBlocks, stripThinkTags } from './text.js';
 export { callLlm, resolveApiKey, resolveBaseUrl } from './llm.js';

package/src/llm.d.ts

@@ -9,6 +9,8 @@
  * @param {number} [opts.maxTokens]
  * @param {number} [opts.temperature]
  * @param {number} [opts.budgetTokens] Anthropic extended-thinking budget
+ * @param {string | null} [opts.reasoningEffort] OpenAI-compatible `reasoning_effort`
+ *   (`low`, `medium`, `high`). Omitted when empty.
  * @param {(text: string) => void} [opts.onToken] when provided, the request is
  *   made with `stream: true` and this is called once per content delta as
  *   tokens arrive. The resolved value keeps the exact non-streaming shape
@@ -19,7 +21,7 @@
  * @param {number} [opts.retryBaseMs] base backoff in ms (default 1500, exponential, capped 30s)
  * @returns {Promise<{choices: Array<{message: {content: string}}>, usage: object}>}
  */
-export function callLlm({ apiKey, baseUrl, model, messages, maxTokens, temperature, budgetTokens, onToken, fetchImpl, maxRetries, retryBaseMs, }: {
+export function callLlm({ apiKey, baseUrl, model, messages, maxTokens, temperature, budgetTokens, reasoningEffort, onToken, fetchImpl, maxRetries, retryBaseMs, }: {
     apiKey?: string;
     baseUrl?: string;
     model: string;
@@ -27,6 +29,7 @@ export function callLlm({ apiKey, baseUrl, model, messages, maxTokens, temperatu
     maxTokens?: number;
     temperature?: number;
     budgetTokens?: number;
+    reasoningEffort?: string | null;
     onToken?: (text: string) => void;
     fetchImpl?: typeof fetch;
     maxRetries?: number;

package/src/llm.js

@@ -150,6 +150,8 @@ async function consumeSseStream(resp, onToken) {
  * @param {number} [opts.maxTokens]
  * @param {number} [opts.temperature]
  * @param {number} [opts.budgetTokens] Anthropic extended-thinking budget
+ * @param {string | null} [opts.reasoningEffort] OpenAI-compatible `reasoning_effort`
+ *   (`low`, `medium`, `high`). Omitted when empty.
  * @param {(text: string) => void} [opts.onToken] when provided, the request is
  *   made with `stream: true` and this is called once per content delta as
  *   tokens arrive. The resolved value keeps the exact non-streaming shape
@@ -168,6 +170,7 @@ export async function callLlm({
   maxTokens = null,
   temperature = 1.0,
   budgetTokens = null,
+  reasoningEffort = null,
   onToken = null,
   fetchImpl,
   maxRetries = 3,
@@ -235,6 +238,7 @@ export async function callLlm({
     messages,
     temperature,
     ...(maxTokens ? { max_tokens: maxTokens } : {}),
+    ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
     // Streaming: ask for SSE deltas plus a final usage chunk.
     ...(onToken ? { stream: true, stream_options: { include_usage: true } } : {}),
   });