godmode 0.0.2 → 0.0.3

package/dist/chunk-ZTPILA7B.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+import {
+  BUILTINS
+} from "./chunk-KHFZI7IA.js";
+import {
+  DIM,
+  HelpPage,
+  ITALIC,
+  RED,
+  RESET,
+  USE_COLOR
+} from "./chunk-YDXTIN53.js";
+
+// 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 METHOD_LABEL = USE_COLOR ? {
+  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"
+} : { get: "GET", post: "POST", put: "PUT", patch: "PATCH", delete: "DELETE" };
+var INTERFACE_LABEL = {
+  api: "API",
+  graphql: "GraphQL",
+  mcp: "MCP",
+  skill: "Skill"
+};
+var titleCase = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+var ROOT_OPTION_ROWS = [
+  ["-v, --version", "output version information and exit"]
+];
+var INTERFACE_OPTION_ROWS = [
+  ["-H, --header <key:value>", "add a request header"],
+  ["-A, --all", "list all resources"],
+  ["-F, --filter <text>", "fuzzy-filter resources by name"],
+  ["-X, --method <verb>", "filter resources by HTTP method"],
+  ["-h, --help", "show help for this subcommand"],
+  ["-v, --version", "show extension spec versions"]
+];
+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(" ");
+}
+var RootHelp = class extends HelpPage {
+  tagline() {
+    return "A control surface of agentic I/O.";
+  }
+  usage() {
+    return [
+      "godmode <extension> [args]...",
+      "godmode <extension> <interface> [args]..."
+    ];
+  }
+  sections() {
+    return [
+      { title: "Built-in extensions:", rows: [...BUILTINS].map(([slug, b]) => [slug, b.description]) },
+      { title: "Options:", rows: ROOT_OPTION_ROWS }
+    ];
+  }
+  footer() {
+    return {
+      extras: [
+        'Run "godmode ext list" to see installed extensions.',
+        'Run "godmode <extension> --help" for extension-specific usage.'
+      ],
+      reportBugs: "https://github.com/tomsiwik/godmode/issues",
+      homepage: "https://godmode.so"
+    };
+  }
+};
+var ExtHelp = class extends HelpPage {
+  tagline() {
+    return "Install, inspect, and manage godmode extensions.";
+  }
+  usage() {
+    return ["godmode ext <command> [args]"];
+  }
+  sections() {
+    return [
+      { title: "Commands:", rows: [
+        ["install <name|folder>", "Install an extension"],
+        ["uninstall <name>", "Uninstall an extension"],
+        ["update <name>", "Re-fetch spec, rebuild routes"],
+        ["list", "Show installed extensions"],
+        ["create", "Interactive manifest wizard"]
+      ] },
+      { title: "Options:", rows: [
+        ["-g, --global", "Apply to ~/.godmode (default: <cwd>/.godmode)"]
+      ] }
+    ];
+  }
+};
+var ExtensionOverview = class extends HelpPage {
+  constructor(multi) {
+    super();
+    this.multi = multi;
+  }
+  multi;
+  title() {
+    return titleCase(this.multi.name || this.multi.slug);
+  }
+  usage() {
+    const declared = Object.keys(this.multi.interfaces);
+    const args = (iface) => iface === "mcp" ? " <tool> [args]" : iface === "graphql" ? " <query> [flags]" : " <method> <resource> [id] [flags]";
+    return declared.map((iface) => `godmode ${this.multi.slug} ${iface}${args(iface)}`);
+  }
+  sections() {
+    const declared = Object.keys(this.multi.interfaces);
+    return [
+      { title: "Interfaces:", rows: declared.map((iface) => {
+        const d = this.multi.interfaces[iface];
+        const url = d && "url" in d && d.url ? d.url : "(local)";
+        return [iface, url];
+      }) },
+      { title: "Options:", rows: [["-v, --version", "show extension spec versions"]] }
+    ];
+  }
+};
+var ExtensionVersionPage = class extends HelpPage {
+  constructor(multi) {
+    super();
+    this.multi = multi;
+  }
+  multi;
+  title() {
+    return titleCase(this.multi.name || this.multi.slug);
+  }
+  sections() {
+    const declared = Object.keys(this.multi.interfaces);
+    return [
+      { title: "", rows: declared.map((iface) => {
+        const d = this.multi.interfaces[iface];
+        return [iface, d?.specVersion || "(unversioned)"];
+      }) }
+    ];
+  }
+};
+var InterfaceHelp = class extends HelpPage {
+  constructor(manifest, apiName, rawPath = [], opts = {}) {
+    super();
+    this.manifest = manifest;
+    this.apiName = apiName;
+    this.opts = opts;
+    const HTTP_VERBS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+    const cleaned = [...rawPath];
+    while (cleaned.length && HTTP_VERBS.has(cleaned[cleaned.length - 1].toUpperCase())) {
+      cleaned.pop();
+    }
+    this.path = cleaned;
+  }
+  manifest;
+  apiName;
+  opts;
+  path;
+  get ifaceType() {
+    return this.manifest.config.type;
+  }
+  getNav() {
+    const root = buildTrie(this.manifest.routes);
+    return navigateTrie(root, this.path);
+  }
+  title() {
+    if (this.path.length) return null;
+    return `${titleCase(this.manifest.config.name || this.apiName)} ${INTERFACE_LABEL[this.ifaceType] || this.ifaceType}`;
+  }
+  authNote() {
+    const auth = this.manifest.config.auth;
+    if (!auth?.env) return null;
+    return {
+      env: auth.env,
+      authType: auth.type || "bearer",
+      present: !!process.env[auth.env]
+    };
+  }
+  usage() {
+    if (!this.path.length) {
+      const multi = this.opts.multi;
+      const declared = multi ? Object.keys(multi.interfaces) : [this.ifaceType];
+      const ordered = [this.ifaceType, ...declared.filter((k) => k !== this.ifaceType)];
+      const args = (iface) => iface === "mcp" ? " <tool> [args]" : iface === "graphql" ? " <query> [flags]" : " <method> <resource> [id] [flags]";
+      return ordered.map((iface) => `godmode ${this.apiName} ${iface}${args(iface)}`);
+    }
+    const nav = this.getNav();
+    if (!nav) return [];
+    const paramHint = getParamName(nav.node);
+    const idRef = paramHint ? ` [${paramHint}]` : "";
+    const methodSlot = this.ifaceType === "api" ? "<method> " : "";
+    return [`godmode ${this.apiName} ${this.ifaceType} ${methodSlot}${nav.fullPath.join(" ")}${idRef} [flags]`];
+  }
+  sections() {
+    const nav = this.getNav();
+    if (!nav) return [];
+    const sections = [];
+    if (!this.path.length) {
+      if (this.ifaceType === "api") {
+        const methodsPresent = new Set(this.manifest.routes.map((r) => r.method.toLowerCase()));
+        const METHOD_DESC = {
+          get: "retrieve a resource",
+          post: "create a resource or send a command",
+          put: "replace a resource",
+          patch: "modify a resource",
+          delete: "remove a resource",
+          head: "retrieve headers only"
+        };
+        const order = ["get", "post", "put", "patch", "delete", "head"];
+        const methodsHere = order.filter((m) => methodsPresent.has(m));
+        if (methodsHere.length) {
+          sections.push({
+            title: "Methods:",
+            rows: methodsHere.map((m) => [METHOD_LABEL[m] || m.toUpperCase(), METHOD_DESC[m]])
+          });
+        }
+      }
+    } else {
+      const mcpTools = this.manifest.config._mcpTools;
+      const mcpTool = mcpTools?.find((t) => t.name === this.path[this.path.length - 1]);
+      if (mcpTool?.inputSchema?.properties) {
+        const props = mcpTool.inputSchema.properties;
+        const required = new Set(mcpTool.inputSchema.required || []);
+        const rows = [];
+        for (const [name, schema] of Object.entries(props)) {
+          const req = required.has(name) ? `${RED}[REQUIRED]${RESET}` : "";
+          const desc = schema.description ? `${ITALIC}${schema.description}${RESET}` : "";
+          rows.push([name, req, desc]);
+        }
+        sections.push({ title: "Parameters:", rows });
+      } else {
+        const order = ["get", "post", "put", "patch", "delete"];
+        const pc = nav.node.children.find((c) => c.isParam);
+        const items = [];
+        for (const ep of nav.node.methods) items.push({ method: ep.method, summary: ep.summary, needsId: false });
+        if (pc) for (const ep of pc.methods) items.push({ method: ep.method, summary: ep.summary, needsId: true });
+        if (items.length) {
+          const rows = [];
+          for (const m of order) {
+            for (const r of items.filter((r2) => r2.method === m)) {
+              const label = METHOD_LABEL[m] || m.toUpperCase();
+              const idArg = r.needsId ? `<${pc.name}>` : "";
+              const desc = r.summary ? `${ITALIC}${r.summary}${RESET}` : "";
+              rows.push([label, idArg, desc]);
+            }
+          }
+          sections.push({ title: "Methods:", rows });
+        }
+      }
+    }
+    const children = getChildren(nav.node).filter((c) => !c.isParam);
+    const childNames = [...new Set(children.map((c) => c.name))];
+    const resourceSection = buildResourceSection(
+      children,
+      childNames,
+      this.manifest,
+      this.opts.filter,
+      this.opts.methodFilter,
+      this.opts.all
+    );
+    if (resourceSection) sections.push(resourceSection.section);
+    sections.push({ title: "Options:", rows: INTERFACE_OPTION_ROWS });
+    return sections;
+  }
+  /** Drilled-in view also shows param status lines (ANSI-only). */
+  render() {
+    super.render();
+  }
+};
+function showHelp() {
+  new RootHelp().render();
+}
+function showExtHelp() {
+  new ExtHelp().render();
+}
+function showExtensionOverview(multi) {
+  new ExtensionOverview(multi).render();
+}
+function showExtensionVersion(multi) {
+  new ExtensionVersionPage(multi).render();
+}
+function showApiHelp(manifest, apiName, path, filter, methodFilter, all, multi) {
+  new InterfaceHelp(manifest, apiName, path, { multi, filter, methodFilter, all }).render();
+}
+async function showVersion() {
+  const { readFile } = await import("fs/promises");
+  const { resolve, dirname } = await import("path");
+  const { fileURLToPath } = await import("url");
+  const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  const pkg = JSON.parse(await readFile(resolve(root, "package.json"), "utf-8"));
+  const license = await readFile(resolve(root, "LICENSE"), "utf-8");
+  const copyright = license.match(/^Copyright.*$/m)?.[0] ?? "";
+  console.log(`godmode ${pkg.version}
+
+${pkg.license} License
+${copyright}`);
+}
+function buildResourceSection(children, childNames, manifest, filter, methodFilter, all) {
+  if (!childNames.length) return null;
+  const ALL_METHODS = ["get", "post", "put", "patch", "delete"];
+  const mf = methodFilter ? fuzzysort.go(methodFilter, ALL_METHODS)[0]?.target : void 0;
+  if (methodFilter && !mf) return null;
+  const 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 title = filter || mf ? `Resources${filter ? ` matching "${filter}"` : ""}${mf ? ` with ${mf.toUpperCase()}` : ""}:` : "Resources:";
+  if (!filtered.length) return { section: { title, rows: [["  No matches.", ""]] } };
+  const limit = filter || mf || all ? filtered.length : 5;
+  const shown = filtered.slice(0, limit);
+  const more = filtered.length - shown.length;
+  const rows = [];
+  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 ? `(${subCount} sub)` : "";
+    const rawDesc = manifest.resourceDescriptions[n] || "";
+    const desc = rawDesc ? `${ITALIC}${rawDesc}${RESET}` : "";
+    const parts = [labels, sub, desc].filter(Boolean);
+    rows.push([n, parts.join("  ")]);
+  }
+  if (more) {
+    const verb = mf ? ` ${mf.toUpperCase()}` : "";
+    const hintText = `${more} more${verb} resources. Use options to display more`;
+    const dots = USE_COLOR ? `${DIM}...${RESET}` : "...";
+    const body = USE_COLOR ? `${DIM}${hintText}${RESET}` : hintText;
+    rows.push([dots, body]);
+  }
+  return { section: { title, rows } };
+}
+
+export {
+  showHelp,
+  showExtHelp,
+  showExtensionOverview,
+  showExtensionVersion,
+  showApiHelp,
+  showVersion
+};