@jackwener/opencli 0.1.0

package/dist/generate.js

@@ -0,0 +1,134 @@
+/**
+ * Generate: one-shot CLI creation from URL.
+ *
+ * Orchestrates the full pipeline:
+ *   explore (Deep Explore) → synthesize (YAML generation) → register → verify
+ *
+ * Includes Strategy Cascade: if the initial strategy fails,
+ * automatically downgrades and retries.
+ */
+import { exploreUrl } from './explore.js';
+import { synthesizeFromExplore } from './synthesize.js';
+import { registerCandidates } from './register.js';
+const CAPABILITY_ALIASES = {
+    search: ['search', '搜索', '查找', 'query', 'keyword'],
+    hot: ['hot', '热门', '热榜', '热搜', 'popular', 'top', 'ranking'],
+    trending: ['trending', '趋势', '流行', 'discover'],
+    feed: ['feed', '动态', '关注', '时间线', 'timeline', 'following'],
+    me: ['profile', 'me', '个人信息', 'myinfo', '账号'],
+    detail: ['detail', '详情', 'video', 'article', 'view'],
+    comments: ['comments', '评论', '回复', 'reply'],
+    history: ['history', '历史', '记录'],
+    favorite: ['favorite', '收藏', 'bookmark', 'collect'],
+};
+/**
+ * Normalize a goal string to a standard capability name.
+ */
+function normalizeGoal(goal) {
+    if (!goal)
+        return null;
+    const lower = goal.trim().toLowerCase();
+    for (const [cap, aliases] of Object.entries(CAPABILITY_ALIASES)) {
+        if (lower === cap || aliases.some(a => lower.includes(a.toLowerCase())))
+            return cap;
+    }
+    return null;
+}
+/**
+ * Select the best candidate matching the user's goal.
+ */
+function selectCandidate(candidates, goal) {
+    if (!candidates.length)
+        return null;
+    if (!goal)
+        return candidates[0]; // highest confidence first
+    const normalized = normalizeGoal(goal);
+    if (normalized) {
+        const exact = candidates.find(c => c.name === normalized);
+        if (exact)
+            return exact;
+    }
+    const lower = (goal ?? '').trim().toLowerCase();
+    const partial = candidates.find(c => c.name?.toLowerCase().includes(lower) || lower.includes(c.name?.toLowerCase()));
+    return partial ?? candidates[0];
+}
+export async function generateCliFromUrl(opts) {
+    // Step 1: Deep Explore
+    const exploreResult = await exploreUrl(opts.url, {
+        BrowserFactory: opts.BrowserFactory,
+        site: opts.site,
+        goal: normalizeGoal(opts.goal) ?? opts.goal,
+        waitSeconds: opts.waitSeconds ?? 3,
+    });
+    // Step 2: Synthesize candidates
+    const synthesizeResult = synthesizeFromExplore(exploreResult.out_dir, {
+        top: opts.top ?? 5,
+    });
+    // Step 3: Select best candidate for goal
+    const selected = selectCandidate(synthesizeResult.candidates ?? [], opts.goal);
+    const selectedSite = selected?.site ?? synthesizeResult.site ?? exploreResult.site;
+    // Step 4: Register (if requested)
+    let registerResult = null;
+    if (opts.register !== false && synthesizeResult.candidate_count > 0) {
+        try {
+            registerResult = registerCandidates({
+                target: synthesizeResult.out_dir,
+                builtinClis: opts.builtinClis,
+                userClis: opts.userClis,
+                name: selected?.name,
+            });
+        }
+        catch { }
+    }
+    const ok = exploreResult.endpoint_count > 0 && synthesizeResult.candidate_count > 0;
+    return {
+        ok,
+        goal: opts.goal,
+        normalized_goal: normalizeGoal(opts.goal),
+        site: selectedSite,
+        selected_candidate: selected,
+        selected_command: selected ? `${selectedSite}/${selected.name}` : '(none)',
+        explore: {
+            endpoint_count: exploreResult.endpoint_count,
+            api_endpoint_count: exploreResult.api_endpoint_count,
+            capability_count: exploreResult.capabilities?.length ?? 0,
+            top_strategy: exploreResult.top_strategy,
+            framework: exploreResult.framework,
+        },
+        synthesize: {
+            candidate_count: synthesizeResult.candidate_count,
+            candidates: (synthesizeResult.candidates ?? []).map((c) => ({
+                name: c.name,
+                strategy: c.strategy,
+                confidence: c.confidence,
+            })),
+        },
+        register: registerResult,
+    };
+}
+export function renderGenerateSummary(r) {
+    const lines = [
+        `opencli generate: ${r.ok ? 'OK' : 'FAIL'}`,
+        `Site: ${r.site}`,
+        `Goal: ${r.goal ?? '(auto)'}`,
+        `Selected: ${r.selected_command}`,
+        '',
+        `Explore:`,
+        `  Endpoints: ${r.explore?.endpoint_count ?? 0} total, ${r.explore?.api_endpoint_count ?? 0} API`,
+        `  Capabilities: ${r.explore?.capability_count ?? 0}`,
+        `  Strategy: ${r.explore?.top_strategy ?? 'unknown'}`,
+        '',
+        `Synthesize:`,
+        `  Candidates: ${r.synthesize?.candidate_count ?? 0}`,
+    ];
+    for (const c of r.synthesize?.candidates ?? []) {
+        lines.push(`    • ${c.name} (${c.strategy}, ${((c.confidence ?? 0) * 100).toFixed(0)}%)`);
+    }
+    if (r.register)
+        lines.push(`\nRegistered: ${r.register.count ?? 0}`);
+    const fw = r.explore?.framework ?? {};
+    const fwNames = Object.entries(fw).filter(([, v]) => v).map(([k]) => k);
+    if (fwNames.length)
+        lines.push(`Framework: ${fwNames.join(', ')}`);
+    return lines.join('\n');
+}

