Add ACP support with Cursor provider

apps/server/scripts/acp-mock-agent.mjs

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/**
+ * Minimal NDJSON JSON-RPC "agent" for ACP client tests.
+ * Reads stdin lines; writes responses/notifications to stdout.
+ */
+import * as readline from "node:readline";
+import { appendFileSync } from "node:fs";
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+const requestLogPath = process.env.T3_ACP_REQUEST_LOG_PATH;
+const emitToolCalls = process.env.T3_ACP_EMIT_TOOL_CALLS === "1";
+const sessionId = "mock-session-1";
+let currentModeId = "ask";
+let currentModelId = "default";
+let nextRequestId = 1;
+
+function configOptions() {
+  return [
+    {
+      id: "model",
+      name: "Model",
+      category: "model",
+      type: "select",
+      currentValue: currentModelId,
+      options: [
+        { value: "default", name: "Auto" },
+        { value: "composer-2", name: "Composer 2" },
+        { value: "composer-2[fast=true]", name: "Composer 2 Fast" },
+        { value: "gpt-5.3-codex[reasoning=medium,fast=false]", name: "Codex 5.3" },
+      ],
+    },
+  ];
+}
+
+const availableModes = [
+  {
+    id: "ask",
+    name: "Ask",
+    description: "Request permission before making any changes",
+  },
+  {
+    id: "architect",
+    name: "Architect",
+    description: "Design and plan software systems without implementation",
+  },
+  {
+    id: "code",
+    name: "Code",
+    description: "Write and modify code with full tool access",
+  },
+];
+const pendingPermissionRequests = new Map();
+
+function send(obj) {
+  process.stdout.write(`${JSON.stringify(obj)}\n`);
+}
+
+function modeState() {
+  return {
+    currentModeId,
+    availableModes,
+  };
+}
+
+function sendSessionUpdate(update, session = sessionId) {
+  send({
+    jsonrpc: "2.0",
+    method: "session/update",
+    params: {
+      sessionId: session,
+      update,
+    },
+  });
+}
+
+rl.on("line", (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  let msg;
+  try {
+    msg = JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+  if (!msg || typeof msg !== "object") return;
+  if (requestLogPath) {
+    appendFileSync(requestLogPath, `${JSON.stringify(msg)}\n`, "utf8");
+  }
+
+  const id = msg.id;
+  const method = msg.method;
+
+  if (method === undefined && id !== undefined && pendingPermissionRequests.has(id)) {
+    const pending = pendingPermissionRequests.get(id);
+    pendingPermissionRequests.delete(id);
+    sendSessionUpdate(
+      {
+        sessionUpdate: "tool_call_update",
+        toolCallId: pending.toolCallId,
+        title: "Terminal",
+        kind: "execute",
+        status: "completed",
+        rawOutput: {
+          exitCode: 0,
+          stdout: '{ "name": "t3" }',
+          stderr: "",
+        },
+      },
+      pending.sessionId,
+    );
+    sendSessionUpdate(
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "hello from mock" },
+      },
+      pending.sessionId,
+    );
+    send({
+      jsonrpc: "2.0",
+      id: pending.promptRequestId,
+      result: { stopReason: "end_turn" },
+    });
+    return;
+  }
+
+  if (method === "initialize" && id !== undefined) {
+    send({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: 1,
+        agentCapabilities: { loadSession: true },
+      },
+    });
+    return;
+  }
+
+  if (method === "authenticate" && id !== undefined) {
+    send({ jsonrpc: "2.0", id, result: { authenticated: true } });
+    return;
+  }
+
+  if (method === "session/new" && id !== undefined) {
+    send({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        sessionId,
+        modes: modeState(),
+        configOptions: configOptions(),
+      },
+    });
+    return;
+  }
+
+  if (method === "session/load" && id !== undefined) {
+    const requestedSessionId = msg.params?.sessionId ?? sessionId;
+    sendSessionUpdate(
+      {
+        sessionUpdate: "user_message_chunk",
+        content: { type: "text", text: "replay" },
+      },
+      requestedSessionId,
+    );
+    send({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        modes: modeState(),
+        configOptions: configOptions(),
+      },
+    });
+    return;
+  }
+
+  if (method === "session/set_config_option" && id !== undefined) {
+    const configId = msg.params?.configId;
+    const value = msg.params?.value;
+    if (configId === "model" && typeof value === "string") {
+      currentModelId = value;
+    }
+    send({
+      jsonrpc: "2.0",
+      id,
+      result: { configOptions: configOptions() },
+    });
+    return;
+  }
+
+  if (method === "session/prompt" && id !== undefined) {
+    const requestedSessionId = msg.params?.sessionId ?? sessionId;
+    if (emitToolCalls) {
+      const toolCallId = "tool-call-1";
+      const permissionRequestId = nextRequestId++;
+      sendSessionUpdate(
+        {
+          sessionUpdate: "tool_call",
+          toolCallId,
+          title: "Terminal",
+          kind: "execute",
+          status: "pending",
+          rawInput: {
+            command: ["cat", "server/package.json"],
+          },
+        },
+        requestedSessionId,
+      );
+      sendSessionUpdate(
+        {
+          sessionUpdate: "tool_call_update",
+          toolCallId,
+          status: "in_progress",
+        },
+        requestedSessionId,
+      );
+      pendingPermissionRequests.set(permissionRequestId, {
+        promptRequestId: id,
+        sessionId: requestedSessionId,
+        toolCallId,
+      });
+      send({
+        jsonrpc: "2.0",
+        id: permissionRequestId,
+        method: "session/request_permission",
+        params: {
+          sessionId: requestedSessionId,
+          toolCall: {
+            toolCallId,
+            title: "`cat server/package.json`",
+            kind: "execute",
+            status: "pending",
+            content: [
+              {
+                type: "content",
+                content: {
+                  type: "text",
+                  text: "Not in allowlist: cat server/package.json",
+                },
+              },
+            ],
+          },
+          options: [
+            { optionId: "allow-once", name: "Allow once", kind: "allow_once" },
+            { optionId: "allow-always", name: "Allow always", kind: "allow_always" },
+            { optionId: "reject-once", name: "Reject", kind: "reject_once" },
+          ],
+        },
+      });
+      return;
+    }
+    sendSessionUpdate(
+      {
+        sessionUpdate: "plan",
+        explanation: `Mock plan while in ${currentModeId}`,
+        entries: [
+          {
+            content: "Inspect mock ACP state",
+            priority: "high",
+            status: "completed",
+          },
+          {
+            content: "Implement the requested change",
+            priority: "high",
+            status: "in_progress",
+          },
+        ],
+      },
+      requestedSessionId,
+    );
+    sendSessionUpdate(
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "hello from mock" },
+      },
+      requestedSessionId,
+    );
+    send({
+      jsonrpc: "2.0",
+      id,
+      result: { stopReason: "end_turn" },
+    });
+    return;
+  }
+
+  if ((method === "session/set_mode" || method === "session/mode/set") && id !== undefined) {
+    const nextModeId =
+      typeof msg.params?.modeId === "string"
+        ? msg.params.modeId
+        : typeof msg.params?.mode === "string"
+          ? msg.params.mode
+          : undefined;
+    if (typeof nextModeId === "string" && nextModeId.trim()) {
+      currentModeId = nextModeId.trim();
+      sendSessionUpdate({
+        sessionUpdate: "current_mode_update",
+        currentModeId,
+      });
+    }
+    send({ jsonrpc: "2.0", id, result: null });
+    return;
+  }
+
+  if (method === "session/cancel" && id !== undefined) {
+    send({ jsonrpc: "2.0", id, result: null });
+    return;
+  }
+
+  if (id !== undefined) {
+    send({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32601, message: `Unhandled method: ${String(method)}` },
+    });
+  }
+});

