@onebullex-group/cli 1.1.2

package/dist/lint-api.d.ts

@@ -0,0 +1,38 @@
+import { CommandRegEntry } from './core/types.js';
+
+interface Endpoint {
+    method: 'GET' | 'POST';
+    path: string;
+}
+interface DocParam {
+    name: string;
+    required: boolean;
+}
+/**
+ * In Phase 2 every documented endpoint has a CLI command. The list is
+ * intentionally empty; the constant is kept as a hook for staging Phase 3
+ * additions if needed.
+ */
+declare const PHASE1_DEFERRED: readonly Endpoint[];
+declare function parseDocEndpoints(md: string): Endpoint[];
+declare function diffEndpoints(doc: readonly Endpoint[], cli: readonly Endpoint[]): {
+    missingInCli: Endpoint[];
+    extraInCli: Endpoint[];
+};
+/**
+ * Extract `(name, required)` pairs from the request param table that follows the
+ * `#### METHOD <path>` heading. Supports both shapes:
+ * - GET / query table: 5 columns `参数 | 位置 | 类型 | 必填 | 说明`
+ * - POST body table: 4 columns `字段 | 类型 | 必填 | 说明`
+ */
+declare function parseDocParams(md: string, path: string): DocParam[];
+/**
+ * Parses a TS source string and returns commander positional/option flags as
+ * `(name, required)` pairs. Positional `<x>` → required, `[x]` → optional;
+ * `.requiredOption('--foo …')` → required, `.option('--foo …')` → optional.
+ */
+declare function extractCliParamsFromSource(source: string): DocParam[];
+declare function diffParams(endpoint: Endpoint, docParams: readonly DocParam[], cliParams: readonly DocParam[]): string[];
+declare function checkWriteSafety(reg?: readonly CommandRegEntry[]): string[];
+
+export { type DocParam, type Endpoint, PHASE1_DEFERRED, checkWriteSafety, diffEndpoints, diffParams, extractCliParamsFromSource, parseDocEndpoints, parseDocParams };