package/dist/main.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * opencli — Make any website your CLI. AI-powered.
+ */
+import './clis/index.js';

package/dist/main.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * opencli — Make any website your CLI. AI-powered.
+ */
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { discoverClis, executeCommand } from './engine.js';
+import { fullName, getRegistry, strategyLabel } from './registry.js';
+import { render as renderOutput } from './output.js';
+import './clis/index.js';
+import { PlaywrightMCP } from './browser.js';
+import { browserSession, DEFAULT_BROWSER_COMMAND_TIMEOUT, runWithTimeout } from './runtime.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const BUILTIN_CLIS = path.resolve(__dirname, 'clis');
+const USER_CLIS = path.join(os.homedir(), '.opencli', 'clis');
+discoverClis(BUILTIN_CLIS, USER_CLIS);
+const program = new Command();
+program.name('opencli').description('Make any website your CLI. Zero setup. AI-powered.').version('0.1.0');
+// ── Built-in commands ──────────────────────────────────────────────────────
+program.command('list').description('List all available CLI commands').option('--json', 'JSON output')
+    .action((opts) => {
+    const registry = getRegistry();
+    const commands = [...registry.values()].sort((a, b) => fullName(a).localeCompare(fullName(b)));
+    if (opts.json) {
+        console.log(JSON.stringify(commands.map(c => ({ command: fullName(c), site: c.site, name: c.name, description: c.description, strategy: strategyLabel(c), browser: c.browser, args: c.args.map(a => a.name) })), null, 2));
+        return;
+    }
+    const sites = new Map();
+    for (const cmd of commands) {
+        const g = sites.get(cmd.site) ?? [];
+        g.push(cmd);
+        sites.set(cmd.site, g);
+    }
+    console.log();
+    console.log(chalk.bold('  opencli') + chalk.dim(' — available commands'));
+    console.log();
+    for (const [site, cmds] of sites) {
+        console.log(chalk.bold.cyan(`  ${site}`));
+        for (const cmd of cmds) {
+            const tag = strategyLabel(cmd) === 'public' ? chalk.green('[public]') : chalk.yellow(`[${strategyLabel(cmd)}]`);
+            console.log(`    ${cmd.name} ${tag}${cmd.description ? chalk.dim(` — ${cmd.description}`) : ''}`);
+        }
+        console.log();
+    }
+    console.log(chalk.dim(`  ${commands.length} commands across ${sites.size} sites`));
+    console.log();
+});
+program.command('validate').description('Validate CLI definitions').argument('[target]', 'site or site/name')
+    .action(async (target) => { const { validateClisWithTarget, renderValidationReport } = await import('./validate.js'); console.log(renderValidationReport(validateClisWithTarget([BUILTIN_CLIS, USER_CLIS], target))); });
+program.command('verify').description('Validate + smoke test').argument('[target]').option('--smoke', 'Run smoke tests', false)
+    .action(async (target, opts) => { const { verifyClis, renderVerifyReport } = await import('./verify.js'); const r = await verifyClis({ builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, target, smoke: opts.smoke }); console.log(renderVerifyReport(r)); process.exitCode = r.ok ? 0 : 1; });
+program.command('explore').description('Explore a website').argument('<url>').option('--site <name>').option('--goal <text>').option('--wait <s>', '', '3')
+    .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: PlaywrightMCP, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait) }))); });
+program.command('synthesize').description('Synthesize CLIs from explore').argument('<target>').option('--top <n>', '', '3')
+    .action(async (target, opts) => { const { synthesizeFromExplore, renderSynthesizeSummary } = await import('./synthesize.js'); console.log(renderSynthesizeSummary(synthesizeFromExplore(target, { top: parseInt(opts.top) }))); });
+program.command('generate').description('One-shot: explore → synthesize → register').argument('<url>').option('--goal <text>').option('--site <name>')
+    .action(async (url, opts) => { const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js'); const r = await generateCliFromUrl({ url, BrowserFactory: PlaywrightMCP, builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, goal: opts.goal, site: opts.site }); console.log(renderGenerateSummary(r)); process.exitCode = r.ok ? 0 : 1; });
+// ── Dynamic site commands ──────────────────────────────────────────────────
+const registry = getRegistry();
+const siteGroups = new Map();
+for (const [, cmd] of registry) {
+    let siteCmd = siteGroups.get(cmd.site);
+    if (!siteCmd) {
+        siteCmd = program.command(cmd.site).description(`${cmd.site} commands`);
+        siteGroups.set(cmd.site, siteCmd);
+    }
+    const subCmd = siteCmd.command(cmd.name).description(cmd.description);
+    for (const arg of cmd.args) {
+        const flag = arg.required ? `--${arg.name} <value>` : `--${arg.name} [value]`;
+        if (arg.required)
+            subCmd.requiredOption(flag, arg.help ?? '');
+        else if (arg.default != null)
+            subCmd.option(flag, arg.help ?? '', String(arg.default));
+        else
+            subCmd.option(flag, arg.help ?? '');
+    }
+    subCmd.option('-f, --format <fmt>', 'Output format: table, json, md, csv', 'table').option('-v, --verbose', 'Debug output', false);
+    subCmd.action(async (actionOpts) => {
+        const startTime = Date.now();
+        const kwargs = {};
+        for (const arg of cmd.args) {
+            const v = actionOpts[arg.name];
+            if (v !== undefined)
+                kwargs[arg.name] = coerce(v, arg.type ?? 'str');
+            else if (arg.default != null)
+                kwargs[arg.name] = arg.default;
+        }
+        try {
+            let result;
+            if (cmd.browser) {
+                result = await browserSession(PlaywrightMCP, async (page) => runWithTimeout(executeCommand(cmd, page, kwargs, actionOpts.verbose), { timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT, label: fullName(cmd) }));
+            }
+            else {
+                result = await executeCommand(cmd, null, kwargs, actionOpts.verbose);
+            }
+            renderOutput(result, { fmt: actionOpts.format, columns: cmd.columns, title: `${cmd.site}/${cmd.name}`, elapsed: (Date.now() - startTime) / 1000, source: fullName(cmd) });
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err.message ?? err}`));
+            process.exitCode = 1;
+        }
+    });
+}
+function coerce(v, t) {
+    if (t === 'bool')
+        return ['1', 'true', 'yes', 'on'].includes(String(v).toLowerCase());
+    if (t === 'int')
+        return parseInt(String(v), 10);
+    if (t === 'float')
+        return parseFloat(String(v));
+    return String(v);
+}
+program.parse();

package/dist/output.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Output formatting: table, JSON, Markdown, CSV.
+ */
+export interface RenderOptions {
+    fmt?: string;
+    columns?: string[];
+    title?: string;
+    elapsed?: number;
+    source?: string;
+}
+export declare function render(data: any, opts?: RenderOptions): void;

package/dist/output.js

@@ -0,0 +1,98 @@
+/**
+ * Output formatting: table, JSON, Markdown, CSV.
+ */
+import chalk from 'chalk';
+import Table from 'cli-table3';
+export function render(data, opts = {}) {
+    const fmt = opts.fmt ?? 'table';
+    if (data === null || data === undefined) {
+        console.log(data);
+        return;
+    }
+    switch (fmt) {
+        case 'json':
+            renderJson(data);
+            break;
+        case 'md':
+        case 'markdown':
+            renderMarkdown(data, opts);
+            break;
+        case 'csv':
+            renderCsv(data, opts);
+            break;
+        default:
+            renderTable(data, opts);
+            break;
+    }
+}
+function renderTable(data, opts) {
+    const rows = Array.isArray(data) ? data : [data];
+    if (!rows.length) {
+        console.log(chalk.dim('(no data)'));
+        return;
+    }
+    const columns = opts.columns ?? Object.keys(rows[0]);
+    const header = columns.map((c, i) => i === 0 ? '#' : capitalize(c));
+    const table = new Table({
+        head: header.map(h => chalk.bold(h)),
+        style: { head: [], border: [] },
+        wordWrap: true,
+        wrapOnWordBoundary: true,
+        colWidths: columns.map((c, i) => {
+            if (i === 0)
+                return 4;
+            if (c === 'url' || c === 'description')
+                return null;
+            if (c === 'title' || c === 'name' || c === 'repo')
+                return null;
+            return null;
+        }).filter(() => true),
+    });
+    for (const row of rows) {
+        table.push(columns.map(c => {
+            const v = row[c];
+            return v === null || v === undefined ? '' : String(v);
+        }));
+    }
+    console.log();
+    if (opts.title)
+        console.log(chalk.dim(`  ${opts.title}`));
+    console.log(table.toString());
+    const footer = [];
+    footer.push(`${rows.length} items`);
+    if (opts.elapsed)
+        footer.push(`${opts.elapsed.toFixed(1)}s`);
+    if (opts.source)
+        footer.push(opts.source);
+    console.log(chalk.dim(footer.join(' · ')));
+}
+function renderJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function renderMarkdown(data, opts) {
+    const rows = Array.isArray(data) ? data : [data];
+    if (!rows.length)
+        return;
+    const columns = opts.columns ?? Object.keys(rows[0]);
+    console.log('| ' + columns.join(' | ') + ' |');
+    console.log('| ' + columns.map(() => '---').join(' | ') + ' |');
+    for (const row of rows) {
+        console.log('| ' + columns.map(c => String(row[c] ?? '')).join(' | ') + ' |');
+    }
+}
+function renderCsv(data, opts) {
+    const rows = Array.isArray(data) ? data : [data];
+    if (!rows.length)
+        return;
+    const columns = opts.columns ?? Object.keys(rows[0]);
+    console.log(columns.join(','));
+    for (const row of rows) {
+        console.log(columns.map(c => {
+            const v = String(row[c] ?? '');
+            return v.includes(',') || v.includes('"') ? `"${v.replace(/"/g, '""')}"` : v;
+        }).join(','));
+    }
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,9 @@
+/**
+ * YAML pipeline executor.
+ * Steps: fetch, navigate, evaluate, map, filter, sort, limit, select, snapshot, click, type, wait, press, intercept.
+ */
+export interface PipelineContext {
+    args?: Record<string, any>;
+    debug?: boolean;
+}
+export declare function executePipeline(page: any, pipeline: any[], ctx?: PipelineContext): Promise<any>;