godmode 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,34 @@
+# godmode
+
+any API as CLI. any API as MCP. zero code generation.
+
+## Install
+
+```sh
+npm install -g godmode
+```
+
+## Usage
+
+```sh
+godmode ext install stripe
+godmode stripe api customers cus_123
+godmode stripe mcp                # serve as MCP server
+```
+
+Run `godmode --help` or `godmode <extension> --help` at any nesting level for usage.
+
+## Claude Code
+
+```json
+{
+  "mcpServers": {
+    "stripe": {
+      "command": "godmode",
+      "args": ["stripe", "mcp"]
+    }
+  }
+}
+```
+
+See [documentation](https://docs.godmode.so) for more.

package/dist/{add-ZRNIX6DM.js → add-AJERMPEA.js}

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
 import {
   addApi
-} from "./chunk-FBMQ3AC4.js";
-import "./chunk-EHS56XXY.js";
+} from "./chunk-2J2VDCQ4.js";
+import "./chunk-EXWYJU2I.js";
 
 // src/commands/add.ts
 async function runAdd(args) {
   if (!args[0] || args[0] === "--help" || args[0] === "-h") {
-    console.log(`Add an adapter from a folder, built-in name, or manifest.
+    console.log(`Add an extension from a folder, built-in name, or manifest.
 
 Usage:
-  godmode add <name>          Built-in adapter (e.g. stripe, github)
-  godmode add <folder>        Folder containing manifest.yaml
+  godmode extension add <name>          Built-in extension (e.g. stripe, github)
+  godmode extension add <folder>        Folder containing manifest.yaml
+  godmode extension add <manifest>      Direct path to manifest.yaml/json
 
 Manifest format (manifest.yaml):
-  slug:    stripe             CLI name (used as "godmode <slug>")
+  slug:    stripe             CLI name
   name:    Stripe             Display name
   description: Payments API   Short description
   type:    api                api | graphql | mcp
@@ -32,9 +33,10 @@ Types:
   mcp                         MCP endpoint  (requires url)
 
 Examples:
-  $ godmode add stripe
-  $ godmode add ./my-adapter
-  $ godmode add openai`);
+  $ godmode extension add stripe
+  $ godmode extension add ./my-extension
+  $ godmode extension add ./my-extension/manifest.yaml
+  $ godmode extension add openai`);
     process.exit(args[0] ? 0 : 1);
   }
   await addApi(args[0]);

package/dist/chunk-2J2VDCQ4.js

@@ -0,0 +1,503 @@
+#!/usr/bin/env node
+import {
+  parseMcp
+} from "./chunk-EXWYJU2I.js";
+
+// ../../interfaces/graphql/src/index.ts
+import { readFile } from "fs/promises";
+import { isAbsolute, resolve } from "path";
+var INTROSPECTION_QUERY = `{
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      name kind description
+      fields { name description args { name type { name kind ofType { name kind } } } }
+    }
+  }
+}`;
+async function introspect(url, headers) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...headers },
+    body: JSON.stringify({ query: INTROSPECTION_QUERY })
+  });
+  if (!res.ok) throw new Error(`Introspection failed: ${res.status} ${res.statusText}`);
+  const json = await res.json();
+  return json.data?.__schema?.types?.filter((t) => !t.name.startsWith("__")) || [];
+}
+function parseSdl(text) {
+  const types = [];
+  const typeRegex = /type\s+(\w+)\s*\{([^}]*)}/g;
+  let match;
+  while ((match = typeRegex.exec(text)) !== null) {
+    const [, typeName, body] = match;
+    const fields = [];
+    const fieldRegex = /(\w+)(?:\(([^)]*)\))?\s*:\s*\S+/g;
+    let fm;
+    while ((fm = fieldRegex.exec(body)) !== null) {
+      const args = [];
+      if (fm[2]) {
+        const argRegex = /(\w+)\s*:\s*(\w+)/g;
+        let am;
+        while ((am = argRegex.exec(fm[2])) !== null) {
+          args.push({ name: am[1], type: { name: am[2], kind: "SCALAR" } });
+        }
+      }
+      fields.push({ name: fm[1], args: args.length ? args : void 0 });
+    }
+    types.push({ name: typeName, kind: "OBJECT", fields });
+  }
+  return types;
+}
+async function parseGraphQL(name, config) {
+  let types;
+  if (config.spec) {
+    const isRemote = /^https?:\/\//.test(config.spec);
+    if (isRemote) {
+      process.stderr.write(`Fetching ${config.spec}...
+`);
+      const res = await fetch(config.spec);
+      if (!res.ok) throw new Error(`Failed to fetch spec: ${res.status}`);
+      types = parseSdl(await res.text());
+    } else {
+      const specPath = isAbsolute(config.spec) ? config.spec : resolve(process.cwd(), config.spec);
+      process.stderr.write(`Loading ${specPath}...
+`);
+      types = parseSdl(await readFile(specPath, "utf-8"));
+    }
+  } else {
+    if (!config.url) throw new Error('GraphQL config needs either "spec" or "url"');
+    process.stderr.write(`Introspecting ${config.url}...
+`);
+    const headers = { ...config.headers };
+    const token = config.auth?.env ? process.env[config.auth.env] : void 0;
+    if (token) {
+      const authType = config.auth?.type || "bearer";
+      if (authType === "bearer") headers["Authorization"] = `Bearer ${token}`;
+      else if (authType === "api-key") headers[config.auth?.header || "X-API-Key"] = token;
+    }
+    types = await introspect(config.url, headers);
+  }
+  const routes = [];
+  for (const type of types) {
+    if (!type.fields) continue;
+    const isQuery = type.name === "Query" || type.name === "RootQuery";
+    const isMutation = type.name === "Mutation" || type.name === "RootMutation";
+    if (!isQuery && !isMutation) continue;
+    const method = isMutation ? "post" : "get";
+    for (const field of type.fields) {
+      routes.push({
+        path: field.name,
+        method,
+        summary: field.description || "",
+        version: "",
+        segments: [{ value: field.name, isParam: false }]
+      });
+    }
+  }
+  routes.sort((a, b) => a.path.localeCompare(b.path));
+  process.stderr.write(`Parsed ${routes.length} fields (${types.length} types)
+`);
+  return { name, description: config.description || "", specVersion: "", config, versions: [], resourceDescriptions: {}, routes };
+}
+function validateGraphQLFlags(method, query, body, apiName) {
+  if (["put", "patch", "delete", "head"].includes(method)) {
+    return `GraphQL only supports POST. ${method.toUpperCase()} is not valid.`;
+  }
+  if (method === "post") {
+    process.stderr.write(`Note: POST is implicit for GraphQL, flag not needed.
+`);
+  }
+  if (Object.keys(query).length || Object.keys(body).length) {
+    return `GraphQL uses document syntax, not key=value params.
+  godmode ${apiName} '{ field { subfield } }'`;
+  }
+  return null;
+}
+
+// src/config.ts
+import { resolve as resolve2, basename, dirname, extname } from "path";
+import { homedir } from "os";
+import { mkdir, readFile as readFile2, writeFile, readdir, unlink, access, rename } from "fs/promises";
+import { execSync } from "child_process";
+import { parse as parseYaml2 } from "yaml";
+
+// ../../interfaces/api/src/index.ts
+import { parse as parseYaml } from "yaml";
+async function parseOpenApi(name, config) {
+  process.stderr.write(`Fetching ${config.spec}...
+`);
+  const res = await fetch(config.spec);
+  if (!res.ok) throw new Error(`Failed to fetch spec: ${res.status} ${res.statusText}`);
+  const text = await res.text();
+  const isJson = text.trimStart().startsWith("{");
+  const spec = isJson ? JSON.parse(text) : parseYaml(text);
+  if (!spec.paths) throw new Error("No paths found - is this a valid OpenAPI document?");
+  if (!config.url) {
+    if (spec.servers?.[0]?.url) {
+      config.url = spec.servers[0].url;
+    } else if (spec.host) {
+      const scheme = spec.schemes?.[0] || "https";
+      config.url = `${scheme}://${spec.host}${spec.basePath || ""}`;
+    }
+  }
+  const versions = resolveVersions(config, Object.keys(spec.paths));
+  const httpMethods = ["get", "post", "put", "patch", "delete", "head"];
+  const routes = [];
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    for (const method of httpMethods) {
+      const op = pathItem[method];
+      if (!op) continue;
+      const ver = versions.find((v) => path.startsWith(v.prefix));
+      const version = ver?.name || "";
+      const stripped = ver ? path.slice(ver.prefix.length).replace(/^\//, "") : path.slice(1);
+      const rawSegments = stripped.split("/").filter(Boolean);
+      const segments = rawSegments.map((s) => {
+        const isParam = s.startsWith("{") && s.endsWith("}");
+        return { value: isParam ? s.slice(1, -1) : s, isParam };
+      });
+      const tag = op.tags?.[0] || "";
+      routes.push({ path, method, summary: op.summary || "", version, tag, segments });
+    }
+  }
+  routes.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+  const resourceDescriptions = {};
+  if (spec.tags) {
+    const stripHtml = (s) => s.replace(/<[^>]+>/g, "").trim();
+    for (const t of spec.tags) {
+      if (t.name && t.description) {
+        const first = stripHtml(t.description).split(/\.\s/)[0];
+        resourceDescriptions[t.name] = first.endsWith(".") ? first : first + ".";
+      }
+    }
+  }
+  const description = config.description || spec.info?.description || "";
+  const specVersion = spec.info?.version || "";
+  const versionNames = versions.map((v) => v.name).join(", ");
+  process.stderr.write(`Parsed ${routes.length} routes (versions: ${versionNames || "none"})
+`);
+  return { name, description, specVersion, config, versions, resourceDescriptions, routes };
+}
+function resolveVersions(config, paths) {
+  if (config.versions?.length) {
+    return config.versions.map((v) => ({
+      prefix: v.prefix.endsWith("/") ? v.prefix.slice(0, -1) : v.prefix,
+      name: v.name || v.prefix.replace(/^\//, "")
+    }));
+  }
+  if (config.prefix) {
+    const prefix = config.prefix.endsWith("/") ? config.prefix.slice(0, -1) : config.prefix;
+    return [{ prefix, name: prefix.replace(/^\//, "") }];
+  }
+  const versionPattern = /^(\/(?:api\/)?v\d+)/;
+  const detected = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const match = p.match(versionPattern);
+    if (match) detected.set(match[1], (detected.get(match[1]) || 0) + 1);
+  }
+  if (detected.size) {
+    return [...detected.entries()].sort((a, b) => b[1] - a[1]).map(([prefix]) => ({ prefix, name: prefix.replace(/^\//, "") }));
+  }
+  return [{ prefix: "", name: "" }];
+}
+
+// src/spec.ts
+function projectManifest(multi, iface) {
+  const data = multi.interfaces[iface];
+  if (!data) {
+    throw new Error(
+      `extension '${multi.slug}' does not declare an '${iface}' interface (declared: ${Object.keys(multi.interfaces).join(", ")})`
+    );
+  }
+  const config = {
+    slug: multi.slug,
+    name: multi.name,
+    description: multi.description,
+    type: iface,
+    auth: multi.auth,
+    headers: multi.headers,
+    ..."spec" in data ? { spec: data.spec } : {},
+    ..."url" in data && data.url ? { url: data.url } : {},
+    ..."prefix" in data && data.prefix ? { prefix: data.prefix } : {},
+    versions: data.versions,
+    ...iface === "mcp" && data._mcpTools ? { _mcpTools: data._mcpTools } : {}
+  };
+  return {
+    name: multi.name,
+    description: multi.description,
+    specVersion: data.specVersion,
+    config,
+    versions: data.versions,
+    resourceDescriptions: data.resourceDescriptions,
+    routes: data.routes
+  };
+}
+var parsers = {
+  api: parseOpenApi,
+  graphql: parseGraphQL,
+  mcp: parseMcp
+};
+async function compileInterface(iface, name, source) {
+  const parser = parsers[iface];
+  if (!parser) throw new Error(`Unknown interface '${iface}'`);
+  const ifaceSource = source.interfaces[iface];
+  if (!ifaceSource) throw new Error(`Interface '${iface}' not declared on '${name}'`);
+  const legacyConfig = {
+    slug: source.slug || name,
+    name: source.name,
+    description: source.description,
+    type: iface,
+    auth: source.auth,
+    headers: source.headers,
+    ..."spec" in ifaceSource && ifaceSource.spec ? { spec: ifaceSource.spec } : {},
+    ..."url" in ifaceSource && ifaceSource.url ? { url: ifaceSource.url } : {},
+    ..."prefix" in ifaceSource && ifaceSource.prefix ? { prefix: ifaceSource.prefix } : {},
+    versions: ifaceSource.versions
+  };
+  const flat = await parser(name, legacyConfig);
+  const base = {
+    type: iface,
+    specVersion: flat.specVersion,
+    versions: flat.versions,
+    resourceDescriptions: flat.resourceDescriptions,
+    routes: flat.routes
+  };
+  if (iface === "api") {
+    const s2 = ifaceSource;
+    return {
+      ...base,
+      type: "api",
+      spec: s2.spec,
+      url: flat.config.url,
+      prefix: s2.prefix
+    };
+  }
+  if (iface === "graphql") {
+    const s2 = ifaceSource;
+    return {
+      ...base,
+      type: "graphql",
+      spec: s2.spec,
+      url: flat.config.url
+    };
+  }
+  const s = ifaceSource;
+  return {
+    ...base,
+    type: "mcp",
+    url: s.url,
+    _mcpTools: flat.config._mcpTools
+  };
+}
+
+// src/config.ts
+var GODMODE_HOME = process.platform === "linux" && process.env.XDG_CONFIG_HOME ? resolve2(process.env.XDG_CONFIG_HOME, "godmode") : resolve2(homedir(), ".godmode");
+var GODMODE_EXTENSIONS_DIR = process.env.GODMODE_EXTENSIONS_DIR ? resolve2(process.env.GODMODE_EXTENSIONS_DIR) : resolve2(GODMODE_HOME, "extensions");
+var LEGACY_APIS_DIR = resolve2(GODMODE_HOME, "apis");
+var INTERFACE_KEYS = ["api", "graphql", "mcp"];
+async function ensureDirs() {
+  if (await exists(LEGACY_APIS_DIR) && !await exists(GODMODE_EXTENSIONS_DIR)) {
+    await mkdir(dirname(GODMODE_EXTENSIONS_DIR), { recursive: true });
+    await rename(LEGACY_APIS_DIR, GODMODE_EXTENSIONS_DIR);
+    process.stderr.write(`Migrated ${LEGACY_APIS_DIR} -> ${GODMODE_EXTENSIONS_DIR}
+`);
+  }
+  await mkdir(GODMODE_EXTENSIONS_DIR, { recursive: true });
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateSource(raw, origin) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`${origin}: not a valid object`);
+  }
+  const m = raw;
+  if (!m.name || typeof m.name !== "string") {
+    throw new Error(`${origin}: missing or invalid 'name'`);
+  }
+  if (!m.interfaces || typeof m.interfaces !== "object" || Object.keys(m.interfaces).length === 0) {
+    throw new Error(`${origin}: 'interfaces' must be an object with at least one key`);
+  }
+  for (const key of Object.keys(m.interfaces)) {
+    if (!INTERFACE_KEYS.includes(key)) {
+      throw new Error(
+        `${origin}: unknown interface '${key}' (valid: ${INTERFACE_KEYS.join(", ")})`
+      );
+    }
+  }
+  return m;
+}
+async function loadSourceFromDir(dir) {
+  for (const ext of [".yaml", ".yml", ".json"]) {
+    const filePath = resolve2(dir, `manifest${ext}`);
+    if (await exists(filePath)) {
+      const text = await readFile2(filePath, "utf-8");
+      const raw = ext === ".json" ? JSON.parse(text) : parseYaml2(text);
+      return validateSource(raw, filePath);
+    }
+  }
+  return null;
+}
+async function loadSourceFromFile(filePath) {
+  if (!await exists(filePath)) return null;
+  const ext = extname(filePath);
+  if (![".yaml", ".yml", ".json"].includes(ext)) return null;
+  const text = await readFile2(filePath, "utf-8");
+  const raw = ext === ".json" ? JSON.parse(text) : parseYaml2(text);
+  return { source: validateSource(raw, filePath), dir: dirname(filePath) };
+}
+async function resolveSource(input) {
+  const asPath = resolve2(process.cwd(), input);
+  const fromFile = await loadSourceFromFile(asPath);
+  if (fromFile) {
+    const name = fromFile.source.slug || fromFile.source.name || basename(fromFile.dir);
+    return { name, source: fromFile.source, dir: fromFile.dir };
+  }
+  const fromDir = await loadSourceFromDir(asPath);
+  if (fromDir) {
+    const name = fromDir.slug || fromDir.name || basename(asPath);
+    return { name, source: fromDir, dir: asPath };
+  }
+  try {
+    const pkgDir = resolve2(import.meta.dirname, "..", "..", "..", "extensions", input);
+    const fromPkg = await loadSourceFromDir(pkgDir);
+    if (fromPkg) {
+      const name = fromPkg.slug || fromPkg.name || input;
+      return { name, source: fromPkg, dir: pkgDir };
+    }
+  } catch {
+  }
+  throw new Error(
+    `No manifest found: ${input} (expected manifest file, folder containing manifest.yaml, or @godmode-cli/${input})`
+  );
+}
+async function addApi(input) {
+  await ensureDirs();
+  const resolved = await resolveSource(input).catch(() => null);
+  if (resolved) {
+    const { name: name2, source } = resolved;
+    const ifaceKeys = Object.keys(source.interfaces).filter(
+      (k) => INTERFACE_KEYS.includes(k)
+    );
+    if (ifaceKeys.length > 0) {
+      const multi = {
+        name: source.name,
+        slug: source.slug || name2,
+        description: source.description || "",
+        auth: source.auth,
+        headers: source.headers,
+        interfaces: {}
+      };
+      for (const iface of ifaceKeys) {
+        const data = await compileInterface(iface, name2, source);
+        multi.interfaces[iface] = data;
+      }
+      await writeFile(resolve2(GODMODE_EXTENSIONS_DIR, `${name2}.json`), JSON.stringify(multi, null, 2));
+      const ifaceSummary = ifaceKeys.map((k) => {
+        const d = multi.interfaces[k];
+        return d ? `${k}=${d.routes.length}` : k;
+      }).join(", ");
+      process.stderr.write(`Registered "${name2}" - interfaces: ${ifaceSummary}
+`);
+      return;
+    }
+  }
+  const name = resolved?.name || input;
+  const installTarget = resolved?.dir && await exists(resolve2(resolved.dir, "package.json")) ? resolved.dir : input.startsWith("@") ? input : `@godmode-cli/${input}`;
+  process.stderr.write(`Installing ${name}...
+`);
+  try {
+    execSync(`npm install ${installTarget} --prefix ${GODMODE_HOME}`, { stdio: "pipe" });
+  } catch (e) {
+    const err = e;
+    throw new Error(`Failed to install ${name}: ${err.stderr?.toString().trim() || err.message}`);
+  }
+  const pkgName = `@godmode-cli/${name}`;
+  const mcpConfigPath = resolve2(GODMODE_HOME, "node_modules", pkgName, ".mcp.json");
+  if (await exists(mcpConfigPath)) {
+    process.stderr.write(`Installed "${name}" (MCP server extension)
+`);
+  } else {
+    process.stderr.write(`Installed "${name}"
+`);
+  }
+}
+async function updateApi(name) {
+  await addApi(name);
+}
+async function removeApi(name) {
+  try {
+    await unlink(resolve2(GODMODE_EXTENSIONS_DIR, `${name}.json`));
+    process.stderr.write(`Removed "${name}"
+`);
+  } catch {
+    process.stderr.write(`Extension "${name}" not found
+`);
+    process.exit(1);
+  }
+}
+async function listApis() {
+  await ensureDirs();
+  const files = await readdir(GODMODE_EXTENSIONS_DIR);
+  const apis = files.filter((f) => f.endsWith(".json"));
+  if (!apis.length) {
+    console.log("No extensions registered. Create a manifest.yaml and run: godmode extension add <name>");
+    return;
+  }
+  for (const file of apis) {
+    const m = JSON.parse(await readFile2(resolve2(GODMODE_EXTENSIONS_DIR, file), "utf-8"));
+    const ifaces = Object.keys(m.interfaces).join(", ");
+    const desc = m.description ? `  ${m.description}` : "";
+    const routeTotal = Object.values(m.interfaces).reduce((n, d) => n + (d?.routes.length ?? 0), 0);
+    console.log(`  ${m.slug}	[${ifaces}]	${routeTotal} routes${desc}`);
+  }
+}
+async function loadMultiManifest(name) {
+  await ensureDirs();
+  try {
+    return JSON.parse(await readFile2(resolve2(GODMODE_EXTENSIONS_DIR, `${name}.json`), "utf-8"));
+  } catch {
+    process.stderr.write(`Extension "${name}" not found. Create ${name}.yaml and run: godmode extension add ${name}
+`);
+    process.exit(1);
+  }
+}
+async function loadManifest(name, iface) {
+  const multi = await loadMultiManifest(name);
+  const declared = Object.keys(multi.interfaces);
+  if (declared.length === 0) {
+    process.stderr.write(`Extension "${name}" has no interfaces declared
+`);
+    process.exit(1);
+  }
+  const target = iface ?? declared[0];
+  if (!multi.interfaces[target]) {
+    process.stderr.write(
+      `Extension "${name}" does not declare a '${target}' interface (declared: ${declared.join(", ")}).
+`
+    );
+    process.stderr.write(`Try: godmode ${declared[0]} ${name} --help
+`);
+    process.exit(1);
+  }
+  return projectManifest(multi, target);
+}
+
+export {
+  validateGraphQLFlags,
+  GODMODE_HOME,
+  GODMODE_EXTENSIONS_DIR,
+  addApi,
+  updateApi,
+  removeApi,
+  listApis,
+  loadMultiManifest,
+  loadManifest
+};

package/dist/{chunk-EHS56XXY.js → chunk-EXWYJU2I.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// src/protocols/mcp.ts
+// ../../interfaces/mcp/src/index.ts
 var requestId = 0;
 async function mcpRequest(url, method, params, headers, sessionId) {
   const body = {

package/dist/{chunk-I4WS4MMI.js → chunk-GJCJO7YT.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// src/request.ts
+// ../../interfaces/api/src/request.ts
 async function executeToString(manifest, match, options) {
   const baseUrl = manifest.config.url;
   if (!baseUrl) {
@@ -16,9 +16,9 @@ async function executeToString(manifest, match, options) {
   }
   const headers = { ...manifest.config.headers, ...options.headers };
   const authConfig = manifest.config.auth;
-  const token = options.token || (authConfig?.env ? process.env[authConfig.env] : void 0);
+  const token = authConfig?.env ? process.env[authConfig.env] : void 0;
   if (authConfig?.env && !token && !options.dryRun) {
-    throw new Error(`Missing ${authConfig.env}. Set it in .env or environment, or use --token.`);
+    throw new Error(`Missing ${authConfig.env}. Set it in .env or export it in your shell.`);
   }
   if (token) {
     const authType = authConfig?.type || "bearer";