@harness-engineering/mcp-server 0.5.3 → 0.6.1

package/dist/src/tools/interaction.js

@@ -0,0 +1,235 @@
+import { randomUUID } from 'crypto';
+import { sanitizePath } from '../utils/sanitize-path.js';
+export const emitInteractionDefinition = {
+    name: 'emit_interaction',
+    description: 'Emit a structured interaction (question, confirmation, or phase transition) for round-trip communication with the user',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            type: {
+                type: 'string',
+                enum: ['question', 'confirmation', 'transition'],
+                description: 'Type of interaction',
+            },
+            stream: {
+                type: 'string',
+                description: 'State stream for recording (auto-resolves from branch if omitted)',
+            },
+            question: {
+                type: 'object',
+                description: 'Question payload (required when type is question)',
+                properties: {
+                    text: { type: 'string', description: 'The question text' },
+                    options: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Multiple choice options (omit for free-form)',
+                    },
+                    default: { type: 'string', description: 'Default answer' },
+                },
+                required: ['text'],
+            },
+            confirmation: {
+                type: 'object',
+                description: 'Confirmation payload (required when type is confirmation)',
+                properties: {
+                    text: { type: 'string', description: 'What to confirm' },
+                    context: {
+                        type: 'string',
+                        description: 'Why confirmation is needed',
+                    },
+                },
+                required: ['text', 'context'],
+            },
+            transition: {
+                type: 'object',
+                description: 'Transition payload (required when type is transition)',
+                properties: {
+                    completedPhase: {
+                        type: 'string',
+                        description: 'Phase that was completed',
+                    },
+                    suggestedNext: {
+                        type: 'string',
+                        description: 'Suggested next phase',
+                    },
+                    reason: {
+                        type: 'string',
+                        description: 'Why the transition is happening',
+                    },
+                    artifacts: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'File paths produced during the completed phase',
+                    },
+                    requiresConfirmation: {
+                        type: 'boolean',
+                        description: 'true = wait for user confirmation, false = proceed immediately',
+                    },
+                    summary: {
+                        type: 'string',
+                        description: '1-2 sentence rich summary with key metrics',
+                    },
+                },
+                required: [
+                    'completedPhase',
+                    'suggestedNext',
+                    'reason',
+                    'artifacts',
+                    'requiresConfirmation',
+                    'summary',
+                ],
+            },
+        },
+        required: ['path', 'type'],
+    },
+};
+export async function handleEmitInteraction(input) {
+    try {
+        const projectPath = sanitizePath(input.path);
+        const id = randomUUID();
+        switch (input.type) {
+            case 'question': {
+                if (!input.question) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: question payload is required when type is question',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const { text, options, default: defaultAnswer } = input.question;
+                let prompt = text;
+                if (options && options.length > 0) {
+                    prompt +=
+                        '\n\nOptions:\n' +
+                            options.map((o, i) => `  ${String.fromCharCode(65 + i)}) ${o}`).join('\n');
+                }
+                if (defaultAnswer) {
+                    prompt += `\n\nDefault: ${defaultAnswer}`;
+                }
+                // Record in state decisions array
+                await recordInteraction(projectPath, id, 'question', text, input.stream);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ id, prompt }) }],
+                };
+            }
+            case 'confirmation': {
+                if (!input.confirmation) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: confirmation payload is required when type is confirmation',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const { text, context } = input.confirmation;
+                const prompt = `${text}\n\nContext: ${context}\n\nProceed? (yes/no)`;
+                await recordInteraction(projectPath, id, 'confirmation', text, input.stream);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ id, prompt }) }],
+                };
+            }
+            case 'transition': {
+                if (!input.transition) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: transition payload is required when type is transition',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const { completedPhase, suggestedNext, reason, artifacts, requiresConfirmation, summary } = input.transition;
+                const prompt = `Phase "${completedPhase}" complete. ${reason}\n\n` +
+                    `${summary}\n\n` +
+                    `Artifacts produced:\n${artifacts.map((a) => `  - ${a}`).join('\n')}\n\n` +
+                    (requiresConfirmation
+                        ? `Suggested next: "${suggestedNext}". Proceed?`
+                        : `Proceeding to ${suggestedNext}...`);
+                // Write handoff
+                try {
+                    const { saveHandoff } = await import('@harness-engineering/core');
+                    await saveHandoff(projectPath, {
+                        timestamp: new Date().toISOString(),
+                        fromSkill: 'emit_interaction',
+                        phase: completedPhase,
+                        summary: reason,
+                        completed: [completedPhase],
+                        pending: [suggestedNext],
+                        concerns: [],
+                        decisions: [],
+                        blockers: [],
+                        contextKeywords: [],
+                    }, input.stream);
+                }
+                catch {
+                    // Handoff write failure is non-fatal
+                }
+                await recordInteraction(projectPath, id, 'transition', `${completedPhase} -> ${suggestedNext}`, input.stream);
+                const responsePayload = { id, prompt, handoffWritten: true };
+                if (!requiresConfirmation) {
+                    responsePayload.autoTransition = true;
+                    responsePayload.nextAction = `Invoke harness-${suggestedNext} skill now`;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(responsePayload),
+                        },
+                    ],
+                };
+            }
+            default: {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: unknown interaction type: ${String(input.type)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function recordInteraction(projectPath, id, type, decision, stream) {
+    try {
+        const { loadState, saveState } = await import('@harness-engineering/core');
+        const stateResult = await loadState(projectPath, stream);
+        if (stateResult.ok) {
+            const state = stateResult.value;
+            state.decisions.push({
+                date: new Date().toISOString(),
+                decision: `[${type}:${id}] ${decision}`,
+                context: 'pending user response',
+            });
+            await saveState(projectPath, state, stream);
+        }
+    }
+    catch {
+        // State recording failure is non-fatal
+    }
+}

package/dist/src/tools/linter.js

@@ -1,3 +1,4 @@
+import { sanitizePath } from '../utils/sanitize-path.js';
 export const generateLinterDefinition = {
     name: 'generate_linter',
     description: 'Generate an ESLint rule from YAML configuration',
@@ -13,7 +14,10 @@ export const generateLinterDefinition = {
 export async function handleGenerateLinter(input) {
     try {
         const { generate } = await import('@harness-engineering/linter-gen');
-        const result = await generate({ configPath: input.configPath, outputDir: input.outputDir });
+        const result = await generate({
+            configPath: sanitizePath(input.configPath),
+            outputDir: input.outputDir ? sanitizePath(input.outputDir) : undefined,
+        });
         if ('success' in result && result.success) {
             return { content: [{ type: 'text', text: JSON.stringify(result) }] };
         }
@@ -45,7 +49,7 @@ export const validateLinterConfigDefinition = {
 export async function handleValidateLinterConfig(input) {
     try {
         const { validate } = await import('@harness-engineering/linter-gen');
-        const result = await validate({ configPath: input.configPath });
+        const result = await validate({ configPath: sanitizePath(input.configPath) });
         if ('success' in result && result.success) {
             return { content: [{ type: 'text', text: JSON.stringify(result) }] };
         }

package/dist/src/tools/performance.js

@@ -1,6 +1,6 @@
-import * as path from 'path';
 import { Ok } from '@harness-engineering/core';
 import { resultToMcpResponse } from '../utils/result-adapter.js';
+import { sanitizePath } from '../utils/sanitize-path.js';
 export const checkPerformanceDefinition = {
     name: 'check_performance',
     description: 'Run performance checks: structural complexity, coupling metrics, and size budgets',
@@ -21,8 +21,9 @@ export async function handleCheckPerformance(input) {
     try {
         const { EntropyAnalyzer } = await import('@harness-engineering/core');
         const typeFilter = input.type ?? 'all';
+        const projectPath = sanitizePath(input.path);
         const analyzer = new EntropyAnalyzer({
-            rootDir: path.resolve(input.path),
+            rootDir: projectPath,
             analyze: {
                 complexity: typeFilter === 'all' || typeFilter === 'structural',
                 coupling: typeFilter === 'all' || typeFilter === 'coupling',
@@ -33,7 +34,7 @@ export async function handleCheckPerformance(input) {
         let graphOptions;
         try {
             const { loadGraphStore } = await import('../utils/graph-loader.js');
-            const store = await loadGraphStore(path.resolve(input.path));
+            const store = await loadGraphStore(projectPath);
             if (store) {
                 const { GraphComplexityAdapter, GraphCouplingAdapter } = await import('@harness-engineering/graph');
                 const complexityAdapter = new GraphComplexityAdapter(store);
@@ -77,7 +78,7 @@ export const getPerfBaselinesDefinition = {
 export async function handleGetPerfBaselines(input) {
     try {
         const { BaselineManager } = await import('@harness-engineering/core');
-        const manager = new BaselineManager(path.resolve(input.path));
+        const manager = new BaselineManager(sanitizePath(input.path));
         const baselines = manager.load();
         return resultToMcpResponse(Ok(baselines ?? { version: 1, updatedAt: '', updatedFrom: '', benchmarks: {} }));
     }
@@ -125,7 +126,7 @@ export const updatePerfBaselinesDefinition = {
 export async function handleUpdatePerfBaselines(input) {
     try {
         const { BaselineManager } = await import('@harness-engineering/core');
-        const manager = new BaselineManager(path.resolve(input.path));
+        const manager = new BaselineManager(sanitizePath(input.path));
         manager.save(input.results, input.commitHash);
         const updated = manager.load();
         return resultToMcpResponse(Ok(updated));
@@ -157,7 +158,7 @@ export const getCriticalPathsDefinition = {
 export async function handleGetCriticalPaths(input) {
     try {
         const { CriticalPathResolver } = await import('@harness-engineering/core');
-        const resolver = new CriticalPathResolver(path.resolve(input.path));
+        const resolver = new CriticalPathResolver(sanitizePath(input.path));
         const result = await resolver.resolve();
         return resultToMcpResponse(Ok(result));
     }

package/dist/src/tools/persona.js

@@ -2,6 +2,7 @@ import * as path from 'path';
 import { Ok, Err } from '@harness-engineering/core';
 import { resultToMcpResponse } from '../utils/result-adapter.js';
 import { resolvePersonasDir } from '../utils/paths.js';
+import { sanitizePath } from '../utils/sanitize-path.js';
 export const listPersonasDefinition = {
     name: 'list_personas',
     description: 'List available agent personas',
@@ -100,7 +101,7 @@ export async function handleRunPersona(input) {
     const personaResult = loadPersona(filePath);
     if (!personaResult.ok)
         return resultToMcpResponse(personaResult);
-    const projectPath = input.path ? path.resolve(input.path) : process.cwd();
+    const projectPath = input.path ? sanitizePath(input.path) : process.cwd();
     const trigger = (input.trigger ?? 'auto');
     const { ALLOWED_PERSONA_COMMANDS } = await import('@harness-engineering/cli');
     const commandExecutor = async (command) => {

package/dist/src/tools/phase-gate.js

@@ -1,4 +1,4 @@
-import * as path from 'path';
+import { sanitizePath } from '../utils/sanitize-path.js';
 export const checkPhaseGateDefinition = {
     name: 'check_phase_gate',
     description: 'Verify implementation-to-spec mappings: checks that each implementation file has a corresponding spec document',
@@ -13,7 +13,7 @@ export const checkPhaseGateDefinition = {
 export async function handleCheckPhaseGate(input) {
     try {
         const { runCheckPhaseGate } = await import('@harness-engineering/cli');
-        const result = await runCheckPhaseGate({ cwd: path.resolve(input.path) });
+        const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
         if (result.ok) {
             return { content: [{ type: 'text', text: JSON.stringify(result.value) }] };
         }

package/dist/src/tools/review-pipeline.d.ts

@@ -0,0 +1,63 @@
+export declare const runCodeReviewDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            diff: {
+                type: string;
+                description: string;
+            };
+            commitMessage: {
+                type: string;
+                description: string;
+            };
+            comment: {
+                type: string;
+                description: string;
+            };
+            ci: {
+                type: string;
+                description: string;
+            };
+            deep: {
+                type: string;
+                description: string;
+            };
+            noMechanical: {
+                type: string;
+                description: string;
+            };
+            prNumber: {
+                type: string;
+                description: string;
+            };
+            repo: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleRunCodeReview(input: {
+    path: string;
+    diff: string;
+    commitMessage?: string;
+    comment?: boolean;
+    ci?: boolean;
+    deep?: boolean;
+    noMechanical?: boolean;
+    prNumber?: number;
+    repo?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/src/tools/review-pipeline.js

@@ -0,0 +1,114 @@
+import { sanitizePath } from '../utils/sanitize-path.js';
+// ============ run_code_review ============
+export const runCodeReviewDefinition = {
+    name: 'run_code_review',
+    description: 'Run the unified 7-phase code review pipeline: gate, mechanical checks, context scoping, parallel agents, validation, deduplication, and output.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            diff: { type: 'string', description: 'Git diff string to review' },
+            commitMessage: {
+                type: 'string',
+                description: 'Most recent commit message (for change-type detection)',
+            },
+            comment: {
+                type: 'boolean',
+                description: 'Post inline comments to GitHub PR (requires prNumber and repo)',
+            },
+            ci: {
+                type: 'boolean',
+                description: 'Enable eligibility gate and non-interactive output',
+            },
+            deep: {
+                type: 'boolean',
+                description: 'Add threat modeling pass to security agent',
+            },
+            noMechanical: {
+                type: 'boolean',
+                description: 'Skip mechanical checks (useful if already run)',
+            },
+            prNumber: {
+                type: 'number',
+                description: 'PR number (required for --comment and CI gate)',
+            },
+            repo: {
+                type: 'string',
+                description: 'Repository in owner/repo format (required for --comment)',
+            },
+        },
+        required: ['path', 'diff'],
+    },
+};
+export async function handleRunCodeReview(input) {
+    try {
+        const { parseDiff, runReviewPipeline } = await import('@harness-engineering/core');
+        const parseResult = parseDiff(input.diff);
+        if (!parseResult.ok) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error parsing diff: ${parseResult.error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const codeChanges = parseResult.value;
+        const projectRoot = sanitizePath(input.path);
+        // Build DiffInfo from parsed diff
+        const diffInfo = {
+            changedFiles: codeChanges.files.map((f) => f.path),
+            newFiles: codeChanges.files
+                .filter((f) => f.status === 'added')
+                .map((f) => f.path),
+            deletedFiles: codeChanges.files
+                .filter((f) => f.status === 'deleted')
+                .map((f) => f.path),
+            totalDiffLines: input.diff.split('\n').length,
+            fileDiffs: new Map(codeChanges.files.map((f) => [f.path, f.diff ?? ''])),
+        };
+        const result = await runReviewPipeline({
+            projectRoot,
+            diff: diffInfo,
+            commitMessage: input.commitMessage ?? '',
+            flags: {
+                comment: input.comment ?? false,
+                ci: input.ci ?? false,
+                deep: input.deep ?? false,
+                noMechanical: input.noMechanical ?? false,
+            },
+            ...(input.repo != null ? { repo: input.repo } : {}),
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        skipped: result.skipped,
+                        skipReason: result.skipReason,
+                        stoppedByMechanical: result.stoppedByMechanical,
+                        assessment: result.assessment,
+                        findingCount: result.findings.length,
+                        terminalOutput: result.terminalOutput,
+                        githubCommentCount: result.githubComments.length,
+                        exitCode: result.exitCode,
+                    }, null, 2),
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/src/tools/roadmap.d.ts

@@ -0,0 +1,82 @@
+export declare const manageRoadmapDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            feature: {
+                type: string;
+                description: string;
+            };
+            milestone: {
+                type: string;
+                description: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            summary: {
+                type: string;
+                description: string;
+            };
+            spec: {
+                type: string;
+                description: string;
+            };
+            plans: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            blocked_by: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            filter: {
+                type: string;
+                description: string;
+            };
+            apply: {
+                type: string;
+                description: string;
+            };
+            force_sync: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+interface ManageRoadmapInput {
+    path: string;
+    action: 'show' | 'add' | 'update' | 'remove' | 'query' | 'sync';
+    feature?: string;
+    milestone?: string;
+    status?: 'backlog' | 'planned' | 'in-progress' | 'done' | 'blocked';
+    summary?: string;
+    spec?: string;
+    plans?: string[];
+    blocked_by?: string[];
+    filter?: string;
+    apply?: boolean;
+    force_sync?: boolean;
+}
+export declare function handleManageRoadmap(input: ManageRoadmapInput): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export {};