volute 0.2.0 → 0.3.0

package/dist/{merge-CSAVLSLY.js → variant-JPLJTS2P.js}

@@ -5,19 +5,30 @@ import {
 import {
   exec,
   execInherit
-} from "./chunk-XZN4WPNC.js";
+} from "./chunk-5SKQ6J7T.js";
+import {
+  daemonFetch
+} from "./chunk-VVD3XO3E.js";
+import {
+  resolveAgentName
+} from "./chunk-VRVVQIYY.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
+  addVariant,
   checkHealth,
   findVariant,
+  nextPort,
+  readVariants,
   removeVariant,
   resolveAgent,
-  validateBranchName
-} from "./chunk-6UCG6MIX.js";
+  validateBranchName,
+  writeVariants
+} from "./chunk-RALYNMHR.js";
+import "./chunk-K3NQKI34.js";
 
-// src/commands/merge.ts
+// src/commands/variant.ts
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { resolve } from "path";
 
@@ -82,19 +93,178 @@ async function verify(port) {
   }
 }
 
-// src/commands/merge.ts
+// 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;
+    default:
+      printUsage();
+      process.exit(subcommand ? 1 : 0);
+  }
+}
+function printUsage() {
+  console.error(`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]`);
+}
+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 = resolve(projectRoot, ".variants", variantName);
+  if (existsSync(variantDir)) {
+    console.error(`Variant directory already exists: ${variantDir}`);
+    process.exit(1);
+  }
+  mkdirSync(resolve(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(resolve(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 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 = positional[0];
-  const variantName = positional[1];
-  if (!agentName || !variantName) {
+  const agentName = resolveAgentName(flags);
+  const variantName = positional[0];
+  if (!variantName) {
     console.error(
-      "Usage: volute merge <agent> <variant> [--summary '...'] [--justification '...'] [--memory '...'] [--skip-verify]"
+      "Usage: volute variant merge <variant> [--agent <name>] [--summary '...'] [--justification '...'] [--memory '...'] [--skip-verify]"
     );
     process.exit(1);
   }
@@ -196,7 +366,6 @@ async function run(args) {
   );
   if (process.env.VOLUTE_SUPERVISOR) return;
   try {
-    const { daemonFetch } = await import("./daemon-client-VN24HM5T.js");
     console.log("Restarting agent via daemon...");
     const res = await daemonFetch(`/api/agents/${encodeURIComponent(agentName)}/restart`, {
       method: "POST"