volute 0.1.0

package/dist/import-W2AMTEV5.js

@@ -0,0 +1,410 @@
+#!/usr/bin/env node
+import {
+  composeTemplate,
+  copyTemplateToDir,
+  findTemplatesRoot
+} from "./chunk-GSPKUPKU.js";
+import {
+  exec,
+  execInherit
+} from "./chunk-XZN4WPNC.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  addAgent,
+  agentDir,
+  ensureVoluteHome,
+  nextPort
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/import.ts
+import {
+  cpSync,
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  rmSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/lib/consolidate.ts
+import { readdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+async function consolidateMemory(agentDir2) {
+  const soulPath = resolve(agentDir2, "home/SOUL.md");
+  const memoryPath = resolve(agentDir2, "home/MEMORY.md");
+  const memoryDir = resolve(agentDir2, "home/memory");
+  const soul = readFileSync(soulPath, "utf-8");
+  const logs = [];
+  try {
+    const files = readdirSync(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
+    for (const filename of files) {
+      const date = filename.replace(".md", "");
+      const content2 = readFileSync(resolve(memoryDir, filename), "utf-8").trim();
+      if (content2) {
+        logs.push(`### ${date}
+
+${content2}`);
+      }
+    }
+  } catch {
+  }
+  if (logs.length === 0) {
+    console.log("No daily logs found.");
+    return;
+  }
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.error("ANTHROPIC_API_KEY not set, skipping memory consolidation.");
+    return;
+  }
+  console.log("Consolidating memory from daily logs...");
+  const userMessage = [
+    "You have daily logs from a previous environment but no long-term memory file yet.",
+    "Please review the daily logs below and produce consolidated MEMORY.md content.",
+    "Keep it concise and organized by topic. Output ONLY the markdown content for MEMORY.md, nothing else.",
+    "",
+    "## Daily logs",
+    "",
+    logs.join("\n\n")
+  ].join("\n");
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 4096,
+      system: soul,
+      messages: [{ role: "user", content: userMessage }]
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    console.error(`Anthropic API error (${res.status}): ${body}`);
+    return;
+  }
+  const data = await res.json();
+  const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
+  if (content) {
+    writeFileSync(memoryPath, `${content}
+`);
+    console.log("MEMORY.md created successfully.");
+  } else {
+    console.warn("Warning: No content produced.");
+  }
+}
+
+// src/lib/convert-session.ts
+import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { resolve as resolve2 } from "path";
+function convertSession(opts) {
+  const lines = readFileSync2(opts.sessionPath, "utf-8").trim().split("\n");
+  const sessionId = randomUUID();
+  const idMap = /* @__PURE__ */ new Map();
+  const messages = [];
+  for (const line of lines) {
+    const event = JSON.parse(line);
+    if (event.type === "message" && event.message) {
+      messages.push(event);
+    }
+  }
+  const sdkEvents = [];
+  let lastSdkUuid = null;
+  for (let i = 0; i < messages.length; i++) {
+    const event = messages[i];
+    const msg = event.message;
+    if (msg.role === "user") {
+      const uuid = randomUUID();
+      idMap.set(event.id, uuid);
+      const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : null;
+      const sdkEvent = {
+        uuid,
+        parentUuid,
+        sessionId,
+        timestamp: event.timestamp,
+        cwd: opts.projectDir,
+        version: "0.1.0",
+        gitBranch: "main",
+        isSidechain: false,
+        userType: "external",
+        type: "user",
+        message: {
+          role: "user",
+          content: msg.content
+        }
+      };
+      sdkEvents.push(JSON.stringify(sdkEvent));
+      lastSdkUuid = uuid;
+    } else if (msg.role === "assistant") {
+      const content = convertAssistantContent(msg.content);
+      if (content.length === 0) continue;
+      const uuid = randomUUID();
+      idMap.set(event.id, uuid);
+      const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : null;
+      const stopReason = mapStopReason(msg.stopReason);
+      const sdkEvent = {
+        uuid,
+        parentUuid,
+        sessionId,
+        timestamp: event.timestamp,
+        cwd: opts.projectDir,
+        version: "0.1.0",
+        gitBranch: "main",
+        isSidechain: false,
+        userType: "external",
+        type: "assistant",
+        requestId: `req_imported_${randomUUID()}`,
+        message: {
+          role: "assistant",
+          content,
+          type: "message",
+          id: `msg_imported_${randomUUID()}`,
+          model: mapModel(msg.model),
+          stop_reason: stopReason,
+          stop_sequence: null,
+          usage: mapUsage(msg.usage)
+        }
+      };
+      sdkEvents.push(JSON.stringify(sdkEvent));
+      lastSdkUuid = uuid;
+    } else if (msg.role === "toolResult") {
+      const toolResults = [];
+      let lastToolResultId = event.id;
+      let lastTimestamp = event.timestamp;
+      let j = i;
+      while (j < messages.length && messages[j].message.role === "toolResult") {
+        const tr = messages[j];
+        const trMsg = tr.message;
+        lastToolResultId = tr.id;
+        lastTimestamp = tr.timestamp;
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: trMsg.toolCallId,
+          content: trMsg.content,
+          ...trMsg.isError ? { is_error: true } : {}
+        });
+        j++;
+      }
+      i = j - 1;
+      const uuid = randomUUID();
+      idMap.set(lastToolResultId, uuid);
+      const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : lastSdkUuid;
+      const sdkEvent = {
+        uuid,
+        parentUuid,
+        sessionId,
+        timestamp: lastTimestamp,
+        cwd: opts.projectDir,
+        version: "0.1.0",
+        gitBranch: "main",
+        isSidechain: false,
+        userType: "external",
+        type: "user",
+        sourceToolAssistantUUID: lastSdkUuid ?? void 0,
+        toolUseResult: "imported",
+        message: {
+          role: "user",
+          content: toolResults
+        }
+      };
+      sdkEvents.push(JSON.stringify(sdkEvent));
+      lastSdkUuid = uuid;
+    }
+  }
+  const projectId = opts.projectDir.replace(/\//g, "-");
+  const sdkDir = resolve2(homedir(), ".claude", "projects", projectId);
+  mkdirSync(sdkDir, { recursive: true });
+  const sdkPath = resolve2(sdkDir, `${sessionId}.jsonl`);
+  writeFileSync2(sdkPath, `${sdkEvents.join("\n")}
+`);
+  console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
+  return sessionId;
+}
+var MODEL_MAP = {
+  "claude-opus-4-5": "claude-opus-4-5-20251101",
+  "claude-sonnet-4": "claude-sonnet-4-20250514"
+};
+function mapModel(model) {
+  if (!model) return "claude-opus-4-5-20251101";
+  return MODEL_MAP[model] ?? model;
+}
+function mapStopReason(stopReason) {
+  if (!stopReason) return "end_turn";
+  const map = {
+    toolUse: "tool_use",
+    endTurn: "end_turn",
+    stop: "end_turn",
+    maxTokens: "max_tokens"
+  };
+  return map[stopReason] ?? stopReason;
+}
+function mapUsage(usage) {
+  if (!usage) return { input_tokens: 0, output_tokens: 0 };
+  return {
+    input_tokens: usage.input ?? usage.input_tokens ?? 0,
+    output_tokens: usage.output ?? usage.output_tokens ?? 0,
+    cache_read_input_tokens: usage.cacheRead ?? usage.cache_read_input_tokens ?? 0,
+    cache_creation_input_tokens: usage.cacheWrite ?? usage.cache_creation_input_tokens ?? 0
+  };
+}
+function convertAssistantContent(content) {
+  const result = [];
+  for (const block of content) {
+    if (block.type === "thinking") {
+    } else if (block.type === "toolCall") {
+      result.push({
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input: block.arguments ?? block.input ?? {},
+        caller: { type: "direct" }
+      });
+    } else {
+      result.push(block);
+    }
+  }
+  return result;
+}
+
+// src/commands/import.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    name: { type: "string" },
+    session: { type: "string" },
+    template: { type: "string" }
+  });
+  const workspacePath = positional[0];
+  if (!workspacePath) {
+    console.error(
+      "Usage: volute import <openclaw-workspace-path> [--name <name>] [--session <session-jsonl-path>] [--template <name>]"
+    );
+    process.exit(1);
+  }
+  const wsDir = resolve3(workspacePath);
+  const soulPath = resolve3(wsDir, "SOUL.md");
+  const identityPath = resolve3(wsDir, "IDENTITY.md");
+  if (!existsSync(soulPath) || !existsSync(identityPath)) {
+    console.error("Not a valid OpenClaw workspace: missing SOUL.md or IDENTITY.md");
+    process.exit(1);
+  }
+  const soul = readFileSync3(soulPath, "utf-8");
+  const identity = readFileSync3(identityPath, "utf-8");
+  const userPath = resolve3(wsDir, "USER.md");
+  const user = existsSync(userPath) ? readFileSync3(userPath, "utf-8") : "";
+  const name = flags.name ?? parseNameFromIdentity(identity) ?? "imported-agent";
+  const mergedSoul = `${soul.trimEnd()}
+
+---
+
+${identity.trimEnd()}
+`;
+  const mergedMemoryExtra = user ? `
+
+---
+
+${user.trimEnd()}
+` : "";
+  ensureVoluteHome();
+  const dest = agentDir(name);
+  if (existsSync(dest)) {
+    console.error(`Agent already exists: ${name}`);
+    process.exit(1);
+  }
+  const template = flags.template ?? "agent-sdk";
+  const templatesRoot = findTemplatesRoot();
+  const { composedDir, manifest } = composeTemplate(templatesRoot, template);
+  try {
+    console.log(`Creating project: ${name}`);
+    copyTemplateToDir(composedDir, dest, name, manifest);
+  } finally {
+    rmSync(composedDir, { recursive: true, force: true });
+  }
+  const initDir = resolve3(dest, ".init");
+  if (existsSync(initDir)) {
+    cpSync(initDir, resolve3(dest, "home"), { recursive: true });
+    rmSync(initDir, { recursive: true, force: true });
+  }
+  writeFileSync3(resolve3(dest, "home/SOUL.md"), mergedSoul);
+  console.log("Wrote SOUL.md (merged with IDENTITY.md)");
+  const wsMemoryPath = resolve3(wsDir, "MEMORY.md");
+  const hasMemory = existsSync(wsMemoryPath);
+  if (hasMemory) {
+    const existingMemory = readFileSync3(wsMemoryPath, "utf-8");
+    writeFileSync3(
+      resolve3(dest, "home/MEMORY.md"),
+      `${existingMemory.trimEnd()}${mergedMemoryExtra}`
+    );
+    console.log(user ? "Wrote MEMORY.md (merged with USER.md)" : "Copied MEMORY.md");
+  } else if (user) {
+    writeFileSync3(resolve3(dest, "home/MEMORY.md"), `${user.trimEnd()}
+`);
+    console.log("Wrote MEMORY.md (from USER.md)");
+  }
+  const wsMemoryDir = resolve3(wsDir, "memory");
+  let dailyLogCount = 0;
+  if (existsSync(wsMemoryDir)) {
+    const destMemoryDir = resolve3(dest, "home/memory");
+    const files = readdirSync2(wsMemoryDir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      cpSync(resolve3(wsMemoryDir, file), resolve3(destMemoryDir, file));
+    }
+    dailyLogCount = files.length;
+    if (dailyLogCount > 0) {
+      console.log(`Copied ${dailyLogCount} daily log(s)`);
+    }
+  }
+  const port = nextPort();
+  addAgent(name, port);
+  console.log("Installing dependencies...");
+  await execInherit("npm", ["install"], { cwd: dest });
+  if (!hasMemory && dailyLogCount > 0) {
+    console.log("No MEMORY.md \u2014 running memory consolidation...");
+    await consolidateMemory(dest);
+  }
+  await exec("git", ["init"], { cwd: dest });
+  await exec("git", ["add", "-A"], { cwd: dest });
+  await exec("git", ["commit", "-m", "import from OpenClaw"], { cwd: dest });
+  if (flags.session && template !== "agent-sdk") {
+    console.warn(
+      "Warning: --session is only supported with the agent-sdk template, skipping session import"
+    );
+  }
+  if (flags.session && template === "agent-sdk") {
+    const sessionFile = resolve3(flags.session);
+    if (!existsSync(sessionFile)) {
+      console.error(`Session file not found: ${sessionFile}`);
+      process.exit(1);
+    }
+    console.log("Converting session...");
+    const sessionId = convertSession({
+      sessionPath: sessionFile,
+      projectDir: dest
+    });
+    const voluteDir = resolve3(dest, ".volute");
+    mkdirSync2(voluteDir, { recursive: true });
+    writeFileSync3(resolve3(voluteDir, "session.json"), JSON.stringify({ sessionId }));
+  }
+  console.log(`
+Imported agent: ${name} (port ${port})`);
+  console.log(`
+  volute start ${name}`);
+}
+function parseNameFromIdentity(identity) {
+  const match = identity.match(/\*\*Name:\*\*\s*(.+)/);
+  if (match) {
+    return match[1].trim().toLowerCase().replace(/\s+/g, "-");
+  }
+  return void 0;
+}
+export {
+  run
+};

