volute 0.3.1 → 0.5.0

package/templates/pi/src/agent.ts

@@ -1,74 +1,295 @@
 import type { ImageContent } from "@mariozechner/pi-ai";
-import { createPiSessionManager } from "./lib/agent-sessions.js";
-import { formatPrefix } from "./lib/format-prefix.js";
-import { logMessage } from "./lib/logger.js";
+import { getModel, getModels } from "@mariozechner/pi-ai";
 import {
-  type ChannelMeta,
-  INTERACTIVE_CHANNELS,
-  type Listener,
-  type VoluteContentPart,
+  AuthStorage,
+  createAgentSession,
+  DefaultResourceLoader,
+  type ExtensionFactory,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager,
+} from "@mariozechner/pi-coding-agent";
+import { commitFileChange } from "./lib/auto-commit.js";
+import { log, logText, logThinking, logToolResult, logToolUse } from "./lib/logger.js";
+import type {
+  HandlerMeta,
+  HandlerResolver,
+  Listener,
+  MessageHandler,
+  VoluteContentPart,
+  VoluteEvent,
 } from "./lib/types.js";
 
+type AgentSession = Awaited<ReturnType<typeof createAgentSession>>["session"];
+
+type PiSession = {
+  name: string;
+  agentSession: AgentSession | null;
+  ready: Promise<void>;
+  listeners: Set<Listener>;
+  unsubscribe?: () => void;
+  messageIds: (string | undefined)[];
+  currentMessageId?: string;
+};
+
+function defaultCompactionMessage(): string {
+  const today = new Date().toISOString().slice(0, 10);
+  return `Context is getting long — compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/${today}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.`;
+}
+
+function resolveModel(modelStr: string) {
+  const [provider, ...rest] = modelStr.split(":");
+  const modelId = rest.join(":");
+
+  // Try exact match first, then prefix match against available models
+  let model = getModel(provider as any, modelId as any);
+  if (!model) {
+    const available = getModels(provider as any);
+    const found = available.find((m) => m.id.startsWith(modelId));
+    if (found) model = found;
+  }
+  if (!model) {
+    const available = getModels(provider as any);
+    throw new Error(
+      `Model not found: ${modelStr}\nAvailable ${provider} models: ${available.map((m) => m.id).join(", ")}`,
+    );
+  }
+  return model;
+}
+
+function extractText(content: VoluteContentPart[]): string {
+  return content
+    .filter((p): p is { type: "text"; text: string } => p.type === "text")
+    .map((p) => p.text)
+    .join("\n");
+}
+
+function extractImages(content: VoluteContentPart[]): ImageContent[] {
+  return content
+    .filter((p): p is { type: "image"; media_type: string; data: string } => p.type === "image")
+    .map((p) => ({ type: "image" as const, mimeType: p.media_type, data: p.data }));
+}
+
 export function createAgent(options: {
   systemPrompt: string;
   cwd: string;
   model?: string;
   compactionMessage?: string;
-}) {
-  const { getOrCreateSession, interruptSession } = createPiSessionManager(options);
-
-  function sendMessage(content: string | VoluteContentPart[], meta?: ChannelMeta) {
-    const raw =
-      typeof content === "string"
-        ? content
-        : content
-            .filter((p) => p.type === "text")
-            .map((p) => (p as { text: string }).text)
-            .join("\n");
-    logMessage("in", raw, meta?.channel);
-
-    const sessionName = meta?.sessionName ?? "main";
-    const session = getOrCreateSession(sessionName);
-
-    // Build context prefix from channel metadata
-    const prefix = formatPrefix(meta, new Date().toLocaleString());
-    const text = prefix + raw;
-
-    // Convert image parts to pi-ai ImageContent format
-    const images: ImageContent[] | undefined =
-      typeof content === "string"
-        ? undefined
-        : content
-            .filter((p) => p.type === "image")
-            .map((p) => ({ type: "image" as const, mimeType: p.media_type, data: p.data }));
-
-    const opts = images?.length ? { images } : {};
-
-    // Track messageId for this turn (must be pushed before prompt)
-    session.messageIds.push(meta?.messageId);
-
-    // Fire-and-forget: await session ready then prompt
-    (async () => {
-      await session.ready;
-      if (session.agentSession!.isStreaming) {
-        if (INTERACTIVE_CHANNELS.has(meta?.channel ?? "")) {
-          interruptSession(sessionName);
-          session.agentSession!.prompt(text, { streamingBehavior: "steer", ...opts });
-        } else {
-          session.agentSession!.prompt(text, { streamingBehavior: "followUp", ...opts });
+}): { resolve: HandlerResolver } {
+  const sessions = new Map<string, PiSession>();
+  const compactionMessage = options.compactionMessage ?? defaultCompactionMessage();
+
+  // Shared setup (created once)
+  const modelStr = options.model || process.env.PI_MODEL || "anthropic:claude-sonnet-4-20250514";
+  const model = resolveModel(modelStr);
+  const authStorage = new AuthStorage();
+  const modelRegistry = new ModelRegistry(authStorage);
+
+  // --- Session lifecycle ---
+
+  function getOrCreateSession(name: string): PiSession {
+    const existing = sessions.get(name);
+    if (existing) return existing;
+
+    const session: PiSession = {
+      name,
+      agentSession: null,
+      ready: Promise.resolve(),
+      listeners: new Set(),
+      messageIds: [],
+    };
+    sessions.set(name, session);
+
+    session.ready = initSession(session).catch((err) => {
+      log("agent", `session "${session.name}": init failed:`, err);
+    });
+    return session;
+  }
+
+  async function initSession(session: PiSession) {
+    const isEphemeral = session.name.startsWith("new-");
+
+    const sessionManager = isEphemeral
+      ? SessionManager.inMemory()
+      : SessionManager.continueRecent(options.cwd, `.volute/pi-sessions/${session.name}`);
+
+    log("agent", `session "${session.name}": ${isEphemeral ? "ephemeral" : "persistent"}`);
+
+    let compactBlocked = false;
+    const preCompactExtension: ExtensionFactory = (pi) => {
+      pi.on("session_before_compact", () => {
+        if (!compactBlocked) {
+          compactBlocked = true;
+          log(
+            "agent",
+            `session "${session.name}": blocking compaction — asking agent to update daily log`,
+          );
+          session.messageIds.push(undefined);
+          session.agentSession?.prompt(compactionMessage, { streamingBehavior: "followUp" });
+          return { cancel: true };
         }
-      } else {
-        session.agentSession!.prompt(text, opts);
+        compactBlocked = false;
+        log("agent", `session "${session.name}": allowing compaction`);
+      });
+    };
+
+    const settingsManager = SettingsManager.inMemory({
+      retry: { enabled: true, maxRetries: 3 },
+    });
+
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: options.cwd,
+      settingsManager,
+      systemPrompt: options.systemPrompt,
+      extensionFactories: [preCompactExtension],
+    });
+    await resourceLoader.reload();
+
+    const { session: agentSession } = await createAgentSession({
+      cwd: options.cwd,
+      model,
+      authStorage,
+      modelRegistry,
+      sessionManager,
+      settingsManager,
+      resourceLoader,
+    });
+
+    session.agentSession = agentSession;
+
+    // Per-session event subscription
+    const toolArgs = new Map<string, any>();
+
+    session.unsubscribe = agentSession.subscribe((event) => {
+      if (session.currentMessageId === undefined) {
+        session.currentMessageId = session.messageIds.shift();
       }
-    })();
+
+      if (event.type === "message_update") {
+        const ae = event.assistantMessageEvent;
+        if (ae.type === "text_delta") {
+          logText(ae.delta);
+          broadcast(session, { type: "text", content: ae.delta });
+        } else if (ae.type === "thinking_delta") {
+          logThinking(ae.delta);
+        }
+      }
+
+      if (event.type === "tool_execution_start") {
+        toolArgs.set(event.toolCallId, event.args);
+        logToolUse(event.toolName, event.args);
+        broadcast(session, { type: "tool_use", name: event.toolName, input: event.args });
+      }
+
+      if (event.type === "tool_execution_end") {
+        const output =
+          typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+        logToolResult(event.toolName, output, event.isError);
+        broadcast(session, { type: "tool_result", output, is_error: event.isError });
+
+        // Auto-commit file changes in home/
+        if ((event.toolName === "edit" || event.toolName === "write") && !event.isError) {
+          const args = toolArgs.get(event.toolCallId);
+          const filePath = (args as { path?: string })?.path;
+          if (filePath) {
+            commitFileChange(filePath, options.cwd);
+          }
+        }
+        toolArgs.delete(event.toolCallId);
+      }
+
+      if (event.type === "agent_end") {
+        log("agent", `session "${session.name}": turn done`);
+        broadcast(session, { type: "done" });
+        session.currentMessageId = undefined;
+      }
+    });
+
+    log("agent", `session "${session.name}": ready`);
+  }
+
+  // --- Event broadcasting ---
+
+  function broadcast(session: PiSession, event: VoluteEvent) {
+    const tagged =
+      session.currentMessageId != null ? { ...event, messageId: session.currentMessageId } : event;
+    for (const listener of session.listeners) {
+      try {
+        listener(tagged);
+      } catch (err) {
+        log("agent", "listener threw during broadcast:", err);
+      }
+    }
+  }
+
+  function interruptSession(name: string) {
+    const session = sessions.get(name);
+    if (session?.currentMessageId !== undefined) {
+      log("agent", `session "${name}": interrupting current turn`);
+      broadcast(session, { type: "done" });
+      session.currentMessageId = undefined;
+    }
+  }
+
+  // --- MessageHandler implementation ---
+
+  function createSessionHandler(sessionName: string): MessageHandler {
+    return {
+      handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void {
+        const session = getOrCreateSession(sessionName);
+
+        // Filter listener to only receive events for this messageId
+        const filteredListener: Listener = (event) => {
+          if (event.messageId === meta.messageId) listener(event);
+        };
+        session.listeners.add(filteredListener);
+
+        // Track messageId (must be pushed before prompt)
+        session.messageIds.push(meta.messageId);
+
+        const text = extractText(content);
+        const images = extractImages(content);
+        const opts = images.length ? { images } : {};
+
+        // Fire-and-forget: await session ready then prompt
+        (async () => {
+          await session.ready;
+          if (session.agentSession!.isStreaming) {
+            if (meta.interrupt) {
+              interruptSession(sessionName);
+              session.agentSession!.prompt(text, { streamingBehavior: "steer", ...opts });
+            } else {
+              session.agentSession!.prompt(text, { streamingBehavior: "followUp", ...opts });
+            }
+          } else {
+            session.agentSession!.prompt(text, opts);
+          }
+        })().catch((err) => {
+          log("agent", `session "${sessionName}": prompt failed:`, err);
+          broadcast(session, { type: "done" });
+        });
+
+        return () => session.listeners.delete(filteredListener);
+      },
+    };
   }
 
-  function onMessage(listener: Listener, sessionName?: string): () => void {
-    const name = sessionName ?? "main";
-    const session = getOrCreateSession(name);
-    session.listeners.add(listener);
-    return () => session.listeners.delete(listener);
+  // --- HandlerResolver ---
+
+  const handlers = new Map<string, MessageHandler>();
+
+  function resolve(sessionName: string): MessageHandler {
+    // Ephemeral sessions get unique names — don't cache their handlers
+    if (sessionName.startsWith("new-")) {
+      return createSessionHandler(sessionName);
+    }
+    let handler = handlers.get(sessionName);
+    if (!handler) {
+      handler = createSessionHandler(sessionName);
+      handlers.set(sessionName, handler);
+    }
+    return handler;
   }
 
-  return { sendMessage, onMessage };
+  return { resolve };
 }

package/templates/pi/src/server.ts

@@ -1,6 +1,8 @@
 import { resolve } from "node:path";
 import { createAgent } from "./agent.js";
+import { createFileHandlerResolver } from "./lib/file-handler.js";
 import { log } from "./lib/logger.js";
+import { createRouter } from "./lib/router.js";
 import {
   handleMergeContext,
   handleStartupContext,
@@ -26,21 +28,30 @@ const agent = createAgent({
   compactionMessage: config.compactionMessage,
 });
 
+const router = createRouter({
+  configPath: resolve("home/.config/routes.json"),
+  agentHandler: agent.resolve,
+  fileHandler: createFileHandlerResolver(resolve("home")),
+});
+
 const server = createVoluteServer({
-  agent,
+  router,
   port,
   name: pkg.name,
   version: pkg.version,
-  sessionsConfigPath: resolve("home/.config/sessions.json"),
 });
 
 server.listen(port, async () => {
   const addr = server.address();
   const actualPort = typeof addr === "object" && addr ? addr.port : port;
   log("server", `listening on :${actualPort}`);
-  const hasMerge = handleMergeContext((content) => agent.sendMessage(content));
+  const hasMerge = handleMergeContext((content) =>
+    router.route([{ type: "text", text: content }], { channel: "system" }),
+  );
   if (!hasMerge) {
-    await handleStartupContext((content) => agent.sendMessage(content));
+    await handleStartupContext((content) =>
+      router.route([{ type: "text", text: content }], { channel: "system" }),
+    );
   }
 });
 

package/templates/pi/volute-template.json

@@ -4,6 +4,6 @@
     "biome.json.tmpl": "biome.json",
     "home/.config/volute.json.tmpl": "home/.config/volute.json"
   },
-  "substitute": ["package.json", ".init/SOUL.md"],
+  "substitute": ["package.json", ".init/SOUL.md", "home/.config/routes.json"],
   "skillsDir": "home/.claude/skills"
 }

