godmode 0.0.1

package/dist/index.js

@@ -0,0 +1,613 @@
+#!/usr/bin/env node
+import {
+  execute
+} from "./chunk-I4WS4MMI.js";
+import {
+  listApis,
+  loadManifest,
+  removeApi,
+  updateApi,
+  validateGraphQLFlags
+} from "./chunk-FBMQ3AC4.js";
+import {
+  executeMcpTool,
+  validateMcpFlags
+} from "./chunk-EHS56XXY.js";
+
+// src/env.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function loadEnv() {
+  let text;
+  try {
+    text = readFileSync(resolve(process.cwd(), ".env"), "utf-8");
+  } catch {
+    return;
+  }
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx < 0) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const val = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+    if (key && !(key in process.env)) process.env[key] = val;
+  }
+}
+
+// src/match.ts
+function matchRoute(manifest, userSegments, method) {
+  if (userSegments.length > 0) {
+    const ver = manifest.versions.find((v) => v.name === userSegments[0]);
+    if (ver) {
+      const match = findMatch(manifest.routes, userSegments.slice(1), method, ver.name);
+      if (match) return match;
+    }
+  }
+  return findMatch(manifest.routes, userSegments, method);
+}
+function findMatch(routes, userSegments, method, version) {
+  let bestMatch = null;
+  let bestScore = -1;
+  for (const route of routes) {
+    if (route.method !== method) continue;
+    if (route.segments.length !== userSegments.length) continue;
+    if (version !== void 0 && route.version !== version) continue;
+    let score = 0;
+    const params = {};
+    let matches = true;
+    for (let i = 0; i < route.segments.length; i++) {
+      const seg = route.segments[i];
+      const userSeg = userSegments[i];
+      if (seg.isParam) {
+        params[seg.value] = userSeg;
+      } else if (seg.value === userSeg) {
+        score += 1;
+      } else {
+        matches = false;
+        break;
+      }
+    }
+    if (matches && (score > bestScore || score === bestScore && isLaterVersion(route, bestMatch?.route))) {
+      bestScore = score;
+      bestMatch = { route, params };
+    }
+  }
+  return bestMatch;
+}
+function isLaterVersion(a, b) {
+  if (!b) return true;
+  return a.version > b.version;
+}
+function suggestRoutes(manifest, userSegments) {
+  if (!userSegments.length) return [];
+  return manifest.routes.filter((route) => {
+    if (route.segments.length < userSegments.length) return false;
+    const firstSeg = route.segments[0];
+    return !firstSeg.isParam && firstSeg.value === userSegments[0];
+  });
+}
+
+// src/args.ts
+function parseArgs(args) {
+  const segments = [];
+  const headers = {};
+  const query = {};
+  const body = {};
+  let method = "get";
+  let token;
+  let filter;
+  let methodFilter;
+  let all = false;
+  let verbose = false;
+  let dryRun = false;
+  let help = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      // HTTP methods
+      case "-g":
+      case "--get":
+        method = "get";
+        break;
+      case "-po":
+      case "--post":
+        method = "post";
+        break;
+      case "-pu":
+      case "--put":
+        method = "put";
+        break;
+      case "-pa":
+      case "--patch":
+        method = "patch";
+        break;
+      case "-d":
+      case "--delete":
+        method = "delete";
+        break;
+      case "--head":
+        method = "head";
+        break;
+      // Options
+      case "-H":
+      case "--header": {
+        const val = args[++i];
+        const idx = val.indexOf(":");
+        if (idx > 0) headers[val.slice(0, idx).trim()] = val.slice(idx + 1).trim();
+        break;
+      }
+      case "--token":
+        token = args[++i];
+        break;
+      case "--filter":
+        filter = args[++i];
+        break;
+      case "--method":
+        methodFilter = args[++i];
+        break;
+      case "--all":
+        all = true;
+        break;
+      case "-v":
+      case "--verbose":
+        verbose = true;
+        break;
+      case "--dry-run":
+        dryRun = true;
+        break;
+      case "-h":
+      case "--help":
+        help = true;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          process.stderr.write(`Unknown flag: ${arg}
+`);
+          process.exit(1);
+        }
+        const eqeq = arg.indexOf("==");
+        const eq = arg.indexOf("=");
+        if (eqeq > 0) {
+          query[arg.slice(0, eqeq)] = arg.slice(eqeq + 2);
+        } else if (eq > 0) {
+          body[arg.slice(0, eq)] = arg.slice(eq + 1);
+        } else {
+          segments.push(arg);
+        }
+    }
+  }
+  if (Object.keys(body).length && method === "get") method = "post";
+  return { segments, method, headers, query, body, token, filter, methodFilter, all, verbose, dryRun, help };
+}
+async function readStdin() {
+  if (process.stdin.isTTY) return void 0;
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const text = Buffer.concat(chunks).toString("utf-8").trim();
+  return text || void 0;
+}
+
+// src/help.ts
+import fuzzysort from "fuzzysort";
+function buildTrie(routes) {
+  const root = { name: "", isParam: false, methods: [], children: [] };
+  for (const route of routes) {
+    let node = root;
+    for (const seg of route.segments) {
+      let child = node.children.find((c) => c.name === seg.value && c.isParam === seg.isParam);
+      if (!child) {
+        child = { name: seg.value, isParam: seg.isParam, methods: [], children: [] };
+        node.children.push(child);
+      }
+      node = child;
+    }
+    node.methods.push({ method: route.method, summary: route.summary });
+  }
+  return root;
+}
+function navigateTrie(root, segments) {
+  let node = root;
+  const fullPath = [];
+  const params = [];
+  for (const seg of segments) {
+    const staticChild = node.children.find((c) => !c.isParam && c.name === seg);
+    if (staticChild) {
+      fullPath.push(seg);
+      node = staticChild;
+      continue;
+    }
+    const paramChild = node.children.find((c) => c.isParam);
+    if (paramChild) {
+      const nested = paramChild.children.find((c) => !c.isParam && c.name === seg);
+      if (nested) {
+        fullPath.push(`<${paramChild.name}>`, seg);
+        params.push({ name: paramChild.name, provided: false });
+        node = nested;
+        continue;
+      }
+      fullPath.push(seg);
+      params.push({ name: paramChild.name, provided: true, value: seg });
+      node = paramChild;
+      continue;
+    }
+    return null;
+  }
+  return { node, fullPath, params };
+}
+function getChildren(node) {
+  const statics = node.children.filter((c) => !c.isParam);
+  const params = node.children.filter((c) => c.isParam);
+  const result = [...statics];
+  for (const p of params) result.push(...p.children);
+  result.sort((a, b) => a.name.localeCompare(b.name));
+  return result;
+}
+var ACTION_ORDER = ["list", "create", "get", "update", "delete"];
+var METHOD_LABEL = {
+  get: "\x1B[1;38;5;34mGET\x1B[0m",
+  post: "\x1B[1;38;5;25mPOST\x1B[0m",
+  put: "\x1B[1;38;5;172mPUT\x1B[0m",
+  patch: "\x1B[1;38;5;30mPATCH\x1B[0m",
+  delete: "\x1B[1;38;5;160mDELETE\x1B[0m"
+};
+var DIM = "\x1B[2m";
+var ITALIC = "\x1B[3m";
+var RESET = "\x1B[0m";
+function methodToAction(method, isResource) {
+  switch (method) {
+    case "get":
+      return isResource ? "get" : "list";
+    case "post":
+      return isResource ? "update" : "create";
+    case "put":
+    case "patch":
+      return "update";
+    case "delete":
+      return "delete";
+    default:
+      return method;
+  }
+}
+function getNodeActions(node) {
+  const actions = /* @__PURE__ */ new Set();
+  const paramChild = node.children.find((c) => c.isParam);
+  const isLeaf = !paramChild;
+  for (const ep of node.methods) actions.add(methodToAction(ep.method, isLeaf));
+  if (paramChild) {
+    for (const ep of paramChild.methods) actions.add(methodToAction(ep.method, true));
+  }
+  return [...actions].sort((a, b) => ACTION_ORDER.indexOf(a) - ACTION_ORDER.indexOf(b));
+}
+function getParamName(node) {
+  return node.children.find((c) => c.isParam)?.name || null;
+}
+function methodLabels(node) {
+  const methods = /* @__PURE__ */ new Set();
+  for (const ep of node.methods) methods.add(ep.method);
+  const paramChild = node.children.find((c) => c.isParam);
+  if (paramChild) for (const ep of paramChild.methods) methods.add(ep.method);
+  const order = ["get", "post", "put", "patch", "delete"];
+  return order.filter((m) => methods.has(m)).map((m) => METHOD_LABEL[m]).join(" ");
+}
+function showHelp() {
+  console.log(`\u0262\u1D0F\u1D05\u1D0D\u1D0F\u1D05\u1D07
+\x1B[2mbetter than mcp\x1B[0m
+
+Usage:
+  godmode <api> <resource> [id] [flags]
+  godmode <api> /path [flags]
+
+Setup:
+  create                      Create own custom API entrypoint
+  add <name|file>             Add API as CLI command from <name>.yaml config
+  update <name>               Re-fetch OpenAPI spec and rebuild routes
+  remove <name>               Unregister an API
+  list                        Show all registered APIs
+  mcp <name>                  Serve registered API as MCP server (stdio)
+  ...                         Run \x1B[2mgodmode add --help\x1B[0m for config format
+
+Navigation:
+  <api> --help                Show resources, auth, and usage
+  <api> <resource> --help     Show operations and sub-resources
+
+Methods:
+  -g,  --get                  GET (default)
+  -po, --post                 POST
+  -pu, --put                  PUT
+  -pa, --patch                PATCH
+  -d,  --delete               DELETE
+
+Data (httpie-style):
+  key=value                   Body field (JSON, implies POST)
+  key==value                  Query param (URL)
+
+Options:
+  -H  <key:value>             Add header
+      --token <tok>            Auth token (overrides config)
+      --dry-run                Preview request without sending
+  -v, --verbose                Show full request/response
+
+Use "godmode <api> --help" for API-specific usage.`);
+}
+function showApiHelp(manifest, apiName, path, filter, methodFilter, all) {
+  const root = buildTrie(manifest.routes);
+  const nav = navigateTrie(root, path);
+  if (!nav) {
+    console.log("No matching resource.");
+    return;
+  }
+  const { node, fullPath } = nav;
+  const actions = getNodeActions(node);
+  const param = getParamName(node);
+  const children = getChildren(node).filter((c) => !c.isParam);
+  const childNames = [...new Set(children.map((c) => c.name))];
+  const resourceName = fullPath.join(" ");
+  if (!path.length) {
+    const name = manifest.config.name || apiName;
+    const ver = manifest.specVersion ? ` \x1B[2mv${manifest.specVersion}\x1B[0m` : "";
+    const desc = manifest.description ? `
+\x1B[2m${manifest.description}\x1B[0m` : "";
+    console.log(`${name}${ver}${desc}
+`);
+    console.log(`Usage:
+  godmode ${apiName} <resource> [id] [flags]
+`);
+    const auth = manifest.config.auth;
+    if (auth?.env) {
+      const ok = !!process.env[auth.env];
+      const status = ok ? "\x1B[32m(token provided)\x1B[0m" : "\x1B[31m(missing token)\x1B[0m";
+      console.log(`${auth.env} ${status}
+`);
+    }
+  } else {
+    const paramHint = getParamName(node);
+    const idRef = paramHint ? ` [${paramHint}]` : "";
+    console.log(`Usage:
+  godmode ${apiName} ${resourceName}${idRef} [flags]
+`);
+    const auth = manifest.config.auth;
+    if (auth?.env) {
+      const ok = !!process.env[auth.env];
+      const status = ok ? "\x1B[32m(token provided)\x1B[0m" : "\x1B[31m(missing token)\x1B[0m";
+      console.log(`${auth.env} ${status}`);
+    }
+    for (const p of nav.params) {
+      const status = p.provided ? `\x1B[32m(${p.value})\x1B[0m` : "\x1B[31m(missing parameter)\x1B[0m";
+      console.log(`<${p.name}> ${status}`);
+    }
+    console.log("");
+    const mcpTools = manifest.config._mcpTools;
+    const mcpTool = mcpTools?.find((t) => t.name === path[path.length - 1]);
+    if (mcpTool?.inputSchema?.properties) {
+      const props = mcpTool.inputSchema.properties;
+      const required = new Set(mcpTool.inputSchema.required || []);
+      const toolName = mcpTool.name;
+      if (mcpTool.description) {
+        const first = mcpTool.description.split("\n")[0];
+        console.log(`${ITALIC}${first}${RESET}
+`);
+      }
+      console.log("Parameters:");
+      for (const [name, schema] of Object.entries(props)) {
+        const req = required.has(name) ? `\x1B[1;38;5;160m[REQUIRED]${RESET} ` : "";
+        const desc = schema.description ? `${DIM}${ITALIC}${schema.description}${RESET}` : "";
+        console.log(`  ${name.padEnd(28)}${req}${desc}`);
+      }
+      console.log("");
+      console.log(`Example:
+  godmode ${apiName} ${toolName} ${[...required].map((r) => `${r}=...`).join(" ")}`);
+      console.log("");
+    } else {
+      const order = ["get", "post", "put", "patch", "delete"];
+      const pc = node.children.find((c) => c.isParam);
+      const rows = [];
+      for (const ep of node.methods) {
+        rows.push({ method: ep.method, summary: ep.summary, needsId: false });
+      }
+      if (pc) {
+        for (const ep of pc.methods) {
+          rows.push({ method: ep.method, summary: ep.summary, needsId: true });
+        }
+      }
+      if (rows.length) {
+        const lastSeg = path[path.length - 1] || resourceName;
+        const base = lastSeg;
+        const lines = [];
+        for (const m of order) {
+          for (const r of rows.filter((r2) => r2.method === m)) {
+            const id = r.needsId ? ` <${pc.name}>` : "";
+            let suffix = "";
+            if (m === "post" || m === "put" || m === "patch") suffix = " key=val";
+            if (m === "delete") suffix = " -d";
+            const needsFlag = !r.needsId && m !== "get" && m !== "post" || r.needsId && m === "post";
+            const flag = needsFlag ? ` -${m === "post" ? "po" : m === "put" ? "pu" : m === "patch" ? "pa" : ""}` : "";
+            const cmd = `${base}${id}${suffix}${flag}`.trim();
+            lines.push({ cmd, label: METHOD_LABEL[m] || m, desc: r.summary || "" });
+          }
+        }
+        const maxCmd = Math.max(...lines.map((l) => l.cmd.length));
+        for (const l of lines) {
+          const desc = l.desc ? `  ${ITALIC}${l.desc}${RESET}` : "";
+          console.log(`  ${l.cmd.padEnd(maxCmd + 2)}${l.label}${desc}`);
+        }
+        console.log("");
+      }
+    }
+  }
+  if (childNames.length) {
+    const ALL_METHODS = ["get", "post", "put", "patch", "delete"];
+    const mf = methodFilter ? fuzzysort.go(methodFilter, ALL_METHODS)[0]?.target : void 0;
+    if (methodFilter && !mf) {
+      console.log(`
+No method matching "${methodFilter}".`);
+      return;
+    }
+    let candidates = mf ? childNames.filter((n) => {
+      const child = children.find((c) => c.name === n);
+      if (!child) return false;
+      const methods = /* @__PURE__ */ new Set();
+      for (const ep of child.methods) methods.add(ep.method);
+      const pc = child.children.find((c) => c.isParam);
+      if (pc) for (const ep of pc.methods) methods.add(ep.method);
+      return methods.has(mf);
+    }) : childNames;
+    const filtered = filter ? fuzzysort.go(filter, candidates).map((r) => r.target) : candidates;
+    const prefix = `godmode ${apiName}${resourceName ? " " + resourceName : ""}`;
+    const label = filter || mf ? `Resources${filter ? ` matching "${filter}"` : ""}${mf ? ` with ${mf.toUpperCase()}${methodFilter !== mf ? ` (matched "${methodFilter}")` : ""}` : ""}:` : "Resources:";
+    console.log(`
+${label}`);
+    if (!filtered.length) {
+      console.log("  No matches.");
+    } else {
+      const limit = filter || mf || all ? filtered.length : 5;
+      const shown = filtered.slice(0, limit);
+      const more = filtered.length - shown.length;
+      for (const n of shown) {
+        const child = children.find((c) => c.name === n);
+        const labels = child ? methodLabels(child) : "";
+        const subCount = child ? getChildren(child).filter((c) => !c.isParam).length : 0;
+        const sub = subCount ? `  ${DIM}(${subCount} sub)${RESET}` : "";
+        const rawDesc = manifest.resourceDescriptions[n] || "";
+        const truncated = rawDesc.length > 60 ? rawDesc.slice(0, 57) + "..." : rawDesc;
+        const descStr = truncated ? `  ${ITALIC}${truncated}${RESET}` : "";
+        console.log(`  ${n.padEnd(28)}${labels}${sub}${descStr}`);
+      }
+      if (more) {
+        console.log(`  \x1B[2m...${more} more \u2192 use --all, --filter or --method\x1B[0m`);
+      }
+    }
+    console.log(`
+Use "${prefix} <resource> --help" for more.`);
+  }
+}
+
+// src/index.ts
+loadEnv();
+async function main() {
+  const args = process.argv.slice(2);
+  if (!args.length || args.length === 1 && (args[0] === "-h" || args[0] === "--help")) {
+    showHelp();
+    return;
+  }
+  const cmd = args[0];
+  if (cmd === "create") {
+    const { configWizard } = await import("./prompt-DCFFOQ7K.js");
+    await configWizard();
+    return;
+  }
+  if (cmd === "add") {
+    const { runAdd } = await import("./add-ZRNIX6DM.js");
+    await runAdd(args.slice(1));
+    return;
+  }
+  if (cmd === "update") {
+    if (!args[1]) {
+      console.error("Usage: godmode update <name>");
+      process.exit(1);
+    }
+    await updateApi(args[1]);
+    return;
+  }
+  if (cmd === "remove") {
+    if (!args[1]) {
+      console.error("Usage: godmode remove <name>");
+      process.exit(1);
+    }
+    await removeApi(args[1]);
+    return;
+  }
+  if (cmd === "list") {
+    await listApis();
+    return;
+  }
+  if (cmd === "mcp") {
+    const { runMcp } = await import("./mcp-NZIEMQOM.js");
+    await runMcp(args.slice(1));
+    return;
+  }
+  const apiName = cmd;
+  const parsed = parseArgs(args.slice(1));
+  const manifest = await loadManifest(apiName);
+  if (parsed.help || !parsed.segments.length) {
+    showApiHelp(manifest, apiName, parsed.segments, parsed.filter, parsed.methodFilter, parsed.all);
+    return;
+  }
+  if (manifest.config.type === "graphql") {
+    const err = validateGraphQLFlags(parsed.method, parsed.query, parsed.body, apiName);
+    if (err) {
+      process.stderr.write(err + "\n");
+      process.exit(1);
+    }
+  }
+  if (manifest.config.type === "mcp") {
+    const err = validateMcpFlags(parsed.method, parsed.query);
+    if (err) {
+      process.stderr.write(err + "\n");
+      process.exit(1);
+    }
+    const result = await executeMcpTool(manifest.config, parsed.segments[0], parsed.body, {
+      verbose: parsed.verbose,
+      dryRun: parsed.dryRun
+    });
+    if (result) process.stdout.write(result + "\n");
+    return;
+  }
+  const query = parsed.query;
+  const hasBody = Object.keys(parsed.body).length > 0;
+  let body = hasBody ? JSON.stringify(parsed.body) : void 0;
+  if (!body && ["post", "put", "patch"].includes(parsed.method)) body = await readStdin();
+  if (parsed.segments[0]?.startsWith("/")) {
+    const rawPath = parsed.segments[0];
+    const syntheticRoute = { path: rawPath, method: parsed.method, summary: "", version: "", segments: [] };
+    await execute(manifest, { route: syntheticRoute, params: {} }, {
+      headers: parsed.headers,
+      query,
+      body,
+      token: parsed.token,
+      verbose: parsed.verbose,
+      dryRun: parsed.dryRun
+    });
+    return;
+  }
+  const match = matchRoute(manifest, parsed.segments, parsed.method);
+  if (!match) {
+    process.stderr.write(`No ${parsed.method.toUpperCase()} route matching: ${parsed.segments.join(" ")}
+`);
+    for (const m of ["get", "post", "put", "patch", "delete"]) {
+      if (m === parsed.method) continue;
+      const alt = matchRoute(manifest, parsed.segments, m);
+      if (alt) {
+        const flag = m === "delete" ? "-d" : `--${m}`;
+        process.stderr.write(`  try: godmode ${apiName} ${parsed.segments.join(" ")} ${flag}
+`);
+      }
+    }
+    const similar = suggestRoutes(manifest, parsed.segments).slice(0, 5);
+    if (similar.length) {
+      process.stderr.write("\nSimilar:\n");
+      const seen = /* @__PURE__ */ new Set();
+      for (const r of similar) {
+        const p = r.segments.map((s) => s.isParam ? `{${s.value}}` : s.value).join(" ");
+        if (seen.has(p)) continue;
+        seen.add(p);
+        process.stderr.write(`  ${p}
+`);
+      }
+    }
+    process.exit(1);
+  }
+  await execute(manifest, match, {
+    headers: parsed.headers,
+    query,
+    body,
+    token: parsed.token,
+    verbose: parsed.verbose,
+    dryRun: parsed.dryRun
+  });
+}
+main().catch((err) => {
+  process.stderr.write(`${err.message || err}
+`);
+  process.exit(1);
+});

