@harness-engineering/mcp-server 0.1.0

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

@@ -0,0 +1,39 @@
+export declare const detectEntropyDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleDetectEntropy(input: {
+    path: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const applyFixesDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            dryRun: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleApplyFixes(input: {
+    path: string;
+    dryRun?: boolean;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/entropy.js

@@ -0,0 +1,81 @@
+import * as path from 'path';
+import { Ok } from '@harness-engineering/core';
+import { resultToMcpResponse } from '../utils/result-adapter.js';
+export const detectEntropyDefinition = {
+    name: 'detect_entropy',
+    description: 'Detect documentation drift, dead code, and pattern violations',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleDetectEntropy(input) {
+    try {
+        const { EntropyAnalyzer } = await import('@harness-engineering/core');
+        const analyzer = new EntropyAnalyzer({
+            rootDir: path.resolve(input.path),
+            analyze: { drift: true, deadCode: true, patterns: true },
+        });
+        const result = await analyzer.analyze();
+        return resultToMcpResponse(result);
+    }
+    catch (error) {
+        return {
+            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',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            dryRun: { type: 'boolean', description: 'Preview fixes without applying' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleApplyFixes(input) {
+    try {
+        const { EntropyAnalyzer, createFixes, applyFixes } = await import('@harness-engineering/core');
+        const analyzer = new EntropyAnalyzer({
+            rootDir: path.resolve(input.path),
+            analyze: { drift: true, deadCode: true, patterns: true },
+        });
+        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, {});
+        if (input.dryRun) {
+            return { content: [{ type: 'text', text: JSON.stringify(fixes) }] };
+        }
+        const applied = await applyFixes(fixes, {});
+        return resultToMcpResponse(applied);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,33 @@
+export declare const initProjectDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            level: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            framework: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleInitProject(input: {
+    path: string;
+    name?: string;
+    level?: string;
+    framework?: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/init.js

@@ -0,0 +1,55 @@
+import * as path from 'path';
+import { resultToMcpResponse } from '../utils/result-adapter.js';
+import { resolveTemplatesDir } from '../utils/paths.js';
+export const initProjectDefinition = {
+    name: 'init_project',
+    description: 'Scaffold a new harness engineering project from a template',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Target directory' },
+            name: { type: 'string', description: 'Project name' },
+            level: {
+                type: 'string',
+                enum: ['basic', 'intermediate', 'advanced'],
+                description: 'Adoption level',
+            },
+            framework: { type: 'string', description: 'Framework overlay (e.g., nextjs)' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleInitProject(input) {
+    try {
+        // Import TemplateEngine - ensure CLI exports it
+        const { TemplateEngine } = await import('@harness-engineering/cli');
+        const templatesDir = resolveTemplatesDir();
+        const engine = new TemplateEngine(templatesDir);
+        const level = input.level ?? 'basic';
+        const resolveResult = engine.resolveTemplate(level, input.framework);
+        if (!resolveResult.ok)
+            return resultToMcpResponse(resolveResult);
+        const renderResult = engine.render(resolveResult.value, {
+            projectName: input.name ?? path.basename(input.path),
+            level,
+            framework: input.framework,
+        });
+        if (!renderResult.ok)
+            return resultToMcpResponse(renderResult);
+        const writeResult = engine.write(renderResult.value, path.resolve(input.path), {
+            overwrite: false,
+        });
+        return resultToMcpResponse(writeResult);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Init failed: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,63 @@
+export declare const generateLinterDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            configPath: {
+                type: string;
+                description: string;
+            };
+            outputDir: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGenerateLinter(input: {
+    configPath: string;
+    outputDir?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export declare const validateLinterConfigDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            configPath: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleValidateLinterConfig(input: {
+    configPath: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/src/tools/linter.js

@@ -0,0 +1,65 @@
+export const generateLinterDefinition = {
+    name: 'generate_linter',
+    description: 'Generate an ESLint rule from YAML configuration',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            configPath: { type: 'string', description: 'Path to harness-linter.yml' },
+            outputDir: { type: 'string', description: 'Output directory for generated rule' },
+        },
+        required: ['configPath'],
+    },
+};
+export async function handleGenerateLinter(input) {
+    try {
+        const { generate } = await import('@harness-engineering/linter-gen');
+        const result = await generate({ configPath: input.configPath, outputDir: input.outputDir });
+        if ('success' in result && result.success) {
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result) }], isError: true };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+export const validateLinterConfigDefinition = {
+    name: 'validate_linter_config',
+    description: 'Validate a harness-linter.yml configuration file',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            configPath: { type: 'string', description: 'Path to harness-linter.yml' },
+        },
+        required: ['configPath'],
+    },
+};
+export async function handleValidateLinterConfig(input) {
+    try {
+        const { validate } = await import('@harness-engineering/linter-gen');
+        const result = await validate({ configPath: input.configPath });
+        if ('success' in result && result.success) {
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result) }], isError: true };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,59 @@
+export declare const listPersonasDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+};
+export declare function handleListPersonas(): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const generatePersonaArtifactsDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            only: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGeneratePersonaArtifacts(input: {
+    name: string;
+    only?: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const runPersonaDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            persona: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            dryRun: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleRunPersona(input: {
+    persona: string;
+    path?: string;
+    dryRun?: boolean;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/persona.js

@@ -0,0 +1,106 @@
+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';
+export const listPersonasDefinition = {
+    name: 'list_personas',
+    description: 'List available agent personas',
+    inputSchema: { type: 'object', properties: {} },
+};
+export async function handleListPersonas() {
+    const { listPersonas } = await import('@harness-engineering/cli');
+    const result = listPersonas(resolvePersonasDir());
+    return resultToMcpResponse(result);
+}
+export const generatePersonaArtifactsDefinition = {
+    name: 'generate_persona_artifacts',
+    description: 'Generate runtime config, AGENTS.md fragment, and CI workflow from a persona',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Persona name (e.g., architecture-enforcer)' },
+            only: {
+                type: 'string',
+                enum: ['runtime', 'agents-md', 'ci'],
+                description: 'Generate only a specific artifact type',
+            },
+        },
+        required: ['name'],
+    },
+};
+export async function handleGeneratePersonaArtifacts(input) {
+    const { loadPersona, generateRuntime, generateAgentsMd, generateCIWorkflow } = await import('@harness-engineering/cli');
+    const filePath = path.join(resolvePersonasDir(), `${input.name}.yaml`);
+    const personaResult = loadPersona(filePath);
+    if (!personaResult.ok)
+        return resultToMcpResponse(personaResult);
+    const persona = personaResult.value;
+    const artifacts = {};
+    if (!input.only || input.only === 'runtime') {
+        const r = generateRuntime(persona);
+        if (r.ok)
+            artifacts.runtime = r.value;
+    }
+    if (!input.only || input.only === 'agents-md') {
+        const r = generateAgentsMd(persona);
+        if (r.ok)
+            artifacts.agentsMd = r.value;
+    }
+    if (!input.only || input.only === 'ci') {
+        const r = generateCIWorkflow(persona, 'github');
+        if (r.ok)
+            artifacts.ciWorkflow = r.value;
+    }
+    return resultToMcpResponse(Ok(artifacts));
+}
+export const runPersonaDefinition = {
+    name: 'run_persona',
+    description: 'Execute all commands defined in a persona and return aggregated results',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            persona: { type: 'string', description: 'Persona name (e.g., architecture-enforcer)' },
+            path: { type: 'string', description: 'Path to project root' },
+            dryRun: { type: 'boolean', description: 'Preview without side effects' },
+        },
+        required: ['persona'],
+    },
+};
+export async function handleRunPersona(input) {
+    const { loadPersona, runPersona } = await import('@harness-engineering/cli');
+    const filePath = path.join(resolvePersonasDir(), `${input.persona}.yaml`);
+    const personaResult = loadPersona(filePath);
+    if (!personaResult.ok)
+        return resultToMcpResponse(personaResult);
+    const projectPath = input.path ? path.resolve(input.path) : process.cwd();
+    const ALLOWED_COMMANDS = new Set([
+        'validate',
+        'check-deps',
+        'check-docs',
+        'cleanup',
+        'fix-drift',
+        'add',
+    ]);
+    const executor = async (command) => {
+        if (!ALLOWED_COMMANDS.has(command)) {
+            return Err(new Error(`Unknown harness command: ${command}`));
+        }
+        try {
+            const { execFileSync } = await import('node:child_process');
+            const args = ['harness', command];
+            if (input.dryRun)
+                args.push('--dry-run');
+            const output = execFileSync('npx', args, {
+                cwd: projectPath,
+                stdio: 'pipe',
+                timeout: personaResult.value.config.timeout,
+            });
+            return Ok(output.toString());
+        }
+        catch (error) {
+            return Err(new Error(`${command} failed: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    };
+    const report = await runPersona(personaResult.value, executor);
+    return resultToMcpResponse(Ok(report));
+}

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

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

package/dist/src/tools/skill.js

@@ -0,0 +1,46 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Ok, Err } from '@harness-engineering/core';
+import { resultToMcpResponse } from '../utils/result-adapter.js';
+import { resolveSkillsDir } from '../utils/paths.js';
+export const runSkillDefinition = {
+    name: 'run_skill',
+    description: 'Load and return the content of a skill (SKILL.md), optionally with project state context',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            skill: { type: 'string', description: 'Skill name (e.g., harness-tdd)' },
+            path: { type: 'string', description: 'Path to project root for state context injection' },
+            complexity: {
+                type: 'string',
+                enum: ['auto', 'light', 'full'],
+                description: 'Complexity level for scale-adaptive rigor',
+            },
+            phase: { type: 'string', description: 'Start at a specific phase (re-entry)' },
+            party: { type: 'boolean', description: 'Enable multi-perspective evaluation' },
+        },
+        required: ['skill'],
+    },
+};
+export async function handleRunSkill(input) {
+    const skillsDir = resolveSkillsDir();
+    const skillDir = path.join(skillsDir, input.skill);
+    if (!fs.existsSync(skillDir)) {
+        return resultToMcpResponse(Err(new Error(`Skill not found: ${input.skill}`)));
+    }
+    const skillMdPath = path.join(skillDir, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath)) {
+        return resultToMcpResponse(Err(new Error(`SKILL.md not found for skill: ${input.skill}`)));
+    }
+    let content = fs.readFileSync(skillMdPath, 'utf-8');
+    // Optionally inject project state context
+    if (input.path) {
+        const projectPath = path.resolve(input.path);
+        const stateFile = path.join(projectPath, '.harness', 'state.json');
+        if (fs.existsSync(stateFile)) {
+            const stateContent = fs.readFileSync(stateFile, 'utf-8');
+            content += `\n\n---\n## Project State\n\`\`\`json\n${stateContent}\n\`\`\`\n`;
+        }
+    }
+    return resultToMcpResponse(Ok(content));
+}

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

@@ -0,0 +1,22 @@
+export declare const validateToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleValidateProject(input: {
+    path: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;