cssprobe-cli 0.1.0

package/dist/collector-bundle.js

@@ -0,0 +1,342 @@
+"use strict";
+var __cssprobe_cli = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/engine/collector.ts
+  var collector_exports = {};
+  __export(collector_exports, {
+    classifyShape: () => classifyShape,
+    collect: () => collect
+  });
+  var WANTED_PROPS = [
+    // layout
+    "height",
+    "max-height",
+    "min-height",
+    "width",
+    "max-width",
+    "min-width",
+    "overflow",
+    "overflow-x",
+    "overflow-y",
+    "position",
+    "display",
+    "box-sizing",
+    "flex",
+    "flex-grow",
+    "flex-shrink",
+    "flex-basis",
+    "flex-direction",
+    "align-items",
+    "justify-content",
+    "align-self",
+    "grid-template-columns",
+    "grid-template-rows",
+    "top",
+    "left",
+    "right",
+    "bottom",
+    "margin",
+    "margin-top",
+    "margin-bottom",
+    "margin-left",
+    "margin-right",
+    "padding",
+    "padding-top",
+    "padding-bottom",
+    "transform",
+    "filter",
+    "perspective",
+    "will-change",
+    "contain",
+    "z-index",
+    "visibility",
+    "opacity",
+    // visual (colors / backgrounds / fonts)
+    "color",
+    "background",
+    "background-color",
+    "background-image",
+    "background-size",
+    "background-position",
+    "background-repeat",
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "line-height",
+    "text-align",
+    "letter-spacing",
+    "text-transform"
+  ];
+  function matchDeclarations(el, wantedProps, crossOriginBlocked, blockedSheetUrls) {
+    const out = {};
+    let scanned = 0;
+    for (const sheet of Array.from(document.styleSheets)) {
+      let rules = null;
+      let accessible = true;
+      try {
+        rules = sheet.cssRules;
+      } catch (_e) {
+        accessible = false;
+        crossOriginBlocked.count++;
+        const short = (sheet.href || "unknown").split("/").pop() || "unknown";
+        if (!blockedSheetUrls.includes(short)) blockedSheetUrls.push(short);
+        continue;
+      }
+      if (!rules) continue;
+      for (const rule of Array.from(rules)) {
+        const styleRule = rule;
+        if (styleRule.selectorText && el.matches && el.matches(styleRule.selectorText)) {
+          const decls = styleRule.style;
+          for (const p of wantedProps) {
+            const v = decls.getPropertyValue(p);
+            if (v) {
+              (out[p] = out[p] || []).push({
+                selector: styleRule.selectorText,
+                value: v.trim(),
+                href: (sheet.href || "").split("/").slice(-2).join("/"),
+                accessible
+              });
+            }
+          }
+        }
+        scanned += 1;
+        if (scanned > 8e3) return out;
+      }
+    }
+    for (const p of wantedProps) {
+      const iv = el.style.getPropertyValue(p);
+      if (iv && !(out[p] || []).some((d) => d.selector === "inline")) {
+        (out[p] = out[p] || []).push({ selector: "inline", value: iv.trim(), href: "", accessible: true });
+      }
+    }
+    return out;
+  }
+  function classifyShape(cs, declared) {
+    const display = cs.display;
+    const position = cs.position;
+    const flexDir = cs.flexDirection;
+    const overflowY = cs.overflowY;
+    const overflowX = cs.overflowX;
+    let role = "block";
+    if (position === "fixed") role = "fixed";
+    else if (position === "absolute") role = "absolute";
+    else if (position === "sticky") role = "sticky";
+    else if (display === "grid" || display === "inline-grid") role = "grid";
+    else if (display === "flex" || display === "inline-flex") {
+      role = flexDir === "column" ? "flex-col" : "flex-row";
+    } else if (display === "inline" || display === "inline-block") role = "inline";
+    const isScrollY = overflowY === "auto" || overflowY === "scroll";
+    const isScrollX = overflowX === "auto" || overflowX === "scroll";
+    const scrollTag = isScrollY ? isScrollX ? "scroll-xy" : "scroll-y" : isScrollX ? "scroll-x" : "";
+    const getDeclared = (prop) => {
+      const arr = declared && declared[prop];
+      if (!arr || arr.length === 0) return null;
+      const inline = arr.find((d) => d.selector === "inline");
+      return inline ? inline.value : arr[0].value;
+    };
+    const sizeClass = (prop, maxProp) => {
+      const val = getDeclared(prop);
+      const maxVal = getDeclared(maxProp);
+      if (val) {
+        if (/^(0|[1-9]\d*)(\.\d+)?(px|pt|cm|mm|in)$/.test(val)) return "fixed";
+        if (/^(0|[1-9]\d*)(\.\d+)?(vh|vw|vmin|vmax)$/.test(val)) return "viewport";
+        if (val.endsWith("%")) return "percent";
+        if (/^calc\(/.test(val)) return "calc";
+        if (val === "min-content" || val === "max-content" || val === "fit-content") return "content";
+      }
+      if (maxVal && maxVal !== "none" && maxVal !== "auto") return "constrained";
+      return "content";
+    };
+    const heightStrategy = sizeClass("height", "max-height");
+    const widthStrategy = sizeClass("width", "max-width");
+    const isFlexChild = !!(getDeclared("flex-grow") || getDeclared("flex-shrink") || getDeclared("flex-basis") || getDeclared("flex"));
+    return { role, scrollTag, heightStrategy, widthStrategy, isFlexChild };
+  }
+  var CB_PROPS = ["transform", "filter", "perspective", "willChange", "contain"];
+  function collectNode(el, maxText, crossOriginBlocked, blockedSheetUrls) {
+    try {
+      const cs = getComputedStyle(el);
+      const rect = el.getBoundingClientRect();
+      if (!rect) return null;
+      const props = {};
+      const LAYOUT_PROPS = [
+        "position",
+        "display",
+        "height",
+        "width",
+        "minHeight",
+        "maxHeight",
+        "overflowX",
+        "overflowY",
+        "boxSizing",
+        "margin",
+        "padding",
+        "flexDirection",
+        "flexGrow",
+        "flexShrink",
+        "flexBasis",
+        "alignItems",
+        "justifyContent",
+        "transform",
+        "filter",
+        "perspective",
+        "willChange",
+        "contain",
+        "zIndex",
+        "top",
+        "left",
+        "right",
+        "bottom",
+        "visibility",
+        "opacity"
+      ];
+      for (const p of LAYOUT_PROPS) props[p] = cs[p] ?? "";
+      const text = (el.textContent || "").replace(/\s+/g, " ").trim().slice(0, maxText);
+      const declared = matchDeclarations(el, WANTED_PROPS, crossOriginBlocked, blockedSheetUrls);
+      const shape = classifyShape(cs, declared);
+      const rawClass = el.getAttribute("class") || "";
+      return {
+        tag: el.tagName.toLowerCase(),
+        id: el.id || null,
+        classes: rawClass.split(/\s+/).filter(Boolean),
+        inlineStyle: el.getAttribute("style") || null,
+        text,
+        props,
+        declared,
+        shape,
+        metrics: {
+          rect: {
+            x: +rect.x.toFixed(1),
+            y: +rect.y.toFixed(1),
+            width: +rect.width.toFixed(1),
+            height: +rect.height.toFixed(1)
+          },
+          rectBottom: +rect.bottom.toFixed(1),
+          rectRight: +rect.right.toFixed(1),
+          offsetHeight: el.offsetHeight,
+          clientHeight: el.clientHeight,
+          scrollHeight: el.scrollHeight,
+          clientWidth: el.clientWidth,
+          scrollWidth: el.scrollWidth
+        },
+        flags: {
+          overflowsViewport: rect.bottom > innerHeight + 1 || rect.right > innerWidth + 1,
+          overflowsParent: rect.bottom > (el.parentElement ? el.parentElement.getBoundingClientRect().bottom + 1 : innerHeight),
+          hasScrollY: el.scrollHeight > el.clientHeight + 1,
+          hasScrollX: el.scrollWidth > el.clientWidth + 1,
+          scrollable: (cs.overflowY === "auto" || cs.overflowY === "scroll") && el.scrollHeight > el.clientHeight + 1 && el.clientHeight > 0
+        },
+        containingBlockModifiers: CB_PROPS.filter((p) => {
+          const v = cs[p];
+          return v && v !== "none" && v !== "auto" && v !== "normal" && v !== "visible" && v !== "false";
+        }).map((p) => `${p}: ${cs[p]}`)
+      };
+    } catch (_e) {
+      return null;
+    }
+  }
+  function isSameShape(a, b) {
+    return !!a && !!b && a.tagName === b.tagName && a.id === b.id && (a.getAttribute("class") || "") === (b.getAttribute("class") || "");
+  }
+  function buildTree(el, depth, state, maxNodes, crossOriginBlocked, blockedSheetUrls) {
+    if (!el || state.count >= maxNodes || depth < 0) return null;
+    state.count += 1;
+    const collected = collectNode(el, 40, crossOriginBlocked, blockedSheetUrls);
+    if (!collected) return null;
+    const node = { ...collected, children: [] };
+    const kids = Array.from(el.children);
+    if (depth > 0) {
+      let i = 0;
+      while (i < kids.length) {
+        const run = [kids[i]];
+        let j = i + 1;
+        while (j < kids.length && isSameShape(kids[i], kids[j])) {
+          run.push(kids[j]);
+          j += 1;
+        }
+        const rep = buildTree(run[0], depth - 1, state, maxNodes, crossOriginBlocked, blockedSheetUrls);
+        if (rep) {
+          node.children.push({ ...rep, repeat: run.length });
+        }
+        i = j;
+      }
+    }
+    return node;
+  }
+  function walkUp(el, stopTag) {
+    const chain = [];
+    let cur = el;
+    while (cur && cur.tagName.toLowerCase() !== stopTag) {
+      chain.unshift(cur);
+      cur = cur.parentElement;
+    }
+    if (cur) chain.unshift(cur);
+    return chain;
+  }
+  function collect(cfg) {
+    const crossOriginBlocked = { count: 0 };
+    const blockedSheetUrls = [];
+    const viewport = { width: window.innerWidth, height: window.innerHeight };
+    const root = document.querySelector(cfg.rootSelector);
+    if (!root) {
+      const candidates = Array.from(document.querySelectorAll('.s-kit-modal, [class*="dialog"], [class*="modal"], [class*="popup"]')).slice(0, 5).map((el) => `${el.tagName}.${(el.getAttribute("class") || "").split(/\s+/).filter(Boolean).join(".")}`);
+      return {
+        rootSelector: cfg.rootSelector,
+        upTo: cfg.upTo,
+        downDepth: cfg.downDepth,
+        maxNodes: cfg.maxNodes,
+        nodeCount: 0,
+        viewport,
+        ancestors: [],
+        tree: null,
+        crossOriginBlocked: crossOriginBlocked.count,
+        blockedSheetUrls: blockedSheetUrls.slice(0, 5),
+        error: `\u672A\u627E\u5230 ${cfg.rootSelector}`,
+        candidates
+      };
+    }
+    const ancestors = walkUp(root, cfg.upTo).map((el) => collectNode(el, 30, crossOriginBlocked, blockedSheetUrls)).filter((n) => n !== null).map((n) => ({
+      label: `${n.tag}.${n.classes.join(".")}`,
+      props: n.props,
+      metrics: n.metrics,
+      flags: n.flags,
+      declared: n.declared,
+      shape: n.shape,
+      containingBlockModifiers: n.containingBlockModifiers,
+      inlineStyle: n.inlineStyle
+    }));
+    const state = { count: 0 };
+    const tree = buildTree(root, cfg.downDepth, state, cfg.maxNodes, crossOriginBlocked, blockedSheetUrls);
+    return {
+      rootSelector: cfg.rootSelector,
+      upTo: cfg.upTo,
+      downDepth: cfg.downDepth,
+      maxNodes: cfg.maxNodes,
+      nodeCount: state.count,
+      viewport,
+      ancestors,
+      tree,
+      crossOriginBlocked: crossOriginBlocked.count,
+      blockedSheetUrls: blockedSheetUrls.slice(0, 5)
+    };
+  }
+  return __toCommonJS(collector_exports);
+})();

