volute 0.18.0 → 0.20.0

package/dist/chunk-GZ7DW4YL.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import {
+  publish
+} from "./chunk-UU7A7KLB.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+
+// src/lib/mind-activity-tracker.ts
+var IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
+var minds = /* @__PURE__ */ new Map();
+function getState(mind) {
+  let state = minds.get(mind);
+  if (!state) {
+    state = { active: false, idleTimer: null };
+    minds.set(mind, state);
+  }
+  return state;
+}
+var IGNORED_EVENTS = /* @__PURE__ */ new Set(["done", "usage", "log"]);
+function onMindEvent(mind, type, channel) {
+  const state = getState(mind);
+  if (type === "done") {
+    state.active = false;
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+    }
+    state.idleTimer = setTimeout(() => {
+      state.idleTimer = null;
+      if (!state.active) {
+        publish({
+          type: "mind_idle",
+          mind,
+          summary: `${mind} is idle`
+        }).catch((err) => {
+          logger_default.error("[mind-activity] failed to publish mind_idle", logger_default.errorData(err));
+        });
+      }
+    }, IDLE_TIMEOUT_MS);
+  } else if (!IGNORED_EVENTS.has(type)) {
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+      state.idleTimer = null;
+    }
+    if (!state.active) {
+      state.active = true;
+      state.channel = channel;
+      publish({
+        type: "mind_active",
+        mind,
+        summary: `${mind} is active`,
+        metadata: channel ? { channel } : void 0
+      }).catch((err) => {
+        logger_default.error("[mind-activity] failed to publish mind_active", logger_default.errorData(err));
+      });
+    }
+  }
+}
+function markIdle(mind) {
+  const state = minds.get(mind);
+  if (!state) return;
+  if (state.idleTimer) {
+    clearTimeout(state.idleTimer);
+    state.idleTimer = null;
+  }
+  if (state.active) {
+    state.active = false;
+    publish({
+      type: "mind_idle",
+      mind,
+      summary: `${mind} is idle`
+    }).catch((err) => {
+      logger_default.error("[mind-activity] failed to publish mind_idle", logger_default.errorData(err));
+    });
+  }
+  minds.delete(mind);
+}
+function getActiveMinds() {
+  const result = [];
+  for (const [mind, state] of minds) {
+    if (state.active) result.push(mind);
+  }
+  return result;
+}
+function stopAll() {
+  for (const [, state] of minds) {
+    if (state.idleTimer) clearTimeout(state.idleTimer);
+  }
+  minds.clear();
+}
+
+export {
+  onMindEvent,
+  markIdle,
+  getActiveMinds,
+  stopAll
+};

