@elixium.ai/mcp-server 0.1.0 → 0.1.1

package/README.md

@@ -0,0 +1,84 @@
+# Elixium MCP Server
+
+This server implements the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/), allowing AI agents (like Antigravity, Cursor, or Windsurf) to interact directly with your Elixium Board.
+
+## Features
+- **List Stories**: See the current backlog and icebox.
+- **Create Story**: Add new stories directly from your editor.
+- **Iteration Context**: Provide the AI with the full context of your Current and Backlog lanes for better planning.
+
+## Setup
+
+### 1. Install
+If you do not have the Elixium codebase, install the MCP server package:
+```bash
+npm install -g @elixium.ai/mcp-server
+```
+
+Air-gapped/offline install (download the `.tgz` from GitHub Releases first):
+```bash
+npm install -g /path/to/elixium.ai-mcp-server-0.1.0.tgz
+```
+
+If you are developing from source:
+```bash
+cd mcp-server
+npm install
+npm run build
+```
+
+### 2. Authentication (API Key)
+Elixium uses a secure, tenant-scoped API key system for external integrations.
+
+1.  **Request a Key**: Ask your Elixium administrator to create an API key in the `sys_api_keys` collection.
+2.  **Scope**: Each key is hardcoded to a specific `tenantId` in the database, ensuring your AI agent only has access to your workspace.
+3.  **Board Selection**: Optionally scope the MCP server to a single board by setting `ELIXIUM_BOARD_SLUG`.
+
+### 3. Configuration
+Add the following to your IDE's MCP configuration (e.g., `mcp_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "elixium": {
+      "command": "elixium-mcp-server",
+      "args": [],
+      "env": {
+        "ELIXIUM_API_KEY": "your_api_key_here",
+        "ELIXIUM_API_URL": "https://your-tenant-slug.elixium.ai/api",
+        "ELIXIUM_BOARD_SLUG": "main",
+        "ELIXIUM_LANE_STYLE": "upper"
+      }
+    }
+  }
+}
+```
+
+> [!IMPORTANT]
+> Always use your **Tenant Subdomain** in the `ELIXIUM_API_URL` (e.g., `https://indirecttek.elixium.ai/api`) to ensure the server correctly resolves your workspace context.
+>
+> If you set `ELIXIUM_BOARD_SLUG`, the MCP server will only read/write stories for that board.
+> The server resolves the board slug to a boardId on startup, so the slug must match an existing board.
+>
+> `ELIXIUM_LANE_STYLE` is optional. Use `upper` for APIs that store lanes as `CURRENT/BACKLOG`, or `title` for `Current/Backlog`. The server auto-detects when possible.
+>
+> If you built the MCP server from source, set `command` to `node` and `args`
+> to the absolute path of `dist/index.js`.
+
+## Usage
+Once configured, your AI agent will have access to tools like `list_stories` and `create_story`. You can use these to groom your backlog or generate implementation plans based on real-time board data.
+
+## Maintainers: build a clean release tarball (gh CLI)
+This package uses the `files` list in `package.json` to keep the tarball small.
+
+```bash
+cd mcp-server
+npm install
+npm run build
+npm pack
+```
+
+```bash
+gh release create mcp-server-v0.1.0 elixium.ai-mcp-server-0.1.0.tgz \
+  -t "MCP Server v0.1.0" -n "Air-gapped install artifact"
+```

package/dist/index.js

@@ -5,6 +5,8 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextpro
 import axios from "axios";
 const API_KEY = process.env.ELIXIUM_API_KEY;
 const API_URL = process.env.ELIXIUM_API_URL || "https://elixium.ai/api";
