@splicr/mcp-server 0.11.1 → 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/api-client.d.ts

@@ -146,7 +146,4 @@ export declare function getDecisions(params: {
 }): Promise<{
     results: any[];
 }>;
-export declare function getTeamStatus(params: {
-    project?: string;
-}): Promise<any>;
 export { API_URL };

package/dist/lib/api-client.js

@@ -104,8 +104,4 @@ 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/lib/github-local.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Local GitHub Status - uses `gh` CLI instead of stored token.
+ * Zero onboarding friction: if the user has `gh auth login` done, this just works.
+ */
+export interface TeamStatus {
+    repo: string;
+    open_prs: Array<{
+        number: number;
+        title: string;
+        author: string;
+        branch: string;
+        updated: string;
+        draft: boolean;
+    }>;
+    recent_merges: Array<{
+        title: string;
+        author: string;
+        merged_at: string;
+    }>;
+    active_branches: Array<{
+        name: string;
+    }>;
+    error?: string;
+}
+export declare function getLocalGitHubStatus(cwd: string): Promise<TeamStatus>;

package/dist/lib/github-local.js

@@ -0,0 +1,92 @@
+/**
+ * Local GitHub Status - uses `gh` CLI instead of stored token.
+ * Zero onboarding friction: if the user has `gh auth login` done, this just works.
+ */
+import { execSync } from 'child_process';
+import { getGitRemoteUrl, normalizeGitUrl } from './project-detector.js';
+/** Check if `gh` CLI is available and authenticated */
+function isGhAvailable() {
+    try {
+        execSync('gh auth status', { encoding: 'utf-8', stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Extract owner/repo from a git remote URL */
+function extractRepoFullName(cwd) {
+    const remote = getGitRemoteUrl(cwd);
+    if (!remote)
+        return null;
+    const normalized = normalizeGitUrl(remote);
+    // https://github.com/owner/repo -> owner/repo
+    const match = normalized.match(/github\.com\/([^/]+\/[^/]+)/);
+    return match ? match[1] : null;
+}
+/** Run a gh api command and parse JSON result */
+function ghApi(endpoint) {
+    try {
+        const result = execSync(`gh api "${endpoint}" --paginate`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 10000,
+        });
+        return JSON.parse(result);
+    }
+    catch {
+        return null;
+    }
+}
+export async function getLocalGitHubStatus(cwd) {
+    const repoFullName = extractRepoFullName(cwd);
+    if (!repoFullName) {
+        return { repo: 'unknown', open_prs: [], recent_merges: [], active_branches: [], error: 'No GitHub remote found in this directory.' };
+    }
+    if (!isGhAvailable()) {
+        return { repo: repoFullName, open_prs: [], recent_merges: [], active_branches: [], error: 'GitHub CLI (gh) not authenticated. Run `gh auth login` to enable team status.' };
+    }
+    const status = {
+        repo: repoFullName,
+        open_prs: [],
+        recent_merges: [],
+        active_branches: [],
+    };
+    // Fetch open PRs
+    const openPRs = ghApi(`repos/${repoFullName}/pulls?state=open&sort=updated&direction=desc&per_page=10`);
+    if (openPRs) {
+        status.open_prs = openPRs.map(pr => ({
+            number: pr.number,
+            title: pr.title,
+            author: pr.user.login,
+            branch: pr.head?.ref || pr.headRefName || '',
+            updated: pr.updated_at || pr.updatedAt || '',
+            draft: pr.draft ?? pr.isDraft ?? false,
+        }));
+    }
+    // Fetch recently merged PRs
+    const mergedPRs = ghApi(`repos/${repoFullName}/pulls?state=closed&sort=updated&direction=desc&per_page=10`);
+    if (mergedPRs) {
+        const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+        status.recent_merges = mergedPRs
+            .filter(pr => {
+            const mergedDate = pr.merged_at || pr.mergedAt || pr.updated_at || pr.updatedAt;
+            return mergedDate && new Date(mergedDate) >= sevenDaysAgo;
+        })
+            .map(pr => ({
+            title: pr.title,
+            author: pr.user.login,
+            merged_at: pr.merged_at || pr.mergedAt || pr.updated_at || pr.updatedAt || '',
+        }));
+    }
+    // Fetch branches
+    const branches = ghApi(`repos/${repoFullName}/branches?per_page=20`);
+    if (branches) {
+        const skipBranches = new Set(['main', 'master', 'develop', 'dev', 'staging', 'production']);
+        status.active_branches = branches
+            .filter(b => !skipBranches.has(b.name))
+            .slice(0, 10)
+            .map(b => ({ name: b.name }));
+    }
+    return status;
+}

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/get-team-status.d.ts

@@ -3,12 +3,7 @@ export declare const getTeamStatusSchema: {
     description: string;
     inputSchema: {
         type: "object";
-        properties: {
-            project: {
-                type: "string";
-                description: string;
-            };
-        };
+        properties: {};
     };
 };
 export declare function handleGetTeamStatus(args: Record<string, unknown>): Promise<string>;

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

@@ -1,5 +1,4 @@
-import { getTeamStatus } from '../lib/api-client.js';
-import { detectProject } from '../lib/project-detector.js';
+import { getLocalGitHubStatus } from '../lib/github-local.js';
 import * as session from '../lib/session-state.js';
 export const getTeamStatusSchema = {
     name: 'get_team_status',
@@ -10,25 +9,14 @@ Use when:
 - 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).`,
+Requires GitHub CLI (gh) to be authenticated. Run \`gh auth login\` if not set up.`,
     inputSchema: {
         type: 'object',
-        properties: {
-            project: { type: 'string', description: 'Project name or "auto" (default: auto)' },
-        },
+        properties: {},
     },
 };
 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 });
+    const data = await getLocalGitHubStatus(process.cwd());
     session.recordToolCall();
     if (data.error) {
         return data.error;

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