@baseworks/cli 0.2.0

package/dist/args.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Lightweight arg/flag parser for Node CLI binaries.
+ *
+ * Supports:
+ *   --flag          → { flag: true }
+ *   --flag value    → { flag: 'value' }
+ *   --flag=value    → { flag: 'value' }
+ *   positional args → args[]
+ *
+ * Usage:
+ *   const { args, flags } = parseFlags(process.argv.slice(2));
+ *   if (flags.json) { ... }
+ *   const [ws, proj] = args;
+ */
+interface ParsedArgs {
+    /** Positional (non-flag) arguments in order. */
+    args: string[];
+    /** Parsed flags. Values are string if the flag had a value, true if bare. */
+    flags: Record<string, string | boolean>;
+}
+declare function parseFlags(argv: string[]): ParsedArgs;
+/** Returns true if --json or -j flag is present in process.argv. */
+declare function isJsonMode(argv?: string[]): boolean;
+/**
+ * Extract a named flag value from argv.
+ *   getFlag(process.argv, '--public-key')  → string | undefined
+ */
+declare function getFlag(argv: string[], flag: string): string | undefined;
+
+export { type ParsedArgs, getFlag, isJsonMode, parseFlags };

package/dist/args.js

@@ -0,0 +1,10 @@
+import {
+  getFlag,
+  isJsonMode,
+  parseFlags
+} from "./chunk-H4M2NPA2.js";
+export {
+  getFlag,
+  isJsonMode,
+  parseFlags
+};

package/dist/chunk-5U3CFW6F.js

@@ -0,0 +1,26 @@
+import {
+  clr
+} from "./chunk-C2YZKMJ7.js";
+
+// src/tree.ts
+function tree(nodes, prefix = "") {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const last = i === nodes.length - 1;
+    const isRoot = prefix === "";
+    const connector = isRoot ? "" : last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childPfx = isRoot ? last ? "    " : "\u2502   " : prefix + (last ? "    " : "\u2502   ");
+    const badge = node.badge ? node.badge + " " : "";
+    const meta = node.meta ? `  ${clr.dim}${node.meta}${clr.reset}` : "";
+    console.log(
+      `${clr.dim}${prefix}${connector}${clr.reset}${badge}${clr.bold}${node.label}${clr.reset}${meta}`
+    );
+    if (node.children?.length) {
+      tree(node.children, childPfx);
+    }
+  }
+}
+
+export {
+  tree
+};

package/dist/chunk-BEHHVEGL.js

@@ -0,0 +1,17 @@
+// src/config-loader.ts
+function resolveToken(cfg, opts = {}) {
+  return cfg.token ?? (opts.env ? process.env[opts.env] : void 0);
+}
+function resolveApiBase(cfg, opts = {}) {
+  const raw = cfg.apiBase ?? (opts.env ? process.env[opts.env] : void 0) ?? opts.default ?? "";
+  return raw.replace(/\/$/, "");
+}
+function resolveField(cfg, key, opts = {}) {
+  return cfg[key] ?? (opts.env ? process.env[opts.env] : void 0) ?? opts.default;
+}
+
+export {
+  resolveToken,
+  resolveApiBase,
+  resolveField
+};

package/dist/chunk-C2YZKMJ7.js

