@splicr/mcp-server 0.10.4 → 0.11.0

package/dist/cli.js

@@ -713,31 +713,23 @@ async function runSessionEnd() {
         // Take the last ~5000 chars of assistant messages
         const combined = messages.join('\n\n');
         const tail = combined.length > 5000 ? combined.slice(-5000) : combined;
-        // Skip if agent already saved to Splicr during this session
-        if (tail.includes('Saved to Splicr')) {
-            process.exit(0);
-            return;
-        }
-        // Send to capture endpoint — let the AI pipeline distill and decide significance
+        // Send to structured learning extraction endpoint
         const authMod = await import('./auth.js');
         const auth = await authMod.loadAuth();
         const API_URL = process.env.SPLICR_API_URL || 'https://api-production-d889.up.railway.app';
-        // Fire-and-forget POST to capture endpoint
-        fetch(`${API_URL}/capture`, {
+        // Fire-and-forget POST to session/complete-with-transcript
+        // This replaces the old raw transcript dump with structured AI extraction
+        fetch(`${API_URL}/mcp/session/complete-with-transcript`, {
             method: 'POST',
             headers: {
                 'Authorization': `Bearer ${auth.accessToken}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
-                content: tail,
-                source_type: 'agent',
-                captured_from: 'ide_agent',
-                title: `Session learning — ${new Date().toISOString().split('T')[0]}`,
-                tags: ['auto-save', 'session-learning'],
-                extracted_content: tail,
+                session_id: sessionId || undefined,
+                transcript_tail: tail,
             }),
-            signal: AbortSignal.timeout(8000),
+            signal: AbortSignal.timeout(10000),
         }).catch(() => { }); // fire-and-forget
         process.exit(0);
     }

package/dist/index.js

@@ -13,6 +13,8 @@ import { browseProjectSchema, handleBrowseProject } from './tools/browse-project
 import { getCompiledPageSchema, handleGetCompiledPage } from './tools/get-compiled-page.js';
 import { grepKnowledgeSchema, handleGrepKnowledge } from './tools/grep-knowledge.js';
 import { exploreKnowledgeSchema, handleExploreKnowledge } from './tools/explore-knowledge.js';
+import { getDecisionsSchema, handleGetDecisions } from './tools/get-decisions.js';
+import { getTeamStatusSchema, handleGetTeamStatus } from './tools/get-team-status.js';
 import { completeSession } from './lib/api-client.js';
 // Prevent unhandled errors from crashing the MCP server
 process.on('uncaughtException', (err) => {
@@ -61,6 +63,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         getCompiledPageSchema,
         grepKnowledgeSchema,
         exploreKnowledgeSchema,
+        getDecisionsSchema,
+        getTeamStatusSchema,
     ],
 }));
 // Handle tool calls with per-tool timeout
@@ -79,6 +83,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             get_compiled_page: handleGetCompiledPage,
             grep_knowledge: handleGrepKnowledge,
             explore_knowledge: handleExploreKnowledge,
+            get_decisions: handleGetDecisions,
+            get_team_status: handleGetTeamStatus,
         }[name];
         if (!handler) {
             return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };

package/dist/lib/api-client.d.ts

@@ -11,6 +11,7 @@ export declare function getProjectContext(params: {
     limit?: number;
 }): Promise<{
     results: any[];
+    patterns?: any[];
     project_name?: string;
 }>;
 export declare function getRecentInsights(params: {
@@ -27,6 +28,7 @@ export declare function saveFromAgent(params: {
     tags?: string[];
     memory_type?: string;
     context?: Record<string, unknown>;
+    register_as_pattern?: boolean;
 }): Promise<{
     id: string;
     title: string;
@@ -136,4 +138,15 @@ export declare function getRelevantContext(params: {
     results: any[];
     search_strategy: string;
 }>;
+export declare function getDecisions(params: {
+    topic?: string;
+    project_name?: string;
+    type?: string;
+    limit?: number;
+}): Promise<{
+    results: any[];
+}>;
+export declare function getTeamStatus(params: {
+    project?: string;
+}): Promise<any>;
 export { API_URL };

package/dist/lib/api-client.js

@@ -100,4 +100,12 @@ export async function getRelevantContext(params) {
     const data = await apiRequest('POST', '/mcp/relevant-context', params);
     return { results: data.results ?? [], search_strategy: data.search_strategy ?? '' };
 }
+export async function getDecisions(params) {
+    const data = await apiRequest('POST', '/mcp/decisions', params);
+    return { results: data.results ?? [] };
+}
+export async function getTeamStatus(params) {
+    const query = params.project ? `?project=${encodeURIComponent(params.project)}` : '';
+    return await apiRequest('GET', `/mcp/team-status${query}`);
+}
 export { API_URL };

package/dist/tools/get-decisions.d.ts

@@ -0,0 +1,27 @@
+export declare const getDecisionsSchema: {
+    name: "get_decisions";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            topic: {
+                type: "string";
+                description: string;
+            };
+            project: {
+                type: "string";
+                description: string;
+            };
+            type: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            limit: {
+                type: "number";
+                description: string;
+            };
+        };
+    };
+};
+export declare function handleGetDecisions(args: Record<string, unknown>): Promise<string>;

package/dist/tools/get-decisions.js

@@ -0,0 +1,90 @@
+import { getDecisions } from '../lib/api-client.js';
+import { detectProject } from '../lib/project-detector.js';
+import * as session from '../lib/session-state.js';
+export const getDecisionsSchema = {
+    name: 'get_decisions',
+    description: `Query the team's decision log - technical decisions, patterns, discoveries, and failures recorded during agent sessions.
+
+Use when:
+- Before making an architecture or technology choice (see what the team decided before)
+- When someone asks "why did we do X this way?"
+- When evaluating alternatives for a new approach
+- To check if something was tried before and failed
+
+Returns structured decisions with rationale, alternatives considered, and anti-pattern warnings.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            topic: { type: 'string', description: 'Topic to search decisions about (e.g., "auth", "caching", "error handling")' },
+            project: { type: 'string', description: 'Project name or "auto" (default: auto)' },
+            type: {
+                type: 'string',
+                enum: ['decision', 'discovery', 'pattern', 'failure', 'workaround', 'all'],
+                description: 'Filter by decision type (default: all)',
+            },
+            limit: { type: 'number', description: 'Max results (default: 10)' },
+        },
+    },
+};
+export async function handleGetDecisions(args) {
+    const topic = args.topic;
+    const typeFilter = args.type || 'all';
+    const limit = Math.min(Math.max(1, Number(args.limit) || 10), 50);
+    // Resolve project
+    let projectName;
+    const projectArg = args.project || 'auto';
+    if (projectArg === 'auto') {
+        const detected = await detectProject(process.cwd());
+        projectName = detected?.name;
+    }
+    else {
+        projectName = projectArg;
+    }
+    const data = await getDecisions({
+        topic,
+        project_name: projectName,
+        type: typeFilter,
+        limit,
+    });
+    session.recordToolCall();
+    if (!data.results || data.results.length === 0) {
+        const scope = projectName ? ` for ${projectName}` : '';
+        const topicNote = topic ? ` about "${topic}"` : '';
+        return `No decisions found${scope}${topicNote}. The decision log builds over time as agents auto-extract learnings from sessions.`;
+    }
+    const items = data.results.map((r, i) => {
+        const meta = r.metadata || {};
+        const typeLabel = meta.decision_type || meta.learning_type || 'unknown';
+        const confidence = meta.confidence ? ` (${meta.confidence} confidence)` : '';
+        // Special formatting for failures/anti-patterns
+        let prefix = '';
+        if (typeLabel === 'failure')
+            prefix = '[ANTI-PATTERN] ';
+        else if (typeLabel === 'architecture')
+            prefix = '[DECISION] ';
+        else if (typeLabel === 'pattern')
+            prefix = '[PATTERN] ';
+        else if (typeLabel === 'discovery')
+            prefix = '[DISCOVERY] ';
+        else if (typeLabel === 'workaround')
+            prefix = '[WORKAROUND] ';
+        let entry = `${i + 1}. ${prefix}**${r.title || 'Untitled'}**${confidence}\n`;
+        entry += `   ${r.insight || r.raw_content || '(no content)'}\n`;
+        if (meta.alternatives_considered) {
+            entry += `   *Alternatives considered:* ${meta.alternatives_considered}\n`;
+        }
+        if (meta.failed_reason) {
+            entry += `   *Why it failed:* ${meta.failed_reason}\n`;
+        }
+        if (meta.better_approach) {
+            entry += `   *Better approach:* ${meta.better_approach}\n`;
+        }
+        const tags = r.tags?.filter((t) => !t.startsWith('learning:') && t !== 'auto-extracted');
+        if (tags?.length > 0) {
+            entry += `   tags: ${tags.join(', ')}`;
+        }
+        return entry;
+    }).join('\n\n');
+    const scope = projectName ? ` for ${projectName}` : '';
+    return `*Decision log${scope} — ${data.results.length} result(s):*\n\n${items}`;
+}

package/dist/tools/get-project-context.js

@@ -40,6 +40,12 @@ export async function handleGetProjectContext(args) {
     const results = data.results;
     const name = data.project_name || projectName;
     let output = '';
+    // --- SECTION 0: Active project patterns (cross-agent consistency) ---
+    const patterns = data.patterns;
+    if (patterns && patterns.length > 0) {
+        const patternItems = patterns.map((p, i) => `${i + 1}. **${p.name}** — ${p.description}`).join('\n');
+        output += `*Active patterns for ${name}:*\n${patternItems}\n\n---\n\n`;
+    }
     if (results && results.length > 0) {
         const items = results.map((r, i) => `${i + 1}. **${r.title || 'Untitled'}** · splicr [${r.relevance}]\n` +
             `   ${r.insight}\n` +

package/dist/tools/get-team-status.d.ts

@@ -0,0 +1,14 @@
+export declare const getTeamStatusSchema: {
+    name: "get_team_status";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            project: {
+                type: "string";
+                description: string;
+            };
+        };
+    };
+};
+export declare function handleGetTeamStatus(args: Record<string, unknown>): Promise<string>;

package/dist/tools/get-team-status.js

@@ -0,0 +1,61 @@
+import { getTeamStatus } from '../lib/api-client.js';
+import { detectProject } from '../lib/project-detector.js';
+import * as session from '../lib/session-state.js';
+export const getTeamStatusSchema = {
+    name: 'get_team_status',
+    description: `Get a brief on what the team is working on right now. Shows open PRs, active branches, and recent merges from GitHub.
+
+Use when:
+- Starting a session and want to know what's in flight
+- Before starting work on a feature (check if someone else is already on it)
+- To understand recent changes to the codebase
+
+Requires GitHub integration (connected via Splicr dashboard).`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: { type: 'string', description: 'Project name or "auto" (default: auto)' },
+        },
+    },
+};
+export async function handleGetTeamStatus(args) {
+    const projectArg = args.project || 'auto';
+    let projectName;
+    if (projectArg === 'auto') {
+        const detected = await detectProject(process.cwd());
+        projectName = detected?.name;
+    }
+    else {
+        projectName = projectArg;
+    }
+    const data = await getTeamStatus({ project: projectName });
+    session.recordToolCall();
+    if (data.error) {
+        return data.error;
+    }
+    let output = `*Team status for ${data.repo}:*\n\n`;
+    // Open PRs
+    if (data.open_prs && data.open_prs.length > 0) {
+        output += `**Open PRs (${data.open_prs.length}):**\n`;
+        output += data.open_prs.map((pr) => `- #${pr.number} ${pr.title} (${pr.author}, branch: \`${pr.branch}\`)${pr.draft ? ' [DRAFT]' : ''}`).join('\n');
+        output += '\n\n';
+    }
+    else {
+        output += 'No open PRs.\n\n';
+    }
+    // Recent merges
+    if (data.recent_merges && data.recent_merges.length > 0) {
+        output += `**Recently merged (last 7 days):**\n`;
+        output += data.recent_merges.map((m) => {
+            const daysAgo = Math.floor((Date.now() - new Date(m.merged_at).getTime()) / (1000 * 60 * 60 * 24));
+            const when = daysAgo === 0 ? 'today' : daysAgo === 1 ? 'yesterday' : `${daysAgo}d ago`;
+            return `- ${m.title} (${m.author}, ${when})`;
+        }).join('\n');
+        output += '\n\n';
+    }
+    // Active branches
+    if (data.active_branches && data.active_branches.length > 0) {
+        output += `**Active branches:** ${data.active_branches.map((b) => `\`${b.name}\``).join(', ')}`;
+    }
+    return output.trim();
+}

package/dist/tools/save-from-agent.d.ts

@@ -52,6 +52,7 @@ export declare const saveFromAgentSchema: {
                     };
                     decision_type: {
                         type: "string";
+                        enum: string[];
                         description: string;
                     };
                     durability: {
@@ -60,6 +61,10 @@ export declare const saveFromAgentSchema: {
                     };
                 };
             };
+            register_as_pattern: {
+                type: "boolean";
+                description: string;
+            };
         };
         required: ("title" | "content")[];
     };

package/dist/tools/save-from-agent.js

@@ -37,10 +37,14 @@ What NOT to save: file edits (git has those), routine commands, anything derivab
                     agent: { type: 'string', description: 'Agent/model name (e.g. "claude-opus-4-6")' },
                     files: { type: 'array', items: { type: 'string' }, description: 'Files involved in this learning' },
                     splicr_refs: { type: 'array', items: { type: 'string' }, description: 'IDs of Splicr captures referenced during this session' },
-                    decision_type: { type: 'string', description: 'Type: architecture, workaround, discovery, synthesis, or pattern' },
+                    decision_type: { type: 'string', enum: ['architecture', 'workaround', 'discovery', 'synthesis', 'pattern', 'failure'], description: 'Type: architecture, workaround, discovery, synthesis, pattern, or failure' },
                     durability: { type: 'string', description: 'How long this knowledge stays relevant: permanent, versioned, or ephemeral' },
                 },
             },
+            register_as_pattern: {
+                type: 'boolean',
+                description: 'Set true to also register this as an active project pattern (enforced across future agent sessions)',
+            },
         },
         required: ['content', 'title'],
     },
@@ -52,6 +56,7 @@ export async function handleSaveFromAgent(args) {
     const tags = args.tags || [];
     const memoryType = args.memory_type || 'fact';
     const context = args.context;
+    const registerAsPattern = args.register_as_pattern;
     // Resolve project name
     let projectName;
     if (projectArg === 'auto') {
@@ -68,6 +73,7 @@ export async function handleSaveFromAgent(args) {
         tags,
         memory_type: memoryType,
         context,
+        register_as_pattern: registerAsPattern,
     });
     if (result.duplicate) {
         return `*Already saved in Splicr:* "${title}"`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splicr/mcp-server",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "description": "Splicr MCP server — route what you read to what you're building",
   "type": "module",
   "bin": "./dist/cli.js",