obsidian-catui-acp 0.1.0

package/manifest.json

@@ -0,0 +1,9 @@
+{
+  "id": "catui-acp",
+  "name": "CatUI ACP",
+  "version": "0.1.0",
+  "minAppVersion": "1.5.0",
+  "description": "Chat with and edit this LLM-Wiki vault through a local CatUI ACP agent.",
+  "author": "cunyu666",
+  "isDesktopOnly": true
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "obsidian-catui-acp",
+  "version": "0.1.0",
+  "description": "Obsidian desktop sidebar for chatting with a local CatUI ACP agent.",
+  "license": "MIT",
+  "author": "cunyu666",
+  "keywords": [
+    "obsidian",
+    "obsidian-plugin",
+    "catui",
+    "acp",
+    "llm-wiki"
+  ],
+  "files": [
+    "main.js",
+    "manifest.json",
+    "styles.css",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.txt",
+    "src/",
+    "test/",
+    "tsconfig.json",
+    "esbuild.config.mjs",
+    "package-lock.json"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "type": "module",
+  "scripts": {
+    "build:css": "tailwindcss -i ./src/styles.css -o ./styles.css --minify",
+    "build": "npm run build:css && node esbuild.config.mjs production",
+    "dev": "npm run build:css && node esbuild.config.mjs",
+    "test": "node --test --import tsx test/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@tailwindcss/cli": "^4.3.3",
+    "@types/node": "^22.15.0",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.4",
+    "builtin-modules": "^5.0.0",
+    "esbuild": "^0.27.3",
+    "obsidian": "^1.8.7",
+    "tailwindcss": "^4.3.3",
+    "tsx": "^4.20.0",
+    "typescript": "^5.7.0",
+    "@ai-sdk/react": "^4.0.51",
+    "ai": "^7.0.48",
+    "lucide-react": "^0.561.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1"
+  }
+}

package/src/acp/catui-client.ts

@@ -0,0 +1,108 @@
+import { EventEmitter } from "node:events";
+import type {
+  AcpInitializeResult,
+  AcpListSessionsResult,
+  AcpNewSessionResult,
+  AcpPermissionRequestParams,
+  AcpSessionUpdateParams,
+} from "./types";
+
+export interface RpcPeerLike {
+  request<TResult = unknown>(method: string, params?: unknown): Promise<TResult>;
+  notify(method: string, params?: unknown): void;
+  onNotification(method: string, handler: (params: unknown) => void): void;
+  onRequest(method: string, handler: (params: unknown) => Promise<unknown> | unknown): void;
+  onError?(handler: (error: Error) => void): void;
+}
+
+export class CatuiAcpClient extends EventEmitter {
+  sessionId: string | null = null;
+  initializeResult: AcpInitializeResult | null = null;
+  sessionState: AcpNewSessionResult | null = null;
+
+  constructor(
+    private readonly peer: RpcPeerLike,
+    private readonly cwd: string,
+  ) {
+    super();
+    this.peer.onNotification("session/update", (params) =>
+      this.emit("session-update", params as AcpSessionUpdateParams),
+    );
+    this.peer.onRequest("session/request_permission", (params) =>
+      this.emitPermission(params as AcpPermissionRequestParams),
+    );
+    this.peer.onError?.((error) => this.emit("error", error));
+  }
+
+  async initialize(): Promise<AcpInitializeResult> {
+    this.initializeResult = await this.peer.request<AcpInitializeResult>("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: {},
+    });
+    return this.initializeResult;
+  }
+
+  async newSession(): Promise<AcpNewSessionResult> {
+    const result = await this.peer.request<AcpNewSessionResult>("session/new", {
+      cwd: this.cwd,
+      mcpServers: [],
+    });
+    this.sessionId = result.sessionId;
+    this.sessionState = result;
+    this.emit("session-ready", result);
+    return result;
+  }
+
+  async listSessions(): Promise<AcpListSessionsResult> {
+    return this.peer.request<AcpListSessionsResult>("session/list", { cwd: this.cwd });
+  }
+
+  async loadSession(sessionId: string): Promise<unknown> {
+    const result = await this.peer.request("session/load", {
+      sessionId,
+      cwd: this.cwd,
+      mcpServers: [],
+    });
+    this.sessionId = sessionId;
+    this.emit("session-ready", result);
+    return result;
+  }
+
+  async closeSession(sessionId: string): Promise<unknown> {
+    const result = await this.peer.request("session/close", { sessionId });
+    if (this.sessionId === sessionId) {
+      this.sessionId = null;
+      this.sessionState = null;
+    }
+    return result;
+  }
+
+  async setMode(modeId: string): Promise<void> {
+    if (!this.sessionId) throw new Error("No ACP session is active");
+    await this.peer.request("session/set_mode", { sessionId: this.sessionId, modeId });
+  }
+
+  async setModel(modelId: string): Promise<void> {
+    if (!this.sessionId) throw new Error("No ACP session is active");
+    await this.peer.request("session/set_model", { sessionId: this.sessionId, modelId });
+  }
+
+  async prompt(text: string): Promise<unknown> {
+    if (!this.sessionId) throw new Error("No ACP session is active");
+    return this.peer.request("session/prompt", {
+      sessionId: this.sessionId,
+      prompt: [{ type: "text", text }],
+    });
+  }
+
+  cancel(): void {
+    if (!this.sessionId) return;
+    this.peer.notify("session/cancel", { sessionId: this.sessionId });
+  }
+
+  private emitPermission(params: AcpPermissionRequestParams): Promise<unknown> {
+    return new Promise((resolve) => {
+      this.emit("permission-request", params, resolve);
+    });
+  }
+}