@@ -0,0 +1,185 @@
+// src/display.ts
+import { createInterface } from "readline";
+var isTTY = typeof process !== "undefined" && process.stdout?.isTTY;
+var clr = {
+  reset: isTTY ? "\x1B[0m" : "",
+  bold: isTTY ? "\x1B[1m" : "",
+  dim: isTTY ? "\x1B[2m" : "",
+  green: isTTY ? "\x1B[32m" : "",
+  yellow: isTTY ? "\x1B[33m" : "",
+  cyan: isTTY ? "\x1B[36m" : "",
+  red: isTTY ? "\x1B[31m" : ""
+};
+function truncateId(id, n = 8) {
+  if (!id || id.length <= n + 1) return id;
+  const isUuid = /^[0-9a-f]{8}-/i.test(id);
+  return isUuid ? id.slice(0, n) + "\u2026" : id;
+}
+function statusColor(status) {
+  const s = status.toLowerCase();
+  if (["active", "succeeded", "paid", "completed"].includes(s))
+    return `${clr.green}${status}${clr.reset}`;
+  if (["canceled", "cancelled", "failed", "expired", "revoked"].includes(s))
+    return `${clr.dim}${status}${clr.reset}`;
+  if (["trialing", "past_due", "pending", "draft"].includes(s))
+    return `${clr.yellow}${status}${clr.reset}`;
+  return status;
+}
+function summary(text) {
+  console.log(`  ${clr.dim}${text}${clr.reset}`);
+}
+function visibleLength(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function padEnd(str, width) {
+  return str + " ".repeat(Math.max(0, width - visibleLength(str)));
+}
+function table(rows, cols, opts = {}) {
+  const isWide = opts.wide ?? (process.argv.includes("--detail") || process.argv.includes("-d") || process.argv.includes("-o") && process.argv[process.argv.indexOf("-o") + 1] === "wide" || process.argv.includes("--output") && process.argv[process.argv.indexOf("--output") + 1] === "wide");
+  const visibleCols = cols.filter((c) => !c.wide && !c.detail || isWide);
+  if (!rows.length) {
+    const msg = opts.emptyHint ?? "(none)";
+    console.log(`  ${clr.dim}${msg}${clr.reset}`);
+    return;
+  }
+  const widths = visibleCols.map((col, i) => {
+    const labelLen = col.label.length;
+    const maxVal = Math.max(...rows.map((r) => visibleLength(String(col.fmt ? col.fmt(r[col.key], r) : r[col.key] ?? "\u2014"))));
+    return Math.max(labelLen, maxVal, i);
+  });
+  console.log("");
+  const header = visibleCols.map(
+    (col, i) => padEnd(`${clr.bold}${clr.dim}${col.label}${clr.reset}`, widths[i] ?? col.label.length)
+  ).join("  ");
+  console.log("  " + header);
+  console.log("  " + widths.map((w) => "\u2500".repeat(w)).join("  "));
+  for (const row of rows) {
+    const line = visibleCols.map((col, i) => {
+      const val = col.fmt ? col.fmt(row[col.key], row) : row[col.key] ?? "\u2014";
+      return padEnd(String(val), widths[i] ?? 0);
+    }).join("  ");
+    console.log("  " + line);
+  }
+  console.log("");
+}
+function kv(pairs) {
+  const w = Math.max(...pairs.map(([k]) => k.length));
+  for (const [k, v] of pairs) {
+    console.log(`  ${clr.dim}${k.padEnd(w)}${clr.reset}  ${v}`);
+  }
+}
+function success(msg) {
+  console.log(`${clr.green}\u2713${clr.reset} ${msg}`);
+}
+function warn(msg) {
+  console.warn(`${clr.yellow}\u26A0${clr.reset}  ${msg}`);
+}
+function fatal(msg) {
+  console.error(`${clr.red}error:${clr.reset} ${msg}`);
+  process.exit(1);
+  throw new Error(msg);
+}
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(question, (ans) => {
+      rl.close();
+      resolve(ans.trim());
+    });
+  });
+}
+function helpFor(cmdName, args, flags, helpMap) {
+  if (!flags["help"] && !flags["h"]) return false;
+  const key = args.join(" ").trim();
+  const text = (key && helpMap[key]) ?? helpMap[""] ?? null;
+  if (text) {
+    console.log(text);
+  } else {
+    const lines = Object.entries(helpMap).filter(([k]) => k !== "").map(([k, v]) => `  ${cmdName} ${k.padEnd(28)}${v.split("\n")[0]}`);
+    console.log(`
+${clr.bold}${cmdName}${clr.reset}
+
+${lines.join("\n")}
+`);
+  }
+  return true;
+}
+function printOrJson(data, textFn, argv = process.argv) {
+  if (argv.includes("--json") || argv.includes("-j")) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    textFn();
+  }
+}
+function printOutput(data, format, renderFn, codeKey) {
+  const fmt = format ?? "table";
+  switch (fmt) {
+    case "json":
+      console.log(JSON.stringify(data, null, 2));
+      break;
+    case "yaml": {
+      const toYaml = (v, indent = 0) => {
+        const pad = " ".repeat(indent);
+        if (v === null || v === void 0) return "null";
+        if (typeof v === "string") return /[:\n#{}[\],&*?|<>=!%@`]/.test(v) ? `"${v.replace(/"/g, '\\"')}"` : v;
+        if (typeof v === "number" || typeof v === "boolean") return String(v);
+        if (Array.isArray(v)) {
+          if (v.length === 0) return "[]";
+          return v.map((item) => `${pad}- ${toYaml(item, indent + 2).trimStart()}`).join("\n");
+        }
+        if (typeof v === "object") {
+          return Object.entries(v).map(([k, val]) => {
+            const rendered = toYaml(val, indent + 2);
+            return typeof val === "object" && val !== null && !Array.isArray(val) ? `${pad}${k}:
+${rendered}` : `${pad}${k}: ${rendered}`;
+          }).join("\n");
+        }
+        return String(v);
+      };
+      console.log(toYaml(data));
+      break;
+    }
+    case "code": {
+      const items = Array.isArray(data) ? data : [data];
+      for (const item of items) {
+        let code;
+        if (typeof codeKey === "function") {
+          code = codeKey(item);
+        } else if (codeKey && item[codeKey] != null) {
+          code = String(item[codeKey]);
+        } else {
+          code = String(item["slug"] ?? item["code"] ?? item["short_id"] ?? item["id"] ?? "");
+        }
+        if (code) console.log(code);
+      }
+      break;
+    }
+    case "wide":
+      renderFn(true);
+      break;
+    case "table":
+    default:
+      renderFn(false);
+      break;
+  }
+}
+function outputOption() {
+  return ["-o, --output <format>", "Output format: table|wide|json|yaml|code", "table"];
+}
+
+export {
+  clr,
+  truncateId,
+  statusColor,
+  summary,
+  table,
+  kv,
+  success,
+  warn,
+  fatal,
+  prompt,
+  helpFor,
+  printOrJson,
+  printOutput,
+  outputOption
+};

package/dist/chunk-H4M2NPA2.js

@@ -0,0 +1,46 @@
+// src/args.ts
+function parseFlags(argv) {
+  const args = [];
+  const flags = {};
+  let i = 0;
+  while (i < argv.length) {
+    const token = argv[i];
+    if (token.startsWith("--")) {
+      const eqIdx = token.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = token.slice(2, eqIdx);
+        const val = token.slice(eqIdx + 1);
+        flags[key] = val;
+      } else {
+        const key = token.slice(2);
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("--")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      }
+    } else if (token.startsWith("-") && token.length === 2) {
+      flags[token.slice(1)] = true;
+    } else {
+      args.push(token);
+    }
+    i++;
+  }
+  return { args, flags };
+}
+function isJsonMode(argv = process.argv) {
+  return argv.includes("--json") || argv.includes("-j");
+}
+function getFlag(argv, flag) {
+  const i = argv.indexOf(flag);
+  if (i === -1) return void 0;
+  return argv[i + 1];
+}
+
+export {
+  parseFlags,
+  isJsonMode,
+  getFlag
+};

