@splicr/mcp-server 0.11.2 → 0.13.0

package/dist/cli.js

@@ -433,6 +433,11 @@ async function runHook() {
             }
         }
         const [{ results }, patternData] = await Promise.all([contextPromise, patternsPromise]);
+        // Build brief section (first message only)
+        let briefSection = '';
+        if (isFirstMessage && patternData.brief) {
+            briefSection = `${patternData.brief}\n\n---\n\n`;
+        }
         // Build patterns section (first message only, deterministic enforcement)
         let patternsSection = '';
         if (isFirstMessage && patternData.patterns && patternData.patterns.length > 0) {
@@ -441,7 +446,7 @@ async function runHook() {
             // Mark patterns as injected for this session
             saveSessionMeta(sessionId, { patterns_injected: true });
         }
-        if ((!results || results.length === 0) && !patternsSection) {
+        if ((!results || results.length === 0) && !patternsSection && !briefSection) {
             process.exit(0);
             return;
         }
@@ -466,7 +471,7 @@ async function runHook() {
             }).join('\n\n');
             contextSection = `SPLICR CONTEXT — The user's saved research matched this task. Use these findings to inform your response:\n\n${contextLines}\n\nACTION: Review above before answering. Call get_full_content(id) for complete articles. Fall back to web search only if these don't cover the question.`;
         }
-        const context = patternsSection + contextSection;
+        const context = briefSection + patternsSection + contextSection;
         if (!context.trim()) {
             process.exit(0);
             return;

package/dist/index.js

@@ -15,6 +15,8 @@ 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 { regenerateBriefSchema, handleRegenerateBrief } from './tools/regenerate-brief.js';
 import { completeSession } from './lib/api-client.js';
 // Prevent unhandled errors from crashing the MCP server
 process.on('uncaughtException', (err) => {
@@ -44,6 +46,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 +70,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         exploreKnowledgeSchema,
         getDecisionsSchema,
         getTeamStatusSchema,
+        reviewCodeSchema,
+        regenerateBriefSchema,
     ],
 }));
 // Handle tool calls with per-tool timeout
@@ -85,6 +92,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             explore_knowledge: handleExploreKnowledge,
             get_decisions: handleGetDecisions,
             get_team_status: handleGetTeamStatus,
+            review_code: handleReviewCode,
+            regenerate_brief: handleRegenerateBrief,
         }[name];
         if (!handler) {
             return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };

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

@@ -13,6 +13,7 @@ export declare function getProjectContext(params: {
     results: any[];
     patterns?: any[];
     project_name?: string;
+    brief?: string;
 }>;
 export declare function getRecentInsights(params: {
     days?: number;

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/regenerate-brief.d.ts

@@ -0,0 +1,9 @@
+export declare const regenerateBriefSchema: {
+    name: "regenerate_brief";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+};
+export declare function handleRegenerateBrief(args: Record<string, unknown>): Promise<string>;

package/dist/tools/regenerate-brief.js

@@ -0,0 +1,60 @@
+import { detectProject } from '../lib/project-detector.js';
+import { gatherProjectProfile } from '../lib/profile-gatherer.js';
+import * as session from '../lib/session-state.js';
+import { loadAuth } from '../auth.js';
+import { getSessionId } from '../lib/session-state.js';
+const API_URL = process.env.SPLICR_API_URL || 'https://api-production-d889.up.railway.app';
+export const regenerateBriefSchema = {
+    name: 'regenerate_brief',
+    description: `Regenerate the project onboarding brief. The brief is an auto-generated summary that gives agents instant context about the codebase (architecture, conventions, how-tos, gotchas).
+
+Use when:
+- The brief feels outdated or incomplete
+- After significant project changes (new framework, major refactor)
+- When you want to refresh the project context with latest patterns and learnings
+- On first use if no brief exists yet
+
+The brief is generated from: project patterns, accumulated learnings, local codebase analysis (directory structure, recent commits, tech stack).`,
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+};
+export async function handleRegenerateBrief(args) {
+    const cwd = process.cwd();
+    // Detect project
+    const detected = await detectProject(cwd).catch(() => null);
+    if (!detected) {
+        return 'Could not detect project. Register this project with Splicr first.';
+    }
+    // Gather local profile data for richer brief
+    const profileData = gatherProjectProfile(cwd);
+    // Call API to regenerate
+    const auth = await loadAuth();
+    const res = await fetch(`${API_URL}/mcp/regenerate-brief`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${auth.accessToken}`,
+            'Content-Type': 'application/json',
+            'X-Splicr-Session-Id': getSessionId(),
+        },
+        body: JSON.stringify({
+            project_name: detected.name,
+            profile_data: {
+                recent_commits: profileData.recent_commits,
+                directory_structure: profileData.directory_structure,
+            },
+        }),
+        signal: AbortSignal.timeout(30000),
+    });
+    session.recordToolCall();
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+        return `Brief regeneration failed: ${err.error || res.status}`;
+    }
+    const data = await res.json();
+    if (data.data?.updated) {
+        return `*Brief regenerated for ${detected.name}:*\n\n${data.data.brief}`;
+    }
+    return data.data?.error || 'Brief regeneration produced no result.';
+}

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