+const BOARD_SLUG = process.env.ELIXIUM_BOARD_SLUG;
+const LANE_STYLE_ENV = process.env.ELIXIUM_LANE_STYLE;
 if (!API_KEY) {
     console.error("Error: ELIXIUM_API_KEY environment variable is required");
     process.exit(1);
@@ -14,8 +16,142 @@ const client = axios.create({
     headers: {
         "x-api-key": API_KEY,
         "Content-Type": "application/json",
+        ...(BOARD_SLUG ? { "x-board-slug": BOARD_SLUG } : {}),
     },
 });
+const LANE_TITLE = {
+    backlog: "Backlog",
+    icebox: "Icebox",
+    current: "Current",
+    done: "Done",
+};
+const LANE_UPPER = {
+    backlog: "BACKLOG",
+    icebox: "ICEBOX",
+    current: "CURRENT",
+    done: "DONE",
+};
+const parseLaneStyle = (value) => {
+    if (!value)
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "upper")
+        return "upper";
+    if (normalized === "title")
+        return "title";
+    return null;
+};
+const inferLaneStyleFromUrl = (apiUrl) => {
+    try {
+        const host = new URL(apiUrl).hostname.toLowerCase();
+        if (host === "localhost" || host === "127.0.0.1" || host.endsWith(".local")) {
+            return "title";
+        }
+    }
+    catch {
+        // Fall through to default.
+    }
+    return "upper";
+};
+const normalizeLaneForComparison = (lane) => {
+    if (typeof lane !== "string")
+        return "";
+    return lane.trim().toLowerCase();
+};
+const extractStories = (data) => {
+    if (Array.isArray(data))
+        return data;
+    if (data?.stories && Array.isArray(data.stories))
+        return data.stories;
+    return [];
+};
+const extractEpics = (data) => {
+    if (Array.isArray(data))
+        return data;
+    if (data?.epics && Array.isArray(data.epics))
+        return data.epics;
+    return [];
+};
+const normalizeBoardSlug = (value) => {
+    if (!value)
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+};
+let cachedBoardId = null;
+let cachedBoardSlug = null;
+const resolveBoardId = async () => {
+    const slug = normalizeBoardSlug(BOARD_SLUG);
+    if (!slug)
+        return null;
+    if (cachedBoardSlug === slug && cachedBoardId)
+        return cachedBoardId;
+    const response = await client.get("/boards");
+    const boards = Array.isArray(response.data) ? response.data : [];
+    const match = boards.find((board) => {
+        if (typeof board?.slug !== "string")
+            return false;
+        return board.slug.trim().toLowerCase() === slug;
+    });
+    if (!match?.id) {
+        throw new Error(`Board slug "${BOARD_SLUG}" not found`);
+    }
+    cachedBoardSlug = slug;
+    cachedBoardId = match.id;
+    return cachedBoardId;
+};
+const fetchStories = async () => {
+    const boardId = await resolveBoardId();
+    const response = await client.get("/stories", {
+        params: boardId ? { boardId } : undefined,
+    });
+    return extractStories(response.data);
+};
+const fetchEpics = async () => {
+    const boardId = await resolveBoardId();
+    const response = await client.get("/epics", {
+        params: boardId ? { boardId } : undefined,
+    });
+    return extractEpics(response.data);
+};
+let cachedLaneStyle = null;
+const detectLaneStyle = async () => {
+    const envStyle = parseLaneStyle(LANE_STYLE_ENV);
+    if (envStyle)
+        return envStyle;
+    if (cachedLaneStyle)
+        return cachedLaneStyle;
+    try {
+        const stories = await fetchStories();
+        const sampleLane = stories.find((story) => typeof story?.lane === "string")
+            ?.lane;
+        if (sampleLane) {
+            cachedLaneStyle =
+                sampleLane.trim() === sampleLane.trim().toUpperCase()
+                    ? "upper"
+                    : "title";
+            return cachedLaneStyle;
+        }
+    }
+    catch {
+        // Fall back to URL-based inference.
+    }
+    cachedLaneStyle = inferLaneStyleFromUrl(API_URL);
+    return cachedLaneStyle;
+};
+const normalizeLane = async (lane) => {
+    if (!lane)
+        return undefined;
+    const style = await detectLaneStyle();
+    const key = lane.trim().toLowerCase();
+    const map = style === "upper" ? LANE_UPPER : LANE_TITLE;
+    return map[key] || (style === "upper" ? lane.trim().toUpperCase() : lane.trim());
+};
+const buildIterationContext = (stories, user = null) => {
+    const currentIteration = stories.filter((story) => normalizeLaneForComparison(story?.lane) === "current");
+    const backlog = stories.filter((story) => normalizeLaneForComparison(story?.lane) === "backlog");
+    return { currentIteration, backlog, user };
+};
 const server = new Server({
     name: "elixium-mcp-server",
     version: "0.1.0",
@@ -24,6 +160,7 @@ const server = new Server({
         tools: {},
     },
 });
+// Define Tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
@@ -41,22 +178,28 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 inputSchema: {
                     type: "object",
                     properties: {
-                        title: {
-                            type: "string",
-                            description: "Title of the story",
-                        },
+                        title: { type: "string", description: "Title of the story" },
                         description: {
                             type: "string",
                             description: "Description of the story",
                         },
                         lane: {
                             type: "string",
-                            description: "Lane to add the story to (BACKLOG, ICEBOX, CURRENT)",
-                            enum: ["BACKLOG", "ICEBOX", "CURRENT"],
+                            description: "Lane to add the story to (case-insensitive)",
+                            enum: [
+                                "Backlog",
+                                "Icebox",
+                                "Current",
+                                "Done",
+                                "BACKLOG",
+                                "ICEBOX",
+                                "CURRENT",
+                                "DONE",
+                            ],
                         },
                         points: {
                             type: "number",
-                            description: "Story points (0, 1, 2, 3, 5, 8)",
+                            description: "Points (0, 1, 2, 3, 5, 8)",
                         },
                     },
                     required: ["title"],
@@ -64,52 +207,335 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: "get_iteration_context",
-                description: "Get the current iteration context (current stories and backlog) for AI planning",
+                description: "Get the current iteration context (Current + Backlog) for AI planning",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "create_hypothesis",
+                description: "Create a new assumption/hypothesis in the Icebox",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "The assumption statement" },
+                        hypothesis: { type: "string", description: "Detailed hypothesis" },
+                        confidence_score: {
+                            type: "number",
+                            description: "Initial confidence (1-5)",
+                            minimum: 1,
+                            maximum: 5,
+                        },
+                    },
+                    required: ["title", "hypothesis", "confidence_score"],
+                },
+            },
+            {
+                name: "list_objectives",
+                description: "List objectives for the current workspace",
                 inputSchema: {
                     type: "object",
                     properties: {},
                 },
             },