package/src/acp/catui-process.ts

@@ -0,0 +1,49 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { EventEmitter } from "node:events";
+
+export interface CatuiProcessOptions {
+  command: string;
+  args: string[];
+  cwd: string;
+}
+
+export class CatuiProcess extends EventEmitter {
+  private child: ChildProcessWithoutNullStreams | null = null;
+  stderrText = "";
+
+  get running(): boolean {
+    return this.child !== null;
+  }
+
+  start(options: CatuiProcessOptions): ChildProcessWithoutNullStreams {
+    this.stop();
+    this.stderrText = "";
+    this.child = spawn(options.command, options.args, {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.child.stderr.on("data", (chunk: Buffer) => {
+      const text = chunk.toString("utf8");
+      this.stderrText += text;
+      this.emit("stderr", text);
+    });
+    this.child.on("exit", (code, signal) => {
+      this.emit("exit", { code, signal });
+      this.child = null;
+    });
+    this.child.on("error", (error) => {
+      this.emit("error", error);
+      this.child = null;
+    });
+
+    return this.child;
+  }
+
+  stop(): void {
+    if (!this.child) return;
+    this.child.kill();
+    this.child = null;
+  }
+}

package/src/acp/ndjson-rpc.ts

@@ -0,0 +1,142 @@
+import type { Readable, Writable } from "node:stream";
+import type {
+  JsonRpcFailure,
+  JsonRpcId,
+  JsonRpcMessage,
+  JsonRpcRequest,
+  JsonRpcSuccess,
+} from "./types";
+
+type Pending = {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+};
+
+type RequestHandler = (params: unknown) => Promise<unknown> | unknown;
+type NotificationHandler = (params: unknown) => void;
+type ErrorHandler = (error: Error) => void;
+
+export class NdjsonRpcPeer {
+  private nextId = 1;
+  private buffer = "";
+  private readonly pending = new Map<JsonRpcId, Pending>();
+  private readonly requestHandlers = new Map<string, RequestHandler>();
+  private readonly notificationHandlers = new Map<string, NotificationHandler[]>();
+  private readonly errorHandlers: ErrorHandler[] = [];
+
+  constructor(
+    private readonly input: Readable,
+    private readonly output: Writable,
+  ) {
+    this.input.setEncoding("utf8");
+    this.input.on("data", (chunk: string) => this.accept(chunk));
+    this.input.on("error", (error) => this.fail(error instanceof Error ? error : new Error(String(error))));
+    this.input.on("close", () => this.rejectAll(new Error("ACP stream closed")));
+  }
+
+  request<TResult = unknown>(method: string, params?: unknown): Promise<TResult> {
+    const id = this.nextId++;
+    const message: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
+    this.write(message);
+    return new Promise<TResult>((resolve, reject) => {
+      this.pending.set(id, { resolve: resolve as (value: unknown) => void, reject });
+    });
+  }
+
+  notify(method: string, params?: unknown): void {
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+
+  onRequest(method: string, handler: RequestHandler): void {
+    this.requestHandlers.set(method, handler);
+  }
+
+  onNotification(method: string, handler: NotificationHandler): void {
+    const handlers = this.notificationHandlers.get(method) ?? [];
+    handlers.push(handler);
+    this.notificationHandlers.set(method, handlers);
+  }
+
+  onError(handler: ErrorHandler): void {
+    this.errorHandlers.push(handler);
+  }
+
+  private accept(chunk: string): void {
+    this.buffer += chunk;
+    for (;;) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline === -1) return;
+      const line = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line) this.handleLine(line);
+    }
+  }
+
+  private handleLine(line: string): void {
+    let message: JsonRpcMessage;
+    try {
+      message = JSON.parse(line) as JsonRpcMessage;
+    } catch {
+      for (const handler of this.errorHandlers) {
+        handler(new Error(`Ignored non-ACP output: ${line.slice(0, 120)}`));
+      }
+      return;
+    }
+
+    if ("id" in message && typeof message.id === "number" && ("result" in message || "error" in message)) {
+      this.handleResponse(message as JsonRpcSuccess | JsonRpcFailure);
+      return;
+    }
+
+    if ("id" in message && typeof message.id === "number" && "method" in message && typeof message.method === "string") {
+      void this.handleRequest(message.id, message.method, message.params);
+      return;
+    }
+
+    if ("method" in message && typeof message.method === "string") {
+      for (const handler of this.notificationHandlers.get(message.method) ?? []) {
+        handler(message.params);
+      }
+    }
+  }
+
+  private handleResponse(message: JsonRpcSuccess | JsonRpcFailure): void {
+    const pending = this.pending.get(message.id);
+    if (!pending) return;
+    this.pending.delete(message.id);
+    if ("error" in message) {
+      pending.reject(new Error(message.error.message));
+    } else {
+      pending.resolve(message.result);
+    }
+  }
+
+  private async handleRequest(id: number, method: string, params: unknown): Promise<void> {
+    const handler = this.requestHandlers.get(method);
+    if (!handler) {
+      this.write({ jsonrpc: "2.0", id, error: { code: -32601, message: `No handler for ${method}` } });
+      return;
+    }
+
+    try {
+      this.write({ jsonrpc: "2.0", id, result: await handler(params) });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.write({ jsonrpc: "2.0", id, error: { code: -32000, message } });
+    }
+  }
+
+  private write(message: unknown): void {
+    this.output.write(`${JSON.stringify(message)}\n`);
+  }
+
+  private fail(error: Error): void {
+    for (const handler of this.errorHandlers) handler(error);
+    this.rejectAll(error);
+  }
+
+  private rejectAll(error: Error): void {
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+  }
+}

