@harness-engineering/mcp-server 0.5.0 → 0.5.1

package/dist/src/resources/state.js

@@ -1,6 +1,7 @@
 export async function getStateResource(projectRoot) {
     try {
-        const { loadState } = await import('@harness-engineering/core');
+        const { loadState, migrateToStreams } = await import('@harness-engineering/core');
+        await migrateToStreams(projectRoot);
         const result = await loadState(projectRoot);
         if (result.ok) {
             return JSON.stringify(result.value, null, 2);

package/dist/src/server.js

@@ -5,6 +5,7 @@ import { validateToolDefinition, handleValidateProject } from './tools/validate.
 import { checkDependenciesDefinition, handleCheckDependencies } from './tools/architecture.js';
 import { checkDocsDefinition, handleCheckDocs, validateKnowledgeMapDefinition, handleValidateKnowledgeMap, } from './tools/docs.js';
 import { detectEntropyDefinition, handleDetectEntropy, applyFixesDefinition, handleApplyFixes, } from './tools/entropy.js';
+import { checkPerformanceDefinition, handleCheckPerformance, getPerfBaselinesDefinition, handleGetPerfBaselines, updatePerfBaselinesDefinition, handleUpdatePerfBaselines, getCriticalPathsDefinition, handleGetCriticalPaths, } from './tools/performance.js';
 import { generateLinterDefinition, handleGenerateLinter, validateLinterConfigDefinition, handleValidateLinterConfig, } from './tools/linter.js';
 import { initProjectDefinition, handleInitProject } from './tools/init.js';
 import { listPersonasDefinition, handleListPersonas, generatePersonaArtifactsDefinition, handleGeneratePersonaArtifacts, runPersonaDefinition, handleRunPersona, } from './tools/persona.js';
@@ -14,7 +15,7 @@ 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 { manageStateDefinition, handleManageState, manageHandoffDefinition, handleManageHandoff, listStreamsDefinition, handleListStreams, } 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';
@@ -23,6 +24,7 @@ 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';
+import { runSecurityScanDefinition, handleRunSecurityScan } from './tools/security.js';
 const TOOL_DEFINITIONS = [
     validateToolDefinition,
     checkDependenciesDefinition,
@@ -55,6 +57,12 @@ const TOOL_DEFINITIONS = [
     getImpactDefinition,
     ingestSourceDefinition,
     generateAgentDefinitionsDefinition,
+    runSecurityScanDefinition,
+    checkPerformanceDefinition,
+    getPerfBaselinesDefinition,
+    updatePerfBaselinesDefinition,
+    getCriticalPathsDefinition,
+    listStreamsDefinition,
 ];
 const TOOL_HANDLERS = {
     validate_project: handleValidateProject,
@@ -88,6 +96,12 @@ const TOOL_HANDLERS = {
     get_impact: handleGetImpact,
     ingest_source: handleIngestSource,
     generate_agent_definitions: handleGenerateAgentDefinitions,
+    run_security_scan: handleRunSecurityScan,
+    check_performance: handleCheckPerformance,
+    get_perf_baselines: handleGetPerfBaselines,
+    update_perf_baselines: handleUpdatePerfBaselines,
+    get_critical_paths: handleGetCriticalPaths,
+    list_streams: handleListStreams,
 };
 const RESOURCE_DEFINITIONS = [
     {

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

@@ -0,0 +1,115 @@
+export declare const checkPerformanceDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleCheckPerformance(input: {
+    path: string;
+    type?: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const getPerfBaselinesDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGetPerfBaselines(input: {
+    path: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const updatePerfBaselinesDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            commitHash: {
+                type: string;
+                description: string;
+            };
+            results: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        file: {
+                            type: string;
+                        };
+                        opsPerSec: {
+                            type: string;
+                        };
+                        meanMs: {
+                            type: string;
+                        };
+                        p99Ms: {
+                            type: string;
+                        };
+                        marginOfError: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleUpdatePerfBaselines(input: {
+    path: string;
+    commitHash: string;
+    results: Array<{
+        name: string;
+        file: string;
+        opsPerSec: number;
+        meanMs: number;
+        p99Ms: number;
+        marginOfError: number;
+    }>;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const getCriticalPathsDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGetCriticalPaths(input: {
+    path: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/performance.js

@@ -0,0 +1,175 @@
+import * as path from 'path';
+import { Ok } from '@harness-engineering/core';
+import { resultToMcpResponse } from '../utils/result-adapter.js';
+export const checkPerformanceDefinition = {
+    name: 'check_performance',
+    description: 'Run performance checks: structural complexity, coupling metrics, and size budgets',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            type: {
+                type: 'string',
+                enum: ['structural', 'coupling', 'size', 'all'],
+                description: 'Type of performance check (default: all)',
+            },
+        },
+        required: ['path'],
+    },
+};
+export async function handleCheckPerformance(input) {
+    try {
+        const { EntropyAnalyzer } = await import('@harness-engineering/core');
+        const typeFilter = input.type ?? 'all';
+        const analyzer = new EntropyAnalyzer({
+            rootDir: path.resolve(input.path),
+            analyze: {
+                complexity: typeFilter === 'all' || typeFilter === 'structural',
+                coupling: typeFilter === 'all' || typeFilter === 'coupling',
+                sizeBudget: typeFilter === 'all' || typeFilter === 'size',
+            },
+        });
+        // Load graph data if available
+        let graphOptions;
+        try {
+            const { loadGraphStore } = await import('../utils/graph-loader.js');
+            const store = await loadGraphStore(path.resolve(input.path));
+            if (store) {
+                const { GraphComplexityAdapter, GraphCouplingAdapter } = await import('@harness-engineering/graph');
+                const complexityAdapter = new GraphComplexityAdapter(store);
+                const couplingAdapter = new GraphCouplingAdapter(store);
+                graphOptions = {
+                    graphComplexityData: complexityAdapter.computeComplexityHotspots(),
+                    graphCouplingData: couplingAdapter.computeCouplingData(),
+                };
+            }
+        }
+        catch {
+            // Graph not available — proceed without
+        }
+        const result = await analyzer.analyze(graphOptions);
+        return resultToMcpResponse(result);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// --- get_perf_baselines ---
+export const getPerfBaselinesDefinition = {
+    name: 'get_perf_baselines',
+    description: 'Read current performance baselines from .harness/perf/baselines.json',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleGetPerfBaselines(input) {
+    try {
+        const { BaselineManager } = await import('@harness-engineering/core');
+        const manager = new BaselineManager(path.resolve(input.path));
+        const baselines = manager.load();
+        return resultToMcpResponse(Ok(baselines ?? { version: 1, updatedAt: '', updatedFrom: '', benchmarks: {} }));
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// --- update_perf_baselines ---
+export const updatePerfBaselinesDefinition = {
+    name: 'update_perf_baselines',
+    description: 'Update performance baselines from benchmark results. Run benchmarks first via CLI.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            commitHash: { type: 'string', description: 'Current commit hash for baseline tracking' },
+            results: {
+                type: 'array',
+                description: 'Array of benchmark results to save as baselines',
+                items: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        file: { type: 'string' },
+                        opsPerSec: { type: 'number' },
+                        meanMs: { type: 'number' },
+                        p99Ms: { type: 'number' },
+                        marginOfError: { type: 'number' },
+                    },
+                    required: ['name', 'file', 'opsPerSec', 'meanMs', 'p99Ms', 'marginOfError'],
+                },
+            },
+        },
+        required: ['path', 'commitHash', 'results'],
+    },
+};
+export async function handleUpdatePerfBaselines(input) {
+    try {
+        const { BaselineManager } = await import('@harness-engineering/core');
+        const manager = new BaselineManager(path.resolve(input.path));
+        manager.save(input.results, input.commitHash);
+        const updated = manager.load();
+        return resultToMcpResponse(Ok(updated));
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// --- get_critical_paths ---
+export const getCriticalPathsDefinition = {
+    name: 'get_critical_paths',
+    description: 'List performance-critical functions from @perf-critical annotations and graph inference',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleGetCriticalPaths(input) {
+    try {
+        const { CriticalPathResolver } = await import('@harness-engineering/core');
+        const resolver = new CriticalPathResolver(path.resolve(input.path));
+        const result = await resolver.resolve();
+        return resultToMcpResponse(Ok(result));
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,42 @@
+export declare const runSecurityScanDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            files: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            strict: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleRunSecurityScan(input: {
+    path: string;
+    files?: string[];
+    strict?: boolean;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/src/tools/security.js

@@ -0,0 +1,87 @@
+import * as path from 'path';
+// ============ run_security_scan ============
+export const runSecurityScanDefinition = {
+    name: 'run_security_scan',
+    description: 'Run the built-in security scanner on a project or specific files. Detects secrets, injection, XSS, weak crypto, and other vulnerabilities.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional list of specific files to scan. If omitted, scans all source files.',
+            },
+            strict: {
+                type: 'boolean',
+                description: 'Override strict mode — promotes all warnings to errors',
+            },
+        },
+        required: ['path'],
+    },
+};
+export async function handleRunSecurityScan(input) {
+    try {
+        const core = await import('@harness-engineering/core');
+        const projectRoot = path.resolve(input.path);
+        // Load config from project
+        let configData = {};
+        try {
+            const fs = await import('node:fs');
+            const configPath = path.join(projectRoot, 'harness.config.json');
+            if (fs.existsSync(configPath)) {
+                const raw = fs.readFileSync(configPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                configData = parsed.security ?? {};
+            }
+        }
+        catch {
+            // No config file — use defaults
+        }
+        // Apply overrides
+        if (input.strict !== undefined) {
+            configData.strict = input.strict;
+        }
+        const securityConfig = core.parseSecurityConfig(configData);
+        const scanner = new core.SecurityScanner(securityConfig);
+        scanner.configureForProject(projectRoot);
+        let filesToScan;
+        if (input.files && input.files.length > 0) {
+            filesToScan = input.files.map((f) => path.resolve(projectRoot, f));
+        }
+        else {
+            // Use core's glob utility to find source files
+            const { globFiles } = await import('../utils/glob-helper.js');
+            filesToScan = await globFiles(projectRoot, securityConfig.exclude);
+        }
+        const result = await scanner.scanFiles(filesToScan);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        ...result,
+                        summary: {
+                            errors: result.findings.filter((f) => f.severity === 'error')
+                                .length,
+                            warnings: result.findings.filter((f) => f.severity === 'warning').length,
+                            info: result.findings.filter((f) => f.severity === 'info')
+                                .length,
+                        },
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -33,6 +33,10 @@ export declare const manageStateDefinition: {
                 type: string;
                 description: string;
             };
+            stream: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
     };
@@ -45,6 +49,7 @@ export declare function handleManageState(input: {
     outcome?: string;
     description?: string;
     failureType?: string;
+    stream?: string;
 }): Promise<import("../utils/result-adapter.js").McpToolResponse>;
 export declare const manageHandoffDefinition: {
     name: string;
@@ -65,6 +70,10 @@ export declare const manageHandoffDefinition: {
                 type: string;
                 description: string;
             };
+            stream: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
     };
@@ -73,4 +82,22 @@ export declare function handleManageHandoff(input: {
     path: string;
     action: 'save' | 'load';
     handoff?: unknown;
+    stream?: string;
+}): Promise<import("../utils/result-adapter.js").McpToolResponse>;
+export declare const listStreamsDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleListStreams(input: {
+    path: string;
 }): Promise<import("../utils/result-adapter.js").McpToolResponse>;

package/dist/src/tools/state.js

@@ -19,6 +19,10 @@ export const manageStateDefinition = {
             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)' },
+            stream: {
+                type: 'string',
+                description: 'Stream name to target (auto-resolves from branch if omitted)',
+            },
         },
         required: ['path', 'action'],
     },
@@ -29,7 +33,7 @@ export async function handleManageState(input) {
         const projectPath = path.resolve(input.path);
         switch (input.action) {
             case 'show': {
-                const result = await loadState(projectPath);
+                const result = await loadState(projectPath, input.stream);
                 return resultToMcpResponse(result);
             }
             case 'learn': {
@@ -41,7 +45,7 @@ export async function handleManageState(input) {
                         isError: true,
                     };
                 }
-                const result = await appendLearning(projectPath, input.learning, input.skillName, input.outcome);
+                const result = await appendLearning(projectPath, input.learning, input.skillName, input.outcome, input.stream);
                 if (!result.ok)
                     return resultToMcpResponse(result);
                 return resultToMcpResponse(Ok({ recorded: true }));
@@ -66,19 +70,19 @@ export async function handleManageState(input) {
                         isError: true,
                     };
                 }
-                const result = await appendFailure(projectPath, input.description, input.skillName ?? 'unknown', input.failureType);
+                const result = await appendFailure(projectPath, input.description, input.skillName ?? 'unknown', input.failureType, input.stream);
                 if (!result.ok)
                     return resultToMcpResponse(result);
                 return resultToMcpResponse(Ok({ recorded: true }));
             }
             case 'archive': {
-                const result = await archiveFailures(projectPath);
+                const result = await archiveFailures(projectPath, input.stream);
                 if (!result.ok)
                     return resultToMcpResponse(result);
                 return resultToMcpResponse(Ok({ archived: true }));
             }
             case 'reset': {
-                const result = await saveState(projectPath, { ...DEFAULT_STATE });
+                const result = await saveState(projectPath, { ...DEFAULT_STATE }, input.stream);
                 if (!result.ok)
                     return resultToMcpResponse(result);
                 return resultToMcpResponse(Ok({ reset: true }));
@@ -121,6 +125,10 @@ export const manageHandoffDefinition = {
                 description: 'Action to perform',
             },
             handoff: { type: 'object', description: 'Handoff data to save (required for save)' },
+            stream: {
+                type: 'string',
+                description: 'Stream name to target (auto-resolves from branch if omitted)',
+            },
         },
         required: ['path', 'action'],
     },
@@ -139,11 +147,11 @@ export async function handleManageHandoff(input) {
                         isError: true,
                     };
                 }
-                const result = await saveHandoff(projectPath, input.handoff);
+                const result = await saveHandoff(projectPath, input.handoff, input.stream);
                 return resultToMcpResponse(result.ok ? Ok({ saved: true }) : result);
             }
             case 'load': {
-                const result = await loadHandoff(projectPath);
+                const result = await loadHandoff(projectPath, input.stream);
                 return resultToMcpResponse(result);
             }
             default: {
@@ -166,3 +174,40 @@ export async function handleManageHandoff(input) {
         };
     }
 }
+// ── list_streams ──────────────────────────────────────────────────────
+export const listStreamsDefinition = {
+    name: 'list_streams',
+    description: 'List known state streams with branch associations and last-active timestamps',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to project root' },
+        },
+        required: ['path'],
+    },
+};
+export async function handleListStreams(input) {
+    try {
+        const { listStreams, loadStreamIndex } = await import('@harness-engineering/core');
+        const projectPath = path.resolve(input.path);
+        const indexResult = await loadStreamIndex(projectPath);
+        const streamsResult = await listStreams(projectPath);
+        if (!streamsResult.ok)
+            return resultToMcpResponse(streamsResult);
+        return resultToMcpResponse(Ok({
+            activeStream: indexResult.ok ? indexResult.value.activeStream : null,
+            streams: streamsResult.value,
+        }));
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/src/utils/glob-helper.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Find source files recursively, skipping excluded paths.
+ * Zero external dependencies — uses only node:fs.
+ */
+export declare function globFiles(rootDir: string, exclude?: string[]): Promise<string[]>;

package/dist/src/utils/glob-helper.js

@@ -0,0 +1,71 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.go', '.py']);
+/**
+ * Convert a simple glob pattern to a regex for matching file paths.
+ * Handles: ** (any path), * (any segment), and literal strings.
+ */
+function globToRegex(pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex chars
+        .replace(/\*\*/g, '§§') // temp placeholder for **
+        .replace(/\*/g, '[^/]*') // * matches within segment
+        .replace(/§§/g, '.*'); // ** matches across segments
+    return new RegExp(escaped);
+}
+/**
+ * Check if a file path matches any of the exclude patterns.
+ */
+function isExcluded(relativePath, excludeRegexes) {
+    for (const regex of excludeRegexes) {
+        if (regex.test(relativePath))
+            return true;
+    }
+    return false;
+}
+// Directories that are always skipped for performance
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', '.next', '.nuxt', '__pycache__']);
+/**
+ * Find source files recursively, skipping excluded paths.
+ * Zero external dependencies — uses only node:fs.
+ */
+export async function globFiles(rootDir, exclude) {
+    const patterns = exclude ?? [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/*.test.ts',
+        '**/fixtures/**',
+    ];
+    const excludeRegexes = patterns.map(globToRegex);
+    const files = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // Permission denied or missing directory
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.relative(rootDir, fullPath);
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+                if (isExcluded(relativePath + '/', excludeRegexes))
+                    continue;
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (!SOURCE_EXTENSIONS.has(ext))
+                    continue;
+                if (isExcluded(relativePath, excludeRegexes))
+                    continue;
+                files.push(fullPath);
+            }
+        }
+    }
+    await walk(rootDir);
+    return files;
+}

package/package.json

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