@syke1/mcp-server 1.8.3 → 1.8.5

package/README.md

@@ -256,13 +256,14 @@ You (developer)          AI Agent            SYKE
 
 | | Free | Pro | Cortex |
 |---|------|-----|--------|
-| **Price** | $0 forever | $9/mo | $29/mo |
 | **Files** | 200 | Unlimited | Unlimited |
-| **Tools** | 3 (gate_build, check_safe, get_dependencies) | 7 (+ analyze_impact, hub_files, refresh, warnings) | 9 (+ ai_analyze, scan_project) |
+| **Tools** | 3 core | 7 (+ advanced algorithms) | 9 (+ AI analysis) |
 | **Projects** | 1 | Unlimited | Unlimited |
 | **AI Analysis** | — | — | Gemini / OpenAI / Claude (BYOK) |
 
-Annual plans: Pro $89/year, Cortex $249/year.
+**[See current pricing →](https://syke.cloud/#pricing)**
+
+Annual plans available. 14-day money-back guarantee.
 
 ## Founding 20 — Free Pro for Early Adopters
 
@@ -280,6 +281,12 @@ We're giving the **first 20 developers** full Pro access for **30 days** — no
 
 Spots are limited. Once they're gone, they're gone.
 
+## Source Code
+
+This repository contains the **Free tier source code** — the core dependency graph engine, language plugins, and 3 free MCP tools (`gate_build`, `check_safe`, `get_dependencies`).
+
+Pro and Cortex features (advanced algorithms, AI analysis, real-time monitoring, web dashboard) are included in the [npm package](https://www.npmjs.com/package/@syke1/mcp-server) as compiled code.
+
 ## License
 
 [Elastic License 2.0 (ELv2)](LICENSE)

package/dist/graph.d.ts

@@ -12,5 +12,13 @@ export interface DependencyGraph {
     scc?: SCCResult;
 }
 export declare function buildGraph(projectRoot: string, packageName?: string, maxFiles?: number): DependencyGraph;
+/**
+ * Async graph builder — reads all files in parallel batches for faster startup.
+ * Returns the graph + contentMap (reusable by FileCache to avoid re-reading).
+ */
+export declare function buildGraphAsync(projectRoot: string, packageName?: string, maxFiles?: number): Promise<{
+    graph: DependencyGraph;
+    contentMap: Map<string, string>;
+}>;
 export declare function getGraph(projectRoot: string, packageName?: string, maxFiles?: number): DependencyGraph;
 export declare function rebuildGraph(projectRoot: string, packageName?: string, maxFiles?: number): DependencyGraph;

package/dist/graph.js

@@ -34,9 +34,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildGraph = buildGraph;
+exports.buildGraphAsync = buildGraphAsync;
 exports.getGraph = getGraph;
 exports.rebuildGraph = rebuildGraph;
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
 const plugin_1 = require("./languages/plugin");
 const typescript_1 = require("./languages/typescript");
 const scc_1 = require("./graph/scc");
@@ -109,6 +111,104 @@ function buildGraph(projectRoot, packageName, maxFiles) {
     console.error(`[syke] Graph built (${languages.join("+")}): ${files.size} files, ${countEdges(forward)} edges, ${scc.components.length} SCCs (${cyclicCount} cyclic)`);
     return graph;
 }
+/**
+ * Async graph builder — reads all files in parallel batches for faster startup.
+ * Returns the graph + contentMap (reusable by FileCache to avoid re-reading).
+ */
+async function buildGraphAsync(projectRoot, packageName, maxFiles) {
+    const detectedPlugins = (0, plugin_1.detectLanguages)(projectRoot);
+    const languages = detectedPlugins.map(p => p.id);
+    const forward = new Map();
+    const reverse = new Map();
+    const files = new Set();
+    const allSourceDirs = [];
+    let totalDiscovered = 0;
+    let fileLimitHit = false;
+    // Phase 1: Discover files (sync — directory walking is I/O-light)
+    const pluginDirFiles = new Map();
+    for (const plugin of detectedPlugins) {
+        const dirs = plugin.getSourceDirs(projectRoot);
+        const dirMap = new Map();
+        for (const dir of dirs) {
+            if (!allSourceDirs.includes(dir))
+                allSourceDirs.push(dir);
+            const sourceFiles = plugin.discoverFiles(dir);
+            totalDiscovered += sourceFiles.length;
+            dirMap.set(dir, sourceFiles);
+            for (const f of sourceFiles) {
+                if (maxFiles && files.size >= maxFiles) {
+                    fileLimitHit = true;
+                    break;
+                }
+                files.add(f);
+                if (!forward.has(f))
+                    forward.set(f, []);
+            }
+        }
+        pluginDirFiles.set(plugin, dirMap);
+    }
+    if (fileLimitHit) {
+        console.error(`[syke] Free tier: loaded ${files.size}/${totalDiscovered} files (limit: ${maxFiles}). Upgrade to Pro for unlimited.`);
+    }
+    // Phase 2: Parallel file reading (biggest performance win)
+    const contentMap = new Map();
+    const filesToRead = [...files];
+    const BATCH_SIZE = 100;
+    for (let i = 0; i < filesToRead.length; i += BATCH_SIZE) {
+        const batch = filesToRead.slice(i, i + BATCH_SIZE);
+        const results = await Promise.all(batch.map(async (f) => {
+            try {
+                const content = await fs.readFile(f, "utf-8");
+                return [f, content];
+            }
+            catch {
+                return null;
+            }
+        }));
+        for (const r of results) {
+            if (r)
+                contentMap.set(r[0], r[1]);
+        }
+    }
+    // Phase 3: Parse imports using pre-read content (no I/O)
+    for (const [plugin, dirMap] of pluginDirFiles) {
+        for (const [dir, sourceFiles] of dirMap) {
+            for (const f of sourceFiles) {
+                if (!files.has(f))
+                    continue;
+                const content = contentMap.get(f);
+                const imports = plugin.parseImports(f, projectRoot, dir, content);
+                const validImports = [];
+                for (const imp of imports) {
+                    if (!files.has(imp))
+                        continue;
+                    validImports.push(imp);
+                    const rev = reverse.get(imp) || [];
+                    rev.push(f);
+                    reverse.set(imp, rev);
+                }
+                forward.set(f, validImports);
+            }
+        }
+    }
+    const sourceDir = allSourceDirs[0] || path.join(projectRoot, "src");
+    const graph = {
+        forward,
+        reverse,
+        files,
+        projectRoot,
+        languages,
+        sourceDirs: allSourceDirs,
+        sourceDir,
+    };
+    (0, memo_cache_1.resetMemoCache)();
+    const scc = (0, scc_1.computeSCC)(graph);
+    graph.scc = scc;
+    const cyclicCount = scc.condensed.nodes.filter(n => n.isCyclic).length;
+    cachedGraph = graph;
+    console.error(`[syke] Graph built (${languages.join("+")}): ${files.size} files, ${countEdges(forward)} edges, ${scc.components.length} SCCs (${cyclicCount} cyclic)`);
+    return { graph, contentMap };
+}
 function countEdges(forward) {
     let count = 0;
     for (const deps of forward.values()) {

package/dist/index.js

@@ -147,7 +147,7 @@ async function main() {
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-    const server = new index_js_1.Server({ name: "syke", version: "1.8.3" }, { capabilities: { tools: {} } });
+    const server = new index_js_1.Server({ name: "syke", version: "1.8.5" }, { capabilities: { tools: {} } });
     // List tools
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
         tools: [
@@ -628,7 +628,7 @@ async function main() {
         }
     });
     // Pre-warm the graph (skip if no project root — e.g. Smithery scan)
-    console.error(`[syke] Starting SYKE MCP Server v1.8.3`);
+    console.error(`[syke] Starting SYKE MCP Server v1.8.5`);
     console.error(`[syke] License: ${licenseStatus.plan.toUpperCase()} (${licenseStatus.source})`);
     if (licenseStatus.expiresAt) {
         console.error(`[syke] Expires: ${licenseStatus.expiresAt}`);
@@ -656,9 +656,9 @@ async function main() {
             });
             const data = await res.json();
             const latest = data["dist-tags"]?.latest;
-            if (latest && latest !== "1.8.3") {
+            if (latest && latest !== "1.8.5") {
                 const [lM, lm, lp] = latest.split(".").map(Number);
-                const [cM, cm, cp] = [1, 8, 1];
+                const [cM, cm, cp] = [1, 8, 5];
                 if (lM > cM || (lM === cM && lm > cm) || (lM === cM && lm === cm && lp > cp)) {
                     console.error(`[syke] Update available: v${latest}. Run: npx @syke1/mcp-server@latest`);
                 }
@@ -672,10 +672,10 @@ async function main() {
         console.error(`[syke] Project root: ${currentProjectRoot}`);
         console.error(`[syke] Detected languages: ${detectedLangs}`);
         console.error(`[syke] Package name: ${currentPackageName}`);
-        const graph = (0, graph_1.getGraph)(currentProjectRoot, currentPackageName, getMaxFiles());
-        // Initialize file cache (load ALL source files into memory)
+        const { graph, contentMap } = await (0, graph_1.buildGraphAsync)(currentProjectRoot, currentPackageName, getMaxFiles());
+        // Initialize file cache from pre-read content (no re-reading files)
         fileCache = new file_cache_1.FileCache(currentProjectRoot);
-        fileCache.initialize();
+        fileCache.initializeFromContentMap(contentMap);
         fileCache.setGraph(graph); // Enable incremental graph updates on file changes
         fileCache.startWatching();
     }
@@ -816,7 +816,7 @@ main().catch((err) => {
  * See: https://smithery.ai/docs/deploy#sandbox-server
  */
 function createSandboxServer() {
-    const sandboxServer = new index_js_1.Server({ name: "syke", version: "1.8.3" }, { capabilities: { tools: {} } });
+    const sandboxServer = new index_js_1.Server({ name: "syke", version: "1.8.5" }, { capabilities: { tools: {} } });
     sandboxServer.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
         tools: [
             {

package/dist/languages/cpp.js

@@ -73,13 +73,14 @@ exports.cppPlugin = {
     discoverFiles(dir) {
         return (0, plugin_1.discoverAllFiles)(dir, [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hxx"]);
     },
-    parseImports(filePath, projectRoot, sourceDir) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, "utf-8");
-        }
-        catch {
-            return [];
+    parseImports(filePath, projectRoot, sourceDir, content) {
+        if (!content) {
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return [];
+            }
         }
         const fileDir = path.dirname(filePath);
         const imports = [];

package/dist/languages/dart.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const plugin_1 = require("./plugin");
 const IMPORT_RE = /^import\s+['"](.+?)['"]/;
+const dartPackageNameCache = new Map();
 exports.dartPlugin = {
     id: "dart",
     name: "Dart",
@@ -63,25 +64,30 @@ exports.dartPlugin = {
     discoverFiles(dir) {
         return (0, plugin_1.discoverAllFiles)(dir, [".dart"]);
     },
-    parseImports(filePath, projectRoot, sourceDir) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, "utf-8");
-        }
-        catch {
-            return [];
+    parseImports(filePath, projectRoot, sourceDir, content) {
+        if (!content) {
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return [];
+            }
         }
         const libDir = sourceDir;
         const imports = [];
-        // Read package name for resolving package: imports
-        let packageName = path.basename(projectRoot);
-        try {
-            const pubspec = fs.readFileSync(path.join(projectRoot, "pubspec.yaml"), "utf-8");
-            const match = pubspec.match(/^name:\s*(\S+)/m);
-            if (match)
-                packageName = match[1];
+        // Read package name (cached per projectRoot)
+        let packageName = dartPackageNameCache.get(projectRoot);
+        if (!packageName) {
+            packageName = path.basename(projectRoot);
+            try {
+                const pubspec = fs.readFileSync(path.join(projectRoot, "pubspec.yaml"), "utf-8");
+                const match = pubspec.match(/^name:\s*(\S+)/m);
+                if (match)
+                    packageName = match[1];
+            }
+            catch { }
+            dartPackageNameCache.set(projectRoot, packageName);
         }
-        catch { }
         for (const line of content.split("\n")) {
             const trimmed = line.trim();
             if (trimmed.length > 0 &&

package/dist/languages/go.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const plugin_1 = require("./plugin");
 const IMPORT_LINE_RE = /^\s*"([^"]+)"/;
+const goModuleCache = new Map();
 exports.goPlugin = {
     id: "go",
     name: "Go",
@@ -62,23 +63,28 @@ exports.goPlugin = {
     discoverFiles(dir) {
         return (0, plugin_1.discoverAllFiles)(dir, [".go"]).filter(f => !f.endsWith("_test.go"));
     },
-    parseImports(filePath, projectRoot, _sourceDir) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, "utf-8");
-        }
-        catch {
-            return [];
+    parseImports(filePath, projectRoot, _sourceDir, content) {
+        if (!content) {
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return [];
+            }
         }
-        // Get module prefix from go.mod
-        let modulePrefix = "";
-        try {
-            const goMod = fs.readFileSync(path.join(projectRoot, "go.mod"), "utf-8");
-            const match = goMod.match(/^module\s+(\S+)/m);
-            if (match)
-                modulePrefix = match[1];
+        // Get module prefix from go.mod (cached per projectRoot)
+        let modulePrefix = goModuleCache.get(projectRoot);
+        if (modulePrefix === undefined) {
+            modulePrefix = "";
+            try {
+                const goMod = fs.readFileSync(path.join(projectRoot, "go.mod"), "utf-8");
+                const match = goMod.match(/^module\s+(\S+)/m);
+                if (match)
+                    modulePrefix = match[1];
+            }
+            catch { }
+            goModuleCache.set(projectRoot, modulePrefix);
         }
-        catch { }
         const imports = [];
         // Parse import block or single imports
         const importBlockMatch = content.match(/import\s*\(([\s\S]*?)\)/);

package/dist/languages/java.js

@@ -73,13 +73,14 @@ exports.javaPlugin = {
     discoverFiles(dir) {
         return (0, plugin_1.discoverAllFiles)(dir, [".java"]);
     },
-    parseImports(filePath, _projectRoot, sourceDir) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, "utf-8");
-        }
-        catch {
-            return [];
+    parseImports(filePath, _projectRoot, sourceDir, content) {
+        if (!content) {
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return [];
+            }
         }
         const imports = [];
         for (const line of content.split("\n")) {

package/dist/languages/plugin.d.ts

@@ -7,7 +7,7 @@ export interface LanguagePlugin {
     getSourceDirs(root: string): string[];
     getPackageName(root: string): string;
     discoverFiles(dir: string): string[];
-    parseImports(filePath: string, projectRoot: string, sourceDir: string): string[];
+    parseImports(filePath: string, projectRoot: string, sourceDir: string, content?: string): string[];
     classifyLayer?(relPath: string): string | null;
 }
 export declare function registerPlugin(plugin: LanguagePlugin): void;
@@ -15,6 +15,7 @@ export declare function getPlugins(): LanguagePlugin[];
 export declare function getPluginById(id: string): LanguagePlugin | undefined;
 export declare function getPluginForFile(filePath: string): LanguagePlugin | undefined;
 export declare function detectLanguages(root: string): LanguagePlugin[];
+export declare function clearDetectCache(): void;
 export declare function detectProjectRoot(startDir?: string): string;
 export declare function detectPackageName(root: string, detectedPlugins: LanguagePlugin[]): string;
 export declare function discoverAllFiles(rootDir: string, extensions: string[], extraSkipDirs?: string[]): string[];

package/dist/languages/plugin.js

@@ -38,6 +38,7 @@ exports.getPlugins = getPlugins;
 exports.getPluginById = getPluginById;
 exports.getPluginForFile = getPluginForFile;
 exports.detectLanguages = detectLanguages;
+exports.clearDetectCache = clearDetectCache;
 exports.detectProjectRoot = detectProjectRoot;
 exports.detectPackageName = detectPackageName;
 exports.discoverAllFiles = discoverAllFiles;
@@ -60,9 +61,17 @@ function getPluginForFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return plugins.find(p => p.extensions.includes(ext));
 }
-// ── Auto-detect ──
+// ── Auto-detect (cached) ──
+let detectCache = null;
 function detectLanguages(root) {
-    return plugins.filter(p => p.detectProject(root));
+    if (detectCache && detectCache.root === root)
+        return detectCache.result;
+    const result = plugins.filter(p => p.detectProject(root));
+    detectCache = { root, result };
+    return result;
+}
+function clearDetectCache() {
+    detectCache = null;
 }
 function detectProjectRoot(startDir) {
     let dir = startDir || process.cwd();
@@ -156,6 +165,29 @@ function hasManifestFile(root, manifests) {
     catch { }
     return false;
 }
+/**
+ * Quick check: does a directory (recursively) contain any file with matching extensions?
+ * Short-circuits on the first match — much faster than collecting all files.
+ */
+function hasAnySourceFile(dir, extensions, skipSet) {
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
+                return true;
+            }
+        }
+        // Check subdirectories only if no file found at this level
+        for (const entry of entries) {
+            if (entry.isDirectory() && !skipSet.has(entry.name) && !entry.name.startsWith(".")) {
+                if (hasAnySourceFile(path.join(dir, entry.name), extensions, skipSet))
+                    return true;
+            }
+        }
+    }
+    catch { }
+    return false;
+}
 /**
  * Find first-level subdirectories (and optionally root) that contain files with given extensions.
  * Skips hidden dirs and common non-source dirs (.venv, node_modules, etc.).
@@ -168,14 +200,14 @@ function findSourceDirsWithFiles(root, extensions) {
         if (entries.some(e => e.isFile() && extensions.some(ext => e.name.endsWith(ext)))) {
             dirs.push(root);
         }
-        // Check first-level subdirectories
+        // Check first-level subdirectories (quick existence check, not full walk)
         for (const entry of entries) {
             if (!entry.isDirectory())
                 continue;
             if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
                 continue;
             const subdir = path.join(root, entry.name);
-            if (discoverAllFiles(subdir, extensions).length > 0) {
+            if (hasAnySourceFile(subdir, extensions, SKIP_DIRS)) {
                 dirs.push(subdir);
             }
         }

package/dist/languages/python.js

@@ -64,13 +64,14 @@ exports.pythonPlugin = {
     discoverFiles(dir) {
         return (0, plugin_1.discoverAllFiles)(dir, [".py"]);
     },
-    parseImports(filePath, projectRoot, sourceDir) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, "utf-8");
-        }
-        catch {
-            return [];
+    parseImports(filePath, projectRoot, sourceDir, content) {
+        if (!content) {
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return [];
+            }
         }
         const imports = [];
         for (const line of content.split("\n")) {

package/dist/languages/ruby.js

@@ -69,13 +69,14 @@ exports.rubyPlugin = {
     discoverFiles(dir) {
         return (0, plugin_1.discoverAllFiles)(dir, [".rb"]);
     },
-    parseImports(filePath, _projectRoot, _sourceDir) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, "utf-8");
-        }
-        catch {
-            return [];
+    parseImports(filePath, _projectRoot, _sourceDir, content) {
+        if (!content) {
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return [];
+            }
         }
         const fileDir = path.dirname(filePath);
         const imports = [];

package/dist/languages/rust.js

@@ -64,13 +64,14 @@ exports.rustPlugin = {
     discoverFiles(dir) {
         return (0, plugin_1.discoverAllFiles)(dir, [".rs"]);
     },
-    parseImports(filePath, _projectRoot, sourceDir) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, "utf-8");
-        }
-        catch {
-            return [];
+    parseImports(filePath, _projectRoot, sourceDir, content) {
+        if (!content) {
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return [];
+            }
         }
         const imports = [];
         for (const line of content.split("\n")) {

package/dist/languages/typescript.js

@@ -142,18 +142,26 @@ exports.typescriptPlugin = {
     discoverFiles(dir) {
         return (0, plugin_1.discoverAllFiles)(dir, [".ts", ".tsx", ".js", ".jsx"]).filter(f => !f.endsWith(".d.ts"));
     },
-    parseImports(filePath, projectRoot, _sourceDir) {
-        let content;
-        try {
-            content = fs.readFileSync(filePath, "utf-8");
-        }
-        catch {
-            return [];
+    parseImports(filePath, projectRoot, _sourceDir, content) {
+        if (!content) {
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return [];
+            }
         }
         const fileDir = path.dirname(filePath);
         const imports = [];
         for (const line of content.split("\n")) {
             const trimmed = line.trim();
+            // Quick prefix guard — skip lines that can't be imports
+            if (trimmed.length === 0 || !(trimmed.charCodeAt(0) === 105 /* i */ ||
+                trimmed.charCodeAt(0) === 101 /* e */ ||
+                trimmed.charCodeAt(0) === 99 /* c */ ||
+                trimmed.charCodeAt(0) === 108 /* l */ ||
+                trimmed.charCodeAt(0) === 118 /* v */))
+                continue;
             let importPath = null;
             const match = trimmed.match(TS_IMPORT_RE) || trimmed.match(TS_SIDE_EFFECT_RE) || trimmed.match(JS_REQUIRE_RE);
             if (match)

package/dist/watcher/file-cache.d.ts

@@ -44,6 +44,14 @@ export declare class FileCache extends EventEmitter {
         fileCount: number;
         totalLines: number;
     };
+    /**
+     * Initialize from a pre-read content map (avoids re-reading files after graph build).
+     * Used when buildGraphAsync already read all files into memory.
+     */
+    initializeFromContentMap(contentMap: Map<string, string>): {
+        fileCount: number;
+        totalLines: number;
+    };
     /** Start watching source directories for changes */
     startWatching(): void;
     private isWatchedFile;

package/dist/watcher/file-cache.js

@@ -106,6 +106,19 @@ class FileCache extends events_1.EventEmitter {
         console.error(`[syke:cache] Loaded ${this.cache.size} files (${totalLines.toLocaleString()} lines) into memory`);
         return { fileCount: this.cache.size, totalLines };
     }
+    /**
+     * Initialize from a pre-read content map (avoids re-reading files after graph build).
+     * Used when buildGraphAsync already read all files into memory.
+     */
+    initializeFromContentMap(contentMap) {
+        let totalLines = 0;
+        for (const [filePath, content] of contentMap) {
+            this.cache.set(path.normalize(filePath), content);
+            totalLines += content.split("\n").length;
+        }
+        console.error(`[syke:cache] Loaded ${this.cache.size} files (${totalLines.toLocaleString()} lines) from graph build (no re-read)`);
+        return { fileCount: this.cache.size, totalLines };
+    }
     /** Start watching source directories for changes */
     startWatching() {
         if (this.watcher)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syke1/mcp-server",
-  "version": "1.8.3",
+  "version": "1.8.5",
   "mcpName": "io.github.khalomsky/syke",
   "description": "AI code impact analysis MCP server — dependency graphs, cascade detection, and a mandatory build gate for AI coding agents",
   "main": "dist/index.js",