engramx 2.0.2 → 3.0.0

package/dist/chunk-ZUC6OXSL.js

@@ -0,0 +1,178 @@
+// src/providers/mcp-config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getMcpConfigPath() {
+  const override = process.env.ENGRAM_MCP_CONFIG_PATH;
+  if (override && override.length > 0) return override;
+  return join(homedir(), ".engram", "mcp-providers.json");
+}
+function loadMcpConfigs(path = getMcpConfigPath()) {
+  if (!existsSync(path)) {
+    return { configs: [], failed: [] };
+  }
+  let raw;
+  try {
+    raw = readFileSync(path, "utf-8");
+  } catch (err) {
+    return {
+      configs: [],
+      failed: [
+        {
+          index: -1,
+          reason: `failed to read config file: ${err.message}`
+        }
+      ]
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return {
+      configs: [],
+      failed: [
+        {
+          index: -1,
+          reason: `invalid JSON in ${path}: ${err.message}`
+        }
+      ]
+    };
+  }
+  if (!isMcpProvidersFile(parsed)) {
+    return {
+      configs: [],
+      failed: [
+        {
+          index: -1,
+          reason: `expected { providers: [...] } shape in ${path}`
+        }
+      ]
+    };
+  }
+  const valid = [];
+  const failed = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < parsed.providers.length; i++) {
+    const entry = parsed.providers[i];
+    const validation = validateProviderConfig(entry);
+    if (validation.ok) {
+      if (seenNames.has(validation.value.name)) {
+        failed.push({
+          index: i,
+          reason: `duplicate provider name '${validation.value.name}' \u2014 first occurrence wins`
+        });
+        continue;
+      }
+      seenNames.add(validation.value.name);
+      valid.push(validation.value);
+    } else {
+      failed.push({ index: i, reason: validation.reason });
+    }
+  }
+  return { configs: valid, failed };
+}
+function isMcpProvidersFile(v) {
+  if (!v || typeof v !== "object") return false;
+  const obj = v;
+  return Array.isArray(obj.providers);
+}
+function validateProviderConfig(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { ok: false, reason: "entry is not an object" };
+  }
+  const o = raw;
+  if (typeof o.name !== "string" || o.name.length === 0) {
+    return { ok: false, reason: "`name` must be a non-empty string" };
+  }
+  if (typeof o.label !== "string" || o.label.length === 0) {
+    return { ok: false, reason: `[${o.name}] 'label' must be a non-empty string` };
+  }
+  if (o.transport !== "stdio" && o.transport !== "http") {
+    return {
+      ok: false,
+      reason: `[${o.name}] 'transport' must be 'stdio' or 'http'`
+    };
+  }
+  if (!Array.isArray(o.tools)) {
+    return { ok: false, reason: `[${o.name}] 'tools' must be an array` };
+  }
+  for (let i = 0; i < o.tools.length; i++) {
+    const t = o.tools[i];
+    if (!t || typeof t.name !== "string" || t.name.length === 0) {
+      return {
+        ok: false,
+        reason: `[${o.name}] tools[${i}].name must be a non-empty string`
+      };
+    }
+    if (t.args !== void 0 && (typeof t.args !== "object" || t.args === null)) {
+      return { ok: false, reason: `[${o.name}] tools[${i}].args must be an object` };
+    }
+    if (t.confidence !== void 0) {
+      if (typeof t.confidence !== "number" || t.confidence < 0 || t.confidence > 1) {
+        return {
+          ok: false,
+          reason: `[${o.name}] tools[${i}].confidence must be in [0, 1]`
+        };
+      }
+    }
+  }
+  if (o.transport === "stdio") {
+    if (typeof o.command !== "string" || o.command.length === 0) {
+      return { ok: false, reason: `[${o.name}] 'command' required for stdio transport` };
+    }
+    if (o.args !== void 0 && !Array.isArray(o.args)) {
+      return { ok: false, reason: `[${o.name}] 'args' must be an array of strings` };
+    }
+  } else {
+    if (typeof o.url !== "string" || o.url.length === 0) {
+      return { ok: false, reason: `[${o.name}] 'url' required for http transport` };
+    }
+    try {
+      new URL(o.url);
+    } catch {
+      return { ok: false, reason: `[${o.name}] 'url' is not a valid URL` };
+    }
+  }
+  for (const field of ["tokenBudget", "timeoutMs", "cacheTtlSec", "priority"]) {
+    if (o[field] !== void 0) {
+      if (typeof o[field] !== "number" || o[field] < 0) {
+        return {
+          ok: false,
+          reason: `[${o.name}] '${field}' must be a non-negative number`
+        };
+      }
+    }
+  }
+  return { ok: true, value: raw };
+}
+function applyArgTemplate(template, ctx) {
+  const defaults = { path: "{filePath}" };
+  const src = template ?? defaults;
+  const out = {};
+  const basename = ctx.fileBasename ?? ctx.filePath.split(/[\\/]/).pop() ?? ctx.filePath;
+  const tokens = {
+    filePath: ctx.filePath,
+    projectRoot: ctx.projectRoot,
+    imports: ctx.imports.join(","),
+    fileBasename: basename
+  };
+  for (const [key, value] of Object.entries(src)) {
+    if (typeof value === "string") {
+      out[key] = value.replace(
+        /\{(\w+)\}/g,
+        (match, token) => Object.prototype.hasOwnProperty.call(tokens, token) ? tokens[token] : match
+      );
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+export {
+  getMcpConfigPath,
+  loadMcpConfigs,
+  validateProviderConfig,
+  applyArgTemplate
+};