@harness-engineering/mcp-server 0.1.0

package/dist/src/tools/validate.js

@@ -0,0 +1,85 @@
+import * as path from 'path';
+import { resolveProjectConfig } from '../utils/config-resolver.js';
+export const validateToolDefinition = {
+    name: 'validate_project',
+    description: 'Run all validation checks on a harness engineering project',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root directory' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleValidateProject(input) {
+    const projectPath = path.resolve(input.path);
+    const errors = [];
+    const checks = {
+        config: 'fail',
+        structure: 'skipped',
+        agentsMap: 'skipped',
+    };
+    // 1. Load config
+    const configResult = resolveProjectConfig(projectPath);
+    if (!configResult.ok) {
+        errors.push(`Config: ${configResult.error.message}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ valid: false, checks, errors }) }],
+        };
+    }
+    checks.config = 'pass';
+    const config = configResult.value;
+    // 2. Run validateFileStructure if conventions are available
+    try {
+        const core = await import('@harness-engineering/core');
+        if (typeof core.validateFileStructure === 'function' &&
+            Array.isArray(config.conventions)) {
+            const structureResult = await core.validateFileStructure(projectPath, config.conventions);
+            if (structureResult.ok) {
+                checks.structure = structureResult.value.valid ? 'pass' : 'fail';
+                if (!structureResult.value.valid) {
+                    for (const missing of structureResult.value.missing) {
+                        errors.push(`Missing required file: ${missing}`);
+                    }
+                }
+            }
+            else {
+                checks.structure = 'fail';
+                errors.push(`Structure validation error: ${structureResult.error.message}`);
+            }
+        }
+    }
+    catch {
+        // core not available, skip
+    }
+    // 3. Run validateAgentsMap
+    try {
+        const core = await import('@harness-engineering/core');
+        if (typeof core.validateAgentsMap === 'function') {
+            const agentsMapPath = path.join(projectPath, 'AGENTS.md');
+            const agentsResult = await core.validateAgentsMap(agentsMapPath);
+            if (agentsResult.ok) {
+                checks.agentsMap = agentsResult.value.valid ? 'pass' : 'fail';
+                if (!agentsResult.value.valid) {
+                    if (agentsResult.value.missingSections.length > 0) {
+                        errors.push(`AGENTS.md missing sections: ${agentsResult.value.missingSections.join(', ')}`);
+                    }
+                    if (agentsResult.value.brokenLinks.length > 0) {
+                        errors.push(`AGENTS.md has ${agentsResult.value.brokenLinks.length} broken link(s)`);
+                    }
+                }
+            }
+            else {
+                checks.agentsMap = 'fail';
+                errors.push(`AGENTS.md validation error: ${agentsResult.error.message}`);
+            }
+        }
+    }
+    catch {
+        // core not available, skip
+    }
+    const valid = errors.length === 0;
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ valid, checks, errors }) }],
+    };
+}

package/dist/src/utils/config-resolver.d.ts

@@ -0,0 +1,7 @@
+import type { Result } from '@harness-engineering/core';
+export interface ProjectConfig {
+    name?: string;
+    version: number;
+    [key: string]: unknown;
+}
+export declare function resolveProjectConfig(projectPath: string): Result<ProjectConfig, Error>;

package/dist/src/utils/config-resolver.js

@@ -0,0 +1,18 @@
+// packages/mcp-server/src/utils/config-resolver.ts
+import * as fs from 'fs';
+import * as path from 'path';
+import { Ok, Err } from '@harness-engineering/core';
+export function resolveProjectConfig(projectPath) {
+    const configPath = path.join(projectPath, 'harness.config.json');
+    if (!fs.existsSync(configPath)) {
+        return Err(new Error(`No harness.config.json found in ${projectPath}`));
+    }
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(raw);
+        return Ok(config);
+    }
+    catch (error) {
+        return Err(new Error(`Failed to parse config: ${error instanceof Error ? error.message : String(error)}`));
+    }
+}

package/dist/src/utils/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveTemplatesDir(): string;
+export declare function resolvePersonasDir(): string;
+export declare function resolveSkillsDir(): string;

package/dist/src/utils/paths.js

@@ -0,0 +1,33 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function findUpDir(targetName, marker, maxLevels = 8) {
+    let dir = __dirname;
+    for (let i = 0; i < maxLevels; i++) {
+        const candidate = path.join(dir, targetName);
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+            if (fs.existsSync(path.join(candidate, marker))) {
+                return candidate;
+            }
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+export function resolveTemplatesDir() {
+    return (findUpDir('templates', 'base') ?? path.resolve(__dirname, '..', '..', '..', '..', 'templates'));
+}
+export function resolvePersonasDir() {
+    const agentsDir = findUpDir('agents', 'personas');
+    if (agentsDir)
+        return path.join(agentsDir, 'personas');
+    return path.resolve(__dirname, '..', '..', '..', '..', 'agents', 'personas');
+}
+export function resolveSkillsDir() {
+    const agentsDir = findUpDir('agents', 'skills');
+    if (agentsDir)
+        return path.join(agentsDir, 'skills', 'claude-code');
+    return path.resolve(__dirname, '..', '..', '..', '..', 'agents', 'skills', 'claude-code');
+}

package/dist/src/utils/result-adapter.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from '@harness-engineering/core';
+export interface McpToolResponse {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export declare function resultToMcpResponse(result: Result<unknown, {
+    message: string;
+}>): McpToolResponse;

package/dist/src/utils/result-adapter.js

@@ -0,0 +1,11 @@
+export function resultToMcpResponse(result) {
+    if (result.ok) {
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result.value) }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: result.error.message }],
+        isError: true,
+    };
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@harness-engineering/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for Harness Engineering toolkit",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "harness-mcp": "./dist/bin/harness-mcp.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.0",
+    "yaml": "^2.3.0",
+    "handlebars": "^4.7.0",
+    "@harness-engineering/types": "0.0.0",
+    "@harness-engineering/cli": "1.0.0",
+    "@harness-engineering/core": "0.5.0",
+    "@harness-engineering/linter-gen": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Intense-Visions/harness-engineering.git",
+    "directory": "packages/mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/Intense-Visions/harness-engineering/issues"
+  },
+  "homepage": "https://github.com/Intense-Visions/harness-engineering/tree/main/packages/mcp-server#readme",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}