@rely-ai/caliber 1.22.0-dev.1773766400 → 1.22.0-dev.1773767049

package/dist/bin.js

@@ -159,12 +159,12 @@ __export(constants_exports, {
   MANIFEST_FILE: () => MANIFEST_FILE
 });
 import path9 from "path";
-import os3 from "os";
+import os2 from "os";
 var AUTH_DIR, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR, LEARNING_DIR, LEARNING_SESSION_FILE, LEARNING_STATE_FILE, LEARNING_MAX_EVENTS, LEARNING_ROI_FILE;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
-    AUTH_DIR = path9.join(os3.homedir(), ".caliber");
+    AUTH_DIR = path9.join(os2.homedir(), ".caliber");
     CALIBER_DIR = ".caliber";
     MANIFEST_FILE = path9.join(CALIBER_DIR, "manifest.json");
     BACKUPS_DIR = path9.join(CALIBER_DIR, "backups");
@@ -185,7 +185,7 @@ __export(lock_exports, {
 });
 import fs29 from "fs";
 import path23 from "path";
-import os6 from "os";
+import os5 from "os";
 function isCaliberRunning() {
   try {
     if (!fs29.existsSync(LOCK_FILE)) return false;
@@ -218,7 +218,7 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path23.join(os6.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path23.join(os5.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
@@ -1205,198 +1205,125 @@ var OpenAICompatProvider = class {
 
 // src/llm/cursor-acp.ts
 import { spawn, execSync as execSync3 } from "child_process";
-import readline from "readline";
-import os2 from "os";
-var ACP_AGENT_BIN = "agent";
+var AGENT_BIN = "agent";
 var IS_WINDOWS = process.platform === "win32";
 var CursorAcpProvider = class {
   defaultModel;
   cursorApiKey;
-  connections = /* @__PURE__ */ new Map();
-  connectPromises = /* @__PURE__ */ new Map();
-  shutdownRequested = false;
   constructor(config) {
     this.defaultModel = config.model || "sonnet-4.6";
     this.cursorApiKey = process.env.CURSOR_API_KEY ?? process.env.CURSOR_AUTH_TOKEN;
-    process.once("exit", () => this.shutdown());
   }
   async call(options) {
-    const chunks = [];
-    await this.runPrompt(options, {
-      onText: (text) => chunks.push(text),
-      onEnd: () => {
-      },
-      onError: () => {
-      }
-    });
-    return chunks.join("");
+    const prompt = this.buildPrompt(options);
+    const model = options.model || this.defaultModel;
+    return this.runPrint(model, prompt);
   }
   async stream(options, callbacks) {
-    await this.runPrompt(options, callbacks);
-  }
-  shutdown() {
-    this.shutdownRequested = true;
-    for (const conn of this.connections.values()) {
-      conn.child.stdin?.end();
-      conn.child.kill("SIGTERM");
-    }
-    this.connections.clear();
-    this.connectPromises.clear();
-  }
-  // -- Connection pool --------------------------------------------------------
-  resolveModel(options) {
-    return options.model || this.defaultModel;
-  }
-  async ensureConnection(model) {
-    const existing = this.connections.get(model);
-    if (existing && !existing.child.killed) return existing;
-    const pending = this.connectPromises.get(model);
-    if (pending) {
-      await pending;
-      return this.connections.get(model);
-    }
-    const promise = this.connect(model);
-    this.connectPromises.set(model, promise);
-    try {
-      await promise;
-    } catch (err) {
-      this.connectPromises.delete(model);
-      throw err;
-    }
-    return this.connections.get(model);
+    const prompt = this.buildPrompt(options);
+    const model = options.model || this.defaultModel;
+    return this.runPrintStream(model, prompt, callbacks);
   }
-  async connect(model) {
-    const args = ["acp"];
+  buildArgs(model, streaming) {
+    const args = ["--print"];
     if (model && model !== "auto" && model !== "default") {
-      args.unshift("--model", model);
+      args.push("--model", model);
+    }
+    if (streaming) {
+      args.push("--output-format", "stream-json", "--stream-partial-output");
     }
     if (this.cursorApiKey) {
-      args.unshift("--api-key", this.cursorApiKey);
+      args.push("--api-key", this.cursorApiKey);
     }
-    const child = spawn(ACP_AGENT_BIN, args, {
-      stdio: ["pipe", "pipe", "ignore"],
-      cwd: process.cwd(),
-      env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
-      ...IS_WINDOWS && { shell: true }
-    });
-    const conn = {
-      child,
-      rl: readline.createInterface({ input: child.stdout, crlfDelay: Infinity }),
-      pending: /* @__PURE__ */ new Map(),
-      nextId: 1,
-      activeCallbacks: null
-    };
-    conn.rl.on("line", (line) => this.handleLine(conn, line));
-    child.on("error", (err) => {
-      for (const w of conn.pending.values()) w.reject(err);
-      conn.pending.clear();
-      conn.activeCallbacks?.onError(err);
-    });
-    child.on("close", () => {
-      if (!this.shutdownRequested) {
-        const err = new Error("Cursor agent process exited unexpectedly");
-        for (const w of conn.pending.values()) w.reject(err);
-        conn.pending.clear();
-        conn.activeCallbacks?.onError(err);
-      }
-      this.connections.delete(model);
-      this.connectPromises.delete(model);
-    });
-    this.connections.set(model, conn);
-    await this.send(conn, "initialize", {
-      protocolVersion: 1,
-      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
-      clientInfo: { name: "caliber", version: "1.0.0" }
-    });
-    await this.send(conn, "authenticate", { methodId: "cursor_login" });
+    return args;
   }
-  // -- JSON-RPC ---------------------------------------------------------------
-  send(conn, method, params) {
-    if (!conn.child.stdin) {
-      return Promise.reject(new Error("Cursor agent not connected"));
-    }
+  runPrint(model, prompt) {
     return new Promise((resolve2, reject) => {
-      const id = conn.nextId++;
-      conn.pending.set(id, { resolve: resolve2, reject });
-      const msg = { jsonrpc: "2.0", id, method, params };
-      conn.child.stdin.write(JSON.stringify(msg) + "\n", (err) => {
-        if (err) {
-          conn.pending.delete(id);
-          reject(err);
+      const args = this.buildArgs(model, false);
+      const child = spawn(AGENT_BIN, args, {
+        stdio: ["pipe", "pipe", "ignore"],
+        env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
+        ...IS_WINDOWS && { shell: true }
+      });
+      const chunks = [];
+      child.stdout.on("data", (data) => {
+        chunks.push(data);
+      });
+      child.on("error", reject);
+      child.on("close", (code) => {
+        const output = Buffer.concat(chunks).toString("utf-8").trim();
+        if (code !== 0 && !output) {
+          reject(new Error(`Cursor agent exited with code ${code}`));
+        } else {
+          resolve2(output);
         }
       });
+      child.stdin.write(prompt);
+      child.stdin.end();
     });
   }
-  handleLine(conn, line) {
-    let msg;
-    try {
-      msg = JSON.parse(line);
-    } catch {
-      return;
-    }
-    if (msg.id != null && (msg.result !== void 0 || msg.error !== void 0)) {
-      const waiter = conn.pending.get(msg.id);
-      if (waiter) {
-        conn.pending.delete(msg.id);
-        if (msg.error) {
-          waiter.reject(new Error(msg.error.message || "ACP error"));
-        } else {
-          waiter.resolve(msg.result);
+  runPrintStream(model, prompt, callbacks) {
+    return new Promise((resolve2, reject) => {
+      const args = this.buildArgs(model, true);
+      const child = spawn(AGENT_BIN, args, {
+        stdio: ["pipe", "pipe", "ignore"],
+        env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
+        ...IS_WINDOWS && { shell: true }
+      });
+      let buffer = "";
+      child.stdout.on("data", (data) => {
+        buffer += data.toString("utf-8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "assistant") {
+              const text = event.message?.content?.[0]?.text || event.content;
+              if (text) callbacks.onText(text);
+            } else if (event.type === "result") {
+              callbacks.onEnd({ stopReason: "end_turn" });
+            }
+          } catch {
+            callbacks.onText(line);
+          }
         }
-      }
-      if (msg.result && typeof msg.result === "object" && "stopReason" in msg.result) {
-        conn.activeCallbacks?.onEnd({
-          stopReason: msg.result.stopReason
-        });
-      }
-      return;
-    }
-    if (msg.method === "session/update" && msg.params?.update) {
-      const update = msg.params.update;
-      if (update.sessionUpdate === "agent_message_chunk" && update.content?.text) {
-        conn.activeCallbacks?.onText(update.content.text);
-      }
-      return;
-    }
-    if (msg.method === "session/request_permission" && msg.id != null) {
-      const response = JSON.stringify({
-        jsonrpc: "2.0",
-        id: msg.id,
-        result: { outcome: { outcome: "selected", optionId: "allow-once" } }
-      }) + "\n";
-      conn.child.stdin?.write(response);
-    }
-  }
-  // -- Prompt execution -------------------------------------------------------
-  async runPrompt(options, callbacks) {
-    const model = this.resolveModel(options);
-    const conn = await this.ensureConnection(model);
-    conn.activeCallbacks = callbacks;
-    try {
-      const sessionResult = await this.send(conn, "session/new", {
-        cwd: os2.tmpdir(),
-        mcpServers: []
       });
-      await this.send(conn, "session/prompt", {
-        sessionId: sessionResult.sessionId,
-        prompt: [{ type: "text", text: this.buildCombinedPrompt(options) }]
+      child.on("error", (err) => {
+        callbacks.onError(err);
+        reject(err);
       });
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      callbacks.onError(error);
-      throw error;
-    } finally {
-      conn.activeCallbacks = null;
-    }
+      child.on("close", (code) => {
+        if (buffer.trim()) {
+          try {
+            const event = JSON.parse(buffer);
+            if (event.type === "assistant") {
+              const text = event.message?.content?.[0]?.text || event.content;
+              if (text) callbacks.onText(text);
+            } else if (event.type === "result") {
+              callbacks.onEnd({ stopReason: "end_turn" });
+            }
+          } catch {
+            callbacks.onText(buffer);
+          }
+        }
+        if (code !== 0 && code !== null) {
+          const err = new Error(`Cursor agent exited with code ${code}`);
+          callbacks.onError(err);
+          reject(err);
+        } else {
+          resolve2();
+        }
+      });
+      child.stdin.write(prompt);
+      child.stdin.end();
+    });
   }
-  buildCombinedPrompt(options) {
+  buildPrompt(options) {
     const streamOpts = options;
     const hasHistory = streamOpts.messages && streamOpts.messages.length > 0;
     let combined = "";
-    combined += "IMPORTANT: You are being used as a direct LLM, not as a coding agent. ";
-    combined += "Do NOT use tools, do NOT read or write files, do NOT check the repository. ";
-    combined += "Process the prompt below and output your response directly in your message. ";
-    combined += "Follow the system instructions exactly.\n\n";
     combined += "[[System]]\n" + options.system + "\n\n";
     if (hasHistory) {
       for (const msg of streamOpts.messages) {
@@ -1412,7 +1339,7 @@ ${msg.content}
 };
 function isCursorAgentAvailable() {
   try {
-    const cmd = process.platform === "win32" ? `where ${ACP_AGENT_BIN}` : `which ${ACP_AGENT_BIN}`;
+    const cmd = process.platform === "win32" ? `where ${AGENT_BIN}` : `which ${AGENT_BIN}`;
     execSync3(cmd, { stdio: "ignore" });
     return true;
   } catch {
@@ -3291,9 +3218,9 @@ import { createTwoFilesPatch } from "diff";
 import { execSync as execSync5, spawn as spawn3 } from "child_process";
 import fs14 from "fs";
 import path12 from "path";
-import os4 from "os";
+import os3 from "os";
 var IS_WINDOWS3 = process.platform === "win32";
-var DIFF_TEMP_DIR = path12.join(os4.tmpdir(), "caliber-diff");
+var DIFF_TEMP_DIR = path12.join(os3.tmpdir(), "caliber-diff");
 function getEmptyFilePath(proposedPath) {
   fs14.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
   const tempPath = path12.join(DIFF_TEMP_DIR, path12.basename(proposedPath));
@@ -4056,9 +3983,9 @@ var SpinnerMessages = class {
 
 // src/utils/prompt.ts
 import chalk4 from "chalk";
-import readline2 from "readline";
+import readline from "readline";
 function promptInput(question) {
-  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
     rl.question(chalk4.cyan(`${question} `), (answer) => {
       rl.close();
@@ -5719,10 +5646,10 @@ import chalk7 from "chalk";
 // src/telemetry/config.ts
 import fs23 from "fs";
 import path18 from "path";
-import os5 from "os";
+import os4 from "os";
 import crypto3 from "crypto";
 import { execSync as execSync12 } from "child_process";
-var CONFIG_DIR2 = path18.join(os5.homedir(), ".caliber");
+var CONFIG_DIR2 = path18.join(os4.homedir(), ".caliber");
 var CONFIG_FILE2 = path18.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rely-ai/caliber",
-  "version": "1.22.0-dev.1773766400",
+  "version": "1.22.0-dev.1773767049",
   "description": "Analyze your codebase and generate optimized AI agent configs (CLAUDE.md, .cursorrules, skills) — no API key needed",
   "type": "module",
   "bin": {