@ulpi/cli 0.1.5 → 0.1.6

package/dist/chunk-JLHNLM3C.js

@@ -0,0 +1,228 @@
+import {
+  loadMcpCatalog
+} from "./chunk-4ZPOZULQ.js";
+import {
+  MCPS_LIBRARY_FILE,
+  ULPI_GLOBAL_DIR,
+  projectMcpsFile
+} from "./chunk-C7CLUQI6.js";
+import {
+  McpLibrarySchema,
+  McpRepoConfigSchema
+} from "./chunk-YOKL7RB5.js";
+
+// ../../packages/mcp-gateway-engine/dist/index.js
+import * as fs from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import * as fs2 from "fs";
+import * as path from "path";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+import * as fs3 from "fs";
+import * as path2 from "path";
+function loadLibrary() {
+  try {
+    if (!fs.existsSync(MCPS_LIBRARY_FILE)) {
+      return { mcps: {} };
+    }
+    const raw = fs.readFileSync(MCPS_LIBRARY_FILE, "utf-8");
+    const parsed = parseYaml(raw);
+    return McpLibrarySchema.parse(parsed ?? {});
+  } catch {
+    return { mcps: {} };
+  }
+}
+function saveLibrary(library) {
+  fs.mkdirSync(ULPI_GLOBAL_DIR, { recursive: true });
+  const yaml = stringifyYaml(library, { lineWidth: 120 });
+  fs.writeFileSync(MCPS_LIBRARY_FILE, yaml, "utf-8");
+}
+function addToLibrary(name, definition) {
+  const library = loadLibrary();
+  library.mcps[name] = { ...definition, name, added_at: definition.added_at ?? (/* @__PURE__ */ new Date()).toISOString() };
+  saveLibrary(library);
+}
+function removeFromLibrary(name) {
+  const library = loadLibrary();
+  if (!(name in library.mcps)) return false;
+  delete library.mcps[name];
+  saveLibrary(library);
+  return true;
+}
+function getLibraryEntry(name) {
+  const library = loadLibrary();
+  return library.mcps[name];
+}
+function listLibrary() {
+  const library = loadLibrary();
+  return Object.values(library.mcps);
+}
+function loadActivations(projectDir) {
+  try {
+    const filePath = projectMcpsFile(projectDir);
+    if (!fs2.existsSync(filePath)) {
+      return { mcps: {} };
+    }
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    const parsed = parseYaml2(raw);
+    return McpRepoConfigSchema.parse(parsed ?? {});
+  } catch {
+    return { mcps: {} };
+  }
+}
+function saveActivations(projectDir, config) {
+  const filePath = projectMcpsFile(projectDir);
+  fs2.mkdirSync(path.dirname(filePath), { recursive: true });
+  const yaml = stringifyYaml2(config, { lineWidth: 120 });
+  fs2.writeFileSync(filePath, yaml, "utf-8");
+}
+function enableMcp(projectDir, name, config) {
+  const current = loadActivations(projectDir);
+  current.mcps[name] = { enabled: true, config: config ?? current.mcps[name]?.config ?? {} };
+  saveActivations(projectDir, current);
+}
+function disableMcp(projectDir, name) {
+  const current = loadActivations(projectDir);
+  if (!(name in current.mcps)) return false;
+  current.mcps[name] = { ...current.mcps[name], enabled: false, config: current.mcps[name]?.config ?? {} };
+  saveActivations(projectDir, current);
+  return true;
+}
+function updateActivationConfig(projectDir, name, config) {
+  const current = loadActivations(projectDir);
+  const existing = current.mcps[name];
+  current.mcps[name] = { enabled: existing?.enabled ?? true, config };
+  saveActivations(projectDir, current);
+}
+function getActivation(projectDir, name) {
+  const config = loadActivations(projectDir);
+  return config.mcps[name];
+}
+function listActivations(projectDir) {
+  const config = loadActivations(projectDir);
+  return Object.entries(config.mcps).map(([name, activation]) => ({ name, activation }));
+}
+function loadCatalog() {
+  return loadMcpCatalog();
+}
+function getCatalogEntry(name) {
+  return loadMcpCatalog().find((e) => e.name === name);
+}
+function searchCatalog(query) {
+  const q = query.toLowerCase();
+  return loadMcpCatalog().filter((entry) => {
+    if (entry.name.toLowerCase().includes(q)) return true;
+    if (entry.display_name?.toLowerCase().includes(q)) return true;
+    if (entry.description?.toLowerCase().includes(q)) return true;
+    if (entry.tags?.some((t) => t.toLowerCase().includes(q))) return true;
+    if (entry.category?.toLowerCase().includes(q)) return true;
+    return false;
+  });
+}
+function suggestMcps(input) {
+  const catalog = loadMcpCatalog();
+  const library = loadLibrary();
+  const suggestions = [];
+  for (const entry of catalog) {
+    const signals = entry.detect_signals;
+    if (!signals) continue;
+    const evidence = [];
+    const depMatches = (signals.dependencies ?? []).filter(
+      (d) => input.dependencies.some((dep) => dep === d || dep.startsWith(d + "/"))
+    );
+    if (depMatches.length > 0) {
+      evidence.push(`Dependencies: ${depMatches.join(", ")}`);
+    }
+    const envMatches = (signals.env_vars ?? []).filter((e) => input.envVars.includes(e));
+    if (envMatches.length > 0) {
+      evidence.push(`Env vars: ${envMatches.join(", ")}`);
+    }
+    const dockerMatches = (signals.docker_services ?? []).filter((s) => input.dockerServices.includes(s));
+    if (dockerMatches.length > 0) {
+      evidence.push(`Docker services: ${dockerMatches.join(", ")}`);
+    }
+    if (evidence.length === 0) continue;
+    let confidence = "low";
+    if (depMatches.length > 0 && (envMatches.length > 0 || dockerMatches.length > 0)) {
+      confidence = "high";
+    } else if (depMatches.length > 0 || envMatches.length > 0) {
+      confidence = "medium";
+    }
+    suggestions.push({
+      name: entry.name,
+      displayName: entry.display_name ?? entry.name,
+      description: entry.description ?? "",
+      category: entry.category ?? "custom",
+      confidence,
+      evidence,
+      alreadyAdded: entry.name in library.mcps
+    });
+  }
+  const order = { high: 0, medium: 1, low: 2 };
+  suggestions.sort((a, b) => order[a.confidence] - order[b.confidence] || a.name.localeCompare(b.name));
+  return suggestions;
+}
+function collectProjectSignals(projectDir) {
+  const dependencies = [];
+  const envVars = [];
+  const dockerServices = [];
+  const pkgJsonPath = path2.join(projectDir, "package.json");
+  try {
+    if (fs3.existsSync(pkgJsonPath)) {
+      const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+      dependencies.push(...Object.keys(pkg.dependencies ?? {}));
+      dependencies.push(...Object.keys(pkg.devDependencies ?? {}));
+    }
+  } catch {
+  }
+  for (const envFile of [".env", ".env.local", ".env.example"]) {
+    const envPath = path2.join(projectDir, envFile);
+    try {
+      if (fs3.existsSync(envPath)) {
+        const content = fs3.readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+          const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+          if (match?.[1]) envVars.push(match[1]);
+        }
+      }
+    } catch {
+    }
+  }
+  for (const dcFile of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
+    const dcPath = path2.join(projectDir, dcFile);
+    try {
+      if (fs3.existsSync(dcPath)) {
+        const content = fs3.readFileSync(dcPath, "utf-8");
+        const servicesMatch = content.match(/^services:\s*\n((?:\s+\S+.*\n?)*)/m);
+        if (servicesMatch?.[1]) {
+          for (const line of servicesMatch[1].split("\n")) {
+            const svcMatch = line.match(/^\s{2}(\w[\w-]*):/);
+            if (svcMatch?.[1]) dockerServices.push(svcMatch[1]);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return { dependencies, envVars, dockerServices };
+}
+
+export {
+  loadLibrary,
+  saveLibrary,
+  addToLibrary,
+  removeFromLibrary,
+  getLibraryEntry,
+  listLibrary,
+  loadActivations,
+  saveActivations,
+  enableMcp,
+  disableMcp,
+  updateActivationConfig,
+  getActivation,
+  listActivations,
+  loadCatalog,
+  getCatalogEntry,
+  searchCatalog,
+  suggestMcps,
+  collectProjectSignals
+};

package/dist/{chunk-P2RESJRN.js → chunk-KYYI23AQ.js}

@@ -1,7 +1,7 @@
 import {
   CLI_REGISTRY_URL,
   VERSION_CACHE_FILE
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 
 // src/version-checker.ts
 import * as fs from "fs";
@@ -13,7 +13,7 @@ var REGISTRY_URL = CLI_REGISTRY_URL;
 var FETCH_TIMEOUT_MS = 5e3;
 function getCurrentVersion() {
   try {
-    return "0.1.5";
+    return "0.1.6";
   } catch {
     return "0.0.0";
   }