volute 0.3.1 → 0.4.0

package/templates/pi/src/agent.ts

@@ -1,74 +1,293 @@
 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;
+};
+
+const DEFAULT_COMPACTION_MESSAGE =
+  "Your conversation is approaching its context limit. Please update today's journal entry to preserve important context before the conversation is compacted.";
+
+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 ?? DEFAULT_COMPACTION_MESSAGE;
+
+  // 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 };
+        }
+        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);
+          }
         }
-      } else {
-        session.agentSession!.prompt(text, opts);
+        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/sessions.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/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
-};

package/templates/_base/src/lib/sessions.ts

@@ -1,71 +0,0 @@
-import { readFileSync } from "node:fs";
-
-export type SessionRule = {
-  session: string;
-  [key: string]: string; // all other keys are match criteria
-};
-
-export type SessionConfig = {
-  rules?: SessionRule[];
-  default?: string;
-};
-
-export function loadSessionConfig(configPath: string): SessionConfig {
-  try {
-    return JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-
-/**
- * Match a glob-like pattern against a string.
- * Supports only `*` as wildcard (matches any sequence of characters).
- */
-function globMatch(pattern: string, value: string): boolean {
-  // Escape regex special chars except *, then replace * with .*
-  const regex = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${regex}$`).test(value);
-}
-
-/**
- * Resolve which session a message should route to based on the config.
- * Returns the session name (with template variables expanded, path-safe).
- */
-export function resolveSession(
-  config: SessionConfig,
-  meta: { channel?: string; sender?: string },
-): string {
-  const fallback = config.default ?? "main";
-  if (!config.rules) return fallback;
-
-  for (const rule of config.rules) {
-    if (ruleMatches(rule, meta)) {
-      return sanitizeSessionName(expandTemplate(rule.session, meta));
-    }
-  }
-
-  return fallback;
-}
-
-const MATCH_KEYS = new Set(["channel", "sender"]);
-
-function ruleMatches(rule: SessionRule, meta: { channel?: string; sender?: string }): boolean {
-  for (const [key, pattern] of Object.entries(rule)) {
-    if (key === "session") continue;
-    if (!MATCH_KEYS.has(key)) return false;
-    const value = meta[key as keyof typeof meta] ?? "";
-    if (!globMatch(pattern, value)) return false;
-  }
-  return true;
-}
-
-function expandTemplate(template: string, meta: { channel?: string; sender?: string }): string {
-  return template
-    .replace(/\$\{sender\}/g, meta.sender ?? "unknown")
-    .replace(/\$\{channel\}/g, meta.channel ?? "unknown");
-}
-
-function sanitizeSessionName(name: string): string {
-  return name.replace(/\0/g, "").replace(/[/\\]/g, "-").replace(/\.\./g, "-").slice(0, 100);
-}