package/dist/config/config.d.ts

@@ -0,0 +1,23 @@
+import type { MinimistArgs } from '../cli/minimist';
+export interface ProfileConfig {
+    browser?: string;
+    depth?: string;
+    headed?: string;
+}
+export interface Config {
+    browser: string;
+    depth: number;
+    headed: boolean;
+    output: 'text' | 'json';
+    raw: boolean;
+}
+export declare const rcFilePath: string;
+export declare function loadConfig(args: MinimistArgs): Config;
+export declare function maskConfig(config: Config): Record<string, string>;
+export declare function writeRcConfig(key: string, value: string, profileName?: string): Record<string, string>;
+export declare function getRcConfig(): {
+    active: string;
+    profiles: Record<string, ProfileConfig>;
+};
+export declare function setActiveProfile(name: string): void;
+export declare function createProfile(name: string): void;

package/dist/config/config.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rcFilePath = void 0;
+exports.loadConfig = loadConfig;
+exports.maskConfig = maskConfig;
+exports.writeRcConfig = writeRcConfig;
+exports.getRcConfig = getRcConfig;
+exports.setActiveProfile = setActiveProfile;
+exports.createProfile = createProfile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+exports.rcFilePath = path.join(os.homedir(), '.cssprobe-clirc');
+let cachedRc = null;
+function readRcFile() {
+    try {
+        const stat = fs.statSync(exports.rcFilePath);
+        if (cachedRc && cachedRc.mtime === stat.mtimeMs)
+            return cachedRc.rc;
+        const content = fs.readFileSync(exports.rcFilePath, 'utf-8');
+        const rc = JSON.parse(content);
+        cachedRc = { rc, mtime: stat.mtimeMs };
+        return rc;
+    }
+    catch {
+        return { active: 'default', profiles: {} };
+    }
+}
+function writeRcFile(rc) {
+    fs.writeFileSync(exports.rcFilePath, JSON.stringify(rc, null, 2) + '\n');
+    cachedRc = null;
+}
+function resolveProfileName(args) {
+    const fromArgs = args.p || args.profile;
+    const fromEnv = process.env.CSSPROBE_PROFILE;
+    if (fromArgs)
+        return fromArgs;
+    if (fromEnv)
+        return fromEnv;
+    return readRcFile().active;
+}
+function resolveProfile(args) {
+    const name = resolveProfileName(args);
+    const rc = readRcFile();
+    return rc.profiles[name] || {};
+}
+function loadConfig(args) {
+    const profile = resolveProfile(args);
+    const browser = args.browser || process.env.CSSPROBE_BROWSER || profile.browser || 'chromium';
+    const depthRaw = args.depth ?? process.env.CSSPROBE_DEPTH ?? profile.depth;
+    const depth = depthRaw ? Number(depthRaw) : 6;
+    const headed = !!(args.headed || process.env.CSSPROBE_HEADED === 'true' || profile.headed === 'true');
+    return {
+        browser,
+        depth: Number.isNaN(depth) ? 6 : depth,
+        headed,
+        output: args.json ? 'json' : 'text',
+        raw: !!args.raw,
+    };
+}
+function maskConfig(config) {
+    return {
+        browser: config.browser,
+        depth: String(config.depth),
+        headed: String(config.headed),
+    };
+}
+function writeRcConfig(key, value, profileName) {
+    const rc = readRcFile();
+    const name = profileName || rc.active;
+    if (!rc.profiles[name])
+        rc.profiles[name] = {};
+    rc.profiles[name][key] = value;
+    writeRcFile(rc);
+    return { profile: name, [key]: value };
+}
+function getRcConfig() {
+    const rc = readRcFile();
+    return { active: rc.active, profiles: rc.profiles };
+}
+function setActiveProfile(name) {
+    const rc = readRcFile();
+    if (!rc.profiles[name])
+        throw new Error(`Profile '${name}' not found`);
+    rc.active = name;
+    writeRcFile(rc);
+}
+function createProfile(name) {
+    const rc = readRcFile();
+    if (rc.profiles[name])
+        throw new Error(`Profile '${name}' already exists`);
+    rc.profiles[name] = {};
+    writeRcFile(rc);
+}
+//# sourceMappingURL=config.js.map

