@elixium.ai/mcp-server 0.3.2 → 0.3.6

package/dist/index.js

@@ -200,12 +200,16 @@ const fetchFeatureConfig = async () => {
                 learningLoop: true,
                 tddWorkflow: true,
                 aiTools: true,
+                teamDecisions: false,
+                ragKnowledgeBase: false,
             },
             source: {
                 balancedTeam: "error-fallback",
                 learningLoop: "error-fallback",
                 tddWorkflow: "error-fallback",
                 aiTools: "error-fallback",
+                teamDecisions: "error-fallback",
+                ragKnowledgeBase: "error-fallback",
             },
         };
     }
@@ -219,6 +223,10 @@ const isLearningLoopEnabled = async () => {
     const config = await fetchFeatureConfig();
     return config.features.learningLoop;
 };
+const isTeamDecisionsEnabled = async () => {
+    const config = await fetchFeatureConfig();
+    return config.features.teamDecisions;
+};
 const isAiToolsEnabled = async () => {
     const config = await fetchFeatureConfig();
     return config.features.aiTools;
@@ -423,6 +431,8 @@ const createServer = () => {
         const featureConfig = await fetchFeatureConfig();
         const tddEnabled = featureConfig.features.tddWorkflow;
         const learningLoopEnabled = featureConfig.features.learningLoop;
+        const teamDecisionsEnabled = featureConfig.features.teamDecisions;
+        const ragKnowledgeBaseEnabled = featureConfig.features.ragKnowledgeBase;
         const baseTools = [
             {
                 name: "get_feature_config",
@@ -434,10 +444,34 @@ const createServer = () => {
             },
             {
                 name: "list_stories",
-                description: "List all stories on the Elixium board",
+                description: "List stories on the Elixium board. Returns compact summaries (id, title, lane, points, owners, epic, state). Use lane filter to reduce results. Defaults to 25 stories max.",
                 inputSchema: {
                     type: "object",
-                    properties: {},
+                    properties: {
+                        lane: {
+                            type: "string",
+                            description: "Filter by lane (case-insensitive). Omit to list all lanes.",
+                            enum: ["Current", "Backlog", "Icebox", "Done"],
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Max stories to return (default 25, max 100)",
+                        },
+                    },
+                },
+            },
+            {
+                name: "get_story",
+                description: "Get full details for a single story by UUID. Returns all fields including description, acceptance criteria, tasks, labels, metrics, and workflow state.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "The full UUID of the story (from list_stories output)",
+                        },
+                    },
+                    required: ["id"],
                 },
             },
             {
@@ -477,6 +511,14 @@ const createServer = () => {
                             type: "string",
                             description: "Email of the person requesting this story. Defaults to ELIXIUM_USER_EMAIL env var or API key owner.",
                         },
+                        epicId: {
+                            type: "string",
+                            description: "Epic ID to link this story to (optional). Use list_epics to find epic IDs.",
+                        },
+                        testPlan: {
+                            type: "string",
+                            description: "Markdown test plan describing test strategy (optional). Sets the test_plan field without changing workflow_stage.",
+                        },
                     },
                     required: ["title"],
                 },
@@ -595,6 +637,18 @@ const createServer = () => {
                             type: "string",
                             description: "Acceptance criteria in Given/When/Then format",
                         },
+                        sortOrder: {
+                            type: "number",
+                            description: "Sort order within the lane (lower = higher priority)",
+                        },
+                        epicId: {
+                            type: "string",
+                            description: "Epic ID to link this story to. Set to empty string to unlink.",
+                        },
+                        testPlan: {
+                            type: "string",
+                            description: "Markdown test plan. Updates test_plan field without changing workflow_stage.",
+                        },
                     },
                     required: ["storyId"],
                 },
@@ -658,6 +712,25 @@ const createServer = () => {
                     required: ["epicId"],
                 },
             },
+            {
+                name: "prioritize_epic",
+                description: "AI-powered dependency analysis and story prioritization for an epic. Analyzes stories, proposes optimal execution order based on dependencies, and optionally applies the reorder. Uses the same server-side endpoint as the UI.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        epicId: {
+                            type: "string",
+                            description: "ID of the epic to prioritize",
+                        },
+                        mode: {
+                            type: "string",
+                            description: "analyze (preview proposed order) or apply (commit the reorder)",
+                            enum: ["analyze", "apply"],
+                        },
+                    },
+                    required: ["epicId"],
+                },
+            },
         ];
         const tddTools = tddEnabled ? [
             // TDD Workflow Tools
@@ -725,6 +798,20 @@ const createServer = () => {
                     required: ["storyId"],
                 },
             },
