volute 0.1.0 → 0.2.1

package/templates/pi/src/server.ts

@@ -1,121 +1,47 @@
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { resolve } from "node:path";
-import { createAgent } from "./lib/agent.js";
+import { createAgent } from "./agent.js";
 import { log } from "./lib/logger.js";
+import {
+  handleMergeContext,
+  handleStartupContext,
+  loadConfig,
+  loadPackageInfo,
+  loadSystemPrompt,
+  parseArgs,
+  setupShutdown,
+} from "./lib/startup.js";
 import { createVoluteServer } from "./lib/volute-server.js";
 
-function parseArgs() {
-  const args = process.argv.slice(2);
-  let port = 4100;
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--port" && args[i + 1]) {
-      port = parseInt(args[++i], 10);
-    }
-  }
-
-  return { port };
-}
-
-function loadConfig(): { model?: string } {
-  try {
-    return JSON.parse(readFileSync(resolve("volute.json"), "utf-8"));
-  } catch {
-    return {};
-  }
-}
-
-function loadFile(path: string): string {
-  try {
-    return readFileSync(path, "utf-8");
-  } catch {
-    return "";
-  }
-}
-
 const { port } = parseArgs();
 const config = loadConfig();
-const model = config.model;
-const soulPath = resolve("home/SOUL.md");
-const memoryPath = resolve("home/MEMORY.md");
-const volutePath = resolve("home/VOLUTE.md");
+if (config.model) log("server", `using model: ${config.model}`);
 
-const soul = loadFile(soulPath);
-if (!soul) {
-  console.error(`Could not read soul file: ${soulPath}`);
-  process.exit(1);
-}
+const systemPrompt = loadSystemPrompt();
+const pkg = loadPackageInfo();
 