package/dist/chunk-HJFKWDPX.js

@@ -0,0 +1,40 @@
+import {
+  clr
+} from "./chunk-C2YZKMJ7.js";
+
+// src/fmt.ts
+function fmtDate(val) {
+  if (val === null || val === void 0) return `${clr.dim}\u2014${clr.reset}`;
+  const d = typeof val === "number" ? new Date(val) : new Date(val);
+  if (isNaN(d.getTime())) return `${clr.dim}\u2014${clr.reset}`;
+  return `${clr.dim}${d.toISOString().slice(0, 10)}${clr.reset}`;
+}
+function fmtRole(role) {
+  if (role === "owner") return `${clr.cyan}owner${clr.reset}`;
+  if (role === "admin") return `${clr.yellow}admin${clr.reset}`;
+  if (role === "member") return "member";
+  return `${clr.dim}${role ?? "\u2014"}${clr.reset}`;
+}
+function fmtStatus(revokedAt) {
+  return revokedAt ? `${clr.dim}revoked${clr.reset}` : `${clr.green}active${clr.reset}`;
+}
+function fmtBool(val) {
+  return val ? `${clr.green}yes${clr.reset}` : `${clr.dim}no${clr.reset}`;
+}
+function fmtCount(n) {
+  if (!n) return `${clr.dim}0${clr.reset}`;
+  return String(n);
+}
+function fmtId(id) {
+  if (!id) return `${clr.dim}\u2014${clr.reset}`;
+  return `${clr.dim}${id}${clr.reset}`;
+}
+
+export {
+  fmtDate,
+  fmtRole,
+  fmtStatus,
+  fmtBool,
+  fmtCount,
+  fmtId
+};

package/dist/chunk-LQJTQ52B.js