+            {
+                name: "record_learning",
+                description: "Record a learning outcome for a completed story",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: { type: "string", description: "ID of the story" },
+                        outcome_summary: {
+                            type: "string",
+                            description: "What was learned?",
+                        },
+                    },
+                    required: ["storyId", "outcome_summary"],
+                },
+            },
+            {
+                name: "list_epics",
+                description: "List epics for the current board",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "create_epic",
+                description: "Create a new epic for the current board",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "Epic title" },
+                        description: { type: "string", description: "Epic description" },
+                        stage: {
+                            type: "string",
+                            description: "Roadmap stage",
+                            enum: ["in_progress", "next", "soon", "someday", "archived"],
+                        },
+                    },
+                    required: ["title"],
+                },
+            },
+            {
+                name: "update_epic",
+                description: "Update an epic (title, description, or stage)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        epicId: { type: "string", description: "ID of the epic" },
+                        title: { type: "string", description: "Epic title" },
+                        description: { type: "string", description: "Epic description" },
+                        stage: {
+                            type: "string",
+                            description: "Roadmap stage",
+                            enum: ["in_progress", "next", "soon", "someday", "archived"],
+                        },
+                    },
+                    required: ["epicId"],
+                },
+            },
+            {
+                name: "update_story",
+                description: "Update fields on an existing story",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: { type: "string", description: "ID of the story" },
+                        title: { type: "string", description: "Updated title" },
+                        description: { type: "string", description: "Updated description" },
+                        lane: {
+                            type: "string",
+                            description: "Lane to move the story to (case-insensitive)",
+                            enum: [
+                                "Backlog",
+                                "Icebox",
+                                "Current",
+                                "Done",
+                                "BACKLOG",
+                                "ICEBOX",
+                                "CURRENT",
+                                "DONE",
+                            ],
+                        },
+                        points: {
+                            type: "number",
+                            description: "Updated points (0, 1, 2, 3, 5, 8)",
+                        },
+                        state: {
+                            type: "string",
+                            description: "Story state (unstarted, started, finished, delivered, accepted, rejected)",
+                        },
+                        outcome_summary: {
+                            type: "string",
+                            description: "Learning outcome summary",
+                        },
+                    },
+                    required: ["storyId"],
+                },
+            },
+            {
+                name: "prepare_implementation",
+                description: "Fetch all context for a story and format an implementation brief",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story to prepare",
+                        },
+                    },
+                    required: ["storyId"],
+                },
+            },
         ],
     };
 });