package/dist/channel-7FZ6D25H.js

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadMergedEnv
-} from "./chunk-DNOXHLE5.js";
-import {
-  resolveAgentName
-} from "./chunk-VRVVQIYY.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
-import {
-  resolveAgent
-} from "./chunk-3C2XR4IY.js";
-import "./chunk-K3NQKI34.js";
-
-// src/lib/channels/discord.ts
-var API_BASE = "https://discord.com/api/v10";
-async function read(token, channelId, limit) {
-  const res = await fetch(`${API_BASE}/channels/${channelId}/messages?limit=${limit}`, {
-    headers: { Authorization: `Bot ${token}` }
-  });
-  if (!res.ok) {
-    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
-  }
-  const messages = await res.json();
-  return messages.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
-}
-async function send(token, channelId, message) {
-  const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bot ${token}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ content: message })
-  });
-  if (!res.ok) {
-    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
-  }
-}
-
-// src/commands/channel.ts
-async function run(args) {
-  const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" },
-    limit: { type: "number" }
-  });
-  const subcommand = positional[0];
-  const uri = positional[1];
-  const message = positional[2];
-  if (!subcommand || !uri || subcommand === "send" && !message) {
-    console.error(`Usage:
-  volute channel read <channel-uri> [--limit N] [--agent <name>]
-  volute channel send <channel-uri> "<message>" [--agent <name>]`);
-    process.exit(1);
-  }
-  const agentName = resolveAgentName(flags);
-  const colonIdx = uri.indexOf(":");
-  if (colonIdx === -1) {
-    console.error(`Invalid channel URI: ${uri} (expected format: platform:id)`);
-    process.exit(1);
-  }
-  const platform = uri.slice(0, colonIdx);
-  const channelId = uri.slice(colonIdx + 1);
-  const { dir } = resolveAgent(agentName);
-  const env = loadMergedEnv(dir);
-  if (platform === "discord") {
-    const token = env.DISCORD_TOKEN;
-    if (!token) {
-      console.error("DISCORD_TOKEN not set. Run: volute env set DISCORD_TOKEN <token>");
-      process.exit(1);
-    }
-    if (subcommand === "read") {
-      const limit = flags.limit ?? 20;
-      const output = await read(token, channelId, limit);
-      console.log(output);
-    } else if (subcommand === "send") {
-      await send(token, channelId, message);
-    } else {
-      console.error(`Unknown subcommand: ${subcommand}`);
-      process.exit(1);
-    }
-  } else {
-    console.error(`Unsupported platform: ${platform}`);
-    process.exit(1);
-  }
-}
-export {
-  run
-};

