@syke1/mcp-server 1.0.0

package/dist/languages/python.js

@@ -0,0 +1,129 @@
+"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.pythonPlugin = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plugin_1 = require("./plugin");
+const FROM_IMPORT_RE = /^from\s+(\S+)\s+import/;
+const IMPORT_RE = /^import\s+(\S+)/;
+exports.pythonPlugin = {
+    id: "python",
+    name: "Python",
+    extensions: [".py"],
+    codeBlockLang: "python",
+    detectProject(root) {
+        return fs.existsSync(path.join(root, "pyproject.toml")) ||
+            fs.existsSync(path.join(root, "requirements.txt")) ||
+            fs.existsSync(path.join(root, "setup.py"));
+    },
+    getSourceDirs(root) {
+        const srcDir = path.join(root, "src");
+        if (fs.existsSync(srcDir))
+            return [srcDir];
+        return [root];
+    },
+    getPackageName(root) {
+        try {
+            const toml = fs.readFileSync(path.join(root, "pyproject.toml"), "utf-8");
+            const match = toml.match(/name\s*=\s*"([^"]+)"/);
+            return match ? match[1] : path.basename(root);
+        }
+        catch {
+            return path.basename(root);
+        }
+    },
+    discoverFiles(dir) {
+        return (0, plugin_1.discoverAllFiles)(dir, [".py"]);
+    },
+    parseImports(filePath, projectRoot, sourceDir) {
+        let content;
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return [];
+        }
+        const imports = [];
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("#"))
+                continue;
+            let modulePath = null;
+            const fromMatch = trimmed.match(FROM_IMPORT_RE);
+            if (fromMatch) {
+                modulePath = fromMatch[1];
+            }
+            else {
+                const impMatch = trimmed.match(IMPORT_RE);
+                if (impMatch) {
+                    modulePath = impMatch[1];
+                }
+            }
+            if (!modulePath)
+                continue;
+            // Handle relative imports (starts with .)
+            if (modulePath.startsWith(".")) {
+                const dots = modulePath.match(/^\.+/)?.[0].length || 1;
+                let base = path.dirname(filePath);
+                for (let i = 1; i < dots; i++)
+                    base = path.dirname(base);
+                const rest = modulePath.slice(dots).replace(/\./g, path.sep);
+                const resolved = resolveModule(base, rest);
+                if (resolved)
+                    imports.push(resolved);
+                continue;
+            }
+            // Try resolving as local module relative to source dir
+            const modPath = modulePath.replace(/\./g, path.sep);
+            const resolved = resolveModule(sourceDir, modPath);
+            if (resolved)
+                imports.push(resolved);
+        }
+        return imports;
+    },
+};
+function resolveModule(baseDir, modPath) {
+    const candidates = [
+        path.join(baseDir, modPath + ".py"),
+        path.join(baseDir, modPath, "__init__.py"),
+    ];
+    for (const c of candidates) {
+        const normalized = path.normalize(c);
+        if (fs.existsSync(normalized))
+            return normalized;
+    }
+    return null;
+}

package/dist/languages/ruby.d.ts

@@ -0,0 +1,2 @@
+import { LanguagePlugin } from "./plugin";
+export declare const rubyPlugin: LanguagePlugin;

package/dist/languages/ruby.js