+            {
+                name: "get_test_plan",
+                description: "Retrieve and display the full TDD test plan for a story. Shows the plan text, workflow stage, approval status, and test file paths.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story whose test plan to display",
+                        },
+                    },
+                    required: ["storyId"],
+                },
+            },
             {
                 name: "submit_for_review",
                 description: "Submit implementation for human review. Only works if tests are approved. Sets state to finished.",
@@ -802,14 +889,92 @@ const createServer = () => {
                 },
             },
         ] : [];
-        return { tools: [...baseTools, ...tddTools, ...learningLoopTools] };
+        // Team Decisions tools (conditional on feature flag)
+        const teamDecisionsTools = teamDecisionsEnabled ? [
+            {
+                name: "record_decision",
+                description: "Record a team decision, meeting outcome, or architectural choice. These are shared across all team members' AI sessions.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "Short title for the decision" },
+                        content: { type: "string", description: "Full description of the decision, context, and rationale" },
+                        category: {
+                            type: "string",
+                            description: "Category (e.g., architecture, meeting-note, convention, tooling, decision, general)",
+                        },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Tags for filtering (e.g., ['auth', 'self-hosted', 'phase-2'])",
+                        },
+                        storyId: { type: "string", description: "Optional story UUID to link this decision to" },
+                        epicId: { type: "string", description: "Optional epic UUID to link this decision to" },
+                    },
+                    required: ["title", "content"],
+                },
+            },
+            {
+                name: "list_decisions",
+                description: "List recent team decisions. Filter by category, tag, or date. Use this to check what the team has decided recently.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        category: { type: "string", description: "Filter by category" },
+                        tag: { type: "string", description: "Filter by tag" },
+                        since: { type: "string", description: "ISO date string — only return decisions after this date" },
+                        limit: { type: "number", description: "Max results to return (default 20)" },
+                    },
+                },
+            },
+            {
+                name: "search_decisions",
+                description: "Full-text search across all team decisions. Use this when looking for decisions related to a specific topic or keyword.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query (keywords)" },
+                        category: { type: "string", description: "Optional category filter" },
+                        limit: { type: "number", description: "Max results to return (default 10)" },
+                    },
+                    required: ["query"],
+                },
+            },
+        ] : [];
+        // RAG Knowledge Base tools (conditional on feature flag)
+        const ragTools = ragKnowledgeBaseEnabled ? [
+            {
+                name: "search_knowledge",
+                description: "Semantic search across team knowledge base (documents, wikis, runbooks, etc). Returns relevant chunks with source attribution.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query (natural language)" },
+                        category: { type: "string", description: "Optional source type filter (e.g., wiki, runbook, adr, confluence)" },
+                        limit: { type: "number", description: "Max results to return (default 10)" },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "list_knowledge_sources",
+                description: "List all knowledge sources indexed in the RAG knowledge base, grouped by source type.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        source_type: { type: "string", description: "Optional filter by source type" },
+                    },
+                },
+            },
+        ] : [];
+        return { tools: [...baseTools, ...tddTools, ...learningLoopTools, ...teamDecisionsTools, ...ragTools] };
     });
     // Handle Requests
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         try {
             const toolName = request.params.name;
             // Check TDD workflow tools
-            const tddWorkflowTools = ["start_story", "propose_test_plan", "submit_for_review", "review_pr"];
+            const tddWorkflowTools = ["start_story", "propose_test_plan", "get_test_plan", "submit_for_review", "review_pr"];
             if (tddWorkflowTools.includes(toolName)) {
                 const enabled = await isTddWorkflowEnabled();
                 if (!enabled) {
@@ -844,6 +1009,42 @@ const createServer = () => {
                     };
                 }
             }
+            // Check Team Decisions tools
+            const teamDecisionsToolNames = ["record_decision", "list_decisions", "search_decisions"];
+            if (teamDecisionsToolNames.includes(toolName)) {
+                const enabled = await isTeamDecisionsEnabled();
+                if (!enabled) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "Team Decisions is disabled",
+                                    message: "The Team Decisions feature is currently disabled for this board. This feature enables shared institutional memory across all team members' AI sessions.",
+                                    help: "Team Decisions can be enabled in workspace settings or per-board settings."
+                                }, null, 2)
+                            }],
+                        isError: true,
+                    };
+                }
+            }
+            // Check RAG Knowledge Base tools
+            const ragToolNames = ["search_knowledge", "list_knowledge_sources"];
+            if (ragToolNames.includes(toolName)) {
+                const config = await fetchFeatureConfig();
+                if (!config.features.ragKnowledgeBase) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "RAG Knowledge Base is disabled",
+                                    message: "The RAG Knowledge Base feature is currently disabled for this board. This feature enables semantic search across team knowledge sources.",
+                                    help: "RAG Knowledge Base can be enabled in workspace settings or per-board settings."
+                                }, null, 2)
+                            }],
+                        isError: true,
+                    };
+                }
+            }
             switch (toolName) {
                 case "get_feature_config": {
                     const config = await fetchFeatureConfig();
@@ -855,6 +1056,8 @@ ${config.features.balancedTeam ? "✅" : "❌"} **Balanced Team** - Design URLs,
 ${config.features.learningLoop ? "✅" : "❌"} **Learning Loop** - Hypothesis tracking, risk profiles, confidence scores
 ${config.features.tddWorkflow ? "✅" : "❌"} **TDD Workflow** - Test-driven development enforcement
 ${config.features.aiTools ? "✅" : "❌"} **AI Tools** - AI-powered suggestions and analysis
+${config.features.teamDecisions ? "✅" : "❌"} **Team Decisions** - Shared institutional memory across AI sessions
+${config.features.ragKnowledgeBase ? "✅" : "❌"} **RAG Knowledge Base** - Semantic search across team knowledge sources
 
 ## Team Profile
 ${config.teamProfile ? `
@@ -870,6 +1073,8 @@ ${config.teamProfile ? `
 - Learning Loop: ${config.source.learningLoop}
 - TDD Workflow: ${config.source.tddWorkflow}
 - AI Tools: ${config.source.aiTools}
+- Team Decisions: ${config.source.teamDecisions}
+- RAG Knowledge Base: ${config.source.ragKnowledgeBase}
 
 ## Branching Strategy Defaults
 ${config.branchingDefaults ? `- Trunk-Based: ${config.branchingDefaults.trunkBased ? "Yes" : "No"}
@@ -890,10 +1095,49 @@ ${config.infrastructureProfile?.provider ? `- Provider: ${config.infrastructureP
                     };
                 }
                 case "list_stories": {
-                    const stories = await fetchStories();
+                    const args = request.params.arguments;
+                    let stories = await fetchStories();
+                    // Filter by lane if specified
+                    if (args?.lane) {
+                        const targetLane = args.lane.toLowerCase();
+                        stories = stories.filter((s) => (s.lane || "").toLowerCase() === targetLane);
+                    }
+                    // Apply limit (default 25, max 100)
+                    const limit = Math.min(Math.max(args?.limit || 25, 1), 100);
+                    const total = stories.length;
+                    stories = stories.slice(0, limit);
+                    // Return compact summaries to fit LLM context
+                    const compact = stories.map((s) => ({
+                        id: s.id,
+                        title: s.title,
+                        lane: s.lane,
+                        state: s.state,
+                        points: s.points,
+                        owners: s.owners,
+                        labels: s.labels,
+                        epicId: s.epicId,
+                        storyType: s.storyType || s.story_type,
+                        createdAt: s.createdAt || s.created_at,
+                    }));
+                    const result = {
+                        total,
+                        showing: compact.length,
+                        ...(args?.lane ? { lane: args.lane } : {}),
+                        stories: compact,
+                    };
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(result, null, 2) },
+                        ],
+                    };
+                }
+                case "get_story": {
+                    const args = request.params.arguments;
+                    assertUUID(args.id, "story id");
+                    const response = await client.get(`/stories/${args.id}`);
                     return {
                         content: [
-                            { type: "text", text: JSON.stringify(stories, null, 2) },
+                            { type: "text", text: JSON.stringify(response.data, null, 2) },
                         ],
                     };
                 }
