@cruxy/cli 1.7.0 → 1.7.1

package/README.md

@@ -275,7 +275,7 @@ branch on them:
 | `3`  | config     | `CRUXY_E_CONFIG_PARSE`, `CRUXY_E_CONFIG_INVALID`                                                                                                                                                     |
 | `4`  | auth       | `CRUXY_E_AUTH_MISSING_KEY`, `CRUXY_E_AUTH_INVALID`, `CRUXY_E_FORGE_AUTH`                                                                                                                             |
 | `5`  | network    | `CRUXY_E_GATEWAY_UNREACHABLE`, `CRUXY_E_GIT_PUSH_FAILED`                                                                                                                                             |
-| `6`  | api        | `CRUXY_E_API`, `CRUXY_E_API_RATE_LIMIT`, `CRUXY_E_API_OVERLOADED`, `CRUXY_E_BUDGET_EXHAUSTED`, `CRUXY_E_FORGE_API`                                                                                   |
+| `6`  | api        | `CRUXY_E_API`, `CRUXY_E_API_REQUEST_REJECTED`, `CRUXY_E_API_RATE_LIMIT`, `CRUXY_E_API_OVERLOADED`, `CRUXY_E_BUDGET_EXHAUSTED`, `CRUXY_E_FORGE_API`                                                   |
 | `7`  | filesystem | `CRUXY_E_FILE_NOT_FOUND`, `CRUXY_E_PERMISSION_DENIED`, `CRUXY_E_PATH_ESCAPE`, `CRUXY_E_CHECKPOINT_FAILED`                                                                                            |
 | `8`  | index      | `CRUXY_E_INDEX_EMBEDDER_UNAVAILABLE`, `CRUXY_E_INDEX_EMBEDDER_DOWNLOAD_FAILED`, `CRUXY_E_INDEX_STORE_UNAVAILABLE`, `CRUXY_E_INDEX_FAILED`                                                            |
 | `9`  | skill      | `CRUXY_E_SKILL_INVALID`, `CRUXY_E_SKILL_NOT_FOUND`                                                                                                                                                   |

package/dist/errors/constructors.js