package/dist/lint-api.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+import {
+  REGISTRY
+} from "./chunk-FTINNKNR.js";
+
+// scripts/check-cli-coverage.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { Project, SyntaxKind } from "ts-morph";
+var PHASE1_DEFERRED = [];
+var ENDPOINT_RE = /^####\s+(GET|POST)\s+(\/v2\/\S+)/gm;
+function parseDocEndpoints(md) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  ENDPOINT_RE.lastIndex = 0;
+  let m;
+  while ((m = ENDPOINT_RE.exec(md)) !== null) {
+    const method = m[1];
+    const path = m[2].replace(/[—,;:]+$/, "");
+    const key = `${method} ${path}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push({ method, path });
+    }
+  }
+  return out;
+}
+function diffEndpoints(doc, cli) {
+  const k = (e) => `${e.method} ${e.path}`;
+  const docSet = new Set(doc.map(k));
+  const cliSet = new Set(cli.map(k));
+  return {
+    missingInCli: doc.filter((e) => !cliSet.has(k(e))),
+    extraInCli: cli.filter((e) => !docSet.has(k(e)))
+  };
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseDocParams(md, path) {
+  const headingRe = new RegExp(
+    `####\\s+(?:GET|POST)\\s+${escapeRegex(path)}\\b`,
+    "m"
+  );
+  const m = headingRe.exec(md);
+  if (!m) return [];
+  const after = md.slice(m.index + m[0].length);
+  const nextSection = /^####\s+/m.exec(after);
+  const section = nextSection ? after.slice(0, nextSection.index) : after;
+  const tableRe = /\|\s*(?:参数|字段)\s*\|[^\n]*\|\s*必填\s*\|[^\n]*\n\|[-:\s|]+\|\n((?:\|[^\n]*\n)+)/;
+  const t = tableRe.exec(section);
+  if (!t) return [];
+  const headerEnd = t[0].indexOf("\n");
+  const headerLine = t[0].slice(0, headerEnd);
+  const headerCells = headerLine.split("|").map((c) => c.trim()).slice(1, -1);
+  const requiredIdx = headerCells.indexOf("\u5FC5\u586B");
+  if (requiredIdx < 0) return [];
+  const rows = (t[1] ?? "").split("\n").filter((l) => l.trim().startsWith("|"));
+  const out = [];
+  for (const row of rows) {
+    const cells = row.split("|").map((c) => c.trim()).slice(1, -1);
+    if (cells.length < headerCells.length) continue;
+    const nameCell = cells[0] ?? "";
+    const reqCell = cells[requiredIdx] ?? "";
+    const nameMatch = /^`([^`]+)`$/.exec(nameCell);
+    if (!nameMatch) continue;
+    out.push({ name: nameMatch[1] ?? "", required: reqCell === "\u662F" });
+  }
+  return out;
+}
+function unquote(s) {
+  if (s.startsWith("'") && s.endsWith("'") || s.startsWith('"') && s.endsWith('"') || s.startsWith("`") && s.endsWith("`")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function extractCliParamsFromSource(source) {
+  const project = new Project({ useInMemoryFileSystem: true });
+  const f = project.createSourceFile("temp.ts", source);
+  const out = [];
+  for (const call of f.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    const expr = call.getExpression();
+    const text = expr.getText();
+    if (text.endsWith(".command")) {
+      const arg = call.getArguments()[0];
+      if (arg) {
+        const sigText = unquote(arg.getText());
+        const tokens = sigText.split(/\s+/).slice(1);
+        for (const tok of tokens) {
+          if (tok.startsWith("<") && tok.endsWith(">")) {
+            out.push({ name: tok.slice(1, -1), required: true });
+          } else if (tok.startsWith("[") && tok.endsWith("]")) {
+            out.push({ name: tok.slice(1, -1), required: false });
+          }
+        }
+      }
+      continue;
+    }
+    if (text.endsWith(".requiredOption") || text.endsWith(".option")) {
+      const arg = call.getArguments()[0];
+      if (arg) {
+        const flag = unquote(arg.getText());
+        const m = /--([a-z][a-z0-9-]*)/i.exec(flag);
+        if (m && m[1]) {
+          out.push({ name: m[1], required: text.endsWith(".requiredOption") });
+        }
+      }
+    }
+  }
+  return out;
+}
+var GLOBAL_FLAGS = /* @__PURE__ */ new Set([
+  "profile",
+  "api-key",
+  "secret",
+  "base-url",
+  "output",
+  "debug",
+  "timeout",
+  "confirm",
+  "reveal",
+  "stdin",
+  "value",
+  "name",
+  "env",
+  "identify",
+  "set-default",
+  "yes"
+]);
+function normalize(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+function diffParams(endpoint, docParams, cliParams) {
+  const errors = [];
+  const docMap = new Map(
+    docParams.map((p) => [normalize(p.name), p])
+  );
+  const cliMap = new Map(
+    cliParams.filter((p) => !GLOBAL_FLAGS.has(p.name)).map((p) => [normalize(p.name), p])
+  );
+  for (const [k, dp] of docMap.entries()) {
+    if (dp.required) {
+      const cp = cliMap.get(k);
+      if (!cp) {
+        errors.push(`${endpoint.method} ${endpoint.path}: missing required CLI option --${k}`);
+      } else if (!cp.required) {
+        errors.push(
+          `${endpoint.method} ${endpoint.path}: --${k} should be requiredOption (doc says \u5FC5\u586B=\u662F)`
+        );
+      }
+    }
+  }
+  for (const k of cliMap.keys()) {
+    if (!docMap.has(k)) {
+      errors.push(
+        `${endpoint.method} ${endpoint.path}: CLI defines --${k} not present in doc params`
+      );
+    }
+  }
+  return errors;
+}
+var READ_ONLY_POST_ALLOWLIST = /* @__PURE__ */ new Set(["/v2/order/list-by-ids"]);
+function checkWriteSafety(reg = REGISTRY) {
+  const errors = [];
+  for (const e of reg) {
+    if (e.isWrite && e.method === "GET") {
+      errors.push(`${e.command}: isWrite=true but method=GET (suspicious)`);
+    }
+    if (!e.isWrite && e.method === "POST" && !READ_ONLY_POST_ALLOWLIST.has(e.path)) {
+      errors.push(
+        `${e.command}: method=POST but isWrite=false (likely missing isWrite flag for ${e.path})`
+      );
+    }
+  }
+  return errors;
+}
+async function main(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const log = opts.log ?? ((s) => process.stdout.write(`${s}
+`));
+  const errLog = opts.errLog ?? ((s) => process.stderr.write(`${s}
+`));
+  const mdPath = resolve(cwd, "..", "docs", "onebullex-openapi-cn-v2.md");
+  const md = readFileSync(mdPath, "utf8");
+  const allDoc = parseDocEndpoints(md);
+  const deferredKey = (e) => `${e.method} ${e.path}`;
+  const deferredSet = new Set(PHASE1_DEFERRED.map(deferredKey));
+  const docEndpoints = allDoc.filter((e) => !deferredSet.has(deferredKey(e)));
+  const cliEndpoints = REGISTRY.map((e) => ({ method: e.method, path: e.path }));
+  const { missingInCli, extraInCli } = diffEndpoints(docEndpoints, cliEndpoints);
+  let ok = true;
+  if (missingInCli.length > 0) {
+    ok = false;
+    errLog(`
+[Endpoint coverage] Missing in CLI (${missingInCli.length}):`);
+    for (const e of missingInCli) errLog(`  ${e.method.padEnd(4)} ${e.path}`);
+  }
+  if (extraInCli.length > 0) {
+    ok = false;
+    errLog(`
+[Endpoint coverage] Extra in CLI (${extraInCli.length}):`);
+    for (const e of extraInCli) errLog(`  ${e.method.padEnd(4)} ${e.path}`);
+  }
+  const paramErrors = [];
+  for (const entry of REGISTRY) {
+    const docParams = parseDocParams(md, entry.path);
+    if (docParams.length === 0) continue;
+    const implPath = resolve(cwd, entry.implFile);
+    let src;
+    try {
+      src = readFileSync(implPath, "utf8");
+    } catch {
+      paramErrors.push(`${entry.command}: cannot read ${entry.implFile}`);
+      continue;
+    }
+    const cliParams = extractCliParamsFromSource(src);
+    paramErrors.push(...diffParams({ method: entry.method, path: entry.path }, docParams, cliParams));
+  }
+  if (paramErrors.length > 0) {
+    ok = false;
+    errLog(`
+[Parameter coverage] ${paramErrors.length} mismatch(es):`);
+    for (const e of paramErrors) errLog(`  ${e}`);
+  }
+  const writeErrors = checkWriteSafety(REGISTRY);
+  if (writeErrors.length > 0) {
+    ok = false;
+    errLog(`
+[Write-op safety] ${writeErrors.length} issue(s):`);
+    for (const e of writeErrors) errLog(`  ${e}`);
+  }
+  if (!ok) {
+    errLog("\nEdit cli/src/registry.ts and add/remove command files to match the docs.");
+    return 1;
+  }
+  log(
+    `OK V2 endpoint coverage: ${cliEndpoints.length} commands cover ${docEndpoints.length} doc endpoints. Parameter and write-safety lints passed.`
+  );
+  return 0;
+}
+var isMainModule = () => {
+  const argv1 = process.argv[1];
+  if (!argv1) return false;
+  return argv1.endsWith("check-cli-coverage.ts") || argv1.endsWith("check-cli-coverage.js");
+};
+if (isMainModule()) {
+  void main().then((code) => process.exit(code));
+}
+export {
+  PHASE1_DEFERRED,
+  checkWriteSafety,
+  diffEndpoints,
+  diffParams,
+  extractCliParamsFromSource,
+  parseDocEndpoints,
+  parseDocParams
+};

package/dist/output-UIZGG7EU.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  effectiveFormat,
+  formatTimestamp,
+  render,
+  renderTable
+} from "./chunk-J3TAAD3Q.js";
+export {
+  effectiveFormat,
+  formatTimestamp,
+  render,
+  renderTable
+};

package/dist/registry.d.ts

@@ -0,0 +1,5 @@
+import { CommandRegEntry } from './core/types.js';
+
+declare const REGISTRY: CommandRegEntry[];
+
+export { REGISTRY };

package/dist/registry.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import {
+  REGISTRY
+} from "./chunk-FTINNKNR.js";
+export {
+  REGISTRY
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@onebullex-group/cli",
+  "version": "1.1.2",
+  "description": "OneBullEx Open API V2 command-line interface",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "onebullex": "dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./registry": "./dist/registry.js",
+    "./lint": "./dist/lint-api.js",
+    "./core/http-client": "./dist/core/http-client.js",
+    "./core/config": "./dist/core/config.js",
+    "./core/errors": "./dist/core/errors.js",
+    "./core/signature": "./dist/core/signature.js",
+    "./core/types": "./dist/core/types.js",
+    "./core/redact": "./dist/core/redact.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "ts-morph": "^23.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^20.14.0",
+    "nock": "^13.5.5",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0",
+    "undici": "^8.3.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:e2e": "vitest run tests/e2e",
+    "lint": "biome lint src tests",
+    "format": "biome format --write src tests",
+    "check-coverage": "tsx scripts/check-cli-coverage.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}