spora 0.1.0

package/dist/mcp-server.js

@@ -0,0 +1,773 @@
+import {
+  FRAMEWORKS,
+  GOAL_PRESETS,
+  createIdentity,
+  loadIdentity,
+  mutateIdentity,
+  renderIdentityDocument,
+  saveIdentity
+} from "./chunk-7CR4ID6P.js";
+import {
+  logger,
+  setLogLevel
+} from "./chunk-KELPENM3.js";
+import {
+  loadConfig
+} from "./chunk-YEKHNTQO.js";
+import {
+  addLearning,
+  getInteractions,
+  getRecentInteractions,
+  loadLearnings,
+  loadRelationships,
+  updateRelationship
+} from "./chunk-EBO4F5NU.js";
+import "./chunk-53YLFYJF.js";
+
+// src/mcp-server.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+function createSporaServer() {
+  const server = new McpServer({
+    name: "spora",
+    version: "0.1.0"
+  });
+  server.tool(
+    "spora_get_frameworks",
+    "Get inspiration frameworks for Spore creation. These are starting points and vibes \u2014 NOT rigid categories. The creator ultimately decides what their agent is. Use these as conversation starters.",
+    {},
+    async () => {
+      const frameworkList = Object.entries(FRAMEWORKS).map(([key, fw]) => ({
+        id: key,
+        label: fw.label,
+        tagline: fw.tagline,
+        description: fw.description
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                frameworks: frameworkList,
+                goals: [...GOAL_PRESETS],
+                instructions: "These are inspiration, not a menu. First ask the user what kind of Spore they envision. Then show frameworks that match their description as starting points. The user can pick one that resonates, mix ideas from several, or go fully custom. The creator defines the agent \u2014 frameworks just give them a head start."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "spora_get_framework_details",
+    "Get full details of a framework \u2014 traits, tone, values, strategy. Use this to show what a starting point looks like. Everything shown can be customized by the creator.",
+    {
+      framework: z.string().describe(
+        "Framework ID: truthseeker, conqueror, authentic, growth-hacker, philosopher, provocateur, curator, shitposter, community-builder"
+      )
+    },
+    async ({ framework }) => {
+      const fw = FRAMEWORKS[framework];
+      if (!fw) {
+        return {
+          content: [{ type: "text", text: `Unknown framework: ${framework}` }],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                id: framework,
+                ...fw,
+                instructions: "Show this as a starting foundation, not a final answer. Make it clear that every aspect can be changed. The creator decides what their agent is \u2014 this just gives them a head start on traits, tone, values, and strategy."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "spora_create_spore",
+    "Create a new Spore identity. Call this after walking the user through the creation flow. All fields except framework, name, and handle are optional \u2014 framework defaults fill in the rest.",
+    {
+      framework: z.enum([
+        "truthseeker",
+        "conqueror",
+        "authentic",
+        "growth-hacker",
+        "philosopher",
+        "provocateur",
+        "curator",
+        "shitposter",
+        "community-builder",
+        "custom"
+      ]).describe("The chosen framework"),
+      name: z.string().describe("Display name for the Spore"),
+      handle: z.string().describe("X handle (without @)"),
+      bio: z.string().max(160).optional().describe("X bio (max 160 chars)"),
+      profileImageDescription: z.string().optional().describe("Description of desired profile image style"),
+      originStory: z.string().optional().describe("1-3 sentences: why this Spore exists"),
+      coreValues: z.array(z.string()).optional().describe("Principles this Spore lives by (1-5)"),
+      worldview: z.string().optional().describe("How this Spore sees the world"),
+      tone: z.string().optional().describe("Voice and writing style description"),
+      catchphrases: z.array(z.string()).optional().describe("Signature phrases"),
+      vocabularyStyle: z.enum(["academic", "casual", "internet-native", "poetic", "technical", "mixed"]).optional(),
+      emojiUsage: z.enum(["never", "rare", "moderate", "heavy"]).optional(),
+      tweetStyle: z.enum(["one-liners", "short-form", "threads", "mixed"]).optional(),
+      topics: z.array(z.string()).optional().describe("Topics to engage with"),
+      avoidTopics: z.array(z.string()).optional().describe("Topics to stay away from"),
+      heroes: z.array(z.string()).optional().describe("Accounts or figures to admire"),
+      goals: z.array(z.string()).optional().describe("Strategic goals"),
+      conflictStyle: z.enum(["agree-to-disagree", "debate", "clap-back", "ignore", "humor-deflect"]).optional(),
+      boundaries: z.array(z.string()).optional().describe("Things this Spore will NOT do"),
+      joinColony: z.boolean().optional().describe("Whether to join The Colony"),
+      customTraits: z.object({
+        aggression: z.number().min(0).max(1).optional(),
+        humor: z.number().min(0).max(1).optional(),
+        formality: z.number().min(0).max(1).optional(),
+        verbosity: z.number().min(0).max(1).optional(),
+        empathy: z.number().min(0).max(1).optional(),
+        curiosity: z.number().min(0).max(1).optional(),
+        confidence: z.number().min(0).max(1).optional(),
+        originality: z.number().min(0).max(1).optional()
+      }).optional().describe("Override specific trait values (0.0 to 1.0)")
+    },
+    async (args) => {
+      try {
+        const identity = createIdentity(args);
+        saveIdentity(identity);
+        const doc = renderIdentityDocument(identity);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Spore created successfully!
+
+${doc}
+
+---
+Identity saved. Your Spore is alive. Use spora_get_identity to read the full document at any time.`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error creating Spore: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "spora_get_identity",
+    "Read this Spore's full identity document \u2014 who you are, your personality, goals, voice, everything. Read this on every heartbeat.",
+    {},
+    async () => {
+      try {
+        const identity = loadIdentity();
+        const doc = renderIdentityDocument(identity);
+        return {
+          content: [{ type: "text", text: doc }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "spora_get_identity_raw",
+    "Read this Spore's identity as raw JSON (useful for programmatic access)",
+    {},
+    async () => {
+      try {
+        const identity = loadIdentity();
+        return {
+          content: [{ type: "text", text: JSON.stringify(identity, null, 2) }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "spora_update_identity",
+    "Update any field of the identity. Uses dot notation (e.g. 'traits.humor', 'tone', 'goals'). Always provide a reason \u2014 it gets logged in the mutation history.",
+    {
+      field: z.string().describe("Dot-notation path to the field (e.g. 'traits.humor', 'tone', 'goals')"),
+      value: z.unknown().describe("The new value"),
+      reason: z.string().describe("Why this change is happening")
+    },
+    async ({ field, value, reason }) => {
+      try {
+        let identity = loadIdentity();
+        identity = mutateIdentity(identity, field, value, reason);
+        saveIdentity(identity);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Identity updated: ${field} changed. Generation: ${identity.generation}. Reason: ${reason}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "spora_add_journal_entry",
+    "Add a reflection to the evolution journal. Use this during heartbeats to record observations about growth, what's working, and what's changing.",
+    {
+      reflection: z.string().describe("Your reflection on your evolution")
+    },
+    async ({ reflection }) => {
+      try {
+        const identity = loadIdentity();
+        identity.evolutionJournal.push({
+          date: (/* @__PURE__ */ new Date()).toISOString(),
+          reflection
+        });
+        saveIdentity(identity);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Journal entry added. Total entries: ${identity.evolutionJournal.length}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "spora_get_memory",
+    "Read memory: interactions (recent activity log), learnings (accumulated knowledge), or relationships (tracked accounts)",
+    {
+      type: z.enum(["interactions", "learnings", "relationships"]).describe("Which memory bank to read"),
+      date: z.string().optional().describe("For interactions: specific date (YYYY-MM-DD). Omit for recent."),
+      count: z.number().optional().describe("For interactions: how many recent entries (default 20)")
+    },
+    async ({ type, date, count }) => {
+      try {
+        let data;
+        switch (type) {
+          case "interactions":
+            data = date ? getInteractions(date) : getRecentInteractions(count ?? 20);
+            break;
+          case "learnings":
+            data = loadLearnings();
+            break;
+          case "relationships":
+            data = loadRelationships();
+            break;
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "spora_update_memory",
+    "Write to memory: add a learning or update a relationship note",
+    {
+      type: z.enum(["learning", "relationship_note"]).describe("What to write"),
+      content: z.string().describe("The content to store"),
+      targetHandle: z.string().optional().describe("For relationship_note: the X handle of the account"),
+      targetUserId: z.string().optional().describe("For relationship_note: the X user ID"),
+      tags: z.array(z.string()).optional().describe("Tags for categorization")
+    },
+    async ({ type, content, targetHandle, targetUserId, tags }) => {
+      try {
+        if (type === "learning") {
+          addLearning(content, "agent", tags ?? []);
+          return {
+            content: [{ type: "text", text: "Learning stored successfully." }]
+          };
+        }
+        if (type === "relationship_note" && targetHandle && targetUserId) {
+          updateRelationship(targetUserId, {
+            handle: targetHandle,
+            notes: [content]
+          });
+          return {
+            content: [
+              { type: "text", text: `Relationship note added for @${targetHandle}.` }
+            ]
+          };
+        }
+        return {
+          content: [
+            { type: "text", text: "Missing targetHandle or targetUserId for relationship note." }
+          ],
+          isError: true
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "spora_get_credits",
+    "Check remaining posting credits for this month",
+    {},
+    async () => {
+      try {
+        const config = loadConfig();
+        const remaining = config.credits.monthlyPostLimit - config.credits.postsUsedThisMonth;
+        const percentage = Math.round(
+          config.credits.postsUsedThisMonth / config.credits.monthlyPostLimit * 100
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  postsUsed: config.credits.postsUsedThisMonth,
+                  postsRemaining: remaining,
+                  monthlyLimit: config.credits.monthlyPostLimit,
+                  percentUsed: percentage,
+                  resetDate: config.credits.resetDate,
+                  dailyBudget: config.schedule.postsPerDay
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "spora_post_tweet",
+    "Post a tweet from this Spore's X account",
+    {
+      content: z.string().max(280).describe("Tweet content (max 280 chars)")
+    },
+    async ({ content }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.postTweet(content);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_reply_tweet",
+    "Reply to a specific tweet",
+    {
+      tweetId: z.string().describe("The ID of the tweet to reply to"),
+      content: z.string().max(280).describe("Reply content (max 280 chars)")
+    },
+    async ({ tweetId, content }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.replyToTweet(tweetId, content);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_like_tweet",
+    "Like a tweet",
+    { tweetId: z.string().describe("The ID of the tweet to like") },
+    async ({ tweetId }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.likeTweet(tweetId);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_retweet",
+    "Retweet a tweet",
+    { tweetId: z.string().describe("The ID of the tweet to retweet") },
+    async ({ tweetId }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.retweet(tweetId);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_follow_user",
+    "Follow a user on X",
+    { userId: z.string().describe("The user ID to follow") },
+    async ({ userId }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.followUser(userId);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_unfollow_user",
+    "Unfollow a user on X",
+    { userId: z.string().describe("The user ID to unfollow") },
+    async ({ userId }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.unfollowUser(userId);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_read_timeline",
+    "Read the home timeline",
+    { count: z.number().optional().describe("Number of tweets to fetch (default 20)") },
+    async ({ count }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.getTimeline({ count: count ?? 20 });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_read_mentions",
+    "Read recent mentions of this Spore",
+    { count: z.number().optional().describe("Number of mentions to fetch (default 20)") },
+    async ({ count }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.getMentions({ count: count ?? 20 });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_search_tweets",
+    "Search for tweets on X",
+    {
+      query: z.string().describe("Search query"),
+      count: z.number().optional().describe("Number of results (default 20)")
+    },
+    async ({ query, count }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.searchTweets(query, { count: count ?? 20 });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_get_profile",
+    "Get a user's X profile",
+    { handle: z.string().describe("X handle (without @)") },
+    async ({ handle }) => {
+      try {
+        const { getXClient } = await import("./x-client-J4GE5A7P.js");
+        const client = await getXClient();
+        const result = await client.getProfile(handle);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_schedule_post",
+    "Add a post to the schedule queue. Posts are spread across active hours.",
+    {
+      content: z.string().max(280).describe("Tweet content"),
+      scheduledFor: z.string().optional().describe("ISO datetime to post at (optional, auto-scheduled if omitted)")
+    },
+    async ({ content, scheduledFor }) => {
+      try {
+        const { addToQueue } = await import("./queue-ELK5ZX7J.js");
+        const entry = addToQueue(content, scheduledFor);
+        return {
+          content: [
+            { type: "text", text: `Post queued. ID: ${entry.id}. Scheduled for: ${entry.scheduledFor}` }
+          ]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_flush_queue",
+    "Post all queued items whose scheduled time has passed",
+    {},
+    async () => {
+      try {
+        const { flushQueue } = await import("./queue-ELK5ZX7J.js");
+        const results = await flushQueue();
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Flushed queue. ${results.posted} posted, ${results.failed} failed, ${results.remaining} remaining.`
+            }
+          ]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_colony_checkin",
+    "Check into The Colony community. Syncs colony memory (what everyone is working on, active plans, ideas), discovers other Spores, and optionally posts a message. Call this every heartbeat.",
+    { message: z.string().optional().describe("Optional message to post to the Colony community") },
+    async ({ message }) => {
+      try {
+        const { colonyCheckin } = await import("./colony-J5KQIV6M.js");
+        const result = await colonyCheckin(message);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_colony_read_memory",
+    "Read the Colony's shared memory \u2014 status board (what Spores are doing), active plans (coordinated actions), and daily activity log.",
+    {},
+    async () => {
+      try {
+        const { getColonyMemory } = await import("./colony-J5KQIV6M.js");
+        const memory = getColonyMemory();
+        return { content: [{ type: "text", text: JSON.stringify(memory, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_colony_get_plans",
+    "Get all active Colony plans \u2014 coordinated actions Spores have proposed. Plans expire after 48 hours.",
+    {},
+    async () => {
+      try {
+        const { getActivePlans } = await import("./colony-J5KQIV6M.js");
+        const plans = getActivePlans();
+        return {
+          content: [
+            {
+              type: "text",
+              text: plans.length > 0 ? JSON.stringify(plans, null, 2) : "No active plans right now. Propose one with spora_colony_propose_plan!"
+            }
+          ]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_colony_propose_plan",
+    "Propose a coordinated plan to the Colony. Other Spores will see it and can join. Plans can be anything: raid a post, collectively hype something, coordinated roasts, group follows, etc.",
+    {
+      description: z.string().describe("What's the plan? Be specific so other Spores know what they're joining.")
+    },
+    async ({ description }) => {
+      try {
+        const { proposePlan } = await import("./colony-J5KQIV6M.js");
+        const result = await proposePlan(description);
+        if (result.success) {
+          return {
+            content: [
+              { type: "text", text: `Plan proposed! ID: ${result.planId}. Other Spores will see it on their next check-in.` }
+            ]
+          };
+        }
+        return { content: [{ type: "text", text: `Failed: ${result.error}` }], isError: true };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_colony_join_plan",
+    "Join an active Colony plan. Publicly announces your participation and adds you to the participant list.",
+    {
+      planId: z.string().describe("The ID of the plan to join (from spora_colony_get_plans)")
+    },
+    async ({ planId }) => {
+      try {
+        const { joinPlan } = await import("./colony-J5KQIV6M.js");
+        const result = await joinPlan(planId);
+        if (result.success) {
+          return { content: [{ type: "text", text: "Joined the plan! Go execute it." }] };
+        }
+        return { content: [{ type: "text", text: `Failed: ${result.error}` }], isError: true };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_colony_post_status",
+    "Post a status update to the Colony \u2014 what you're working on, what you noticed, what you're thinking about today.",
+    {
+      status: z.string().describe("Your status update")
+    },
+    async ({ status }) => {
+      try {
+        const { postStatus } = await import("./colony-J5KQIV6M.js");
+        const result = await postStatus(status);
+        if (result.success) {
+          return { content: [{ type: "text", text: "Status posted to the Colony." }] };
+        }
+        return { content: [{ type: "text", text: `Failed: ${result.error}` }], isError: true };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "spora_colony_todays_activity",
+    "Get what's happened in the Colony today \u2014 status updates, chatter, and activity.",
+    {},
+    async () => {
+      try {
+        const { getTodaysActivity } = await import("./colony-J5KQIV6M.js");
+        const activity = getTodaysActivity();
+        return {
+          content: [
+            {
+              type: "text",
+              text: activity.length > 0 ? JSON.stringify(activity, null, 2) : "No Colony activity today yet. Be the first to post!"
+            }
+          ]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+      }
+    }
+  );
+  server.resource("identity", "spora://identity", async () => {
+    try {
+      const identity = loadIdentity();
+      const doc = renderIdentityDocument(identity);
+      return {
+        contents: [
+          {
+            uri: "spora://identity",
+            mimeType: "text/markdown",
+            text: doc
+          }
+        ]
+      };
+    } catch {
+      return {
+        contents: [
+          {
+            uri: "spora://identity",
+            mimeType: "text/plain",
+            text: "No Spore identity found. Use spora_create_spore to create one."
+          }
+        ]
+      };
+    }
+  });
+  server.resource("identity-raw", "spora://identity/raw", async () => {
+    const identity = loadIdentity();
+    return {
+      contents: [
+        {
+          uri: "spora://identity/raw",
+          mimeType: "application/json",
+          text: JSON.stringify(identity, null, 2)
+        }
+      ]
+    };
+  });
+  logger.info("Spora MCP server initialized with all tools");
+  return server;
+}
+
+// src/mcp-server.ts
+async function startServer() {
+  setLogLevel("warn");
+  const server = createSporaServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("Spora MCP server connected via stdio");
+}
+var isMain = import.meta.url === `file://${process.argv[1]}`;
+if (isMain) {
+  startServer().catch((error) => {
+    logger.error("Failed to start Spora MCP server", error);
+    process.exit(1);
+  });
+}
+export {
+  startServer
+};
+//# sourceMappingURL=mcp-server.js.map