@dotcontext/cli 0.8.0

package/dist/services/mcp/mcpServer.js

@@ -0,0 +1,844 @@
+"use strict";
+/**
+ * MCP Server - Model Context Protocol server for Claude Code integration
+ *
+ * Exposes 9 tools (5 consolidated gateways + 4 dedicated workflow tools) for
+ * reduced context and simpler tool selection for AI agents.
+ *
+ * Simplified workflow: context init → fillSingle → workflow-init
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIContextMCPServer = void 0;
+exports.startMCPServer = startMCPServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const tools_1 = require("../ai/tools");
+const pathSecurity_1 = require("../../utils/pathSecurity");
+const contextBuilder_1 = require("../semantic/contextBuilder");
+const contextCache_1 = require("../semantic/contextCache");
+const version_1 = require("../../version");
+const workflow_1 = require("../workflow");
+const actionLogger_1 = require("./actionLogger");
+const workflow_2 = require("../../workflow");
+const gatewayTools_1 = require("./gatewayTools");
+class AIContextMCPServer {
+    constructor(options = {}) {
+        this.transport = null;
+        this.initialRepoPath = null;
+        this.cachedRepoPath = null;
+        this.options = {
+            name: 'dotcontext',
+            verbose: false,
+            ...options
+        };
+        this.server = new mcp_js_1.McpServer({
+            name: this.options.name,
+            version: version_1.VERSION
+        });
+        // Support dependency injection for testing, with default fallback
+        this.contextBuilder = options.contextBuilder ?? new contextBuilder_1.SemanticContextBuilder();
+        this.contextCache = new contextCache_1.ContextCache();
+        // Initialize and cache the correct repo path
+        void this.initializeRepoPath();
+        this.registerGatewayTools();
+        this.registerResources();
+    }
+    /**
+     * Register tools: 5 consolidated gateways + 4 dedicated workflow tools
+     * Total: 9 tools for clear entry points and reduced AI cognitive load
+     *
+     * Project tools removed - use context({ action: "init" }) + workflow-init instead
+     *
+     * NOTE: repoPath is now determined dynamically via getRepoPath() at runtime,
+     * which uses smart initialization and client path caching.
+     */
+    registerGatewayTools() {
+        const wrap = (toolName, handler) => this.wrapWithActionLogging(toolName, handler);
+        // Gateway 1: explore - File and code exploration
+        this.server.registerTool('explore', {
+            description: `File and code exploration. Actions:
+- read: Read file contents (params: filePath, encoding?)
+- list: List files matching pattern (params: pattern, cwd?, ignore?)
+- analyze: Analyze symbols in a file (params: filePath, symbolTypes?)
+- search: Search code with regex (params: pattern, fileGlob?, maxResults?, cwd?)
+- getStructure: Get directory structure (params: rootPath?, maxDepth?, includePatterns?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['read', 'list', 'analyze', 'search', 'getStructure'])
+                    .describe('Action to perform'),
+                filePath: zod_1.z.string().optional()
+                    .describe('(read, analyze) File path to read or analyze'),
+                pattern: zod_1.z.string().optional()
+                    .describe('(list, search) Glob pattern for list, regex pattern for search'),
+                cwd: zod_1.z.string().optional()
+                    .describe('(list, search) Working directory'),
+                encoding: zod_1.z.enum(['utf-8', 'ascii', 'binary']).optional()
+                    .describe('(read) File encoding'),
+                ignore: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(list) Patterns to ignore'),
+                symbolTypes: zod_1.z.array(zod_1.z.enum(['class', 'interface', 'function', 'type', 'enum'])).optional()
+                    .describe('(analyze) Types of symbols to extract'),
+                fileGlob: zod_1.z.string().optional()
+                    .describe('(search) Glob pattern to filter files'),
+                maxResults: zod_1.z.number().optional()
+                    .describe('(search) Maximum results to return'),
+                rootPath: zod_1.z.string().optional()
+                    .describe('(getStructure) Root path for structure'),
+                maxDepth: zod_1.z.number().optional()
+                    .describe('(getStructure) Maximum directory depth'),
+                includePatterns: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(getStructure) Include patterns'),
+            }
+        }, wrap('explore', async (params) => {
+            // explore uses cwd for file operations, not repoPath for context resolution
+            return (0, gatewayTools_1.handleExplore)(params, { repoPath: this.getRepoPath() });
+        }));
+        // Gateway 2: context - Context scaffolding and semantic context
+        this.server.registerTool('context', {
+            description: `Context scaffolding and semantic context. Actions:
+- check: Check if .context scaffolding exists (params: repoPath?)
+- init: Initialize .context scaffolding (params: repoPath?, type?, outputDir?, semantic?, autoFill?, skipContentGeneration?)
+- fill: Fill scaffolding with AI content (params: repoPath?, outputDir?, target?, offset?, limit?)
+- fillSingle: Fill a single scaffold file (params: repoPath?, filePath)
+- listToFill: List files that need filling (params: repoPath?, outputDir?, target?)
+- getMap: Get codebase map section (params: repoPath?, section?)
+- buildSemantic: Build semantic context (params: repoPath?, contextType?, targetFile?, options?)
+- scaffoldPlan: Create a plan template (params: planName, repoPath?, title?, summary?, autoFill?)
+
+**Important:** Agents should provide repoPath on the FIRST call, then it will be cached:
+1. First call: context({ action: "check", repoPath: "/path/to/project" })
+2. Subsequent calls can omit repoPath - it will use cached value from step 1
+3. After context init, call fillSingle for each pending file
+4. Call workflow-init to enable PREVC workflow (unless trivial change)`,
+            inputSchema: {
+                action: zod_1.z.enum(['check', 'init', 'fill', 'fillSingle', 'listToFill', 'getMap', 'buildSemantic', 'scaffoldPlan'])
+                    .describe('Action to perform'),
+                repoPath: zod_1.z.string().optional()
+                    .describe('Repository path (defaults to cwd)'),
+                outputDir: zod_1.z.string().optional()
+                    .describe('Output directory (default: ./.context)'),
+                type: zod_1.z.enum(['docs', 'agents', 'both']).optional()
+                    .describe('(init) Type of scaffolding to create'),
+                semantic: zod_1.z.boolean().optional()
+                    .describe('(init, scaffoldPlan) Enable semantic analysis'),
+                include: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(init) Include patterns'),
+                exclude: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(init) Exclude patterns'),
+                autoFill: zod_1.z.boolean().optional()
+                    .describe('(init, scaffoldPlan) Auto-fill with codebase content'),
+                skipContentGeneration: zod_1.z.boolean().optional()
+                    .describe('(init) Skip pre-generating content'),
+                target: zod_1.z.enum(['docs', 'agents', 'plans', 'all']).optional()
+                    .describe('(fill, listToFill) Which scaffolding to target'),
+                offset: zod_1.z.number().optional()
+                    .describe('(fill) Skip first N files'),
+                limit: zod_1.z.number().optional()
+                    .describe('(fill) Max files to return'),
+                filePath: zod_1.z.string().optional()
+                    .describe('(fillSingle) Absolute path to scaffold file'),
+                section: zod_1.z.enum([
+                    'all', 'stack', 'structure', 'architecture', 'symbols',
+                    'symbols.classes', 'symbols.interfaces', 'symbols.functions',
+                    'symbols.types', 'symbols.enums', 'publicAPI', 'dependencies', 'stats'
+                ]).optional()
+                    .describe('(getMap) Section to retrieve'),
+                contextType: zod_1.z.enum(['documentation', 'playbook', 'plan', 'compact']).optional()
+                    .describe('(buildSemantic) Type of context to build'),
+                targetFile: zod_1.z.string().optional()
+                    .describe('(buildSemantic) Target file for focused context'),
+                options: zod_1.z.object({
+                    useLSP: zod_1.z.boolean().optional(),
+                    maxContextLength: zod_1.z.number().optional(),
+                    includeDocumentation: zod_1.z.boolean().optional(),
+                    includeSignatures: zod_1.z.boolean().optional()
+                }).optional()
+                    .describe('(buildSemantic) Builder options'),
+                planName: zod_1.z.string().optional()
+                    .describe('(scaffoldPlan) Name of the plan'),
+                title: zod_1.z.string().optional()
+                    .describe('(scaffoldPlan) Plan title'),
+                summary: zod_1.z.string().optional()
+                    .describe('(scaffoldPlan) Plan summary/goal'),
+            }
+        }, wrap('context', async (params) => {
+            return (0, gatewayTools_1.handleContext)(params, { repoPath: this.getRepoPath(params.repoPath), contextBuilder: this.contextBuilder });
+        }));
+        // Dedicated Workflow Tools (split from consolidated workflow gateway)
+        // Tool 3a: workflow-init - Initialize PREVC workflow
+        this.server.registerTool('workflow-init', {
+            description: `Initialize a PREVC workflow for structured development.
+
+**What it does:**
+- Creates .context/workflow/ folder (automatically, if it doesn't exist)
+- Initializes workflow status file with phase tracking
+- Detects project scale and configures gates
+- Sets up PREVC phases (Plan → Review → Execute → Verify → Complete)
+
+**Prerequisites:**
+- .context/ folder must exist (use context with action "init" first)
+- Scaffolding files should be filled (use context with action "fillSingle")
+
+**When to use:**
+- Starting a new feature or bug fix after scaffolding is set up
+- Need structured, phase-gated development
+- Working on non-trivial changes
+
+**Don't use if:**
+- Making trivial changes (typo fixes, single-line edits)
+- Just exploring/researching code
+- User explicitly wants to skip workflow`,
+            inputSchema: {
+                name: zod_1.z.string().describe('Workflow/feature name (required)'),
+                description: zod_1.z.string().optional()
+                    .describe('Task description for scale detection'),
+                scale: zod_1.z.enum(['QUICK', 'SMALL', 'MEDIUM', 'LARGE']).optional()
+                    .describe(`Project scale - AI should evaluate based on task characteristics:
+
+SCALE EVALUATION CRITERIA:
+• QUICK: Single file changes, bug fixes, typos (~5 min)
+  - Phases: E → V only
+  - Example: "Fix typo in button text"
+
+• SMALL: Simple features, no architecture changes (~15 min)
+  - Phases: P → E → V
+  - Example: "Add email validation to form"
+
+• MEDIUM: Regular features with design decisions (~30 min)
+  - Phases: P → R → E → V
+  - Example: "Implement user profile page"
+
+• LARGE: Complex features, systems, compliance (~1+ hour)
+  - Phases: P → R → E → V → C (full workflow)
+  - Examples: "Build OAuth system", "Add GDPR compliance"
+
+GUIDANCE:
+- Analyze task complexity, architectural impact, and review needs
+- Use LARGE for security/compliance requirements
+- When uncertain, prefer MEDIUM
+- Omit scale only if unable to evaluate (auto-detect fallback)`),
+                autonomous: zod_1.z.boolean().optional()
+                    .describe('Skip all workflow gates (default: scale-dependent)'),
+                require_plan: zod_1.z.boolean().optional()
+                    .describe('Require plan before P→R'),
+                require_approval: zod_1.z.boolean().optional()
+                    .describe('Require approval before R→E'),
+                archive_previous: zod_1.z.boolean().optional()
+                    .describe('Archive existing workflow'),
+            }
+        }, wrap('workflow-init', async (params) => {
+            return (0, gatewayTools_1.handleWorkflowInit)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Tool 3b: workflow-status - Get current workflow status
+        this.server.registerTool('workflow-status', {
+            description: `Get current PREVC workflow status including phase, gates, and linked plans.
+
+Returns: Current phase, all phase statuses, gate settings, linked plans, agent activity.`,
+            inputSchema: {
+            // No required parameters
+            }
+        }, wrap('workflow-status', async (params) => {
+            return (0, gatewayTools_1.handleWorkflowStatus)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Tool 3c: workflow-advance - Advance to next phase
+        this.server.registerTool('workflow-advance', {
+            description: `Advance workflow to the next PREVC phase (P→R→E→V→C).
+
+Enforces gates:
+- P→R: Requires plan if require_plan=true
+- R→E: Requires approval if require_approval=true
+
+Use force=true to bypass gates, or use workflow-manage({ action: 'setAutonomous' }).`,
+            inputSchema: {
+                outputs: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('Artifact paths produced in current phase'),
+                force: zod_1.z.boolean().optional()
+                    .describe('Force advancement even if gates block'),
+            }
+        }, wrap('workflow-advance', async (params) => {
+            return (0, gatewayTools_1.handleWorkflowAdvance)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Tool 3d: workflow-manage - Manage workflow operations
+        this.server.registerTool('workflow-manage', {
+            description: `Manage workflow operations: handoffs, collaboration, documents, gates, approvals.
+
+Actions:
+- handoff: Transfer work between agents (params: from, to, artifacts)
+- collaborate: Start collaboration session (params: topic, participants?)
+- createDoc: Create workflow document (params: type, docName)
+- getGates: Check gate status
+- approvePlan: Approve linked plan (params: planSlug?, approver?, notes?)
+- setAutonomous: Toggle autonomous mode (params: enabled, reason?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['handoff', 'collaborate', 'createDoc', 'getGates', 'approvePlan', 'setAutonomous'])
+                    .describe('Action to perform'),
+                from: zod_1.z.string().optional()
+                    .describe('(handoff) Agent handing off (e.g., feature-developer)'),
+                to: zod_1.z.string().optional()
+                    .describe('(handoff) Agent receiving (e.g., code-reviewer)'),
+                artifacts: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(handoff) Artifacts to hand off'),
+                topic: zod_1.z.string().optional()
+                    .describe('(collaborate) Collaboration topic'),
+                participants: zod_1.z.array(zod_1.z.enum(workflow_2.PREVC_ROLES)).optional()
+                    .describe('(collaborate) Participating roles'),
+                type: zod_1.z.enum(['prd', 'tech-spec', 'architecture', 'adr', 'test-plan', 'changelog']).optional()
+                    .describe('(createDoc) Document type'),
+                docName: zod_1.z.string().optional()
+                    .describe('(createDoc) Document name'),
+                planSlug: zod_1.z.string().optional()
+                    .describe('(approvePlan) Plan to approve'),
+                approver: zod_1.z.enum(workflow_2.PREVC_ROLES).optional()
+                    .describe('(approvePlan) Approving role'),
+                notes: zod_1.z.string().optional()
+                    .describe('(approvePlan) Approval notes'),
+                enabled: zod_1.z.boolean().optional()
+                    .describe('(setAutonomous) Enable/disable'),
+                reason: zod_1.z.string().optional()
+                    .describe('(setAutonomous) Reason for change'),
+            }
+        }, wrap('workflow-manage', async (params) => {
+            return (0, gatewayTools_1.handleWorkflowManage)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Gateway 5: sync - Import/export synchronization
+        this.server.registerTool('sync', {
+            description: `Import/export synchronization with AI tools. Actions:
+- exportRules: Export rules to AI tools (params: preset?, force?, dryRun?)
+- exportDocs: Export docs to AI tools (params: preset?, indexMode?, force?, dryRun?)
+- exportAgents: Export agents to AI tools (params: preset?, mode?, force?, dryRun?)
+- exportContext: Export all context (params: preset?, skipDocs?, skipAgents?, skipSkills?, docsIndexMode?, agentMode?, force?, dryRun?)
+- exportSkills: Export skills to AI tools (params: preset?, includeBuiltIn?, force?)
+- reverseSync: Import from AI tools to .context/ (params: skipRules?, skipAgents?, skipSkills?, mergeStrategy?, dryRun?, force?, addMetadata?)
+- importDocs: Import docs from AI tools (params: autoDetect?, force?, dryRun?)
+- importAgents: Import agents from AI tools (params: autoDetect?, force?, dryRun?)
+- importSkills: Import skills from AI tools (params: autoDetect?, mergeStrategy?, force?, dryRun?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['exportRules', 'exportDocs', 'exportAgents', 'exportContext', 'exportSkills', 'reverseSync', 'importDocs', 'importAgents', 'importSkills'])
+                    .describe('Action to perform'),
+                preset: zod_1.z.string().optional()
+                    .describe('Target AI tool preset'),
+                force: zod_1.z.boolean().optional()
+                    .describe('Overwrite existing files'),
+                dryRun: zod_1.z.boolean().optional()
+                    .describe('Preview without writing'),
+                indexMode: zod_1.z.enum(['readme', 'all']).optional()
+                    .describe('(exportDocs) Index mode'),
+                mode: zod_1.z.enum(['symlink', 'markdown']).optional()
+                    .describe('(exportAgents) Sync mode'),
+                skipDocs: zod_1.z.boolean().optional()
+                    .describe('(exportContext) Skip docs'),
+                skipAgents: zod_1.z.boolean().optional()
+                    .describe('(exportContext, reverseSync) Skip agents'),
+                skipSkills: zod_1.z.boolean().optional()
+                    .describe('(exportContext, reverseSync) Skip skills'),
+                skipRules: zod_1.z.boolean().optional()
+                    .describe('(reverseSync) Skip rules'),
+                docsIndexMode: zod_1.z.enum(['readme', 'all']).optional()
+                    .describe('(exportContext) Docs index mode'),
+                agentMode: zod_1.z.enum(['symlink', 'markdown']).optional()
+                    .describe('(exportContext) Agent sync mode'),
+                includeBuiltInSkills: zod_1.z.boolean().optional()
+                    .describe('(exportContext) Include built-in skills'),
+                includeBuiltIn: zod_1.z.boolean().optional()
+                    .describe('(exportSkills) Include built-in skills'),
+                mergeStrategy: zod_1.z.enum(['skip', 'overwrite', 'merge', 'rename']).optional()
+                    .describe('(reverseSync, importSkills) Conflict handling'),
+                autoDetect: zod_1.z.boolean().optional()
+                    .describe('(import*) Auto-detect files'),
+                addMetadata: zod_1.z.boolean().optional()
+                    .describe('(reverseSync) Add frontmatter metadata'),
+                repoPath: zod_1.z.string().optional()
+                    .describe('Repository path'),
+            }
+        }, wrap('sync', async (params) => {
+            return (0, gatewayTools_1.handleSync)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Gateway 6: plan - Plan management and execution tracking
+        this.server.registerTool('plan', {
+            description: `Plan management and execution tracking. Actions:
+- link: Link plan to workflow (params: planSlug)
+- getLinked: Get all linked plans
+- getDetails: Get detailed plan info (params: planSlug)
+- getForPhase: Get plans for PREVC phase (params: phase)
+- updatePhase: Update plan phase status (params: planSlug, phaseId, status)
+- recordDecision: Record a decision (params: planSlug, title, description, phase?, alternatives?)
+- updateStep: Update step status (params: planSlug, phaseId, stepIndex, status, output?, notes?)
+- getStatus: Get plan execution status (params: planSlug)
+- syncMarkdown: Sync tracking to markdown (params: planSlug)
+- commitPhase: Create git commit for completed phase (params: planSlug, phaseId, coAuthor?, stagePatterns?, dryRun?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['link', 'getLinked', 'getDetails', 'getForPhase', 'updatePhase', 'recordDecision', 'updateStep', 'getStatus', 'syncMarkdown', 'commitPhase'])
+                    .describe('Action to perform'),
+                planSlug: zod_1.z.string().optional()
+                    .describe('Plan slug/identifier'),
+                phaseId: zod_1.z.string().optional()
+                    .describe('(updatePhase, updateStep, commitPhase) Phase ID'),
+                status: zod_1.z.enum(['pending', 'in_progress', 'completed', 'skipped']).optional()
+                    .describe('(updatePhase, updateStep) New status'),
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).optional()
+                    .describe('(getForPhase, recordDecision) PREVC phase'),
+                title: zod_1.z.string().optional()
+                    .describe('(recordDecision) Decision title'),
+                description: zod_1.z.string().optional()
+                    .describe('(recordDecision) Decision description'),
+                alternatives: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(recordDecision) Considered alternatives'),
+                stepIndex: zod_1.z.number().optional()
+                    .describe('(updateStep) Step number (1-based)'),
+                output: zod_1.z.string().optional()
+                    .describe('(updateStep) Step output artifact'),
+                notes: zod_1.z.string().optional()
+                    .describe('(updateStep) Execution notes'),
+                coAuthor: zod_1.z.string().optional()
+                    .describe('(commitPhase) Agent name for Co-Authored-By footer'),
+                stagePatterns: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(commitPhase) Patterns for files to stage (default: [".context/**"])'),
+                dryRun: zod_1.z.boolean().optional()
+                    .describe('(commitPhase) Preview without committing'),
+            }
+        }, wrap('plan', async (params) => {
+            return (0, gatewayTools_1.handlePlan)(params, { repoPath: this.getRepoPath() });
+        }));
+        // Gateway 7: agent - Agent orchestration and discovery
+        this.server.registerTool('agent', {
+            description: `Agent orchestration and discovery. Actions:
+- discover: Discover all agents (built-in + custom)
+- getInfo: Get agent details (params: agentType)
+- orchestrate: Select agents for task/phase/role (params: task?, phase?, role?)
+- getSequence: Get agent handoff sequence (params: task, includeReview?, phases?)
+- getDocs: Get agent documentation (params: agent)
+- getPhaseDocs: Get phase documentation (params: phase)
+- listTypes: List all agent types`,
+            inputSchema: {
+                action: zod_1.z.enum(['discover', 'getInfo', 'orchestrate', 'getSequence', 'getDocs', 'getPhaseDocs', 'listTypes'])
+                    .describe('Action to perform'),
+                agentType: zod_1.z.string().optional()
+                    .describe('(getInfo) Agent type identifier'),
+                task: zod_1.z.string().optional()
+                    .describe('(orchestrate, getSequence) Task description'),
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).optional()
+                    .describe('(orchestrate, getPhaseDocs) PREVC phase'),
+                role: zod_1.z.enum(workflow_2.PREVC_ROLES).optional()
+                    .describe('(orchestrate) PREVC role'),
+                includeReview: zod_1.z.boolean().optional()
+                    .describe('(getSequence) Include code review'),
+                phases: zod_1.z.array(zod_1.z.enum(['P', 'R', 'E', 'V', 'C'])).optional()
+                    .describe('(getSequence) Phases to include'),
+                agent: zod_1.z.enum(workflow_2.AGENT_TYPES).optional()
+                    .describe('(getDocs) Agent type for docs'),
+            }
+        }, wrap('agent', async (params) => {
+            return (0, gatewayTools_1.handleAgent)(params, { repoPath: this.getRepoPath() });
+        }));
+        // Gateway 8: skill - Skill management
+        this.server.registerTool('skill', {
+            description: `Skill management for on-demand expertise. Actions:
+- list: List all skills (params: includeContent?)
+- getContent: Get skill content (params: skillSlug)
+- getForPhase: Get skills for PREVC phase (params: phase)
+- scaffold: Generate skill files (params: skills?, force?)
+- export: Export skills to AI tools (params: preset?, includeBuiltIn?, force?)
+- fill: Fill skills with codebase content (params: skills?, force?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['list', 'getContent', 'getForPhase', 'scaffold', 'export', 'fill'])
+                    .describe('Action to perform'),
+                skillSlug: zod_1.z.string().optional()
+                    .describe('(getContent) Skill identifier'),
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).optional()
+                    .describe('(getForPhase) PREVC phase'),
+                skills: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(scaffold, fill) Specific skills to process'),
+                includeContent: zod_1.z.boolean().optional()
+                    .describe('(list) Include full content'),
+                includeBuiltIn: zod_1.z.boolean().optional()
+                    .describe('(export, fill) Include built-in skills'),
+                preset: zod_1.z.enum(['claude', 'gemini', 'codex', 'antigravity', 'all']).optional()
+                    .describe('(export) Target AI tool'),
+                force: zod_1.z.boolean().optional()
+                    .describe('(scaffold, export) Overwrite existing'),
+            }
+        }, wrap('skill', async (params) => {
+            return (0, gatewayTools_1.handleSkill)(params, { repoPath: this.getRepoPath() });
+        }));
+        this.log('Registered 9 tools (5 consolidated gateways + 4 dedicated workflow tools)');
+    }
+    /**
+     * Register semantic context resources
+     * Uses initialRepoPath if found, otherwise process.cwd()
+     */
+    registerResources() {
+        const repoPath = this.initialRepoPath ?? process.cwd();
+        // Register context resources as templates with URI patterns
+        this.server.registerResource('codebase-context', `context://codebase/{contextType}`, {
+            description: 'Semantic context for the codebase. Use contextType: documentation, playbook, plan, or compact',
+            mimeType: 'text/markdown'
+        }, async (uri) => {
+            // Extract context type from URI
+            const match = uri.pathname.match(/\/([^/]+)$/);
+            const contextType = (match?.[1] || 'compact');
+            let context;
+            // Check cache first
+            const cached = await this.contextCache.get(repoPath, contextType);
+            if (cached) {
+                context = cached;
+            }
+            else {
+                switch (contextType) {
+                    case 'documentation':
+                        context = await this.contextBuilder.buildDocumentationContext(repoPath);
+                        break;
+                    case 'playbook':
+                        context = await this.contextBuilder.buildPlaybookContext(repoPath, 'generic');
+                        break;
+                    case 'plan':
+                        context = await this.contextBuilder.buildPlanContext(repoPath);
+                        break;
+                    case 'compact':
+                    default:
+                        context = await this.contextBuilder.buildCompactContext(repoPath);
+                        break;
+                }
+                // Store in cache for subsequent calls
+                await this.contextCache.set(repoPath, contextType, context);
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'text/markdown',
+                        text: context
+                    }]
+            };
+        });
+        // Register file resource template
+        this.server.registerResource('file-content', `file://{path}`, {
+            description: 'Read file contents from the repository',
+            mimeType: 'text/plain'
+        }, async (uri) => {
+            const filePath = uri.pathname;
+            const result = await tools_1.readFileTool.execute({ filePath }, { toolCallId: '', messages: [] });
+            if (!result.success) {
+                throw new Error(result.error || 'Failed to read file');
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        mimeType: 'text/plain',
+                        text: result.content || ''
+                    }]
+            };
+        });
+        this.log('Registered 2 resource templates');
+        // Register PREVC workflow resources
+        this.registerWorkflowResources();
+    }
+    /**
+     * Register PREVC workflow resources
+     * Uses initialRepoPath if found, otherwise process.cwd()
+     */
+    registerWorkflowResources() {
+        const repoPath = this.initialRepoPath ?? process.cwd();
+        // workflow://status - Current workflow status
+        this.server.registerResource('workflow-status', 'workflow://status', {
+            description: 'Current PREVC workflow status including phases, roles, and progress',
+            mimeType: 'application/json'
+        }, async () => {
+            try {
+                const service = new workflow_1.WorkflowService(repoPath);
+                if (!(await service.hasWorkflow())) {
+                    return {
+                        contents: [{
+                                uri: 'workflow://status',
+                                mimeType: 'application/json',
+                                text: JSON.stringify({ error: 'No workflow found' }, null, 2)
+                            }]
+                    };
+                }
+                const summary = await service.getSummary();
+                const status = await service.getStatus();
+                return {
+                    contents: [{
+                            uri: 'workflow://status',
+                            mimeType: 'application/json',
+                            text: JSON.stringify({
+                                name: summary.name,
+                                scale: (0, workflow_2.getScaleName)(summary.scale),
+                                currentPhase: summary.currentPhase,
+                                progress: summary.progress,
+                                isComplete: summary.isComplete,
+                                phases: status.phases,
+                                roles: status.roles,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: 'workflow://status',
+                            mimeType: 'application/json',
+                            text: JSON.stringify({
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.log('Registered 1 workflow resource');
+    }
+    /**
+     * Initialize repo path with smart detection and caching
+     *
+     * Strategy:
+     * 1. If explicit options.repoPath provided, try to find project root from there
+     * 2. Otherwise search upward from process.cwd() for .context or .git
+     * 3. Set as initialRepoPath if found (for resources)
+     * 4. First valid repoPath from client gets cached for all subsequent tool calls
+     * 5. Fallback to process.cwd() if nothing found (allows flexible MCP usage)
+     */
+    async initializeRepoPath() {
+        const startPath = this.options.repoPath || process.cwd();
+        const foundRoot = await this.findProjectRoot(startPath);
+        if (foundRoot) {
+            this.initialRepoPath = path.resolve(foundRoot);
+            this.log(`Server initialized with project root: ${this.initialRepoPath}`);
+        }
+        else {
+            // No project found - will use process.cwd() as fallback
+            // This allows flexible MCP server usage without strict project detection
+            this.initialRepoPath = null;
+            this.log(`No project root found. Will use process.cwd() or first valid client-provided path.`);
+        }
+    }
+    /**
+     * Find project root by searching upward for .context or .git
+     */
+    async findProjectRoot(startPath) {
+        let currentPath = path.resolve(startPath);
+        const root = path.parse(currentPath).root;
+        // Search upward for .context or .git
+        while (currentPath !== root) {
+            if (await fs.pathExists(path.join(currentPath, '.context')) ||
+                await fs.pathExists(path.join(currentPath, '.git'))) {
+                return currentPath;
+            }
+            currentPath = path.dirname(currentPath);
+        }
+        // Not found
+        return null;
+    }
+    /**
+     * Cache a valid repoPath from client
+     * Only cache if it contains .context and we haven't cached yet
+     */
+    cacheRepoPathIfValid(repoPath) {
+        if (this.cachedRepoPath) {
+            return; // Already cached
+        }
+        const contextPath = path.join(repoPath, '.context');
+        if (fs.existsSync(contextPath)) {
+            this.cachedRepoPath = path.resolve(repoPath);
+            process.stderr.write(`[mcp] ✓ Cached repoPath for this session: ${this.cachedRepoPath}\n`);
+            this.log(`Cached valid repoPath: ${this.cachedRepoPath}`);
+        }
+    }
+    /**
+     * Get the effective repo path for a tool call
+     * Priority: 1) explicit param, 2) cached path, 3) initial path, 4) process.cwd()
+     */
+    getRepoPath(paramsRepoPath) {
+        if (paramsRepoPath) {
+            const resolved = path.resolve(paramsRepoPath);
+            this.cacheRepoPathIfValid(resolved);
+            return resolved;
+        }
+        if (this.cachedRepoPath) {
+            this.log(`Using cached repoPath: ${this.cachedRepoPath}`);
+            return this.cachedRepoPath;
+        }
+        if (this.initialRepoPath) {
+            this.log(`Using initial repoPath: ${this.initialRepoPath}`);
+            return this.initialRepoPath;
+        }
+        // Fallback to current working directory
+        const cwd = process.cwd();
+        this.log(`Using fallback cwd: ${cwd}`);
+        return cwd;
+    }
+    wrapWithActionLogging(toolName, handler) {
+        return async (params) => {
+            const resolvedRepoPath = this.getRepoPath(params?.repoPath);
+            const action = typeof params?.action === 'string'
+                ? params.action
+                : toolName;
+            // Validate file paths to prevent path traversal attacks
+            try {
+                this.validatePathParams(params, resolvedRepoPath);
+            }
+            catch (error) {
+                if (error instanceof pathSecurity_1.SecurityError) {
+                    this.log(`[SECURITY] Path traversal blocked: ${error.message} (tool: ${toolName}, path: ${error.attemptedPath})`);
+                    const errorResponse = {
+                        content: [{ type: 'text', text: JSON.stringify({ success: false, error: `Security: ${error.message}` }) }],
+                        isError: true,
+                    };
+                    await this.logToolError(resolvedRepoPath, toolName, action, params, error);
+                    return errorResponse;
+                }
+                throw error;
+            }
+            try {
+                const response = await handler(params);
+                await this.logToolResponse(resolvedRepoPath, toolName, action, params, response);
+                return response;
+            }
+            catch (error) {
+                await this.logToolError(resolvedRepoPath, toolName, action, params, error);
+                throw error;
+            }
+        };
+    }
+    /**
+     * Validate path-related parameters against the workspace boundary.
+     * Throws SecurityError if any path escapes the workspace.
+     */
+    validatePathParams(params, repoPath) {
+        const validator = new pathSecurity_1.PathValidator(repoPath);
+        const pathKeys = ['filePath', 'rootPath', 'cwd'];
+        for (const key of pathKeys) {
+            const value = params[key];
+            if (typeof value === 'string' && value.length > 0) {
+                validator.validatePath(value);
+            }
+        }
+    }
+    async logToolResponse(repoPath, toolName, action, params, response) {
+        const payload = this.parseResponsePayload(response);
+        const success = typeof payload?.success === 'boolean'
+            ? payload.success
+            : !response.isError;
+        const errorMessage = typeof payload?.error === 'string' ? payload.error : undefined;
+        const resultSummary = payload ? this.buildResultSummary(payload) : undefined;
+        await (0, actionLogger_1.logMcpAction)(repoPath, {
+            tool: toolName,
+            action,
+            status: success ? 'success' : 'error',
+            details: {
+                params,
+                ...(resultSummary ? { result: resultSummary } : {}),
+            },
+            ...(success ? {} : { error: errorMessage || 'Tool reported failure' }),
+        });
+    }
+    async logToolError(repoPath, toolName, action, params, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await (0, actionLogger_1.logMcpAction)(repoPath, {
+            tool: toolName,
+            action,
+            status: 'error',
+            details: { params },
+            error: message,
+        });
+    }
+    parseResponsePayload(response) {
+        const text = response.content?.[0]?.text;
+        if (!text)
+            return null;
+        try {
+            const parsed = JSON.parse(text);
+            return parsed && typeof parsed === 'object' ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    buildResultSummary(payload) {
+        const summaryKeys = [
+            'success',
+            'message',
+            'currentPhase',
+            'nextPhase',
+            'phase',
+            'scale',
+            'planSlug',
+            'count',
+            'total',
+            'status',
+        ];
+        const summary = {};
+        for (const key of summaryKeys) {
+            if (key in payload) {
+                summary[key] = payload[key];
+            }
+        }
+        return Object.keys(summary).length > 0 ? summary : null;
+    }
+    /**
+     * Start the MCP server with stdio transport
+     */
+    async start() {
+        this.transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(this.transport);
+        this.log('MCP Server started on stdio');
+    }
+    /**
+     * Stop the MCP server
+     */
+    async stop() {
+        await this.server.close();
+        await this.contextBuilder.shutdown();
+        this.log('MCP Server stopped');
+    }
+    /**
+     * Log message to stderr (not stdout, to avoid polluting MCP messages)
+     */
+    log(message) {
+        if (this.options.verbose) {
+            process.stderr.write(`[mcp] ${message}\n`);
+        }
+    }
+}
+exports.AIContextMCPServer = AIContextMCPServer;
+/**
+ * Create and start an MCP server
+ */
+async function startMCPServer(options = {}) {
+    const server = new AIContextMCPServer(options);
+    await server.start();
+    return server;
+}
+//# sourceMappingURL=mcpServer.js.map