@harness-engineering/mcp-server 0.1.2 → 0.2.0

package/dist/src/resources/state.d.ts

@@ -0,0 +1 @@
+export declare function getStateResource(projectRoot: string): Promise<string>;

package/dist/src/resources/state.js

@@ -0,0 +1,17 @@
+export async function getStateResource(projectRoot) {
+    try {
+        const { loadState } = await import('@harness-engineering/core');
+        const result = await loadState(projectRoot);
+        if (result.ok) {
+            return JSON.stringify(result.value, null, 2);
+        }
+        return JSON.stringify({
+            schemaVersion: 1, position: {}, decisions: [], blockers: [], progress: {},
+        });
+    }
+    catch {
+        return JSON.stringify({
+            schemaVersion: 1, position: {}, decisions: [], blockers: [], progress: {},
+        });
+    }
+}

package/dist/src/server.js

@@ -9,11 +9,16 @@ import { generateLinterDefinition, handleGenerateLinter, validateLinterConfigDef
 import { initProjectDefinition, handleInitProject } from './tools/init.js';
 import { listPersonasDefinition, handleListPersonas, generatePersonaArtifactsDefinition, handleGeneratePersonaArtifacts, runPersonaDefinition, handleRunPersona, } from './tools/persona.js';
 import { addComponentDefinition, handleAddComponent, runAgentTaskDefinition, handleRunAgentTask, } from './tools/agent.js';
-import { runSkillDefinition, handleRunSkill } from './tools/skill.js';
+import { runSkillDefinition, handleRunSkill, createSkillDefinition, handleCreateSkill } from './tools/skill.js';
 import { getSkillsResource } from './resources/skills.js';
 import { getRulesResource } from './resources/rules.js';
 import { getProjectResource } from './resources/project.js';
 import { getLearningsResource } from './resources/learnings.js';
+import { manageStateDefinition, handleManageState, manageHandoffDefinition, handleManageHandoff, } from './tools/state.js';
+import { createSelfReviewDefinition, handleCreateSelfReview, analyzeDiffDefinition, handleAnalyzeDiff, requestPeerReviewDefinition, handleRequestPeerReview, } from './tools/feedback.js';
+import { checkPhaseGateDefinition, handleCheckPhaseGate } from './tools/phase-gate.js';
+import { validateCrossCheckDefinition, handleValidateCrossCheck } from './tools/cross-check.js';
+import { getStateResource } from './resources/state.js';
 const TOOL_DEFINITIONS = [
     validateToolDefinition,
     checkDependenciesDefinition,
@@ -30,6 +35,14 @@ const TOOL_DEFINITIONS = [
     addComponentDefinition,
     runAgentTaskDefinition,
     runSkillDefinition,
+    manageStateDefinition,
+    manageHandoffDefinition,
+    createSelfReviewDefinition,
+    analyzeDiffDefinition,
+    requestPeerReviewDefinition,
+    checkPhaseGateDefinition,
+    validateCrossCheckDefinition,
+    createSkillDefinition,
 ];
 const TOOL_HANDLERS = {
     validate_project: handleValidateProject,
@@ -47,6 +60,14 @@ const TOOL_HANDLERS = {
     add_component: handleAddComponent,
     run_agent_task: handleRunAgentTask,
     run_skill: handleRunSkill,
+    manage_state: handleManageState,
+    manage_handoff: handleManageHandoff,
+    create_self_review: handleCreateSelfReview,
+    analyze_diff: handleAnalyzeDiff,
+    request_peer_review: handleRequestPeerReview,
+    check_phase_gate: handleCheckPhaseGate,
+    validate_cross_check: handleValidateCrossCheck,
+    create_skill: handleCreateSkill,
 };
 const RESOURCE_DEFINITIONS = [
     {
@@ -73,12 +94,19 @@ const RESOURCE_DEFINITIONS = [
         description: 'Review learnings and anti-pattern log from .harness/',
         mimeType: 'text/markdown',
     },
+    {
+        uri: 'harness://state',
+        name: 'Project State',
+        description: 'Current harness state including position, progress, decisions, and blockers',
+        mimeType: 'application/json',
+    },
 ];
 const RESOURCE_HANDLERS = {
     'harness://skills': getSkillsResource,
     'harness://rules': getRulesResource,
     'harness://project': getProjectResource,
     'harness://learnings': getLearningsResource,
+    'harness://state': getStateResource,
 };
 export function getToolDefinitions() {
     return TOOL_DEFINITIONS;

package/dist/src/tools/cross-check.d.ts

@@ -0,0 +1,28 @@
+import type { McpToolResponse } from '../utils/result-adapter.js';
+export declare const validateCrossCheckDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            specsDir: {
+                type: string;
+                description: string;
+            };
+            plansDir: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleValidateCrossCheck(input: {
+    path: string;
+    specsDir?: string;
+    plansDir?: string;
+}): Promise<McpToolResponse>;

package/dist/src/tools/cross-check.js

@@ -0,0 +1,35 @@
+import * as path from 'path';
+export const validateCrossCheckDefinition = {
+    name: 'validate_cross_check',
+    description: 'Validate plan-to-implementation coverage: checks that specs have plans and plans have implementations, detects staleness',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root directory' },
+            specsDir: { type: 'string', description: 'Specs directory relative to project root (default: docs/specs)' },
+            plansDir: { type: 'string', description: 'Plans directory relative to project root (default: docs/plans)' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleValidateCrossCheck(input) {
+    const projectPath = path.resolve(input.path);
+    try {
+        const { runCrossCheck } = await import('@harness-engineering/cli');
+        const result = await runCrossCheck({
+            projectPath,
+            specsDir: path.resolve(projectPath, input.specsDir ?? 'docs/specs'),
+            plansDir: path.resolve(projectPath, input.plansDir ?? 'docs/plans'),
+        });
+        if (result.ok) {
+            return { content: [{ type: 'text', text: JSON.stringify(result.value) }] };
+        }
+        return { content: [{ type: 'text', text: result.error.message }], isError: true };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
+    }
+}

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

@@ -8,12 +8,18 @@ export declare const detectEntropyDefinition: {
                 type: string;
                 description: string;
             };
+            type: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
         };
         required: string[];
     };
 };
 export declare function handleDetectEntropy(input: {
     path: string;
+    type?: string;
 }): Promise<import("../utils/result-adapter.js").McpToolResponse>;
 export declare const applyFixesDefinition: {
     name: string;

package/dist/src/tools/entropy.js

@@ -8,6 +8,11 @@ export const detectEntropyDefinition = {
         type: 'object',
         properties: {
             path: { type: 'string', description: 'Path to project root' },
+            type: {
+                type: 'string',
+                enum: ['drift', 'dead-code', 'patterns', 'all'],
+                description: 'Type of entropy to detect (default: all)',
+            },
         },
         required: ['path'],
     },
@@ -15,28 +20,28 @@ export const detectEntropyDefinition = {
 export async function handleDetectEntropy(input) {
     try {
         const { EntropyAnalyzer } = await import('@harness-engineering/core');
+        const typeFilter = input.type ?? 'all';
         const analyzer = new EntropyAnalyzer({
             rootDir: path.resolve(input.path),
-            analyze: { drift: true, deadCode: true, patterns: true },
+            analyze: {
+                drift: typeFilter === 'all' || typeFilter === 'drift',
+                deadCode: typeFilter === 'all' || typeFilter === 'dead-code',
+                patterns: typeFilter === 'all' || typeFilter === 'patterns',
+            },
         });
         const result = await analyzer.analyze();
         return resultToMcpResponse(result);
     }
     catch (error) {
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
+            content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
             isError: true,
         };
     }
 }
 export const applyFixesDefinition = {
     name: 'apply_fixes',
-    description: 'Auto-fix detected entropy issues',
+    description: 'Auto-fix detected entropy issues and return actionable suggestions for remaining issues',
     inputSchema: {
         type: 'object',
         properties: {
@@ -48,7 +53,7 @@ export const applyFixesDefinition = {
 };
 export async function handleApplyFixes(input) {
     try {
-        const { EntropyAnalyzer, createFixes, applyFixes } = await import('@harness-engineering/core');
+        const { EntropyAnalyzer, createFixes, applyFixes, generateSuggestions } = await import('@harness-engineering/core');
         const analyzer = new EntropyAnalyzer({
             rootDir: path.resolve(input.path),
             analyze: { drift: true, deadCode: true, patterns: true },
@@ -56,25 +61,24 @@ export async function handleApplyFixes(input) {
         const analysisResult = await analyzer.analyze();
         if (!analysisResult.ok)
             return resultToMcpResponse(analysisResult);
-        const deadCode = analysisResult.value.deadCode;
-        if (!deadCode) {
-            return resultToMcpResponse(Ok({ fixes: [], applied: 0 }));
-        }
-        const fixes = createFixes(deadCode, {});
+        const report = analysisResult.value;
+        const deadCode = report.deadCode;
+        const fixes = deadCode ? createFixes(deadCode, {}) : [];
+        const suggestions = generateSuggestions(report.deadCode, report.drift, report.patterns);
         if (input.dryRun) {
-            return { content: [{ type: 'text', text: JSON.stringify(fixes) }] };
+            return { content: [{ type: 'text', text: JSON.stringify({ fixes, suggestions }) }] };
+        }
+        if (fixes.length > 0) {
+            const applied = await applyFixes(fixes, {});
+            if (!applied.ok)
+                return resultToMcpResponse(applied);
+            return { content: [{ type: 'text', text: JSON.stringify({ ...applied.value, suggestions }) }] };
         }
-        const applied = await applyFixes(fixes, {});
-        return resultToMcpResponse(applied);
+        return resultToMcpResponse(Ok({ fixes: [], applied: 0, suggestions }));
     }
     catch (error) {
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
+            content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
             isError: true,
         };
     }

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

@@ -0,0 +1,108 @@
+export declare const createSelfReviewDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            diff: {
+                type: string;
+                description: string;
+            };
+            customRules: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            maxFileSize: {
+                type: string;
+                description: string;
+            };
+            maxFileCount: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleCreateSelfReview(input: {
+    path: string;
+    diff: string;
+    customRules?: Array<Record<string, unknown>>;
+    maxFileSize?: number;
+    maxFileCount?: number;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const analyzeDiffDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            diff: {
+                type: string;
+                description: string;
+            };
+            forbiddenPatterns: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            maxFileSize: {
+                type: string;
+                description: string;
+            };
+            maxFileCount: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleAnalyzeDiff(input: {
+    diff: string;
+    forbiddenPatterns?: string[];
+    maxFileSize?: number;
+    maxFileCount?: number;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const requestPeerReviewDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            agentType: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            diff: {
+                type: string;
+                description: string;
+            };
+            context: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleRequestPeerReview(input: {
+    path: string;
+    agentType: 'architecture-enforcer' | 'documentation-maintainer' | 'test-reviewer' | 'entropy-cleaner' | 'custom';
+    diff: string;
+    context?: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/feedback.js

@@ -0,0 +1,180 @@
+import * as path from 'path';
+import { resultToMcpResponse } from '../utils/result-adapter.js';
+// ============ create_self_review ============
+export const createSelfReviewDefinition = {
+    name: 'create_self_review',
+    description: 'Generate a checklist-based code review from a git diff, checking harness constraints, custom rules, and diff patterns',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            diff: { type: 'string', description: 'Git diff string to review' },
+            customRules: {
+                type: 'array',
+                items: { type: 'object' },
+                description: 'Optional custom rules to apply during review',
+            },
+            maxFileSize: {
+                type: 'number',
+                description: 'Maximum number of lines changed per file before flagging',
+            },
+            maxFileCount: {
+                type: 'number',
+                description: 'Maximum number of changed files before flagging',
+            },
+        },
+        required: ['path', 'diff'],
+    },
+};
+export async function handleCreateSelfReview(input) {
+    try {
+        const { parseDiff, createSelfReview } = await import('@harness-engineering/core');
+        const parseResult = parseDiff(input.diff);
+        if (!parseResult.ok) {
+            return resultToMcpResponse(parseResult);
+        }
+        const config = {
+            rootDir: path.resolve(input.path),
+            harness: {
+                context: true,
+                constraints: true,
+                entropy: true,
+            },
+            ...(input.customRules ? { customRules: input.customRules } : {}),
+            diffAnalysis: {
+                enabled: true,
+                ...(input.maxFileSize !== undefined ? { maxFileSize: input.maxFileSize } : {}),
+                ...(input.maxFileCount !== undefined ? { maxChangedFiles: input.maxFileCount } : {}),
+            },
+        };
+        const result = await createSelfReview(parseResult.value, config);
+        return resultToMcpResponse(result);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ============ analyze_diff ============
+export const analyzeDiffDefinition = {
+    name: 'analyze_diff',
+    description: 'Parse a git diff and check for forbidden patterns, oversized files, and missing test coverage',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            diff: { type: 'string', description: 'Git diff string to analyze' },
+            forbiddenPatterns: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'List of regex patterns that are forbidden in the diff',
+            },
+            maxFileSize: {
+                type: 'number',
+                description: 'Maximum number of lines changed per file before flagging',
+            },
+            maxFileCount: {
+                type: 'number',
+                description: 'Maximum number of changed files before flagging',
+            },
+        },
+        required: ['diff'],
+    },
+};
+export async function handleAnalyzeDiff(input) {
+    try {
+        const { parseDiff, analyzeDiff } = await import('@harness-engineering/core');
+        const parseResult = parseDiff(input.diff);
+        if (!parseResult.ok) {
+            return resultToMcpResponse(parseResult);
+        }
+        const options = {
+            enabled: true,
+            ...(input.forbiddenPatterns
+                ? {
+                    forbiddenPatterns: input.forbiddenPatterns.map((pattern) => ({
+                        pattern,
+                        message: `Forbidden pattern matched: ${pattern}`,
+                        severity: 'warning',
+                    })),
+                }
+                : {}),
+            ...(input.maxFileSize !== undefined ? { maxFileSize: input.maxFileSize } : {}),
+            ...(input.maxFileCount !== undefined ? { maxChangedFiles: input.maxFileCount } : {}),
+        };
+        const result = await analyzeDiff(parseResult.value, options);
+        return resultToMcpResponse(result);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ============ request_peer_review ============
+export const requestPeerReviewDefinition = {
+    name: 'request_peer_review',
+    description: 'Spawn an agent subprocess to perform code review. Returns structured feedback with approval status. Timeout: 120 seconds.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            agentType: {
+                type: 'string',
+                enum: [
+                    'architecture-enforcer',
+                    'documentation-maintainer',
+                    'test-reviewer',
+                    'entropy-cleaner',
+                    'custom',
+                ],
+                description: 'Type of agent to use for the peer review',
+            },
+            diff: { type: 'string', description: 'Git diff string to review' },
+            context: { type: 'string', description: 'Optional additional context for the reviewer' },
+        },
+        required: ['path', 'agentType', 'diff'],
+    },
+};
+export async function handleRequestPeerReview(input) {
+    try {
+        const { parseDiff, requestPeerReview } = await import('@harness-engineering/core');
+        const parseResult = parseDiff(input.diff);
+        if (!parseResult.ok) {
+            return resultToMcpResponse(parseResult);
+        }
+        const reviewContext = {
+            files: parseResult.value.files.map((f) => f.path),
+            diff: input.diff,
+            ...(input.context ? { metadata: { context: input.context } } : {}),
+        };
+        const result = await requestPeerReview(input.agentType, reviewContext, {
+            timeout: 120_000,
+            wait: true,
+        });
+        return resultToMcpResponse(result);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/src/tools/phase-gate.d.ts

@@ -0,0 +1,18 @@
+import type { McpToolResponse } from '../utils/result-adapter.js';
+export declare const checkPhaseGateDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleCheckPhaseGate(input: {
+    path: string;
+}): Promise<McpToolResponse>;

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

@@ -0,0 +1,28 @@
+import * as path from 'path';
+export const checkPhaseGateDefinition = {
+    name: 'check_phase_gate',
+    description: 'Verify implementation-to-spec mappings: checks that each implementation file has a corresponding spec document',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root directory' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleCheckPhaseGate(input) {
+    try {
+        const { runCheckPhaseGate } = await import('@harness-engineering/cli');
+        const result = await runCheckPhaseGate({ cwd: path.resolve(input.path) });
+        if (result.ok) {
+            return { content: [{ type: 'text', text: JSON.stringify(result.value) }] };
+        }
+        return { content: [{ type: 'text', text: result.error.message }], isError: true };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
+    }
+}

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

@@ -1,3 +1,4 @@
+import type { McpToolResponse } from '../utils/result-adapter.js';
 export declare const runSkillDefinition: {
     name: string;
     description: string;
@@ -35,4 +36,37 @@ export declare function handleRunSkill(input: {
     complexity?: 'auto' | 'light' | 'full';
     phase?: string;
     party?: boolean;
-}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+}): Promise<McpToolResponse>;
+export declare const createSkillDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            cognitiveMode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleCreateSkill(input: {
+    path: string;
+    name: string;
+    description: string;
+    cognitiveMode?: string;
+}): Promise<McpToolResponse>;

package/dist/src/tools/skill.js

@@ -44,3 +44,42 @@ export async function handleRunSkill(input) {
     }
     return resultToMcpResponse(Ok(content));
 }
+export const createSkillDefinition = {
+    name: 'create_skill',
+    description: 'Scaffold a new harness skill with skill.yaml and SKILL.md',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root directory' },
+            name: { type: 'string', description: 'Skill name in kebab-case (e.g., my-new-skill)' },
+            description: { type: 'string', description: 'Skill description' },
+            cognitiveMode: {
+                type: 'string',
+                enum: [
+                    'adversarial-reviewer', 'constructive-architect', 'meticulous-implementer',
+                    'diagnostic-investigator', 'advisory-guide', 'meticulous-verifier',
+                ],
+                description: 'Cognitive mode (default: constructive-architect)',
+            },
+        },
+        required: ['path', 'name', 'description'],
+    },
+};
+export async function handleCreateSkill(input) {
+    try {
+        const { generateSkillFiles } = await import('@harness-engineering/cli');
+        const result = generateSkillFiles({
+            name: input.name,
+            description: input.description,
+            cognitiveMode: input.cognitiveMode ?? 'constructive-architect',
+            outputDir: path.resolve(input.path),
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,76 @@
+export declare const manageStateDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            learning: {
+                type: string;
+                description: string;
+            };
+            skillName: {
+                type: string;
+                description: string;
+            };
+            outcome: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            failureType: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleManageState(input: {
+    path: string;
+    action: 'show' | 'learn' | 'failure' | 'archive' | 'reset' | 'gate';
+    learning?: string;
+    skillName?: string;
+    outcome?: string;
+    description?: string;
+    failureType?: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const manageHandoffDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            handoff: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleManageHandoff(input: {
+    path: string;
+    action: 'save' | 'load';
+    handoff?: unknown;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/state.js

@@ -0,0 +1,168 @@
+import * as path from 'path';
+import { Ok } from '@harness-engineering/core';
+import { resultToMcpResponse } from '../utils/result-adapter.js';
+// ── manage_state ──────────────────────────────────────────────────────
+export const manageStateDefinition = {
+    name: 'manage_state',
+    description: 'Manage harness project state: show current state, record learnings/failures, archive failures, reset state, or run mechanical gate checks',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            action: {
+                type: 'string',
+                enum: ['show', 'learn', 'failure', 'archive', 'reset', 'gate'],
+                description: 'Action to perform',
+            },
+            learning: { type: 'string', description: 'Learning text to record (required for learn)' },
+            skillName: { type: 'string', description: 'Skill name associated with the entry' },
+            outcome: { type: 'string', description: 'Outcome associated with the learning' },
+            description: { type: 'string', description: 'Failure description (required for failure)' },
+            failureType: { type: 'string', description: 'Type of failure (required for failure)' },
+        },
+        required: ['path', 'action'],
+    },
+};
+export async function handleManageState(input) {
+    try {
+        const { loadState, saveState, appendLearning, appendFailure, archiveFailures, runMechanicalGate, DEFAULT_STATE, } = await import('@harness-engineering/core');
+        const projectPath = path.resolve(input.path);
+        switch (input.action) {
+            case 'show': {
+                const result = await loadState(projectPath);
+                return resultToMcpResponse(result);
+            }
+            case 'learn': {
+                if (!input.learning) {
+                    return {
+                        content: [
+                            { type: 'text', text: 'Error: learning is required for learn action' },
+                        ],
+                        isError: true,
+                    };
+                }
+                const result = await appendLearning(projectPath, input.learning, input.skillName, input.outcome);
+                if (!result.ok)
+                    return resultToMcpResponse(result);
+                return resultToMcpResponse(Ok({ recorded: true }));
+            }
+            case 'failure': {
+                if (!input.description) {
+                    return {
+                        content: [
+                            { type: 'text', text: 'Error: description is required for failure action' },
+                        ],
+                        isError: true,
+                    };
+                }
+                if (!input.failureType) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: failureType is required for failure action',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const result = await appendFailure(projectPath, input.description, input.skillName ?? 'unknown', input.failureType);
+                if (!result.ok)
+                    return resultToMcpResponse(result);
+                return resultToMcpResponse(Ok({ recorded: true }));
+            }
+            case 'archive': {
+                const result = await archiveFailures(projectPath);
+                if (!result.ok)
+                    return resultToMcpResponse(result);
+                return resultToMcpResponse(Ok({ archived: true }));
+            }
+            case 'reset': {
+                const result = await saveState(projectPath, { ...DEFAULT_STATE });
+                if (!result.ok)
+                    return resultToMcpResponse(result);
+                return resultToMcpResponse(Ok({ reset: true }));
+            }
+            case 'gate': {
+                const result = await runMechanicalGate(projectPath);
+                return resultToMcpResponse(result);
+            }
+            default: {
+                return {
+                    content: [{ type: 'text', text: `Error: unknown action` }],
+                    isError: true,
+                };
+            }
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ── manage_handoff ────────────────────────────────────────────────────
+export const manageHandoffDefinition = {
+    name: 'manage_handoff',
+    description: 'Save or load session handoff context for agent continuity across sessions',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            action: {
+                type: 'string',
+                enum: ['save', 'load'],
+                description: 'Action to perform',
+            },
+            handoff: { type: 'object', description: 'Handoff data to save (required for save)' },
+        },
+        required: ['path', 'action'],
+    },
+};
+export async function handleManageHandoff(input) {
+    try {
+        const { saveHandoff, loadHandoff } = await import('@harness-engineering/core');
+        const projectPath = path.resolve(input.path);
+        switch (input.action) {
+            case 'save': {
+                if (!input.handoff) {
+                    return {
+                        content: [
+                            { type: 'text', text: 'Error: handoff is required for save action' },
+                        ],
+                        isError: true,
+                    };
+                }
+                const result = await saveHandoff(projectPath, input.handoff);
+                return resultToMcpResponse(result.ok ? Ok({ saved: true }) : result);
+            }
+            case 'load': {
+                const result = await loadHandoff(projectPath);
+                return resultToMcpResponse(result);
+            }
+            default: {
+                return {
+                    content: [{ type: 'text', text: `Error: unknown action` }],
+                    isError: true,
+                };
+            }
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/mcp-server",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "MCP server for Harness Engineering toolkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -23,8 +23,8 @@
     "zod": "^3.22.0",
     "yaml": "^2.3.0",
     "handlebars": "^4.7.0",
-    "@harness-engineering/cli": "1.0.2",
     "@harness-engineering/core": "0.5.0",
+    "@harness-engineering/cli": "1.1.1",
     "@harness-engineering/types": "0.0.0",
     "@harness-engineering/linter-gen": "0.1.0"
   },