+// Handle Requests
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         switch (request.params.name) {
             case "list_stories": {
-                const response = await client.get("/stories");
+                const stories = await fetchStories();
                 return {
                     content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response.data, null, 2),
-                        },
+                        { type: "text", text: JSON.stringify(stories, null, 2) },
                     ],
                 };
             }
             case "create_story": {
                 const args = request.params.arguments;
-                const response = await client.post("/stories", args);
+                const normalizedLane = await normalizeLane(args.lane);
+                const boardId = await resolveBoardId();
+                const response = await client.post("/stories", {
+                    ...args,
+                    lane: normalizedLane,
+                    ...(boardId ? { boardId } : {}),
+                });
                 return {
                     content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response.data, null, 2),
-                        },
+                        { type: "text", text: JSON.stringify(response.data, null, 2) },
                     ],
                 };
             }
             case "get_iteration_context": {
-                const response = await client.get("/context");
+                const boardId = await resolveBoardId();
+                let contextData = null;
+                if (!boardId) {
+                    try {
+                        const response = await client.get("/context");
+                        contextData = response.data;
+                    }
+                    catch {
+                        // Fall back to /stories if /context is unavailable.
+                    }
+                }
+                const currentIteration = contextData?.currentIteration;
+                const backlog = contextData?.backlog;
+                const hasContextData = Array.isArray(currentIteration) &&
+                    Array.isArray(backlog) &&
+                    (currentIteration.length > 0 || backlog.length > 0);
+                const context = hasContextData
+                    ? contextData
+                    : buildIterationContext(await fetchStories(), contextData?.user ?? null);
                 return {
                     content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response.data, null, 2),
-                        },
+                        { type: "text", text: JSON.stringify(context, null, 2) },
                     ],
                 };
             }
