@simonren/quorum 0.7.0

package/dist/index.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Quorum MCP Server
+ *
+ * Provides tools for getting second-opinion reviews from external AI CLIs
+ * (Codex and Gemini) on Claude Code's work.
+ *
+ * Features:
+ * - Single model review (codex_review, gemini_review)
+ * - Multi-model parallel review (multi_review)
+ * - Structured JSON output with confidence scores
+ * - Expert role specialization per focus area
+ *
+ * Usage:
+ * - npx -y @simonren/quorum         # Run MCP server (normal usage)
+ * - npx -y @simonren/quorum update  # Install/update slash commands
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { handleMultiReview, ReviewInputSchema, TOOL_DEFINITIONS, } from './tools/feedback.js';
+import { handleMultiConsult, ConsultInputSchema, MULTI_CONSULT_TOOL_DEFINITION, } from './tools/consult.js';
+import { logCliStatus } from './cli/check.js';
+import { installCommands } from './commands.js';
+import { initConfig } from './config.js';
+// Read version from package.json
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+const __pkg = JSON.parse(readFileSync(__pkgPath, 'utf-8'));
+const VERSION = __pkg.version;
+// Handle subcommands
+const subcommand = process.argv[2];
+if (subcommand === 'update' || subcommand === '--setup' || subcommand === '--commands') {
+    const result = installCommands();
+    if (result.success) {
+        console.log(`quorum v${VERSION}`);
+        if (result.removed.length > 0) {
+            console.log(`✓ Removed ${result.removed.length} deprecated commands: ${result.removed.map(c => `/${c}`).join(', ')}`);
+        }
+        console.log(`✓ Installed ${result.installed.length} slash commands: ${result.installed.map(c => `/${c}`).join(', ')}`);
+        process.exit(0);
+    }
+    else {
+        console.error(`✗ Failed to install commands: ${result.error}`);
+        process.exit(1);
+    }
+}
+// Import adapters to register them
+import './adapters/index.js';
+// Create the MCP server
+const server = new Server({
+    name: 'quorum',
+    version: VERSION,
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Handle tool listing
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            TOOL_DEFINITIONS.multi_review,
+            MULTI_CONSULT_TOOL_DEFINITION,
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'multi_review': {
+                const input = ReviewInputSchema.parse(args);
+                return await handleMultiReview(input);
+            }
+            case 'multi_consult': {
+                const input = ConsultInputSchema.parse(args);
+                return await handleMultiConsult(input);
+            }
+            default:
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Unknown tool: ${name}`
+                        }],
+                    isError: true
+                };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error: ${errorMessage}`
+                }],
+            isError: true
+        };
+    }
+});
+// Start the server
+async function main() {
+    // Initialize config (writes defaults to ~/.config/quorum/config.json on first run)
+    try {
+        const cfg = initConfig();
+        console.error(cfg.created
+            ? `[quorum] Initialized config at ${cfg.path}`
+            : `[quorum] Loaded config from ${cfg.path}`);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[quorum] Warning: Could not initialize config: ${msg}`);
+    }
+    // Auto-install slash commands
+    const result = installCommands();
+    if (result.success) {
+        console.error(`[quorum] Installed ${result.installed.length} slash commands`);
+    }
+    else {
+        console.error(`[quorum] Warning: Could not install commands: ${result.error}`);
+    }
+    // Log CLI availability status on startup
+    await logCliStatus();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Quorum MCP server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/pipeline.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Review Response Processing Pipeline
+ *
+ * Processes reviewer output through multiple stages:
+ * 1. Parse - Extract structured data
+ * 2. Verify - Check file/line references exist
+ * 3. Cross-check - Compare with CC's knowledge
+ * 4. Prioritize - Rank by impact and confidence
+ * 5. Plan - Generate actionable next steps
+ */
+import { ReviewOutput, ReviewFinding } from './schema.js';
+import { ReviewContext, VerificationData } from './context.js';
+export interface PipelineStage<TInput, TOutput> {
+    name: string;
+    process(input: TInput, context: PipelineContext): Promise<TOutput>;
+}
+export interface PipelineContext {
+    workingDir: string;
+    reviewContext: ReviewContext;
+    verificationData?: VerificationData;
+}
+export interface VerifiedFinding extends ReviewFinding {
+    verification: {
+        fileExists: boolean;
+        lineValid: boolean;
+        codeSnippetMatches?: boolean;
+        verificationNotes?: string;
+    };
+    crossCheck: {
+        alreadyAddressedByCC: boolean;
+        conflictsWithCC: boolean;
+        ccMentioned: boolean;
+    };
+    adjustedConfidence: number;
+}
+export interface ActionItem {
+    finding: VerifiedFinding;
+    action: 'fix_now' | 'investigate' | 'defer' | 'reject';
+    priority: number;
+    suggestedFix?: string;
+    reason: string;
+}
+export interface ProcessedReview {
+    original: ReviewOutput;
+    verified: VerifiedFinding[];
+    rejected: {
+        finding: ReviewFinding;
+        reason: string;
+    }[];
+    actionPlan: ActionItem[];
+    summary: {
+        totalFindings: number;
+        verifiedCount: number;
+        rejectedCount: number;
+        actionableCount: number;
+        topPriority: ActionItem[];
+    };
+}
+/**
+ * Simple file cache to avoid re-reading files for each finding
+ */
+export declare class FileCache {
+    private workingDir;
+    private contentCache;
+    private lineCountCache;
+    private linesCache;
+    constructor(workingDir: string);
+    /**
+     * Check if file exists (cached)
+     */
+    exists(relativePath: string): boolean;
+    /**
+     * Get file content (cached, lazy-loaded)
+     */
+    getContent(relativePath: string): string | null;
+    /**
+     * Get lines array (cached)
+     */
+    getLines(relativePath: string): string[] | null;
+    /**
+     * Get line count (cached)
+     */
+    getLineCount(relativePath: string): number | null;
+    /**
+     * Get stats about cache usage
+     */
+    getStats(): {
+        filesChecked: number;
+        filesLoaded: number;
+    };
+}
+/**
+ * Build verification data by scanning the filesystem
+ */
+export declare function buildVerificationData(workingDir: string): Promise<VerificationData>;
+/**
+ * Verify a single finding's references
+ * @param finding The finding to verify
+ * @param workingDir Working directory for path resolution
+ * @param cache Optional file cache for performance (recommended for multiple findings)
+ */
+export declare function verifyFinding(finding: ReviewFinding, workingDir: string, cache?: FileCache): Promise<VerifiedFinding>;
+/**
+ * Cross-check findings against CC's analysis
+ */
+export declare function crossCheckWithCC(finding: VerifiedFinding, ccAnalysis: ReviewContext['analysis']): VerifiedFinding;
+/**
+ * Calculate priority score for a finding
+ */
+export declare function calculatePriority(finding: VerifiedFinding): number;
+/**
+ * Determine action for a finding
+ */
+export declare function determineAction(finding: VerifiedFinding, priority: number): {
+    action: ActionItem['action'];
+    reason: string;
+};
+/**
+ * Process a review output through the full verification pipeline
+ */
+export declare function processReviewOutput(output: ReviewOutput, context: ReviewContext): Promise<ProcessedReview>;
+/**
+ * Format processed review for display
+ */
+export declare function formatProcessedReview(processed: ProcessedReview): string;
+export interface FollowUpQuestion {
+    topic: string;
+    question: string;
+    relatedFindings: string[];
+    context: string;
+}
+/**
+ * Generate follow-up questions for uncertain findings
+ */
+export declare function generateFollowUpQuestions(processed: ProcessedReview): FollowUpQuestion[];