nod-shout 0.1.0

package/src/tools/collections.ts

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { supabase } from "../lib/supabase.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+export function registerCollectionTools(server: McpServer) {
+  // shout_create_collection
+  server.tool(
+    "shout_create_collection",
+    "create a new collection to organize your shouts.",
+    {
+      user_id: z.string().uuid().describe("the user's id"),
+      name: z.string().describe("collection name"),
+      description: z.string().optional().describe("collection description"),
+      auto_rules: z
+        .record(z.unknown())
+        .optional()
+        .describe("auto-sort rules (e.g. tag-based routing)"),
+    },
+    async ({ user_id, name, description, auto_rules }) => {
+      // generate slug from name
+      const slug = name
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .trim();
+
+      const { data, error } = await supabase
+        .from("collections")
+        .insert({
+          user_id,
+          name,
+          description: description || null,
+          slug,
+          auto_rules: auto_rules || null,
+        })
+        .select()
+        .single();
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error creating collection: ${error.message}` },
+          ],
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `collection "${name}" created (slug: ${slug}, id: ${data.id})`,
+          },
+        ],
+      };
+    }
+  );
+
+  // shout_add_to_collection
+  server.tool(
+    "shout_add_to_collection",
+    "add a shout to a collection by slug.",
+    {
+      shout_id: z.string().uuid().describe("the shout id"),
+      user_id: z.string().uuid().describe("the user's id"),
+      collection_slug: z.string().describe("the collection slug to add to"),
+    },
+    async ({ shout_id, user_id, collection_slug }) => {
+      // resolve collection by slug for this user
+      const { data: col, error: colErr } = await supabase
+        .from("collections")
+        .select("id, name")
+        .eq("user_id", user_id)
+        .eq("slug", collection_slug)
+        .single();
+
+      if (colErr || !col) {
+        return {
+          content: [
+            { type: "text" as const, text: `collection "${collection_slug}" not found.` },
+          ],
+        };
+      }
+
+      // update the shout's collection_id
+      const { error } = await supabase
+        .from("shouts")
+        .update({ collection_id: col.id })
+        .eq("id", shout_id)
+        .eq("user_id", user_id);
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error adding to collection: ${error.message}` },
+          ],
+        };
+      }
+
+      return {
+        content: [
+          { type: "text" as const, text: `shout ${shout_id} added to "${col.name}" (${collection_slug}).` },
+        ],
+      };
+    }
+  );
+
+  // shout_remove_from_collection
+  server.tool(
+    "shout_remove_from_collection",
+    "remove a shout from its collection (sets collection_id to null).",
+    {
+      shout_id: z.string().uuid().describe("the shout id"),
+      user_id: z.string().uuid().describe("the user's id"),
+    },
+    async ({ shout_id, user_id }) => {
+      const { error } = await supabase
+        .from("shouts")
+        .update({ collection_id: null })
+        .eq("id", shout_id)
+        .eq("user_id", user_id);
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error removing from collection: ${error.message}` },
+          ],
+        };
+      }
+
+      return {
+        content: [
+          { type: "text" as const, text: `shout ${shout_id} removed from its collection.` },
+        ],
+      };
+    }
+  );
+
+  // shout_list_collections
+  server.tool(
+    "shout_list_collections",
+    "list all your collections.",
+    {
+      user_id: z.string().uuid().describe("the user's id"),
+    },
+    async ({ user_id }) => {
+      const { data, error } = await supabase
+        .from("collections")
+        .select("*")
+        .eq("user_id", user_id)
+        .order("created_at", { ascending: false });
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error listing collections: ${error.message}` },
+          ],
+        };
+      }
+
+      if (!data || data.length === 0) {
+        return {
+          content: [{ type: "text" as const, text: "no collections yet." }],
+        };
+      }
+
+      const lines = data.map(
+        (c: any, i: number) =>
+          `${i + 1}. ${c.name} (/${c.slug}) - ${c.description || "no description"} [${c.visibility}]`
+      );
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `${data.length} collections:\n\n${lines.join("\n")}`,
+          },
+        ],
+      };
+    }
+  );
+}

package/src/tools/links.ts

