amp-acp 0.2.0 → 0.3.7

package/AGENTS.md

@@ -0,0 +1,22 @@
+# AGENTS.md
+
+## Commands
+- `npm start` or `node src/index.js` — Run the ACP adapter
+- `npm run lint` — Lint (currently a no-op)
+- `npm test` — Test (currently a no-op)
+
+## Architecture
+This is an ACP (Agent Client Protocol) adapter that bridges Amp Code to ACP-compatible clients like Zed.
+
+- `src/index.js` — Entry point, redirects console to stderr (stdout reserved for ACP stream)
+- `src/run-acp.js` — Sets up ACP connection using stdin/stdout JSON streams
+- `src/server.js` — `AmpAcpAgent` class: handles sessions, prompts, MCP config, and calls `@sourcegraph/amp-sdk`
+- `src/to-acp.js` — Converts Amp stream events to ACP `sessionUpdate` notifications
+- `src/utils.js` — Node-to-Web stream converters
+
+## Code Style
+- ES modules (`"type": "module"` in package.json), use `.js` extension in imports
+- No TypeScript; plain JavaScript with JSDoc if needed
+- Use `console.error` for logging (stdout is for ACP protocol only)
+- Error handling: throw `RequestError` from `@agentclientprotocol/sdk` for protocol errors
+- Naming: camelCase for variables/functions, PascalCase for classes

package/README.md

@@ -1,16 +1,34 @@
 # ACP adapter for AmpCode
 
