nod-shout 0.1.0

package/src/tools/posts.ts

@@ -0,0 +1,264 @@
+import { z } from "zod";
+import { supabase } from "../lib/supabase.js";
+import { filterPII, filterShoutContentFull } from "../lib/content-filter.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+async function publishDraft(draftId: string, userId: string, text: string, tags: string[], category: string | null, collectionId: string | null, visibility: string) {
+  // PII filter runs again on publish (hard constraint)
+  const filtered = await filterShoutContentFull({ take: text, skipLLMForMetadata: true });
+
+  if (filtered.blocked) {
+    // update draft status to rejected with reason
+    await supabase.from("draft_posts").update({
+      status: "rejected",
+      filter_report: filtered.blockReason,
+      updated_at: new Date().toISOString(),
+    }).eq("id", draftId);
+    return { published: false, reason: filtered.blockReason };
+  }
+
+  const finalText = filtered.take || text;
+
+  // insert into shouts
+  const { data: shout, error: shoutErr } = await supabase
+    .from("shouts")
+    .insert({
+      user_id: userId,
+      url: null,
+      title: null,
+      description: finalText,
+      summary: finalText,
+      user_take: finalText,
+      image_url: null,
+      tags,
+      category,
+      collection_id: collectionId,
+      source: "agent_post",
+      visibility,
+      shout_type: "post",
+      draft_id: draftId,
+    })
+    .select()
+    .single();
+
+  if (shoutErr) {
+    return { published: false, reason: `db error: ${shoutErr.message}` };
+  }
+
+  // update draft status
+  await supabase.from("draft_posts").update({
+    status: "published",
+    published_shout_id: shout.id,
+    filtered_text: finalText,
+    filter_report: filtered.filterReport,
+    updated_at: new Date().toISOString(),
+  }).eq("id", draftId);
+
+  return { published: true, shoutId: shout.id, text: finalText };
+}
+
+export function registerPostTools(server: McpServer) {
+  // shout_draft_post — create a text post draft
+  server.tool(
+    "shout_draft_post",
+    "draft a text post for a shout page. runs PII filter. saved as pending unless auto-publish is on.",
+    {
+      user_id: z.string().uuid().describe("the user's id"),
+      text: z.string().max(500).describe("post content, max 500 chars"),
+      tags: z.array(z.string()).optional().describe("tags for the post"),
+      category: z.string().optional().describe("category"),
+      collection: z.string().optional().describe("collection slug"),
+      visibility: z.enum(["public", "private", "unlisted"]).optional().default("public"),
+    },
+    async ({ user_id, text, tags, category, collection, visibility }) => {
+      // layer 1: regex PII filter
+      const regexResult = filterPII(text);
+
+      // resolve collection
+      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();
+        if (col) collection_id = col.id;
+      }
+
+      // create draft
+      const { data: draft, error } = await supabase
+        .from("draft_posts")
+        .insert({
+          user_id,
+          text: regexResult.text,
+          filtered_text: regexResult.text,
+          tags: tags || [],
+          category: category || null,
+          collection_id,
+          visibility: visibility || "public",
+          status: "pending",
+          filter_report: regexResult.filtered ? `regex: ${regexResult.removals.join(", ")}` : null,
+          source: "agent",
+        })
+        .select()
+        .single();
+
+      if (error) {
+        return { content: [{ type: "text" as const, text: `error creating draft: ${error.message}` }] };
+      }
+
+      // check auto-publish setting
+      const { data: settings } = await supabase
+        .from("user_settings")
+        .select("auto_publish")
+        .eq("user_id", user_id)
+        .single();
+
+      if (settings?.auto_publish) {
+        const result = await publishDraft(
+          draft.id, user_id, regexResult.text, tags || [], category || null, collection_id, visibility || "public"
+        );
+        if (result.published) {
+          return { content: [{ type: "text" as const, text: `auto-published post: "${result.text}" (shout id: ${result.shoutId})` }] };
+        } else {
+          return { content: [{ type: "text" as const, text: `auto-publish blocked by content filter: ${result.reason}` }] };
+        }
+      }
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: `draft created (id: ${draft.id}). status: pending approval.${regexResult.filtered ? ` PII filter applied: ${regexResult.removals.join(", ")}` : ""}\n\ntext: "${regexResult.text}"`,
+        }],
+      };
+    }
+  );
+
+  // shout_list_drafts — list draft posts
+  server.tool(
+    "shout_list_drafts",
+    "list draft posts by status. defaults to pending.",
+    {
+      user_id: z.string().uuid().describe("the user's id"),
+      status: z.enum(["pending", "approved", "rejected", "published"]).optional().default("pending"),
+      limit: z.number().optional().default(20),
+    },
+    async ({ user_id, status, limit }) => {
+      const { data, error } = await supabase
+        .from("draft_posts")
+        .select("*")
+        .eq("user_id", user_id)
+        .eq("status", status || "pending")
+        .order("created_at", { ascending: false })
+        .limit(limit || 20);
+
+      if (error) {
+        return { content: [{ type: "text" as const, text: `error listing drafts: ${error.message}` }] };
+      }
+
+      if (!data || data.length === 0) {
+        return { content: [{ type: "text" as const, text: `no ${status || "pending"} drafts found.` }] };
+      }
+
+      const lines = data.map((d: any, i: number) =>
+        `${i + 1}. [${d.id}] "${d.text?.substring(0, 80)}${(d.text?.length || 0) > 80 ? "..." : ""}" (${d.status}, ${new Date(d.created_at).toLocaleDateString()})`
+      );
+
+      return { content: [{ type: "text" as const, text: `${data.length} ${status || "pending"} drafts:\n\n${lines.join("\n")}` }] };
+    }
+  );
+
+  // shout_approve_draft — approve, reject, or edit a draft
+  server.tool(
+    "shout_approve_draft",
+    "approve, reject, or edit a draft post. approved posts are published to the shout page.",
+    {
+      draft_id: z.string().uuid().describe("the draft post id"),
+      user_id: z.string().uuid().describe("the user's id (for auth)"),
+      action: z.enum(["approve", "reject", "edit"]).describe("action to take"),
+      edited_text: z.string().max(500).optional().describe("revised text if action is edit"),
+    },
+    async ({ draft_id, user_id, action, edited_text }) => {
+      // fetch draft
+      const { data: draft, error } = await supabase
+        .from("draft_posts")
+        .select("*")
+        .eq("id", draft_id)
+        .eq("user_id", user_id)
+        .single();
+
+      if (error || !draft) {
+        return { content: [{ type: "text" as const, text: `draft not found or access denied.` }] };
+      }
+
+      if (draft.status !== "pending") {
+        return { content: [{ type: "text" as const, text: `draft is already ${draft.status}, can't ${action}.` }] };
+      }
+
+      if (action === "reject") {
+        await supabase.from("draft_posts").update({
+          status: "rejected",
+          updated_at: new Date().toISOString(),
+        }).eq("id", draft_id);
+        return { content: [{ type: "text" as const, text: `draft rejected.` }] };
+      }
+
+      if (action === "edit") {
+        if (!edited_text) {
+          return { content: [{ type: "text" as const, text: `edited_text is required for edit action.` }] };
+        }
+        const regexResult = filterPII(edited_text);
+        await supabase.from("draft_posts").update({
+          text: regexResult.text,
+          filtered_text: regexResult.text,
+          filter_report: regexResult.filtered ? `regex: ${regexResult.removals.join(", ")}` : null,
+          updated_at: new Date().toISOString(),
+        }).eq("id", draft_id);
+        return { content: [{ type: "text" as const, text: `draft updated. text: "${regexResult.text}"${regexResult.filtered ? ` (PII filtered: ${regexResult.removals.join(", ")})` : ""}` }] };
+      }
+
+      // approve → publish
+      const result = await publishDraft(
+        draft_id, user_id, draft.text, draft.tags || [], draft.category, draft.collection_id, draft.visibility
+      );
+
+      if (result.published) {
+        return { content: [{ type: "text" as const, text: `published! shout id: ${result.shoutId}\ntext: "${result.text}"` }] };
+      } else {
+        return { content: [{ type: "text" as const, text: `publish blocked by content filter: ${result.reason}` }] };
+      }
+    }
+  );
+
+  // shout_set_auto_publish — toggle auto-publish
+  server.tool(
+    "shout_set_auto_publish",
+    "enable or disable auto-publish for agent posts. PII filter always runs regardless.",
+    {
+      user_id: z.string().uuid().describe("the user's id"),
+      enabled: z.boolean().describe("true to enable auto-publish, false to disable"),
+      filter_level: z.enum(["strict", "standard"]).optional().default("strict"),
+    },
+    async ({ user_id, enabled, filter_level }) => {
+      const { error } = await supabase
+        .from("user_settings")
+        .upsert({
+          user_id,
+          auto_publish: enabled,
+          auto_publish_filter_level: filter_level || "strict",
+        }, { onConflict: "user_id" });
+
+      if (error) {
+        return { content: [{ type: "text" as const, text: `error updating settings: ${error.message}` }] };
+      }
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: `auto-publish ${enabled ? "enabled" : "disabled"}. filter level: ${filter_level || "strict"}. PII filter always runs.`,
+        }],
+      };
+    }
+  );
+}

