godmode 0.0.2 → 0.0.3

package/dist/chunk-SMQBMG24.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+// src/settings.ts
+import { resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { parse as parseYaml } from "yaml";
+function findProjectGodmode(start = process.cwd()) {
+  let dir = resolve(start);
+  while (true) {
+    const candidate = resolve(dir, ".godmode");
+    if (existsSync(candidate)) return candidate;
+    const parent = resolve(dir, "..");
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readSettingsFile(path) {
+  if (!existsSync(path)) return { settings: {} };
+  try {
+    const raw = parseYaml(readFileSync(path, "utf-8"));
+    return { settings: raw ?? {} };
+  } catch (e) {
+    const msg = e.message || String(e);
+    return { settings: {}, error: { path, message: msg } };
+  }
+}
+function mergePermissions(base = {}, overlay = {}) {
+  const allow = [...base.allow ?? [], ...overlay.allow ?? []];
+  const deny = [...base.deny ?? [], ...overlay.deny ?? []];
+  if (!allow.length && !deny.length) return void 0;
+  const merged = {};
+  if (allow.length) merged.allow = allow;
+  if (deny.length) merged.deny = deny;
+  return merged;
+}
+function mergeExtension(base = {}, overlay = {}) {
+  const merged = { ...base, ...overlay };
+  const permissions = mergePermissions(base.permissions, overlay.permissions);
+  if (permissions) merged.permissions = permissions;
+  return merged;
+}
+function mergeSettings(base, overlay) {
+  const extensions = {};
+  const slugs = /* @__PURE__ */ new Set([
+    ...Object.keys(base.extensions ?? {}),
+    ...Object.keys(overlay.extensions ?? {})
+  ]);
+  for (const slug of slugs) {
+    extensions[slug] = mergeExtension(
+      base.extensions?.[slug],
+      overlay.extensions?.[slug]
+    );
+  }
+  return { extensions };
+}
+var cached = null;
+function loadSettingsDetailed() {
+  if (cached) return cached;
+  const globalPath = resolve(homedir(), ".godmode", "settings.yaml");
+  const projectRoot = findProjectGodmode();
+  const projectPath = projectRoot ? resolve(projectRoot, "settings.yaml") : null;
+  const globalResult = readSettingsFile(globalPath);
+  const projectResult = projectPath ? readSettingsFile(projectPath) : { settings: {} };
+  const sources = [];
+  if (existsSync(globalPath)) sources.push({ scope: "global", path: globalPath, settings: globalResult.settings });
+  if (projectPath && existsSync(projectPath)) sources.push({ scope: "project", path: projectPath, settings: projectResult.settings });
+  cached = {
+    settings: mergeSettings(globalResult.settings, projectResult.settings),
+    errors: [globalResult.error, projectResult.error].filter(Boolean),
+    sources
+  };
+  return cached;
+}
+function loadSettings() {
+  return loadSettingsDetailed().settings;
+}
+function settingsErrorMessage(error) {
+  return `cannot parse ${error.path}: ${error.message} - refusing to run with an unreadable policy.`;
+}
+function warnSettingsErrors() {
+  for (const error of loadSettingsDetailed().errors) {
+    process.stderr.write(`Warning: ${settingsErrorMessage(error)}
+`);
+  }
+}
+function resetSettingsCache() {
+  cached = null;
+}
+function extensionSettings(slug) {
+  const s = loadSettings();
+  return s.extensions?.[slug] ?? {};
+}
+
+export {
+  loadSettingsDetailed,
+  loadSettings,
+  settingsErrorMessage,
+  warnSettingsErrors,
+  resetSettingsCache,
+  extensionSettings
+};

package/dist/chunk-XFFBFBN6.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+// src/exit-codes.ts
+var EXIT_CODES = {
+  success: 0,
+  usage: 2,
+  notFound: 3,
+  permissionDenied: 4,
+  upstream4xx: 10,
+  upstream5xx: 11,
+  upstream: 12
+};
+
+export {
+  EXIT_CODES
+};

package/dist/chunk-YDXTIN53.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+// ../cli-tools/src/auth.ts
+var AuthStrategy = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  config;
+  static for(config) {
+    const type = config?.type ?? "bearer";
+    switch (type) {
+      case "bearer":
+        return new BearerAuth(config ?? {});
+      case "api-key":
+        return new ApiKeyAuth(config ?? {});
+      case "basic":
+        return new BasicAuth(config ?? {});
+    }
+  }
+};
+var BearerAuth = class extends AuthStrategy {
+  label = "bearer";
+  apply(headers, token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  missingMessage() {
+    return "missing bearer token";
+  }
+};
+var ApiKeyAuth = class extends AuthStrategy {
+  label = "api-key";
+  apply(headers, token) {
+    headers[this.config.header || "X-API-Key"] = token;
+  }
+  missingMessage() {
+    return "missing api-key";
+  }
+};
+var BasicAuth = class extends AuthStrategy {
+  label = "basic";
+  apply(headers, token) {
+    headers["Authorization"] = `Basic ${token}`;
+  }
+  missingMessage() {
+    return "missing basic auth credentials";
+  }
+};
+
+// ../cli-tools/src/index.ts
+var USE_COLOR = process.stdout.isTTY;
+var DIM = USE_COLOR ? "\x1B[2m" : "";
+var ITALIC = USE_COLOR ? "\x1B[3m" : "";
+var RESET = USE_COLOR ? "\x1B[0m" : "";
+var RED = USE_COLOR ? "\x1B[31m" : "";
+function visibleLength(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function wrapText(text, width) {
+  if (text.length <= width) return [text];
+  const out = [];
+  let line = "";
+  for (const word of text.split(/\s+/)) {
+    if (!line) {
+      line = word;
+      continue;
+    }
+    if (line.length + 1 + word.length <= width) {
+      line += " " + word;
+    } else {
+      out.push(line);
+      line = word;
+    }
+  }
+  if (line) out.push(line);
+  return out;
+}
+function renderSections(sections, maxLineWidth = 80) {
+  const INDENT = "  ";
+  const GAP = "  ";
+  const flattened = sections.map((s) => {
+    if (!s.rows.length) return { title: s.title, rows: [] };
+    const cols = Math.max(...s.rows.map((r) => r.length));
+    const widths = Array(cols).fill(0);
+    for (const row of s.rows) {
+      for (let i = 0; i < cols; i++) {
+        widths[i] = Math.max(widths[i], visibleLength(row[i] ?? ""));
+      }
+    }
+    const rows = s.rows.map((row) => {
+      const left = row.slice(0, cols - 1).map((cell, i) => (cell ?? "") + " ".repeat(widths[i] - visibleLength(cell ?? ""))).join(GAP).replace(/\s+$/, "");
+      const desc = row[cols - 1] ?? "";
+      return [left, desc];
+    });
+    return { title: s.title, rows };
+  });
+  const allRows = flattened.flatMap((s) => s.rows);
+  if (!allRows.length) return;
+  const rowsWithDesc = allRows.filter((r) => r[1].length > 0);
+  const widthCandidates = (rowsWithDesc.length ? rowsWithDesc : allRows).map((r) => visibleLength(r[0]));
+  const globalLeft = Math.max(...widthCandidates);
+  const descBudget = Math.max(20, maxLineWidth - INDENT.length - globalLeft - GAP.length);
+  for (const s of flattened) {
+    if (!s.rows.length) continue;
+    if (s.title) {
+      console.log("");
+      console.log(s.title);
+    }
+    for (const [left, desc] of s.rows) {
+      const pad = " ".repeat(Math.max(0, globalLeft - visibleLength(left)));
+      const plain = desc.replace(/\x1b\[[0-9;]*m/g, "");
+      if (!plain) {
+        console.log(`${INDENT}${left}${pad}`.trimEnd());
+        continue;
+      }
+      if (plain.length <= descBudget) {
+        console.log(`${INDENT}${left}${pad}${GAP}${desc}`);
+        continue;
+      }
+      const italic = /^\x1b\[3m/.test(desc);
+      const wrap = (s2) => italic ? `${ITALIC}${s2}${RESET}` : s2;
+      const lines = wrapText(plain, Math.max(10, descBudget));
+      console.log(`${INDENT}${left}${pad}${GAP}${wrap(lines[0])}`);
+      for (let i = 1; i < lines.length; i++) {
+        console.log(`${INDENT}${" ".repeat(Math.max(0, globalLeft))}${GAP}${wrap(lines[i])}`);
+      }
+    }
+  }
+}
+function authMissingLabel(type) {
+  return AuthStrategy.for({ type }).missingMessage();
+}
+var HelpPage = class {
+  title() {
+    return null;
+  }
+  tagline() {
+    return null;
+  }
+  authNote() {
+    return null;
+  }
+  usage() {
+    return [];
+  }
+  sections() {
+    return [];
+  }
+  footer() {
+    return null;
+  }
+  toJSON() {
+    return {
+      title: this.title(),
+      tagline: this.tagline(),
+      authNote: this.authNote(),
+      usage: this.usage(),
+      sections: this.sections(),
+      footer: this.footer()
+    };
+  }
+  render() {
+    const d = this.toJSON();
+    let wrote = false;
+    if (d.title) {
+      console.log(d.title);
+      wrote = true;
+    }
+    if (d.tagline) {
+      if (wrote) console.log("");
+      console.log(d.tagline);
+      wrote = true;
+    }
+    if (d.authNote && !d.authNote.present) {
+      const arrow = USE_COLOR ? `${RED}-->${RESET}` : "-->";
+      const label = authMissingLabel(d.authNote.authType);
+      const body = USE_COLOR ? `${RED}${label}${RESET}` : label;
+      if (wrote) console.log("");
+      console.log(`${arrow} ${d.authNote.env}: ${body}`);
+      wrote = true;
+    }
+    if (d.usage.length) {
+      if (wrote) console.log("");
+      for (let i = 0; i < d.usage.length; i++) {
+        const prefix = i === 0 ? "Usage:" : "   or:";
+        console.log(`${prefix} ${d.usage[i]}`);
+      }
+      wrote = true;
+    }
+    renderSections(d.sections);
+    if (d.footer) {
+      if (d.footer.extras?.length) {
+        console.log("");
+        for (const line of d.footer.extras) console.log(line);
+      }
+      if (d.footer.reportBugs || d.footer.homepage) {
+        console.log("");
+        if (d.footer.reportBugs) console.log(`Report bugs to <${d.footer.reportBugs}>.`);
+        if (d.footer.homepage) console.log(`Godmode home page: <${d.footer.homepage}>.`);
+      }
+    }
+  }
+};
+
+export {
+  AuthStrategy,
+  USE_COLOR,
+  DIM,
+  ITALIC,
+  RESET,
+  RED,
+  HelpPage
+};