@@ -0,0 +1,97 @@
+"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.rubyPlugin = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plugin_1 = require("./plugin");
+const REQUIRE_RELATIVE_RE = /^require_relative\s+['"](.+?)['"]/;
+exports.rubyPlugin = {
+    id: "ruby",
+    name: "Ruby",
+    extensions: [".rb"],
+    codeBlockLang: "ruby",
+    detectProject(root) {
+        return fs.existsSync(path.join(root, "Gemfile"));
+    },
+    getSourceDirs(root) {
+        const libDir = path.join(root, "lib");
+        if (fs.existsSync(libDir))
+            return [libDir];
+        return [root];
+    },
+    getPackageName(root) {
+        // Try reading from gemspec
+        try {
+            const gemspecs = fs.readdirSync(root).filter(f => f.endsWith(".gemspec"));
+            if (gemspecs.length > 0) {
+                const content = fs.readFileSync(path.join(root, gemspecs[0]), "utf-8");
+                const match = content.match(/\.name\s*=\s*['"]([^'"]+)['"]/);
+                if (match)
+                    return match[1];
+            }
+        }
+        catch { }
+        return path.basename(root);
+    },
+    discoverFiles(dir) {
+        return (0, plugin_1.discoverAllFiles)(dir, [".rb"]);
+    },
+    parseImports(filePath, _projectRoot, _sourceDir) {
+        let 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();
+            if (trimmed.startsWith("#"))
+                continue;
+            const match = trimmed.match(REQUIRE_RELATIVE_RE);
+            if (!match)
+                continue;
+            const reqPath = match[1];
+            const resolved = path.normalize(path.resolve(fileDir, reqPath + ".rb"));
+            if (fs.existsSync(resolved)) {
+                imports.push(resolved);
+            }
+        }
+        return imports;
+    },
+};

package/dist/languages/rust.d.ts

@@ -0,0 +1,2 @@
+import { LanguagePlugin } from "./plugin";
+export declare const rustPlugin: LanguagePlugin;

package/dist/languages/rust.js