@@ -1,4 +1,4 @@
-import { ApiError, AuthError, BudgetExhaustedError, NetworkError, OverloadedError, RateLimitError, } from "@cruxy/sdk";
+import { ApiError, AuthError, BudgetExhaustedError, InvalidRequestError, NetworkError, OverloadedError, RateLimitError, } from "@cruxy/sdk";
 import { scrubModelNames } from "../brand/index.js";
 import { CruxyError, ErrorCode } from "./types.js";
 /**
@@ -199,6 +199,91 @@ export function apiError(underlying) {
         meta: status ? { status } : undefined,
     });
 }
+/**
+ * The gateway REJECTED what we sent (400/422) — it never reached a model.
+ *
+ * Everything else `classifyProviderError` produces says, in one wording or
+ * another, "wait and try again", because everything else IS a condition that
+ * passes. This one is not, and saying so is the entire point. The gateway parsed
+ * the request, found it invalid, and answered before any upstream call. The
+ * payload is built from this build's own code — the tool harness, the message
+ * shaping — so it is deterministic: a retry sends byte-identical content and
+ * earns a byte-identical refusal. There is no outage, nothing recovers on a
+ * clock, and no amount of patience helps.
+ *
+ * It follows that this is a DEFECT IN CRUXY and the only thing that fixes it is
+ * a code change. So the next steps say that instead of a soothing "retry in a
+ * moment", and they point at the issue tracker with a code to quote, because a
+ * report is the one action that actually moves this forward.
+ *
+ * The gateway's message names the offending tool when a tool is at fault (its
+ * validator emits `tool "<name>": ...`), and that name is the single most useful
+ * token in the whole error — it turns "cruxy is broken" into a filed issue
+ * someone can act on. It is lifted out of the SCRUBBED message, never the raw
+ * one, so the U.8 gag can never be undone by this path.
+ */
+export function apiRequestRejected(underlying) {
+    const status = underlying instanceof ApiError ? underlying.status : undefined;
+    const cause = scrubbedMessageOf(underlying);
+    const tool = toolNamedIn(cause);
+    return new CruxyError({
+        code: ErrorCode.ApiRequestRejected,
+        title: tool
+            ? `the provider rejected this request — the \`${tool}\` tool definition cruxy sent is invalid`
+            : "the provider rejected this request — cruxy sent something invalid",
+        cause,
+        nextSteps: [
+            // First, because it pre-empts the reflex the other API errors trained.
+            "retrying will NOT help: the same request would be sent again and refused identically",
+            "this is a defect in cruxy, not a provider outage — nothing recovers on its own",
+            tool
+                ? `report it at ${ISSUE_URL} with this code and the tool name \`${tool}\``
+                : `report it at ${ISSUE_URL} with this code and the cause line above`,
+        ],
+        underlying,
+        meta: {
+            ...(status !== undefined ? { status } : {}),
+            ...(tool !== undefined ? { tool } : {}),
+        },
+    });
+}
+/**
+ * The tool name in a gateway rejection, if it named one.
+ *
+ * The gateway's tool-schema validator prefixes its complaint with the offending
+ * function — `tool "apply_patch": parameters nests deeper than 8 levels` — so
+ * one quoted token after the word `tool` is the whole pattern. Anything else
+ * yields `undefined` and the caller falls back to generic wording: a WRONG tool
+ * name in a bug report is worse than none, so this never guesses.
+ *
+ * ── TEMPORARY COUPLING, AND IT IS THE WRONG KIND ────────────────────────────
+ *
+ * This reads the gateway's `error` MESSAGE, and the gateway's own contract
+ * (cruxy-ai/api, `internal/httpx/errcode.go`) says the message MAY change while
+ * the `code` MAY NOT. So this parses the half that is explicitly allowed to move
+ * under us — the exact coupling the code/message split exists to prevent.
+ *
+ * It is deliberate and bounded: today the code is the generic `invalid_request`,
+ * shared with bad JSON, a missing field and an unknown model, so the message is
+ * the ONLY thing distinguishing "this build's tool harness is permanently
+ * unusable" from "this one request was malformed". The tool name is the single
+ * most actionable token in the error and it is worth having; a regex that fails
+ * closed is the cheapest way to have it.
+ *
+ * Failing closed is what makes the risk acceptable. If the gateway rewords, this
+ * returns `undefined`, the caller drops to generic wording, and the error is
+ * still correct — less specific, never wrong. Nothing downstream branches on it.
+ *
+ * The real fix is server-side and filed as cruxy-ai/api#183: a distinct 400 code
+ * for harness-bound rejections (the `invalid_schema` precedent already exists
+ * for `response_format`), with the tool name as a STRUCTURED FIELD rather than a
+ * message prefix. When that lands, match on the code, read the field, and delete
+ * this function — do not "improve" the regex.
+ */
+function toolNamedIn(message) {
+    const match = /\btool "([^"]+)"/.exec(message ?? "");
+    return match?.[1];
+}
 export function apiRateLimit(underlying) {
     const retryAfterMs = underlying instanceof RateLimitError ? underlying.retryAfterMs : undefined;
     return new CruxyError({
@@ -1433,6 +1518,14 @@ export function classifyProviderError(underlying) {
     if (underlying instanceof BudgetExhaustedError) {
         return budgetExhausted(underlying);
     }
+    // Also before the `ApiError` base. Without this arm a rejected request lands
+    // on the generic `apiError`, whose only next step is "retry in a moment; if it
+    // persists, check the provider's status" — advice that is wrong twice over for
+    // a 400: retrying re-sends the identical payload, and the provider's status
+    // page has nothing to say about a request it correctly refused.
+    if (underlying instanceof InvalidRequestError) {
+        return apiRequestRejected(underlying);
+    }
     if (underlying instanceof ApiError)
         return apiError(underlying);
     return null;

package/dist/errors/types.js

@@ -44,6 +44,18 @@ export const ErrorCode = {
     GitPushFailed: "CRUXY_E_GIT_PUSH_FAILED",
     // api (exit 6)
     Api: "CRUXY_E_API",
+    /**
+     * The gateway REJECTED the request (400/422) rather than failing to serve it.
+     *
+     * A DISTINCT CODE from {@link Api} because the two are opposite kinds of fact
+     * and take opposite advice. `Api` covers a provider that could not serve a
+     * valid request — a condition, which passes, so "retry in a moment" is sound.
+     * This one covers a request the gateway parsed, judged invalid, and refused
+     * before any upstream call. The payload is deterministic: a retry sends
+     * identical bytes and earns an identical refusal. Telling someone to wait out
+     * a rejection is telling them to wait for a defect in cruxy to fix itself.
+     */
+    ApiRequestRejected: "CRUXY_E_API_REQUEST_REJECTED",
     ApiRateLimit: "CRUXY_E_API_RATE_LIMIT",
     ApiOverloaded: "CRUXY_E_API_OVERLOADED",
     BudgetExhausted: "CRUXY_E_BUDGET_EXHAUSTED",
@@ -289,6 +301,11 @@ const EXIT_CODES = {
     [ErrorCode.GatewayUnreachable]: 5,
     [ErrorCode.GitPushFailed]: 5,
     [ErrorCode.Api]: 6,
+    // Still the API exit class: the failure arrived from the gateway, and a script
+    // wrapping cruxy should treat it the same way it treats any other API failure.
+    // The difference this code carries is what a HUMAN should do about it, which
+    // is the next steps, not the exit status.
+    [ErrorCode.ApiRequestRejected]: 6,
     [ErrorCode.ApiRateLimit]: 6,
     [ErrorCode.ApiOverloaded]: 6,
     [ErrorCode.BudgetExhausted]: 6,

package/dist/tools/file/apply-patch.js

@@ -5,34 +5,93 @@ import { resolveToolPath, toPosix } from "./paths.js";
 import { applyEol, detectEol, findMatch, tierLabel } from "./match.js";
 /** How many leading lines of a created file the approval preview shows. */
 const PREVIEW_LINES = 20;
-const HunkSchema = z.object({
+/**
+ * ONE FLAT OPERATION SHAPE — deliberately flat, and it must stay that way.
+ *
+ * The provider rejects a tool schema nested 8 or more levels deep, and it
+ * rejects the entire REQUEST when any tool trips it: one over-deep schema kills
+ * every turn of every session, which is exactly how 1.7.0 died in the field.
+ * JSON Schema's own wrapper keys (`properties`, `items`, `anyOf`) are containers
+ * too, so every semantic level an author writes costs two, and a union costs two
+ * more on top. The previous shape — a discriminated union of operations, each
+ * carrying an array of hunk OBJECTS — rendered 11 levels deep.
+ *
+ * Neither lever alone was enough (both measured, see schema-depth.test.ts):
+ * keeping the union and flattening hunks still renders 8; dropping the union and
+ * keeping the hunk array renders 9. So both go. The discriminator survives as a
+ * plain `type` enum, and the per-variant field requirements the union used to
+ * encode are enforced by {@link refineOperation} below — `superRefine` is a
+ * runtime check that adds NO depth to the rendered schema, so the model still
+ * gets a precise rejection for a malformed operation, just from zod instead of
+ * from the schema's shape.
+ *
+ * The multi-hunk capability is NOT lost: a path may appear in as many `update`
+ * operations as it likes, and they apply in order against the running content —
+ * the same semantics the `hunks` array had, spelled one hunk per operation.
+ */
+const OperationSchema = z
+    .object({
+    type: z
+        .enum(["update", "create", "delete"])
+        .describe('What to do: "update" replaces oldStr with newStr in an existing file; ' +
+        '"create" writes a new file from content; "delete" removes an existing file.'),
+    path: z.string().describe("Path to the file, relative to the root."),
     oldStr: z
         .string()
         .min(1)
-        .describe("Exact text to replace; must occur exactly once in the file."),
-    newStr: z.string().describe("Replacement text."),
-});
-const OperationSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("update"),
-        path: z
-            .string()
-            .describe("Path to an existing file, relative to the root."),
-        hunks: z
-            .array(HunkSchema)
-            .min(1)
-            .describe("Edits applied in order; each oldStr must match exactly once."),
-    }),
-    z.object({
-        type: z.literal("create"),
-        path: z.string().describe("Path for a new file; must not already exist."),
-        content: z.string().describe("Full UTF-8 contents of the new file."),
-    }),
-    z.object({
-        type: z.literal("delete"),
-        path: z.string().describe("Path to an existing file to delete."),
-    }),
-]);
+        .optional()
+        .describe("update only — exact text to replace; must occur exactly once in the " +
+        "file as it stands when this operation runs."),
+    newStr: z
+        .string()
+        .optional()
+        .describe("update only — the replacement text (may be empty to delete)."),
+    content: z
+        .string()
+        .optional()
+        .describe("create only — full UTF-8 contents of the new file."),
+})
+    .superRefine(refineOperation);
+/**
+ * The per-variant requirements the discriminated union used to express in the
+ * schema. Enforced here so a malformed operation is still rejected before
+ * `execute` runs, with a message naming the exact field.
+ */
+function refineOperation(op, ctx) {
+    const needs = (field) => {
+        if (op[field] === undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [field],
+                message: `"${field}" is required when type is "${op.type}"`,
+            });
+        }
+    };
+    const forbid = (field) => {
+        if (op[field] !== undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [field],
+                message: `"${field}" is not allowed when type is "${op.type}"`,
+            });
+        }
+    };
+    if (op.type === "update") {
+        needs("oldStr");
+        needs("newStr");
+        forbid("content");
+        return;
+    }
+    if (op.type === "create") {
+        needs("content");
+        forbid("oldStr");
+        forbid("newStr");
+        return;
+    }
+    forbid("oldStr");
+    forbid("newStr");
+    forbid("content");
+}
 const parameters = z.object({
     operations: z
         .array(OperationSchema)
@@ -50,14 +109,19 @@ export const applyPatchTool = {
     name: "apply_patch",
     description: "Apply multiple edits across one or more files in a single, atomic, reviewed change — preferred over many edit_file calls for multi-file or multi-hunk work. " +
         "Input is { operations: [...] } where each operation is one of: " +
-        '{ "type":"update", "path", "hunks":[{ "oldStr", "newStr" }] } — replace each oldStr (which must match EXACTLY ONCE in the file, like edit_file; hunks apply in order) with newStr; ' +
+        '{ "type":"update", "path", "oldStr", "newStr" } — replace oldStr (which must match EXACTLY ONCE in the file, like edit_file) with newStr; ' +
         '{ "type":"create", "path", "content" } — create a new file (must not already exist); ' +
         '{ "type":"delete", "path" } — delete an existing file. ' +
+        "To make several edits to the SAME file, list several update operations with the same path: they apply in order, each one matching against the result of the previous. " +
+        "A path used by a create or a delete may appear only once. " +
         "The whole patch is validated before anything is written: if any operation is invalid, nothing is applied and the failing operation is reported.",
     parameters,
     async execute(input, ctx) {
-        const planned = [];
-        const seen = new Set();
+        // One track per path, in first-touch order. Repeated `update` operations on
+        // a path fold into its track, each hunk matching against the running content
+        // — so a file is still written exactly once, from one final byte string.
+        const tracks = new Map();
+        const order = [];
         for (let i = 0; i < input.operations.length; i++) {
             const op = input.operations[i];
             let abs;
@@ -67,18 +131,29 @@ export const applyPatchTool = {
             catch (err) {
                 return { ok: false, error: opError(i, op, err.message) };
             }
-            if (seen.has(abs)) {
-                return {
-                    ok: false,
-                    error: opError(i, op, "duplicate path in patch"),
-                };
+            const existing = tracks.get(abs);
+            if (existing) {
+                // Only an update chain may share a path. A create or a delete alongside
+                // anything else on the same path is an order-dependent muddle, and the
+                // shape that preceded this one couldn't express it either.
+                if (existing.kind !== "update" || op.type !== "update") {
+                    return {
+                        ok: false,
+                        error: opError(i, op, `path already used by operation ${existing.firstOp + 1}; only repeated "update" operations may share a path`),
+                    };
+                }
+                const failure = applyHunk(i, op, existing);
+                if (failure)
+                    return { ok: false, error: failure };
+                continue;
             }
-            seen.add(abs);
-            const planResult = await planOp(i, op, abs, ctx);
-            if (!planResult.ok)
-                return planResult;
-            planned.push(planResult.planned);
+            const opened = await openTrack(i, op, abs, ctx);
+            if (!opened.ok)
+                return opened;
+            tracks.set(abs, opened.track);
+            order.push(abs);
         }
+        const planned = order.map((abs) => toPlanned(tracks.get(abs)));
         // One approval for the whole patch — denial writes nothing.
         const decision = await ctx.requestApproval({
             kind: "patch",
@@ -114,27 +189,31 @@ export const applyPatchTool = {
         return { ok: true, output: `applied patch:\n${applied.join("\n")}` };
     },
 };
-/** Validate one operation against the filesystem and compute its final bytes. */
-async function planOp(i, op, abs, ctx) {
+/** Validate the FIRST operation on a path and open its track. */
+async function openTrack(i, op, abs, ctx) {
     // Forward-slash for model-facing output (the `applied` lines and error
     // messages), consistent with every other path tool — see {@link toPosix}.
     const rel = toPosix(path.relative(ctx.cwd, abs));
+    const base = { abs, rel, firstOp: i, hunks: [] };
     if (op.type === "create") {
         if (await exists(abs)) {
             return { ok: false, error: opError(i, op, "file already exists") };
         }
+        const content = op.content ?? "";
         return {
             ok: true,
-            planned: { op: "create", abs, rel, content: op.content },
+            track: { ...base, kind: "create", content, eol: detectEol(content) },
         };
     }
     if (op.type === "delete") {
         if (!(await exists(abs))) {
             return { ok: false, error: opError(i, op, "file not found") };
         }
-        return { ok: true, planned: { op: "delete", abs, rel } };
+        return {
+            ok: true,
+            track: { ...base, kind: "delete", content: "", eol: "\n" },
+        };
     }
-    // update: read, then apply each hunk in order against the running content.
     let content;
     try {
         content = await fs.readFile(abs, "utf8");
@@ -145,34 +224,49 @@ async function planOp(i, op, abs, ctx) {
         }
         return { ok: false, error: opError(i, op, err.message) };
     }
-    // Detect the file's line ending once, from the original bytes, so every hunk
-    // re-encodes newStr to the same convention as content mutates across hunks.
-    const fileEol = detectEol(content);
-    for (let h = 0; h < op.hunks.length; h++) {
-        const { oldStr, newStr } = op.hunks[h];
-        const match = findMatch(content, oldStr);
-        if (match.kind === "none") {
-            return {
-                ok: false,
-                error: opError(i, op, `hunk ${h + 1}: oldStr not found`),
-            };
-        }
-        if (match.kind === "ambiguous") {
-            return {
-                ok: false,
-                error: opError(i, op, `hunk ${h + 1}: oldStr not unique (${match.count} matches${tierLabel(match.tier)})`),
-            };
-        }
-        // Splice by offset so `$` patterns in newStr aren't interpreted.
-        content =
-            content.slice(0, match.start) +
-                applyEol(newStr, fileEol) +
-                content.slice(match.end);
-    }
-    return {
-        ok: true,
-        planned: { op: "update", abs, rel, content, hunks: op.hunks },
+    const track = {
+        ...base,
+        kind: "update",
+        content,
+        eol: detectEol(content),
     };
+    const failure = applyHunk(i, op, track);
+    return failure ? { ok: false, error: failure } : { ok: true, track };
+}
+/**
+ * Apply one update operation's hunk to its track's running content. Returns an
+ * error string on failure, or `undefined` on success (the track is mutated).
+ */
+function applyHunk(i, op, track) {
+    const { oldStr, newStr } = op;
+    // Guaranteed present by `refineOperation`; re-checked so the narrowing is
+    // structural rather than a cast, and a schema regression fails loud.
+    if (oldStr === undefined || newStr === undefined) {
+        return opError(i, op, 'update requires both "oldStr" and "newStr"');
+    }
+    const match = findMatch(track.content, oldStr);
+    if (match.kind === "none") {
+        return opError(i, op, "oldStr not found");
+    }
+    if (match.kind === "ambiguous") {
+        return opError(i, op, `oldStr not unique (${match.count} matches${tierLabel(match.tier)})`);
+    }
+    // Splice by offset so `$` patterns in newStr aren't interpreted.
+    track.content =
+        track.content.slice(0, match.start) +
+            applyEol(newStr, track.eol) +
+            track.content.slice(match.end);
+    track.hunks.push({ oldStr, newStr });
+    return undefined;
+}
+/** Collapse a finished track into the single write it represents. */
+function toPlanned(track) {
+    const { kind, abs, rel, content, hunks } = track;
+    if (kind === "delete")
+        return { op: "delete", abs, rel };
+    if (kind === "create")
+        return { op: "create", abs, rel, content };
+    return { op: "update", abs, rel, content, hunks };
 }
 /** Shape a planned op into its approval-preview form. */
 function toPreview(p) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
     "undici": "^6.21.0",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5",
-    "@cruxy/sdk": "0.5.0"
+    "@cruxy/sdk": "0.6.0"
   },
   "optionalDependencies": {
     "better-sqlite3": "^12.11.1"