volute 0.3.0 → 0.4.0

package/templates/agent-sdk/src/lib/agent-sessions.ts

@@ -1,204 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { createPreCompactHook } from "./hooks/pre-compact.js";
-import { log, logText, logThinking, logToolUse } from "./logger.js";
-import { createMessageChannel } from "./message-channel.js";
-import type { Listener, VoluteEvent } from "./types.js";
-
-type Session = {
-  name: string;
-  channel: ReturnType<typeof createMessageChannel>;
-  listeners: Set<Listener>;
-  messageIds: (string | undefined)[];
-  currentMessageId?: string;
-  currentQuery?: ReturnType<typeof query>;
-};
-
-export function createSessionManager(options: {
-  systemPrompt: string;
-  cwd: string;
-  abortController: AbortController;
-  model?: string;
-  sessionsDir: string;
-  postToolUseHooks: { matcher: string; hooks: HookCallback[] }[];
-  onTurnDone?: () => void;
-  compactionMessage?: string;
-}) {
-  const sessions = new Map<string, Session>();
-  const compactionMessage =
-    options.compactionMessage ??
-    "Your conversation is approaching its context limit. Please update today's journal entry to preserve important context before the conversation is compacted.";
-
-  function sessionFilePath(sessionName: string): string {
-    return resolve(options.sessionsDir, `${sessionName}.json`);
-  }
-
-  function loadSessionId(sessionName: string): string | undefined {
-    try {
-      const data = JSON.parse(readFileSync(sessionFilePath(sessionName), "utf-8"));
-      return data.sessionId;
-    } catch {
-      return undefined;
-    }
-  }
-
-  function saveSessionId(sessionName: string, sessionId: string) {
-    mkdirSync(options.sessionsDir, { recursive: true });
-    writeFileSync(sessionFilePath(sessionName), JSON.stringify({ sessionId }));
-  }
-
-  function deleteSessionId(sessionName: string) {
-    try {
-      const path = sessionFilePath(sessionName);
-      if (existsSync(path)) unlinkSync(path);
-    } catch (err) {
-      log("agent", `failed to delete session file for "${sessionName}":`, err);
-    }
-  }
-
-  function broadcastToSession(session: Session, 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 createStream(session: Session, resume?: string) {
-    const preCompact = createPreCompactHook(() => {
-      session.messageIds.push(undefined); // internal message, no messageId
-      session.channel.push({
-        type: "user",
-        session_id: "",
-        message: {
-          role: "user",
-          content: [{ type: "text", text: compactionMessage }],
-        },
-        parent_tool_use_id: null,
-      });
-    });
-
-    return query({
-      prompt: session.channel.iterable,
-      options: {
-        systemPrompt: options.systemPrompt,
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        settingSources: ["project"],
-        cwd: options.cwd,
-        abortController: options.abortController,
-        model: options.model,
-        resume,
-        hooks: {
-          PostToolUse: options.postToolUseHooks,
-          PreCompact: [{ hooks: [preCompact.hook] }],
-        },
-      },
-    });
-  }
-
-  async function consumeStream(stream: ReturnType<typeof query>, session: Session) {
-    for await (const msg of stream) {
-      // At the start of each turn, shift the next messageId
-      if (session.currentMessageId === undefined) {
-        session.currentMessageId = session.messageIds.shift();
-      }
-      if ("session_id" in msg && msg.session_id) {
-        if (!session.name.startsWith("new-")) {
-          saveSessionId(session.name, msg.session_id as string);
-        }
-      }
-      if (msg.type === "assistant") {
-        for (const b of msg.message.content) {
-          if (b.type === "thinking" && "thinking" in b && b.thinking) {
-            logThinking(b.thinking as string);
-          } else if (b.type === "text") {
-            const text = (b as { text: string }).text;
-            logText(text);
-            broadcastToSession(session, { type: "text", content: text });
-          } else if (b.type === "tool_use") {
-            const tb = b as { name: string; input: unknown };
-            logToolUse(tb.name, tb.input);
-            broadcastToSession(session, { type: "tool_use", name: tb.name, input: tb.input });
-          }
-        }
-      }
-      if (msg.type === "result") {
-        log("agent", `session "${session.name}": turn done`);
-        broadcastToSession(session, { type: "done" });
-        session.currentMessageId = undefined;
-        options.onTurnDone?.();
-      }
-    }
-  }
-
-  function startSession(session: Session, savedSessionId?: string) {
-    (async () => {
-      log("agent", `session "${session.name}": stream consumer started`);
-      try {
-        const q = createStream(session, savedSessionId);
-        session.currentQuery = q;
-        await consumeStream(q, session);
-      } catch (err) {
-        if (savedSessionId) {
-          log("agent", `session "${session.name}": resume failed, starting fresh:`, err);
-          deleteSessionId(session.name);
-          try {
-            const q = createStream(session);
-            session.currentQuery = q;
-            await consumeStream(q, session);
-          } catch (retryErr) {
-            log("agent", `session "${session.name}": stream consumer error:`, retryErr);
-            broadcastToSession(session, { type: "done" });
-            sessions.delete(session.name);
-          }
-        } else {
-          log("agent", `session "${session.name}": stream consumer error:`, err);
-          broadcastToSession(session, { type: "done" });
-          sessions.delete(session.name);
-        }
-      }
-      log("agent", `session "${session.name}": stream consumer ended`);
-    })();
-  }
-
-  function getOrCreateSession(name: string): Session {
-    const existing = sessions.get(name);
-    if (existing) return existing;
-
-    const session: Session = {
-      name,
-      channel: createMessageChannel(),
-      listeners: new Set(),
-      messageIds: [],
-    };
-    sessions.set(name, session);
-
-    const isEphemeral = name.startsWith("new-");
-    const savedSessionId = isEphemeral ? undefined : loadSessionId(name);
-    if (savedSessionId) {
-      log("agent", `session "${name}": resuming ${savedSessionId}`);
-    } else {
-      log("agent", `session "${name}": starting fresh`);
-    }
-
-    startSession(session, savedSessionId);
-    return session;
-  }
-
-  function interruptSession(name: string) {
-    const session = sessions.get(name);
-    if (session?.currentMessageId !== undefined && session.currentQuery) {
-      log("agent", `session "${name}": interrupting current turn`);
-      session.currentQuery.interrupt();
-    }
-  }
-
-  return { getOrCreateSession, interruptSession };
-}

package/templates/pi/src/lib/agent-sessions.ts

@@ -1,210 +0,0 @@
-import { getModel, getModels } from "@mariozechner/pi-ai";
-import {
-  AuthStorage,
-  createAgentSession,
-  DefaultResourceLoader,
-  type ExtensionFactory,
-  ModelRegistry,
-  SessionManager,
-  SettingsManager,
-} from "@mariozechner/pi-coding-agent";
-import { commitFileChange } from "./auto-commit.js";
-import { log, logText, logThinking, logToolResult, logToolUse } from "./logger.js";
-import type { Listener, VoluteEvent } from "./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;
-}
-
-export function createPiSessionManager(options: {
-  systemPrompt: string;
-  cwd: string;
-  model?: string;
-  compactionMessage?: string;
-}) {
-  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);
-
-  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);
-    return session;
-  }
-
-  async function initSession(session: PiSession) {
-    const isEphemeral = session.name.startsWith("new-");
-
-    // Per-session session manager
-    const sessionManager = isEphemeral
-      ? SessionManager.inMemory()
-      : SessionManager.continueRecent(options.cwd, `.volute/pi-sessions/${session.name}`);
-
-    log("agent", `session "${session.name}": ${isEphemeral ? "ephemeral" : "persistent"}`);
-
-    // Per-session pre-compact extension: block once, send compaction message, allow on second call
-    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); // internal message, no messageId
-          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) => {
-      // At the start of each turn, shift the next messageId
-      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/
-        // pi-coding-agent uses lowercase tool names ("edit", "write") and "path" arg
-        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`);
-  }
-
-  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;
-    }
-  }
-
-  return { getOrCreateSession, interruptSession };
-}