package/dist/mcp-NZIEMQOM.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import {
+  GODMODE_HOME,
+  loadManifest
+} from "./chunk-FBMQ3AC4.js";
+import "./chunk-EHS56XXY.js";
+
+// src/commands/mcp.ts
+import { resolve } from "path";
+import { readFile } from "fs/promises";
+import { spawn } from "child_process";
+async function runMcp(args) {
+  const name = args[0];
+  if (!name || name === "--help" || name === "-h") {
+    console.log(`Serve a registered API as an MCP server over stdio.
+
+Usage:
+  godmode mcp <name> [options]
+
+Options:
+  --filter <text>             Fuzzy-filter routes by resource name
+  --method <method>           Filter by HTTP method (get, post, etc.)
+
+For package-based adapters, spawns the adapter's MCP server.
+For spec-based adapters, serves routes as MCP tools.`);
+    process.exit(name ? 0 : 1);
+  }
+  let filter;
+  let method;
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--filter" && args[i + 1]) filter = args[++i];
+    else if (args[i] === "--method" && args[i + 1]) method = args[++i];
+  }
+  const pkgName = name.startsWith("@") ? name : `@godmode-cli/${name}`;
+  const pkgDir = resolve(GODMODE_HOME, "node_modules", pkgName);
+  const mcpConfigPath = resolve(pkgDir, ".mcp.json");
+  try {
+    const mcpConfig = JSON.parse(await readFile(mcpConfigPath, "utf-8"));
+    const serverKey = Object.keys(mcpConfig.mcpServers)[0];
+    const server = mcpConfig.mcpServers[serverKey];
+    if (server.type === "stdio" && server.command) {
+      const child = spawn(server.command, server.args || [], {
+        stdio: "inherit",
+        cwd: pkgDir,
+        env: { ...process.env, ...server.env }
+      });
+      child.on("exit", (code) => process.exit(code ?? 0));
+      return;
+    }
+  } catch {
+  }
+  const manifest = await loadManifest(name);
+  const { serveMcp } = await import("./mcp-server.js");
+  await serveMcp(manifest, { filter, method });
+}
+export {
+  runMcp
+};