@@ -1088,6 +1332,32 @@ ${config.infrastructureProfile?.provider ? `- Provider: ${config.infrastructureP
                         fetchBoardSettings(),
                     ]);
                     const story = storyResponse.data;
+                    // Auto-search team decisions if feature flag is enabled (graceful degradation)
+                    let relevantDecisions = [];
+                    if (teamConfig.features.teamDecisions) {
+                        try {
+                            const decisionsResponse = await client.get("/decisions/search", {
+                                params: { q: story.title, limit: 5 },
+                            });
+                            relevantDecisions = decisionsResponse.data?.decisions || [];
+                        }
+                        catch {
+                            // Silently omit — decisions search failure should not break the brief
+                        }
+                    }
+                    // Auto-search knowledge base if feature flag is enabled (graceful degradation)
+                    let relatedKnowledge = [];
+                    if (teamConfig.features.ragKnowledgeBase) {
+                        try {
+                            const knowledgeResponse = await client.get("/knowledge/search", {
+                                params: { q: story.title, limit: 5 },
+                            });
+                            relatedKnowledge = knowledgeResponse.data?.results || [];
+                        }
+                        catch {
+                            // Silently omit — knowledge search failure should not break the brief
+                        }
+                    }
                     // Validation & Guardrails
                     const storyLane = typeof story.lane === "string" ? story.lane.trim().toLowerCase() : "";
                     const statusWarning = storyLane !== "current"
@@ -1114,6 +1384,24 @@ ${config.infrastructureProfile?.provider ? `- Provider: ${config.infrastructureP
                                 r.concerns.map((c) => `- **${c.severity}:** ${c.description}`).join("\n") + "\n";
                         }
                     }
