@syke1/mcp-server 1.4.16 → 1.4.18

package/dist/ai/realtime-analyzer.js

@@ -35,9 +35,42 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeChangeRealtime = analyzeChangeRealtime;
 const analyze_impact_1 = require("../tools/analyze-impact");
+const crypto = __importStar(require("crypto"));
 const path = __importStar(require("path"));
 const provider_1 = require("./provider");
 const context_extractor_1 = require("./context-extractor");
+const analysisCache = new Map();
+const MAX_CACHE_SIZE = 100;
+function computeContentHash(content, diff) {
+    return crypto.createHash("md5").update((content || "") + "\n---\n" + diff).digest("hex");
+}
+function evictOldestCacheEntry() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of analysisCache) {
+        if (entry.insertedAt < oldestTime) {
+            oldestTime = entry.insertedAt;
+            oldestKey = key;
+        }
+    }
+    if (oldestKey)
+        analysisCache.delete(oldestKey);
+}
+// ── Rate limiter: max 10 AI calls per minute (sliding window) ──
+const RATE_LIMIT_MAX = 10;
+const RATE_LIMIT_WINDOW_MS = 60000;
+const callTimestamps = [];
+function isRateLimited() {
+    const now = Date.now();
+    // Remove timestamps outside the window
+    while (callTimestamps.length > 0 && callTimestamps[0] <= now - RATE_LIMIT_WINDOW_MS) {
+        callTimestamps.shift();
+    }
+    return callTimestamps.length >= RATE_LIMIT_MAX;
+}
+function recordCall() {
+    callTimestamps.push(Date.now());
+}
 function getSystemPrompt() {
     return `You are a senior full-stack architect and code impact monitoring AI with 20 years of experience.
 Role: Detect potential errors and cascading impacts before build when files are modified/added/deleted.
@@ -79,7 +112,7 @@ async function analyzeChangeRealtime(change, graph, getFileContent) {
     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);
+        const impact = await (0, analyze_impact_1.analyzeImpact)(absPath, graph);
         affectedNodes = [...impact.directDependents, ...impact.transitiveDependents];
     }
     // Build context: changed file + top 5 connected files' smart context
@@ -147,14 +180,41 @@ ${diffSummary}
 ${connectedFiles.length > 0 ? `## Connected files (${connectedFiles.length})\n${connectedFiles.join("\n\n")}` : "No connected files"}
 
 Analyze the impact of this change on the project.`;
+    // ── Hash cache check: skip AI if content+diff unchanged ──
+    const diffStr = change.diff.map(d => `${d.type}:${d.line}:${d.old || ""}:${d.new || ""}`).join("|");
+    const contentHash = computeContentHash(change.newContent, diffStr);
+    const cached = analysisCache.get(relPath);
+    if (cached && cached.hash === contentHash) {
+        console.error(`[syke:ai] Cache hit for ${relPath} — skipping AI call`);
+        return { ...cached.result, timestamp: change.timestamp, analysisMs: 0 };
+    }
+    // ── Rate limit check ──
+    if (isRateLimited()) {
+        const analysisMs = Date.now() - start;
+        console.error(`[syke:ai] Rate limit reached (${RATE_LIMIT_MAX}/min) — skipping AI for ${relPath}`);
+        return {
+            file: relPath,
+            changeType: change.type,
+            timestamp: change.timestamp,
+            riskLevel: affectedNodes.length >= 10 ? "HIGH" : affectedNodes.length >= 5 ? "MEDIUM" : "LOW",
+            summary: `Rate limited — graph-based analysis: ${affectedNodes.length} files impacted`,
+            brokenImports: [],
+            sideEffects: [],
+            warnings: ["AI analysis skipped: rate limit (10 calls/min)"],
+            suggestion: "Wait a moment for AI analysis to resume",
+            affectedNodes,
+            analysisMs,
+        };
+    }
     try {
         const provider = (0, provider_1.getAIProvider)();
         if (!provider) {
             throw new Error("No AI provider available (set GEMINI_KEY, OPENAI_KEY, or ANTHROPIC_KEY)");
         }
+        recordCall();
         const parsed = await provider.analyzeJSON(getSystemPrompt(), userPrompt);
         const analysisMs = Date.now() - start;
-        return {
+        const result = {
             file: relPath,
             changeType: change.type,
             timestamp: change.timestamp,
@@ -167,6 +227,11 @@ Analyze the impact of this change on the project.`;
             affectedNodes,
             analysisMs,
         };
