@splicr/mcp-server 0.14.0 → 0.14.2

package/dist/cli.js

@@ -198,6 +198,9 @@ async function main() {
         case 'index':
             await runIndex();
             break;
+        case 'webhook':
+            await webhookCommand();
+            break;
         case 'dashboard':
         case 'open': {
             const url = 'https://splicr.dev/dashboard';
@@ -1145,6 +1148,59 @@ function printManualConfig() {
     console.error('    }');
     console.error('  }\n');
 }
+// ─── splicr webhook ───
+async function webhookCommand() {
+    const { hasAuth } = await import('./auth.js');
+    if (!hasAuth()) {
+        console.error('Not authenticated. Run: splicr setup');
+        process.exit(1);
+    }
+    if (subCommand !== 'setup') {
+        console.error(`
+  Splicr Webhooks
+
+  Commands:
+    webhook setup     Generate webhook secret + show GitHub config instructions
+
+  Auto-extracts patterns from PR review comments.
+  When a reviewer says "use X, not Y", Splicr registers it as a team pattern.
+`);
+        return;
+    }
+    const { listTeams, setupWebhook } = await import('./lib/api-client.js');
+    // Get user's teams
+    let teams;
+    try {
+        teams = await listTeams();
+    }
+    catch {
+        console.error('Failed to load teams.');
+        process.exit(1);
+    }
+    if (!teams || teams.length === 0) {
+        console.error('You need a team first. Create one:');
+        console.error('  splicr team create "My Team"');
+        process.exit(1);
+    }
+    const team = teams[0];
+    console.error(`Setting up GitHub webhook for team "${team.name}"...\n`);
+    try {
+        const result = await setupWebhook(team.id);
+        console.error('Webhook secret generated. Configure GitHub:\n');
+        console.error(`  1. Go to your repo -> Settings -> Webhooks -> Add webhook`);
+        console.error(`  2. Payload URL:   ${result.webhook_url}`);
+        console.error(`  3. Content type:  application/json`);
+        console.error(`  4. Secret:        ${result.webhook_secret}`);
+        console.error(`  5. Events:        Select "Pull request review comments"`);
+        console.error(`  6. Click "Add webhook"\n`);
+        console.error('Once configured, Splicr auto-extracts patterns from PR reviews.');
+        console.error('Every agent on the team will follow these patterns.\n');
+    }
+    catch (err) {
+        console.error(`Failed: ${err.message}`);
+        process.exit(1);
+    }
+}
 // ─── splicr index ───
 async function runIndex() {
     const target = process.argv[3];
@@ -1346,6 +1402,7 @@ function printHelp() {
     team join <code>   Join a team by invite code
     index <path>       Index local files into your knowledge base
     index <dir>        Index all supported files in a directory
+    webhook setup      Set up GitHub PR webhook (auto-extract patterns from reviews)
     dashboard          Open knowledge dashboard in browser
     uninstall          Remove Splicr from all coding agents
 

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,21 @@ 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;
+    webhook_url: string;
+}>;
 export declare function resolveProject(params: {
     local_path?: string;
     git_remote_url?: string;

package/dist/lib/api-client.js

@@ -61,6 +61,19 @@ 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 ?? [];
+}
+export async function setupWebhook(teamId) {
+    return await apiRequest('POST', `/teams/${teamId}/webhook`, {});
+}
 export async function resolveProject(params) {
     return await apiRequest('POST', '/mcp/resolve-project', params);
 }

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.0",
+  "version": "0.14.2",
   "description": "Splicr MCP server — route what you read to what you're building",
   "type": "module",
   "bin": "./dist/cli.js",