volute 0.35.0 → 0.36.0

package/dist/src-GW6FP6VL.js

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+import {
+  createExtension
+} from "./chunk-RG5TOL4O.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/extensions/plan/src/index.ts
+import { resolve } from "path";
+
+// packages/extensions/plan/src/plans.ts
+async function startPlan(db, getUser, userId, title, description) {
+  db.prepare(
+    "UPDATE plans SET status = 'archived', completed_at = datetime('now') WHERE status = 'active'"
+  ).run();
+  const row = db.prepare(
+    `INSERT INTO plans (title, description, set_by)
+       VALUES (?, ?, ?)
+       RETURNING *`
+  ).get(title, description, userId);
+  const user = await getUser(userId);
+  return {
+    ...row,
+    set_by_username: user?.username ?? "unknown",
+    set_by_display_name: user?.display_name ?? null
+  };
+}
+async function getActivePlan(db, getUser) {
+  const row = db.prepare("SELECT * FROM plans WHERE status = 'active' LIMIT 1").get();
+  if (!row) return null;
+  const user = await getUser(row.set_by);
+  const logs = db.prepare("SELECT * FROM plan_logs WHERE plan_id = ? ORDER BY created_at DESC LIMIT 20").all(row.id);
+  const messages = db.prepare("SELECT * FROM plan_messages WHERE plan_id = ? ORDER BY id DESC LIMIT 10").all(row.id);
+  const latestMessage = messages.length > 0 ? messages[0].content : null;
+  return {
+    ...row,
+    set_by_username: user?.username ?? "unknown",
+    set_by_display_name: user?.display_name ?? null,
+    logs,
+    messages,
+    latestMessage
+  };
+}
+function logProgress(db, planId, mindName, content) {
+  return db.prepare(
+    `INSERT INTO plan_logs (plan_id, mind_name, content)
+       VALUES (?, ?, ?)
+       RETURNING *`
+  ).get(planId, mindName, content);
+}
+function addPlanMessage(db, planId, content) {
+  return db.prepare(
+    `INSERT INTO plan_messages (plan_id, content)
+       VALUES (?, ?)
+       RETURNING *`
+  ).get(planId, content);
+}
+function finishPlan(db, planId, message) {
+  const result = db.prepare(
+    "UPDATE plans SET status = 'completed', completed_at = datetime('now'), finish_message = ? WHERE id = ? AND status = 'active'"
+  ).run(message ?? null, planId);
+  return result.changes > 0;
+}
+async function listPlans(db, getUser, opts) {
+  const limit = opts?.limit ?? 20;
+  const offset = opts?.offset ?? 0;
+  const rows = opts?.status ? db.prepare("SELECT * FROM plans WHERE status = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.status, limit, offset) : db.prepare("SELECT * FROM plans ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
+  const userCache = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const row of rows) {
+    if (!userCache.has(row.set_by)) {
+      const u = await getUser(row.set_by);
+      userCache.set(row.set_by, {
+        username: u?.username ?? "unknown",
+        display_name: u?.display_name ?? null
+      });
+    }
+    const userInfo = userCache.get(row.set_by);
+    result.push({
+      ...row,
+      set_by_username: userInfo.username,
+      set_by_display_name: userInfo.display_name
+    });
+  }
+  return result;
+}
+
+// packages/extensions/plan/src/commands.ts
+async function announceToSystem(text, ctx) {
+  if (!ctx) return false;
+  try {
+    await ctx.announceToSystem(text);
+    return true;
+  } catch (err) {
+    console.error("[plan] Failed to announce to system channel:", err);
+    return false;
+  }
+}
+function createCommands() {
+  return {
+    start: {
+      description: "Start a new system plan",
+      args: [
+        { name: "title", required: true, description: "Plan title" },
+        { name: "description", description: "Plan description (or pipe via stdin)" }
+      ],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Plan extension requires a database" };
+        const mindName = ctx.mindName;
+        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const user = await ctx.getUserByUsername(mindName);
+        if (!user) return { error: `Unknown mind: ${mindName}` };
+        const title = args.title;
+        const description = args.description ?? ctx.stdin ?? "";
+        if (!title) return { error: 'Usage: volute plan start "title" "description"' };
+        const plan = await startPlan(ctx.db, ctx.getUser, user.id, title, description);
+        ctx.publishActivity({
+          type: "plan_started",
+          mind: user.username,
+          summary: `${user.username} started plan: "${title}"`,
+          metadata: { planId: plan.id, title }
+        });
+        return { output: `Plan started: ${plan.title}` };
+      }
+    },
+    message: {
+      description: "Post a message about the current plan (sent to #system)",
+      args: [{ name: "content", description: "Message content (or pipe via stdin)" }],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Plan extension requires a database" };
+        const mindName = ctx.mindName;
+        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const content = args.content ?? ctx.stdin;
+        if (!content) return { error: 'Usage: volute plan message "your message"' };
+        const plan = await getActivePlan(ctx.db, ctx.getUser);
+        if (!plan) return { error: "No active plan" };
+        const msg = addPlanMessage(ctx.db, plan.id, content);
+        ctx.publishActivity({
+          type: "plan_message",
+          mind: mindName,
+          summary: `Plan message: "${content.slice(0, 100)}"`,
+          metadata: { planId: plan.id, messageId: msg.id }
+        });
+        const announced = await announceToSystem(`[Plan: ${plan.title}] ${content}`, ctx);
+        return {
+          output: announced ? "Message posted to #system." : "Message logged (system channel unavailable)."
+        };
+      }
+    },
+    log: {
+      description: "Log progress on the current plan",
+      args: [{ name: "content", description: "Progress update (or pipe via stdin)" }],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Plan extension requires a database" };
+        const mindName = ctx.mindName;
+        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const content = args.content ?? ctx.stdin;
+        if (!content) return { error: 'Usage: volute plan log "progress update"' };
+        const plan = await getActivePlan(ctx.db, ctx.getUser);
+        if (!plan) return { error: "No active plan" };
+        const log = logProgress(ctx.db, plan.id, mindName, content);
+        ctx.publishActivity({
+          type: "plan_progress",
+          mind: mindName,
+          summary: `${mindName} logged progress: "${content.slice(0, 100)}"`,
+          metadata: { planId: plan.id, logId: log.id }
+        });
+        return { output: "Progress logged." };
+      }
+    },
+    current: {
+      description: "Show the current active plan",
+      handler: async (_parsed, ctx) => {
+        if (!ctx.db) return { error: "Plan extension requires a database" };
+        const plan = await getActivePlan(ctx.db, ctx.getUser);
+        if (!plan) return { output: "No active plan." };
+        const lines = [
+          `# ${plan.title}`,
+          "",
+          `Set by ${plan.set_by_username} \u2014 ${new Date(plan.created_at).toLocaleString()}`
+        ];
+        if (plan.description) {
+          lines.push("", plan.description);
+        }
+        if (plan.latestMessage) {
+          lines.push("", `## Latest message`, "", plan.latestMessage);
+        }
+        if (plan.logs.length > 0) {
+          lines.push("", "## Progress");
+          for (const log of plan.logs) {
+            const date = new Date(log.created_at).toLocaleString();
+            lines.push(`  ${log.mind_name} (${date}): ${log.content}`);
+          }
+        }
+        return { output: lines.join("\n") };
+      }
+    },
+    history: {
+      description: "List past plans",
+      flags: {
+        limit: { type: "number", description: "Max number of plans to show (default: 10)" }
+      },
+      handler: async ({ flags }, ctx) => {
+        if (!ctx.db) return { error: "Plan extension requires a database" };
+        const limit = flags.limit ?? 10;
+        const plans = await listPlans(ctx.db, ctx.getUser, { limit });
+        if (plans.length === 0) return { output: "No plans found." };
+        const lines = plans.map((p) => {
+          const date = new Date(p.created_at).toLocaleDateString();
+          const status = p.status === "active" ? " [active]" : "";
+          return `  ${p.title}  (${date}, by ${p.set_by_username})${status}`;
+        });
+        return { output: lines.join("\n") };
+      }
+    },
+    finish: {
+      description: "Finish the current plan with a closing message",
+      args: [{ name: "message", description: "Closing message (or pipe via stdin)" }],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Plan extension requires a database" };
+        const mindName = ctx.mindName;
+        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
+        const plan = await getActivePlan(ctx.db, ctx.getUser);
+        if (!plan) return { error: "No active plan" };
+        const message = args.message ?? ctx.stdin ?? "";
+        finishPlan(ctx.db, plan.id, message);
+        ctx.publishActivity({
+          type: "plan_finished",
+          mind: mindName,
+          summary: `${mindName} finished plan: "${plan.title}"`,
+          metadata: { planId: plan.id }
+        });
+        const announcement = message ? `[Plan finished: ${plan.title}] ${message}` : `[Plan finished: ${plan.title}]`;
+        const announced = await announceToSystem(announcement, ctx);
+        const suffix = announced ? "" : " (system channel unavailable)";
+        return { output: `Finished: ${plan.title}${suffix}` };
+      }
+    }
+  };
+}
+
+// packages/extensions/plan/src/db.ts
+function initDb(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS plans (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'active',
+      set_by INTEGER NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT,
+      finish_message TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+    CREATE INDEX IF NOT EXISTS idx_plans_created_at ON plans(created_at);
+
+    CREATE TABLE IF NOT EXISTS plan_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      plan_id INTEGER NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
+      mind_name TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_plan_logs_plan_id ON plan_logs(plan_id);
+
+    CREATE TABLE IF NOT EXISTS plan_messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      plan_id INTEGER NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_plan_messages_plan_id ON plan_messages(plan_id);
+  `);
+}
+
+// packages/extensions/plan/src/routes.ts
+import { Hono } from "hono";
+function resolveUserId(c) {
+  const user = c.get("user");
+  if (!user || user.id === 0) return null;
+  return user;
+}
+async function parseJson(c) {
+  try {
+    return await c.req.json();
+  } catch {
+    return null;
+  }
+}
+function createRoutes(ctx) {
+  if (!ctx.db) throw new Error("Plan extension requires a database");
+  const db = ctx.db;
+  const { getUser } = ctx;
+  const app = new Hono().get("/current", async (c) => {
+    const plan = await getActivePlan(db, getUser);
+    if (!plan) return c.json(null);
+    return c.json(plan);
+  }).get("/", async (c) => {
+    const status = c.req.query("status");
+    const rawLimit = c.req.query("limit");
+    const rawOffset = c.req.query("offset");
+    const limit = rawLimit ? parseInt(rawLimit, 10) : void 0;
+    const offset = rawOffset ? parseInt(rawOffset, 10) : void 0;
+    if (limit !== void 0 && Number.isNaN(limit) || offset !== void 0 && Number.isNaN(offset)) {
+      return c.json({ error: "Invalid limit or offset parameter" }, 400);
+    }
+    const plans = await listPlans(db, getUser, { status: status ?? void 0, limit, offset });
+    return c.json(plans);
+  }).post("/", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    if (actor.role !== "admin" && actor.user_type !== "mind") {
+      return c.json({ error: "Only spirit or admin can start plans" }, 403);
+    }
+    const body = await parseJson(c);
+    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
+    if (!body.title) return c.json({ error: "title is required" }, 400);
+    const plan = await startPlan(db, getUser, actor.id, body.title, body.description ?? "");
+    ctx.publishActivity({
+      type: "plan_started",
+      mind: actor.username,
+      summary: `${actor.username} started plan: "${body.title}"`,
+      metadata: { planId: plan.id, title: body.title }
+    });
+    return c.json(plan, 201);
+  }).post("/:id{[0-9]+}/message", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const planId = parseInt(c.req.param("id"), 10);
+    if (Number.isNaN(planId)) return c.json({ error: "Invalid plan ID" }, 400);
+    const plan = db.prepare("SELECT id FROM plans WHERE id = ? AND status = 'active'").get(planId);
+    if (!plan) return c.json({ error: "Active plan not found" }, 404);
+    const body = await parseJson(c);
+    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
+    if (!body.content) return c.json({ error: "content is required" }, 400);
+    const msg = addPlanMessage(db, planId, body.content);
+    ctx.publishActivity({
+      type: "plan_message",
+      mind: actor.username,
+      summary: `Plan message: "${body.content.slice(0, 100)}"`,
+      metadata: { planId, messageId: msg.id }
+    });
+    return c.json(msg, 201);
+  }).post("/:id{[0-9]+}/log", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const planId = parseInt(c.req.param("id"), 10);
+    if (Number.isNaN(planId)) return c.json({ error: "Invalid plan ID" }, 400);
+    const plan = db.prepare("SELECT id FROM plans WHERE id = ? AND status = 'active'").get(planId);
+    if (!plan) return c.json({ error: "Active plan not found" }, 404);
+    const body = await parseJson(c);
+    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
+    if (!body.content) return c.json({ error: "content is required" }, 400);
+    const log = logProgress(db, planId, actor.username, body.content);
+    ctx.publishActivity({
+      type: "plan_progress",
+      mind: actor.username,
+      summary: `${actor.username} logged progress: "${body.content.slice(0, 100)}"`,
+      metadata: { planId, logId: log.id }
+    });
+    return c.json(log, 201);
+  }).patch("/:id{[0-9]+}/finish", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    if (actor.role !== "admin" && actor.user_type !== "mind") {
+      return c.json({ error: "Only spirit or admin can finish plans" }, 403);
+    }
+    const planId = parseInt(c.req.param("id"), 10);
+    if (Number.isNaN(planId)) return c.json({ error: "Invalid plan ID" }, 400);
+    const body = await parseJson(c);
+    const message = body?.message;
+    const ok = finishPlan(db, planId, message);
+    if (!ok) return c.json({ error: "Plan not found" }, 404);
+    ctx.publishActivity({
+      type: "plan_finished",
+      mind: actor.username,
+      summary: `${actor.username} finished a plan`,
+      metadata: { planId }
+    });
+    return c.json({ ok: true });
+  }).get("/feed", async (c) => {
+    const rawLimit = c.req.query("limit");
+    const limit = rawLimit ? parseInt(rawLimit, 10) : 5;
+    if (Number.isNaN(limit)) return c.json({ error: "Invalid limit parameter" }, 400);
+    const plans = await listPlans(db, getUser, { limit });
+    return c.json(
+      plans.map((p) => ({
+        id: `plan-${p.id}`,
+        title: p.title,
+        url: `/plan`,
+        date: p.created_at,
+        author: p.set_by_username,
+        bodyHtml: p.description || `<em>${p.status}</em>`,
+        icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="8" r="6"/><path d="M8 4v4l2.5 2.5"/></svg>',
+        color: "blue"
+      }))
+    );
+  });
+  return app;
+}
+
+// packages/extensions/plan/src/index.ts
+var assetsDir = resolve(import.meta.dirname, "../dist/ui");
+var skillsDir = resolve(import.meta.dirname, "../skills");
+var src_default = createExtension({
+  id: "plan",
+  name: "Plan",
+  version: "0.1.0",
+  description: "System-wide plans for coordinated mind activity",
+  icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="8" r="6"/><path d="M8 4v4l2.5 2.5"/></svg>',
+  color: "blue",
+  routes: (ctx) => createRoutes(ctx),
+  commands: createCommands(),
+  initDb,
+  skillsDir,
+  standardSkill: true,
+  ui: {
+    assetsDir,
+    systemSection: { id: "plan", label: "Plan", urlPatterns: ["/plan"] },
+    feedSource: { endpoint: "/api/ext/plan/feed" }
+  }
+});
+export {
+  src_default as default
+};