@syke1/mcp-server 1.6.0 → 1.7.0

package/dist/remote/proxy.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * Remote proxy for SYKE Pro tools.
+ *
+ * Serializes the local dependency graph and sends it to Firebase Cloud Functions
+ * for server-side Pro analysis. The user experience is transparent — same tools,
+ * same output format, just executed on the server.
+ */
+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.serializeGraph = serializeGraph;
+exports.remoteAnalyzeImpact = remoteAnalyzeImpact;
+exports.remoteGetHubFiles = remoteGetHubFiles;
+exports.remoteAIAnalyze = remoteAIAnalyze;
+exports.remoteValidateLicense = remoteValidateLicense;
+const https = __importStar(require("https"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+// ── Constants ──
+const BASE_URL = "https://us-central1-syke-cloud.cloudfunctions.net";
+const ENDPOINTS = {
+    analyzeImpact: `${BASE_URL}/proAnalyzeImpact`,
+    getHubFiles: `${BASE_URL}/proGetHubFiles`,
+    aiAnalyze: `${BASE_URL}/proAIAnalyze`,
+};
+// ── Graph Serialization ──
+/**
+ * Serialize a DependencyGraph into a GraphBundle for transmission.
+ * Converts absolute paths to relative paths (relative to sourceDir)
+ * to minimize payload size and avoid leaking local paths.
+ */
+function serializeGraph(graph) {
+    const toRel = (f) => path.relative(graph.sourceDir, f).replace(/\\/g, "/");
+    const files = [];
+    for (const f of graph.files) {
+        files.push(toRel(f));
+    }
+    const forward = {};
+    for (const [file, deps] of graph.forward) {
+        const rel = toRel(file);
+        forward[rel] = deps.map(toRel);
+    }
+    const reverse = {};
+    for (const [file, deps] of graph.reverse) {
+        const rel = toRel(file);
+        reverse[rel] = deps.map(toRel);
+    }
+    return {
+        files,
+        forward,
+        reverse,
+        languages: graph.languages,
+    };
+}
+// ── HTTP Client ──
+function postJSON(url, body) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(body);
+        const parsed = new URL(url);
+        const options = {
+            hostname: parsed.hostname,
+            port: 443,
+            path: parsed.pathname + parsed.search,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(data),
+            },
+        };
+        const req = https.request(options, (res) => {
+            let responseData = "";
+            res.on("data", (chunk) => { responseData += chunk; });
+            res.on("end", () => {
+                try {
+                    const json = JSON.parse(responseData);
+                    if (res.statusCode && res.statusCode >= 400) {
+                        reject(new Error(json.error || `HTTP ${res.statusCode}`));
+                    }
+                    else {
+                        resolve(json);
+                    }
+                }
+                catch {
+                    reject(new Error(`Invalid response: ${responseData.substring(0, 200)}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.setTimeout(60000, () => {
+            req.destroy();
+            reject(new Error("Request timeout (60s)"));
+        });
+        req.write(data);
+        req.end();
+    });
+}
+// ── License + Device Info ──
+function getLicenseKey() {
+    return (0, config_1.getConfig)("licenseKey", "SYKE_LICENSE_KEY");
+}
+function getDeviceId() {
+    const os = require("os");
+    const crypto = require("crypto");
+    const raw = `${os.hostname()}:${os.userInfo().username}:${process.platform}:${os.arch()}`;
+    return crypto.createHash("sha256").update(raw).digest("hex").substring(0, 16);
+}
+// ── Public API ──
+/**
+ * Remote analyze_impact: sends graph + target file to server.
+ */
+async function remoteAnalyzeImpact(graph, resolvedFilePath, options) {
+    const licenseKey = getLicenseKey();
+    if (!licenseKey) {
+        throw new Error("No license key configured");
+    }
+    const graphBundle = serializeGraph(graph);
+    const targetFile = path.relative(graph.sourceDir, resolvedFilePath).replace(/\\/g, "/");
+    const result = await postJSON(ENDPOINTS.analyzeImpact, {
+        licenseKey,
+        deviceId: getDeviceId(),
+        graphBundle,
+        targetFile,
+        options: { includeRiskScore: options?.includeRiskScore !== false },
+    });
+    return result;
+}
+/**
+ * Remote get_hub_files: sends graph to server for PageRank analysis.
+ */
+async function remoteGetHubFiles(graph, topN = 10) {
+    const licenseKey = getLicenseKey();
+    if (!licenseKey) {
+        throw new Error("No license key configured");
+    }
+    const graphBundle = serializeGraph(graph);
+    const result = await postJSON(ENDPOINTS.getHubFiles, {
+        licenseKey,
+        deviceId: getDeviceId(),
+        graphBundle,
+        topN,
+    });
+    return result;
+}
+/**
+ * Remote ai_analyze: sends graph + file contents to server for AI analysis.
+ */
+async function remoteAIAnalyze(graph, resolvedFilePath, fileContents) {
+    const licenseKey = getLicenseKey();
+    if (!licenseKey) {
+        throw new Error("No license key configured");
+    }
+    const graphBundle = serializeGraph(graph);
+    const targetFile = path.relative(graph.sourceDir, resolvedFilePath).replace(/\\/g, "/");
+    const result = await postJSON(ENDPOINTS.aiAnalyze, {
+        licenseKey,
+        deviceId: getDeviceId(),
+        graphBundle,
+        targetFile,
+        fileContents,
+        languages: graph.languages,
+    });
+    return result;
+}
+/**
+ * Remote license validation only (for refresh_graph, check_warnings).
+ * Returns true if the license is valid Pro.
+ */
+async function remoteValidateLicense() {
+    const licenseKey = getLicenseKey();
+    if (!licenseKey)
+        return false;
+    try {
+        const result = await postJSON(`${BASE_URL}/validateLicenseKey`, {
+            key: licenseKey,
+            deviceId: getDeviceId(),
+        });
+        return result.valid === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/remote/types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Types for SYKE Remote Pro Analysis.
+ *
+ * GraphBundle is the serialization format sent from the local MCP server
+ * to Firebase Cloud Functions for server-side Pro analysis.
+ */
+export interface GraphBundle {
+    /** Relative file paths (relative to project root) */
+    files: string[];
+    /** Forward dependencies: file → files it imports */
+    forward: Record<string, string[]>;
+    /** Reverse dependencies: file → files that import it */
+    reverse: Record<string, string[]>;
+    /** Detected language plugin IDs */
+    languages: string[];
+}
+export interface RemoteAnalyzeImpactRequest {
+    licenseKey: string;
+    deviceId: string;
+    graphBundle: GraphBundle;
+    targetFile: string;
+    options?: {
+        includeRiskScore?: boolean;
+    };
+}
+export interface RemoteAnalyzeImpactResponse {
+    riskLevel: string;
+    totalImpacted: number;
+    directDependents: string[];
+    transitiveDependents: string[];
+    cascadeLevels?: Record<string, number>;
+    circularCluster?: string[];
+    sccCount?: number;
+    cyclicSCCs?: number;
+    riskScore?: {
+        composite: number;
+        fanIn: number;
+        fanOut: number;
+        transitiveFanIn: number;
+        instability: number;
+        complexity: number;
+        normalizedComplexity: number;
+        cascadeDepth: number;
+        riskLevel: string;
+        pageRank?: number;
+        pageRankPercentile?: number;
+    };
+}
+export interface RemoteGetHubFilesRequest {
+    licenseKey: string;
+    deviceId: string;
+    graphBundle: GraphBundle;
+    topN?: number;
+}
+export interface RemoteGetHubFilesResponse {
+    hubs: Array<{
+        relativePath: string;
+        dependentCount: number;
+        riskLevel: string;
+        pageRank?: number;
+        pageRankPercentile?: number;
+        riskScore?: number;
+        riskScoreLevel?: string;
+    }>;
+    totalFiles: number;
+}
+export interface RemoteAIAnalyzeRequest {
+    licenseKey: string;
+    deviceId: string;
+    graphBundle: GraphBundle;
+    targetFile: string;
+    fileContents: string;
+    languages: string[];
+}
+export interface RemoteAIAnalyzeResponse {
+    analysis: string;
+}
+export interface RemoteError {
+    error: string;
+    code?: string;
+}

package/dist/remote/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Types for SYKE Remote Pro Analysis.
+ *
+ * GraphBundle is the serialization format sent from the local MCP server
+ * to Firebase Cloud Functions for server-side Pro analysis.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tools/analyze-impact.d.ts

@@ -1,5 +1,4 @@
 import { DependencyGraph } from "../graph";
-import { RiskScore } from "../scoring/risk-scorer";
 import { MemoCache } from "../graph/memo-cache";
 export type RiskLevel = "HIGH" | "MEDIUM" | "LOW" | "NONE";
 export interface CoupledFileInfo {
@@ -23,8 +22,6 @@ export interface ImpactResult {
     sccCount?: number;
     /** Number of SCCs with more than one file (circular dependencies) */
     cyclicSCCs?: number;
-    /** Composite risk score (0-1) combining multiple signals */
-    riskScore?: RiskScore;
     /** Files that historically co-change but may not be in the dependency graph */
     coupledFiles?: CoupledFileInfo[];
     /** True if the BFS result came from the memo cache (fast path) */
@@ -38,9 +35,12 @@ export interface ImpactResult {
  * Optionally computes a composite risk score when `includeRiskScore` is true.
  * Optionally computes historical change coupling when `includeCoupling` is true.
  */
+/**
+ * Local BFS impact analysis — used by BYOK ai_analyze and web dashboard.
+ * Risk scoring is now server-side (Pro). This function provides basic
+ * BFS traversal and SCC-enhanced cascade analysis.
+ */
 export declare function analyzeImpact(filePath: string, graph: DependencyGraph, options?: {
-    includeRiskScore?: boolean;
-    fileContent?: string | null;
     includeCoupling?: boolean;
 }): Promise<ImpactResult>;
 /**