-const memory = loadFile(memoryPath);
-const volute = loadFile(volutePath);
-
-const promptParts = [soul];
-if (volute) promptParts.push(volute);
-if (memory) promptParts.push(`## Memory\n\n${memory}`);
-const systemPrompt = promptParts.join("\n\n---\n\n");
-
-// Check if a session directory exists (indicates resumable session)
-const sessionsDir = resolve("home/.pi/sessions");
-const hasExistingSession = existsSync(sessionsDir);
-if (hasExistingSession) {
-  log("server", "found existing sessions, will attempt resume");
-}
-
-// Read name/version from package.json for health endpoint
-let pkgName = "unknown";
-let pkgVersion = "0.0.0";
-try {
-  const pkg = JSON.parse(readFileSync(resolve("package.json"), "utf-8"));
-  pkgName = pkg.name || pkgName;
-  pkgVersion = pkg.version || pkgVersion;
-} catch {}
-
-const agent = await createAgent({
+const agent = createAgent({
   systemPrompt,
   cwd: resolve("home"),
-  model,
-  resume: hasExistingSession,
-  onCompact: () => {
-    log("server", "pre-compact — asking agent to update daily log");
-    agent.sendMessage(
-      "Conversation is about to be compacted. Please update today's daily log with a summary of what we've discussed and accomplished so far, so context is preserved before compaction.",
-      "system",
-    );
-  },
+  model: config.model,
+  compactionMessage: config.compactionMessage,
 });
 
-const server = createVoluteServer({ agent, port, name: pkgName, version: pkgVersion });
+const server = createVoluteServer({
+  agent,
+  port,
+  name: pkg.name,
+  version: pkg.version,
+  sessionsConfigPath: resolve("home/.config/sessions.json"),
+});
 
-server.listen(port, () => {
+server.listen(port, async () => {
   const addr = server.address();
   const actualPort = typeof addr === "object" && addr ? addr.port : port;
   log("server", `listening on :${actualPort}`);
-
-  // Check for post-merge context
-  const mergedPath = resolve(".volute/merged.json");
-  if (existsSync(mergedPath)) {
-    try {
-      const merged = JSON.parse(readFileSync(mergedPath, "utf-8"));
-      unlinkSync(mergedPath);
-
-      const parts = [
-        `[system] Variant "${merged.name}" has been merged and you have been restarted.`,
-      ];
-      if (merged.summary) parts.push(`Changes: ${merged.summary}`);
-      if (merged.justification) parts.push(`Why: ${merged.justification}`);
-      if (merged.memory) parts.push(`Context: ${merged.memory}`);
-
-      agent.sendMessage(parts.join("\n"));
-      log("server", `sent post-merge orientation for variant: ${merged.name}`);
-    } catch (e) {
-      log("server", "failed to process merged.json:", e);
-    }
+  const hasMerge = handleMergeContext((content) => agent.sendMessage(content));
+  if (!hasMerge) {
+    await handleStartupContext((content) => agent.sendMessage(content));
   }
 });
 
-function shutdown() {
-  log("server", "shutdown signal received");
-  process.exit(0);
-}
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
+setupShutdown();

package/templates/pi/volute-template.json

@@ -2,7 +2,7 @@
   "rename": {
     "package.json.tmpl": "package.json",
     "biome.json.tmpl": "biome.json",
-    "volute.json.tmpl": "volute.json"
+    "home/.config/volute.json.tmpl": "home/.config/volute.json"
   },
   "substitute": ["package.json", ".init/SOUL.md"],
   "skillsDir": "home/.claude/skills"

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

@@ -1,199 +0,0 @@
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { createAutoCommitHook } from "./hooks/auto-commit.js";
-import { createIdentityReloadHook } from "./hooks/identity-reload.js";
-import { createPreCompactHook } from "./hooks/pre-compact.js";
-import { log, logMessage, logText, logThinking, logToolUse } from "./logger.js";
-import { createMessageChannel } from "./message-channel.js";
-import type { ChannelMeta, VoluteContentPart, VoluteEvent } from "./types.js";
-
-type Listener = (event: VoluteEvent) => void;
-
-function formatPrefix(meta: ChannelMeta | undefined, time: string): string {
-  if (!meta?.channel && !meta?.sender) return "";
-  // Use explicit platform name or capitalize from channel URI prefix
-  const platform =
-    meta.platform ??
-    (() => {
-      const n = (meta.channel ?? "").split(":")[0];
-      return n.charAt(0).toUpperCase() + n.slice(1);
-    })();
-  // Build sender context (e.g., "χθ in DM" or "χθ in #general in My Server")
-  let sender = meta.sender ?? "";
-  if (meta.isDM) {
-    sender += " in DM";
-  } else if (meta.channelName) {
-    sender += ` in #${meta.channelName}`;
-    if (meta.guildName) sender += ` in ${meta.guildName}`;
-  }
-  const parts = [platform, sender].filter(Boolean);
-  return parts.length > 0 ? `[${parts.join(": ")} — ${time}]\n` : "";
-}
-
-export function createAgent(options: {
-  systemPrompt: string;
-  cwd: string;
-  abortController: AbortController;
-  model?: string;
-  resume?: string;
-  onSessionId?: (id: string) => void;
-  onStreamError?: (err: unknown) => void;
-  onCompact?: () => void;
-  onIdentityReload?: () => void;
-}) {
-  const channel = createMessageChannel();
-  const listeners = new Set<Listener>();
-
-  const autoCommit = createAutoCommitHook(options.cwd);
-  const identityReload = createIdentityReloadHook(options.cwd);
-  const preCompact = createPreCompactHook(() => {
-    if (options.onCompact) options.onCompact();
-  });
-
-  function broadcast(event: VoluteEvent) {
-    for (const listener of listeners) {
-      try {
-        listener(event);
-      } catch (err) {
-        log("agent", "listener threw during broadcast:", err);
-      }
-    }
-  }
-
-  function createStream(resume?: string) {
-    return query({
-      prompt: channel.iterable,
-      options: {
-        systemPrompt: options.systemPrompt,
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        settingSources: ["project"],
-        cwd: options.cwd,
-        abortController: options.abortController,
-        model: options.model,
-        resume,
-        hooks: {
-          PostToolUse: [{ matcher: "Edit|Write", hooks: [autoCommit.hook, identityReload.hook] }],
-          PreCompact: [{ hooks: [preCompact.hook] }],
-        },
-      },
-    });
-  }
-
-  async function consumeStream(stream: ReturnType<typeof query>) {
-    for await (const msg of stream) {
-      if ("session_id" in msg && msg.session_id && options.onSessionId) {
-        options.onSessionId(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);
-            broadcast({ type: "text", content: text });
-          } else if (b.type === "tool_use") {
-            const tb = b as { name: string; input: unknown };
-            logToolUse(tb.name, tb.input);
-            broadcast({ type: "tool_use", name: tb.name, input: tb.input });
-          }
-        }
-      }
-      if (msg.type === "result") {
-        log("agent", "turn done");
-        broadcast({ type: "done" });
-        if (identityReload.needsReload()) {
-          options.onIdentityReload?.();
-        }
-      }
-    }
-  }
-
-  // Consume the SDK stream and broadcast VoluteEvent events
-  (async () => {
-    log("agent", "stream consumer started");
-    try {
-      await consumeStream(createStream(options.resume));
-    } catch (err) {
-      if (options.resume) {
-        log("agent", "session resume failed, starting fresh:", err);
-        if (options.onStreamError) options.onStreamError(err);
-        try {
-          await consumeStream(createStream());
-        } catch (retryErr) {
-          log("agent", "stream consumer error:", retryErr);
-          process.exit(1);
-        }
-      } else {
-        log("agent", "stream consumer error:", err);
-        if (options.onStreamError) options.onStreamError(err);
-        process.exit(1);
-      }
-    }
-    log("agent", "stream consumer ended");
-  })();
-
-  function sendMessage(content: string | VoluteContentPart[], meta?: ChannelMeta) {
-    const text =
-      typeof content === "string"
-        ? content
-        : content.map((p) => (p.type === "text" ? p.text : `[${p.type}]`)).join(" ");
-    logMessage("in", text, meta?.channel);
-
-    // Build context prefix from channel metadata
-    const time = new Date().toLocaleString();
-    const prefix = formatPrefix(meta, time);
-
-    let sdkContent: (
-      | { type: "text"; text: string }
-      | {
-          type: "image";
-          source: {
-            type: "base64";
-            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
-            data: string;
-          };
-        }
-    )[];
-
-    if (typeof content === "string") {
-      sdkContent = [{ type: "text" as const, text: prefix + content }];
-    } else {
-      const hasText = content.some((p) => p.type === "text");
-      sdkContent = content.map((part, i) => {
-        if (part.type === "text") {
-          return { type: "text" as const, text: (i === 0 ? prefix : "") + part.text };
-        }
-        return {
-          type: "image" as const,
-          source: {
-            type: "base64" as const,
-            media_type: part.media_type as "image/jpeg" | "image/png" | "image/gif" | "image/webp",
-            data: part.data,
-          },
-        };
-      });
-      // If no text parts but we have a prefix, prepend a text part
-      if (prefix && !hasText) {
-        sdkContent.unshift({ type: "text" as const, text: prefix.trimEnd() });
-      }
-    }
-
-    channel.push({
-      type: "user",
-      session_id: "",
-      message: {
-        role: "user",
-        content: sdkContent,
-      },
-      parent_tool_use_id: null,
-    });
-  }
-
-  function onMessage(listener: Listener): () => void {
-    listeners.add(listener);
-    return () => listeners.delete(listener);
-  }
-
-  return { sendMessage, onMessage, waitForCommits: autoCommit.waitForCommits };
-}

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

@@ -1,205 +0,0 @@
-import { getModel, getModels, type ImageContent } 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, logMessage, logText, logThinking, logToolResult, logToolUse } from "./logger.js";
-import type { ChannelMeta, VoluteContentPart, VoluteEvent } from "./types.js";
-
-type Listener = (event: VoluteEvent) => void;
-
-function formatPrefix(meta: ChannelMeta | undefined): string {
-  if (!meta?.channel && !meta?.sender) return "";
-  const platform =
-    meta.platform ??
-    (() => {
-      const n = (meta.channel ?? "").split(":")[0];
-      return n.charAt(0).toUpperCase() + n.slice(1);
-    })();
-  let sender = meta.sender ?? "";
-  if (meta.isDM) {
-    sender += " in DM";
-  } else if (meta.channelName) {
-    sender += ` in #${meta.channelName}`;
-    if (meta.guildName) sender += ` in ${meta.guildName}`;
-  }
-  const parts = [platform, sender].filter(Boolean);
-  return parts.length > 0 ? `[${parts.join(": ")}]\n` : "";
-}
-
-export async function createAgent(options: {
-  systemPrompt: string;
-  cwd: string;
-  model?: string;
-  resume?: boolean;
-  onCompact?: () => void;
-}) {
-  const listeners = new Set<Listener>();
-
-  // Block compaction once so the agent can update its daily log with full context
-  let compactBlocked = false;
-  const preCompactExtension: ExtensionFactory = (pi) => {
-    pi.on("session_before_compact", () => {
-      if (!compactBlocked) {
-        compactBlocked = true;
-        log("agent", "blocking compaction — asking agent to update daily log first");
-        if (options.onCompact) options.onCompact();
-        return { cancel: true };
-      }
-      compactBlocked = false;
-      log("agent", "allowing compaction");
-    });
-  };
-
-  // Parse model string: "provider:model-id" or use default
-  const modelStr = options.model || process.env.PI_MODEL || "anthropic:claude-sonnet-4-20250514";
-  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(", ")}`,
-    );
-  }
-
-  const authStorage = new AuthStorage();
-  const modelRegistry = new ModelRegistry(authStorage);
-
-  // Use persistent sessions in cwd for resume support, or in-memory if not resuming
-  const sessionManager = options.resume
-    ? SessionManager.continueRecent(options.cwd)
-    : SessionManager.create(options.cwd);
-
-  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 } = await createAgentSession({
-    cwd: options.cwd,
-    model,
-    authStorage,
-    modelRegistry,
-    sessionManager,
-    settingsManager,
-    resourceLoader,
-  });
-
-  function broadcast(event: VoluteEvent) {
-    for (const listener of listeners) {
-      try {
-        listener(event);
-      } catch (err) {
-        log("agent", "listener threw during broadcast:", err);
-      }
-    }
-  }
-
-  const toolArgs = new Map<string, any>();
-
-  session.subscribe((event) => {
-    if (event.type === "message_update") {
-      const ae = event.assistantMessageEvent;
-      if (ae.type === "text_delta") {
-        logText(ae.delta);
-        broadcast({ 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({
-        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({
-        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 { file_path?: string })?.file_path;
-        if (filePath) {
-          commitFileChange(filePath, options.cwd);
-        }
-      }
-      toolArgs.delete(event.toolCallId);
-    }
-
-    if (event.type === "agent_end") {
-      log("agent", "turn done");
-      broadcast({ type: "done" });
-    }
-  });
-
-  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);
-
-    // Build context prefix from channel metadata
-    const prefix = formatPrefix(meta);
-    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 } : {};
-
-    if (session.isStreaming) {
-      session.prompt(text, { streamingBehavior: "followUp", ...opts });
-    } else {
-      session.prompt(text, opts);
-    }
-  }
-
-  function onMessage(listener: Listener): () => void {
-    listeners.add(listener);
-    return () => listeners.delete(listener);
-  }
-
-  return { sendMessage, onMessage };
-}