+                    // Format relevant team decisions section (only if matches exist)
+                    let decisionsSection = "";
+                    if (relevantDecisions.length > 0) {
+                        const formatted = relevantDecisions.map((d) => {
+                            const date = d.created_at ? new Date(d.created_at).toISOString().split("T")[0] : "unknown";
+                            return `- [${date}] **${d.title}** (${d.category || "general"})\n  ${d.content}`;
+                        }).join("\n");
+                        decisionsSection = `\n## Relevant Team Decisions\n${formatted}\n`;
+                    }
+                    // Format related knowledge section (only if matches exist)
+                    let knowledgeSection = "";
+                    if (relatedKnowledge.length > 0) {
+                        const formatted = relatedKnowledge.map((k) => {
+                            const relevance = k.relevance ? ` (${(k.relevance * 100).toFixed(0)}% match)` : "";
+                            return `- **${k.source_title}** [${k.source_type}]${relevance}\n  ${k.content}`;
+                        }).join("\n");
+                        knowledgeSection = `\n## Related Knowledge\n${formatted}\n`;
+                    }
                     const formattedBrief = `
 # Implementation Brief: ${story.title}
 
@@ -1126,7 +1414,7 @@ ${acceptanceCriteria}
 ## Assumptions
 Here are the assumptions I think we’re testing:
 ${assumptions}
-
+${decisionsSection}${knowledgeSection}
 ${formatTeamContext(teamConfig)}
 ${formatDorDodSection(boardSettings, story.dorChecklist, story.dodChecklist)}
 ## Proposal
@@ -1234,6 +1522,56 @@ ${dorWarnings}`;
                         content: [{ type: "text", text: formattedResult.trim() }],
                     };
                 }