+        // Store in cache
+        if (analysisCache.size >= MAX_CACHE_SIZE)
+            evictOldestCacheEntry();
+        analysisCache.set(relPath, { hash: contentHash, result, insertedAt: Date.now() });
+        return result;
     }
     catch (err) {
         const analysisMs = Date.now() - start;

package/dist/git/change-coupling.d.ts

@@ -0,0 +1,41 @@
+export interface ChangeCoupling {
+    file1: string;
+    file2: string;
+    coChangeCount: number;
+    file1Changes: number;
+    file2Changes: number;
+    confidence: number;
+    support: number;
+}
+export interface CouplingResult {
+    couplings: ChangeCoupling[];
+    fileCouplings: Map<string, ChangeCoupling[]>;
+    totalCommitsAnalyzed: number;
+    analyzedAt: number;
+}
+export interface CouplingOptions {
+    maxCommits?: number;
+    minSupport?: number;
+    minConfidence?: number;
+    maxFilesPerCommit?: number;
+}
+/**
+ * Invalidate the coupling cache. Call this when the graph is refreshed
+ * or when git history may have changed.
+ */
+export declare function invalidateCouplingCache(): void;
+/**
+ * Mine git history to find files that frequently co-change.
+ *
+ * Runs `git log --name-only` and analyzes pairwise file combinations
+ * within each commit to identify hidden logical dependencies.
+ */
+export declare function mineGitHistory(projectRoot: string, options?: CouplingOptions): Promise<CouplingResult>;
+/**
+ * Get all significant couplings for a given file path.
+ * Returns an empty array if no couplings are found.
+ *
+ * The filePath should be a relative path matching git log output format
+ * (forward slashes, relative to project root).
+ */
+export declare function getCoupledFiles(filePath: string, result: CouplingResult): ChangeCoupling[];

package/dist/git/change-coupling.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidateCouplingCache = invalidateCouplingCache;
+exports.mineGitHistory = mineGitHistory;
+exports.getCoupledFiles = getCoupledFiles;
+const child_process_1 = require("child_process");
+// ── Defaults ──
+const DEFAULT_MAX_COMMITS = 500;
+const DEFAULT_MIN_SUPPORT = 3;
+const DEFAULT_MIN_CONFIDENCE = 0.3;
+const DEFAULT_MAX_FILES_PER_COMMIT = 20;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+// ── Cache ──
+let cachedResult = null;
+let cachedProjectRoot = null;
+/**
+ * Invalidate the coupling cache. Call this when the graph is refreshed
+ * or when git history may have changed.
+ */
+function invalidateCouplingCache() {
+    cachedResult = null;
+    cachedProjectRoot = null;
+}
+// ── Git History Mining ──
+/**
+ * Check whether the given directory is inside a git repository.
+ */
+function isGitRepo(projectRoot) {
+    try {
+        (0, child_process_1.execSync)("git rev-parse --is-inside-work-tree", {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse git log output into a list of commits, each containing
+ * the list of files changed in that commit.
+ */
+function parseGitLog(raw) {
+    const commits = [];
+    const segments = raw.split("COMMIT:");
+    for (const segment of segments) {
+        const trimmed = segment.trim();
+        if (!trimmed)
+            continue;
+        // First line is the commit hash, remaining lines are file paths
+        const lines = trimmed.split("\n");
+        const files = [];
+        for (let i = 1; i < lines.length; i++) {
+            const fileLine = lines[i].trim();
+            if (fileLine) {
+                files.push(fileLine);
+            }
+        }
+        if (files.length > 0) {
+            commits.push(files);
+        }
+    }
+    return commits;
+}
+/**
+ * Normalize a git-output path (forward slashes) to be consistent
+ * with how the dependency graph stores paths.
+ */
+function normalizePath(filePath) {
+    // Git always outputs forward slashes; normalize for consistency
+    return filePath.replace(/\\/g, "/");
+}
+/**
+ * Check if a file path looks like a source file (not binary, not config noise).
+ * We keep this broad — the dependency graph comparison will handle the real filtering.
+ */
+function isSourceFile(filePath) {
+    // Skip obviously non-source files
+    const skipPatterns = [
+        /\.lock$/,
+        /package-lock\.json$/,
+        /yarn\.lock$/,
+        /\.min\.(js|css)$/,
+        /\.map$/,
+        /\.d\.ts$/,
+        /\.png$/,
+        /\.jpg$/,
+        /\.jpeg$/,
+        /\.gif$/,
+        /\.svg$/,
+        /\.ico$/,
+        /\.woff2?$/,
+        /\.ttf$/,
+        /\.eot$/,
+        /\.pdf$/,
+        /\.zip$/,
+        /\.tar$/,
+        /\.gz$/,
+    ];
+    const normalized = filePath.toLowerCase();
+    return !skipPatterns.some((p) => p.test(normalized));
+}
+/**
+ * Create a canonical pair key for two files (order-independent).
+ */
+function pairKey(a, b) {
+    return a < b ? `${a}\0${b}` : `${b}\0${a}`;
+}
+/**
+ * Mine git history to find files that frequently co-change.
+ *
+ * Runs `git log --name-only` and analyzes pairwise file combinations
+ * within each commit to identify hidden logical dependencies.
+ */
+async function mineGitHistory(projectRoot, options) {
+    // Return cached result if still valid
+    if (cachedResult &&
+        cachedProjectRoot === projectRoot &&
+        Date.now() - cachedResult.analyzedAt < CACHE_TTL_MS) {
+        return cachedResult;
+    }
+    const maxCommits = options?.maxCommits ?? DEFAULT_MAX_COMMITS;
+    const minSupport = options?.minSupport ?? DEFAULT_MIN_SUPPORT;
+    const minConfidence = options?.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+    const maxFilesPerCommit = options?.maxFilesPerCommit ?? DEFAULT_MAX_FILES_PER_COMMIT;
+    // Empty result for non-git projects
+    const emptyResult = {
+        couplings: [],
+        fileCouplings: new Map(),
+        totalCommitsAnalyzed: 0,
+        analyzedAt: Date.now(),
+    };
+    if (!isGitRepo(projectRoot)) {
+        cachedResult = emptyResult;
+        cachedProjectRoot = projectRoot;
+        return emptyResult;
+    }
+    // Run git log
+    let raw;
+    try {
+        raw = (0, child_process_1.execSync)(`git log --name-only --format="COMMIT:%H" --max-count=${maxCommits}`, {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            maxBuffer: 10 * 1024 * 1024,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch {
+        cachedResult = emptyResult;
+        cachedProjectRoot = projectRoot;
+        return emptyResult;
+    }
+    const commits = parseGitLog(raw);
+    // Track per-file change counts and per-pair co-change counts
+    const fileChangeCount = new Map();
+    const pairCoChangeCount = new Map();
+    let totalCommitsAnalyzed = 0;
+    for (const commitFiles of commits) {
+        // Filter to source files and normalize paths
+        const filtered = commitFiles
+            .map(normalizePath)
+            .filter(isSourceFile);
+        // Skip mega-commits (merge commits, large refactors)
+        if (filtered.length > maxFilesPerCommit || filtered.length < 2) {
+            if (filtered.length === 1) {
+                // Still count single-file commits for per-file totals
+                const file = filtered[0];
+                fileChangeCount.set(file, (fileChangeCount.get(file) || 0) + 1);
+            }
+            totalCommitsAnalyzed++;
+            continue;
+        }
+        totalCommitsAnalyzed++;
+        // Count per-file changes
+        for (const file of filtered) {
+            fileChangeCount.set(file, (fileChangeCount.get(file) || 0) + 1);
+        }
+        // Count pairwise co-changes
+        for (let i = 0; i < filtered.length; i++) {
+            for (let j = i + 1; j < filtered.length; j++) {
+                const key = pairKey(filtered[i], filtered[j]);
+                pairCoChangeCount.set(key, (pairCoChangeCount.get(key) || 0) + 1);
+            }
+        }
+    }
+    // Build coupling results, filtering by thresholds
+    const couplings = [];
+    for (const [key, coCount] of pairCoChangeCount) {
+        if (coCount < minSupport)
+            continue;
+        const [file1, file2] = key.split("\0");
+        const file1Changes = fileChangeCount.get(file1) || 0;
+        const file2Changes = fileChangeCount.get(file2) || 0;
+        const maxChanges = Math.max(file1Changes, file2Changes);
+        const confidence = maxChanges > 0 ? coCount / maxChanges : 0;
+        if (confidence < minConfidence)
+            continue;
+        couplings.push({
+            file1,
+            file2,
+            coChangeCount: coCount,
+            file1Changes,
+            file2Changes,
+            confidence,
+            support: coCount,
+        });
+    }
+    // Sort by confidence descending
+    couplings.sort((a, b) => b.confidence - a.confidence);
+    // Build the per-file lookup map
+    const fileCouplings = new Map();
+    for (const coupling of couplings) {
+        // Add to file1's list
+        if (!fileCouplings.has(coupling.file1)) {
+            fileCouplings.set(coupling.file1, []);
+        }
+        fileCouplings.get(coupling.file1).push(coupling);
+        // Add to file2's list
+        if (!fileCouplings.has(coupling.file2)) {
+            fileCouplings.set(coupling.file2, []);
+        }
+        fileCouplings.get(coupling.file2).push(coupling);
+    }
+    // Sort each file's couplings by confidence descending
+    for (const [, list] of fileCouplings) {
+        list.sort((a, b) => b.confidence - a.confidence);
+    }
+    const result = {
+        couplings,
+        fileCouplings,
+        totalCommitsAnalyzed,
+        analyzedAt: Date.now(),
+    };
+    cachedResult = result;
+    cachedProjectRoot = projectRoot;
+    return result;
+}
+/**
+ * Get all significant couplings for a given file path.
+ * Returns an empty array if no couplings are found.
+ *
+ * The filePath should be a relative path matching git log output format
+ * (forward slashes, relative to project root).
+ */
+function getCoupledFiles(filePath, result) {
+    const normalized = normalizePath(filePath);
+    return result.fileCouplings.get(normalized) || [];
+}

package/dist/graph/incremental.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Incremental Graph Updates for SYKE.
+ *
+ * Instead of rebuilding the entire dependency graph when a single file changes,
+ * this module re-parses only the changed file's imports and updates the
+ * forward/reverse maps in place. SCC and PageRank are recomputed fully
+ * (both are O(V+E) and fast enough) only when edges actually change.
+ *
+ * This brings update latency from O(N * parse) down to O(1 * parse + V+E)
+ * for large codebases (10K+ files).
+ */
+import { DependencyGraph } from "../graph";
+export interface IncrementalUpdateResult {
+    updatedFile: string;
+    addedEdges: [string, string][];
+    removedEdges: [string, string][];
+    edgesChanged: boolean;
+    affectedFiles: string[];
+}
+/**
+ * Update the graph for a single changed file.
+ * Re-parses only that file's imports and updates forward/reverse maps.
+ * Returns info about what changed for cache invalidation.
+ */
+export declare function updateGraphForFile(graph: DependencyGraph, filePath: string, projectRoot: string): IncrementalUpdateResult;
+/**
+ * Add a new file to the graph.
+ * Initializes forward/reverse entries, parses imports, and adds edges.
+ */
+export declare function addFileToGraph(graph: DependencyGraph, filePath: string, projectRoot: string): IncrementalUpdateResult;
+/**
+ * Remove a file from the graph.
+ * Cleans up all forward edges, reverse edges, and the files set.
+ */
+export declare function removeFileFromGraph(graph: DependencyGraph, filePath: string): IncrementalUpdateResult;