+            case "create_hypothesis": {
+                const args = request.params.arguments;
+                const normalizedLane = await normalizeLane("Icebox");
+                const boardId = await resolveBoardId();
+                // Enforce Icebox lane
+                const payload = {
+                    ...args,
+                    lane: normalizedLane, // Map to lane style expected by API
+                    ...(boardId ? { boardId } : {}),
+                };
+                const response = await client.post("/stories", payload);
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(response.data, null, 2) },
+                    ],
+                };
+            }
+            case "record_learning": {
+                const args = request.params.arguments;
+                const { storyId, outcome_summary } = args;
+                const response = await client.patch(`/stories/${storyId}`, {
+                    outcome_summary,
+                });
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(response.data, null, 2) },
+                    ],
+                };
+            }
+            case "update_story": {
+                const args = request.params.arguments;
+                const { storyId, lane, ...rest } = args;
+                if (!storyId) {
+                    throw new Error("storyId is required");
+                }
+                const normalizedLane = await normalizeLane(lane);
+                const payload = Object.fromEntries(Object.entries({
+                    ...rest,
+                    ...(normalizedLane ? { lane: normalizedLane } : {}),
+                }).filter(([, value]) => value !== undefined));
+                const response = await client.patch(`/stories/${storyId}`, payload);
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(response.data, null, 2) },
+                    ],
+                };
+            }
+            case "list_objectives": {
+                const response = await client.get("/strategy/objectives");
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(response.data, null, 2) },
+                    ],
+                };
+            }
+            case "list_epics": {
+                const epics = await fetchEpics();
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(epics, null, 2) },
+                    ],
+                };
+            }
+            case "create_epic": {
+                const args = request.params.arguments;
+                const boardId = await resolveBoardId();
+                const response = await client.post("/epics", {
+                    ...args,
+                    ...(boardId ? { boardId } : {}),
+                });
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(response.data, null, 2) },
+                    ],
+                };
+            }
+            case "update_epic": {
+                const args = request.params.arguments;
+                const { epicId, ...rest } = args;
+                if (!epicId) {
+                    throw new Error("epicId is required");
+                }
+                const payload = Object.fromEntries(Object.entries(rest).filter(([, value]) => value !== undefined));
+                const response = await client.patch(`/epics/${epicId}`, payload);
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(response.data, null, 2) },
+                    ],
+                };
+            }
+            case "prepare_implementation": {
+                const args = request.params.arguments;
+                const { storyId } = args;
+                const storyResponse = await client.get(`/stories/${storyId}`);
+                const story = storyResponse.data;
+                // Validation & Guardrails
+                const storyLane = typeof story.lane === "string" ? story.lane.trim().toLowerCase() : "";
+                const statusWarning = storyLane !== "current"
+                    ? `\n> [!WARNING]\n> This story is currently in the **${story.lane}** lane. It should ideally be in **Current** before starting implementation.\n`
+                    : "";
+                const acceptanceCriteria = story.acceptance_criteria ||
+                    story.acceptanceCriteria ||
+                    story.description ||
+                    "No specific AC provided.";
+                const assumptions = story.learning_goals ||
+                    story.learning_goal ||
+                    story.learningGoals ||
+                    story.hypothesis ||
+                    "No specific learning goals identified.";
+                const formattedBrief = `
+# Implementation Brief: ${story.title}
+
+${statusWarning}
+
+## Acceptance Criteria
+Here’s the acceptance criteria I’m going to satisfy:
+${acceptanceCriteria}
+
+## Assumptions
+Here are the assumptions I think we’re testing:
+${assumptions}
+
+## Proposal
+Here’s the smallest change that will validate it:
+[Agent should fill this in based on the context above]
+`;
+                return {
+                    content: [{ type: "text", text: formattedBrief.trim() }],
+                };
+            }
             default:
                 throw new Error("Unknown tool");
         }

package/dist/test-prepare.js

