@harness-engineering/mcp-server 0.3.2 → 0.5.0

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

@@ -0,0 +1,3 @@
+export declare function getGraphResource(projectRoot: string): Promise<string>;
+export declare function getEntitiesResource(projectRoot: string): Promise<string>;
+export declare function getRelationshipsResource(projectRoot: string): Promise<string>;

package/dist/src/resources/graph.js

@@ -0,0 +1,104 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'path';
+import { loadGraphStore } from '../utils/graph-loader.js';
+const MAX_ITEMS = 5000;
+function formatStaleness(isoTimestamp) {
+    const then = new Date(isoTimestamp).getTime();
+    const now = Date.now();
+    const diffMs = now - then;
+    const seconds = Math.floor(diffMs / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days} day${days === 1 ? '' : 's'} ago`;
+    if (hours > 0)
+        return `${hours} hour${hours === 1 ? '' : 's'} ago`;
+    if (minutes > 0)
+        return `${minutes} minute${minutes === 1 ? '' : 's'} ago`;
+    return 'just now';
+}
+export async function getGraphResource(projectRoot) {
+    const store = await loadGraphStore(projectRoot);
+    if (!store) {
+        return JSON.stringify({
+            status: 'no_graph',
+            message: 'No knowledge graph found. Run harness scan to build one.',
+        });
+    }
+    const graphDir = path.join(projectRoot, '.harness', 'graph');
+    const metadataPath = path.join(graphDir, 'metadata.json');
+    let lastScanTimestamp = null;
+    try {
+        const raw = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
+        lastScanTimestamp = raw.lastScanTimestamp ?? null;
+    }
+    catch {
+        // Ignore missing or malformed metadata
+    }
+    const allNodes = store.findNodes({});
+    const allEdges = store.getEdges({});
+    const nodesByType = {};
+    for (const node of allNodes) {
+        nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
+    }
+    const edgesByType = {};
+    for (const edge of allEdges) {
+        edgesByType[edge.type] = (edgesByType[edge.type] ?? 0) + 1;
+    }
+    let status = 'ok';
+    let staleness = 'unknown';
+    if (lastScanTimestamp) {
+        const ageMs = Date.now() - new Date(lastScanTimestamp).getTime();
+        const twentyFourHoursMs = 24 * 60 * 60 * 1000;
+        if (ageMs > twentyFourHoursMs) {
+            status = 'stale';
+        }
+        staleness = formatStaleness(lastScanTimestamp);
+    }
+    return JSON.stringify({
+        status,
+        nodeCount: store.nodeCount,
+        edgeCount: store.edgeCount,
+        nodesByType,
+        edgesByType,
+        lastScanTimestamp,
+        staleness,
+    });
+}
+export async function getEntitiesResource(projectRoot) {
+    const store = await loadGraphStore(projectRoot);
+    if (!store) {
+        return '[]';
+    }
+    const nodes = store.findNodes({});
+    const entities = nodes.slice(0, MAX_ITEMS).map((n) => ({
+        id: n.id,
+        type: n.type,
+        name: n.name,
+        path: n.path,
+        metadata: n.metadata,
+    }));
+    if (nodes.length > MAX_ITEMS) {
+        return JSON.stringify({ entities, _truncated: true, _total: nodes.length }, null, 2);
+    }
+    return JSON.stringify(entities);
+}
+export async function getRelationshipsResource(projectRoot) {
+    const store = await loadGraphStore(projectRoot);
+    if (!store) {
+        return '[]';
+    }
+    const edges = store.getEdges({});
+    const relationships = edges.slice(0, MAX_ITEMS).map((e) => ({
+        from: e.from,
+        to: e.to,
+        type: e.type,
+        confidence: e.confidence,
+        metadata: e.metadata,
+    }));
+    if (edges.length > MAX_ITEMS) {
+        return JSON.stringify({ relationships, _truncated: true, _total: edges.length }, null, 2);
+    }
+    return JSON.stringify(relationships);
+}

package/dist/src/server.js

@@ -20,6 +20,9 @@ import { checkPhaseGateDefinition, handleCheckPhaseGate } from './tools/phase-ga
 import { validateCrossCheckDefinition, handleValidateCrossCheck } from './tools/cross-check.js';
 import { generateSlashCommandsDefinition, handleGenerateSlashCommands, } from './tools/generate-slash-commands.js';
 import { getStateResource } from './resources/state.js';
+import { queryGraphDefinition, handleQueryGraph, searchSimilarDefinition, handleSearchSimilar, findContextForDefinition, handleFindContextFor, getRelationshipsDefinition, handleGetRelationships, getImpactDefinition, handleGetImpact, ingestSourceDefinition, handleIngestSource, } from './tools/graph.js';
+import { getGraphResource, getEntitiesResource, getRelationshipsResource, } from './resources/graph.js';
+import { generateAgentDefinitionsDefinition, handleGenerateAgentDefinitions, } from './tools/agent-definitions.js';
 const TOOL_DEFINITIONS = [
     validateToolDefinition,
     checkDependenciesDefinition,
@@ -45,6 +48,13 @@ const TOOL_DEFINITIONS = [
     validateCrossCheckDefinition,
     createSkillDefinition,
     generateSlashCommandsDefinition,
+    queryGraphDefinition,
+    searchSimilarDefinition,
+    findContextForDefinition,
+    getRelationshipsDefinition,
+    getImpactDefinition,
+    ingestSourceDefinition,
+    generateAgentDefinitionsDefinition,
 ];
 const TOOL_HANDLERS = {
     validate_project: handleValidateProject,
@@ -71,6 +81,13 @@ const TOOL_HANDLERS = {
     validate_cross_check: handleValidateCrossCheck,
     create_skill: handleCreateSkill,
     generate_slash_commands: handleGenerateSlashCommands,
+    query_graph: handleQueryGraph,
+    search_similar: handleSearchSimilar,
+    find_context_for: handleFindContextFor,
+    get_relationships: handleGetRelationships,
+    get_impact: handleGetImpact,
+    ingest_source: handleIngestSource,
+    generate_agent_definitions: handleGenerateAgentDefinitions,
 };
 const RESOURCE_DEFINITIONS = [
     {
@@ -103,6 +120,24 @@ const RESOURCE_DEFINITIONS = [
         description: 'Current harness state including position, progress, decisions, and blockers',
         mimeType: 'application/json',
     },
+    {
+        uri: 'harness://graph',
+        name: 'Knowledge Graph',
+        description: 'Graph statistics, node/edge counts by type, staleness',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'harness://entities',
+        name: 'Graph Entities',
+        description: 'All entity nodes with types and metadata',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'harness://relationships',
+        name: 'Graph Relationships',
+        description: 'All edges with types, confidence scores, and timestamps',
+        mimeType: 'application/json',
+    },
 ];
 const RESOURCE_HANDLERS = {
     'harness://skills': getSkillsResource,
@@ -110,6 +145,9 @@ const RESOURCE_HANDLERS = {
     'harness://project': getProjectResource,
     'harness://learnings': getLearningsResource,
     'harness://state': getStateResource,
+    'harness://graph': getGraphResource,
+    'harness://entities': getEntitiesResource,
+    'harness://relationships': getRelationshipsResource,
 };
 export function getToolDefinitions() {
     return TOOL_DEFINITIONS;

package/dist/src/tools/agent-definitions.d.ts

@@ -0,0 +1,27 @@
+export declare const generateAgentDefinitionsDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            global: {
+                type: string;
+                description: string;
+            };
+            platform: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            dryRun: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+};
+export declare function handleGenerateAgentDefinitions(input: {
+    global?: boolean;
+    platform?: string;
+    dryRun?: boolean;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/agent-definitions.js

@@ -0,0 +1,30 @@
+import { Ok } from '@harness-engineering/core';
+import { resultToMcpResponse } from '../utils/result-adapter.js';
+export const generateAgentDefinitionsDefinition = {
+    name: 'generate_agent_definitions',
+    description: 'Generate agent definition files from personas for Claude Code and Gemini CLI',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            global: { type: 'boolean', description: 'Write to global agent directory' },
+            platform: {
+                type: 'string',
+                enum: ['claude-code', 'gemini-cli', 'all'],
+                description: 'Target platform (default: all)',
+            },
+            dryRun: { type: 'boolean', description: 'Preview without writing' },
+        },
+    },
+};
+export async function handleGenerateAgentDefinitions(input) {
+    const { generateAgentDefinitions } = await import('@harness-engineering/cli');
+    const platforms = input.platform === 'all' || !input.platform
+        ? ['claude-code', 'gemini-cli']
+        : [input.platform];
+    const results = generateAgentDefinitions({
+        platforms: [...platforms],
+        global: input.global ?? false,
+        dryRun: input.dryRun ?? false,
+    });
+    return resultToMcpResponse(Ok(results));
+}

package/dist/src/tools/architecture.js

@@ -28,7 +28,25 @@ export async function handleCheckDependencies(input) {
             allowedDependencies: l.allowedDependencies,
         }));
         const parser = new TypeScriptParser();
-        const result = await validateDependencies({ layers, rootDir: projectPath, parser });
+        // Attempt to load graph for enhanced validation
+        const { loadGraphStore } = await import('../utils/graph-loader.js');
+        const store = await loadGraphStore(projectPath);
+        let graphDependencyData;
+        if (store) {
+            const { GraphConstraintAdapter } = await import('@harness-engineering/graph');
+            const adapter = new GraphConstraintAdapter(store);
+            const graphData = adapter.computeDependencyGraph();
+            graphDependencyData = {
+                nodes: [...graphData.nodes],
+                edges: graphData.edges.map((e) => ({ ...e })),
+            };
+        }
+        const result = await validateDependencies({
+            layers,
+            rootDir: projectPath,
+            parser,
+            graphDependencyData,
+        });
         return resultToMcpResponse(result);
     }
     catch (error) {

package/dist/src/tools/docs.js

@@ -16,9 +16,24 @@ export async function handleCheckDocs(input) {
     try {
         const { checkDocCoverage } = await import('@harness-engineering/core');
         const domain = input.domain ?? 'src';
+        // Attempt to load graph for enhanced coverage analysis
+        const { loadGraphStore } = await import('../utils/graph-loader.js');
+        const store = await loadGraphStore(path.resolve(input.path));
+        let graphCoverage;
+        if (store) {
+            const { Assembler } = await import('@harness-engineering/graph');
+            const assembler = new Assembler(store);
+            const report = assembler.checkCoverage();
+            graphCoverage = {
+                documented: [...report.documented],
+                undocumented: [...report.undocumented],
+                coveragePercentage: report.coveragePercentage,
+            };
+        }
         const result = await checkDocCoverage(domain, {
             sourceDir: path.resolve(input.path, 'src'),
             docsDir: path.resolve(input.path, 'docs'),
+            graphCoverage,
         });
         return resultToMcpResponse(result);
     }

package/dist/src/tools/entropy.js

@@ -1,6 +1,35 @@
 import * as path from 'path';
 import { Ok } from '@harness-engineering/core';
 import { resultToMcpResponse } from '../utils/result-adapter.js';
+async function loadEntropyGraphOptions(projectPath) {
+    const { loadGraphStore } = await import('../utils/graph-loader.js');
+    const store = await loadGraphStore(projectPath);
+    if (!store)
+        return undefined;
+    const { GraphEntropyAdapter } = await import('@harness-engineering/graph');
+    const adapter = new GraphEntropyAdapter(store);
+    const driftData = adapter.computeDriftData();
+    const deadCodeData = adapter.computeDeadCodeData();
+    return {
+        graphDriftData: {
+            staleEdges: driftData.staleEdges.map((e) => ({
+                docNodeId: e.docNodeId,
+                codeNodeId: e.codeNodeId,
+                edgeType: e.edgeType,
+            })),
+            missingTargets: [...driftData.missingTargets],
+        },
+        graphDeadCodeData: {
+            reachableNodeIds: new Set(deadCodeData.reachableNodeIds),
+            unreachableNodes: deadCodeData.unreachableNodes.map((n) => ({
+                id: n.id,
+                type: n.type,
+                name: n.name,
+                path: n.path,
+            })),
+        },
+    };
+}
 export const detectEntropyDefinition = {
     name: 'detect_entropy',
     description: 'Detect documentation drift, dead code, and pattern violations',
@@ -29,7 +58,8 @@ export async function handleDetectEntropy(input) {
                 patterns: typeFilter === 'all' || typeFilter === 'patterns',
             },
         });
-        const result = await analyzer.analyze();
+        const graphOptions = await loadEntropyGraphOptions(path.resolve(input.path));
+        const result = await analyzer.analyze(graphOptions);
         return resultToMcpResponse(result);
     }
     catch (error) {
@@ -63,7 +93,8 @@ export async function handleApplyFixes(input) {
             rootDir: path.resolve(input.path),
             analyze: { drift: true, deadCode: true, patterns: true },
         });
-        const analysisResult = await analyzer.analyze();
+        const graphOptions = await loadEntropyGraphOptions(path.resolve(input.path));
+        const analysisResult = await analyzer.analyze(graphOptions);
         if (!analysisResult.ok)
             return resultToMcpResponse(analysisResult);
         const report = analysisResult.value;

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

@@ -48,6 +48,10 @@ export declare const analyzeDiffDefinition: {
                 type: string;
                 description: string;
             };
+            path: {
+                type: string;
+                description: string;
+            };
             forbiddenPatterns: {
                 type: string;
                 items: {
@@ -69,6 +73,7 @@ export declare const analyzeDiffDefinition: {
 };
 export declare function handleAnalyzeDiff(input: {
     diff: string;
+    path?: string;
     forbiddenPatterns?: string[];
     maxFileSize?: number;
     maxFileCount?: number;

package/dist/src/tools/feedback.js

@@ -47,7 +47,26 @@ export async function handleCreateSelfReview(input) {
                 ...(input.maxFileCount !== undefined ? { maxChangedFiles: input.maxFileCount } : {}),
             },
         };
-        const result = await createSelfReview(parseResult.value, config);
+        // Attempt to load graph for enhanced review
+        const { loadGraphStore } = await import('../utils/graph-loader.js');
+        const store = await loadGraphStore(path.resolve(input.path));
+        let graphData;
+        if (store) {
+            const { GraphFeedbackAdapter } = await import('@harness-engineering/graph');
+            const adapter = new GraphFeedbackAdapter(store);
+            const changedFiles = parseResult.value.files.map((f) => f.path);
+            const impact = adapter.computeImpactData(changedFiles);
+            const harness = adapter.computeHarnessCheckData();
+            graphData = {
+                impact: {
+                    affectedTests: [...impact.affectedTests],
+                    affectedDocs: [...impact.affectedDocs],
+                    impactScope: impact.impactScope,
+                },
+                harness: { ...harness },
+            };
+        }
+        const result = await createSelfReview(parseResult.value, config, graphData);
         return resultToMcpResponse(result);
     }
     catch (error) {
@@ -70,6 +89,10 @@ export const analyzeDiffDefinition = {
         type: 'object',
         properties: {
             diff: { type: 'string', description: 'Git diff string to analyze' },
+            path: {
+                type: 'string',
+                description: 'Path to project root (enables graph-enhanced analysis)',
+            },
             forbiddenPatterns: {
                 type: 'array',
                 items: { type: 'string' },
@@ -108,7 +131,28 @@ export async function handleAnalyzeDiff(input) {
             ...(input.maxFileSize !== undefined ? { maxFileSize: input.maxFileSize } : {}),
             ...(input.maxFileCount !== undefined ? { maxChangedFiles: input.maxFileCount } : {}),
         };
-        const result = await analyzeDiff(parseResult.value, options);
+        let graphImpactData;
+        if (input.path) {
+            try {
+                const { loadGraphStore } = await import('../utils/graph-loader.js');
+                const store = await loadGraphStore(path.resolve(input.path));
+                if (store) {
+                    const { GraphFeedbackAdapter } = await import('@harness-engineering/graph');
+                    const adapter = new GraphFeedbackAdapter(store);
+                    const changedFiles = parseResult.value.files.map((f) => f.path);
+                    const impact = adapter.computeImpactData(changedFiles);
+                    graphImpactData = {
+                        affectedTests: [...impact.affectedTests],
+                        affectedDocs: [...impact.affectedDocs],
+                        impactScope: impact.impactScope,
+                    };
+                }
+            }
+            catch {
+                // Graph loading is optional — continue without it
+            }
+        }
+        const result = await analyzeDiff(parseResult.value, options, graphImpactData);
         return resultToMcpResponse(result);
     }
     catch (error) {
@@ -160,6 +204,24 @@ export async function handleRequestPeerReview(input) {
             diff: input.diff,
             ...(input.context ? { metadata: { context: input.context } } : {}),
         };
+        // Attempt to load graph for enhanced context
+        try {
+            const { loadGraphStore } = await import('../utils/graph-loader.js');
+            const store = await loadGraphStore(path.resolve(input.path));
+            if (store) {
+                const { GraphFeedbackAdapter } = await import('@harness-engineering/graph');
+                const adapter = new GraphFeedbackAdapter(store);
+                const changedFiles = parseResult.value.files.map((f) => f.path);
+                const impactData = adapter.computeImpactData(changedFiles);
+                reviewContext.metadata = {
+                    ...reviewContext.metadata,
+                    graphContext: impactData,
+                };
+            }
+        }
+        catch {
+            // Graph loading is optional
+        }
         const result = await requestPeerReview(input.agentType, reviewContext, {
             timeout: 120_000,
             wait: true,

package/dist/src/tools/generate-slash-commands.d.ts

@@ -21,6 +21,10 @@ export declare const generateSlashCommandsDefinition: {
                 type: string;
                 description: string;
             };
+            includeGlobal: {
+                type: string;
+                description: string;
+            };
             dryRun: {
                 type: string;
                 description: string;
@@ -31,6 +35,7 @@ export declare const generateSlashCommandsDefinition: {
 export declare function handleGenerateSlashCommands(input: {
     platforms?: string;
     global?: boolean;
+    includeGlobal?: boolean;
     output?: string;
     skillsDir?: string;
     dryRun?: boolean;

package/dist/src/tools/generate-slash-commands.js

@@ -23,6 +23,10 @@ export const generateSlashCommandsDefinition = {
                 type: 'string',
                 description: 'Skills directory to scan',
             },
+            includeGlobal: {
+                type: 'boolean',
+                description: 'Include built-in global skills alongside project skills',
+            },
             dryRun: {
                 type: 'boolean',
                 description: 'Show what would change without writing files',
@@ -38,6 +42,7 @@ export async function handleGenerateSlashCommands(input) {
         const results = generateSlashCommands({
             platforms,
             global: input.global ?? false,
+            includeGlobal: input.includeGlobal ?? false,
             output: input.output,
             skillsDir: input.skillsDir ?? '',
             dryRun: input.dryRun ?? false,