package/src/acp/types.ts

@@ -0,0 +1,101 @@
+export type JsonRpcId = number;
+
+export interface JsonRpcRequest<TParams = unknown> {
+  jsonrpc: "2.0";
+  id: JsonRpcId;
+  method: string;
+  params?: TParams;
+}
+
+export interface JsonRpcNotification<TParams = unknown> {
+  jsonrpc: "2.0";
+  method: string;
+  params?: TParams;
+}
+
+export interface JsonRpcSuccess<TResult = unknown> {
+  jsonrpc: "2.0";
+  id: JsonRpcId;
+  result: TResult;
+}
+
+export interface JsonRpcFailure {
+  jsonrpc: "2.0";
+  id: JsonRpcId;
+  error: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export type JsonRpcMessage =
+  | JsonRpcRequest
+  | JsonRpcNotification
+  | JsonRpcSuccess
+  | JsonRpcFailure;
+
+export interface AcpTextContentBlock {
+  type: "text";
+  text: string;
+}
+
+export interface AcpInitializeResult {
+  protocolVersion: number;
+  agentInfo: { name: string; version: string };
+  agentCapabilities: Record<string, unknown>;
+}
+
+export interface AcpModeInfo {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+export interface AcpModelInfo {
+  modelId: string;
+  name?: string;
+  description?: string;
+}
+
+export interface AcpNewSessionResult {
+  sessionId: string;
+  modes?: {
+    currentModeId?: string;
+    availableModes?: AcpModeInfo[];
+  };
+  models?: {
+    currentModelId?: string;
+    availableModels?: AcpModelInfo[];
+  };
+}
+
+export interface AcpListSessionsResult {
+  sessions: Array<{
+    sessionId: string;
+    cwd?: string;
+    title?: string;
+    updatedAt?: string;
+  }>;
+}
+
+export interface AcpSessionUpdateParams {
+  sessionId: string;
+  update: Record<string, unknown> & { sessionUpdate: string };
+}
+
+export interface AcpPermissionRequestParams {
+  sessionId: string;
+  options: Array<{ optionId: string; name: string; kind?: string }>;
+  toolCall: {
+    toolCallId: string;
+    title: string;
+    kind?: string;
+    status?: string;
+    rawInput?: unknown;
+  };
+}
+
+export type AcpPermissionResponse =
+  | { outcome: { outcome: "selected"; optionId: string } }
+  | { outcome: { outcome: "cancelled" } };

package/src/chat/acp-chat-transport.ts

@@ -0,0 +1,28 @@
+import type { ChatTransport, UIMessage, UIMessageChunk } from "ai";
+import type CatuiAcpPlugin from "../main";
+
+export class AcpChatTransport implements ChatTransport<UIMessage> {
+  constructor(private readonly plugin: CatuiAcpPlugin) {}
+
+  async sendMessages(options: Parameters<ChatTransport<UIMessage>["sendMessages"]>[0]): Promise<ReadableStream<UIMessageChunk>> {
+    const text = getLastUserText(options.messages);
+    if (!text) throw new Error("Cannot send an empty message.");
+    return this.plugin.runPromptAsStream(text, options.abortSignal);
+  }
+
+  async reconnectToStream(): Promise<ReadableStream<UIMessageChunk> | null> {
+    return null;
+  }
+}
+
+function getLastUserText(messages: UIMessage[]): string {
+  const message = [...messages].reverse().find((item) => item.role === "user");
+  if (!message) return "";
+  return message.parts
+    .map((part) => {
+      if (part.type === "text") return part.text;
+      return "";
+    })
+    .join("\n")
+    .trim();
+}

package/src/chat/session-messages-cache.ts

@@ -0,0 +1,40 @@
+import type { UIMessage } from "ai";
+
+const DEFAULT_CAPACITY = 10;
+
+export class SessionMessagesCache {
+  private readonly entries = new Map<string, UIMessage[]>();
+
+  constructor(private readonly capacity = DEFAULT_CAPACITY) {}
+
+  save(sessionId: string, messages: UIMessage[]): void {
+    if (messages.length === 0) return;
+    this.entries.delete(sessionId);
+    this.entries.set(sessionId, [...messages]);
+    while (this.entries.size > this.capacity) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === undefined) break;
+      this.entries.delete(oldest);
+    }
+  }
+
+  load(sessionId: string): UIMessage[] | null {
+    const messages = this.entries.get(sessionId);
+    if (!messages) return null;
+    this.entries.delete(sessionId);
+    this.entries.set(sessionId, messages);
+    return [...messages];
+  }
+
+  evict(sessionId: string): void {
+    this.entries.delete(sessionId);
+  }
+
+  clear(): void {
+    this.entries.clear();
+  }
+
+  get size(): number {
+    return this.entries.size;
+  }
+}

package/src/context/vault-context.ts

@@ -0,0 +1,35 @@
+export interface VaultPromptContext {
+  userText: string;
+  activePath: string | null;
+  selection: string;
+  includeActiveNote: boolean;
+  includeSelection: boolean;
+  personality?: string;
+}
+
+export function buildPromptWithVaultContext(context: VaultPromptContext): string {
+  const lines = [
+    context.userText.trim(),
+    "",
+    "Vault context:",
+    "- This vault is a Karpathy-style LLM-Wiki.",
+    "- raw/ is immutable source material. Do not modify raw/.",
+    "- wiki/ is agent-maintained compiled knowledge.",
+    "- wiki/log.md is append-only.",
+    "- Follow AGENTS.md and skills/karpathy-llm-wiki/SKILL.md when editing.",
+  ];
+
+  if (context.personality?.trim()) {
+    lines.push(`- CatUI personality: ${context.personality.trim()}`);
+  }
+
+  if (context.includeActiveNote && context.activePath) {
+    lines.push(`- Active note: ${context.activePath}`);
+  }
+
+  if (context.includeSelection && context.selection.trim()) {
+    lines.push("", "Selected text:", context.selection.trim());
+  }
+
+  return lines.join("\n");
+}