package/dist/chunk-N4YNKR3Q.js

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/log-buffer.ts
-var LogBuffer = class {
-  entries = [];
-  maxSize = 1e3;
-  subscribers = /* @__PURE__ */ new Set();
-  append(entry) {
-    this.entries.push(entry);
-    if (this.entries.length > this.maxSize) {
-      this.entries.shift();
-    }
-    for (const sub of this.subscribers) {
-      sub(entry);
-    }
-  }
-  getEntries() {
-    return [...this.entries];
-  }
-  subscribe(fn) {
-    this.subscribers.add(fn);
-    return () => this.subscribers.delete(fn);
-  }
-};
-var logBuffer = new LogBuffer();
-
-// src/lib/logger.ts
-function write(level, msg, data) {
-  const entry = {
-    level,
-    msg,
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    ...data ? { data } : {}
-  };
-  const line = JSON.stringify(entry);
-  process.stderr.write(`${line}
-`);
-  logBuffer.append(entry);
-}
-var log = {
-  info: (msg, data) => write("info", msg, data),
-  warn: (msg, data) => write("warn", msg, data),
-  error: (msg, data) => write("error", msg, data)
-};
-var logger_default = log;
-
-// src/lib/ndjson.ts
-var MAX_BUFFER_SIZE = 1e6;
-async function* readNdjson(body) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      if (buffer.length > MAX_BUFFER_SIZE) {
-        logger_default.warn("ndjson: buffer exceeded 1MB, resetting");
-        buffer = "";
-        continue;
-      }
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          yield JSON.parse(line);
-        } catch {
-          logger_default.warn("ndjson: skipping invalid line", { line: line.slice(0, 100) });
-        }
-      }
-    }
-    if (buffer.trim()) {
-      try {
-        yield JSON.parse(buffer);
-      } catch {
-        logger_default.warn("ndjson: skipping invalid line", { line: buffer.slice(0, 100) });
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-export {
-  logBuffer,
-  logger_default,
-  readNdjson
-};

package/dist/connector-TVJULIRT.js

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadMergedEnv
-} from "./chunk-DNOXHLE5.js";
-import {
-  daemonFetch
-} from "./chunk-YGFIWIOF.js";
-import {
-  resolveAgentName
-} from "./chunk-VRVVQIYY.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
-import {
-  resolveAgent
-} from "./chunk-3C2XR4IY.js";
-import "./chunk-K3NQKI34.js";
-
-// src/commands/connector.ts
-async function run(args) {
-  const subcommand = args[0];
-  switch (subcommand) {
-    case "connect":
-      await connectConnector(args.slice(1));
-      break;
-    case "disconnect":
-      await disconnectConnector(args.slice(1));
-      break;
-    default:
-      printUsage();
-      process.exit(subcommand ? 1 : 0);
-  }
-}
-function printUsage() {
-  console.error(`Usage:
-  volute connector connect <type> [--agent <name>]
-  volute connector disconnect <type> [--agent <name>]`);
-}
-async function connectConnector(args) {
-  const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" }
-  });
-  const agentName = resolveAgentName(flags);
-  const type = positional[0];
-  if (!type) {
-    console.error("Usage: volute connector connect <type> [--agent <name>]");
-    process.exit(1);
-  }
-  const { dir } = resolveAgent(agentName);
-  if (type === "discord") {
-    const env = loadMergedEnv(dir);
-    if (!env.DISCORD_TOKEN) {
-      console.error("DISCORD_TOKEN not set. Run: volute env set DISCORD_TOKEN <token>");
-      process.exit(1);
-    }
-  } else {
-    console.error(`Unknown connector type: ${type}`);
-    process.exit(1);
-  }
-  const res = await daemonFetch(
-    `/api/agents/${encodeURIComponent(agentName)}/connectors/${encodeURIComponent(type)}`,
-    { method: "POST" }
-  );
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({ error: "Unknown error" }));
-    console.error(`Failed to start ${type} connector: ${body.error}`);
-    process.exit(1);
-  }
-  console.log(`${type} connector for ${agentName} started.`);
-}
-async function disconnectConnector(args) {
-  const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" }
-  });
-  const agentName = resolveAgentName(flags);
-  const type = positional[0];
-  if (!type) {
-    console.error("Usage: volute connector disconnect <type> [--agent <name>]");
-    process.exit(1);
-  }
-  const res = await daemonFetch(
-    `/api/agents/${encodeURIComponent(agentName)}/connectors/${encodeURIComponent(type)}`,
-    {
-      method: "DELETE"
-    }
-  );
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({ error: "Unknown error" }));
-    console.error(`Failed to stop ${type} connector: ${body.error}`);
-    process.exit(1);
-  }
-  console.log(`${type} connector for ${agentName} stopped.`);
-}
-export {
-  run
-};