@jackwener/opencli 0.1.0

package/dist/engine.js

@@ -0,0 +1,77 @@
+/**
+ * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { Strategy, registerCommand } from './registry.js';
+import { executePipeline } from './pipeline.js';
+export function discoverClis(...dirs) {
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        for (const site of fs.readdirSync(dir)) {
+            const siteDir = path.join(dir, site);
+            if (!fs.statSync(siteDir).isDirectory())
+                continue;
+            for (const file of fs.readdirSync(siteDir)) {
+                const filePath = path.join(siteDir, file);
+                if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                    registerYamlCli(filePath, site);
+                }
+            }
+        }
+    }
+}
+function registerYamlCli(filePath, defaultSite) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const def = yaml.load(raw);
+        if (!def || typeof def !== 'object')
+            return;
+        const site = def.site ?? defaultSite;
+        const name = def.name ?? path.basename(filePath, path.extname(filePath));
+        const strategyStr = def.strategy ?? (def.browser === false ? 'public' : 'cookie');
+        const strategy = Strategy[strategyStr.toUpperCase()] ?? Strategy.COOKIE;
+        const browser = def.browser ?? (strategy !== Strategy.PUBLIC);
+        const args = [];
+        if (def.args && typeof def.args === 'object') {
+            for (const [argName, argDef] of Object.entries(def.args)) {
+                args.push({
+                    name: argName,
+                    type: argDef?.type ?? 'str',
+                    default: argDef?.default,
+                    required: argDef?.required ?? false,
+                    help: argDef?.description ?? argDef?.help ?? '',
+                    choices: argDef?.choices,
+                });
+            }
+        }
+        const cmd = {
+            site,
+            name,
+            description: def.description ?? '',
+            domain: def.domain,
+            strategy,
+            browser,
+            args,
+            columns: def.columns,
+            pipeline: def.pipeline,
+            timeoutSeconds: def.timeout,
+            source: filePath,
+        };
+        registerCommand(cmd);
+    }
+    catch (err) {
+        process.stderr.write(`Warning: failed to load ${filePath}: ${err.message}\n`);
+    }
+}
+export async function executeCommand(cmd, page, kwargs, debug = false) {
+    if (cmd.func) {
+        return cmd.func(page, kwargs, debug);
+    }
+    if (cmd.pipeline) {
+        return executePipeline(page, cmd.pipeline, { args: kwargs, debug });
+    }
+    throw new Error(`Command ${cmd.site}/${cmd.name} has no func or pipeline`);
+}

package/dist/explore.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Deep Explore: intelligent API discovery with response analysis.
+ *
+ * Unlike simple page snapshots, Deep Explore intercepts network traffic,
+ * analyzes response schemas, and automatically infers capabilities that
+ * can be turned into CLI commands.
+ *
+ * Flow:
+ *   1. Navigate to target URL
+ *   2. Auto-scroll to trigger lazy loading
+ *   3. Capture network requests (with body analysis)
+ *   4. For each JSON response: detect list fields, infer columns, analyze auth
+ *   5. Detect frontend framework (Vue/React/Pinia/Next.js)
+ *   6. Generate structured capabilities.json
+ */
+export declare function exploreUrl(url: string, opts?: any): Promise<any>;
+export declare function renderExploreSummary(result: any): string;