@harness-engineering/mcp-server 0.3.3 → 0.5.0

package/dist/src/tools/graph.js

@@ -0,0 +1,495 @@
+import * as path from 'path';
+import { loadGraphStore } from '../utils/graph-loader.js';
+// ── Shared helper ────────────────────────────────────────────────────
+function sanitizePath(inputPath) {
+    const resolved = path.resolve(inputPath);
+    if (resolved === '/' || resolved === path.parse(resolved).root) {
+        throw new Error('Invalid project path: cannot use filesystem root');
+    }
+    return resolved;
+}
+function graphNotFoundError() {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: 'No graph found. Run `harness scan` or use `ingest_source` tool first.',
+            },
+        ],
+        isError: true,
+    };
+}
+// ── query_graph ──────────────────────────────────────────────────────
+export const queryGraphDefinition = {
+    name: 'query_graph',
+    description: 'Query the project knowledge graph using ContextQL. Traverses from root nodes outward, filtering by node/edge types.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            rootNodeIds: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Node IDs to start traversal from',
+            },
+            maxDepth: { type: 'number', description: 'Maximum traversal depth (default 3)' },
+            includeTypes: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Only include nodes of these types',
+            },
+            excludeTypes: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Exclude nodes of these types',
+            },
+            includeEdges: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Only traverse edges of these types',
+            },
+            bidirectional: {
+                type: 'boolean',
+                description: 'Traverse edges in both directions (default false)',
+            },
+            pruneObservability: {
+                type: 'boolean',
+                description: 'Prune observability nodes like spans/metrics/logs (default true)',
+            },
+        },
+        required: ['path', 'rootNodeIds'],
+    },
+};
+export async function handleQueryGraph(input) {
+    try {
+        const projectPath = sanitizePath(input.path);
+        const store = await loadGraphStore(projectPath);
+        if (!store)
+            return graphNotFoundError();
+        const { ContextQL } = await import('@harness-engineering/graph');
+        const cql = new ContextQL(store);
+        const result = cql.execute({
+            rootNodeIds: input.rootNodeIds,
+            maxDepth: input.maxDepth,
+            includeTypes: input.includeTypes,
+            excludeTypes: input.excludeTypes,
+            includeEdges: input.includeEdges,
+            bidirectional: input.bidirectional,
+            pruneObservability: input.pruneObservability,
+        });
+        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,
+        };
+    }
+}
+// ── search_similar ───────────────────────────────────────────────────
+export const searchSimilarDefinition = {
+    name: 'search_similar',
+    description: 'Search the knowledge graph for nodes similar to a query string using keyword and semantic fusion.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            query: { type: 'string', description: 'Search query string' },
+            topK: { type: 'number', description: 'Maximum number of results to return (default 10)' },
+        },
+        required: ['path', 'query'],
+    },
+};
+export async function handleSearchSimilar(input) {
+    try {
+        const projectPath = sanitizePath(input.path);
+        const store = await loadGraphStore(projectPath);
+        if (!store)
+            return graphNotFoundError();
+        const { FusionLayer } = await import('@harness-engineering/graph');
+        const fusion = new FusionLayer(store);
+        const results = fusion.search(input.query, input.topK ?? 10);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(results) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ── find_context_for ─────────────────────────────────────────────────
+export const findContextForDefinition = {
+    name: 'find_context_for',
+    description: 'Find relevant context for a given intent by searching the graph and expanding around top results. Returns assembled context within a token budget.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            intent: { type: 'string', description: 'Description of what context is needed for' },
+            tokenBudget: {
+                type: 'number',
+                description: 'Approximate token budget for results (default 4000)',
+            },
+        },
+        required: ['path', 'intent'],
+    },
+};
+export async function handleFindContextFor(input) {
+    try {
+        const projectPath = sanitizePath(input.path);
+        const store = await loadGraphStore(projectPath);
+        if (!store)
+            return graphNotFoundError();
+        const { FusionLayer, ContextQL } = await import('@harness-engineering/graph');
+        const fusion = new FusionLayer(store);
+        const cql = new ContextQL(store);
+        const tokenBudget = input.tokenBudget ?? 4000;
+        const charBudget = tokenBudget * 4;
+        // Find top relevant nodes
+        const searchResults = fusion.search(input.intent, 10);
+        if (searchResults.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ context: [], message: 'No relevant nodes found.' }),
+                    },
+                ],
+            };
+        }
+        // Expand context around each top result
+        const contextBlocks = [];
+        let totalChars = 0;
+        for (const result of searchResults) {
+            if (totalChars >= charBudget)
+                break;
+            const expanded = cql.execute({
+                rootNodeIds: [result.nodeId],
+                maxDepth: 2,
+            });
+            const blockJson = JSON.stringify({
+                rootNode: result.nodeId,
+                score: result.score,
+                nodes: expanded.nodes,
+                edges: expanded.edges,
+            });
+            if (totalChars + blockJson.length > charBudget && contextBlocks.length > 0) {
+                break;
+            }
+            contextBlocks.push({
+                rootNode: result.nodeId,
+                score: result.score,
+                nodes: expanded.nodes,
+                edges: expanded.edges,
+            });
+            totalChars += blockJson.length;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        intent: input.intent,
+                        tokenBudget,
+                        blocksReturned: contextBlocks.length,
+                        context: contextBlocks,
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ── get_relationships ────────────────────────────────────────────────
+export const getRelationshipsDefinition = {
+    name: 'get_relationships',
+    description: 'Get relationships for a specific node in the knowledge graph, with configurable direction and depth.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            nodeId: { type: 'string', description: 'ID of the node to get relationships for' },
+            direction: {
+                type: 'string',
+                enum: ['outbound', 'inbound', 'both'],
+                description: 'Direction of relationships to include (default both)',
+            },
+            depth: { type: 'number', description: 'Traversal depth (default 1)' },
+        },
+        required: ['path', 'nodeId'],
+    },
+};
+export async function handleGetRelationships(input) {
+    try {
+        const projectPath = sanitizePath(input.path);
+        const store = await loadGraphStore(projectPath);
+        if (!store)
+            return graphNotFoundError();
+        const { ContextQL } = await import('@harness-engineering/graph');
+        const cql = new ContextQL(store);
+        const direction = input.direction ?? 'both';
+        const bidirectional = direction === 'both' || direction === 'inbound';
+        const result = cql.execute({
+            rootNodeIds: [input.nodeId],
+            maxDepth: input.depth ?? 1,
+            bidirectional,
+        });
+        // Post-filter for inbound-only: remove outbound edges from the root node
+        let filteredNodes = result.nodes;
+        let filteredEdges = result.edges;
+        if (direction === 'inbound') {
+            filteredEdges = result.edges.filter((e) => e.from !== input.nodeId);
+            const reachableNodeIds = new Set(filteredEdges.map((e) => e.from));
+            reachableNodeIds.add(input.nodeId);
+            filteredNodes = result.nodes.filter((n) => reachableNodeIds.has(n.id));
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        nodeId: input.nodeId,
+                        direction,
+                        depth: input.depth ?? 1,
+                        nodes: filteredNodes,
+                        edges: filteredEdges,
+                        stats: result.stats,
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ── get_impact ───────────────────────────────────────────────────────
+export const getImpactDefinition = {
+    name: 'get_impact',
+    description: 'Analyze the impact of changing a node or file. Returns affected tests, docs, code, and other nodes grouped by type.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            nodeId: { type: 'string', description: 'ID of the node to analyze impact for' },
+            filePath: {
+                type: 'string',
+                description: 'File path (relative to project root) to analyze impact for',
+            },
+        },
+        required: ['path'],
+    },
+};
+export async function handleGetImpact(input) {
+    try {
+        if (!input.nodeId && !input.filePath) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: either nodeId or filePath is required',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const projectPath = sanitizePath(input.path);
+        const store = await loadGraphStore(projectPath);
+        if (!store)
+            return graphNotFoundError();
+        const { ContextQL } = await import('@harness-engineering/graph');
+        let targetNodeId = input.nodeId;
+        // If filePath provided, resolve to nodeId
+        if (!targetNodeId && input.filePath) {
+            const fileNodes = store.findNodes({ type: 'file' });
+            const match = fileNodes.find((n) => n.path === input.filePath || n.id === `file:${input.filePath}`);
+            if (!match) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: no file node found matching path "${input.filePath}"`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            targetNodeId = match.id;
+        }
+        const cql = new ContextQL(store);
+        const result = cql.execute({
+            rootNodeIds: [targetNodeId],
+            bidirectional: true,
+            maxDepth: 3,
+        });
+        // Group result nodes by type
+        const groups = {
+            tests: [],
+            docs: [],
+            code: [],
+            other: [],
+        };
+        const testTypes = new Set(['test_result']);
+        const docTypes = new Set(['adr', 'decision', 'document', 'learning']);
+        const codeTypes = new Set([
+            'file',
+            'module',
+            'class',
+            'interface',
+            'function',
+            'method',
+            'variable',
+        ]);
+        for (const node of result.nodes) {
+            // Skip the target node itself
+            if (node.id === targetNodeId)
+                continue;
+            if (testTypes.has(node.type)) {
+                groups['tests'].push(node);
+            }
+            else if (docTypes.has(node.type)) {
+                groups['docs'].push(node);
+            }
+            else if (codeTypes.has(node.type)) {
+                groups['code'].push(node);
+            }
+            else {
+                groups['other'].push(node);
+            }
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        targetNodeId,
+                        impact: groups,
+                        stats: result.stats,
+                        edges: result.edges,
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ── ingest_source ────────────────────────────────────────────────────
+export const ingestSourceDefinition = {
+    name: 'ingest_source',
+    description: 'Ingest sources into the project knowledge graph. Supports code analysis, knowledge documents, git history, or all at once.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            source: {
+                type: 'string',
+                enum: ['code', 'knowledge', 'git', 'all'],
+                description: 'Type of source to ingest',
+            },
+        },
+        required: ['path', 'source'],
+    },
+};
+export async function handleIngestSource(input) {
+    try {
+        const projectPath = sanitizePath(input.path);
+        const graphDir = path.join(projectPath, '.harness', 'graph');
+        const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import('@harness-engineering/graph');
+        const fs = await import('node:fs/promises');
+        // Ensure graph directory exists
+        await fs.mkdir(graphDir, { recursive: true });
+        // Try to load existing graph, or start fresh
+        const store = new GraphStore();
+        await store.load(graphDir);
+        const results = [];
+        if (input.source === 'code' || input.source === 'all') {
+            const codeIngestor = new CodeIngestor(store);
+            const codeResult = await codeIngestor.ingest(projectPath);
+            results.push(codeResult);
+            const linker = new TopologicalLinker(store);
+            linker.link();
+        }
+        if (input.source === 'knowledge' || input.source === 'all') {
+            const knowledgeIngestor = new KnowledgeIngestor(store);
+            const knowledgeResult = await knowledgeIngestor.ingestAll(projectPath);
+            results.push(knowledgeResult);
+        }
+        if (input.source === 'git' || input.source === 'all') {
+            const gitIngestor = new GitIngestor(store);
+            const gitResult = await gitIngestor.ingest(projectPath);
+            results.push(gitResult);
+        }
+        // Save the graph
+        await store.save(graphDir);
+        // Combine results
+        const combined = {
+            nodesAdded: results.reduce((s, r) => s + r.nodesAdded, 0),
+            nodesUpdated: results.reduce((s, r) => s + r.nodesUpdated, 0),
+            edgesAdded: results.reduce((s, r) => s + r.edgesAdded, 0),
+            edgesUpdated: results.reduce((s, r) => s + r.edgesUpdated, 0),
+            errors: results.flatMap((r) => r.errors),
+            durationMs: results.reduce((s, r) => s + r.durationMs, 0),
+            graphStats: {
+                totalNodes: store.nodeCount,
+                totalEdges: store.edgeCount,
+            },
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(combined) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -44,6 +44,11 @@ export declare const runPersonaDefinition: {
                 type: string;
                 description: string;
             };
+            trigger: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
             dryRun: {
                 type: string;
                 description: string;
@@ -55,5 +60,6 @@ export declare const runPersonaDefinition: {
 export declare function handleRunPersona(input: {
     persona: string;
     path?: string;
+    trigger?: string;
     dryRun?: boolean;
 }): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/persona.js

@@ -55,34 +55,42 @@ export async function handleGeneratePersonaArtifacts(input) {
 }
 export const runPersonaDefinition = {
     name: 'run_persona',
-    description: 'Execute all commands defined in a persona and return aggregated results',
+    description: 'Execute all steps 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' },
+            trigger: {
+                type: 'string',
+                enum: [
+                    'always',
+                    'on_pr',
+                    'on_commit',
+                    'on_review',
+                    'scheduled',
+                    'manual',
+                    'on_plan_approved',
+                    'auto',
+                ],
+                description: 'Trigger context for step filtering (default: auto)',
+            },
             dryRun: { type: 'boolean', description: 'Preview without side effects' },
         },
         required: ['persona'],
     },
 };
 export async function handleRunPersona(input) {
-    const { loadPersona, runPersona } = await import('@harness-engineering/cli');
+    const { loadPersona, runPersona, executeSkill } = 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)) {
+    const trigger = (input.trigger ?? 'auto');
+    const { ALLOWED_PERSONA_COMMANDS } = await import('@harness-engineering/cli');
+    const commandExecutor = async (command) => {
+        if (!ALLOWED_PERSONA_COMMANDS.has(command)) {
             return Err(new Error(`Unknown harness command: ${command}`));
         }
         try {
@@ -101,6 +109,11 @@ export async function handleRunPersona(input) {
             return Err(new Error(`${command} failed: ${error instanceof Error ? error.message : String(error)}`));
         }
     };
-    const report = await runPersona(personaResult.value, executor);
+    const report = await runPersona(personaResult.value, {
+        trigger,
+        commandExecutor,
+        skillExecutor: executeSkill,
+        projectPath,
+    });
     return resultToMcpResponse(Ok(report));
 }

package/dist/src/utils/graph-loader.d.ts

@@ -0,0 +1 @@
+export declare function loadGraphStore(projectRoot: string): Promise<import("@harness-engineering/graph").GraphStore | null>;

package/dist/src/utils/graph-loader.js

@@ -0,0 +1,10 @@
+import * as path from 'path';
+export async function loadGraphStore(projectRoot) {
+    const { GraphStore } = await import('@harness-engineering/graph');
+    const graphDir = path.join(projectRoot, '.harness', 'graph');
+    const store = new GraphStore();
+    const loaded = await store.load(graphDir);
+    if (!loaded)
+        return null;
+    return store;
+}

package/package.json

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