@splicr/mcp-server 0.11.2 → 0.12.0

package/dist/index.js

@@ -15,6 +15,7 @@ import { grepKnowledgeSchema, handleGrepKnowledge } from './tools/grep-knowledge
 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 { reviewCodeSchema, handleReviewCode } from './tools/review-code.js';
 import { completeSession } from './lib/api-client.js';
 // Prevent unhandled errors from crashing the MCP server
 process.on('uncaughtException', (err) => {
@@ -44,6 +45,9 @@ CONTRACTS (you must follow these):
 3. Only fall back to web search or training data if Splicr returns no results or results don't cover the question.
 4. At the END of significant sessions, call save_from_agent with decisions, discoveries, or workarounds you made. Include the context field for attribution.
 
+QUALITY GATE:
+5. Before committing or opening a PR, call review_code to check your changes against the team's active patterns. Fix any violations before proceeding.
+
 FAILURE MODES:
 - Splicr returns no results → proceed with web search or training data
 - Splicr API is unreachable → proceed without it, don't block the session
@@ -65,6 +69,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         exploreKnowledgeSchema,
         getDecisionsSchema,
         getTeamStatusSchema,
+        reviewCodeSchema,
     ],
 }));
 // Handle tool calls with per-tool timeout
@@ -85,6 +90,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             explore_knowledge: handleExploreKnowledge,
             get_decisions: handleGetDecisions,
             get_team_status: handleGetTeamStatus,
+            review_code: handleReviewCode,
         }[name];
         if (!handler) {
             return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };

package/dist/lib/pattern-validator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pattern Validator - checks git diff against active project patterns.
+ * Core logic reusable from MCP tool, hooks, or future GitHub Action.
+ */
+export interface PatternViolationReport {
+    repo: string;
+    project_name: string | null;
+    diff_stats: {
+        files_changed: number;
+        insertions: number;
+        deletions: number;
+    };
+    patterns_checked: Array<{
+        name: string;
+        description: string;
+    }>;
+    diff_summary: string;
+    review_prompt: string;
+    error?: string;
+}
+export declare function validateAgainstPatterns(cwd: string, scope?: 'staged' | 'unstaged' | 'last-commit' | 'branch'): Promise<PatternViolationReport>;

package/dist/lib/pattern-validator.js