@@ -0,0 +1,98 @@
+import {
+  confirmDestructive,
+  requiresContext,
+  requiresToken
+} from "./chunk-TSVJD4R6.js";
+import {
+  parseFlags
+} from "./chunk-H4M2NPA2.js";
+import {
+  fatal
+} from "./chunk-C2YZKMJ7.js";
+import {
+  createApiClient
+} from "./chunk-XQGLG3X3.js";
+
+// src/runner.ts
+function createCliRunner(config) {
+  const allCommands = {};
+  const allAliases = {};
+  const helpSections = [];
+  let activeHooks = {};
+  return {
+    register(plugin) {
+      for (const [name, cmd] of Object.entries(plugin.commands)) {
+        allCommands[name] = cmd;
+      }
+      for (const [alias, target] of Object.entries(plugin.aliases ?? {})) {
+        allAliases[alias] = target;
+      }
+      if (plugin.helpText) helpSections.push(plugin.helpText);
+    },
+    hooks(h) {
+      activeHooks = { ...activeHooks, ...h };
+    },
+    async run(argv) {
+      const { args: topArgs, flags: topFlags } = parseFlags(argv);
+      if (topFlags["version"] || topFlags["v"]) {
+        return;
+      }
+      const rawCmd = topArgs[0];
+      const globalHelp = !rawCmd || argv[0] === "--help" || argv[0] === "-h";
+      if (globalHelp) {
+        console.log(helpSections.join("\n"));
+        return;
+      }
+      const cmdName = allAliases[rawCmd] ?? rawCmd;
+      const cmd = allCommands[cmdName];
+      if (!cmd) {
+        fatal(`Unknown command: ${rawCmd}. Run with --help for usage.`);
+      }
+      const rawIdx = argv.indexOf(rawCmd);
+      const restArgv = argv.slice(rawIdx + 1);
+      const { args, flags } = parseFlags(restArgv);
+      const deps = {
+        argv: restArgv,
+        args,
+        flags,
+        http: createApiClient(config.getToken, config.getApiBase),
+        ctx: config.ctx,
+        appBase: config.appBase,
+        token: config.getToken()
+      };
+      await activeHooks.beforeCommand?.(cmdName, deps);
+      const t0 = Date.now();
+      try {
+        await executeCommand(cmd, deps);
+        await activeHooks.afterCommand?.(cmdName, deps, Date.now() - t0);
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        if (activeHooks.onError) {
+          await activeHooks.onError(cmdName, err, deps);
+        } else {
+          fatal(err.message);
+        }
+      }
+    }
+  };
+}
+async function executeCommand(cmd, deps) {
+  const chain = [];
+  if (cmd.requiresToken !== false) chain.push(requiresToken());
+  if (cmd.requiresContext) chain.push(requiresContext());
+  if (cmd.confirm) chain.push(confirmDestructive(cmd.confirm));
+  if (cmd.middleware?.length) chain.push(...cmd.middleware);
+  let i = 0;
+  const next = async () => {
+    if (i < chain.length) {
+      await chain[i++](deps, next);
+    } else {
+      await cmd.fn(deps);
+    }
+  };
+  await next();
+}
+
+export {
+  createCliRunner
+};

package/dist/chunk-TSVJD4R6.js

@@ -0,0 +1,51 @@
+import {
+  fatal,
+  prompt,
+  warn
+} from "./chunk-C2YZKMJ7.js";
+
+// src/middleware.ts
+function requiresToken() {
+  return async (deps, next) => {
+    if (!deps.token) {
+      fatal("No API token found. Run: login");
+    }
+    await next();
+  };
+}
+function requiresContext() {
+  return async (deps, next) => {
+    const ctx = deps.ctx.getContext();
+    if (!ctx) {
+      fatal("No active context. Set one with: use <org>");
+    }
+    deps.context = ctx;
+    await next();
+  };
+}
+function confirmDestructive(message) {
+  return async (deps, next) => {
+    if (deps.flags["yes"] || deps.flags["y"]) {
+      await next();
+      return;
+    }
+    const isTTY = Boolean(process.stdin.isTTY);
+    if (!isTTY) {
+      fatal(`Destructive operation requires confirmation. Re-run with --yes to proceed.
+  ${message}`);
+    }
+    warn(message);
+    const answer = await prompt("Continue? (y/N) ");
+    if (answer.toLowerCase() !== "y") {
+      console.log("Aborted.");
+      process.exit(0);
+    }
+    await next();
+  };
+}
+
+export {
+  requiresToken,
+  requiresContext,
+  confirmDestructive
+};