package/src/tools/settings.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// in-memory settings store for v1
+// TODO: persist to supabase user_settings table
+const userSettings: Map<string, Record<string, unknown>> = new Map();
+
+export function registerSettingsTools(server: McpServer) {
+  // shout_settings - configure behavior
+  server.tool(
+    "shout_settings",
+    "configure your shout behavior preferences.",
+    {
+      user_id: z.string().uuid().describe("the user's id"),
+      auto_detect: z
+        .boolean()
+        .optional()
+        .describe("auto-detect links in conversation"),
+      default_visibility: z
+        .enum(["public", "private", "unlisted"])
+        .optional()
+        .describe("default visibility for new shouts"),
+      digest_frequency: z
+        .enum(["daily", "weekly", "monthly", "never"])
+        .optional()
+        .describe("how often to generate digests"),
+    },
+    async ({ user_id, auto_detect, default_visibility, digest_frequency }) => {
+      const current = userSettings.get(user_id) || {
+        auto_detect: true,
+        default_visibility: "public",
+        digest_frequency: "weekly",
+      };
+
+      if (auto_detect !== undefined) current.auto_detect = auto_detect;
+      if (default_visibility !== undefined)
+        current.default_visibility = default_visibility;
+      if (digest_frequency !== undefined)
+        current.digest_frequency = digest_frequency;
+
+      userSettings.set(user_id, current);
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `settings updated:\n- auto_detect: ${current.auto_detect}\n- default_visibility: ${current.default_visibility}\n- digest_frequency: ${current.digest_frequency}`,
+          },
+        ],
+      };
+    }
+  );
+
+  // shout_generate_digest is registered in links.ts
+}

