@splicr/mcp-server 0.14.1 → 0.14.2

package/dist/index.js

@@ -17,6 +17,7 @@ import { getDecisionsSchema, handleGetDecisions } from './tools/get-decisions.js
 import { getTeamStatusSchema, handleGetTeamStatus } from './tools/get-team-status.js';
 import { reviewCodeSchema, handleReviewCode } from './tools/review-code.js';
 import { regenerateBriefSchema, handleRegenerateBrief } from './tools/regenerate-brief.js';
+import { managePatternsSchema, handleManagePatterns } from './tools/manage-patterns.js';
 import { completeSession } from './lib/api-client.js';
 // Prevent unhandled errors from crashing the MCP server
 process.on('uncaughtException', (err) => {
@@ -72,6 +73,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         getTeamStatusSchema,
         reviewCodeSchema,
         regenerateBriefSchema,
+        managePatternsSchema,
     ],
 }));
 // Handle tool calls with per-tool timeout
@@ -94,6 +96,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             get_team_status: handleGetTeamStatus,
             review_code: handleReviewCode,
             regenerate_brief: handleRegenerateBrief,
+            manage_patterns: handleManagePatterns,
         }[name];
         if (!handler) {
             return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };

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

@@ -50,6 +50,16 @@ export declare function indexFile(params: {
     title: string;
     status: 'created' | 'updated';
 }>;
+export declare function listPatterns(projectName: string, status?: string): Promise<any>;
+export declare function deprecatePattern(params: {
+    project_name: string;
+    pattern_id?: string;
+    pattern_name?: string;
+}): Promise<{
+    deprecated: boolean;
+    pattern_name: string;
+    pattern_id: string;
+}>;
 export declare function listTeams(): Promise<any[]>;
 export declare function setupWebhook(teamId: string): Promise<{
     webhook_secret: string;

package/dist/lib/api-client.js

@@ -61,6 +61,12 @@ export async function saveFromAgent(params) {
 export async function indexFile(params) {
     return await apiRequest('POST', '/mcp/index', params);
 }
+export async function listPatterns(projectName, status = 'all') {
+    return await apiRequest('GET', `/mcp/patterns?project_name=${encodeURIComponent(projectName)}&status=${status}`);
+}
+export async function deprecatePattern(params) {
+    return await apiRequest('POST', '/mcp/patterns/deprecate', params);
+}
 export async function listTeams() {
     const data = await apiRequest('GET', '/teams');
     return data ?? [];

package/dist/tools/manage-patterns.d.ts

@@ -0,0 +1,32 @@
+export declare const managePatternsSchema: {
+    name: "manage_patterns";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            pattern_name: {
+                type: "string";
+                description: string;
+            };
+            pattern_id: {
+                type: "string";
+                description: string;
+            };
+            status: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            project: {
+                type: "string";
+                description: string;
+            };
+        };
+    };
+};
+export declare function handleManagePatterns(args: Record<string, unknown>): Promise<string>;

package/dist/tools/manage-patterns.js

@@ -0,0 +1,96 @@
+import { detectProject } from '../lib/project-detector.js';
+import { listPatterns, deprecatePattern } from '../lib/api-client.js';
+import * as session from '../lib/session-state.js';
+export const managePatternsSchema = {
+    name: 'manage_patterns',
+    description: `List or deprecate project patterns. Patterns are team conventions enforced across all agent sessions.
+
+Use when:
+- The user asks to see current patterns ("what patterns do we have?")
+- A pattern is outdated or wrong and should be removed ("deprecate the X pattern")
+- You want to check if a pattern exists before creating a new one
+- After a refactor that invalidates existing patterns
+
+Actions:
+- "list": Show all active patterns for the current project (default)
+- "deprecate": Mark a pattern as deprecated (it stops being enforced)`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['list', 'deprecate'],
+                description: 'Action: "list" to show patterns, "deprecate" to remove one',
+            },
+            pattern_name: {
+                type: 'string',
+                description: 'Pattern name to deprecate (for deprecate action)',
+            },
+            pattern_id: {
+                type: 'string',
+                description: 'Pattern ID to deprecate (alternative to pattern_name)',
+            },
+            status: {
+                type: 'string',
+                enum: ['active', 'deprecated', 'all'],
+                description: 'Filter by status (for list action). Default: active',
+            },
+            project: {
+                type: 'string',
+                description: 'Project name. Default: auto-detect from cwd',
+            },
+        },
+    },
+};
+export async function handleManagePatterns(args) {
+    const action = args.action || 'list';
+    const patternName = args.pattern_name;
+    const patternId = args.pattern_id;
+    const status = args.status || 'active';
+    const projectArg = args.project;
+    // Detect project
+    const detected = projectArg
+        ? { name: projectArg }
+        : await detectProject(process.cwd()).catch(() => null);
+    if (!detected) {
+        return 'Could not detect project. Specify a project name.';
+    }
+    session.recordToolCall();
+    if (action === 'deprecate') {
+        if (!patternName && !patternId) {
+            return 'Specify pattern_name or pattern_id to deprecate.';
+        }
+        try {
+            const result = await deprecatePattern({
+                project_name: detected.name,
+                pattern_id: patternId,
+                pattern_name: patternName,
+            });
+            return `*Pattern deprecated:* "${result.pattern_name}"\n\nThis pattern will no longer be enforced in agent sessions. The brief will update on next regeneration.`;
+        }
+        catch (err) {
+            return `Failed to deprecate pattern: ${err.message}`;
+        }
+    }
+    // Default: list
+    try {
+        const data = await listPatterns(detected.name, status);
+        const patterns = data.patterns || [];
+        if (patterns.length === 0) {
+            return `No ${status === 'all' ? '' : status + ' '}patterns for ${detected.name}.`;
+        }
+        const lines = patterns.map((p, i) => {
+            const statusBadge = p.status === 'deprecated' ? ' [DEPRECATED]' : '';
+            const source = p.established_by === 'pr_review' ? ' (from PR review)'
+                : p.established_by === 'bootstrap' ? ' (from bootstrap)'
+                    : p.established_by === 'agent_auto' ? ' (auto-extracted)'
+                        : p.established_by === 'agent_manual' ? ' (agent-registered)'
+                            : '';
+            return `${i + 1}. **${p.name}**${statusBadge}${source}\n   ${p.description}\n   _id: ${p.id}_`;
+        });
+        return `**Patterns for ${detected.name}** (${status}):\n\n${lines.join('\n\n')}`;
+    }
+    catch (err) {
+        return `Failed to list patterns: ${err.message}`;
+    }
+}

package/package.json

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