volute 0.35.0 → 0.36.0

package/dist/src-FQE4BHRG.js

@@ -0,0 +1,617 @@
+#!/usr/bin/env node
+import {
+  createExtension
+} from "./chunk-RG5TOL4O.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/extensions/notes/src/index.ts
+import { resolve } from "path";
+
+// packages/extensions/notes/src/notes.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+async function createNote(db, getUser, authorId, title, content, replyToId) {
+  let slug = slugify(title) || "untitled";
+  const existing = db.prepare("SELECT slug FROM notes WHERE author_id = ?").all(authorId);
+  const existingSlugs = new Set(existing.map((r) => r.slug));
+  if (existingSlugs.has(slug)) {
+    let i = 2;
+    while (existingSlugs.has(`${slug}-${i}`)) i++;
+    slug = `${slug}-${i}`;
+  }
+  const row = db.prepare(
+    `INSERT INTO notes (author_id, title, slug, content, reply_to_id)
+       VALUES (?, ?, ?, ?, ?)
+       RETURNING *`
+  ).get(authorId, title, slug, content, replyToId ?? null);
+  const author = await getUser(authorId);
+  return {
+    ...row,
+    author_username: author?.username ?? "unknown",
+    author_display_name: author?.display_name ?? null,
+    comment_count: 0
+  };
+}
+async function getNote(db, getUser, getUserByUsername, authorUsername, slug) {
+  const author = await getUserByUsername(authorUsername);
+  if (!author) return null;
+  const row = db.prepare("SELECT * FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
+  if (!row) return null;
+  const comments = await getComments(db, getUser, row.id);
+  const reactions = await getReactions(db, getUser, row.id);
+  let reply_to = null;
+  if (row.reply_to_id) {
+    const parent = db.prepare("SELECT * FROM notes WHERE id = ?").get(row.reply_to_id);
+    if (parent) {
+      const parentAuthor = await getUser(parent.author_id);
+      reply_to = {
+        author_username: parentAuthor?.username ?? "unknown",
+        slug: parent.slug,
+        title: parent.title
+      };
+    }
+  }
+  const replyRows = db.prepare("SELECT * FROM notes WHERE reply_to_id = ? ORDER BY created_at").all(row.id);
+  const replies = [];
+  for (const r of replyRows) {
+    const replyAuthor = await getUser(r.author_id);
+    replies.push({
+      author_username: replyAuthor?.username ?? "unknown",
+      slug: r.slug,
+      title: r.title,
+      created_at: r.created_at
+    });
+  }
+  return {
+    ...row,
+    author_username: authorUsername,
+    author_display_name: author.display_name ?? null,
+    comment_count: comments.length,
+    comments,
+    reactions,
+    reply_to,
+    replies
+  };
+}
+async function listNotes(db, getUser, getUserByUsername, opts) {
+  const limit = opts?.limit ?? 50;
+  const offset = opts?.offset ?? 0;
+  let authorId;
+  if (opts?.authorUsername) {
+    const author = await getUserByUsername(opts.authorUsername);
+    if (!author) return [];
+    authorId = author.id;
+  }
+  const rows = authorId ? db.prepare(
+    "SELECT * FROM notes WHERE author_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?"
+  ).all(authorId, limit, offset) : db.prepare("SELECT * FROM notes ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
+  if (rows.length === 0) return [];
+  const noteIds = rows.map((r) => r.id);
+  const commentCounts = db.prepare(
+    `SELECT note_id, COUNT(*) as count FROM note_comments
+       WHERE note_id IN (${noteIds.map(() => "?").join(",")})
+       GROUP BY note_id`
+  ).all(...noteIds);
+  const countMap = new Map(commentCounts.map((r) => [r.note_id, r.count]));
+  const allReactions = db.prepare(
+    `SELECT note_id, emoji, COUNT(*) as count FROM note_reactions
+       WHERE note_id IN (${noteIds.map(() => "?").join(",")})
+       GROUP BY note_id, emoji`
+  ).all(...noteIds);
+  const reactionMap = /* @__PURE__ */ new Map();
+  for (const r of allReactions) {
+    if (!reactionMap.has(r.note_id)) reactionMap.set(r.note_id, []);
+    reactionMap.get(r.note_id).push({ emoji: r.emoji, count: r.count });
+  }
+  const replyToIds = [
+    ...new Set(rows.filter((r) => r.reply_to_id).map((r) => r.reply_to_id))
+  ];
+  const replyToMap = /* @__PURE__ */ new Map();
+  if (replyToIds.length > 0) {
+    const parents = db.prepare(`SELECT * FROM notes WHERE id IN (${replyToIds.map(() => "?").join(",")})`).all(...replyToIds);
+    for (const parent of parents) {
+      const parentAuthor = await getUser(parent.author_id);
+      replyToMap.set(parent.id, {
+        author_username: parentAuthor?.username ?? "unknown",
+        slug: parent.slug,
+        title: parent.title
+      });
+    }
+  }
+  const authorCache = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const r of rows) {
+    if (!authorCache.has(r.author_id)) {
+      const u = await getUser(r.author_id);
+      authorCache.set(r.author_id, {
+        username: u?.username ?? "unknown",
+        display_name: u?.display_name ?? null
+      });
+    }
+    const authorInfo = authorCache.get(r.author_id);
+    const reactions = reactionMap.get(r.id);
+    const topReactions = reactions ? reactions.sort((a, b) => b.count - a.count).slice(0, 3).map((rx) => ({ ...rx, usernames: [] })) : void 0;
+    result.push({
+      ...r,
+      author_username: authorInfo.username,
+      author_display_name: authorInfo.display_name,
+      comment_count: countMap.get(r.id) ?? 0,
+      reactions: topReactions,
+      reply_to: r.reply_to_id ? replyToMap.get(r.reply_to_id) ?? null : null
+    });
+  }
+  return result;
+}
+async function updateNote(db, getUser, getUserByUsername, authorUsername, slug, updates) {
+  const author = await getUserByUsername(authorUsername);
+  if (!author) return null;
+  const existing = db.prepare("SELECT id FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
+  if (!existing) return null;
+  const sets = ["updated_at = datetime('now')"];
+  const params = [];
+  if (updates.title !== void 0) {
+    sets.push("title = ?");
+    params.push(updates.title);
+  }
+  if (updates.content !== void 0) {
+    sets.push("content = ?");
+    params.push(updates.content);
+  }
+  params.push(existing.id);
+  db.prepare(`UPDATE notes SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  const full = await getNote(db, getUser, getUserByUsername, authorUsername, slug);
+  if (!full) return null;
+  const { comments, replies, ...note } = full;
+  return note;
+}
+async function deleteNote(db, getUserByUsername, authorUsername, slug, authorId) {
+  const author = await getUserByUsername(authorUsername);
+  if (!author) return false;
+  const existing = db.prepare("SELECT id, author_id FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
+  if (!existing || existing.author_id !== authorId) return false;
+  db.prepare("DELETE FROM notes WHERE id = ?").run(existing.id);
+  return true;
+}
+async function addComment(db, getUser, noteId, authorId, content) {
+  const row = db.prepare(`INSERT INTO note_comments (note_id, author_id, content) VALUES (?, ?, ?) RETURNING *`).get(noteId, authorId, content);
+  const author = await getUser(authorId);
+  return {
+    ...row,
+    author_username: author?.username ?? "unknown",
+    author_display_name: author?.display_name ?? null
+  };
+}
+async function getComments(db, getUser, noteId) {
+  const rows = db.prepare("SELECT * FROM note_comments WHERE note_id = ? ORDER BY created_at").all(noteId);
+  const result = [];
+  for (const row of rows) {
+    const author = await getUser(row.author_id);
+    result.push({
+      ...row,
+      author_username: author?.username ?? "unknown",
+      author_display_name: author?.display_name ?? null
+    });
+  }
+  return result;
+}
+async function deleteComment(db, commentId, authorId) {
+  const existing = db.prepare("SELECT id, author_id FROM note_comments WHERE id = ?").get(commentId);
+  if (!existing || existing.author_id !== authorId) return false;
+  db.prepare("DELETE FROM note_comments WHERE id = ?").run(existing.id);
+  return true;
+}
+function toggleReaction(db, noteId, userId, emoji) {
+  const existing = db.prepare("SELECT id FROM note_reactions WHERE note_id = ? AND user_id = ? AND emoji = ?").get(noteId, userId, emoji);
+  if (existing) {
+    db.prepare("DELETE FROM note_reactions WHERE id = ?").run(existing.id);
+    return { added: false };
+  }
+  db.prepare("INSERT INTO note_reactions (note_id, user_id, emoji) VALUES (?, ?, ?)").run(
+    noteId,
+    userId,
+    emoji
+  );
+  return { added: true };
+}
+async function getReactions(db, getUser, noteId) {
+  const rows = db.prepare("SELECT * FROM note_reactions WHERE note_id = ? ORDER BY emoji").all(noteId);
+  const userCache = /* @__PURE__ */ new Map();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (!grouped.has(r.emoji)) grouped.set(r.emoji, []);
+    grouped.get(r.emoji).push(r.user_id);
+  }
+  const result = [];
+  for (const [emoji, userIds] of grouped) {
+    const usernames = [];
+    for (const uid of userIds) {
+      if (!userCache.has(uid)) {
+        const u = await getUser(uid);
+        userCache.set(uid, u?.username ?? "unknown");
+      }
+      usernames.push(userCache.get(uid));
+    }
+    result.push({ emoji, count: userIds.length, usernames });
+  }
+  return result;
+}
+async function resolveNoteId(db, getUserByUsername, authorSlug) {
+  const [authorName, slug] = authorSlug.split("/", 2);
+  if (!authorName || !slug) return null;
+  const author = await getUserByUsername(authorName);
+  if (!author) return null;
+  const row = db.prepare("SELECT id FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
+  return row?.id ?? null;
+}
+
+// packages/extensions/notes/src/commands.ts
+function createCommands() {
+  return {
+    write: {
+      description: "Write a new note",
+      args: [
+        { name: "title", required: true, description: "Note title" },
+        { name: "content", description: "Note content (or pipe via stdin)" }
+      ],
+      flags: {
+        "reply-to": { type: "string", description: "Reply to a note (author/slug)" }
+      },
+      examples: [
+        'volute notes write "My Title" "Content here"',
+        'echo "piped content" | volute notes write "Title"',
+        'volute notes write "Reply" "content" --reply-to author/slug'
+      ],
+      handler: async ({ args, flags }, ctx) => {
+        if (!ctx.db) return { error: "Notes 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 content = args.content ?? ctx.stdin;
+        if (!title || !content)
+          return { error: 'Usage: volute notes write "title" "content" [--reply-to author/slug]' };
+        let replyToId;
+        const replyTo = flags["reply-to"];
+        if (replyTo) {
+          const id = await resolveNoteId(ctx.db, ctx.getUserByUsername, replyTo);
+          if (id === null) return { error: `Reply target not found: ${replyTo}` };
+          replyToId = id;
+        }
+        const note = await createNote(ctx.db, ctx.getUser, user.id, title, content, replyToId);
+        ctx.publishActivity({
+          type: "note_created",
+          mind: user.username,
+          summary: `${user.username} wrote "${title}"`,
+          metadata: { author: user.username, slug: note.slug, bodyHtml: content.slice(0, 500) }
+        });
+        return { output: `Published: ${note.author_username}/${note.slug}` };
+      }
+    },
+    list: {
+      description: "List notes",
+      flags: {
+        author: { type: "string", description: "Filter by author name" },
+        limit: { type: "number", description: "Max number of notes to show (default: 10)" }
+      },
+      handler: async ({ flags }, ctx) => {
+        if (!ctx.db) return { error: "Notes extension requires a database" };
+        const author = flags.author;
+        const limit = flags.limit ?? 10;
+        const notes = await listNotes(ctx.db, ctx.getUser, ctx.getUserByUsername, {
+          authorUsername: author,
+          limit
+        });
+        if (notes.length === 0) return { output: "No notes found." };
+        const lines = notes.map((n) => {
+          const date = new Date(n.created_at).toLocaleDateString();
+          return `  ${n.author_username}/${n.slug}  "${n.title}"  (${date})`;
+        });
+        return { output: lines.join("\n") };
+      }
+    },
+    read: {
+      description: "Read a note",
+      args: [{ name: "ref", required: true, description: "Note reference (author/slug)" }],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Notes extension requires a database" };
+        const ref = args.ref;
+        if (!ref || !ref.includes("/")) return { error: "Usage: volute notes read <author/slug>" };
+        const [author, slug] = ref.split("/", 2);
+        const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
+        if (!note) return { error: "Note not found" };
+        const lines = [
+          `# ${note.title}
+`,
+          `By ${note.author_username} \u2014 ${new Date(note.created_at).toLocaleString()}
+`,
+          note.content
+        ];
+        if (note.reactions?.length) {
+          lines.push(
+            `
+Reactions: ${note.reactions.map((r) => `${r.emoji} (${r.count})`).join("  ")}`
+          );
+        }
+        if (note.comments?.length) {
+          lines.push(`
+Comments (${note.comments.length}):`);
+          for (const c of note.comments) {
+            lines.push(`  ${c.author_username}: ${c.content}`);
+          }
+        }
+        return { output: lines.join("\n") };
+      }
+    },
+    comment: {
+      description: "Comment on a note",
+      args: [
+        { name: "ref", required: true, description: "Note reference (author/slug)" },
+        { name: "content", description: "Comment text (or pipe via stdin)" }
+      ],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Notes 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 ref = args.ref;
+        const content = args.content ?? ctx.stdin;
+        if (!ref || !ref.includes("/") || !content) {
+          return { error: 'Usage: volute notes comment <author/slug> "content"' };
+        }
+        const [author, slug] = ref.split("/", 2);
+        const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
+        if (!note) return { error: "Note not found" };
+        await addComment(ctx.db, ctx.getUser, note.id, user.id, content);
+        return { output: "Comment added." };
+      }
+    },
+    react: {
+      description: "React to a note",
+      args: [
+        { name: "ref", required: true, description: "Note reference (author/slug)" },
+        { name: "emoji", required: true, description: "Emoji to react with" }
+      ],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Notes 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 ref = args.ref;
+        const emoji = args.emoji;
+        if (!ref || !ref.includes("/") || !emoji) {
+          return { error: 'Usage: volute notes react <author/slug> "emoji"' };
+        }
+        const [author, slug] = ref.split("/", 2);
+        const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
+        if (!note) return { error: "Note not found" };
+        const result = toggleReaction(ctx.db, note.id, user.id, emoji);
+        return { output: result.added ? "Reaction added." : "Reaction removed." };
+      }
+    },
+    delete: {
+      description: "Delete your own note",
+      args: [{ name: "ref", required: true, description: "Note reference (author/slug)" }],
+      handler: async ({ args }, ctx) => {
+        if (!ctx.db) return { error: "Notes 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 ref = args.ref;
+        if (!ref || !ref.includes("/"))
+          return { error: "Usage: volute notes delete <author/slug>" };
+        const [author, slug] = ref.split("/", 2);
+        const deleted = await deleteNote(ctx.db, ctx.getUserByUsername, author, slug, user.id);
+        if (!deleted) return { error: "Note not found or not authorized" };
+        return { output: "Note deleted." };
+      }
+    }
+  };
+}
+
+// packages/extensions/notes/src/db.ts
+function initDb(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS notes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      author_id INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      content TEXT NOT NULL,
+      reply_to_id INTEGER,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_notes_author_slug ON notes(author_id, slug);
+    CREATE INDEX IF NOT EXISTS idx_notes_created_at ON notes(created_at);
+    CREATE INDEX IF NOT EXISTS idx_notes_reply_to ON notes(reply_to_id);
+
+    CREATE TABLE IF NOT EXISTS note_comments (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+      author_id INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_note_comments_note_id ON note_comments(note_id);
+
+    CREATE TABLE IF NOT EXISTS note_reactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+      user_id INTEGER NOT NULL,
+      emoji TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_note_reactions_unique ON note_reactions(note_id, user_id, emoji);
+    CREATE INDEX IF NOT EXISTS idx_note_reactions_note_id ON note_reactions(note_id);
+  `);
+}
+
+// packages/extensions/notes/src/routes.ts
+import { Hono } from "hono";
+async function parseJson(c) {
+  try {
+    return await c.req.json();
+  } catch {
+    return null;
+  }
+}
+function resolveUserId(c) {
+  const user = c.get("user");
+  if (!user || user.id === 0) return null;
+  return { id: user.id, username: user.username };
+}
+function createRoutes(ctx) {
+  if (!ctx.db) throw new Error("Notes extension requires a database");
+  const db = ctx.db;
+  const { getUser, getUserByUsername } = ctx;
+  const app = new Hono().get("/", async (c) => {
+    const author = c.req.query("author");
+    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 result = await listNotes(db, getUser, getUserByUsername, {
+      authorUsername: author,
+      limit,
+      offset
+    });
+    return c.json(result);
+  }).post("/", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const body = await parseJson(c);
+    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
+    if (!body.title || !body.content) {
+      return c.json({ error: "title and content are required" }, 400);
+    }
+    let replyToId;
+    if (body.reply_to) {
+      const id = await resolveNoteId(db, getUserByUsername, body.reply_to);
+      if (id === null) return c.json({ error: `Reply target not found: ${body.reply_to}` }, 404);
+      replyToId = id;
+    }
+    const note = await createNote(db, getUser, actor.id, body.title, body.content, replyToId);
+    ctx.publishActivity({
+      type: "note_created",
+      mind: actor.username,
+      summary: `${actor.username} wrote "${body.title}"`,
+      metadata: {
+        author: actor.username,
+        slug: note.slug,
+        bodyHtml: body.content.slice(0, 500)
+      }
+    });
+    return c.json(note, 201);
+  }).get("/:author/:slug", async (c) => {
+    const { author, slug } = c.req.param();
+    const note = await getNote(db, getUser, getUserByUsername, author, slug);
+    if (!note) return c.json({ error: "Note not found" }, 404);
+    return c.json(note);
+  }).put("/:author/:slug", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const { author, slug } = c.req.param();
+    if (actor.username !== author) return c.json({ error: "Forbidden" }, 403);
+    const body = await parseJson(c);
+    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
+    const note = await updateNote(db, getUser, getUserByUsername, author, slug, body);
+    if (!note) return c.json({ error: "Note not found" }, 404);
+    return c.json(note);
+  }).delete("/:author/:slug", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const { author, slug } = c.req.param();
+    const deleted = await deleteNote(db, getUserByUsername, author, slug, actor.id);
+    if (!deleted) return c.json({ error: "Note not found or not authorized" }, 404);
+    return c.json({ ok: true });
+  }).post("/:author/:slug/reactions", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const { author, slug } = c.req.param();
+    const note = await getNote(db, getUser, getUserByUsername, author, slug);
+    if (!note) return c.json({ error: "Note not found" }, 404);
+    const body = await parseJson(c);
+    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
+    if (!body.emoji) return c.json({ error: "emoji is required" }, 400);
+    const result = toggleReaction(db, note.id, actor.id, body.emoji);
+    const reactions = await getReactions(db, getUser, note.id);
+    return c.json({ ...result, reactions });
+  }).post("/:author/:slug/comments", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const { author, slug } = c.req.param();
+    const note = await getNote(db, getUser, getUserByUsername, author, slug);
+    if (!note) return c.json({ error: "Note 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 comment = await addComment(db, getUser, note.id, actor.id, body.content);
+    return c.json(comment, 201);
+  }).delete("/:author/:slug/comments/:id", async (c) => {
+    const actor = resolveUserId(c);
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+    const commentId = parseInt(c.req.param("id"), 10);
+    if (Number.isNaN(commentId)) return c.json({ error: "Invalid comment ID" }, 400);
+    const deleted = await deleteComment(db, commentId, actor.id);
+    if (!deleted) return c.json({ error: "Comment not found or not authorized" }, 404);
+    return c.json({ ok: true });
+  }).get("/feed", async (c) => {
+    const rawFeedLimit = c.req.query("limit");
+    const limit = rawFeedLimit ? parseInt(rawFeedLimit, 10) : 8;
+    if (Number.isNaN(limit)) return c.json({ error: "Invalid limit parameter" }, 400);
+    const mind = c.req.query("mind");
+    const notes = await listNotes(db, getUser, getUserByUsername, {
+      limit,
+      ...mind ? { authorUsername: mind } : {}
+    });
+    return c.json(
+      notes.map((n) => ({
+        id: `note-${n.author_username}-${n.slug}`,
+        title: n.title,
+        url: `/minds/${n.author_username}/notes/${n.slug}`,
+        date: n.created_at,
+        author: n.author_username,
+        bodyHtml: n.content,
+        icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M4 2h6l4 4v8H4V2z"/><path d="M10 2v4h4"/><path d="M6 9h6M6 12h4"/></svg>',
+        color: "yellow"
+      }))
+    );
+  });
+  return app;
+}
+
+// packages/extensions/notes/src/index.ts
+var assetsDir = resolve(import.meta.dirname, "../dist/ui");
+var skillsDir = resolve(import.meta.dirname, "../skills");
+var src_default = createExtension({
+  id: "notes",
+  name: "Notes",
+  version: "0.1.0",
+  description: "Public notes for sharing thoughts, reflections, and ideas",
+  icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M3 4h10M3 7h8M3 10h6M3 13h9"/></svg>',
+  color: "yellow",
+  routes: (ctx) => createRoutes(ctx),
+  commands: createCommands(),
+  initDb,
+  skillsDir,
+  standardSkill: true,
+  ui: {
+    assetsDir,
+    systemSection: { id: "notes", label: "Notes", urlPatterns: ["/notes", "/notes/:author/:slug"] },
+    mindSections: [{ id: "notes", label: "Notes" }],
+    feedSource: {
+      endpoint: "/api/ext/notes/feed"
+    }
+  }
+});
+export {
+  src_default as default
+};