package/src/tools/shout_agent_curate.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { supabase } from "../lib/supabase.js";
+import { extractMetadata } from "../lib/metadata.js";
+import { generateSummary } from "../lib/ai.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+export const shoutAgentCurateSchema = z.object({
+  url: z.string().url().describe("The URL to save"),
+  agent_take: z
+    .string()
+    .optional()
+    .describe("The agent's own commentary or opinion on why this link is interesting"),
+  tags: z
+    .array(z.string())
+    .optional()
+    .describe("Override auto-generated tags with these tags"),
+  collection_id: z
+    .string()
+    .uuid()
+    .optional()
+    .describe("Put the shout in a specific collection by ID"),
+  user_id: z.string().uuid().describe("The user's profile ID (fubz)"),
+});
+
+export type ShoutAgentCurateInput = z.infer<typeof shoutAgentCurateSchema>;
+
+export async function shoutAgentCurate(input: ShoutAgentCurateInput) {
+  // 1. Fetch metadata
+  const meta = await extractMetadata(input.url);
+
+  // 2. AI summary + tags + category (all returned from generateSummary)
+  const aiResult = await generateSummary({
+    url: input.url,
+    title: meta.title,
+    description: meta.description,
+    bodyText: meta.bodyText,
+    userContext: input.agent_take ?? null,
+  });
+
+  const tags = input.tags ?? aiResult.tags;
+  const category = aiResult.category;
+  const summary = aiResult.summary;
+
+  // 3. PII filter before saving
+  const { filterShoutContent } = await import("../lib/content-filter.js");
+  const filtered = filterShoutContent({
+    take: input.agent_take ?? null,
+    summary,
+    title: meta.title,
+    description: meta.description,
+  });
+  if (filtered.filterReport) {
+    console.log(`[nod-shout] agent curate filter: ${filtered.filterReport}`);
+  }
+
+  // 4. Insert shout with source "agent_curated"
+  const { data, error } = await supabase
+    .from("shouts")
+    .insert({
+      user_id: input.user_id,
+      url: input.url,
+      title: filtered.title,
+      description: filtered.description,
+      summary: filtered.summary,
+      user_take: filtered.take,
+      image_url: meta.image_url,
+      tags,
+      category,
+      collection_id: input.collection_id ?? null,
+      source: "agent_curated",
+      agent_context: input.agent_take ? `Agent curated: ${input.agent_take}` : "Agent curated link",
+      visibility: "public",
+    })
+    .select()
+    .single();
+
+  if (error) throw new Error(`Failed to save agent-curated shout: ${error.message}`);
+
+  return {
+    message: `Agent curated! "${meta.title}" saved.`,
+    shout: data,
+  };
+}
+
+export function registerAgentCurateTools(server: McpServer) {
+  server.tool(
+    "shout_agent_curate",
+    "Save a link to the agent's shout page. Use this when you find an interesting link worth sharing — from conversations, research, or browsing. The agent curates its own page.",
+    shoutAgentCurateSchema.shape,
+    async (params) => {
+      const result = await shoutAgentCurate(params as ShoutAgentCurateInput);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+}

package/src/tools/social.ts

@@ -0,0 +1,206 @@
+import { z } from "zod";
+import { supabase } from "../lib/supabase.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+export function registerSocialTools(server: McpServer) {
+  // shout_follow - subscribe to a user's shouts
+  server.tool(
+    "shout_follow",
+    "follow another user's shouts. optionally follow a specific collection.",
+    {
+      user_id: z.string().uuid().describe("your user id"),
+      username: z.string().describe("username to follow"),
+      collection: z
+        .string()
+        .optional()
+        .describe("specific collection slug to follow"),
+    },
+    async ({ user_id, username, collection }) => {
+      // resolve username to user id
+      const { data: profile } = await supabase
+        .from("profiles")
+        .select("id")
+        .eq("username", username)
+        .single();
+
+      if (!profile) {
+        return {
+          content: [
+            { type: "text" as const, text: `user "${username}" not found.` },
+          ],
+        };
+      }
+
+      // resolve collection if provided
+      let collection_id: string | null = null;
+      if (collection) {
+        const { data: col } = await supabase
+          .from("collections")
+          .select("id")
+          .eq("user_id", profile.id)
+          .eq("slug", collection)
+          .single();
+        collection_id = col?.id || null;
+      }
+
+      // check if already following
+      let existingQuery = supabase
+        .from("subscriptions")
+        .select("id")
+        .eq("follower_id", user_id)
+        .eq("following_id", profile.id);
+
+      if (collection_id) {
+        existingQuery = existingQuery.eq("collection_id", collection_id);
+      } else {
+        existingQuery = existingQuery.is("collection_id", null);
+      }
+
+      const { data: existing } = await existingQuery.single();
+
+      if (existing) {
+        return {
+          content: [
+            { type: "text" as const, text: `you're already following ${username}${collection ? ` (${collection})` : ""}.` },
+          ],
+        };
+      }
+
+      const { error } = await supabase.from("subscriptions").insert({
+        follower_id: user_id,
+        following_id: profile.id,
+        collection_id,
+      });
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error following: ${error.message}` },
+          ],
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `now following ${username}${collection ? ` (${collection})` : ""}!`,
+          },
+        ],
+      };
+    }
+  );
+
+  // shout_unfollow
+  server.tool(
+    "shout_unfollow",
+    "unfollow a user's shouts.",
+    {
+      user_id: z.string().uuid().describe("your user id"),
+      username: z.string().describe("username to unfollow"),
+    },
+    async ({ user_id, username }) => {
+      const { data: profile } = await supabase
+        .from("profiles")
+        .select("id")
+        .eq("username", username)
+        .single();
+
+      if (!profile) {
+        return {
+          content: [
+            { type: "text" as const, text: `user "${username}" not found.` },
+          ],
+        };
+      }
+
+      const { error } = await supabase
+        .from("subscriptions")
+        .delete()
+        .eq("follower_id", user_id)
+        .eq("following_id", profile.id);
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error unfollowing: ${error.message}` },
+          ],
+        };
+      }
+
+      return {
+        content: [
+          { type: "text" as const, text: `unfollowed ${username}.` },
+        ],
+      };
+    }
+  );
+
+  // shout_feed - aggregated feed from followed users
+  server.tool(
+    "shout_feed",
+    "get an aggregated feed of shouts from users you follow.",
+    {
+      user_id: z.string().uuid().describe("your user id"),
+      limit: z.number().optional().default(20).describe("max results"),
+    },
+    async ({ user_id, limit }) => {
+      // get list of followed user ids
+      const { data: subs } = await supabase
+        .from("subscriptions")
+        .select("following_id, collection_id")
+        .eq("follower_id", user_id);
+
+      if (!subs || subs.length === 0) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "you're not following anyone yet. use shout_follow to subscribe to someone's shouts.",
+            },
+          ],
+        };
+      }
+
+      const followingIds = subs.map((s: any) => s.following_id);
+
+      const { data, error } = await supabase
+        .from("shouts")
+        .select("*, profiles!inner(username, display_name)")
+        .in("user_id", followingIds)
+        .eq("visibility", "public")
+        .order("created_at", { ascending: false })
+        .limit(limit || 20);
+
+      if (error) {
+        return {
+          content: [
+            { type: "text" as const, text: `error fetching feed: ${error.message}` },
+          ],
+        };
+      }
+
+      if (!data || data.length === 0) {
+        return {
+          content: [
+            { type: "text" as const, text: "no shouts in your feed yet." },
+          ],
+        };
+      }
+
+      const lines = data.map((s: any, i: number) => {
+        const who = (s as any).profiles?.username || "unknown";
+        return `${i + 1}. @${who}: ${s.title || s.url}\n   ${s.summary || ""}\n   tags: ${(s.tags || []).join(", ")} | ${s.created_at}`;
+      });
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `feed (${data.length} shouts):\n\n${lines.join("\n\n")}`,
+          },
+        ],
+      };
+    }
+  );
+}

