volute 0.8.3 → 0.10.0

package/dist/upgrade-CZF6PN7Y.js

@@ -1,224 +0,0 @@
-#!/usr/bin/env node
-import {
-  resolveAgentName
-} from "./chunk-AZEL2IEK.js";
-import {
-  composeTemplate,
-  copyTemplateToDir,
-  findTemplatesRoot
-} from "./chunk-XUA3JUFK.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
-import {
-  exec,
-  execInherit
-} from "./chunk-5C5JWR2L.js";
-import {
-  daemonFetch
-} from "./chunk-23L3MKEV.js";
-import {
-  addVariant,
-  nextPort,
-  resolveAgent
-} from "./chunk-DP2DX4WV.js";
-import "./chunk-K3NQKI34.js";
-
-// src/commands/upgrade.ts
-import { existsSync, mkdirSync, rmSync } from "fs";
-import { resolve } from "path";
-var TEMPLATE_BRANCH = "volute/template";
-var VARIANT_NAME = "upgrade";
-async function run(args) {
-  const { positional, flags } = parseArgs(args, {
-    template: { type: "string" },
-    continue: { type: "boolean" }
-  });
-  const agentName = resolveAgentName({ agent: positional[0] });
-  const { dir: projectRoot } = resolveAgent(agentName);
-  const template = flags.template ?? "agent-sdk";
-  if (flags.continue) {
-    await continueUpgrade(agentName, projectRoot);
-    return;
-  }
-  const worktreeDir = resolve(projectRoot, ".variants", VARIANT_NAME);
-  if (existsSync(worktreeDir)) {
-    console.error(
-      `Upgrade variant already exists: ${worktreeDir}
-If a previous upgrade is in progress, use --continue to finish it.
-Otherwise, remove it with: volute variant delete ${VARIANT_NAME} --agent ${agentName}`
-    );
-    process.exit(1);
-  }
-  await exec("git", ["worktree", "prune"], { cwd: projectRoot });
-  try {
-    await exec("git", ["branch", "-D", VARIANT_NAME], { cwd: projectRoot });
-  } catch {
-  }
-  console.log("Updating template branch...");
-  await updateTemplateBranch(projectRoot, template, agentName);
-  console.log("Creating upgrade variant...");
-  const parentDir = resolve(projectRoot, ".variants");
-  if (!existsSync(parentDir)) {
-    mkdirSync(parentDir, { recursive: true });
-  }
-  await exec("git", ["worktree", "add", "-b", VARIANT_NAME, worktreeDir], {
-    cwd: projectRoot
-  });
-  console.log("Merging template changes...");
-  const hasConflicts = await mergeTemplateBranch(worktreeDir);
-  if (hasConflicts) {
-    console.log("\nMerge conflicts detected. Resolve them in:");
-    console.log(`  ${worktreeDir}`);
-    console.log(`
-Then run:`);
-    console.log(`  volute agent upgrade ${agentName} --continue`);
-    return;
-  }
-  await installAndVerify(agentName, worktreeDir);
-}
-async function updateTemplateBranch(projectRoot, template, agentName) {
-  const tempWorktree = resolve(projectRoot, ".variants", "_template_update");
-  let branchExists = false;
-  try {
-    await exec("git", ["rev-parse", "--verify", TEMPLATE_BRANCH], {
-      cwd: projectRoot
-    });
-    branchExists = true;
-  } catch {
-  }
-  try {
-    await exec("git", ["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
-  } catch {
-  }
-  if (existsSync(tempWorktree)) {
-    rmSync(tempWorktree, { recursive: true, force: true });
-  }
-  const templatesRoot = findTemplatesRoot();
-  const { composedDir, manifest } = composeTemplate(templatesRoot, template);
-  try {
-    if (branchExists) {
-      await exec("git", ["worktree", "add", tempWorktree, TEMPLATE_BRANCH], {
-        cwd: projectRoot
-      });
-    } else {
-      await exec("git", ["worktree", "add", "--detach", tempWorktree], {
-        cwd: projectRoot
-      });
-      await exec("git", ["checkout", "--orphan", TEMPLATE_BRANCH], {
-        cwd: tempWorktree
-      });
-      await exec("git", ["rm", "-rf", "--cached", "."], { cwd: tempWorktree });
-      await exec("git", ["clean", "-fd"], { cwd: tempWorktree });
-    }
-    if (branchExists) {
-      await exec("git", ["rm", "-rf", "."], { cwd: tempWorktree }).catch(() => {
-      });
-    }
-    copyTemplateToDir(composedDir, tempWorktree, agentName, manifest);
-    const initDir = resolve(tempWorktree, ".init");
-    if (existsSync(initDir)) {
-      rmSync(initDir, { recursive: true, force: true });
-    }
-    await exec("git", ["add", "-A"], { cwd: tempWorktree });
-    try {
-      await exec("git", ["diff", "--cached", "--quiet"], { cwd: tempWorktree });
-      console.log("Template branch is already up to date.");
-    } catch {
-      await exec("git", ["commit", "-m", "template update"], {
-        cwd: tempWorktree
-      });
-    }
-  } finally {
-    try {
-      await exec("git", ["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
-    } catch {
-    }
-    if (existsSync(tempWorktree)) {
-      rmSync(tempWorktree, { recursive: true, force: true });
-    }
-    rmSync(composedDir, { recursive: true, force: true });
-  }
-}
-async function mergeTemplateBranch(worktreeDir) {
-  try {
-    await exec(
-      "git",
-      ["merge", TEMPLATE_BRANCH, "--allow-unrelated-histories", "-m", "merge template update"],
-      { cwd: worktreeDir }
-    );
-    return false;
-  } catch (e) {
-    try {
-      const status = await exec("git", ["status", "--porcelain"], {
-        cwd: worktreeDir
-      });
-      const hasConflictMarkers = status.split("\n").some((line) => line.startsWith("UU") || line.startsWith("AA"));
-      if (hasConflictMarkers) return true;
-    } catch {
-    }
-    throw e;
-  }
-}
-async function continueUpgrade(agentName, projectRoot) {
-  const worktreeDir = resolve(projectRoot, ".variants", VARIANT_NAME);
-  if (!existsSync(worktreeDir)) {
-    console.error("No upgrade in progress. Run `volute agent upgrade` first.");
-    process.exit(1);
-  }
-  const status = await exec("git", ["status", "--porcelain"], {
-    cwd: worktreeDir
-  });
-  const hasConflicts = status.split("\n").some((line) => line.startsWith("UU") || line.startsWith("AA"));
-  if (hasConflicts) {
-    console.error("There are still unresolved conflicts. Resolve them first.");
-    process.exit(1);
-  }
-  try {
-    await exec("git", ["add", "-A"], { cwd: worktreeDir });
-    await exec("git", ["commit", "--no-edit"], { cwd: worktreeDir });
-  } catch {
-  }
-  await installAndVerify(agentName, worktreeDir);
-}
-async function installAndVerify(agentName, worktreeDir) {
-  console.log("Installing dependencies...");
-  await execInherit("npm", ["install"], { cwd: worktreeDir });
-  const variantPort = nextPort();
-  addVariant(agentName, {
-    name: VARIANT_NAME,
-    branch: VARIANT_NAME,
-    path: worktreeDir,
-    port: variantPort,
-    created: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  console.log("Starting upgrade variant...");
-  try {
-    const res = await daemonFetch(
-      `/api/agents/${encodeURIComponent(`${agentName}@${VARIANT_NAME}`)}/start`,
-      { method: "POST" }
-    );
-    if (!res.ok) {
-      const data = await res.json();
-      console.error(data.error ?? "Failed to start variant");
-      process.exit(1);
-    }
-  } catch {
-    console.error("Failed to start variant. Is the daemon running? (volute up)");
-    console.error(
-      `The variant was created but not started. Use: volute agent start ${agentName}@${VARIANT_NAME}`
-    );
-    process.exit(1);
-  }
-  console.log(`
-Upgrade variant running on port ${variantPort}`);
-  console.log(`
-Next steps:`);
-  console.log(
-    `  volute send @${agentName}@${VARIANT_NAME} "hello"    # chat with upgraded variant`
-  );
-  console.log(`  volute variant merge ${VARIANT_NAME}                # merge back when satisfied`);
-}
-export {
-  run
-};

package/dist/variant-RKXPN5DH.js

@@ -1,476 +0,0 @@
-#!/usr/bin/env node
-import {
-  resolveAgentName
-} from "./chunk-AZEL2IEK.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
-import {
-  exec,
-  execInherit
-} from "./chunk-5C5JWR2L.js";
-import {
-  daemonFetch
-} from "./chunk-23L3MKEV.js";
-import {
-  addVariant,
-  checkHealth,
-  findVariant,
-  nextPort,
-  readVariants,
-  removeVariant,
-  resolveAgent,
-  validateBranchName,
-  writeVariants
-} from "./chunk-DP2DX4WV.js";
-import "./chunk-K3NQKI34.js";
-
-// src/commands/variant.ts
-import { existsSync, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { resolve as resolve2 } from "path";
-
-// src/lib/spawn-server.ts
-import { spawn } from "child_process";
-import { closeSync, mkdirSync, openSync, readFileSync } from "fs";
-import { resolve } from "path";
-function tsxBin(cwd) {
-  return resolve(cwd, "node_modules", ".bin", "tsx");
-}
-function spawnServer(cwd, port, options) {
-  if (options?.detached) {
-    return spawnDetached(cwd, port, options.logDir);
-  }
-  return spawnAttached(cwd, port);
-}
-function spawnAttached(cwd, port) {
-  const child = spawn(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
-    cwd,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  return new Promise((resolve3) => {
-    const timeout = setTimeout(() => resolve3(null), 3e4);
-    function checkOutput(data) {
-      const match = data.toString().match(/listening on :(\d+)/);
-      if (match) {
-        clearTimeout(timeout);
-        resolve3({ child, actualPort: parseInt(match[1], 10) });
-      }
-    }
-    child.stdout?.on("data", checkOutput);
-    child.stderr?.on("data", checkOutput);
-    child.on("error", () => {
-      clearTimeout(timeout);
-      resolve3(null);
-    });
-    child.on("exit", () => {
-      clearTimeout(timeout);
-      resolve3(null);
-    });
-  });
-}
-function spawnDetached(cwd, port, logDir) {
-  const logsDir = logDir ?? resolve(cwd, ".volute", "logs");
-  mkdirSync(logsDir, { recursive: true });
-  const logPath = resolve(logsDir, "agent.log");
-  const logFd = openSync(logPath, "a");
-  const child = spawn(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
-    cwd,
-    stdio: ["ignore", logFd, logFd],
-    detached: true
-  });
-  child.unref();
-  closeSync(logFd);
-  return new Promise((res) => {
-    let done = false;
-    function finish(result) {
-      if (done) return;
-      done = true;
-      clearInterval(interval);
-      clearTimeout(timeout);
-      res(result);
-    }
-    const interval = setInterval(() => {
-      try {
-        const content = readFileSync(logPath, "utf-8");
-        const match = content.match(/listening on :(\d+)/);
-        if (match) {
-          finish({ child, actualPort: parseInt(match[1], 10) });
-        }
-      } catch {
-      }
-    }, 100);
-    const timeout = setTimeout(() => finish(null), 3e4);
-    child.on("error", () => finish(null));
-    child.on("exit", () => finish(null));
-  });
-}
-
-// 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://127.0.0.1:${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) {
-      console.error("  Test message: failed to send");
-      return false;
-    }
-    const result = await res.json();
-    if (result.ok) {
-      console.log("  Test message: OK");
-      return true;
-    } else {
-      console.error("  Test message: unexpected response");
-      return false;
-    }
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    console.error(`  Test message: ${msg}`);
-    return false;
-  }
-}
-
-// src/commands/variant.ts
-async function run(args) {
-  const subcommand = args[0];
-  switch (subcommand) {
-    case "create":
-      await createVariant(args.slice(1));
-      break;
-    case "list":
-      await listVariants(args.slice(1));
-      break;
-    case "merge":
-      await mergeVariant(args.slice(1));
-      break;
-    case "delete":
-      await deleteVariant(args.slice(1));
-      break;
-    case "--help":
-    case "-h":
-    case void 0:
-      printUsage();
-      break;
-    default:
-      printUsage();
-      process.exit(1);
-  }
-}
-function printUsage() {
-  console.log(`Usage:
-  volute variant create <variant> [--agent <name>] [--soul "..."] [--port N] [--no-start] [--json]
-  volute variant list [--agent <name>] [--json]
-  volute variant merge <variant> [--agent <name>] [--summary "..." --memory "..."] [--skip-verify]
-  volute variant delete <variant> [--agent <name>]`);
-}
-async function createVariant(args) {
-  const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" },
-    soul: { type: "string" },
-    port: { type: "number" },
-    "no-start": { type: "boolean" },
-    json: { type: "boolean" }
-  });
-  const agentName = resolveAgentName(flags);
-  const variantName = positional[0];
-  const { soul, port, json } = flags;
-  const noStart = flags["no-start"];
-  if (!variantName) {
-    console.error(
-      'Usage: volute variant create <variant> [--agent <name>] [--soul "..."] [--port N] [--no-start] [--json]'
-    );
-    process.exit(1);
-  }
-  const err = validateBranchName(variantName);
-  if (err) {
-    console.error(err);
-    process.exit(1);
-  }
-  const { dir: projectRoot } = resolveAgent(agentName);
-  const variantDir = resolve2(projectRoot, ".variants", variantName);
-  if (existsSync(variantDir)) {
-    console.error(`Variant directory already exists: ${variantDir}`);
-    process.exit(1);
-  }
-  mkdirSync2(resolve2(projectRoot, ".variants"), { recursive: true });
-  try {
-    await exec("git", ["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    console.error(`Failed to create worktree: ${msg}`);
-    process.exit(1);
-  }
-  if (!json) console.log("Installing dependencies...");
-  try {
-    if (json) {
-      await exec("npm", ["install"], { cwd: variantDir });
-    } else {
-      await execInherit("npm", ["install"], { cwd: variantDir });
-    }
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    console.error(`npm install failed: ${msg}`);
-    process.exit(1);
-  }
-  if (soul) {
-    writeFileSync(resolve2(variantDir, "home/SOUL.md"), soul);
-  }
-  const variantPort = port ?? nextPort();
-  const variant = {
-    name: variantName,
-    branch: variantName,
-    path: variantDir,
-    port: variantPort,
-    created: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  addVariant(agentName, variant);
-  if (!noStart) {
-    if (!json) console.log("Starting variant via daemon...");
-    try {
-      const res = await daemonFetch(
-        `/api/agents/${encodeURIComponent(`${agentName}@${variantName}`)}/start`,
-        {
-          method: "POST"
-        }
-      );
-      if (!res.ok) {
-        const data = await res.json();
-        console.error(data.error ?? "Failed to start variant");
-        process.exit(1);
-      }
-    } catch {
-      console.error("Failed to start variant. Is the daemon running? (volute up)");
-      console.error(
-        `The variant was created but not started. Use: volute agent start ${agentName}@${variantName}`
-      );
-      process.exit(1);
-    }
-  }
-  if (json) {
-    console.log(JSON.stringify(variant, null, 2));
-  } else {
-    console.log(`
-Variant created: ${variantName}`);
-    console.log(`  Branch: ${variant.branch}`);
-    console.log(`  Path:   ${variant.path}`);
-    console.log(`  Port:   ${variantPort}`);
-  }
-}
-async function listVariants(args) {
-  const { flags } = parseArgs(args, {
-    agent: { type: "string" },
-    json: { type: "boolean" }
-  });
-  const agentName = resolveAgentName(flags);
-  const { json } = flags;
-  resolveAgent(agentName);
-  const variants = readVariants(agentName);
-  if (variants.length === 0) {
-    if (json) {
-      console.log("[]");
-    } else {
-      console.log("No variants.");
-    }
-    return;
-  }
-  const results = await Promise.all(
-    variants.map(async (v) => {
-      if (!v.port) return { ...v, status: "no-server" };
-      const health = await checkHealth(v.port);
-      return { ...v, status: health.ok ? "running" : "dead" };
-    })
-  );
-  const updated = results.map(({ status, ...v }) => ({
-    ...v,
-    running: status === "running"
-  }));
-  writeVariants(agentName, updated);
-  if (json) {
-    console.log(JSON.stringify(results, null, 2));
-    return;
-  }
-  const nameW = Math.max(4, ...results.map((r) => r.name.length));
-  const portW = Math.max(4, ...results.map((r) => String(r.port || "-").length));
-  console.log(`${"NAME".padEnd(nameW)}  ${"PORT".padEnd(portW)}  ${"STATUS".padEnd(10)}  BRANCH`);
-  for (const r of results) {
-    console.log(
-      `${r.name.padEnd(nameW)}  ${String(r.port || "-").padEnd(portW)}  ${r.status.padEnd(10)}  ${r.branch}`
-    );
-  }
-}
-async function mergeVariant(args) {
-  const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" },
-    summary: { type: "string" },
-    justification: { type: "string" },
-    memory: { type: "string" },
-    "skip-verify": { type: "boolean" }
-  });
-  const agentName = resolveAgentName(flags);
-  const variantName = positional[0];
-  if (!variantName) {
-    console.error(
-      "Usage: volute variant merge <variant> [--agent <name>] [--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...");
-      try {
-        await exec("git", ["add", "-A"], { cwd: variant.path });
-        await exec("git", ["commit", "-m", "Auto-commit uncommitted changes before merge"], {
-          cwd: variant.path
-        });
-      } catch (err) {
-        console.error("Failed to auto-commit variant changes:", err);
-        console.error("Please commit or stash changes in the variant manually before merging.");
-        process.exit(1);
-      }
-    }
-  }
-  if (!flags["skip-verify"]) {
-    console.log("Verifying variant...");
-    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);
-    }
-    const verified = await verify(result.actualPort);
-    try {
-      process.kill(result.child.pid);
-    } catch {
-    }
-    if (!verified) {
-      console.error("Verification failed. Fix issues or use --skip-verify to proceed anyway.");
-      process.exit(1);
-    }
-    console.log("Verification passed.");
-  }
-  const mainStatus = (await exec("git", ["status", "--porcelain"], { cwd: projectRoot })).trim();
-  if (mainStatus) {
-    console.log("Committing uncommitted changes in main...");
-    try {
-      await exec("git", ["add", "-A"], { cwd: projectRoot });
-      await exec("git", ["commit", "-m", "Auto-commit uncommitted changes before merge"], {
-        cwd: projectRoot
-      });
-    } catch (err) {
-      console.error("Failed to auto-commit main changes:", err);
-      console.error("Please commit or stash your changes manually before merging.");
-      process.exit(1);
-    }
-  }
-  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.`);
-  if (process.env.VOLUTE_SUPERVISOR) return;
-  const context = {
-    type: "merged",
-    name: variantName,
-    ...flags.summary && { summary: flags.summary },
-    ...flags.justification && { justification: flags.justification },
-    ...flags.memory && { memory: flags.memory }
-  };
-  try {
-    console.log("Restarting agent via daemon...");
-    const res = await daemonFetch(`/api/agents/${encodeURIComponent(agentName)}/restart`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ context })
-    });
-    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 agent start ${agentName}`);
-  }
-}
-async function deleteVariant(args) {
-  const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" }
-  });
-  const agentName = resolveAgentName(flags);
-  const variantName = positional[0];
-  if (!variantName) {
-    console.error("Usage: volute variant delete <variant> [--agent <name>]");
-    process.exit(1);
-  }
-  const { dir: projectRoot } = resolveAgent(agentName);
-  const variant = findVariant(agentName, variantName);
-  if (!variant) {
-    console.error(`Unknown variant: ${variantName}`);
-    process.exit(1);
-  }
-  try {
-    await daemonFetch(`/api/agents/${encodeURIComponent(`${agentName}@${variantName}`)}/stop`, {
-      method: "POST"
-    });
-  } catch {
-  }
-  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(`Variant ${variantName} deleted.`);
-}
-export {
-  run
-};