apps/server/src/git/Layers/ClaudeTextGeneration.ts

@@ -11,7 +11,6 @@ import { Effect, Layer, Option, Schema, Stream } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 
 import { ClaudeModelSelection } from "@t3tools/contracts";
-import { resolveApiModelId } from "@t3tools/shared/model";
 import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shared/git";
 
 import { TextGenerationError } from "../Errors.ts";
@@ -27,6 +26,7 @@ import {
   sanitizePrTitle,
   toJsonSchemaObject,
 } from "../Utils.ts";
+import { resolveClaudeApiModelId } from "../../provider/Layers/ClaudeModelId.ts";
 import { normalizeClaudeModelOptions } from "../../provider/Layers/ClaudeProvider.ts";
 import { ServerSettingsService } from "../../serverSettings.ts";
 
@@ -104,7 +104,7 @@ const makeClaudeTextGeneration = Effect.gen(function* () {
             "--json-schema",
             jsonSchemaStr,
             "--model",
-            resolveApiModelId(modelSelection),
+            resolveClaudeApiModelId(modelSelection),
             ...(normalizedOptions?.effort ? ["--effort", normalizedOptions.effort] : []),
             ...(Object.keys(settings).length > 0 ? ["--settings", JSON.stringify(settings)] : []),
             "--dangerously-skip-permissions",

apps/server/src/git/Services/TextGeneration.ts

@@ -13,7 +13,7 @@ import type { ChatAttachment, ModelSelection } from "@t3tools/contracts";
 import type { TextGenerationError } from "../Errors.ts";
 
 /** Providers that support git text generation (commit messages, PR content, branch names). */
-export type TextGenerationProvider = "codex" | "claudeAgent";
+export type TextGenerationProvider = "codex" | "claudeAgent" | "cursor";
 
 export interface CommitMessageGenerationInput {
   cwd: string;