+                case "get_test_plan": {
+                    const args = request.params.arguments;
+                    const { storyId } = args;
+                    if (!storyId) {
+                        throw new Error("storyId is required");
+                    }
+                    assertUUID(storyId, "storyId");
+                    const response = await client.get(`/stories/${storyId}`);
+                    const story = response.data;
+                    const testPlan = story.test_plan || story.testPlan;
+                    const workflowStage = story.workflow_stage || story.workflowStage;
+                    const testFilePaths = story.test_file_paths || story.testFilePaths || [];
+                    const feedback = story.test_plan_feedback || story.testPlanFeedback;
+                    const title = story.title || "Untitled Story";
+                    if (!testPlan) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `# No Test Plan\n\n**Story:** ${title}\n**Story ID:** ${storyId}\n**Workflow Stage:** ${workflowStage || "none"}\n\nThis story does not have a test plan yet. Use \`propose_test_plan\` to submit one.`,
+                                },
+                            ],
+                        };
+                    }
+                    const stageLabel = workflowStage === "tests_approved"
+                        ? "Approved"
+                        : workflowStage === "tests_proposed"
+                            ? "Proposed — Awaiting Approval"
+                            : workflowStage === "tests_revision_requested"
+                                ? "Revision Requested"
+                                : workflowStage || "unknown";
+                    const feedbackSection = feedback
+                        ? `\n## Revision Feedback\n> ${feedback.split("\n").join("\n> ")}\n`
+                        : "";
+                    const formattedResult = `# Test Plan: ${title}
+
+**Story ID:** ${storyId}
+**Workflow Stage:** ${workflowStage}
+**Status:** ${stageLabel}
+
+## Test Plan
+${testPlan}
+${feedbackSection}
+## Test Files
+${testFilePaths.length > 0 ? testFilePaths.map((p) => `- \`${p}\``).join("\n") : "No test files specified"}
+`;
+                    return {
+                        content: [{ type: "text", text: formattedResult.trim() }],
+                    };
+                }
                 case "propose_test_plan": {
                     const args = request.params.arguments;
                     const { storyId, testPlan, testFilePaths } = args;
@@ -1540,6 +1878,49 @@ ${categoryBreakdown}
 ${unestimated.length === 0
                         ? "All stories have been estimated!"
                         : unestimated.map((s) => `- ${s.title} (${s.id})`).join("\n")}
+`;
+                    return {
+                        content: [{ type: "text", text: formattedResult.trim() }],
+                    };
+                }
+                case "prioritize_epic": {
+                    const args = request.params.arguments;
+                    const { epicId, mode = "analyze" } = args;
+                    if (!epicId)
+                        throw new Error("epicId is required");
+                    assertUUID(epicId, "epicId");
+                    const res = await client.post(`/prioritize-epic/${epicId}`, { mode });
+                    if (mode === "apply") {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Prioritization applied to epic. ${res.data.updatedCount} stories reordered.`,
+                                }],
+                        };
+                    }
+                    // Analyze mode — format the preview
+                    const data = res.data;
+                    const orderList = (data.proposedOrder || [])
+                        .map((item, i) => `${i + 1}. **${item.storyTitle}** — ${item.reason}`)
+                        .join("\n");
+                    const depList = (data.dependencies || [])
+                        .map((dep) => `- ${dep.storyTitle} is blocked by ${dep.blockedByStoryTitle}: ${dep.reason}`)
+                        .join("\n");
+                    const circularWarning = data.circularDependencies?.length > 0
+                        ? `\n## Circular Dependencies Detected\n${data.circularDependencies.map((cd) => `- ${cd.description}`).join("\n")}\n`
+                        : "";
+                    const formattedResult = `
+# AI Prioritization Preview
+
+${data.summary}
+${circularWarning}
+## Proposed Order (do first → do last)
+${orderList}
+
+## Dependencies
+${depList || "No dependencies detected."}
+
+> To apply this order, call \`prioritize_epic\` with mode: "apply"
 `;
                     return {
                         content: [{ type: "text", text: formattedResult.trim() }],
@@ -1580,6 +1961,135 @@ ${unestimated.length === 0
                         content: [{ type: "text", text: sections.join("\n") }],
                     };
                 }
+                // Team Decisions Handlers
+                case "record_decision": {
+                    const args = request.params.arguments;
+                    const { title, content, category, tags, storyId, epicId } = args;
+                    if (!title || !content) {
+                        throw new Error("title and content are required");
+                    }
+                    if (storyId)
+                        assertUUID(storyId, "storyId");
+                    if (epicId)
+                        assertUUID(epicId, "epicId");
+                    const response = await client.post("/decisions", {
+                        title,
+                        content,
+                        category,
+                        tags,
+                        storyId,
+                        epicId,
+                    });
+                    const decision = response.data;
+                    const confirmText = `✅ Decision recorded: "${decision.title || title}"
+- **Category:** ${decision.category || category || "general"}
+- **Tags:** ${(decision.tags || tags || []).join(", ") || "none"}
+- **ID:** ${decision.id}`;
+                    return {
+                        content: [{ type: "text", text: confirmText }],
+                    };
+                }
+                case "list_decisions": {
+                    const args = request.params.arguments;
+                    const { category, tag, since, limit } = args || {};
+                    const params = {};
+                    if (category)
+                        params.category = category;
+                    if (tag)
+                        params.tag = tag;
+                    if (since)
+                        params.since = since;
+                    if (limit)
+                        params.limit = String(limit);
+                    const response = await client.get("/decisions", { params });
+                    const { decisions, total } = response.data;
+                    if (!decisions || decisions.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "No team decisions found matching the filters." }],
+                        };
+                    }
+                    const formatted = decisions.map((d) => {
+                        const date = d.created_at ? new Date(d.created_at).toISOString().split("T")[0] : "unknown";
+                        const tagStr = d.tags?.length ? ` [${d.tags.join(", ")}]` : "";
+                        return `### [${date}] ${d.title} (${d.category || "general"})${tagStr}\n${d.content}`;
+                    }).join("\n\n---\n\n");
+                    const header = `# Team Decisions (${decisions.length} of ${total})\n\n`;
+                    return {
+                        content: [{ type: "text", text: header + formatted }],
+                    };
+                }
+                case "search_decisions": {
+                    const args = request.params.arguments;
+                    const { query, category, limit } = args || {};
+                    if (!query) {
+                        throw new Error("query is required");
+                    }
+                    const params = { q: query };
+                    if (category)
+                        params.category = category;
+                    if (limit)
+                        params.limit = String(limit);
+                    const response = await client.get("/decisions/search", { params });
+                    const { decisions } = response.data;
+                    if (!decisions || decisions.length === 0) {
+                        return {
+                            content: [{ type: "text", text: `No team decisions found matching "${query}".` }],
+                        };
+                    }
+                    const formatted = decisions.map((d) => {
+                        const date = d.created_at ? new Date(d.created_at).toISOString().split("T")[0] : "unknown";
+                        const tagStr = d.tags?.length ? ` [${d.tags.join(", ")}]` : "";
+                        return `### [${date}] ${d.title} (${d.category || "general"})${tagStr}\n${d.content}`;
+                    }).join("\n\n---\n\n");
+                    const header = `# Search Results for "${query}" (${decisions.length} matches)\n\n`;
+                    return {
+                        content: [{ type: "text", text: header + formatted }],
+                    };
+                }
+                case "search_knowledge": {
+                    const args = request.params.arguments;
+                    const { query, category, limit } = args || {};
+                    if (!query) {
+                        throw new Error("query is required");
+                    }
+                    const params = { q: query };
+                    if (category)
+                        params.category = category;
+                    if (limit)
+                        params.limit = String(limit);
+                    const response = await client.get("/knowledge/search", { params });
+                    const { results } = response.data;
+                    if (!results || results.length === 0) {
+                        return {
+                            content: [{ type: "text", text: `No knowledge results found matching "${query}".` }],
+                        };
+                    }
+                    const formatted = results.map((r) => {
+                        const relevance = r.relevance ? `(${(r.relevance * 100).toFixed(1)}% relevant)` : "";
+                        return `### ${r.source_title} [${r.source_type}] ${relevance}\n${r.content}`;
+                    }).join("\n\n---\n\n");
+                    const header = `# Knowledge Search Results for "${query}" (${results.length} matches)\n\n`;
+                    return {
+                        content: [{ type: "text", text: header + formatted }],
+                    };
+                }
+                case "list_knowledge_sources": {
+                    const args = request.params.arguments;
+                    const params = {};
+                    if (args?.source_type)
+                        params.source_type = args.source_type;
+                    const response = await client.get("/knowledge/sources", { params });
+                    const { sources } = response.data;
+                    if (!sources || sources.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "No knowledge sources are currently indexed." }],
+                        };
+                    }
+                    const formatted = sources.map((s) => `- **${s.source_title}** (${s.source_type}) — ${s.chunk_count || 0} chunks`).join("\n");
+                    return {
+                        content: [{ type: "text", text: `# Knowledge Sources\n\n${formatted}` }],
+                    };
+                }
                 default:
                     throw new Error("Unknown tool");
             }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@elixium.ai/mcp-server",
-  "version": "0.3.2",
+  "version": "0.3.6",
   "type": "module",
   "description": "MCP Server for Elixium.ai",
-  "mcpName": "io.github.elixium-ai/mcp-server",
+  "mcpName": "io.github.IndirectTek/mcp-server",
   "publishConfig": {
     "access": "public"
   },