package/dist/logs-BUHRIQ2L.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  resolveAgent
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/logs.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { resolve } from "path";
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    follow: { type: "boolean" },
+    n: { type: "number" }
+  });
+  const name = positional[0];
+  if (!name) {
+    console.error("Usage: volute logs <name> [--follow] [-n N]");
+    process.exit(1);
+  }
+  const { dir } = resolveAgent(name);
+  const logFile = resolve(dir, ".volute", "logs", "agent.log");
+  if (!existsSync(logFile)) {
+    console.error(`No log file found. Has ${name} been started?`);
+    process.exit(1);
+  }
+  const tailArgs = [`-n`, String(flags.n ?? 50), ...flags.follow ? ["-f"] : [], logFile];
+  const child = spawn("tail", tailArgs, { stdio: "inherit" });
+  child.on("exit", (code) => process.exit(code ?? 0));
+}
+export {
+  run
+};

package/dist/merge-446QTE7Q.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+import {
+  spawnServer
+} from "./chunk-N4QN44LC.js";
+import {
+  exec,
+  execInherit
+} from "./chunk-XZN4WPNC.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  checkHealth,
+  findVariant,
+  removeVariant,
+  resolveAgent,
+  validateBranchName
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/merge.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+
+// src/lib/verify.ts
+async function verify(port) {
+  const health = await checkHealth(port);
+  if (!health.ok) {
+    console.error("  Health check: failed");
+    return false;
+  }
+  console.log("  Health check: OK");
+  try {
+    const res = await fetch(`http://localhost:${port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        content: [{ type: "text", text: "ping" }],
+        channel: "system"
+      }),
+      signal: AbortSignal.timeout(6e4)
+    });
+    if (!res.ok || !res.body) {
+      console.error("  Test message: failed to send");
+      return false;
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let gotDone = false;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          if (event.type === "done") {
+            gotDone = true;
+          }
+        } catch {
+        }
+      }
+      if (gotDone) {
+        reader.cancel();
+        break;
+      }
+    }
+    if (gotDone) {
+      console.log("  Test message: OK");
+      return true;
+    } else {
+      console.error("  Test message: no done event received");
+      return false;
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`  Test message: ${msg}`);
+    return false;
+  }
+}
+
+// src/commands/merge.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    summary: { type: "string" },
+    justification: { type: "string" },
+    memory: { type: "string" },
+    "skip-verify": { type: "boolean" }
+  });
+  const agentName = positional[0];
+  const variantName = positional[1];
+  if (!agentName || !variantName) {
+    console.error(
+      "Usage: volute merge <agent> <variant> [--summary '...'] [--justification '...'] [--memory '...'] [--skip-verify]"
+    );
+    process.exit(1);
+  }
+  const { dir: projectRoot } = resolveAgent(agentName);
+  const variant = findVariant(agentName, variantName);
+  if (!variant) {
+    console.error(`Unknown variant: ${variantName}`);
+    process.exit(1);
+  }
+  const branchErr = validateBranchName(variant.branch);
+  if (branchErr) {
+    console.error(branchErr);
+    process.exit(1);
+  }
+  if (existsSync(variant.path)) {
+    const status = (await exec("git", ["status", "--porcelain"], { cwd: variant.path })).trim();
+    if (status) {
+      console.log("Committing uncommitted changes in variant...");
+      await exec("git", ["add", "-A"], { cwd: variant.path });
+      await exec("git", ["commit", "-m", "Auto-commit uncommitted changes before merge"], {
+        cwd: variant.path
+      });
+    }
+  }
+  if (!flags["skip-verify"]) {
+    console.log("Verifying variant...");
+    let port = variant.port;
+    let tempServerPid;
+    let running = false;
+    if (variant.pid) {
+      try {
+        process.kill(variant.pid, 0);
+        running = true;
+      } catch {
+      }
+    }
+    if (!running) {
+      console.log("Starting temporary server for verification...");
+      const result = await spawnServer(variant.path, 0, { detached: true });
+      if (!result) {
+        console.error("Failed to start server for verification. Use --skip-verify to skip.");
+        process.exit(1);
+      }
+      port = result.actualPort;
+      tempServerPid = result.child.pid;
+    }
+    const verified = await verify(port);
+    if (tempServerPid) {
+      try {
+        process.kill(tempServerPid);
+      } catch {
+      }
+    }
+    if (!verified) {
+      console.error("Verification failed. Fix issues or use --skip-verify to proceed anyway.");
+      process.exit(1);
+    }
+    console.log("Verification passed.");
+  }
+  if (variant.pid) {
+    try {
+      process.kill(variant.pid);
+      console.log(`Killed server (pid ${variant.pid})`);
+    } catch {
+    }
+  }
+  console.log(`Merging branch: ${variant.branch}`);
+  try {
+    await execInherit("git", ["merge", variant.branch], { cwd: projectRoot });
+  } catch (e) {
+    console.error("Merge failed:", e);
+    process.exit(1);
+  }
+  if (existsSync(variant.path)) {
+    try {
+      await exec("git", ["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
+    } catch {
+    }
+  }
+  try {
+    await exec("git", ["branch", "-D", variant.branch], { cwd: projectRoot });
+  } catch {
+  }
+  removeVariant(agentName, variantName);
+  console.log("Reinstalling dependencies...");
+  try {
+    await execInherit("npm", ["install"], { cwd: projectRoot });
+  } catch (e) {
+    console.error("npm install failed:", e);
+  }
+  console.log(`Variant ${variantName} merged and cleaned up.`);
+  const voluteDir = resolve(projectRoot, ".volute");
+  if (!existsSync(voluteDir)) mkdirSync(voluteDir, { recursive: true });
+  writeFileSync(
+    resolve(voluteDir, "merged.json"),
+    JSON.stringify({
+      name: variantName,
+      ...flags.summary && { summary: flags.summary },
+      ...flags.justification && { justification: flags.justification },
+      ...flags.memory && { memory: flags.memory }
+    })
+  );
+  if (process.env.VOLUTE_SUPERVISOR) return;
+  try {
+    const { daemonFetch } = await import("./daemon-client-ZTHW7ROS.js");
+    console.log("Restarting agent via daemon...");
+    const res = await daemonFetch(`/api/agents/${encodeURIComponent(agentName)}/restart`, {
+      method: "POST"
+    });
+    if (res.ok) {
+      console.log(`${agentName} restarted.`);
+    } else {
+      const data = await res.json();
+      console.error(`Failed to restart: ${data.error ?? "unknown error"}`);
+    }
+  } catch {
+    console.log(`Daemon not running. Start the agent manually: volute start ${agentName}`);
+  }
+}
+export {
+  run
+};