-Use [Amp](https://ampcode.com) from [ACP](https://agentclientprotocol.com/)-compatible clients such as [Zed](https://zed.dev).
+![Screenshot](img/screenshot.png)
+
+Use [Amp](https://ampcode.com) from [ACP](https://agentclientprotocol.com/)-compatible clients such as [Zed](https://zed.dev) or [Toad](https://github.com/batrachianai/toad).
 
 ## Prerequisites
 
-- [Amp CLI](https://ampcode.com) installed and authenticated (`amp login`)
-- Node.js (for running the adapter)
+- Node.js 18+ (the adapter will be installed automatically via `npx`)
 
 ## Installation
 
 Add to your Zed `settings.json` (open with `cmd+,` or `ctrl+,`):
 
+```json
+{
+  "agent_servers": {
+    "Amp": {
+      "command": "npx",
+      "args": ["-y", "amp-acp"]
+    }
+  }
+}
+```
+
+That's it! The SDK handles authentication and Amp integration automatically.
+
+## First Use
+
+**If you don't have Amp CLI installed**: Add the `AMP_API_KEY` environment variable to your Zed config. You can get your API key from https://ampcode.com/settings
+
 ```json
 {
   "agent_servers": {
@@ -18,22 +36,27 @@ Add to your Zed `settings.json` (open with `cmd+,` or `ctrl+,`):
       "command": "npx",
       "args": ["-y", "amp-acp"],
       "env": {
-        "AMP_EXECUTABLE": "path of AMP bin",
-        "AMP_PREFER_SYSTEM_PATH": "1"
+        "AMP_API_KEY": "your-api-key-here"
       }
     }
   }
 }
 ```
 
-Replace `"path of AMP bin"` with your Amp CLI path (e.g., `/usr/local/bin/amp`).
+**If you [have Amp CLI installed](https://ampcode.com/manual#getting-started-command-line-interface)**: Run `amp login` first to authenticate.
 
 ## How it Works
 
-- Streams Amp's JSON over ACP
-- Renders Amp messages and interactions in Zed
+- Uses the official Amp SDK to communicate with AmpCode
+- Streams Amp's responses over the Agent Client Protocol (ACP)
+- Renders Amp messages and interactions natively in Zed
 - Tool permissions are handled by Amp (no additional configuration needed)
+- Supports conversation continuity across multiple prompts
 
 ## Troubleshooting
 
-**Connection fails**: Ensure `amp login` was successful and the CLI is in your `AMP_EXECUTABLE`.
+**Adapter doesn't start**: Make sure you have Node.js 18 or later installed. Run `node --version` to check.
+
+**Connection issues**: Restart Zed and try again. The adapter creates a fresh connection each time.
+
+**Tool execution problems**: Check Zed's output panel for detailed error messages from the Amp SDK.

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "amp-acp",
-  "version": "0.2.0",
+  "version": "0.3.7",
   "private": false,
   "type": "module",
   "bin": {
     "amp-acp": "src/index.js"
   },
-  "description": "ACP adapter that bridges Amp CLI to Agent Client Protocol (Zed external agent)",
+  "description": "ACP adapter that bridges Amp Code to Agent Client Protocol (Zed external agent)",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tao12345666333/amp-acp"
+  },
   "scripts": {
     "start": "node src/index.js",
     "lint": "echo 'no lint'",
     "test": "node -e 'console.log(\"OK\")'"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.4.8"
+    "@agentclientprotocol/sdk": "0.4.8",
+    "@sourcegraph/amp": "^0.0.1765685598-g5365e6",
+    "@sourcegraph/amp-sdk": "^0.1.0-20251214200908-g3251f72"
   }
-}
+}

package/src/server.js

@@ -1,6 +1,5 @@
 import { RequestError } from '@agentclientprotocol/sdk';
-import { spawn } from 'node:child_process';
-import readline from 'node:readline';
+import { execute } from '@sourcegraph/amp-sdk';
 import { toAcpNotifications } from './to-acp.js';
 
 export class AmpAcpAgent {
@@ -15,6 +14,7 @@ export class AmpAcpAgent {
       protocolVersion: 1,
       agentCapabilities: {
         promptCapabilities: { image: true, embeddedContext: true },
+        mcpCapabilities: { http: true, sse: true },
       },
       authMethods: [],
     };
@@ -23,27 +23,64 @@ export class AmpAcpAgent {
   async newSession(params) {
     const sessionId = `S-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 
+    // Convert ACP mcpServers to Amp SDK mcpConfig format
+    const mcpConfig = {};
+    if (Array.isArray(params.mcpServers)) {
+      for (const server of params.mcpServers) {
+        if ('type' in server && (server.type === 'http' || server.type === 'sse')) {
+          // HTTP/SSE type - Amp SDK may not support this directly
+          // Skip for now or handle if SDK supports it
+        } else {
+          // stdio type
+          mcpConfig[server.name] = {
+            command: server.command,
+            args: server.args,
+            env: server.env ? Object.fromEntries(server.env.map((e) => [e.name, e.value])) : undefined,
+          };
+        }
+      }
+    }
+
     this.sessions.set(sessionId, {
-      proc: null,
-      rl: null,
-      queue: null,
+      threadId: null,
+      controller: null,
       cancelled: false,
       active: false,
+      mode: 'default',
+      mcpConfig,
     });
 
-    return {
+    const result = {
       sessionId,
-      models: { currentModelId: 'default', availableModels: [{ modelId: 'default', name: 'Default', description: 'Amp default' }] },
       modes: {
         currentModeId: 'default',
         availableModes: [
-          { id: 'default', name: 'Always Ask', description: 'Prompts for permission on first use of each tool' },
-          { id: 'acceptEdits', name: 'Accept Edits', description: 'Automatically accepts file edit permissions for the session' },
-          { id: 'bypassPermissions', name: 'Bypass Permissions', description: 'Skips all permission prompts' },
-          { id: 'plan', name: 'Plan Mode', description: 'Analyze but not modify files or execute commands' },
+          { id: 'default', name: 'Default', description: 'Prompts for permission on first use of each tool' },
+          { id: 'bypass', name: 'Bypass', description: 'Skips all permission prompts' },
         ],
       },
     };
+
+    setImmediate(async () => {
+      try {
+        await this.client.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: 'available_commands_update',
+            availableCommands: [
+              {
+                name: 'init',
+                description: 'Generate an AGENTS.md file for the project',
+              },
+            ],
+          },
+        });
+      } catch (e) {
+        console.error('[acp] failed to send available_commands_update', e);
+      }
+    });
+
+    return result;
   }
 
   async authenticate(_params) {
@@ -56,56 +93,23 @@ export class AmpAcpAgent {
     s.cancelled = false;
     s.active = true;
 
-    // Start a fresh Amp process per turn. Amp does not expose the Claude Code JSON stream flags;
-    // we pipe plain text and stream stdout lines back to ACP.
-    const ampCmd = process.env.AMP_EXECUTABLE || 'amp';
-    const spawnEnv = { ...process.env };
-    if (process.env.AMP_PREFER_SYSTEM_PATH === '1' && spawnEnv.PATH) {
-      // Drop npx/npm-local node_modules/.bin segments so we pick the system 'amp'
-      const parts = spawnEnv.PATH.split(':').filter((p) => !/\bnode_modules\/\.bin\b|\/_npx\//.test(p));
-      spawnEnv.PATH = parts.join(':');
-    }
-    const proc = spawn(ampCmd, ['--no-notifications'], {
-      cwd: params.cwd || process.cwd(),
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: spawnEnv,
-    });
-
-    const rlOut = readline.createInterface({ input: proc.stdout });
-    const rlErr = readline.createInterface({ input: proc.stderr });
-
-    s.proc = proc;
-    s.rl = rlOut;
-    s.queue = null;
-
-    let hadOutput = false;
-
-    rlOut.on('line', async (line) => {
-      hadOutput = true;
-      if (!line) return;
-      try {
-        await this.client.sessionUpdate({
-          sessionId: params.sessionId,
-          update: {
-            sessionUpdate: 'agent_message_chunk',
-            content: { type: 'text', text: line },
-          },
-        });
-      } catch (e) {
-        console.error('[acp] sessionUpdate failed', e);
-      }
-    });
-
-    rlErr.on('line', (line) => {
-      console.error(`[amp] ${line}`);
-    });
-
     // Build plain-text input for Amp from ACP prompt chunks
     let textInput = '';
     for (const chunk of params.prompt) {
       switch (chunk.type) {
         case 'text':
-          textInput += chunk.text;
+          if (chunk.text.trim() === '/init') {
+            textInput += `Please analyze this codebase and create an AGENTS.md file containing:
+1. Build/lint/test commands - especially for running a single test
+2. Architecture and codebase structure information, including important subprojects, internal APIs, databases, etc.
+3. Code style guidelines, including imports, conventions, formatting, types, naming conventions, error handling, etc.
+
+The file you create will be given to agentic coding tools (such as yourself) that operate in this repository. Make it about 20 lines long.
+
+If there are Cursor rules (in .cursor/rules/ or .cursorrules), Claude rules (CLAUDE.md), Windsurf rules (.windsurfrules), Cline rules (.clinerules), Goose rules (.goosehints), or Copilot rules (in .github/copilot-instructions.md), make sure to include them. Also, first check if there is an existing AGENTS.md or AGENT.md file, and if so, update it instead of overwriting it.`;
+          } else {
+            textInput += chunk.text;
+          }
           break;
         case 'resource_link':
           textInput += `\n${chunk.uri}\n`;
@@ -116,92 +120,89 @@ export class AmpAcpAgent {
           }
           break;
         case 'image':
-          // Images not supported by Amp CLI via stdin; ignore for now
+          // Images not supported by Amp SDK yet via simple prompt string; ignore for now
           break;
         default:
           break;
       }
     }
-    if (!textInput.endsWith('\n')) textInput += '\n';
 
-    proc.stdin.write(textInput);
-    proc.stdin.end();
+    const options = {
+      cwd: params.cwd || process.cwd(),
+    };
+
+    if (s.mode === 'bypass') {
+      options.dangerouslyAllowAll = true;
+    }
+
+    if (Object.keys(s.mcpConfig).length > 0) {
+      options.mcpConfig = s.mcpConfig;
+    }
+
+    if (s.threadId) {
+      options.continue = s.threadId;
+    }
+
+    const controller = new AbortController();
+    s.controller = controller;
 
     try {
-      await new Promise((resolve) => {
-        proc.on('close', () => {
-          try { rlOut.close(); } catch {}
-          try { rlErr.close(); } catch {}
-          resolve();
-        });
-      });
-      return { stopReason: s.cancelled ? 'cancelled' : (hadOutput ? 'end_turn' : 'refusal') };
+      for await (const message of execute({ prompt: textInput, options, signal: controller.signal })) {
+        if (!s.threadId && message.session_id) {
+          s.threadId = message.session_id;
+        }
+
+        if (message.type === 'assistant') {
+          for (const n of toAcpNotifications(message, params.sessionId)) {
+            try {
+              await this.client.sessionUpdate(n);
+            } catch (e) {
+              console.error('[acp] sessionUpdate failed', e);
+            }
+          }
+        }
+
+        if (message.type === 'result' && message.is_error) {
+          await this.client.sessionUpdate({
+            sessionId: params.sessionId,
+            update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: `Error: ${message.error}` } },
+          });
+        }
+      }
+
+      return { stopReason: s.cancelled ? 'cancelled' : 'end_turn' };
+    } catch (err) {
+      if (s.cancelled || (err.name === 'AbortError') || err.message.includes('aborted')) {
+        return { stopReason: 'cancelled' };
+      }
+      console.error('[amp] Execution error:', err);
+      throw err;
     } finally {
       s.active = false;
       s.cancelled = false;
+      s.controller = null;
     }
   }
 
   async cancel(params) {
     const s = this.sessions.get(params.sessionId);
     if (!s) return {};
-    if (s.active && s.proc) {
+    if (s.active && s.controller) {
       s.cancelled = true;
-      try { s.proc.kill('SIGINT'); } catch {}
-      // ensure readers unblock
-      try { s.queue?.end?.(); } catch {}
+      s.controller.abort();
     }
     return {};
   }
 
   async setSessionModel(_params) { return {}; }
 
-  async setSessionMode(_params) { return {}; }
+  async setSessionMode(params) {
+    const s = this.sessions.get(params.sessionId);
+    if (!s) throw new Error('Session not found');
+    s.mode = params.modeId;
+    return {};
+  }
 
   async readTextFile(params) { return this.client.readTextFile(params); }
   async writeTextFile(params) { return this.client.writeTextFile(params); }
 }
-
-function createJsonQueue(rl) {
-  const buf = [];
-  const waiters = [];
-  rl.on('line', (line) => {
-    let obj;
-    try {
-      obj = JSON.parse(line);
-    } catch {
-      return; // ignore non-JSON
-    }
-    if (waiters.length) {
-      const resolve = waiters.shift();
-      resolve(obj);
-    } else {
-      buf.push(obj);
-    }
-  });
-  let ended = false;
-  function end() {
-    if (ended) return;
-    ended = true;
-    while (waiters.length) {
-      const resolve = waiters.shift();
-      resolve(null);
-    }
-  }
-  rl.on('close', end);
-  rl.on('SIGINT', end);
-  return {
-    next() {
-      return new Promise((resolve) => {
-        if (buf.length) {
-          resolve(buf.shift());
-        } else if (ended) {
-          resolve(null);
-        } else {
-          waiters.push(resolve);
-        }
-      });
-    },
-    end,
-  };
-}