package/dist/chunk-IKMY5X76.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  getDb
+} from "./chunk-5XNT2472.js";
+import {
+  sharedSkills
+} from "./chunk-NSE7VJQA.js";
+import {
+  exec,
+  gitExec
+} from "./chunk-DYZGP3EW.js";
+import {
+  voluteHome
+} from "./chunk-EBGCNDMM.js";
+
+// src/lib/skills.ts
+import { createHash } from "crypto";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, join, resolve } from "path";
+import { eq, sql } from "drizzle-orm";
+var VALID_SKILL_ID = /^[a-zA-Z0-9_-]+$/;
+var SEED_SKILLS = ["orientation", "memory"];
+var STANDARD_SKILLS = ["volute-mind", "memory", "sessions"];
+function validateSkillId(id) {
+  if (!id || !VALID_SKILL_ID.test(id)) {
+    throw new Error(`Invalid skill ID: ${id}`);
+  }
+}
+function sharedSkillsDir() {
+  return resolve(voluteHome(), "skills");
+}
+function parseSkillMd(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { name: "", description: "" };
+  const frontmatter = match[1];
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+  return {
+    name: nameMatch?.[1].trim() ?? "",
+    description: descMatch?.[1].trim() ?? ""
+  };
+}
+async function listSharedSkills() {
+  const db = await getDb();
+  return db.select().from(sharedSkills).all();
+}
+async function getSharedSkill(id) {
+  const db = await getDb();
+  return db.select().from(sharedSkills).where(eq(sharedSkills.id, id)).get();
+}
+async function importSkillFromDir(sourceDir, author) {
+  const skillMdPath = join(sourceDir, "SKILL.md");
+  if (!existsSync(skillMdPath)) {
+    throw new Error("SKILL.md not found in source directory");
+  }
+  const content = readFileSync(skillMdPath, "utf-8");
+  const { name, description } = parseSkillMd(content);
+  const id = basename(sourceDir);
+  if (!id || id === "." || id === "..") {
+    throw new Error("Invalid skill directory name");
+  }
+  validateSkillId(id);
+  const destDir = join(sharedSkillsDir(), id);
+  if (existsSync(destDir)) rmSync(destDir, { recursive: true });
+  mkdirSync(destDir, { recursive: true });
+  cpSync(sourceDir, destDir, { recursive: true });
+  const upstreamPath = join(destDir, ".upstream.json");
+  if (existsSync(upstreamPath)) rmSync(upstreamPath);
+  const db = await getDb();
+  const existing = await db.select().from(sharedSkills).where(eq(sharedSkills.id, id)).get();
+  const version = existing ? existing.version + 1 : 1;
+  await db.insert(sharedSkills).values({ id, name: name || id, description, author, version }).onConflictDoUpdate({
+    target: sharedSkills.id,
+    set: {
+      name: name || id,
+      description,
+      author,
+      version,
+      updated_at: sql`(datetime('now'))`
+    }
+  });
+  const row = await db.select().from(sharedSkills).where(eq(sharedSkills.id, id)).get();
+  if (!row) throw new Error(`Failed to upsert shared skill: ${id}`);
+  return row;
+}
+async function removeSharedSkill(id) {
+  const db = await getDb();
+  const existing = await db.select().from(sharedSkills).where(eq(sharedSkills.id, id)).get();
+  if (!existing) throw new Error(`Shared skill not found: ${id}`);
+  await db.delete(sharedSkills).where(eq(sharedSkills.id, id));
+  const dir = join(sharedSkillsDir(), id);
+  if (existsSync(dir)) rmSync(dir, { recursive: true });
+}
+function mindSkillsDir(dir) {
+  return resolve(dir, "home", ".claude", "skills");
+}
+function readUpstream(skillDir) {
+  const upstreamPath = join(skillDir, ".upstream.json");
+  if (!existsSync(upstreamPath)) return null;
+  try {
+    const data = JSON.parse(readFileSync(upstreamPath, "utf-8"));
+    if (typeof data?.source !== "string" || typeof data?.version !== "number" || typeof data?.baseCommit !== "string") {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function installSkill(_mindName, dir, skillId) {
+  validateSkillId(skillId);
+  const shared = await getSharedSkill(skillId);
+  if (!shared) throw new Error(`Shared skill not found: ${skillId}`);
+  const sourceDir = join(sharedSkillsDir(), skillId);
+  if (!existsSync(sourceDir)) throw new Error(`Shared skill files not found: ${skillId}`);
+  const destDir = join(mindSkillsDir(dir), skillId);
+  if (existsSync(destDir)) throw new Error(`Skill already installed: ${skillId}`);
+  mkdirSync(destDir, { recursive: true });
+  cpSync(sourceDir, destDir, { recursive: true });
+  await gitExec(["add", join("home", ".claude", "skills", skillId)], { cwd: dir });
+  await gitExec(["commit", "-m", `Install shared skill: ${skillId}`], { cwd: dir });
+  const commitHash = (await gitExec(["rev-parse", "HEAD"], { cwd: dir })).trim();
+  const upstream = {
+    source: skillId,
+    version: shared.version,
+    baseCommit: commitHash
+  };
+  writeFileSync(join(destDir, ".upstream.json"), `${JSON.stringify(upstream, null, 2)}
+`);
+  await gitExec(["add", join("home", ".claude", "skills", skillId, ".upstream.json")], {
+    cwd: dir
+  });
+  await gitExec(["commit", "--amend", "--no-edit"], { cwd: dir });
+}
+async function uninstallSkill(_mindName, dir, skillId) {
+  validateSkillId(skillId);
+  const skillDir = join(mindSkillsDir(dir), skillId);
+  if (!existsSync(skillDir)) throw new Error(`Skill not installed: ${skillId}`);
+  rmSync(skillDir, { recursive: true });
+  await gitExec(["add", join("home", ".claude", "skills", skillId)], { cwd: dir });
+  await gitExec(["commit", "-m", `Uninstall skill: ${skillId}`], { cwd: dir });
+}
+async function updateSkill(_mindName, dir, skillId) {
+  validateSkillId(skillId);
+  const skillDir = join(mindSkillsDir(dir), skillId);
+  if (!existsSync(skillDir)) throw new Error(`Skill not installed: ${skillId}`);
+  const upstream = readUpstream(skillDir);
+  if (!upstream) throw new Error(`No upstream tracking for skill: ${skillId}`);
+  const shared = await getSharedSkill(upstream.source);
+  if (!shared) throw new Error(`Shared skill no longer exists: ${upstream.source}`);
+  if (shared.version <= upstream.version) {
+    return { status: "up-to-date" };
+  }
+  const sourceDir = join(sharedSkillsDir(), upstream.source);
+  if (!existsSync(sourceDir)) throw new Error(`Shared skill files missing: ${upstream.source}`);
+  const relSkillPath = join("home", ".claude", "skills", skillId);
+  const currentFiles = listFilesRecursive(skillDir).filter((f) => f !== ".upstream.json");
+  const newFiles = listFilesRecursive(sourceDir).filter((f) => f !== ".upstream.json");
+  const allFiles = [.../* @__PURE__ */ new Set([...currentFiles, ...newFiles])];
+  const conflictFiles = [];
+  const tmpBase = join(tmpdir(), `volute-merge-${process.pid}-${Date.now()}`);
+  mkdirSync(tmpBase, { recursive: true });
+  try {
+    for (const file of allFiles) {
+      const currentPath = join(skillDir, file);
+      const newPath = join(sourceDir, file);
+      const currentExists = existsSync(currentPath);
+      const newExists = existsSync(newPath);
+      if (!currentExists && newExists) {
+        const destPath = join(skillDir, file);
+        mkdirSync(join(skillDir, ...file.split("/").slice(0, -1)), { recursive: true });
+        cpSync(newPath, destPath);
+        continue;
+      }
+      if (currentExists && !newExists) {
+        let baseContent2 = null;
+        try {
+          baseContent2 = await gitExec(
+            ["show", `${upstream.baseCommit}:${join(relSkillPath, file)}`],
+            { cwd: dir }
+          );
+        } catch {
+          continue;
+        }
+        const currentContent2 = readFileSync(currentPath, "utf-8");
+        if (currentContent2 === baseContent2) {
+          rmSync(currentPath);
+        }
+        continue;
+      }
+      let baseContent;
+      try {
+        baseContent = await gitExec(
+          ["show", `${upstream.baseCommit}:${join(relSkillPath, file)}`],
+          { cwd: dir }
+        );
+      } catch {
+        baseContent = "";
+      }
+      const currentContent = readFileSync(currentPath, "utf-8");
+      const newContent = readFileSync(newPath, "utf-8");
+      if (currentContent === baseContent) {
+        writeFileSync(currentPath, newContent);
+        continue;
+      }
+      if (newContent === baseContent) {
+        continue;
+      }
+      const baseTmp = join(tmpBase, `${file}.base`);
+      const currentTmp = join(tmpBase, `${file}.current`);
+      const newTmp = join(tmpBase, `${file}.new`);
+      mkdirSync(join(tmpBase, ...file.split("/").slice(0, -1)), { recursive: true });
+      writeFileSync(baseTmp, baseContent);
+      writeFileSync(currentTmp, currentContent);
+      writeFileSync(newTmp, newContent);
+      try {
+        await exec("git", ["merge-file", currentTmp, baseTmp, newTmp]);
+        writeFileSync(currentPath, readFileSync(currentTmp, "utf-8"));
+      } catch (e) {
+        const exitCode = e && typeof e === "object" && "code" in e ? e.code : null;
+        if (exitCode === 1) {
+          writeFileSync(currentPath, readFileSync(currentTmp, "utf-8"));
+          conflictFiles.push(file);
+        } else {
+          throw e;
+        }
+      }
+    }
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
+  if (conflictFiles.length > 0) {
+    return { status: "conflict", conflictFiles };
+  }
+  const upstreamInfo = {
+    source: upstream.source,
+    version: shared.version,
+    baseCommit: upstream.baseCommit
+    // will update after commit
+  };
+  writeFileSync(join(skillDir, ".upstream.json"), `${JSON.stringify(upstreamInfo, null, 2)}
+`);
+  await gitExec(["add", relSkillPath], { cwd: dir });
+  await gitExec(["commit", "-m", `Update skill: ${skillId} (v${shared.version})`], { cwd: dir });
+  const commitHash = (await gitExec(["rev-parse", "HEAD"], { cwd: dir })).trim();
+  upstreamInfo.baseCommit = commitHash;
+  writeFileSync(join(skillDir, ".upstream.json"), `${JSON.stringify(upstreamInfo, null, 2)}
+`);
+  await gitExec(["add", join(relSkillPath, ".upstream.json")], { cwd: dir });
+  await gitExec(["commit", "--amend", "--no-edit"], { cwd: dir });
+  return { status: "updated" };
+}
+async function listMindSkills(dir) {
+  const skillsDir = mindSkillsDir(dir);
+  if (!existsSync(skillsDir)) return [];
+  const entries = readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+  const sharedMap = /* @__PURE__ */ new Map();
+  for (const s of await listSharedSkills()) {
+    sharedMap.set(s.id, s);
+  }
+  const results = [];
+  for (const entry of entries) {
+    const skillDir = join(skillsDir, entry.name);
+    const skillMdPath = join(skillDir, "SKILL.md");
+    let name = entry.name;
+    let description = "";
+    if (existsSync(skillMdPath)) {
+      const parsed = parseSkillMd(readFileSync(skillMdPath, "utf-8"));
+      if (parsed.name) name = parsed.name;
+      description = parsed.description;
+    }
+    const upstream = readUpstream(skillDir);
+    let updateAvailable = false;
+    if (upstream) {
+      const shared = sharedMap.get(upstream.source);
+      if (shared && shared.version > upstream.version) {
+        updateAvailable = true;
+      }
+    }
+    results.push({ id: entry.name, name, description, upstream, updateAvailable });
+  }
+  return results;
+}
+async function publishSkill(mindName, dir, skillId) {
+  const skillDir = join(mindSkillsDir(dir), skillId);
+  if (!existsSync(skillDir)) throw new Error(`Skill not found: ${skillId}`);
+  const skillMdPath = join(skillDir, "SKILL.md");
+  if (!existsSync(skillMdPath)) throw new Error(`SKILL.md not found in ${skillId}`);
+  return importSkillFromDir(skillDir, mindName);
+}
+function listFilesRecursive(dir, prefix = "") {
+  const results = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...listFilesRecursive(join(dir, entry.name), rel));
+    } else {
+      results.push(rel);
+    }
+  }
+  return results;
+}
+function findSkillsRoot() {
+  let dir = dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve(dir, "skills");
+    if (existsSync(candidate) && readdirSync(candidate).length > 0) return candidate;
+    dir = dirname(dir);
+  }
+  throw new Error("Skills directory not found");
+}
+function hashSkillDir(dir) {
+  const hash = createHash("sha256");
+  const files = listFilesRecursive(dir).sort();
+  for (const file of files) {
+    hash.update(file);
+    hash.update(readFileSync(join(dir, file)));
+  }
+  return hash.digest("hex");
+}
+async function syncBuiltinSkills() {
+  let skillsRoot;
+  try {
+    skillsRoot = findSkillsRoot();
+  } catch {
+    logger_default.warn("built-in skills directory not found, skipping sync");
+    return;
+  }
+  const entries = readdirSync(skillsRoot, { withFileTypes: true }).filter((e) => e.isDirectory());
+  for (const entry of entries) {
+    const sourceDir = join(skillsRoot, entry.name);
+    if (!existsSync(join(sourceDir, "SKILL.md"))) continue;
+    try {
+      const sourceHash = hashSkillDir(sourceDir);
+      const destDir = join(sharedSkillsDir(), entry.name);
+      if (existsSync(destDir)) {
+        const destHash = hashSkillDir(destDir);
+        if (sourceHash === destHash) continue;
+      }
+      await importSkillFromDir(sourceDir, "volute");
+      logger_default.info(`synced built-in skill: ${entry.name}`);
+    } catch (err) {
+      logger_default.error(`failed to sync built-in skill: ${entry.name}`, logger_default.errorData(err));
+    }
+  }
+}
+
+export {
+  SEED_SKILLS,
+  STANDARD_SKILLS,
+  sharedSkillsDir,
+  listSharedSkills,
+  getSharedSkill,
+  importSkillFromDir,
+  removeSharedSkill,
+  installSkill,
+  uninstallSkill,
+  updateSkill,
+  listMindSkills,
+  publishSkill,
+  listFilesRecursive,
+  syncBuiltinSkills
+};

