volute 0.8.3 → 0.10.0

package/dist/upgrade-RSE4CZNE.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/upgrade.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    template: { type: "string" },
+    continue: { type: "boolean" }
+  });
+  const agentName = resolveAgentName({ agent: positional[0] });
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(client.api.agents[":name"].upgrade.$url({ param: { name: agentName } })),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        template: flags.template,
+        continue: flags.continue
+      })
+    }
+  );
+  const data = await res.json();
+  if (!res.ok && !data.conflicts) {
+    console.error(data.error ?? "Failed to upgrade agent");
+    process.exit(1);
+  }
+  if (data.conflicts) {
+    console.log("\nMerge conflicts detected. Resolve them in:");
+    console.log(`  ${data.worktreeDir}`);
+    console.log(`
+Then run:`);
+    console.log(`  volute agent upgrade ${agentName} --continue`);
+    return;
+  }
+  console.log(`
+Upgrade variant running on port ${data.port}`);
+  console.log(`
+Next steps:`);
+  console.log(
+    `  volute send @${agentName}@${data.variant} "hello"    # chat with upgraded variant`
+  );
+  console.log(`  volute variant merge ${data.variant}                # merge back when satisfied`);
+}
+export {
+  run
+};

package/dist/variant-7IZF6OWO.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  checkHealth,
+  readVariants,
+  resolveAgent,
+  writeVariants
+} from "./chunk-DP2DX4WV.js";
+import "./chunk-K3NQKI34.js";
+
+// 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);
+  }
+  if (!json) console.log("Creating variant via daemon...");
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(client.api.agents[":name"].variants.$url({ param: { name: agentName } })),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        name: variantName,
+        ...soul && { soul },
+        ...port && { port },
+        ...noStart && { noStart }
+      })
+    }
+  );
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to create variant");
+    process.exit(1);
+  }
+  if (json) {
+    console.log(JSON.stringify(data.variant, null, 2));
+  } else {
+    console.log(`
+Variant created: ${variantName}`);
+    console.log(`  Branch: ${data.variant?.branch}`);
+    console.log(`  Path:   ${data.variant?.path}`);
+    console.log(`  Port:   ${data.variant?.port}`);
+  }
+}
+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);
+  }
+  console.log(`Merging variant ${variantName}...`);
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(
+      client.api.agents[":name"].variants[":variant"].merge.$url({
+        param: { name: agentName, variant: variantName }
+      })
+    ),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...flags.summary && { summary: flags.summary },
+        ...flags.justification && { justification: flags.justification },
+        ...flags.memory && { memory: flags.memory },
+        ...flags["skip-verify"] && { skipVerify: true }
+      })
+    }
+  );
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to merge variant");
+    process.exit(1);
+  }
+  console.log(`Variant ${variantName} merged and cleaned up.`);
+}
+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 { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(
+      client.api.agents[":name"].variants[":variant"].$url({
+        param: { name: agentName, variant: variantName }
+      })
+    ),
+    { method: "DELETE" }
+  );
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to delete variant");
+    process.exit(1);
+  }
+  console.log(`Variant ${variantName} deleted.`);
+}
+export {
+  run
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volute",
-  "version": "0.8.3",
+  "version": "0.10.0",
   "description": "CLI for creating and managing self-modifying AI agents powered by the Claude Agent SDK",
   "type": "module",
   "license": "MIT",

package/dist/chunk-ECPQXRLB.js

@@ -1,264 +0,0 @@
-#!/usr/bin/env node
-import {
-  voluteHome
-} from "./chunk-DP2DX4WV.js";
-import {
-  __export
-} from "./chunk-K3NQKI34.js";
-
-// src/lib/auth.ts
-import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq } from "drizzle-orm";
-
-// src/lib/db.ts
-import { chmodSync, existsSync } from "fs";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-import { drizzle } from "drizzle-orm/libsql";
-import { migrate } from "drizzle-orm/libsql/migrator";
-
-// src/lib/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  agentMessages: () => agentMessages,
-  conversationParticipants: () => conversationParticipants,
-  conversations: () => conversations,
-  messages: () => messages,
-  sessions: () => sessions,
-  users: () => users
-});
-import { sql } from "drizzle-orm";
-import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
-var users = sqliteTable("users", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  username: text("username").unique().notNull(),
-  password_hash: text("password_hash").notNull(),
-  role: text("role").notNull().default("pending"),
-  user_type: text("user_type").notNull().default("human"),
-  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-});
-var conversations = sqliteTable(
-  "conversations",
-  {
-    id: text("id").primaryKey(),
-    agent_name: text("agent_name").notNull(),
-    channel: text("channel").notNull(),
-    user_id: integer("user_id").references(() => users.id),
-    title: text("title"),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
-    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_conversations_agent_name").on(table.agent_name),
-    index("idx_conversations_user_id").on(table.user_id),
-    index("idx_conversations_updated_at").on(table.updated_at)
-  ]
-);
-var agentMessages = sqliteTable(
-  "agent_messages",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    agent: text("agent").notNull(),
-    channel: text("channel").notNull(),
-    sender: text("sender"),
-    content: text("content").notNull(),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_agent_messages_agent").on(table.agent),
-    index("idx_agent_messages_channel").on(table.agent, table.channel)
-  ]
-);
-var conversationParticipants = sqliteTable(
-  "conversation_participants",
-  {
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    role: text("role").notNull().default("member"),
-    joined_at: text("joined_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    uniqueIndex("idx_cp_unique").on(table.conversation_id, table.user_id),
-    index("idx_cp_user_id").on(table.user_id)
-  ]
-);
-var sessions = sqliteTable("sessions", {
-  id: text("id").primaryKey(),
-  userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
-  createdAt: integer("created_at").notNull()
-});
-var messages = sqliteTable(
-  "messages",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    role: text("role").notNull(),
-    sender_name: text("sender_name"),
-    content: text("content").notNull(),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [index("idx_messages_conversation_id").on(table.conversation_id)]
-);
-
-// src/lib/db.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync(resolve(__dirname, "../drizzle")) ? resolve(__dirname, "../drizzle") : resolve(__dirname, "../../drizzle");
-var db = null;
-async function getDb() {
-  if (db) return db;
-  const dbPath = process.env.VOLUTE_DB_PATH || resolve(voluteHome(), "volute.db");
-  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
-  await migrate(db, { migrationsFolder });
-  try {
-    chmodSync(dbPath, 384);
-  } catch (err) {
-    console.error(
-      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
-      err
-    );
-  }
-  return db;
-}
-
-// src/lib/auth.ts
-async function createUser(username, password) {
-  const db2 = await getDb();
-  const hash = hashSync(password, 10);
-  const [{ value }] = await db2.select({ value: count() }).from(users).where(eq(users.user_type, "human"));
-  const role = value === 0 ? "admin" : "pending";
-  const [result] = await db2.insert(users).values({ username, password_hash: hash, role }).returning({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  });
-  return result;
-}
-async function verifyUser(username, password) {
-  const db2 = await getDb();
-  const row = await db2.select().from(users).where(eq(users.username, username)).get();
-  if (!row) return null;
-  if (row.user_type === "agent") return null;
-  if (!compareSync(password, row.password_hash)) return null;
-  const { password_hash: _, ...user } = row;
-  return user;
-}
-async function getUser(id) {
-  const db2 = await getDb();
-  const row = await db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.id, id)).get();
-  return row ?? null;
-}
-async function getUserByUsername(username) {
-  const db2 = await getDb();
-  const row = await db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.username, username)).get();
-  return row ?? null;
-}
-async function listUsers() {
-  const db2 = await getDb();
-  return db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).orderBy(users.created_at).all();
-}
-async function listPendingUsers() {
-  const db2 = await getDb();
-  return db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
-}
-async function listUsersByType(userType) {
-  const db2 = await getDb();
-  return db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
-}
-async function getOrCreateAgentUser(agentName) {
-  const db2 = await getDb();
-  const existing = await db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
-  if (existing) return existing;
-  try {
-    const [result] = await db2.insert(users).values({
-      username: agentName,
-      password_hash: "!agent",
-      role: "agent",
-      user_type: "agent"
-    }).returning({
-      id: users.id,
-      username: users.username,
-      role: users.role,
-      user_type: users.user_type,
-      created_at: users.created_at
-    });
-    return result;
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-      const retried = await db2.select({
-        id: users.id,
-        username: users.username,
-        role: users.role,
-        user_type: users.user_type,
-        created_at: users.created_at
-      }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
-      if (retried) return retried;
-    }
-    throw err;
-  }
-}
-async function deleteAgentUser(agentName) {
-  const db2 = await getDb();
-  await db2.delete(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent")));
-}
-async function approveUser(id) {
-  const db2 = await getDb();
-  await db2.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
-}
-
-export {
-  users,
-  conversations,
-  agentMessages,
-  conversationParticipants,
-  sessions,
-  messages,
-  getDb,
-  createUser,
-  verifyUser,
-  getUser,
-  getUserByUsername,
-  listUsers,
-  listPendingUsers,
-  listUsersByType,
-  getOrCreateAgentUser,
-  deleteAgentUser,
-  approveUser
-};

package/dist/chunk-NETNFBA5.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/volute-config.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, resolve } from "path";
-function readJson(path) {
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function readVoluteConfig(agentDir) {
-  const path = resolve(agentDir, "home/.config/volute.json");
-  return readJson(path);
-}
-function writeVoluteConfig(agentDir, config) {
-  const path = resolve(agentDir, "home/.config/volute.json");
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(config, null, 2)}
-`);
-}
-
-export {
-  readVoluteConfig,
-  writeVoluteConfig
-};

package/dist/chunk-XUA3JUFK.js

@@ -1,121 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/template.ts
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync
-} from "fs";
-import { tmpdir } from "os";
-import { dirname, join, relative, resolve } from "path";
-function findTemplatesRoot() {
-  let dir = dirname(new URL(import.meta.url).pathname);
-  for (let i = 0; i < 5; i++) {
-    const candidate = resolve(dir, "templates");
-    if (existsSync(resolve(candidate, "_base"))) return candidate;
-    dir = dirname(dir);
-  }
-  console.error(
-    "Templates directory not found. Searched up from:",
-    dirname(new URL(import.meta.url).pathname)
-  );
-  process.exit(1);
-}
-function composeTemplate(templatesRoot, templateName) {
-  const baseDir = resolve(templatesRoot, "_base");
-  const templateDir = resolve(templatesRoot, templateName);
-  if (!existsSync(baseDir)) {
-    console.error("Base template not found:", baseDir);
-    process.exit(1);
-  }
-  if (!existsSync(templateDir)) {
-    console.error(`Template not found: ${templateName}`);
-    process.exit(1);
-  }
-  const composedDir = resolve(tmpdir(), `volute-template-${Date.now()}`);
-  mkdirSync(composedDir, { recursive: true });
-  cpSync(baseDir, composedDir, { recursive: true });
-  for (const file of listFiles(templateDir)) {
-    const src = resolve(templateDir, file);
-    const dest = resolve(composedDir, file);
-    mkdirSync(dirname(dest), { recursive: true });
-    cpSync(src, dest);
-  }
-  const manifestPath = resolve(composedDir, "volute-template.json");
-  if (!existsSync(manifestPath)) {
-    rmSync(composedDir, { recursive: true, force: true });
-    console.error(`Template manifest not found: ${templateName}/volute-template.json`);
-    process.exit(1);
-  }
-  const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-  const skillsSrc = resolve(composedDir, "_skills");
-  if (existsSync(skillsSrc)) {
-    const skillsDest = resolve(composedDir, manifest.skillsDir);
-    mkdirSync(skillsDest, { recursive: true });
-    cpSync(skillsSrc, skillsDest, { recursive: true });
-    rmSync(skillsSrc, { recursive: true, force: true });
-  }
-  rmSync(manifestPath);
-  return { composedDir, manifest };
-}
-function copyTemplateToDir(composedDir, destDir, agentName, manifest) {
-  cpSync(composedDir, destDir, { recursive: true });
-  for (const [from, to] of Object.entries(manifest.rename)) {
-    const fromPath = resolve(destDir, from);
-    if (existsSync(fromPath)) {
-      renameSync(fromPath, resolve(destDir, to));
-    }
-  }
-  for (const file of manifest.substitute) {
-    const path = resolve(destDir, file);
-    if (existsSync(path)) {
-      const content = readFileSync(path, "utf-8");
-      writeFileSync(path, content.replaceAll("{{name}}", agentName));
-    }
-  }
-}
-function applyInitFiles(destDir) {
-  const initDir = resolve(destDir, ".init");
-  if (!existsSync(initDir)) return;
-  const homeDir = resolve(destDir, "home");
-  for (const file of listFiles(initDir)) {
-    const src = resolve(initDir, file);
-    const dest = resolve(homeDir, file);
-    const parent = dirname(dest);
-    if (!existsSync(parent)) {
-      mkdirSync(parent, { recursive: true });
-    }
-    cpSync(src, dest);
-  }
-  rmSync(initDir, { recursive: true, force: true });
-}
-function listFiles(dir) {
-  const results = [];
-  function walk(current) {
-    for (const entry of readdirSync(current)) {
-      const full = join(current, entry);
-      if (statSync(full).isDirectory()) {
-        if (entry === ".git") continue;
-        walk(full);
-      } else {
-        results.push(relative(dir, full));
-      }
-    }
-  }
-  walk(dir);
-  return results;
-}
-
-export {
-  findTemplatesRoot,
-  composeTemplate,
-  copyTemplateToDir,
-  applyInitFiles,
-  listFiles
-};