acp-extension-claude 0.13.1

package/dist/utils.js

@@ -0,0 +1,150 @@
+// A pushable async iterable: allows you to push items and consume them with for-await.
+import { WritableStream, ReadableStream } from "node:stream/web";
+import { readFileSync } from "node:fs";
+import { getManagedSettingsPath } from "./settings.js";
+// Useful for bridging push-based and async-iterator-based code.
+export class Pushable {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.done = false;
+    }
+    push(item) {
+        if (this.resolvers.length > 0) {
+            const resolve = this.resolvers.shift();
+            resolve({ value: item, done: false });
+        }
+        else {
+            this.queue.push(item);
+        }
+    }
+    end() {
+        this.done = true;
+        while (this.resolvers.length > 0) {
+            const resolve = this.resolvers.shift();
+            resolve({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    const value = this.queue.shift();
+                    return Promise.resolve({ value, done: false });
+                }
+                if (this.done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}
+// Helper to convert Node.js streams to Web Streams
+export function nodeToWebWritable(nodeStream) {
+    return new WritableStream({
+        write(chunk) {
+            return new Promise((resolve, reject) => {
+                nodeStream.write(Buffer.from(chunk), (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        },
+    });
+}
+export function nodeToWebReadable(nodeStream) {
+    return new ReadableStream({
+        start(controller) {
+            nodeStream.on("data", (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            });
+            nodeStream.on("end", () => controller.close());
+            nodeStream.on("error", (err) => controller.error(err));
+        },
+    });
+}
+export function unreachable(value, logger = console) {
+    let valueAsString;
+    try {
+        valueAsString = JSON.stringify(value);
+    }
+    catch {
+        valueAsString = value;
+    }
+    logger.error(`Unexpected case: ${valueAsString}`);
+}
+export function sleep(time) {
+    return new Promise((resolve) => setTimeout(resolve, time));
+}
+export function loadManagedSettings() {
+    try {
+        return JSON.parse(readFileSync(getManagedSettingsPath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function applyEnvironmentSettings(settings) {
+    if (settings.env) {
+        for (const [key, value] of Object.entries(settings.env)) {
+            process.env[key] = value;
+        }
+    }
+}
+/**
+ * Extracts lines from file content with byte limit enforcement.
+ *
+ * @param fullContent - The complete file content
+ * @param maxContentLength - Maximum number of UTF-16 Code Units to return
+ * @returns Object containing extracted content and metadata
+ */
+export function extractLinesWithByteLimit(fullContent, maxContentLength) {
+    if (fullContent === "") {
+        return {
+            content: "",
+            wasLimited: false,
+            linesRead: 1,
+        };
+    }
+    let linesSeen = 0;
+    let index = 0;
+    linesSeen = 0;
+    let contentLength = 0;
+    let wasLimited = false;
+    while (true) {
+        const nextIndex = fullContent.indexOf("\n", index);
+        if (nextIndex < 0) {
+            // Last line in file (no trailing newline)
+            if (linesSeen > 0 && fullContent.length > maxContentLength) {
+                wasLimited = true;
+                break;
+            }
+            linesSeen += 1;
+            contentLength = fullContent.length;
+            break;
+        }
+        else {
+            // Line with newline - include up to the newline
+            const newContentLength = nextIndex + 1;
+            if (linesSeen > 0 && newContentLength > maxContentLength) {
+                wasLimited = true;
+                break;
+            }
+            linesSeen += 1;
+            contentLength = newContentLength;
+            index = newContentLength;
+        }
+    }
+    return {
+        content: fullContent.slice(0, contentLength),
+        wasLimited,
+        linesRead: linesSeen,
+    };
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "acp-extension-claude",
+  "version": "0.13.1",
+  "description": "Forked ACP-compatible coding agent with improved timeout handling and logging",
+  "main": "dist/lib.js",
+  "types": "dist/lib.d.ts",
+  "bin": {
+    "claude-code-acp": "./dist/index.js"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/lib.d.ts",
+      "import": "./dist/lib.js"
+    },
+    "./*": "./*"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "keywords": [
+    "claude",
+    "acp",
+    "agent",
+    "anthropic",
+    "typescript",
+    "sdk",
+    "code",
+    "lody"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@agentclientprotocol/sdk": "0.13.0",
+    "@anthropic-ai/claude-agent-sdk": "0.2.7",
+    "@modelcontextprotocol/sdk": "1.25.2",
+    "diff": "8.0.3",
+    "minimatch": "10.1.1",
+    "acp-extension-core": "0.0.1"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "0.71.2",
+    "zod": "^3.25.0",
+    "@types/node": "25.0.8",
+    "@typescript-eslint/eslint-plugin": "8.53.0",
+    "@typescript-eslint/parser": "8.53.0",
+    "eslint": "9.39.2",
+    "eslint-config-prettier": "10.1.8",
+    "globals": "17.0.0",
+    "prettier": "3.8.0",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3",
+    "vitest": "4.0.17"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "npm run build && npm run start",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "check": "npm run lint && npm run format:check",
+    "test": "vitest",
+    "test:integration": "RUN_INTEGRATION_TESTS=true vitest run",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}