@jackwener/opencli 0.1.0 → 0.1.2

package/dist/pipeline/template.js

@@ -0,0 +1,115 @@
+/**
+ * Pipeline template engine: ${{ ... }} expression rendering.
+ */
+export function render(template, ctx) {
+    if (typeof template !== 'string')
+        return template;
+    const fullMatch = template.match(/^\$\{\{\s*(.*?)\s*\}\}$/);
+    if (fullMatch)
+        return evalExpr(fullMatch[1].trim(), ctx);
+    return template.replace(/\$\{\{\s*(.*?)\s*\}\}/g, (_m, expr) => String(evalExpr(expr.trim(), ctx)));
+}
+export function evalExpr(expr, ctx) {
+    const args = ctx.args ?? {};
+    const item = ctx.item ?? {};
+    const data = ctx.data;
+    const index = ctx.index ?? 0;
+    // Default filter: args.limit | default(20)
+    if (expr.includes('|') && expr.includes('default(')) {
+        const [mainExpr, rest] = expr.split('|', 2);
+        const defaultMatch = rest.match(/default\((.+?)\)/);
+        const defaultVal = defaultMatch ? defaultMatch[1] : null;
+        const result = resolvePath(mainExpr.trim(), { args, item, data, index });
+        if (result === null || result === undefined) {
+            if (defaultVal !== null) {
+                const intVal = parseInt(defaultVal, 10);
+                if (!isNaN(intVal) && String(intVal) === defaultVal.trim())
+                    return intVal;
+                return defaultVal.replace(/^['"]|['"]$/g, '');
+            }
+        }
+        return result;
+    }
+    // Arithmetic: index + 1
+    const arithMatch = expr.match(/^([\w][\w.]*)\s*([+\-*/])\s*(\d+)$/);
+    if (arithMatch) {
+        const [, varName, op, numStr] = arithMatch;
+        const val = resolvePath(varName, { args, item, data, index });
+        if (val !== null && val !== undefined) {
+            const numVal = Number(val);
+            const num = Number(numStr);
+            if (!isNaN(numVal)) {
+                switch (op) {
+                    case '+': return numVal + num;
+                    case '-': return numVal - num;
+                    case '*': return numVal * num;
+                    case '/': return num !== 0 ? numVal / num : 0;
+                }
+            }
+        }
+    }
+    // JS-like fallback expression: item.tweetCount || 'N/A'
+    const orMatch = expr.match(/^(.+?)\s*\|\|\s*(.+)$/);
+    if (orMatch) {
+        const left = evalExpr(orMatch[1].trim(), ctx);
+        if (left)
+            return left;
+        const right = orMatch[2].trim();
+        return right.replace(/^['"]|['"]$/g, '');
+    }
+    return resolvePath(expr, { args, item, data, index });
+}
+export function resolvePath(pathStr, ctx) {
+    const args = ctx.args ?? {};
+    const item = ctx.item ?? {};
+    const data = ctx.data;
+    const index = ctx.index ?? 0;
+    const parts = pathStr.split('.');
+    const rootName = parts[0];
+    let obj;
+    let rest;
+    if (rootName === 'args') {
+        obj = args;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'item') {
+        obj = item;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'data') {
+        obj = data;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'index')
+        return index;
+    else {
+        obj = item;
+        rest = parts;
+    }
+    for (const part of rest) {
+        if (obj && typeof obj === 'object' && !Array.isArray(obj))
+            obj = obj[part];
+        else if (Array.isArray(obj) && /^\d+$/.test(part))
+            obj = obj[parseInt(part, 10)];
+        else
+            return null;
+    }
+    return obj;
+}
+/**
+ * Normalize JavaScript source for browser evaluate() calls.
+ */
+export function normalizeEvaluateSource(source) {
+    const stripped = source.trim();
+    if (!stripped)
+        return '() => undefined';
+    if (stripped.startsWith('(') && stripped.endsWith(')()'))
+        return `() => (${stripped})`;
+    if (/^(async\s+)?\([^)]*\)\s*=>/.test(stripped))
+        return stripped;
+    if (/^(async\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=>/.test(stripped))
+        return stripped;
+    if (stripped.startsWith('function ') || stripped.startsWith('async function '))
+        return stripped;
+    return `() => (${stripped})`;
+}

package/dist/pipeline/template.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for the pipeline template engine: render, evalExpr, resolvePath.
+ */
+export {};

package/dist/pipeline/template.test.js

@@ -0,0 +1,102 @@
+/**
+ * Tests for the pipeline template engine: render, evalExpr, resolvePath.
+ */
+import { describe, it, expect } from 'vitest';
+import { render, evalExpr, resolvePath, normalizeEvaluateSource } from './template.js';
+describe('resolvePath', () => {
+    it('resolves args path', () => {
+        expect(resolvePath('args.limit', { args: { limit: 20 } })).toBe(20);
+    });
+    it('resolves nested args path', () => {
+        expect(resolvePath('args.query.keyword', { args: { query: { keyword: 'test' } } })).toBe('test');
+    });
+    it('resolves item path', () => {
+        expect(resolvePath('item.title', { item: { title: 'Hello' } })).toBe('Hello');
+    });
+    it('resolves implicit item path (no prefix)', () => {
+        expect(resolvePath('title', { item: { title: 'World' } })).toBe('World');
+    });
+    it('resolves index', () => {
+        expect(resolvePath('index', { index: 5 })).toBe(5);
+    });
+    it('resolves data path', () => {
+        expect(resolvePath('data.items', { data: { items: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('returns null for missing path', () => {
+        expect(resolvePath('args.missing', { args: {} })).toBeUndefined();
+    });
+    it('resolves array index', () => {
+        expect(resolvePath('data.0', { data: ['a', 'b'] })).toBe('a');
+    });
+});
+describe('evalExpr', () => {
+    it('evaluates default filter', () => {
+        expect(evalExpr('args.limit | default(20)', { args: {} })).toBe(20);
+    });
+    it('uses actual value over default', () => {
+        expect(evalExpr('args.limit | default(20)', { args: { limit: 10 } })).toBe(10);
+    });
+    it('evaluates string default', () => {
+        expect(evalExpr("args.name | default('unknown')", { args: {} })).toBe('unknown');
+    });
+    it('evaluates arithmetic: index + 1', () => {
+        expect(evalExpr('index + 1', { index: 0 })).toBe(1);
+    });
+    it('evaluates arithmetic: index * 2', () => {
+        expect(evalExpr('index * 2', { index: 5 })).toBe(10);
+    });
+    it('evaluates || fallback', () => {
+        expect(evalExpr("item.name || 'N/A'", { item: {} })).toBe('N/A');
+    });
+    it('evaluates || with truthy left', () => {
+        expect(evalExpr("item.name || 'N/A'", { item: { name: 'Alice' } })).toBe('Alice');
+    });
+    it('resolves simple path', () => {
+        expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
+    });
+});
+describe('render', () => {
+    it('renders full expression', () => {
+        expect(render('${{ args.limit }}', { args: { limit: 30 } })).toBe(30);
+    });
+    it('renders inline expression in string', () => {
+        expect(render('Hello ${{ item.name }}!', { item: { name: 'World' } })).toBe('Hello World!');
+    });
+    it('renders multiple inline expressions', () => {
+        expect(render('${{ item.first }}-${{ item.second }}', { item: { first: 'X', second: 'Y' } })).toBe('X-Y');
+    });
+    it('returns non-string values as-is', () => {
+        expect(render(42, {})).toBe(42);
+        expect(render(null, {})).toBeNull();
+        expect(render(undefined, {})).toBeUndefined();
+    });
+    it('returns full expression result as native type', () => {
+        expect(render('${{ args.list }}', { args: { list: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('renders URL template', () => {
+        expect(render('https://api.example.com/search?q=${{ args.keyword }}', { args: { keyword: 'test' } })).toBe('https://api.example.com/search?q=test');
+    });
+});
+describe('normalizeEvaluateSource', () => {
+    it('wraps bare expression', () => {
+        expect(normalizeEvaluateSource('document.title')).toBe('() => (document.title)');
+    });
+    it('passes through arrow function', () => {
+        expect(normalizeEvaluateSource('() => 42')).toBe('() => 42');
+    });
+    it('passes through async arrow function', () => {
+        const src = 'async () => { return 1; }';
+        expect(normalizeEvaluateSource(src)).toBe(src);
+    });
+    it('passes through named function', () => {
+        const src = 'function foo() { return 1; }';
+        expect(normalizeEvaluateSource(src)).toBe(src);
+    });
+    it('wraps IIFE pattern', () => {
+        const src = '(async () => { return 1; })()';
+        expect(normalizeEvaluateSource(src)).toBe(`() => (${src})`);
+    });
+    it('handles empty string', () => {
+        expect(normalizeEvaluateSource('')).toBe('() => undefined');
+    });
+});

package/dist/pipeline/transform.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+export {};

package/dist/pipeline/transform.test.js

@@ -0,0 +1,90 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+import { describe, it, expect } from 'vitest';
+import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
+const SAMPLE_DATA = [
+    { title: 'Alpha', score: 10, author: 'Alice' },
+    { title: 'Beta', score: 30, author: 'Bob' },
+    { title: 'Gamma', score: 20, author: 'Charlie' },
+];
+describe('stepSelect', () => {
+    it('selects nested path', async () => {
+        const data = { result: { items: [1, 2, 3] } };
+        const result = await stepSelect(null, 'result.items', data, {});
+        expect(result).toEqual([1, 2, 3]);
+    });
+    it('selects array by index', async () => {
+        const data = { list: ['a', 'b', 'c'] };
+        const result = await stepSelect(null, 'list.1', data, {});
+        expect(result).toBe('b');
+    });
+    it('returns null for missing path', async () => {
+        const result = await stepSelect(null, 'missing.path', { foo: 1 }, {});
+        expect(result).toBeNull();
+    });
+    it('returns data as-is for non-object', async () => {
+        const result = await stepSelect(null, 'foo', 'string-data', {});
+        expect(result).toBe('string-data');
+    });
+});
+describe('stepMap', () => {
+    it('maps array items', async () => {
+        const result = await stepMap(null, {
+            name: '${{ item.title }}',
+            rank: '${{ index + 1 }}',
+        }, SAMPLE_DATA, {});
+        expect(result).toEqual([
+            { name: 'Alpha', rank: 1 },
+            { name: 'Beta', rank: 2 },
+            { name: 'Gamma', rank: 3 },
+        ]);
+    });
+    it('handles single object', async () => {
+        const result = await stepMap(null, {
+            name: '${{ item.title }}',
+        }, { title: 'Solo' }, {});
+        expect(result).toEqual([{ name: 'Solo' }]);
+    });
+    it('returns null/undefined as-is', async () => {
+        expect(await stepMap(null, { x: '${{ item.x }}' }, null, {})).toBeNull();
+    });
+});
+describe('stepFilter', () => {
+    it('filters by expression', async () => {
+        const result = await stepFilter(null, 'item.score', SAMPLE_DATA, {});
+        expect(result).toHaveLength(3); // all truthy
+    });
+    it('returns non-array as-is', async () => {
+        const result = await stepFilter(null, 'item.x', 'not-array', {});
+        expect(result).toBe('not-array');
+    });
+});
+describe('stepSort', () => {
+    it('sorts ascending by key', async () => {
+        const result = await stepSort(null, 'score', SAMPLE_DATA, {});
+        expect(result.map((r) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
+    });
+    it('sorts descending', async () => {
+        const result = await stepSort(null, { by: 'score', order: 'desc' }, SAMPLE_DATA, {});
+        expect(result.map((r) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
+    });
+    it('does not mutate original', async () => {
+        const original = [...SAMPLE_DATA];
+        await stepSort(null, 'score', SAMPLE_DATA, {});
+        expect(SAMPLE_DATA).toEqual(original);
+    });
+});
+describe('stepLimit', () => {
+    it('limits array to N items', async () => {
+        const result = await stepLimit(null, '2', SAMPLE_DATA, {});
+        expect(result).toHaveLength(2);
+    });
+    it('limits using template expression', async () => {
+        const result = await stepLimit(null, '${{ args.limit }}', SAMPLE_DATA, { limit: 1 });
+        expect(result).toHaveLength(1);
+    });
+    it('returns non-array as-is', async () => {
+        expect(await stepLimit(null, '5', 'string', {})).toBe('string');
+    });
+});

package/dist/pipeline.d.ts

@@ -1,9 +1,7 @@
 /**
- * YAML pipeline executor.
- * Steps: fetch, navigate, evaluate, map, filter, sort, limit, select, snapshot, click, type, wait, press, intercept.
+ * YAML pipeline executor — re-exports from modular pipeline system.
+ *
+ * This file exists for backward compatibility. All logic has been
+ * refactored into src/pipeline/ with modular step handlers.
  */
-export interface PipelineContext {
-    args?: Record<string, any>;
-    debug?: boolean;
-}
-export declare function executePipeline(page: any, pipeline: any[], ctx?: PipelineContext): Promise<any>;
+export { executePipeline, type PipelineContext } from './pipeline/index.js';

package/dist/pipeline.js

@@ -1,315 +1,7 @@
 /**
- * YAML pipeline executor.
- * Steps: fetch, navigate, evaluate, map, filter, sort, limit, select, snapshot, click, type, wait, press, intercept.
+ * YAML pipeline executor — re-exports from modular pipeline system.
+ *
+ * This file exists for backward compatibility. All logic has been
+ * refactored into src/pipeline/ with modular step handlers.
  */
-import chalk from 'chalk';
-export async function executePipeline(page, pipeline, ctx = {}) {
-    const args = ctx.args ?? {};
-    const debug = ctx.debug ?? false;
-    let data = null;
-    const total = pipeline.length;
-    for (let i = 0; i < pipeline.length; i++) {
-        const step = pipeline[i];
-        if (!step || typeof step !== 'object')
-            continue;
-        for (const [op, params] of Object.entries(step)) {
-            if (debug)
-                debugStepStart(i + 1, total, op, params);
-            data = await executeStep(page, op, params, data, args);
-            if (debug)
-                debugStepResult(op, data);
-        }
-    }
-    return data;
-}
-function normalizeEvaluateSource(source) {
-    const stripped = source.trim();
-    if (!stripped)
-        return '() => undefined';
-    if (stripped.startsWith('(') && stripped.endsWith(')()'))
-        return `() => (${stripped})`;
-    if (/^(async\s+)?\([^)]*\)\s*=>/.test(stripped))
-        return stripped;
-    if (/^(async\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=>/.test(stripped))
-        return stripped;
-    if (stripped.startsWith('function ') || stripped.startsWith('async function '))
-        return stripped;
-    return `() => (${stripped})`;
-}
-function debugStepStart(stepNum, total, op, params) {
-    let preview = '';
-    if (typeof params === 'string') {
-        preview = params.length <= 80 ? ` → ${params}` : ` → ${params.slice(0, 77)}...`;
-    }
-    else if (params && typeof params === 'object' && !Array.isArray(params)) {
-        preview = ` (${Object.keys(params).join(', ')})`;
-    }
-    process.stderr.write(`  ${chalk.dim(`[${stepNum}/${total}]`)} ${chalk.bold.cyan(op)}${preview}\n`);
-}
-function debugStepResult(op, data) {
-    if (data === null || data === undefined) {
-        process.stderr.write(`       ${chalk.dim('→ (no data)')}\n`);
-    }
-    else if (Array.isArray(data)) {
-        process.stderr.write(`       ${chalk.dim(`→ ${data.length} items`)}\n`);
-    }
-    else if (typeof data === 'object') {
-        const keys = Object.keys(data).slice(0, 5);
-        process.stderr.write(`       ${chalk.dim(`→ dict (${keys.join(', ')}${Object.keys(data).length > 5 ? '...' : ''})`)}\n`);
-    }
-    else if (typeof data === 'string') {
-        const p = data.slice(0, 60).replace(/\n/g, '\\n');
-        process.stderr.write(`       ${chalk.dim(`→ "${p}${data.length > 60 ? '...' : ''}"`)}\n`);
-    }
-    else {
-        process.stderr.write(`       ${chalk.dim(`→ ${typeof data}`)}\n`);
-    }
-}
-// Single URL fetch helper
-async function fetchSingle(page, url, method, queryParams, headers, args, data) {
-    const renderedParams = {};
-    for (const [k, v] of Object.entries(queryParams))
-        renderedParams[k] = String(render(v, { args, data }));
-    const renderedHeaders = {};
-    for (const [k, v] of Object.entries(headers))
-        renderedHeaders[k] = String(render(v, { args, data }));
-    let finalUrl = url;
-    if (Object.keys(renderedParams).length > 0) {
-        const qs = new URLSearchParams(renderedParams).toString();
-        finalUrl = `${finalUrl}${finalUrl.includes('?') ? '&' : '?'}${qs}`;
-    }
-    if (page === null) {
-        const resp = await fetch(finalUrl, { method: method.toUpperCase(), headers: renderedHeaders });
-        return resp.json();
-    }
-    const headersJs = JSON.stringify(renderedHeaders);
-    const escapedUrl = finalUrl.replace(/"/g, '\\"');
-    return page.evaluate(`
-    async () => {
-      const resp = await fetch("${escapedUrl}", {
-        method: "${method}", headers: ${headersJs}, credentials: "include"
-      });
-      return await resp.json();
-    }
-  `);
-}
-async function executeStep(page, op, params, data, args) {
-    switch (op) {
-        case 'navigate': {
-            const url = render(params, { args, data });
-            await page.goto(String(url));
-            return data;
-        }
-        case 'fetch': {
-            const urlOrObj = typeof params === 'string' ? params : (params?.url ?? '');
-            const method = params?.method ?? 'GET';
-            const queryParams = params?.params ?? {};
-            const headers = params?.headers ?? {};
-            const urlTemplate = String(urlOrObj);
-            // Per-item fetch when data is array and URL references item
-            if (Array.isArray(data) && urlTemplate.includes('item')) {
-                const results = [];
-                for (let i = 0; i < data.length; i++) {
-                    const itemUrl = String(render(urlTemplate, { args, data, item: data[i], index: i }));
-                    results.push(await fetchSingle(page, itemUrl, method, queryParams, headers, args, data));
-                }
-                return results;
-            }
-            const url = render(urlOrObj, { args, data });
-            return fetchSingle(page, String(url), method, queryParams, headers, args, data);
-        }
-        case 'select': {
-            const pathStr = String(render(params, { args, data }));
-            if (data && typeof data === 'object') {
-                let current = data;
-                for (const part of pathStr.split('.')) {
-                    if (current && typeof current === 'object' && !Array.isArray(current))
-                        current = current[part];
-                    else if (Array.isArray(current) && /^\d+$/.test(part))
-                        current = current[parseInt(part, 10)];
-                    else
-                        return null;
-                }
-                return current;
-            }
-            return data;
-        }
-        case 'evaluate': {
-            const js = String(render(params, { args, data }));
-            return page.evaluate(normalizeEvaluateSource(js));
-        }
-        case 'snapshot': {
-            const opts = (typeof params === 'object' && params) ? params : {};
-            return page.snapshot({ interactive: opts.interactive ?? false, compact: opts.compact ?? false, maxDepth: opts.max_depth, raw: opts.raw ?? false });
-        }
-        case 'click': {
-            await page.click(String(render(params, { args, data })).replace(/^@/, ''));
-            return data;
-        }
-        case 'type': {
-            if (typeof params === 'object' && params) {
-                const ref = String(render(params.ref ?? '', { args, data })).replace(/^@/, '');
-                const text = String(render(params.text ?? '', { args, data }));
-                await page.typeText(ref, text);
-                if (params.submit)
-                    await page.pressKey('Enter');
-            }
-            return data;
-        }
-        case 'wait': {
-            if (typeof params === 'number')
-                await page.wait(params);
-            else if (typeof params === 'object' && params) {
-                if ('text' in params) {
-                    const timeout = params.timeout ?? 10;
-                    const start = Date.now();
-                    while ((Date.now() - start) / 1000 < timeout) {
-                        const snap = await page.snapshot({ raw: true });
-                        if (typeof snap === 'string' && snap.includes(params.text))
-                            break;
-                        await page.wait(0.5);
-                    }
-                }
-                else if ('time' in params)
-                    await page.wait(Number(params.time));
-            }
-            else if (typeof params === 'string')
-                await page.wait(Number(render(params, { args, data })));
-            return data;
-        }
-        case 'press': {
-            await page.pressKey(String(render(params, { args, data })));
-            return data;
-        }
-        case 'map': {
-            if (!data || typeof data !== 'object')
-                return data;
-            let items = Array.isArray(data) ? data : [data];
-            if (!Array.isArray(data) && typeof data === 'object' && 'data' in data)
-                items = data.data;
-            const result = [];
-            for (let i = 0; i < items.length; i++) {
-                const item = items[i];
-                const row = {};
-                for (const [key, template] of Object.entries(params))
-                    row[key] = render(template, { args, data, item, index: i });
-                result.push(row);
-            }
-            return result;
-        }
-        case 'filter': {
-            if (!Array.isArray(data))
-                return data;
-            return data.filter((item, i) => evalExpr(String(params), { args, item, index: i }));
-        }
-        case 'sort': {
-            if (!Array.isArray(data))
-                return data;
-            const key = typeof params === 'object' ? (params.by ?? '') : String(params);
-            const reverse = typeof params === 'object' ? params.order === 'desc' : false;
-            return [...data].sort((a, b) => { const va = a[key] ?? ''; const vb = b[key] ?? ''; const cmp = va < vb ? -1 : va > vb ? 1 : 0; return reverse ? -cmp : cmp; });
-        }
-        case 'limit': {
-            if (!Array.isArray(data))
-                return data;
-            return data.slice(0, Number(render(params, { args, data })));
-        }
-        case 'intercept': return data;
-        default: return data;
-    }
-}
-function render(template, ctx) {
-    if (typeof template !== 'string')
-        return template;
-    const fullMatch = template.match(/^\$\{\{\s*(.*?)\s*\}\}$/);
-    if (fullMatch)
-        return evalExpr(fullMatch[1].trim(), ctx);
-    return template.replace(/\$\{\{\s*(.*?)\s*\}\}/g, (_m, expr) => String(evalExpr(expr.trim(), ctx)));
-}
-function evalExpr(expr, ctx) {
-    const args = ctx.args ?? {};
-    const item = ctx.item ?? {};
-    const data = ctx.data;
-    const index = ctx.index ?? 0;
-    // Default filter: args.limit | default(20)
-    if (expr.includes('|') && expr.includes('default(')) {
-        const [mainExpr, rest] = expr.split('|', 2);
-        const defaultMatch = rest.match(/default\((.+?)\)/);
-        const defaultVal = defaultMatch ? defaultMatch[1] : null;
-        const result = resolvePath(mainExpr.trim(), { args, item, data, index });
-        if (result === null || result === undefined) {
-            if (defaultVal !== null) {
-                const intVal = parseInt(defaultVal, 10);
-                if (!isNaN(intVal) && String(intVal) === defaultVal.trim())
-                    return intVal;
-                return defaultVal.replace(/^['"]|['"]$/g, '');
-            }
-        }
-        return result;
-    }
-    // Arithmetic: index + 1
-    const arithMatch = expr.match(/^([\w][\w.]*)\s*([+\-*/])\s*(\d+)$/);
-    if (arithMatch) {
-        const [, varName, op, numStr] = arithMatch;
-        const val = resolvePath(varName, { args, item, data, index });
-        if (val !== null && val !== undefined) {
-            const numVal = Number(val);
-            const num = Number(numStr);
-            if (!isNaN(numVal)) {
-                switch (op) {
-                    case '+': return numVal + num;
-                    case '-': return numVal - num;
-                    case '*': return numVal * num;
-                    case '/': return num !== 0 ? numVal / num : 0;
-                }
-            }
-        }
-    }
-    // JS-like fallback expression: item.tweetCount || 'N/A'
-    const orMatch = expr.match(/^(.+?)\s*\|\|\s*(.+)$/);
-    if (orMatch) {
-        const left = evalExpr(orMatch[1].trim(), ctx);
-        if (left)
-            return left;
-        const right = orMatch[2].trim();
-        return right.replace(/^['"]|['"]$/g, '');
-    }
-    return resolvePath(expr, { args, item, data, index });
-}
-function resolvePath(pathStr, ctx) {
-    const args = ctx.args ?? {};
-    const item = ctx.item ?? {};
-    const data = ctx.data;
-    const index = ctx.index ?? 0;
-    const parts = pathStr.split('.');
-    const rootName = parts[0];
-    let obj;
-    let rest;
-    if (rootName === 'args') {
-        obj = args;
-        rest = parts.slice(1);
-    }
-    else if (rootName === 'item') {
-        obj = item;
-        rest = parts.slice(1);
-    }
-    else if (rootName === 'data') {
-        obj = data;
-        rest = parts.slice(1);
-    }
-    else if (rootName === 'index')
-        return index;
-    else {
-        obj = item;
-        rest = parts;
-    }
-    for (const part of rest) {
-        if (obj && typeof obj === 'object' && !Array.isArray(obj))
-            obj = obj[part];
-        else if (Array.isArray(obj) && /^\d+$/.test(part))
-            obj = obj[parseInt(part, 10)];
-        else
-            return null;
-    }
-    return obj;
-}
+export { executePipeline } from './pipeline/index.js';

package/dist/registry.d.ts

@@ -1,6 +1,7 @@
 /**
  * Core registry: Strategy enum, Arg/CliCommand interfaces, cli() registration.
  */
+import type { IPage } from './types.js';
 export declare enum Strategy {
     PUBLIC = "public",
     COOKIE = "cookie",
@@ -25,7 +26,7 @@ export interface CliCommand {
     browser?: boolean;
     args: Arg[];
     columns?: string[];
-    func?: (page: any, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
+    func?: (page: IPage | null, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
     pipeline?: any[];
     timeoutSeconds?: number;
     source?: string;
@@ -39,7 +40,7 @@ export interface CliOptions {
     browser?: boolean;
     args?: Arg[];
     columns?: string[];
-    func?: (page: any, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
+    func?: (page: IPage | null, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
     pipeline?: any[];
     timeoutSeconds?: number;
 }