package/dist/config/helpGenerator.d.ts

@@ -0,0 +1,10 @@
+export declare function generateHelp(): string;
+export declare function generateHelpJSON(): {
+    global: string;
+    commands: Record<string, {
+        help: string;
+        flags: Record<string, "boolean" | "string">;
+        args: string[];
+    }>;
+    booleanOptions: string[];
+};

package/dist/config/helpGenerator.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHelp = generateHelp;
+exports.generateHelpJSON = generateHelpJSON;
+const z = __importStar(require("zod"));
+const commands_1 = require("../cli/commands");
+function commandArgs(command) {
+    const args = [];
+    const shape = command.args ? command.args.shape : {};
+    for (const [name, schema] of Object.entries(shape)) {
+        const zodSchema = schema;
+        const description = zodSchema.description ?? '';
+        args.push({ name, description, optional: zodSchema.safeParse(undefined).success });
+    }
+    return args;
+}
+function commandArgsText(args) {
+    return args.map(a => a.optional ? `[${a.name}]` : `<${a.name}>`).join(' ');
+}
+function generateCommandHelp(command) {
+    const args = commandArgs(command);
+    const lines = [
+        `cssprobe-cli ${command.name} ${commandArgsText(args)}`,
+        '',
+        command.description,
+        '',
+    ];
+    if (args.length) {
+        lines.push('Arguments:');
+        lines.push(...args.map(a => formatWithGap(`  ${a.optional ? `[${a.name}]` : `<${a.name}>`}`, a.description.toLowerCase())));
+    }
+    if (command.options) {
+        lines.push('Options:');
+        const optionsShape = command.options.shape;
+        for (const [name, schema] of Object.entries(optionsShape)) {
+            const zodSchema = schema;
+            const description = (zodSchema.description ?? '').toLowerCase();
+            lines.push(formatWithGap(`  --${name}`, description));
+        }
+    }
+    if (command.category !== 'config') {
+        lines.push('');
+        lines.push('Global options:');
+        lines.push(formatWithGap('  --json', 'output as JSON'));
+        lines.push(formatWithGap('  --profile, -p <name>', 'use named profile'));
+    }
+    return lines.join('\n');
+}
+const categories = [
+    { name: 'core', title: 'Inspection' },
+    { name: 'config', title: 'Configuration' },
+    { name: 'skill', title: 'Agent Skills' },
+];
+function generateHelp() {
+    const lines = [];
+    lines.push('Usage: cssprobe-cli <command> [args] [options]');
+    lines.push('');
+    const commandsByCategory = new Map();
+    for (const c of categories)
+        commandsByCategory.set(c.name, []);
+    for (const command of Object.values(commands_1.commands)) {
+        if (command.hidden)
+            continue;
+        commandsByCategory.get(command.category).push(command);
+    }
+    for (const c of categories) {
+        const cc = commandsByCategory.get(c.name);
+        if (!cc.length)
+            continue;
+        lines.push(`\n${c.title}:`);
+        for (const command of cc)
+            lines.push(generateHelpEntry(command));
+    }
+    lines.push('\nGlobal options:');
+    lines.push(formatWithGap('  --help [command]', 'print help'));
+    lines.push(formatWithGap('  --json', 'output response as JSON'));
+    lines.push(formatWithGap('  --raw', 'output only the result value'));
+    lines.push(formatWithGap('  --version', 'print version'));
+    lines.push(formatWithGap('  -p, --profile <name>', 'use named profile (or CSSPROBE_PROFILE env)'));
+    return lines.join('\n');
+}
+function generateHelpEntry(command) {
+    const args = commandArgs(command);
+    const prefix = `  ${command.name} ${commandArgsText(args)}`;
+    const suffix = command.description.toLowerCase();
+    return formatWithGap(prefix, suffix);
+}
+function unwrapZodType(schema) {
+    if ('unwrap' in schema && typeof schema.unwrap === 'function')
+        return unwrapZodType(schema.unwrap());
+    return schema;
+}
+function isBooleanSchema(schema) {
+    return unwrapZodType(schema) instanceof z.ZodBoolean;
+}
+function generateHelpJSON() {
+    const booleanOptions = new Set();
+    const commandEntries = {};
+    for (const [name, command] of Object.entries(commands_1.commands)) {
+        const flags = {};
+        if (command.options) {
+            const optionsShape = command.options.shape;
+            for (const [flagName, schema] of Object.entries(optionsShape)) {
+                const isBoolean = isBooleanSchema(schema);
+                flags[flagName] = isBoolean ? 'boolean' : 'string';
+                if (isBoolean)
+                    booleanOptions.add(flagName);
+            }
+        }
+        const args = command.args ? Object.keys(command.args.shape) : [];
+        commandEntries[name] = { help: generateCommandHelp(command), flags, args };
+    }
+    return {
+        global: generateHelp(),
+        commands: commandEntries,
+        booleanOptions: [...booleanOptions],
+    };
+}
+function formatWithGap(prefix, text, threshold = 30) {
+    const indent = Math.max(1, threshold - prefix.length);
+    return prefix + ' '.repeat(indent) + text;
+}
+//# sourceMappingURL=helpGenerator.js.map

package/dist/engine/analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { Snapshot, Finding } from './types';
+export declare function analyze(snapshot: Snapshot): Finding[];