@anhlp/alp 0.0.0-beta.1

package/packages/cli/dist/acp/agent.js

@@ -0,0 +1,390 @@
+// packages/cli/src/acp/agent.ts
+import * as acp from "@agentclientprotocol/sdk";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+var MODES = [
+  { id: "read-only", name: "Read only", description: "Agents read and search; nothing is changed" },
+  { id: "workspace-write", name: "Workspace write", description: "Agents change files and run commands inside the project" },
+  { id: "full-access", name: "Full access", description: "Agents may do anything, without a sandbox" }
+];
+var OUTPUT_CHARS = 2e4;
+var COMMANDS = [
+  { name: "answer", description: "Answer the question an agent asked you", input: { hint: "your answer" } },
+  { name: "dismiss", description: "Dismiss the question an agent asked you", input: { hint: "why (optional)" } }
+];
+function hostServers(servers = []) {
+  const host = {};
+  for (const server of servers) {
+    if ("command" in server) host[server.name] = { type: "stdio", command: server.command, args: server.args, env: Object.fromEntries(server.env.map((variable) => [variable.name, variable.value])) };
+    else if (server.type === "http" || server.type === "sse") host[server.name] = { type: server.type, url: server.url, headers: Object.fromEntries(server.headers.map((header) => [header.name, header.value])) };
+  }
+  return host;
+}
+function promptText(blocks) {
+  let text = "";
+  for (const block of blocks) {
+    if (block.type === "text") {
+      text += block.text;
+      continue;
+    }
+    let part = "";
+    if (block.type === "resource_link") part = `@${block.uri.replace(/^file:\/\//, "")}`;
+    else if (block.type === "resource") {
+      const { resource } = block;
+      const where = resource.uri.replace(/^file:\/\//, "");
+      part = "text" in resource ? `
+<file path="${where}">
+${resource.text}
+</file>
+` : `@${where}`;
+    }
+    if (part && text && !/\s$/.test(text) && !part.startsWith("\n")) text += " ";
+    text += part;
+  }
+  return text.trim();
+}
+function toolKind(item) {
+  const word = item.detail.type === "shell" ? String(item.detail.command ?? "").trim().split(/[\s{(]/)[0] : item.name;
+  if (/^(Read|NotebookRead|LS)$/.test(word)) return "read";
+  if (/^(Edit|MultiEdit|Write|NotebookEdit)$/.test(word)) return "edit";
+  if (/^(Grep|Glob)$/.test(word)) return "search";
+  if (/^(WebFetch|WebSearch)$/.test(word)) return "fetch";
+  if (/^(Skill|Task|TodoWrite)$/.test(word) || item.name.startsWith("alp_")) return "other";
+  return item.detail.type === "shell" ? "execute" : "other";
+}
+function toolTitle(item) {
+  if (item.detail.type === "shell") return clip(String(item.detail.command ?? "").split("\n")[0], 160);
+  const input = item.detail.input ?? {};
+  if (item.name === "alp_delegate") return clip(`Delegate to ${input.agent ?? "an agent"}: ${String(input.task ?? "").split("\n")[0]}`, 160);
+  return clip(`${item.name} ${JSON.stringify(input)}`, 160);
+}
+function toolOutput(item) {
+  let text = "";
+  if (item.detail.type === "shell") text = item.detail.output ?? "";
+  else {
+    const output = item.detail.output;
+    text = Array.isArray(output) ? output.map((part) => typeof part?.text === "string" ? part.text : JSON.stringify(part)).join("\n") : output == null ? "" : typeof output === "string" ? output : JSON.stringify(output, null, 2);
+  }
+  if (item.error) text = text ? `${text}
+${item.error}` : item.error;
+  if (!text) return [];
+  if (text.length > OUTPUT_CHARS) text = `${text.slice(0, OUTPUT_CHARS)}
+\u2026 (${text.length - OUTPUT_CHARS} more characters)`;
+  return [{ type: "content", content: { type: "text", text } }];
+}
+var clip = (text, chars) => text.length > chars ? `${text.slice(0, chars - 1)}\u2026` : text;
+var status = (state) => state === "running" ? "in_progress" : state;
+function createAcpAgent(options) {
+  const log = options.log ?? (() => {
+  });
+  const sessions = /* @__PURE__ */ new Map();
+  let alpd;
+  let editor;
+  let leaving = false;
+  async function daemon() {
+    alpd ??= options.connect().then((connection) => {
+      connection.onEvent(project);
+      connection.onClose((error) => {
+        if (leaving) return;
+        log("lost the connection to alpd", { code: "ALP_IPC_LOST", error });
+        alpd = void 0;
+        for (const session of sessions.values()) {
+          session.opened = false;
+          session.waiting?.done({ state: "failed", error: `ALP lost its connection to alpd: ${error.message}` });
+        }
+      });
+      return connection;
+    }, (error) => {
+      alpd = void 0;
+      log("could not reach alpd", { code: "ALP_IPC_CONNECT_FAILED", error });
+      throw error;
+    });
+    return alpd;
+  }
+  const request = async (method, params) => (await daemon()).request(method, params);
+  function send(session, update) {
+    const client = editor;
+    if (!client) return;
+    session.queue = session.queue.then(() => client.notify("session/update", { sessionId: session.id, update })).catch((error) => log("could not send an update to the editor", { code: "ALP_ACP_UPDATE_FAILED", error }));
+  }
+  const say = (session, text) => send(session, { sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
+  function configOptions(session) {
+    const teams = session.opened ? session.preview.teams.filter((team) => team.id === session.preview.team) : session.preview.teams;
+    return [
+      {
+        id: "team",
+        name: "Team",
+        category: "model",
+        type: "select",
+        currentValue: session.preview.team,
+        description: session.opened ? "A session keeps its team; start a new one for another team" : "The team that works on this session",
+        options: (teams.length ? teams : [{ id: session.preview.team, label: session.preview.teamLabel ?? session.preview.team }]).map((team) => ({ value: team.id, name: team.label, ...team.description ? { description: team.description } : {} }))
+      },
+      { id: "mode", name: "Permissions", category: "mode", type: "select", currentValue: session.preview.mode, options: MODES.map((mode) => ({ value: mode.id, name: mode.name, description: mode.description })) }
+    ];
+  }
+  const modeState = (session) => ({ currentModeId: session.preview.mode, availableModes: MODES });
+  function track(id, cwd, mcpServers, preview2, opened) {
+    const session = { id, cwd, mcpServers, preview: preview2, opened, ours: /* @__PURE__ */ new Set(), texts: /* @__PURE__ */ new Map(), tools: /* @__PURE__ */ new Set(), questions: /* @__PURE__ */ new Map(), queue: Promise.resolve() };
+    sessions.set(id, session);
+    return session;
+  }
+  function known(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) throw acp.RequestError.resourceNotFound(sessionId);
+    return session;
+  }
+  function project(envelope) {
+    const session = sessions.get(envelope.sessionId);
+    const { event } = envelope;
+    if (event.type === "question") {
+      const root = sessions.get(event.question.rootId);
+      if (!root || root.questions.has(event.question.id)) return;
+      root.questions.set(event.question.id, event.question);
+      const options2 = event.question.options?.length ? `
+Options: ${event.question.options.join(" \xB7 ")}` : "";
+      say(root, `
+
+**${event.question.agent} asks you:** ${event.question.body}${options2}
+
+Reply with /answer <your answer>, or /dismiss.
+
+`);
+      return;
+    }
+    if (event.type === "question.resolved") {
+      for (const root of sessions.values()) root.questions.delete(event.questionId);
+      return;
+    }
+    if (!session) return;
+    switch (event.type) {
+      case "session.updated":
+        if (event.session.mode !== session.preview.mode) {
+          session.preview = { ...session.preview, mode: event.session.mode };
+          send(session, { sessionUpdate: "current_mode_update", currentModeId: event.session.mode });
+          send(session, { sessionUpdate: "config_option_update", configOptions: configOptions(session) });
+        }
+        return;
+      case "prompt.accepted":
+        if (session.waiting?.clientMessageId === event.clientMessageId) session.waiting.turnId = event.turnId;
+        return;
+      case "prompt.failed":
+        if (session.waiting?.clientMessageId === event.clientMessageId) session.waiting.done({ state: "failed", error: event.error.message });
+        return;
+      case "turn.ended":
+        if (session.waiting?.turnId === event.turnId) session.waiting.done({ state: event.state, ...event.error ? { error: event.error.message } : {} });
+        return;
+      case "session.failed":
+        session.opened = false;
+        session.waiting?.done({ state: "failed", error: event.error.message });
+        return;
+      case "session.closed":
+        session.opened = false;
+        return;
+      case "item":
+        item(session, event.item);
+        return;
+    }
+  }
+  function item(session, item2) {
+    switch (item2.kind) {
+      case "user_message": {
+        if (item2.clientMessageId && session.ours.has(item2.clientMessageId)) return;
+        if (item2.clientMessageId?.startsWith("alp-") || item2.id.startsWith("user:alp-")) {
+          send(session, { sessionUpdate: "tool_call", toolCallId: item2.id, title: clip(`ALP: ${item2.text.split("\n").find((line) => line.trim()) ?? "note"}`, 160), kind: "other", status: "completed", content: [{ type: "content", content: { type: "text", text: item2.text } }] });
+          return;
+        }
+        send(session, { sessionUpdate: "user_message_chunk", content: { type: "text", text: item2.text } });
+        return;
+      }
+      case "assistant_message": {
+        const before = session.texts.get(item2.id) ?? "";
+        session.texts.set(item2.id, item2.text);
+        const fresh = item2.text.startsWith(before) ? item2.text.slice(before.length) : `
+${item2.text}`;
+        if (fresh) say(session, fresh);
+        return;
+      }
+      case "notice":
+        say(session, `
+
+> ALP: ${item2.text}
+
+`);
+        return;
+      case "compaction":
+        if (item2.status !== "running") say(session, `
+
+> ALP: ${item2.status === "completed" ? `the context was compacted${item2.preTokens ? ` from ${Math.round(item2.preTokens / 1e3)}k tokens` : ""}` : "compacting the context failed"}
+
+`);
+        return;
+      case "todo":
+        send(session, { sessionUpdate: "plan", entries: item2.items.map((entry) => ({ content: entry.text, priority: "medium", status: entry.status })) });
+        return;
+      case "tool_call": {
+        const fields = { title: toolTitle(item2), kind: toolKind(item2), status: status(item2.status), content: toolOutput(item2), rawInput: item2.detail.type === "shell" ? { command: item2.detail.command, cwd: item2.detail.cwd } : item2.detail.input };
+        if (session.tools.has(item2.id)) send(session, { sessionUpdate: "tool_call_update", toolCallId: item2.id, ...fields });
+        else {
+          session.tools.add(item2.id);
+          send(session, { sessionUpdate: "tool_call", toolCallId: item2.id, ...fields });
+        }
+        return;
+      }
+    }
+  }
+  async function open(session, resume) {
+    await request("session.create", {
+      sessionId: session.id,
+      spec: { cwd: session.cwd, persist: true, workflow: session.preview.team, mode: session.preview.mode, mcpServers: session.mcpServers },
+      history: "skip",
+      ...resume ? { resume: true } : {}
+    });
+    session.opened = true;
+  }
+  async function prompt(session, blocks) {
+    const text = promptText(blocks);
+    const command = /^\/(answer|dismiss)\b\s*([\s\S]*)$/.exec(text);
+    if (command) {
+      const [question] = session.questions.values();
+      if (!question) say(session, "No agent is waiting for an answer from you.");
+      else {
+        await request("question.answer", command[1] === "answer" ? { questionId: question.id, text: command[2].trim() || "yes" } : { questionId: question.id, dismiss: true, ...command[2].trim() ? { reason: command[2].trim() } : {} });
+        session.questions.delete(question.id);
+        say(session, command[1] === "answer" ? `Sent your answer to ${question.agent}.` : `Dismissed ${question.agent}'s question.`);
+      }
+      await session.queue;
+      return { stopReason: "end_turn" };
+    }
+    if (!text) throw acp.RequestError.invalidParams(void 0, "The prompt is empty");
+    if (!session.opened) {
+      const { session: snapshot } = await request("session.get", { sessionId: session.id }).catch(() => ({ session: void 0 }));
+      await open(session, !!snapshot);
+      send(session, { sessionUpdate: "config_option_update", configOptions: configOptions(session) });
+    }
+    if (session.waiting) throw acp.RequestError.invalidRequest(void 0, "A prompt is already running in this session");
+    const clientMessageId = randomUUID();
+    session.ours.add(clientMessageId);
+    let done;
+    const ended = new Promise((resolve) => {
+      done = (result2) => {
+        if (session.waiting?.clientMessageId === clientMessageId) session.waiting = void 0;
+        resolve(result2);
+      };
+    });
+    session.waiting = { clientMessageId, done };
+    try {
+      await request("session.prompt", { sessionId: session.id, clientMessageId, delivery: "auto", content: [{ type: "text", text }] });
+    } catch (error) {
+      done({ state: "failed", error: error instanceof Error ? error.message : String(error) });
+    }
+    const result = await ended;
+    await session.queue;
+    if (result.state === "canceled") return { stopReason: "cancelled" };
+    if (result.state === "failed") throw acp.RequestError.internalError(void 0, result.error ?? "The turn failed");
+    return { stopReason: "end_turn" };
+  }
+  async function preview(cwd, mcpServers, team, mode) {
+    const { preview: preview2 } = await request("session.preview", { spec: { cwd, mcpServers, ...team ? { workflow: team } : {}, ...mode ? { mode } : {} } });
+    return preview2;
+  }
+  const absolute = (cwd) => {
+    if (!path.isAbsolute(cwd)) throw acp.RequestError.invalidParams(void 0, "cwd must be an absolute path");
+    return path.resolve(cwd);
+  };
+  return acp.agent({ name: "alp" }).onConnect((connection) => {
+    editor = connection.client;
+    void connection.closed.then(() => release());
+  }).onRequest("initialize", () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: {
+      loadSession: true,
+      promptCapabilities: { embeddedContext: true },
+      mcpCapabilities: { http: true, sse: true },
+      sessionCapabilities: { list: {}, close: {} }
+    },
+    agentInfo: { name: "alp", title: "ALP", version: options.version },
+    authMethods: []
+  })).onRequest("authenticate", () => ({})).onRequest("session/new", async ({ params }) => {
+    const cwd = absolute(params.cwd);
+    const mcpServers = hostServers(params.mcpServers);
+    const session = track(`acp-${randomUUID()}`, cwd, mcpServers, await preview(cwd, mcpServers), false);
+    queueMicrotask(() => send(session, { sessionUpdate: "available_commands_update", availableCommands: COMMANDS }));
+    return { sessionId: session.id, configOptions: configOptions(session), modes: modeState(session) };
+  }).onRequest("session/load", async ({ params }) => {
+    const cwd = absolute(params.cwd);
+    const { session: record } = await request("session.get", { sessionId: params.sessionId }).catch(() => {
+      throw acp.RequestError.resourceNotFound(params.sessionId);
+    });
+    if (record.parentId || path.resolve(record.projectRoot) !== cwd) throw acp.RequestError.invalidParams(void 0, "That ALP session belongs to another project");
+    const session = track(params.sessionId, cwd, hostServers(params.mcpServers), {
+      teams: [{ id: record.workflow?.mode ?? "pho", label: record.teamLabel ?? record.workflow?.mode ?? "pho" }],
+      team: record.workflow?.mode ?? "pho",
+      ...record.teamLabel ? { teamLabel: record.teamLabel } : {},
+      agent: record.agent,
+      runtime: record.runtime,
+      model: record.model,
+      mode: record.mode,
+      thinking: record.thinking
+    }, true);
+    const live = record.status === "idle" || record.status === "running";
+    await request("session.attach", { sessionId: session.id, replay: true });
+    session.opened = live;
+    await session.queue;
+    send(session, { sessionUpdate: "available_commands_update", availableCommands: COMMANDS });
+    return { configOptions: configOptions(session), modes: modeState(session) };
+  }).onRequest("session/list", async ({ params }) => {
+    const { sessions: rows } = await request("session.list", { ...params.cwd ? { projectRoot: path.resolve(params.cwd) } : {}, rootsOnly: true, includeClosed: true });
+    return {
+      sessions: rows.filter((row) => row.persistent).slice(0, 100).map((row) => ({
+        sessionId: row.id,
+        cwd: row.projectRoot,
+        title: row.title ?? `ALP ${row.agent}`,
+        ...row.updatedAt ? { updatedAt: row.updatedAt } : {}
+      }))
+    };
+  }).onRequest("session/prompt", ({ params }) => prompt(known(params.sessionId), params.prompt)).onNotification("session/cancel", async ({ params }) => {
+    const session = sessions.get(params.sessionId);
+    if (!session?.opened) return;
+    await request("session.interrupt", { sessionId: session.id }).catch((error) => log("session.interrupt failed", { code: "ALP_ACP_INTERRUPT_FAILED", error }));
+  }).onRequest("session/set_mode", async ({ params }) => {
+    await setMode(known(params.sessionId), params.modeId);
+    return {};
+  }).onRequest("session/set_config_option", async ({ params }) => {
+    const session = known(params.sessionId);
+    const value = String(params.value);
+    if (params.configId === "mode") await setMode(session, value);
+    else if (params.configId === "team") {
+      if (session.opened && value !== session.preview.team) throw acp.RequestError.invalidParams(void 0, "A session keeps its team; start a new one for another team");
+      if (!session.preview.teams.some((team) => team.id === value)) throw acp.RequestError.invalidParams(void 0, `Unknown team ${value}`);
+      session.preview = { ...await preview(session.cwd, session.mcpServers, value), mode: session.preview.mode };
+    } else throw acp.RequestError.invalidParams(void 0, `Unknown option ${params.configId}`);
+    return { configOptions: configOptions(session) };
+  }).onRequest("session/close", async ({ params }) => {
+    const session = known(params.sessionId);
+    sessions.delete(session.id);
+    if (session.opened) await request("session.release", { sessionId: session.id }).catch(() => {
+    });
+    return {};
+  });
+  async function setMode(session, mode) {
+    if (!MODES.some((entry) => entry.id === mode)) throw acp.RequestError.invalidParams(void 0, `Unknown mode ${mode}`);
+    if (session.opened) await request("session.configure", { sessionId: session.id, mode });
+    session.preview = { ...session.preview, mode };
+  }
+  async function release() {
+    leaving = true;
+    const connection = await alpd?.catch(() => void 0);
+    if (!connection) return;
+    await Promise.all([...sessions.values()].filter((session) => session.opened).map((session) => connection.request("session.release", { sessionId: session.id }).catch(() => {
+    })));
+    sessions.clear();
+    connection.close();
+  }
+}
+export {
+  createAcpAgent,
+  hostServers,
+  promptText,
+  toolKind
+};

package/packages/cli/dist/acp/main.d.ts

@@ -0,0 +1,4 @@
+/** `alp acp`: serves the Agent Client Protocol on stdio until the editor closes it (ALPD §60). */
+export declare function runAcp({ daemonEntry }: {
+    daemonEntry: string;
+}): Promise<void>;

package/packages/cli/dist/acp/main.js

@@ -0,0 +1,23 @@
+// packages/cli/src/acp/main.ts
+import * as acp from "@agentclientprotocol/sdk";
+import { Readable, Writable } from "node:stream";
+import { alpHome, connect } from "@anhlp/alp-client/index";
+import { startDaemon } from "@anhlp/alp-client/supervise";
+import { createLogger } from "@anhlp/alp-core/log";
+import { createAcpAgent } from "./agent.js";
+async function runAcp({ daemonEntry }) {
+  const version = true ? "0.0.0-beta.1" : "0.0.0";
+  const logger = createLogger({ component: "acp" });
+  const log = (message, fields) => logger.warn(message, fields);
+  const app = createAcpAgent({
+    version,
+    log,
+    connect: async () => connect(await startDaemon({ home: alpHome(), entry: daemonEntry }), { name: "alp-acp", version })
+  });
+  const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+  const connection = app.connect(stream);
+  await connection.closed;
+}
+export {
+  runAcp
+};