package/dist/chunk-NSE7VJQA.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
+
+// src/lib/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  activity: () => activity,
+  conversationParticipants: () => conversationParticipants,
+  conversations: () => conversations,
+  deliveryQueue: () => deliveryQueue,
+  messages: () => messages,
+  mindHistory: () => mindHistory,
+  sessions: () => sessions,
+  sharedSkills: () => sharedSkills,
+  systemPrompts: () => systemPrompts,
+  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("brain"),
+  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+});
+var conversations = sqliteTable(
+  "conversations",
+  {
+    id: text("id").primaryKey(),
+    mind_name: text("mind_name"),
+    channel: text("channel").notNull(),
+    type: text("type").notNull().default("dm"),
+    name: text("name"),
+    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_mind_name").on(table.mind_name),
+    index("idx_conversations_user_id").on(table.user_id),
+    index("idx_conversations_updated_at").on(table.updated_at),
+    uniqueIndex("idx_conversations_name").on(table.name)
+  ]
+);
+var mindHistory = sqliteTable(
+  "mind_history",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    mind: text("mind").notNull(),
+    channel: text("channel"),
+    session: text("session"),
+    sender: text("sender"),
+    message_id: text("message_id"),
+    type: text("type").notNull(),
+    content: text("content"),
+    metadata: text("metadata"),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_mind_history_mind").on(table.mind),
+    index("idx_mind_history_mind_channel").on(table.mind, table.channel),
+    index("idx_mind_history_mind_type").on(table.mind, table.type)
+  ]
+);
+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 systemPrompts = sqliteTable("system_prompts", {
+  key: text("key").primaryKey(),
+  content: text("content").notNull(),
+  updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
+});
+var sharedSkills = sqliteTable("shared_skills", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  description: text("description").notNull().default(""),
+  author: text("author").notNull(),
+  version: integer("version").notNull().default(1),
+  created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
+  updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
+});
+var deliveryQueue = sqliteTable(
+  "delivery_queue",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    mind: text("mind").notNull(),
+    session: text("session").notNull(),
+    channel: text("channel"),
+    sender: text("sender"),
+    status: text("status").notNull().default("pending"),
+    payload: text("payload").notNull(),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_delivery_queue_mind_session").on(table.mind, table.session),
+    index("idx_delivery_queue_mind_status").on(table.mind, table.status)
+  ]
+);
+var activity = sqliteTable(
+  "activity",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    type: text("type").notNull(),
+    mind: text("mind").notNull(),
+    summary: text("summary").notNull(),
+    metadata: text("metadata"),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_activity_created_at").on(table.created_at),
+    index("idx_activity_mind").on(table.mind)
+  ]
+);
+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)]
+);
+
+export {
+  users,
+  conversations,
+  mindHistory,
+  conversationParticipants,
+  sessions,
+  systemPrompts,
+  sharedSkills,
+  deliveryQueue,
+  activity,
+  messages,
+  schema_exports
+};