@@ -0,0 +1,163 @@
+/**
+ * Pattern Validator - checks git diff against active project patterns.
+ * Core logic reusable from MCP tool, hooks, or future GitHub Action.
+ */
+import { execSync } from 'child_process';
+import { getProjectContext } from './api-client.js';
+import { detectProject } from './project-detector.js';
+/** Get git diff - supports staged, unstaged, or last N commits */
+function getGitDiff(cwd, scope) {
+    try {
+        const cmds = {
+            'staged': 'git diff --cached',
+            'unstaged': 'git diff',
+            'last-commit': 'git diff HEAD~1 HEAD',
+            'branch': 'git diff main...HEAD',
+        };
+        return execSync(cmds[scope], { cwd, encoding: 'utf-8', maxBuffer: 1024 * 1024 }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** Get diff stats */
+function getDiffStats(cwd, scope) {
+    try {
+        const cmds = {
+            'staged': 'git diff --cached --shortstat',
+            'unstaged': 'git diff --shortstat',
+            'last-commit': 'git diff HEAD~1 HEAD --shortstat',
+            'branch': 'git diff main...HEAD --shortstat',
+        };
+        const stat = execSync(cmds[scope], { cwd, encoding: 'utf-8' }).trim();
+        const files = stat.match(/(\d+) files? changed/)?.[1] || '0';
+        const ins = stat.match(/(\d+) insertions?/)?.[1] || '0';
+        const del = stat.match(/(\d+) deletions?/)?.[1] || '0';
+        return { files_changed: parseInt(files), insertions: parseInt(ins), deletions: parseInt(del) };
+    }
+    catch {
+        return { files_changed: 0, insertions: 0, deletions: 0 };
+    }
+}
+/** Get changed file names */
+function getChangedFiles(cwd, scope) {
+    try {
+        const cmds = {
+            'staged': 'git diff --cached --name-only',
+            'unstaged': 'git diff --name-only',
+            'last-commit': 'git diff HEAD~1 HEAD --name-only',
+            'branch': 'git diff main...HEAD --name-only',
+        };
+        const result = execSync(cmds[scope], { cwd, encoding: 'utf-8' }).trim();
+        return result ? result.split('\n') : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Truncate diff to fit in context - keep most important parts */
+function truncateDiff(diff, maxLines = 200) {
+    const lines = diff.split('\n');
+    if (lines.length <= maxLines)
+        return diff;
+    // Keep first maxLines with a truncation note
+    return lines.slice(0, maxLines).join('\n') + `\n\n... (truncated - ${lines.length - maxLines} more lines. Use a narrower scope for full diff.)`;
+}
+export async function validateAgainstPatterns(cwd, scope = 'staged') {
+    // Detect project
+    const detected = await detectProject(cwd).catch(() => null);
+    if (!detected) {
+        return {
+            repo: cwd,
+            project_name: null,
+            diff_stats: { files_changed: 0, insertions: 0, deletions: 0 },
+            patterns_checked: [],
+            diff_summary: '',
+            review_prompt: '',
+            error: 'Could not detect project. Register this project with Splicr first.',
+        };
+    }
+    // Fetch patterns
+    let patterns = [];
+    try {
+        const ctx = await getProjectContext({
+            project_name: detected.name,
+            project_id: detected.id,
+            limit: 1, // only need patterns
+        });
+        patterns = (ctx.patterns || []).map((p) => ({
+            name: p.name,
+            description: p.description,
+        }));
+    }
+    catch { /* no patterns available */ }
+    if (patterns.length === 0) {
+        return {
+            repo: detected.name,
+            project_name: detected.name,
+            diff_stats: { files_changed: 0, insertions: 0, deletions: 0 },
+            patterns_checked: [],
+            diff_summary: '',
+            review_prompt: '',
+            error: 'No active patterns found for this project. Patterns are established over time as agents save learnings.',
+        };
+    }
+    // Get diff
+    let diff = getGitDiff(cwd, scope);
+    // If staged is empty, try unstaged
+    if (!diff && scope === 'staged') {
+        diff = getGitDiff(cwd, 'unstaged');
+        if (!diff) {
+            diff = getGitDiff(cwd, 'last-commit');
+            if (diff)
+                scope = 'last-commit';
+        }
+        else {
+            scope = 'unstaged';
+        }
+    }
+    if (!diff) {
+        return {
+            repo: detected.name,
+            project_name: detected.name,
+            diff_stats: { files_changed: 0, insertions: 0, deletions: 0 },
+            patterns_checked: patterns,
+            diff_summary: '',
+            review_prompt: '',
+            error: 'No changes detected. Stage changes, make commits, or specify a scope.',
+        };
+    }
+    const stats = getDiffStats(cwd, scope);
+    const files = getChangedFiles(cwd, scope);
+    const truncatedDiff = truncateDiff(diff);
+    // Build the review prompt - the agent IS the AI reviewer
+    const patternList = patterns.map((p, i) => `${i + 1}. **${p.name}** — ${p.description}`).join('\n');
+    const reviewPrompt = `## Pattern Compliance Review
+
+### Active Patterns (${patterns.length}):
+${patternList}
+
+### Changes (${scope}, ${stats.files_changed} files, +${stats.insertions}/-${stats.deletions}):
+Files: ${files.join(', ')}
+
+### Diff:
+\`\`\`diff
+${truncatedDiff}
+\`\`\`
+
+### Your task:
+Review the diff above against each active pattern. For each pattern:
+- **PASS** if the changes comply or the pattern is not relevant to these changes
+- **VIOLATION** if the changes contradict the pattern - cite the specific line(s)
+- **WARNING** if the changes are in a gray area
+
+End with a summary: total violations, total warnings, and whether this is safe to merge.`;
+    return {
+        repo: detected.name,
+        project_name: detected.name,
+        diff_stats: stats,
+        patterns_checked: patterns,
+        diff_summary: `${stats.files_changed} files changed (+${stats.insertions}/-${stats.deletions}): ${files.slice(0, 5).join(', ')}${files.length > 5 ? ` +${files.length - 5} more` : ''}`,
+        review_prompt: reviewPrompt,
+    };
+}

package/dist/tools/review-code.d.ts

@@ -0,0 +1,15 @@
+export declare const reviewCodeSchema: {
+    name: "review_code";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            scope: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+        };
+    };
+};
+export declare function handleReviewCode(args: Record<string, unknown>): Promise<string>;

package/dist/tools/review-code.js

@@ -0,0 +1,45 @@
+import { validateAgainstPatterns } from '../lib/pattern-validator.js';
+import * as session from '../lib/session-state.js';
+export const reviewCodeSchema = {
+    name: 'review_code',
+    description: `Review current code changes against the team's active patterns. Checks your git diff for pattern violations before you commit or open a PR.
+
+Use when:
+- Before committing: catch violations early
+- Before opening a PR: ensure compliance with team conventions
+- After making changes: self-review against established patterns
+- When asked to review code quality
+
+Scopes:
+- "staged" (default): checks staged changes (git diff --cached)
+- "unstaged": checks working directory changes
+- "last-commit": checks the most recent commit
+- "branch": checks all changes since diverging from main
+
+Returns the diff + active patterns formatted for review. You (the agent) are the reviewer - analyze each pattern against the changes and report violations.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            scope: {
+                type: 'string',
+                enum: ['staged', 'unstaged', 'last-commit', 'branch'],
+                description: 'What to review: staged (default), unstaged, last-commit, or branch (all commits since main)',
+            },
+        },
+    },
+};
+export async function handleReviewCode(args) {
+    const scope = args.scope || 'staged';
+    const report = await validateAgainstPatterns(process.cwd(), scope);
+    session.recordToolCall();
+    if (report.error) {
+        return report.error;
+    }
+    // Header
+    let output = `*Pattern review for ${report.project_name}*\n`;
+    output += `${report.diff_summary}\n`;
+    output += `Checking against ${report.patterns_checked.length} active pattern(s).\n\n`;
+    // The review prompt — agent reads this and does the actual review
+    output += report.review_prompt;
+    return output;
+}

package/package.json

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