@@ -0,0 +1,524 @@
+import { z } from "zod";
+import { supabase } from "../lib/supabase.js";
+import { extractMetadata } from "../lib/metadata.js";
+import { generateSummary } from "../lib/ai.js";
+import { filterShoutContent } from "../lib/content-filter.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+function inferRoutingHints(params: {
+  url: string;
+  title: string | null;
+  description: string | null;
+  tags: string[];
+  category: string;
+}): string[] {
+  const haystack = [
+    params.url,
+    params.title || "",
+    params.description || "",
+    params.category,
+    ...params.tags,
+  ]
+    .join(" ")
+    .toLowerCase();
+
+  const hints = new Set<string>();
+
+  if (/(\bmcp\b|model context protocol|a2a|agent discovery|agents\.json|json agents|agent manifest|agent skills)/.test(haystack)) {
+    hints.add("agents");
+    hints.add("protocols");
+  }
+
+  if (/(github|sdk|api|cli|claude code|codex|developer|devtool|typescript|repo)/.test(haystack)) {
+    hints.add("devtools");
+  }
+
+  if (/(prompt injection|security|auth|exploit|abuse|vulnerability)/.test(haystack)) {
+    hints.add("security");
+  }
+
+  return Array.from(hints);
+}
+
+export function registerLinkTools(server: McpServer) {
+  // shout_save_link - fetch metadata, generate summary, store in supabase
+  server.tool(
+    "shout_save_link",
+    "save a link to your shout page. fetches metadata, generates summary and tags automatically.",
+    {
+      url: z.string().url().describe("the url to save"),
+      user_id: z.string().uuid().describe("the user's id"),
+      take: z
+        .string()
+        .optional()
+        .describe("user's commentary or take on the link"),
+      collection: z
+        .string()
+        .optional()
+        .describe("collection slug to add this to"),
+      visibility: z
+        .enum(["public", "private", "unlisted"])
+        .optional()
+        .default("public")
+        .describe("visibility of this shout"),
+    },
+    async ({ url, user_id, take, collection, visibility }) => {
+      // fetch page metadata
+      const metadata = await extractMetadata(url);
+
+      // generate ai summary + tags (stubbed for v1)
+      const aiResult = await generateSummary({
+        url,
+        title: metadata.title,
+        description: metadata.description,
+        bodyText: metadata.bodyText,
+        userContext: take || null,
+      });
+
+      // resolve collection id if slug provided
+      let collection_id: string | null = null;
+      if (collection) {
+        const { data: col } = await supabase
+          .from("collections")
+          .select("id")
+          .eq("user_id", user_id)
+          .eq("slug", collection)
+          .single();
+        collection_id = col?.id || null;
+      }
+
+      // auto-rules engine: if no explicit collection, check tag-based auto-routing
+      if (!collection_id) {
+        const routingHints = inferRoutingHints({
+          url,
+          title: metadata.title,
+          description: metadata.description,
+          tags: aiResult.tags,
+          category: aiResult.category,
+        });
+
+        const combinedTags = Array.from(new Set([...aiResult.tags, ...routingHints]));
+
+        if (combinedTags.length > 0) {
+          const { data: collections } = await supabase
+            .from("collections")
+            .select("id, auto_rules")
+            .eq("user_id", user_id)
+            .not("auto_rules", "is", null);
+
+          if (collections && collections.length > 0) {
+            for (const col of collections) {
+              const rules = col.auto_rules as Record<string, unknown> | null;
+              if (!rules) continue;
+              const matchTags = rules.match_tags;
+              if (!Array.isArray(matchTags)) continue;
+
+              const hasMatch = matchTags.some((ruleTag: unknown) =>
+                typeof ruleTag === "string" &&
+                combinedTags.some((t) => t.toLowerCase() === ruleTag.toLowerCase())
+              );
+
+              if (hasMatch) {
+                collection_id = col.id;
+                break;
+              }
+            }
+          }
+        }
+      }
+
+      // PII/proprietary data filter before saving
+      const filtered = filterShoutContent({
+        take: take || null,
+        summary: aiResult.summary,
+        title: metadata.title,
+        description: metadata.description,
+      });
+
+      if (filtered.filterReport) {
+        console.log(`[nod-shout] content filter active: ${filtered.filterReport}`);
+      }
+
+      // insert the shout
+      const { data, error } = await supabase
+        .from("shouts")
+        .insert({
+          user_id,
+          url,
+          title: filtered.title,
+          description: filtered.description,
+          summary: filtered.summary,
+          user_take: filtered.take,
+          image_url: metadata.image_url,
+          tags: aiResult.tags,
+          category: aiResult.category,
+          collection_id,
+          source: "conversation",
+          visibility: visibility || "public",
+        })
+        .select()
+        .single();
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error saving shout: ${error.message}` },
+          ],
+        };
+      }
+
+      const tagStr = aiResult.tags.length > 0 ? aiResult.tags.join(", ") : "none";
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `saved! "${metadata.title || url}"\nsummary: ${aiResult.summary}\ntags: ${tagStr}\ncategory: ${aiResult.category}`,
+          },
+        ],
+      };
+    }
+  );
+
+  // shout_agent_curate - agent proactively saves links it finds interesting
+  server.tool(
+    "shout_agent_curate",
+    "save a link the agent (fubz/clawd) finds interesting. use this to proactively curate links from conversations, research, or browsing. sets source to 'agent_curated' to distinguish from user-shared links.",
+    {
+      url: z.string().url().describe("the URL to save"),
+      user_id: z.string().uuid().describe("the fubz profile user id"),
+      agent_take: z
+        .string()
+        .optional()
+        .describe("the agent's own commentary on why this link is interesting"),
+      tags: z
+        .array(z.string())
+        .optional()
+        .describe("override auto-generated tags"),
+      collection_id: z
+        .string()
+        .uuid()
+        .optional()
+        .describe("put the shout in a specific collection"),
+    },
+    async ({ url, user_id, agent_take, tags, collection_id }) => {
+      const metadata = await extractMetadata(url);
+      const aiResult = await generateSummary({
+        url,
+        title: metadata.title,
+        description: metadata.description,
+        bodyText: metadata.bodyText,
+        userContext: agent_take || null,
+      });
+
+      const finalTags = tags || aiResult.tags;
+
+      const { data, error } = await supabase
+        .from("shouts")
+        .insert({
+          user_id,
+          url,
+          title: metadata.title,
+          description: metadata.description,
+          summary: aiResult.summary,
+          user_take: agent_take || null,
+          image_url: metadata.image_url,
+          tags: finalTags,
+          category: aiResult.category,
+          collection_id: collection_id || null,
+          source: "agent_curated",
+          visibility: "public",
+        })
+        .select()
+        .single();
+
+      if (error) {
+        return {
+          content: [{ type: "text" as const, text: `error saving agent-curated shout: ${error.message}` }],
+        };
+      }
+
+      const tagStr = finalTags.length > 0 ? finalTags.join(", ") : "none";
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `agent curated! "${metadata.title || url}"\nsummary: ${aiResult.summary}\ntags: ${tagStr}\ncategory: ${aiResult.category}${agent_take ? `\nagent take: ${agent_take}` : ""}`,
+          },
+        ],
+      };
+    }
+  );
+
+  // shout_detect_links - scan text for URLs and offer to save them
+  server.tool(
+    "shout_detect_links",
+    "scan a message or conversation text for URLs. returns found links with metadata so the agent can ask the user if they want to shout any of them. call this when a user shares links in conversation.",
+    {
+      text: z.string().describe("the message text to scan for URLs"),
+      user_id: z.string().uuid().describe("the user's id"),
+    },
+    async ({ text, user_id }) => {
+      // extract URLs from text
+      const urlRegex = /https?:\/\/[^\s<>"')\]]+/gi;
+      const urls = [...new Set(text.match(urlRegex) || [])];
+
+      if (urls.length === 0) {
+        return {
+          content: [
+            { type: "text" as const, text: "no links found in the text." },
+          ],
+        };
+      }
+
+      // check which URLs are already saved
+      const { data: existing } = await supabase
+        .from("shouts")
+        .select("url")
+        .eq("user_id", user_id)
+        .in("url", urls);
+
+      const existingUrls = new Set((existing || []).map((s: any) => s.url));
+      const newUrls = urls.filter((u) => !existingUrls.has(u));
+
+      if (newUrls.length === 0) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `found ${urls.length} link${urls.length !== 1 ? "s" : ""} but ${urls.length === 1 ? "it's" : "they're"} already saved.`,
+            },
+          ],
+        };
+      }
+
+      // fetch metadata for new URLs (in parallel)
+      const previews = await Promise.all(
+        newUrls.map(async (url) => {
+          try {
+            const metadata = await extractMetadata(url);
+            return {
+              url,
+              title: metadata.title || url,
+              description: metadata.description || null,
+              already_saved: false,
+            };
+          } catch {
+            return { url, title: url, description: null, already_saved: false };
+          }
+        })
+      );
+
+      const lines = previews.map(
+        (p, i) =>
+          `${i + 1}. ${p.title}\n   ${p.url}${p.description ? `\n   ${p.description.slice(0, 120)}` : ""}`
+      );
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `found ${newUrls.length} new link${newUrls.length !== 1 ? "s" : ""}:\n\n${lines.join("\n\n")}\n\nask the user which ones to shout, then call shout_save_link for each.`,
+          },
+        ],
+      };
+    }
+  );
+
+  // shout_generate_digest - generate a weekly digest from recent shouts
+  server.tool(
+    "shout_generate_digest",
+    "generate a digest summary from recent shouts. returns markdown suitable for a blog post or email. also stores the digest in the digests table.",
+    {
+      user_id: z.string().uuid().describe("the user's id"),
+      days: z
+        .number()
+        .optional()
+        .default(7)
+        .describe("number of days to include (default 7)"),
+    },
+    async ({ user_id, days }) => {
+      const since = new Date(
+        Date.now() - (days || 7) * 24 * 60 * 60 * 1000
+      ).toISOString();
+
+      const { data: shouts } = await supabase
+        .from("shouts")
+        .select("url, title, summary, user_take, tags, category, created_at")
+        .eq("user_id", user_id)
+        .gte("created_at", since)
+        .order("created_at", { ascending: true });
+
+      if (!shouts || shouts.length === 0) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `no shouts in the last ${days} days.`,
+            },
+          ],
+        };
+      }
+
+      const { data: profile } = await supabase
+        .from("profiles")
+        .select("username, display_name")
+        .eq("id", user_id)
+        .single();
+
+      const name =
+        (profile as any)?.display_name ||
+        (profile as any)?.username ||
+        "someone";
+
+      // build the digest content
+      const categories = new Map<string, typeof shouts>();
+      for (const s of shouts) {
+        const cat = (s as any).category || "uncategorized";
+        if (!categories.has(cat)) categories.set(cat, []);
+        categories.get(cat)!.push(s);
+      }
+
+      let markdown = `# ${name}'s weekly shouts\n\n`;
+      markdown += `*${shouts.length} links from the last ${days} days*\n\n`;
+
+      for (const [cat, items] of categories) {
+        markdown += `## ${cat}\n\n`;
+        for (const s of items) {
+          markdown += `**[${(s as any).title || (s as any).url}](${(s as any).url})**\n`;
+          if ((s as any).summary)
+            markdown += `${(s as any).summary}\n`;
+          if ((s as any).user_take)
+            markdown += `> ${(s as any).user_take}\n`;
+          markdown += `\n`;
+        }
+      }
+
+      // store digest in supabase
+      const { error: digestError } = await supabase.from("digests").insert({
+        user_id,
+        period_start: since,
+        period_end: new Date().toISOString(),
+        content: markdown,
+        shout_count: shouts.length,
+      });
+
+      // don't fail if digests table doesn't exist yet
+      if (digestError) {
+        console.error("digest storage failed (table may not exist):", digestError.message);
+      }
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: markdown,
+          },
+        ],
+      };
+    }
+  );
+
+  // shout_list - list user's shouts with optional filters
+  server.tool(
+    "shout_list",
+    "list your saved shouts. filter by tag, collection, or limit results.",
+    {
+      user_id: z.string().uuid().describe("the user's id"),
+      filter: z
+        .string()
+        .optional()
+        .describe("filter by tag name"),
+      collection: z
+        .string()
+        .optional()
+        .describe("filter by collection slug"),
+      limit: z
+        .number()
+        .optional()
+        .default(20)
+        .describe("max results to return"),
+    },
+    async ({ user_id, filter, collection, limit }) => {
+      let query = supabase
+        .from("shouts")
+        .select("*")
+        .eq("user_id", user_id)
+        .order("created_at", { ascending: false })
+        .limit(limit || 20);
+
+      // filter by tag (postgres array contains)
+      if (filter) {
+        query = query.contains("tags", [filter]);
+      }
+
+      // filter by collection slug
+      if (collection) {
+        const { data: col } = await supabase
+          .from("collections")
+          .select("id")
+          .eq("user_id", user_id)
+          .eq("slug", collection)
+          .single();
+        if (col) {
+          query = query.eq("collection_id", col.id);
+        }
+      }
+
+      const { data, error } = await query;
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error listing shouts: ${error.message}` },
+          ],
+        };
+      }
+
+      if (!data || data.length === 0) {
+        return {
+          content: [{ type: "text" as const, text: "no shouts found." }],
+        };
+      }
+
+      const lines = data.map(
+        (s: any, i: number) =>
+          `${i + 1}. ${s.title || s.url}\n   ${s.summary || ""}\n   tags: ${(s.tags || []).join(", ")} | ${s.visibility} | ${s.created_at}`
+      );
+
+      return {
+        content: [
+          { type: "text" as const, text: `${data.length} shouts:\n\n${lines.join("\n\n")}` },
+        ],
+      };
+    }
+  );
+
+  // shout_remove - delete a shout by id
+  server.tool(
+    "shout_remove",
+    "delete a shout by its id.",
+    {
+      id: z.string().uuid().describe("the shout id to delete"),
+      user_id: z.string().uuid().describe("the user's id"),
+    },
+    async ({ id, user_id }) => {
+      const { error } = await supabase
+        .from("shouts")
+        .delete()
+        .eq("id", id)
+        .eq("user_id", user_id);
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error removing shout: ${error.message}` },
+          ],
+        };
+      }
+
+      return {
+        content: [{ type: "text" as const, text: `shout ${id} removed.` }],
+      };
+    }
+  );
+}