@syke1/mcp-server 1.0.0

package/README.md

@@ -0,0 +1,112 @@
+# SYKE — Your Codebase Has a Pulse
+
+**AI code impact analysis MCP server.** SYKE monitors every file your AI touches, maps dependency graphs, detects cascading breakage, and gates builds before damage spreads.
+
+Works with **Claude Code**, **Cursor**, **Windsurf**, and any MCP-compatible AI coding agent.
+
+## Quick Start
+
+### 1. Add to your MCP config
+
+**Claude Code** (`~/.claude/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "syke": {
+      "command": "npx",
+      "args": ["@syke1/mcp-server@latest"],
+      "env": {
+        "SYKE_LICENSE_KEY": "your-key-here"
+      }
+    }
+  }
+}
+```
+
+**Cursor** (`.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "syke": {
+      "command": "npx",
+      "args": ["@syke1/mcp-server@latest"],
+      "env": {
+        "SYKE_LICENSE_KEY": "your-key-here"
+      }
+    }
+  }
+}
+```
+
+### 2. Restart your AI agent
+
+SYKE auto-detects your project language and builds the dependency graph on startup.
+
+### 3. Open the dashboard
+
+A web dashboard opens automatically at `http://localhost:3333` showing your live dependency graph.
+
+## Features
+
+### 8 MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `gate_build` | **Mandatory pre-build check.** Returns PASS/WARN/FAIL verdict before any build or deploy. |
+| `analyze_impact` | Shows direct and transitive dependents when a file is modified. |
+| `check_safe` | Quick one-line safety verdict: HIGH/MEDIUM/LOW/NONE risk. |
+| `get_dependencies` | Lists internal imports (forward dependencies) of a file. |
+| `get_hub_files` | Ranks files by how many other files depend on them. |
+| `refresh_graph` | Re-scans all source files and rebuilds the dependency graph. |
+| `ai_analyze` | **Pro** — Gemini AI semantic analysis of a file and its dependents. |
+| `check_warnings` | Real-time monitoring alerts for file changes that may break dependents. |
+
+### Language Support
+
+Auto-detected, zero-config: **Dart/Flutter**, **TypeScript/JavaScript**, **Python**, **Go**, **Rust**, **Java**, **C++**, **Ruby**.
+
+### Web Dashboard
+
+Live dependency graph visualization at `localhost:3333` with:
+- Interactive node graph (click any file to see its connections)
+- Real-time cascade monitoring
+- Risk level indicators
+
+## Pricing
+
+### Free — $0 forever
+- 1 project, 50 files
+- All 8 core tools
+- Hub & cycle detection
+- 8 language support
+
+### Pro — $12/mo (or $99/yr, save 31%)
+- Unlimited projects & files
+- Real-time cascade monitoring
+- AI semantic analysis (BYOK Gemini key)
+- Priority support
+
+Get your license key at [syke.cloud/dashboard](https://syke.cloud/dashboard/).
+
+## Configuration
+
+| Environment Variable | Description | Required |
+|---------------------|-------------|----------|
+| `SYKE_LICENSE_KEY` | Pro license key from dashboard | No (Free tier works without) |
+| `GEMINI_KEY` | Google Gemini API key for `ai_analyze` | Pro only |
+| `SYKE_WEB_PORT` | Dashboard port (default: 3333) | No |
+| `SYKE_NO_BROWSER` | Set to `1` to disable auto-open browser | No |
+| `SYKE_currentProjectRoot` | Override auto-detected project root | No |
+
+## How It Works
+
+1. **On startup**, SYKE scans your source directory and builds a complete dependency graph using static import analysis.
+2. **When your AI modifies a file**, call `gate_build` to check if the change is safe before building.
+3. **If dependencies break**, SYKE detects cascading failures and blocks the build with a `FAIL` verdict.
+4. **The dashboard** shows a real-time visualization of your dependency graph with risk indicators.
+
+## License
+
+MIT

package/dist/ai/analyzer.d.ts

@@ -0,0 +1,3 @@
+import { DependencyGraph } from "../graph";
+import { ImpactResult } from "../tools/analyze-impact";
+export declare function analyzeWithAI(filePath: string, impactResult: ImpactResult, graph: DependencyGraph): Promise<string>;

package/dist/ai/analyzer.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeWithAI = analyzeWithAI;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generative_ai_1 = require("@google/generative-ai");
+let genAI = null;
+function getGenAI() {
+    if (!genAI) {
+        const key = process.env.GEMINI_KEY;
+        if (!key) {
+            throw new Error("GEMINI_KEY environment variable is required for AI analysis");
+        }
+        genAI = new generative_ai_1.GoogleGenerativeAI(key);
+    }
+    return genAI;
+}
+function readFileContent(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function buildSystemPrompt(languages) {
+    const langNames = languages.length > 0 ? languages.join("/") : "source";
+    return `당신은 ${langNames} 코드 영향도 분석 전문가입니다.
+주어진 파일의 소스코드와 이 파일에 의존하는 파일들의 코드를 분석하여,
+이 파일을 수정할 때 어떤 부분이 깨질 수 있는지 구체적으로 설명해주세요.
+
+분석 포맷:
+## 핵심 역할
+이 파일이 프로젝트에서 하는 역할을 한 문장으로 설명
+
+## 수정 시 위험 포인트
+수정 시 깨질 수 있는 구체적인 부분들 (함수명, 클래스명 포함)
+
+## 영향받는 파일 분석
+의존 파일들이 이 파일의 어떤 부분을 사용하는지 구체적으로
+
+## 안전한 수정 가이드
+이 파일을 수정할 때 주의할 점과 추천 접근법
+
+한국어로 답변하세요. 간결하되 구체적으로 작성하세요.`;
+}
+async function analyzeWithAI(filePath, impactResult, graph) {
+    const ai = getGenAI();
+    const model = ai.getGenerativeModel({ model: "gemini-2.5-flash" });
+    const targetSource = readFileContent(filePath);
+    if (!targetSource) {
+        return `파일을 읽을 수 없습니다: ${filePath}`;
+    }
+    const codeBlockLang = graph.languages[0] || "text";
+    const directDeps = (graph.reverse.get(path.normalize(filePath)) || []).slice(0, 5);
+    const dependentSources = [];
+    for (const dep of directDeps) {
+        const source = readFileContent(dep);
+        if (source) {
+            const rel = path.relative(graph.sourceDir, dep).replace(/\\/g, "/");
+            dependentSources.push(`### ${rel}\n\`\`\`${codeBlockLang}\n${source}\n\`\`\``);
+        }
+    }
+    const userPrompt = `## 분석 대상 파일: ${impactResult.relativePath}
+- 위험도: ${impactResult.riskLevel}
+- 직접 의존 파일 수: ${impactResult.directDependents.length}
+- 전이적 의존 파일 수: ${impactResult.transitiveDependents.length}
+- 총 영향 파일 수: ${impactResult.totalImpacted}
+
+### 대상 파일 소스코드
+\`\`\`${codeBlockLang}
+${targetSource}
+\`\`\`
+
+${dependentSources.length > 0 ? `### 이 파일에 의존하는 파일들 (상위 ${dependentSources.length}개)\n${dependentSources.join("\n\n")}` : "이 파일에 의존하는 내부 파일이 없습니다."}`;
+    try {
+        const systemPrompt = buildSystemPrompt(graph.languages);
+        const result = await model.generateContent({
+            contents: [{ role: "user", parts: [{ text: userPrompt }] }],
+            systemInstruction: { role: "model", parts: [{ text: systemPrompt }] },
+        });
+        return result.response.text();
+    }
+    catch (err) {
+        return `AI 분석 중 오류 발생: ${err.message || err}`;
+    }
+}

package/dist/ai/realtime-analyzer.d.ts

@@ -0,0 +1,20 @@
+import { FileChange } from "../watcher/file-cache";
+import { DependencyGraph } from "../graph";
+export interface RealtimeAnalysis {
+    file: string;
+    changeType: FileChange["type"];
+    timestamp: number;
+    riskLevel: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "SAFE";
+    summary: string;
+    brokenImports: string[];
+    sideEffects: string[];
+    warnings: string[];
+    suggestion: string;
+    affectedNodes: string[];
+    analysisMs: number;
+}
+/**
+ * Analyze a file change in real-time using Gemini.
+ * Receives the diff + connected files context from memory cache.
+ */
+export declare function analyzeChangeRealtime(change: FileChange, graph: DependencyGraph, getFileContent: (relPath: string) => string | null): Promise<RealtimeAnalysis>;

package/dist/ai/realtime-analyzer.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeChangeRealtime = analyzeChangeRealtime;
+const generative_ai_1 = require("@google/generative-ai");
+const analyze_impact_1 = require("../tools/analyze-impact");
+const path = __importStar(require("path"));
+const REALTIME_SYSTEM_PROMPT = `당신은 20년 경력의 풀스택 아키텍트이자, 코드 영향도 감시 AI입니다.
+역할: 파일이 수정/추가/삭제될 때, 빌드 전에 잠재적 오류와 연쇄 영향을 감지합니다.
+
+분석 원칙:
+1. import/export 깨짐: 삭제/이름변경된 클래스/함수/변수가 다른 파일에서 참조되는지 확인
+2. 타입 불일치: 매개변수 타입, 반환 타입 변경이 호출부와 맞는지 확인
+3. 상태 관리 연쇄: Provider/Notifier 변경이 UI와 비즈니스 로직에 미치는 영향
+4. 라우팅 영향: GoRouter 경로/매개변수 변경이 네비게이션에 미치는 영향
+5. 누락된 초기화: 새로 추가된 Provider가 적절히 등록되었는지
+
+응답 형식 (반드시 JSON):
+{
+  "riskLevel": "CRITICAL|HIGH|MEDIUM|LOW|SAFE",
+  "summary": "한 줄 요약 (한국어)",
+  "brokenImports": ["깨질 수 있는 import 목록"],
+  "sideEffects": ["예상되는 부작용 목록"],
+  "warnings": ["주의사항 목록"],
+  "suggestion": "추천 조치 (한국어)"
+}
+
+CRITICAL: 빌드 실패 확실
+HIGH: 런타임 오류 가능
+MEDIUM: 기능 동작 변경 가능
+LOW: 사소한 영향
+SAFE: 안전한 변경
+
+JSON만 응답하세요. 설명 텍스트 없이 순수 JSON만.`;
+let genAI = null;
+function getGenAI() {
+    if (!genAI) {
+        const key = process.env.GEMINI_KEY;
+        if (!key)
+            throw new Error("GEMINI_KEY required");
+        genAI = new generative_ai_1.GoogleGenerativeAI(key);
+    }
+    return genAI;
+}
+/**
+ * Analyze a file change in real-time using Gemini.
+ * Receives the diff + connected files context from memory cache.
+ */
+async function analyzeChangeRealtime(change, graph, getFileContent) {
+    const start = Date.now();
+    const relPath = change.relativePath;
+    const codeBlockLang = graph.languages[0] || "text";
+    // Get impacted files from graph
+    const absPath = path.normalize(path.join(graph.sourceDir, relPath));
+    let affectedNodes = [];
+    if (graph.files.has(absPath)) {
+        const impact = (0, analyze_impact_1.analyzeImpact)(absPath, graph);
+        affectedNodes = [...impact.directDependents, ...impact.transitiveDependents];
+    }
+    // Build context: changed file + top 5 connected files' content
+    const connectedFiles = [];
+    const revDeps = graph.reverse.get(absPath) || [];
+    const fwdDeps = graph.forward.get(absPath) || [];
+    const connected = [...new Set([...revDeps, ...fwdDeps])].slice(0, 5);
+    for (const dep of connected) {
+        const depRel = path.relative(graph.sourceDir, dep).replace(/\\/g, "/");
+        const content = getFileContent(depRel);
+        if (content) {
+            const truncated = content.split("\n").slice(0, 60).join("\n");
+            connectedFiles.push(`### ${depRel}\n\`\`\`${codeBlockLang}\n${truncated}\n\`\`\``);
+        }
+    }
+    // Build diff summary
+    let diffSummary = "";
+    if (change.type === "deleted") {
+        diffSummary = `파일이 삭제됨. 이전 내용:\n\`\`\`${codeBlockLang}\n${(change.oldContent || "").split("\n").slice(0, 40).join("\n")}\n\`\`\``;
+    }
+    else if (change.type === "added") {
+        diffSummary = `새 파일 추가됨:\n\`\`\`${codeBlockLang}\n${(change.newContent || "").split("\n").slice(0, 60).join("\n")}\n\`\`\``;
+    }
+    else {
+        const diffLines = change.diff.slice(0, 30).map(d => {
+            if (d.type === "added")
+                return `+ L${d.line}: ${d.new}`;
+            if (d.type === "removed")
+                return `- L${d.line}: ${d.old}`;
+            return `~ L${d.line}: ${d.old} → ${d.new}`;
+        });
+        diffSummary = `변경된 라인 (${change.diff.length}개 중 상위 30개):\n\`\`\`\n${diffLines.join("\n")}\n\`\`\``;
+        if (change.newContent) {
+            diffSummary += `\n\n전체 수정 후 파일:\n\`\`\`${codeBlockLang}\n${change.newContent.split("\n").slice(0, 80).join("\n")}\n\`\`\``;
+        }
+    }
+    const userPrompt = `## 파일 변경 감지: ${relPath}
+변경 유형: ${change.type.toUpperCase()}
+프로젝트 언어: ${graph.languages.join(", ") || "unknown"}
+영향받는 파일 수: ${affectedNodes.length}
+
+${diffSummary}
+
+${connectedFiles.length > 0 ? `## 연결된 파일들 (${connectedFiles.length}개)\n${connectedFiles.join("\n\n")}` : "연결된 파일 없음"}
+
+이 변경이 프로젝트에 미치는 영향을 분석하세요.`;
+    try {
+        const ai = getGenAI();
+        const model = ai.getGenerativeModel({ model: "gemini-2.5-flash" });
+        const result = await model.generateContent({
+            contents: [{ role: "user", parts: [{ text: userPrompt }] }],
+            systemInstruction: { role: "model", parts: [{ text: REALTIME_SYSTEM_PROMPT }] },
+        });
+        const text = result.response.text();
+        let jsonStr = text;
+        const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (jsonMatch)
+            jsonStr = jsonMatch[1];
+        jsonStr = jsonStr.trim();
+        const parsed = JSON.parse(jsonStr);
+        const analysisMs = Date.now() - start;
+        return {
+            file: relPath,
+            changeType: change.type,
+            timestamp: change.timestamp,
+            riskLevel: parsed.riskLevel || "LOW",
+            summary: parsed.summary || "분석 완료",
+            brokenImports: parsed.brokenImports || [],
+            sideEffects: parsed.sideEffects || [],
+            warnings: parsed.warnings || [],
+            suggestion: parsed.suggestion || "",
+            affectedNodes,
+            analysisMs,
+        };
+    }
+    catch (err) {
+        const analysisMs = Date.now() - start;
+        console.error(`[syke:ai] Analysis error for ${relPath}: ${err.message}`);
+        return {
+            file: relPath,
+            changeType: change.type,
+            timestamp: change.timestamp,
+            riskLevel: affectedNodes.length >= 10 ? "HIGH" : affectedNodes.length >= 5 ? "MEDIUM" : "LOW",
+            summary: `AI 분석 실패 — 그래프 기반 분석: ${affectedNodes.length}개 파일 영향`,
+            brokenImports: [],
+            sideEffects: [],
+            warnings: [`AI 분석 오류: ${err.message}`],
+            suggestion: "수동 확인 필요",
+            affectedNodes,
+            analysisMs,
+        };
+    }
+}

package/dist/graph.d.ts

@@ -0,0 +1,13 @@
+export interface DependencyGraph {
+    forward: Map<string, string[]>;
+    reverse: Map<string, string[]>;
+    files: Set<string>;
+    projectRoot: string;
+    languages: string[];
+    sourceDirs: string[];
+    /** backward compat: first source directory */
+    sourceDir: string;
+}
+export declare function buildGraph(projectRoot: string, packageName?: string): DependencyGraph;
+export declare function getGraph(projectRoot: string, packageName?: string): DependencyGraph;
+export declare function refreshGraph(projectRoot: string, packageName?: string): DependencyGraph;

package/dist/graph.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraph = buildGraph;
+exports.getGraph = getGraph;
+exports.refreshGraph = refreshGraph;
+const path = __importStar(require("path"));
+const plugin_1 = require("./languages/plugin");
+let cachedGraph = null;
+function buildGraph(projectRoot, packageName) {
+    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 = [];
+    for (const plugin of detectedPlugins) {
+        const dirs = plugin.getSourceDirs(projectRoot);
+        for (const dir of dirs) {
+            if (!allSourceDirs.includes(dir))
+                allSourceDirs.push(dir);
+            const sourceFiles = plugin.discoverFiles(dir);
+            for (const f of sourceFiles) {
+                files.add(f);
+                if (!forward.has(f))
+                    forward.set(f, []);
+            }
+            for (const f of sourceFiles) {
+                const imports = plugin.parseImports(f, projectRoot, dir);
+                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,
+    };
+    cachedGraph = graph;
+    console.error(`[syke] Graph built (${languages.join("+")}): ${files.size} files, ${countEdges(forward)} edges`);
+    return graph;
+}
+function countEdges(forward) {
+    let count = 0;
+    for (const deps of forward.values()) {
+        count += deps.length;
+    }
+    return count;
+}
+function getGraph(projectRoot, packageName) {
+    if (cachedGraph && cachedGraph.projectRoot === projectRoot) {
+        return cachedGraph;
+    }
+    return buildGraph(projectRoot, packageName);
+}
+function refreshGraph(projectRoot, packageName) {
+    cachedGraph = null;
+    return buildGraph(projectRoot, packageName);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};