@method-ai-hq/sdk 0.20.0 → 0.20.1

package/README.md

@@ -3,7 +3,7 @@
 MIT-licensed JavaScript API and the `method` CLI. Source and releases: https://github.com/method-ai-hq/method-sdk
 
 ```sh
-npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.20.0/method-ai-hq-sdk-0.20.0.tgz
+npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.20.1/method-ai-hq-sdk-0.20.1.tgz
 npx method --version
 ```
 

package/dist/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@method-ai-hq/sdk",
-    "version": "0.20.0",
+    "version": "0.20.1",
     "description": "Build and run reusable .method files with checked steps and saved results.",
     "license": "MIT",
     "type": "module",
@@ -35,7 +35,7 @@
         "prepack": "npm --prefix ../.. run build"
     },
     "dependencies": {
-        "@withmethod/runtime": "https://codeload.github.com/method-ai-hq/method-spec/tar.gz/v0.16.1",
+        "@withmethod/runtime": "https://codeload.github.com/method-ai-hq/method-spec/tar.gz/v0.16.2",
         "fflate": "^0.8.3",
         "yaml": "^2.9.0",
         "zod": "^3.25.76"

package/dist/packages/sdk/src/improve.d.ts

@@ -205,6 +205,7 @@ export declare function fixWaiting(client: MethodClient, file: string, options?:
 /** Runs cases of a Method file (quality.ts runCases); tests replace it. */
 export type RunCases = (file: string, flags: Record<string, never>, options: {
     ids: string[];
+    casesDir?: string;
 }) => Promise<{
     cases: {
         id: string;
@@ -213,8 +214,8 @@ export type RunCases = (file: string, flags: Record<string, never>, options: {
 }>;
 /**
  * The later check of an applied change: the Method's other cases (improve.method's background_cases) run on the changed
- * file. A failing case that belongs to a retired learned rule (its from.case) brings that rule back. Any other failure
- * undoes the change, saves the restored file as a new version, and opens the corrections it answered again, so the next
+ * file. A failing case that belongs to a retired learned rule (its from.case) brings that rule back. Any other case that
+ * fails now and passed before the change (a correction that no fix answered yet fails on both) undoes the change, saves the restored file as a new version, and opens the corrections it answered again, so the next
  * method run fixes them anew. Each of these says one line on the next method run or method wait.
  */
 export declare function checkBackground(client: MethodClient, file: string, fix: Pick<FixOutcome, 'background_cases' | 'undo_id' | 'fixed' | 'cause'>, options?: {

package/dist/packages/sdk/src/improve.js

@@ -1,5 +1,6 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve, sep } from 'node:path';
+import { appendFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { MethodPackageSchema, packageDigest, packagePath } from '../../contracts/src/method-package.js';
@@ -13,7 +14,7 @@ import { localRuns, saveLocalProposal, writeMethodFile } from './proposals.js';
 import { changedSteps } from './merge.js';
 import { localJudgments, runFolderIndex } from './local-judgments.js';
 import { fixFolder, readFixState, saveError, saveNotice, saveOutcome, setWorker, storedOutcome, writeFixState } from './fix-outcomes.js';
-import { recordChange, saveVersion, snapshot, undoLast } from './undo.js';
+import { recordChange, saveVersion, snapshot, undoLast, undoRecords } from './undo.js';
 import { fixUndoneLine, ruleBackLine } from './fix-lines.js';
 const outcomeKinds = ['fixed', 'no_fix_found', 'could_not_test', 'question', 'held', 'not_reproduced', 'not_fixable_here'];
 const reasons = ['missing_file', 'can_send', 'too_large', 'no_live_step'];
@@ -607,10 +608,40 @@ export async function fixWaiting(client, file, options = {}) {
         rmSync(lock, { force: true });
     }
 }
+/**
+ * The cases among ids that pass on the Method as it was before the change undoId: a copy of the Method's folder with
+ * the file and the changed files from the undo record, tested with the Method's own cases. Without the record, every
+ * case counts as passing before.
+ */
+async function passedBefore(file, undoId, ids, run) {
+    const record = undoRecords(file).find(r => r.id === undoId);
+    if (!record || !ids.length)
+        return new Set(ids);
+    const folder = dirname(resolve(file)), copy = mkdtempSync(join(tmpdir(), 'method-before-'));
+    try {
+        cpSync(folder, copy, { recursive: true, filter: source => !/^(cases|\.method)(\/|$)/.test(relative(folder, source)) });
+        const before = join(copy, basename(file));
+        writeFileSync(before, record.before.text);
+        for (const [path, content] of Object.entries(record.before.files)) {
+            const full = join(copy, packagePath(path));
+            if (content === null)
+                rmSync(full, { force: true });
+            else {
+                mkdirSync(dirname(full), { recursive: true });
+                writeFileSync(full, Buffer.from(content, 'base64'));
+            }
+        }
+        const report = await run(before, {}, { ids, casesDir: join(folder, 'cases') });
+        return new Set(report.cases.filter(c => c.verdict === 'pass').map(c => c.id));
+    }
+    finally {
+        rmSync(copy, { recursive: true, force: true });
+    }
+}
 /**
  * The later check of an applied change: the Method's other cases (improve.method's background_cases) run on the changed
- * file. A failing case that belongs to a retired learned rule (its from.case) brings that rule back. Any other failure
- * undoes the change, saves the restored file as a new version, and opens the corrections it answered again, so the next
+ * file. A failing case that belongs to a retired learned rule (its from.case) brings that rule back. Any other case that
+ * fails now and passed before the change (a correction that no fix answered yet fails on both) undoes the change, saves the restored file as a new version, and opens the corrections it answered again, so the next
  * method run fixes them anew. Each of these says one line on the next method run or method wait.
  */
 export async function checkBackground(client, file, fix, options = {}) {
@@ -635,7 +666,9 @@ export async function checkBackground(client, file, fix, options = {}) {
                     ruleCases.add(r.from.case);
     }
     catch { /* no readable learned rules */ }
-    const broken = done.failed.filter(id => !ruleCases.has(id));
+    const others = done.failed.filter(id => !ruleCases.has(id));
+    const passed = await passedBefore(file, fix.undo_id, others, run);
+    const broken = others.filter(id => passed.has(id));
     if (broken.length && fix.undo_id) {
         try {
             undoLast(file, fix.undo_id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@method-ai-hq/sdk",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "Build and run reusable .method files with checked steps and saved results.",
   "license": "MIT",
   "type": "module",
@@ -35,7 +35,7 @@
     "prepack": "npm --prefix ../.. run build"
   },
   "dependencies": {
-    "@withmethod/runtime": "https://codeload.github.com/method-ai-hq/method-spec/tar.gz/v0.16.1",
+    "@withmethod/runtime": "https://codeload.github.com/method-ai-hq/method-spec/tar.gz/v0.16.2",
     "fflate": "^0.8.3",
     "yaml": "^2.9.0",
     "zod": "^3.25.76"