@@ -0,0 +1,121 @@
+"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.rustPlugin = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plugin_1 = require("./plugin");
+const USE_CRATE_RE = /^use\s+crate::(\S+)/;
+const MOD_RE = /^mod\s+(\w+)\s*;/;
+exports.rustPlugin = {
+    id: "rust",
+    name: "Rust",
+    extensions: [".rs"],
+    codeBlockLang: "rust",
+    detectProject(root) {
+        return fs.existsSync(path.join(root, "Cargo.toml"));
+    },
+    getSourceDirs(root) {
+        const srcDir = path.join(root, "src");
+        return fs.existsSync(srcDir) ? [srcDir] : [];
+    },
+    getPackageName(root) {
+        try {
+            const cargo = fs.readFileSync(path.join(root, "Cargo.toml"), "utf-8");
+            const match = cargo.match(/name\s*=\s*"([^"]+)"/);
+            return match ? match[1] : path.basename(root);
+        }
+        catch {
+            return path.basename(root);
+        }
+    },
+    discoverFiles(dir) {
+        return (0, plugin_1.discoverAllFiles)(dir, [".rs"]);
+    },
+    parseImports(filePath, _projectRoot, sourceDir) {
+        let content;
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return [];
+        }
+        const imports = [];
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            // use crate::module::submodule
+            const useMatch = trimmed.match(USE_CRATE_RE);
+            if (useMatch) {
+                const cratePath = useMatch[1].replace(/::/g, path.sep).replace(/;$/, "").replace(/\{.*$/, "");
+                const resolved = resolveRustPath(sourceDir, cratePath);
+                if (resolved)
+                    imports.push(resolved);
+                continue;
+            }
+            // mod module_name;
+            const modMatch = trimmed.match(MOD_RE);
+            if (modMatch) {
+                const modName = modMatch[1];
+                const fileDir = path.dirname(filePath);
+                const resolved = resolveRustMod(fileDir, modName);
+                if (resolved)
+                    imports.push(resolved);
+            }
+        }
+        return imports;
+    },
+};
+function resolveRustPath(srcDir, modPath) {
+    const candidates = [
+        path.normalize(path.join(srcDir, modPath + ".rs")),
+        path.normalize(path.join(srcDir, modPath, "mod.rs")),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    return null;
+}
+function resolveRustMod(dir, modName) {
+    const candidates = [
+        path.normalize(path.join(dir, modName + ".rs")),
+        path.normalize(path.join(dir, modName, "mod.rs")),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    return null;
+}

package/dist/languages/typescript.d.ts

@@ -0,0 +1,2 @@
+import { LanguagePlugin } from "./plugin";
+export declare const typescriptPlugin: LanguagePlugin;

package/dist/languages/typescript.js

@@ -0,0 +1,138 @@
+"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.typescriptPlugin = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plugin_1 = require("./plugin");
+const TS_IMPORT_RE = /(?:import|export)\s+.*?from\s+['"](.+?)['"]/;
+const TS_SIDE_EFFECT_RE = /^import\s+['"](.+?)['"]/;
+function resolveTsImport(fromDir, importPath) {
+    const base = path.resolve(fromDir, importPath);
+    const candidates = [
+        base,
+        base + ".ts",
+        base + ".js",
+        path.join(base, "index.ts"),
+        path.join(base, "index.js"),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return path.normalize(candidate);
+        }
+    }
+    return null;
+}
+exports.typescriptPlugin = {
+    id: "typescript",
+    name: "TypeScript",
+    extensions: [".ts", ".tsx"],
+    codeBlockLang: "typescript",
+    detectProject(root) {
+        return fs.existsSync(path.join(root, "tsconfig.json")) ||
+            (fs.existsSync(path.join(root, "package.json")) &&
+                fs.existsSync(path.join(root, "src")));
+    },
+    getSourceDirs(root) {
+        const srcDir = path.join(root, "src");
+        return fs.existsSync(srcDir) ? [srcDir] : [];
+    },
+    getPackageName(root) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
+            return pkg.name || path.basename(root);
+        }
+        catch {
+            return path.basename(root);
+        }
+    },
+    discoverFiles(dir) {
+        return (0, plugin_1.discoverAllFiles)(dir, [".ts", ".tsx"]).filter(f => !f.endsWith(".d.ts"));
+    },
+    parseImports(filePath, _projectRoot, _sourceDir) {
+        let 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();
+            let importPath = null;
+            const match = trimmed.match(TS_IMPORT_RE) || trimmed.match(TS_SIDE_EFFECT_RE);
+            if (match)
+                importPath = match[1];
+            if (!importPath)
+                continue;
+            if (!importPath.startsWith("."))
+                continue;
+            const resolved = resolveTsImport(fileDir, importPath);
+            if (resolved)
+                imports.push(resolved);
+        }
+        return imports;
+    },
+    classifyLayer(relPath) {
+        const lower = relPath.toLowerCase();
+        const fileName = lower.split("/").pop() || "";
+        if (fileName.endsWith(".jsx") || fileName.endsWith(".tsx") ||
+            lower.includes("components/") || lower.includes("web/public/")) {
+            return "FE";
+        }
+        if (fileName.endsWith("server.ts") || fileName.endsWith("server.js") ||
+            lower.includes("web/server")) {
+            return "API";
+        }
+        if (fileName.endsWith(".model.ts") || fileName.endsWith(".entity.ts") ||
+            fileName.endsWith(".schema.ts")) {
+            return "DB";
+        }
+        if (fileName.endsWith(".service.ts") || fileName.endsWith(".controller.ts") ||
+            lower.includes("tools/") || lower.includes("ai/") || lower.includes("watcher/")) {
+            return "BE";
+        }
+        if (fileName === "index.ts" || fileName === "index.js" ||
+            fileName.endsWith(".config.ts") || fileName.endsWith(".config.js")) {
+            return "CONFIG";
+        }
+        if (fileName.endsWith(".util.ts") || fileName.endsWith(".helper.ts")) {
+            return "UTIL";
+        }
+        return null;
+    },
+};

package/dist/license/validator.d.ts

@@ -0,0 +1,23 @@
+export interface LicenseStatus {
+    plan: "free" | "pro";
+    email?: string;
+    expiresAt?: string;
+    source: "online" | "cache" | "default";
+    error?: string;
+}
+/**
+ * Start heartbeat interval (called after successful Pro validation)
+ */
+export declare function startHeartbeat(key: string, deviceId: string): void;
+/**
+ * Stop heartbeat and deactivate session (called on shutdown)
+ */
+export declare function stopAndDeactivate(): Promise<void>;
+/**
+ * Get current device fingerprint (exported for use by index.ts)
+ */
+export declare function getDeviceId(): string;
+/**
+ * Main license validation — called on MCP server startup
+ */
+export declare function checkLicense(): Promise<LicenseStatus>;