@@ -0,0 +1,55 @@
+import axios from "axios";
+const API_KEY = process.env.ELIXIUM_API_KEY;
+const API_URL = process.env.ELIXIUM_API_URL || "https://elixium.ai/api";
+const BOARD_SLUG = process.env.ELIXIUM_BOARD_SLUG;
+const client = axios.create({
+    baseURL: API_URL,
+    headers: {
+        "x-api-key": API_KEY,
+        "Content-Type": "application/json",
+        ...(BOARD_SLUG ? { "x-board-slug": BOARD_SLUG } : {}),
+    },
+});
+async function testPrepare(storyId) {
+    try {
+        const storyResponse = await client.get(`/stories/${storyId}`);
+        const story = storyResponse.data;
+        // Validation & Guardrails
+        const storyLane = typeof story.lane === "string" ? story.lane.trim().toLowerCase() : "";
+        const statusWarning = storyLane !== "current"
+            ? `\n> [!WARNING]\n> This story is currently in the **${story.lane}** lane. It should ideally be in **Current** before starting implementation.\n`
+            : "";
+        const acceptanceCriteria = story.acceptance_criteria ||
+            story.acceptanceCriteria ||
+            story.description ||
+            "No specific AC provided.";
+        const assumptions = story.learning_goals ||
+            story.learning_goal ||
+            story.learningGoals ||
+            story.hypothesis ||
+            "No specific learning goals identified.";
+        const formattedBrief = `
+# Implementation Brief: ${story.title}
+
+${statusWarning}
+
+## Acceptance Criteria
+Here’s the acceptance criteria I’m going to satisfy:
+${acceptanceCriteria}
+
+## Assumptions
+Here are the assumptions I think we’re testing:
+${assumptions}
+
+## Proposal
+Here’s the smallest change that will validate it:
+[Agent should fill this in based on the context above]
+`;
+        console.log(formattedBrief.trim());
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+    }
+}
+const storyId = process.argv[2] || "ilX5KnrMSNQzhNvoWczh";
+testPrepare(storyId);

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@elixium.ai/mcp-server",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "MCP Server for Elixium.ai",
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
   "main": "dist/index.js",
   "bin": {
     "elixium-mcp-server": "./dist/index.js"
@@ -25,4 +30,4 @@
     "ts-node": "^10.9.0",
     "typescript": "^5.3.0"
   }
-}
+}

package/src/index.ts

@@ -1,151 +0,0 @@
-#!/usr/bin/env node
-
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import axios from "axios";
-import { z } from "zod";
-
-const API_KEY = process.env.ELIXIUM_API_KEY;
-const API_URL = process.env.ELIXIUM_API_URL || "https://elixium.ai/api";
-
-if (!API_KEY) {
-  console.error("Error: ELIXIUM_API_KEY environment variable is required");
-  process.exit(1);
-}
-
-const client = axios.create({
-  baseURL: API_URL,
-  headers: {
-    "x-api-key": API_KEY,
-    "Content-Type": "application/json",
-  },
-});
-
-const server = new Server(
-  {
-    name: "elixium-mcp-server",
-    version: "0.1.0",
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: "list_stories",
-        description: "List all stories on the Elixium board",
-        inputSchema: {
-          type: "object",
-          properties: {},
-        },
-      },
-      {
-        name: "create_story",
-        description: "Create a new story on the Elixium board",
-        inputSchema: {
-          type: "object",
-          properties: {
-            title: {
-              type: "string",
-              description: "Title of the story",
-            },
-            description: {
-              type: "string",
-              description: "Description of the story",
-            },
-            lane: {
-              type: "string",
-              description: "Lane to add the story to (BACKLOG, ICEBOX, CURRENT)",
-              enum: ["BACKLOG", "ICEBOX", "CURRENT"],
-            },
-            points: {
-              type: "number",
-              description: "Story points (0, 1, 2, 3, 5, 8)",
-            },
-          },
-          required: ["title"],
-        },
-      },
-      {
-        name: "get_iteration_context",
-        description: "Get the current iteration context (current stories and backlog) for AI planning",
-        inputSchema: {
-          type: "object",
-          properties: {},
-        },
-      },
-    ],
-  };
-});
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  try {
-    switch (request.params.name) {
-      case "list_stories": {
-        const response = await client.get("/stories");
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(response.data, null, 2),
-            },
-          ],
-        };
-      }
-
-      case "create_story": {
-        const args = request.params.arguments as any;
-        const response = await client.post("/stories", args);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(response.data, null, 2),
-            },
-          ],
-        };
-      }
-
-      case "get_iteration_context": {
-        const response = await client.get("/context");
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(response.data, null, 2),
-            },
-          ],
-        };
-      }
-
-      default:
-        throw new Error("Unknown tool");
-    }
-  } catch (error: any) {
-    console.error("Error executing tool:", error.message);
-    if (error.response) {
-      console.error("Response data:", error.response.data);
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error.message}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-});
-
-const transport = new StdioServerTransport();
-await server.connect(transport);

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"]
-}