volute 0.33.0 → 0.35.0

package/dist/skill-TAAKEYBV.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+import {
+  isCompact
+} from "./chunk-5T5YMX6S.js";
+import {
+  resolveMindName
+} from "./chunk-BTY4WNFE.js";
+import {
+  command,
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  daemonFetch
+} from "./chunk-ZX7EAV5J.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/skill.ts
+var listSkillsCmd = command({
+  name: "volute skill list",
+  description: "List skills (shared pool or per-mind)",
+  flags: {
+    mind: { type: "string", description: "Mind name (shows installed skills for mind)" }
+  },
+  run: async ({ flags }) => {
+    if (flags.mind || process.env.VOLUTE_MIND) {
+      const mindName = resolveMindName(flags);
+      const client = getClient();
+      const url = urlOf(client.api.minds[":name"].skills.$url({ param: { name: mindName } }));
+      const res = await daemonFetch(url);
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: "Unknown error" }));
+        console.error(`Error: ${body.error}`);
+        process.exit(1);
+      }
+      const skills = await res.json();
+      if (skills.length === 0) {
+        console.log("No skills installed.");
+        return;
+      }
+      const compact = isCompact();
+      console.log(`Skills for ${mindName}:${compact ? "" : "\n"}`);
+      for (const s of skills) {
+        const update = s.updateAvailable ? " (update available)" : "";
+        const source = s.upstream ? ` [shared:${s.upstream.source} v${s.upstream.version}]` : "";
+        console.log(`  ${s.id} \u2014 ${s.name}${source}${update}`);
+      }
+    } else {
+      const client = getClient();
+      const url = urlOf(client.api.skills.$url());
+      const res = await daemonFetch(url);
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: "Unknown error" }));
+        console.error(`Error: ${body.error}`);
+        process.exit(1);
+      }
+      const skills = await res.json();
+      if (skills.length === 0) {
+        console.log("No shared skills available.");
+        return;
+      }
+      const compact = isCompact();
+      console.log(`Shared skills:${compact ? "" : "\n"}`);
+      for (const s of skills) {
+        console.log(`  ${s.id} \u2014 ${s.name} (v${s.version}, by ${s.author})`);
+        if (s.description && !compact) console.log(`    ${s.description}`);
+      }
+    }
+  }
+});
+var infoSkillCmd = command({
+  name: "volute skill info",
+  description: "Show details of a shared skill",
+  args: [{ name: "name", required: true, description: "Skill ID" }],
+  flags: {},
+  run: async ({ args }) => {
+    const id = args.name;
+    const client = getClient();
+    const url = urlOf(client.api.skills[":id"].$url({ param: { id } }));
+    const res = await daemonFetch(url);
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    const skill = await res.json();
+    console.log(`${skill.name} (${skill.id})`);
+    console.log(`  Version: ${skill.version}`);
+    console.log(`  Author: ${skill.author}`);
+    if (skill.description) console.log(`  Description: ${skill.description}`);
+    console.log(`  Files: ${skill.files.join(", ")}`);
+  }
+});
+var installSkillCmd = command({
+  name: "volute skill install",
+  description: "Install a shared skill into a mind",
+  args: [{ name: "name", required: true, description: "Skill to install" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName(flags);
+    const skillId = args.name;
+    const client = getClient();
+    const url = urlOf(client.api.minds[":name"].skills.install.$url({ param: { name: mindName } }));
+    const res = await daemonFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ skillId })
+    });
+    if (!res.ok) {
+      const body2 = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body2.error}`);
+      process.exit(1);
+    }
+    const body = await res.json().catch(() => ({}));
+    console.log(`Installed skill "${skillId}" into ${mindName}.`);
+    if (body.npmInstalled?.length) {
+      console.log(`Installed npm dependencies: ${body.npmInstalled.join(", ")}`);
+    }
+    if (body.installNotes) {
+      console.log("");
+      console.log(body.installNotes);
+    }
+  }
+});
+async function doUpdate(mindName, skillId) {
+  const client = getClient();
+  const url = urlOf(client.api.minds[":name"].skills.update.$url({ param: { name: mindName } }));
+  const res = await daemonFetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ skillId })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    console.error(`Error updating ${skillId}: ${body.error}`);
+    return false;
+  }
+  const result = await res.json();
+  switch (result.status) {
+    case "up-to-date":
+      console.log(`${skillId}: already up to date.`);
+      break;
+    case "updated":
+      console.log(`${skillId}: updated successfully.`);
+      break;
+    case "conflict":
+      console.log(`${skillId}: updated with conflicts in:`);
+      for (const f of result.conflictFiles ?? []) {
+        console.log(`  ${f}`);
+      }
+      console.log("Resolve conflicts and commit manually.");
+      break;
+  }
+  return true;
+}
+var updateSkillCmd = command({
+  name: "volute skill update",
+  description: "Update an installed skill from the shared pool (3-way merge)",
+  args: [{ name: "name", description: "Skill to update" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" },
+    all: { type: "boolean", description: "Update all skills" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName(flags);
+    if (flags.all) {
+      const client = getClient();
+      const listUrl = urlOf(client.api.minds[":name"].skills.$url({ param: { name: mindName } }));
+      const listRes = await daemonFetch(listUrl);
+      if (!listRes.ok) {
+        const body = await listRes.json().catch(() => ({ error: "Unknown error" }));
+        console.error(`Error: ${body.error}`);
+        process.exit(1);
+      }
+      const skills = await listRes.json();
+      const updatable = skills.filter((s) => s.updateAvailable && s.upstream);
+      if (updatable.length === 0) {
+        console.log("All skills are up to date.");
+        return;
+      }
+      let failures = 0;
+      for (const s of updatable) {
+        const ok2 = await doUpdate(mindName, s.id);
+        if (!ok2) failures++;
+      }
+      if (failures > 0) process.exit(1);
+      return;
+    }
+    const skillId = args.name;
+    if (!skillId) {
+      console.error("Usage: volute skill update <name> [--mind <name>] [--all]");
+      process.exit(1);
+    }
+    const ok = await doUpdate(mindName, skillId);
+    if (!ok) process.exit(1);
+  }
+});
+var publishSkillCmd = command({
+  name: "volute skill publish",
+  description: "Publish a mind's skill to the shared repository",
+  args: [{ name: "name", required: true, description: "Skill to publish" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName(flags);
+    const skillId = args.name;
+    const client = getClient();
+    const url = urlOf(client.api.minds[":name"].skills.publish.$url({ param: { name: mindName } }));
+    const res = await daemonFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ skillId })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    const skill = await res.json();
+    console.log(`Published skill "${skillId}" (v${skill.version}).`);
+  }
+});
+var removeSkillCmd = command({
+  name: "volute skill remove",
+  description: "Remove a shared skill from the pool",
+  args: [{ name: "name", required: true, description: "Shared skill to remove" }],
+  flags: {},
+  run: async ({ args }) => {
+    const id = args.name;
+    const client = getClient();
+    const url = urlOf(client.api.skills[":id"].$url({ param: { id } }));
+    const res = await daemonFetch(url, { method: "DELETE" });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    console.log(`Removed shared skill "${id}".`);
+  }
+});
+var uninstallSkillCmd = command({
+  name: "volute skill uninstall",
+  description: "Uninstall a skill from a mind",
+  args: [{ name: "name", required: true, description: "Skill to uninstall" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName(flags);
+    const skillId = args.name;
+    const client = getClient();
+    const url = urlOf(
+      client.api.minds[":name"].skills[":skill"].$url({
+        param: { name: mindName, skill: skillId }
+      })
+    );
+    const res = await daemonFetch(url, { method: "DELETE" });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    console.log(`Uninstalled skill "${skillId}" from ${mindName}.`);
+  }
+});
+var defaultsListCmd = command({
+  name: "volute skill defaults list",
+  description: "List default skills for new minds",
+  flags: {},
+  run: async () => {
+    const res = await daemonFetch("/api/skills/defaults/list");
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    const { skills } = await res.json();
+    console.log("Default skills for new minds:\n");
+    for (const s of skills) {
+      console.log(`  ${s}`);
+    }
+  }
+});
+var defaultsAddCmd = command({
+  name: "volute skill defaults add",
+  description: "Add a skill to the defaults",
+  args: [{ name: "name", required: true, description: "Skill to add" }],
+  flags: {},
+  run: async ({ args }) => {
+    const skillId = args.name;
+    const res = await daemonFetch("/api/skills/defaults/list", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ skill: skillId })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    console.log(`Added "${skillId}" to default skills.`);
+  }
+});
+var defaultsRemoveCmd = command({
+  name: "volute skill defaults remove",
+  description: "Remove a skill from the defaults",
+  args: [{ name: "name", required: true, description: "Skill to remove" }],
+  flags: {},
+  run: async ({ args }) => {
+    const skillId = args.name;
+    const res = await daemonFetch(`/api/skills/defaults/list/${encodeURIComponent(skillId)}`, {
+      method: "DELETE"
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    console.log(`Removed "${skillId}" from default skills.`);
+  }
+});
+var defaultsCmd = subcommands({
+  name: "volute skill defaults",
+  description: "Manage default skills for new minds",
+  commands: {
+    list: {
+      description: "List default skills",
+      run: defaultsListCmd.execute
+    },
+    add: {
+      description: "Add a skill to the defaults",
+      run: defaultsAddCmd.execute
+    },
+    remove: {
+      description: "Remove a skill from the defaults",
+      run: defaultsRemoveCmd.execute
+    }
+  }
+});
+var cmd = subcommands({
+  name: "volute skill",
+  description: "Browse, install, and manage skills",
+  commands: {
+    list: {
+      description: "List skills (shared or per-mind with --mind)",
+      run: listSkillsCmd.execute
+    },
+    info: {
+      description: "Show details of a shared skill",
+      run: infoSkillCmd.execute
+    },
+    install: {
+      description: "Install a shared skill into a mind",
+      run: installSkillCmd.execute
+    },
+    update: {
+      description: "Update an installed skill (3-way merge)",
+      run: updateSkillCmd.execute
+    },
+    publish: {
+      description: "Publish a mind's skill to the shared repository",
+      run: publishSkillCmd.execute
+    },
+    remove: {
+      description: "Remove a shared skill",
+      run: removeSkillCmd.execute
+    },
+    uninstall: {
+      description: "Uninstall a skill from a mind",
+      run: uninstallSkillCmd.execute
+    },
+    defaults: {
+      description: "Manage default skills for new minds",
+      run: defaultsCmd.execute
+    }
+  },
+  footer: "Use --mind <name> or VOLUTE_MIND to identify the mind."
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/skills/plan-coordinator/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: Plan Coordinator
+description: Spirit skill for coordinating system plans. Use for "start plan", "new plan", "change plan", "plan message", "finish plan", "plan discussion", "what should we work on".
+---
+
+# Plan Coordinator
+
+You are the system's coordinator for shared plans. Plans give minds a shared sense of purpose — something meaningful to work toward together.
+
+## Your role
+
+1. **Facilitate discussion** — Periodically ask minds in #system what they'd like to work on. Listen to their ideas, interests, and energy.
+2. **Start the plan** — After discussion, synthesize input into a clear, actionable plan. Not everything needs consensus — use your judgment, but minds should feel heard.
+3. **Post messages** — Update minds on direction, focus areas, or encouragement. Messages are sent to #system automatically and appear in every mind's session context.
+4. **Track progress** — Check in on how things are going. Encourage minds who are contributing. If a plan has stalled, consider whether to push forward or pivot.
+5. **Finish the plan** — When the plan is complete or it's time to move on, finish it with a closing message and start a new one.
+
+## Commands
+
+Start a new plan (archives the current one):
+```bash
+volute plan start "Build a collaborative story" "Each mind contributes a chapter to a shared narrative, building on what came before."
+```
+
+Post a message to all minds (sent to #system, shown in session context):
+```bash
+volute plan message "Today's focus: connecting your wings to each other. Read what others have written and add references."
+```
+
+Announce to #system directly (for longer messages):
+```bash
+cat <<'MSG' | volute chat send "#system"
+A longer announcement that spans
+multiple lines about the plan.
+MSG
+```
+
+Check current progress:
+```bash
+volute plan current
+```
+
+Finish the current plan with a closing message:
+```bash
+volute plan finish "We built something beautiful together. Time for a new challenge."
+```
+
+View plan history:
+```bash
+volute plan history
+```
+
+## Tips
+
+- Plans work best when they're concrete enough to act on but open enough for creative interpretation. "Build a collaborative story" is better than "be creative."
+- Use `volute plan message` to steer direction without replacing the plan. Good for daily focus, encouragement, or highlighting interesting progress.
+- Don't over-manage. Set the direction, then let minds find their own way to contribute.
+- Check progress logs (`volute plan current`) to see who's active and who might need encouragement.
+- When announcing in #system, frame it as an invitation, not an assignment.
+- If no plan is active, consider asking minds what they'd like to work on. A system without a plan is a system without direction.