@cjhyy/code-shell-capability-coding 0.9.44 → 0.9.47

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

@@ -9,7 +9,7 @@
 //
 // Algorithm uses code adapted from codex-rs/apply-patch/src/lib.rs (Apache-2.0)
 // for the chunk-replacement phase (compute_replacements, apply_replacements).
-import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { chmod, mkdir, open, unlink, writeFile } from "node:fs/promises";
 import { existsSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
 import { seekSequence } from "./seek-sequence.js";
@@ -47,42 +47,38 @@ async function planHunks(hunks, cwd, workspaceRoots) {
         const original = hunk.path;
         const sourcePath = resolveAgainst(original, cwd, workspaceRoots);
         if (hunk.kind === "add") {
-            const existed = await readIfExists(sourcePath);
+            const existed = await readSnapshotIfExists(sourcePath);
             schedule(sourcePath, {
                 path: sourcePath,
                 newContent: hunk.contents,
-                originalContent: existed,
+                original: existed,
             });
             set.added.push(original);
             continue;
         }
         if (hunk.kind === "delete") {
-            const stats = await safeStat(sourcePath);
-            if (!stats)
+            const snapshot = await readSnapshotIfExists(sourcePath);
+            if (!snapshot)
                 throw new Error(`Failed to delete file: ${sourcePath} not found`);
-            if (stats.isDirectory()) {
-                throw new Error(`Failed to delete file: ${sourcePath} is a directory`);
-            }
-            const content = await readFile(sourcePath, "utf-8");
             schedule(sourcePath, {
                 path: sourcePath,
                 newContent: null,
-                originalContent: content,
+                original: snapshot,
             });
             set.deleted.push(original);
             continue;
         }
         // Update (with optional rename).
-        const stats = await safeStat(sourcePath);
-        if (!stats) {
+        const snapshot = await readSnapshotIfExists(sourcePath);
+        if (!snapshot) {
             throw new Error(`Failed to update file: ${sourcePath} does not exist`);
         }
-        const originalRaw = await readFile(sourcePath, "utf-8");
+        const originalRaw = snapshot.content.toString("utf-8");
         // CRLF handling: patch context lines are LF (the model emits LF). Match in
         // LF space, then write back in the file's original EOL so a CRLF file isn't
         // silently converted to LF (which would diff the whole file). originalText
-        // (LF) is what we compare; originalRaw is preserved for rollback so a
-        // restore writes back the exact bytes. See eol.ts.
+        // (LF) is what we compare; the undecoded snapshot is preserved for rollback
+        // so a restore writes back the exact bytes. See eol.ts.
         const eol = detectEol(originalRaw);
         const originalText = toLf(originalRaw);
         const newText = applyEol(applyChunksToText(originalText, hunk.chunks, sourcePath), eol);
@@ -93,20 +89,21 @@ async function planHunks(hunks, cwd, workspaceRoots) {
                 schedule(sourcePath, {
                     path: sourcePath,
                     newContent: newText,
-                    originalContent: originalRaw,
+                    original: snapshot,
                 });
             }
             else {
-                const destOriginal = await readIfExists(destPath);
+                const destOriginal = await readSnapshotIfExists(destPath);
                 schedule(sourcePath, {
                     path: sourcePath,
                     newContent: null,
-                    originalContent: originalRaw,
+                    original: snapshot,
                 });
                 schedule(destPath, {
                     path: destPath,
                     newContent: newText,
-                    originalContent: destOriginal,
+                    original: destOriginal,
+                    newMode: snapshot.mode,
                 });
             }
             set.modified.push(original);
@@ -115,7 +112,7 @@ async function planHunks(hunks, cwd, workspaceRoots) {
             schedule(sourcePath, {
                 path: sourcePath,
                 newContent: newText,
-                originalContent: originalRaw,
+                original: snapshot,
             });
             set.modified.push(original);
         }
@@ -191,27 +188,27 @@ async function commitPlanned(set, allowPartial) {
         }
         return { added: set.added, modified: set.modified, deleted: set.deleted };
     }
-    // Track which writes have completed so rollback only touches them. We use
-    // the originalContent captured during plan() rather than re-reading from
-    // disk — this avoids a TOCTOU window between planning and committing.
-    const committed = [];
+    // Include the current attempt: writeFile may write partially before failing,
+    // and chmod can fail after the new content has already been written. Restore
+    // the bytes and permissions captured during planning, without re-reading.
+    const attempted = [];
     try {
         for (const change of ordered) {
+            attempted.push(change);
             await writeChange(change);
-            committed.push(change);
         }
     }
     catch (err) {
-        for (let i = committed.length - 1; i >= 0; i--) {
-            const c = committed[i];
+        for (let i = attempted.length - 1; i >= 0; i--) {
+            const c = attempted[i];
             try {
-                if (c.originalContent === null) {
+                if (c.original === null) {
                     // File did not exist before we wrote it — remove our write.
                     if (existsSync(c.path))
                         await unlink(c.path);
                 }
                 else {
-                    await writeFile(c.path, c.originalContent, "utf-8");
+                    await restoreSnapshot(c.path, c.original);
                 }
             }
             catch {
@@ -222,6 +219,25 @@ async function commitPlanned(set, allowPartial) {
     }
     return { added: set.added, modified: set.modified, deleted: set.deleted };
 }
+async function restoreSnapshot(path, snapshot) {
+    const writableMode = snapshot.mode | 0o200;
+    try {
+        // A successful move may have made an existing target read-only. writeFile's
+        // mode only applies to new files, so temporarily allow restoring its bytes.
+        try {
+            await chmod(path, writableMode);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await writeFile(path, snapshot.content, { mode: writableMode });
+    }
+    finally {
+        // Also restore a read-only snapshot's mode if writing its bytes fails.
+        await chmod(path, snapshot.mode);
+    }
+}
 async function writeChange(change) {
     if (change.newContent === null) {
         if (existsSync(change.path))
@@ -232,7 +248,11 @@ async function writeChange(change) {
     if (!existsSync(parent)) {
         await mkdir(parent, { recursive: true });
     }
-    await writeFile(change.path, change.newContent, "utf-8");
+    await writeFile(change.path, change.newContent, { encoding: "utf-8", mode: change.newMode });
+    if (change.newMode !== undefined) {
+        // The creation mode is masked by umask and ignored for existing targets.
+        await chmod(change.path, change.newMode);
+    }
 }
 // ─── helpers ──────────────────────────────────────────────────────
 /**
@@ -288,19 +308,24 @@ function isInside(child, parent) {
     const p = parent.endsWith(sep) ? parent : parent + sep;
     return child.startsWith(p);
 }
-async function safeStat(path) {
+async function readSnapshotIfExists(path) {
+    let file;
     try {
-        return await stat(path);
+        file = await open(path, "r");
     }
-    catch {
-        return null;
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return null;
+        throw error;
     }
-}
-async function readIfExists(path) {
     try {
-        return await readFile(path, "utf-8");
+        const stats = await file.stat();
+        if (stats.isDirectory())
+            throw new Error(`Cannot apply patch to directory: ${path}`);
+        return { content: await file.readFile(), mode: stats.mode & 0o7777 };
     }
-    catch {
-        return null;
+    finally {
+        await file.close();
     }
 }

package/dist/tools/apply-patch/backup-targets.d.ts

@@ -8,3 +8,11 @@
  * up (undo of an add = delete, handled separately if/when /undo grows that).
  */
 export declare function patchBackupTargets(patchText: string, cwd: string): string[];
+/**
+ * Every filesystem destination an ApplyPatch can change. Unlike undo backup
+ * targets, turn diffs need absent paths too: additions and move destinations
+ * must be captured before execution to distinguish creation from overwrite.
+ * Moves are represented by their source and destination; the tracker compares
+ * each path's real before/after state rather than inferring a rename from text.
+ */
+export declare function patchDiffTargets(patchText: string, cwd: string): string[];

package/dist/tools/apply-patch/backup-targets.js

@@ -28,3 +28,27 @@ export function patchBackupTargets(patchText, cwd) {
     // but be defensive — saveSnapshot is idempotent on identical content anyway).
     return [...new Set(out)];
 }
+/**
+ * Every filesystem destination an ApplyPatch can change. Unlike undo backup
+ * targets, turn diffs need absent paths too: additions and move destinations
+ * must be captured before execution to distinguish creation from overwrite.
+ * Moves are represented by their source and destination; the tracker compares
+ * each path's real before/after state rather than inferring a rename from text.
+ */
+export function patchDiffTargets(patchText, cwd) {
+    let parsed;
+    try {
+        parsed = parsePatch(patchText, "lenient");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const hunk of parsed.hunks) {
+        out.push(resolvePath(cwd, hunk.path));
+        if (hunk.kind === "update" && hunk.movePath) {
+            out.push(resolvePath(cwd, hunk.movePath));
+        }
+    }
+    return [...new Set(out)];
+}

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

@@ -108,8 +108,10 @@ function parseOneHunk(lines, offset, lineNumber) {
         }
         const chunks = [];
         while (cursor < lines.length) {
-            // Skip blank lines between chunks.
-            if (lines[cursor].trim() === "") {
+            // Skip blank lines between chunks. The first chunk may omit `@@`, so a
+            // space-marked line there is whitespace context, not a separator.
+            const leadingContext = chunks.length === 0 && lines[cursor].startsWith(" ");
+            if (lines[cursor].trim() === "" && !leadingContext) {
                 cursor++;
                 consumed++;
                 continue;

package/dist/tools/check-quota.js

@@ -5,7 +5,9 @@ export const checkQuotaToolDef = {
     description: "Check remaining usage/rate-limit quota for the external coding-agent CLIs (Claude Code and/or " +
         "Codex) — the same subscription windows their status lines show. Use before or during " +
         "orchestration (DriveAgent) to plan how much work to hand off, whether to wait for a reset, or " +
-        "which provider to use. Returns each window's used-% and reset time. Codex reports 5h/7d; " +
+        "which provider to use. Returns each window's used-% and reset time. " +
+        "Codex labels each window by its reported duration (e.g. 5h, 7d; 'primary'/'secondary' if " +
+        "the duration is missing); " +
         "Claude reports whichever windows apply to the account (5h/7d normally, 'overage' when the " +
         "account is running on overage), and marks the currently binding window with '*'. " +
         "COST: 'codex' is free (reads a usage endpoint). 'claude' costs ~1 token (Anthropic exposes " +

package/dist/tools/lsp.js

@@ -3,7 +3,7 @@
  */
 import { getLSPManager } from "../lsp/manager.js";
 import { detectLSPServer } from "../lsp/servers.js";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { isAbsolute, resolve } from "node:path";
 /**
  * How long to wait for `textDocument/publishDiagnostics` after opening a file.
@@ -19,6 +19,12 @@ const DIAGNOSTIC_SEVERITY = {
     3: "info",
     4: "hint",
 };
+/**
+ * Documents this tool has opened on each client, with their last synced
+ * version. LSP allows one didOpen per document; later reads must sync the
+ * current disk text with didChange instead of reopening it.
+ */
+const openDocuments = new WeakMap();
 export const lspToolDef = {
     name: "LSP",
     description: "Use Language Server Protocol for code intelligence operations. " +
@@ -134,9 +140,23 @@ export async function lspTool(args, ctx) {
                     };
                     const timer = setTimeout(() => finish(undefined), DIAGNOSTICS_TIMEOUT_MS);
                     client.on?.("notification", onNotification);
-                    void client.notify("textDocument/didOpen", {
-                        textDocument: { uri, languageId: serverConfig.language, version: 1, text },
-                    });
+                    let versions = openDocuments.get(client);
+                    if (!versions)
+                        openDocuments.set(client, (versions = new Map()));
+                    const openVersion = versions.get(uri);
+                    if (openVersion === undefined) {
+                        versions.set(uri, 1);
+                        void client.notify("textDocument/didOpen", {
+                            textDocument: { uri, languageId: serverConfig.language, version: 1, text },
+                        });
+                    }
+                    else {
+                        versions.set(uri, openVersion + 1);
+                        void client.notify("textDocument/didChange", {
+                            textDocument: { uri, version: openVersion + 1 },
+                            contentChanges: [{ text }],
+                        });
+                    }
                 });
                 if (diagnostics === undefined) {
                     return `No diagnostics published within ${DIAGNOSTICS_TIMEOUT_MS}ms. The server may still be indexing.`;
@@ -184,12 +204,23 @@ function formatLocationResult(result, label) {
     const lines = locations.map((loc) => {
         const uri = loc.uri ?? loc.targetUri ?? "";
         const range = loc.range ?? loc.targetRange ?? {};
-        const path = uri.replace("file://", "");
+        const path = locationPath(uri);
         const line = (range.start?.line ?? 0) + 1;
         return `  ${path}:${line}`;
     });
     return `${label} (${locations.length}):\n${lines.join("\n")}`;
 }
+/** Decode a `file:` URI to a filesystem path; keep other URIs as reported. */
+function locationPath(uri) {
+    if (!uri.startsWith("file:"))
+        return uri;
+    try {
+        return fileURLToPath(uri);
+    }
+    catch {
+        return uri;
+    }
+}
 const SYMBOL_KINDS = {
     1: "File",
     2: "Module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-capability-coding",
-  "version": "0.9.44",
+  "version": "0.9.47",
   "description": "Coding capability pack for the generic code-shell agent core.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.44"
+    "@cjhyy/code-shell-core": "0.9.47"
   },
   "engines": {
     "node": ">=20.10"