package/dist/chunk-XQGLG3X3.js

@@ -0,0 +1,54 @@
+// src/client.ts
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+};
+function createApiClient(getToken, getApiBase, getExtraHeaders) {
+  async function api(method, path, body, extra = {}) {
+    const token = getToken();
+    const base = getApiBase().replace(/\/$/, "");
+    const headers = {
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...body !== void 0 ? { "Content-Type": "application/json" } : {},
+      ...getExtraHeaders ? getExtraHeaders() : {},
+      ...extra
+      // per-call headers override defaults
+    };
+    const res = await fetch(`${base}${path}`, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (res.status === 204) return null;
+    const text = await res.text();
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      if (!res.ok) throw new ApiError(res.status, "parse_error", `${res.status}: ${text}`);
+      return text;
+    }
+    if (!res.ok) {
+      const err = data;
+      const code = err?.error?.code ?? "unknown";
+      const msg = err?.error?.message ?? res.statusText;
+      throw new ApiError(res.status, code, `${res.status} ${code}: ${msg}`);
+    }
+    return data;
+  }
+  return {
+    api,
+    get: (path, h) => api("GET", path, void 0, h),
+    post: (path, body, h) => api("POST", path, body, h),
+    patch: (path, body, h) => api("PATCH", path, body, h),
+    del: (path, h) => api("DELETE", path, void 0, h)
+  };
+}
+
+export {
+  ApiError,
+  createApiClient
+};

package/dist/chunk-ZD7NOFZL.js

@@ -0,0 +1,59 @@
+// src/context.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function createContextManager(appName) {
+  const globalDir = join(homedir(), `.${appName}`);
+  const globalPath = join(globalDir, "config.json");
+  function resolveActivePath() {
+    const localDir = join(process.cwd(), `.${appName}`);
+    const localPath = join(localDir, "config.json");
+    const isLocal = existsSync(localPath) || existsSync(localDir);
+    return isLocal ? { cfgPath: localPath, cfgDir: localDir, isLocal: true } : { cfgPath: globalPath, cfgDir: globalDir, isLocal: false };
+  }
+  function resolveReadPath() {
+    return resolveActivePath().cfgPath;
+  }
+  function resolveWritePath() {
+    const { cfgPath, cfgDir } = resolveActivePath();
+    return { cfgPath, cfgDir };
+  }
+  function loadConfig() {
+    const cfgPath = resolveReadPath();
+    if (!existsSync(cfgPath)) return {};
+    try {
+      return JSON.parse(readFileSync(cfgPath, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  function saveConfig(cfg) {
+    const { cfgPath, cfgDir } = resolveWritePath();
+    mkdirSync(cfgDir, { recursive: true });
+    writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n");
+  }
+  return {
+    get configPath() {
+      return resolveWritePath().cfgPath;
+    },
+    loadConfig,
+    saveConfig,
+    getContext() {
+      return loadConfig().context;
+    },
+    setContext(parts) {
+      const cfg = loadConfig();
+      cfg.context = { ...cfg.context ?? {}, ...parts };
+      saveConfig(cfg);
+    },
+    clearContext() {
+      const cfg = loadConfig();
+      delete cfg.context;
+      saveConfig(cfg);
+    }
+  };
+}
+
+export {
+  createContextManager
+};

package/dist/client.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Generic HTTP client factory for Node CLI binaries.
+ *
+ * Usage:
+ *   const { get, post, patch, del } = createApiClient(
+ *     () => cfg.token ?? process.env.MY_TOKEN,
+ *     () => cfg.apiBase ?? 'https://api.example.com',
+ *   );
+ */
+interface ApiClient {
+    api<T>(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    get<T>(path: string, headers?: Record<string, string>): Promise<T>;
+    post<T>(path: string, body: unknown, headers?: Record<string, string>): Promise<T>;
+    patch<T>(path: string, body: unknown, headers?: Record<string, string>): Promise<T>;
+    del<T>(path: string, headers?: Record<string, string>): Promise<T>;
+}
+declare class ApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+declare function createApiClient(getToken: () => string | undefined, getApiBase: () => string, getExtraHeaders?: () => Record<string, string>): ApiClient;
+
+export { type ApiClient, ApiError, createApiClient };

package/dist/client.js

@@ -0,0 +1,8 @@
+import {
+  ApiError,
+  createApiClient
+} from "./chunk-XQGLG3X3.js";
+export {
+  ApiError,
+  createApiClient
+};