package/src/types.ts

@@ -0,0 +1,66 @@
+// shared types for nod-shout mcp server
+
+export interface Profile {
+  id: string;
+  username: string;
+  display_name: string | null;
+  bio: string | null;
+  avatar_url: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Shout {
+  id: string;
+  user_id: string;
+  url: string;
+  title: string | null;
+  description: string | null;
+  summary: string | null;
+  user_take: string | null;
+  image_url: string | null;
+  tags: string[] | null;
+  category: string | null;
+  collection_id: string | null;
+  source: string;
+  agent_context: string | null;
+  visibility: "public" | "private" | "unlisted";
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Collection {
+  id: string;
+  user_id: string;
+  name: string;
+  description: string | null;
+  slug: string;
+  visibility: "public" | "private" | "unlisted";
+  auto_rules: Record<string, unknown> | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Subscription {
+  id: string;
+  follower_id: string;
+  following_id: string;
+  collection_id: string | null;
+  notify: boolean;
+  created_at: string;
+}
+
+export interface PageMetadata {
+  title: string | null;
+  description: string | null;
+  image_url: string | null;
+  author: string | null;
+  date: string | null;
+  bodyText: string | null;
+}
+
+export interface AISummaryResult {
+  summary: string;
+  tags: string[];
+  category: string;
+}

package/supabase/.temp/cli-latest

@@ -0,0 +1 @@
+v2.78.1

package/supabase/.temp/gotrue-version

@@ -0,0 +1 @@
+v2.188.1

package/supabase/.temp/pooler-url

@@ -0,0 +1 @@
+postgresql://postgres.ooykzbkcquvreeheaijy@aws-1-us-east-1.pooler.supabase.com:5432/postgres

package/supabase/.temp/postgres-version

@@ -0,0 +1 @@
+17.6.1.084

package/supabase/.temp/project-ref

@@ -0,0 +1 @@
+ooykzbkcquvreeheaijy