@jackwener/opencli 1.7.3 → 1.7.5

package/dist/src/record.test.js

@@ -1,293 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { analyzeRecordedRequests, buildWriteRecordedYaml, createRecordedEntry, generateFullCaptureInterceptorJs, generateRecordedCandidates, } from './record.js';
-import { render } from './pipeline/template.js';
-describe('record request-body capture', () => {
-    it('captures a JSON fetch request body alongside the JSON response body', () => {
-        const entry = createRecordedEntry({
-            url: 'https://api.example.com/tasks',
-            method: 'POST',
-            requestContentType: 'application/json',
-            requestBodyText: '{"title":"Ship #601","priority":"high"}',
-            responseBody: { id: 'task_123', ok: true },
-        });
-        expect(entry).toMatchObject({
-            method: 'POST',
-            requestContentType: 'application/json',
-            requestBody: { title: 'Ship #601', priority: 'high' },
-            responseBody: { id: 'task_123', ok: true },
-        });
-    });
-    it('captures a JSON request body from fetch(Request)', async () => {
-        class MockXMLHttpRequest {
-            open() { }
-            send() { }
-            setRequestHeader() { }
-            addEventListener() { }
-            getResponseHeader() { return null; }
-            responseText = '';
-        }
-        const mockFetch = vi.fn(async () => new Response(JSON.stringify({ id: 'task_123', ok: true }), { headers: { 'content-type': 'application/json' } }));
-        vi.stubGlobal('fetch', mockFetch);
-        vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
-        vi.stubGlobal('window', globalThis);
-        // eslint-disable-next-line no-eval
-        eval(generateFullCaptureInterceptorJs());
-        const request = new Request('https://api.example.com/tasks', {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ title: 'Ship #601' }),
-        });
-        await globalThis.fetch(request);
-        const recorded = globalThis.__opencli_record;
-        expect(recorded).toHaveLength(1);
-        expect(recorded?.[0]?.requestBody).toEqual({ title: 'Ship #601' });
-    });
-    it('captures a JSON request body from XHR send()', async () => {
-        class MockXMLHttpRequest {
-            __listeners = {};
-            __rec_url;
-            __rec_method;
-            __rec_request_content_type;
-            responseText = JSON.stringify({ id: 'task_456', ok: true });
-            open(method, url) {
-                this.__rec_method = method;
-                this.__rec_url = url;
-            }
-            send() {
-                for (const listener of this.__listeners.load ?? [])
-                    listener.call(this);
-            }
-            setRequestHeader(name, value) {
-                if (name.toLowerCase() === 'content-type')
-                    this.__rec_request_content_type = value;
-            }
-            addEventListener(event, listener) {
-                this.__listeners[event] ??= [];
-                this.__listeners[event].push(listener);
-            }
-            getResponseHeader(name) {
-                return name.toLowerCase() === 'content-type' ? 'application/json' : null;
-            }
-        }
-        const mockFetch = vi.fn(async () => new Response(JSON.stringify({ ok: true }), { headers: { 'content-type': 'application/json' } }));
-        vi.stubGlobal('fetch', mockFetch);
-        vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
-        vi.stubGlobal('window', globalThis);
-        // eslint-disable-next-line no-eval
-        eval(generateFullCaptureInterceptorJs());
-        const xhr = new XMLHttpRequest();
-        xhr.open('PATCH', 'https://api.example.com/tasks/submit');
-        xhr.setRequestHeader('content-type', 'application/json;charset=utf-8');
-        xhr.send('{"done":true}');
-        const recorded = globalThis.__opencli_record;
-        expect(recorded).toHaveLength(1);
-        expect(recorded?.[0]?.requestBody).toEqual({ done: true });
-    });
-    it('does not interrupt fetch when reading a Request body fails', async () => {
-        class MockXMLHttpRequest {
-            open() { }
-            send() { }
-            setRequestHeader() { }
-            addEventListener() { }
-            getResponseHeader() { return null; }
-            responseText = '';
-        }
-        class BrokenRequest extends Request {
-            clone() {
-                throw new Error('clone failed');
-            }
-        }
-        const mockFetch = vi.fn(async () => new Response(JSON.stringify({ id: 'task_123', ok: true }), { headers: { 'content-type': 'application/json' } }));
-        vi.stubGlobal('fetch', mockFetch);
-        vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
-        vi.stubGlobal('window', globalThis);
-        // eslint-disable-next-line no-eval
-        eval(generateFullCaptureInterceptorJs());
-        const request = new BrokenRequest('https://api.example.com/tasks', {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ title: 'Ship #601' }),
-        });
-        await expect(globalThis.fetch(request)).resolves.toBeInstanceOf(Response);
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-});
-describe('record write candidates', () => {
-    it('keeps a POST request with JSON request body and object response as a write candidate', () => {
-        const result = analyzeRecordedRequests([
-            createRecordedEntry({
-                url: 'https://api.example.com/tasks/create',
-                method: 'POST',
-                requestContentType: 'application/json',
-                requestBodyText: '{"title":"Ship #601"}',
-                responseBody: { id: 'task_123', ok: true },
-            }),
-        ]);
-        expect(result.candidates).toHaveLength(1);
-        expect(result.candidates[0]).toMatchObject({
-            kind: 'write',
-            req: { method: 'POST' },
-        });
-    });
-    it('accepts vendor JSON content types for write candidates', () => {
-        const result = analyzeRecordedRequests([
-            createRecordedEntry({
-                url: 'https://api.example.com/tasks',
-                method: 'POST',
-                requestContentType: 'application/vnd.api+json',
-                requestBodyText: '{"title":"Ship #601"}',
-                responseBody: { id: 'task_123', ok: true },
-            }),
-        ]);
-        expect(result.candidates).toHaveLength(1);
-        expect(result.candidates[0]).toMatchObject({
-            kind: 'write',
-            req: { method: 'POST' },
-        });
-    });
-    it('rejects a POST request that has no usable JSON request body', () => {
-        const result = analyzeRecordedRequests([
-            createRecordedEntry({
-                url: 'https://api.example.com/tasks/create',
-                method: 'POST',
-                requestContentType: 'application/json',
-                requestBodyText: '',
-                responseBody: { id: 'task_123', ok: true },
-            }),
-        ]);
-        expect(result.candidates).toEqual([]);
-    });
-    it('rejects array request and response bodies for first-version write candidates', () => {
-        const result = analyzeRecordedRequests([
-            createRecordedEntry({
-                url: 'https://api.example.com/tasks/batch',
-                method: 'POST',
-                requestContentType: 'application/json',
-                requestBodyText: '[{"title":"Ship #601"}]',
-                responseBody: [{ id: 'task_123' }],
-            }),
-        ]);
-        expect(result.candidates).toEqual([]);
-    });
-    it('generates a write YAML candidate from a replayable JSON write request', () => {
-        const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
-            createRecordedEntry({
-                url: 'https://api.example.com/tasks/create',
-                method: 'POST',
-                requestContentType: 'application/json',
-                requestBodyText: '{"title":"Ship #601"}',
-                responseBody: { id: 'task_123', ok: true },
-            }),
-        ]);
-        expect(candidates).toHaveLength(1);
-        expect(candidates[0]).toMatchObject({
-            kind: 'write',
-            name: 'create',
-            strategy: 'cookie',
-        });
-        expect(JSON.stringify(candidates[0].yaml)).toContain('Ship #601');
-    });
-    it('builds a write template that replays the recorded JSON body with application/json', () => {
-        const candidate = buildWriteRecordedYaml('demo', 'https://demo.example.com/app', createRecordedEntry({
-            url: 'https://api.example.com/tasks/create',
-            method: 'POST',
-            requestContentType: 'application/json',
-            requestBodyText: '{"title":"Ship #601"}',
-            responseBody: { id: 'task_123', ok: true },
-        }), 'create');
-        expect(candidate.name).toBe('create');
-        expect(JSON.stringify(candidate.yaml)).toContain('method: \\"POST\\"');
-        expect(JSON.stringify(candidate.yaml)).toContain('content-type');
-        expect(JSON.stringify(candidate.yaml)).toContain('Ship #601');
-    });
-});
-describe('record read candidates', () => {
-    it('keeps existing read candidates for array responses', () => {
-        const result = analyzeRecordedRequests([
-            {
-                url: 'https://api.example.com/feed',
-                method: 'GET',
-                status: null,
-                requestContentType: null,
-                responseContentType: 'application/json',
-                requestBody: null,
-                responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
-                contentType: 'application/json',
-                body: { items: [{ title: 'A' }, { title: 'B' }] },
-                capturedAt: 1,
-            },
-        ]);
-        expect(result.candidates).toHaveLength(1);
-        expect(result.candidates[0]).toMatchObject({ kind: 'read' });
-    });
-    it('keeps read YAML generation on the baseline fetch path', () => {
-        const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
-            createRecordedEntry({
-                url: 'https://api.example.com/search?q=test',
-                method: 'GET',
-                responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
-            }),
-        ]);
-        const yaml = candidates[0].yaml;
-        expect(yaml.pipeline[1]?.evaluate).toContain(`fetch("https://api.example.com/search?q=`);
-        expect(yaml.pipeline[1]?.evaluate).toContain(`{ credentials: 'include' }`);
-        expect(yaml.pipeline[1]?.evaluate).not.toContain('method: "POST"');
-        expect(yaml.pipeline[1]?.evaluate).not.toContain('body: JSON.stringify');
-    });
-    it('renders search and page args into the read YAML fetch URL', () => {
-        const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
-            createRecordedEntry({
-                url: 'https://api.example.com/search?q=test&page=2',
-                method: 'GET',
-                responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
-            }),
-        ]);
-        const yaml = candidates[0].yaml;
-        const renderedEvaluate = render(yaml.pipeline[1]?.evaluate, {
-            args: { keyword: 'desk', page: 3 },
-        });
-        expect(renderedEvaluate).toContain('https://api.example.com/search?q=desk&page=3');
-    });
-    it('keeps GET and POST candidates separate when they share the same URL pattern', () => {
-        const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
-            createRecordedEntry({
-                url: 'https://api.example.com/tasks',
-                method: 'GET',
-                responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
-            }),
-            createRecordedEntry({
-                url: 'https://api.example.com/tasks',
-                method: 'POST',
-                requestContentType: 'application/json',
-                requestBodyText: '{"title":"Ship #601"}',
-                responseBody: { id: 'task_123', ok: true },
-            }),
-        ]);
-        expect(candidates).toHaveLength(2);
-        expect(candidates.some((candidate) => candidate.kind === 'read')).toBe(true);
-        expect(candidates.some((candidate) => candidate.kind === 'write')).toBe(true);
-    });
-});
-describe('record noise filtering', () => {
-    it('filters analytics POST noise from write candidates', () => {
-        const result = analyzeRecordedRequests([
-            createRecordedEntry({
-                url: 'https://api.example.com/analytics/event',
-                method: 'POST',
-                requestContentType: 'application/json',
-                requestBodyText: '{"event":"click"}',
-                responseBody: { ok: true, accepted: 1 },
-            }),
-        ]);
-        expect(result.candidates).toEqual([]);
-    });
-});
-afterEach(() => {
-    vi.unstubAllGlobals();
-    Reflect.deleteProperty(globalThis, '__opencli_record');
-    Reflect.deleteProperty(globalThis, '__opencli_record_patched');
-    Reflect.deleteProperty(globalThis, '__opencli_orig_fetch');
-    Reflect.deleteProperty(globalThis, '__opencli_orig_xhr_open');
-    Reflect.deleteProperty(globalThis, '__opencli_orig_xhr_send');
-    Reflect.deleteProperty(globalThis, '__opencli_orig_xhr_set_request_header');
-});

package/dist/src/skill-generate.d.ts

@@ -1,30 +0,0 @@
-/**
- * Generate skill: thin wrapper over generateVerifiedFromUrl.
- *
- * Maps GenerateOutcome → SkillOutput.
- * Used by `opencli generate <url>` (automated path in opencli-explorer workflow).
- *
- * Design:
- *   - Input: url + goal? (user intent, not execution strategy)
- *   - Output: machine-readable decision fields + human-readable message
- *   - Single source of truth: P1 GenerateOutcome
- *   - No re-orchestration, no auto-escalation to browser
- */
-import { type GenerateOutcome, type StopReason, type EscalationReason, type SuggestedAction, type Reusability } from './generate-verified.js';
-import type { IBrowserFactory } from './runtime.js';
-export interface SkillInput {
-    url: string;
-    goal?: string;
-}
-export interface SkillOutput {
-    conclusion: 'success' | 'blocked' | 'needs-human-check';
-    reason?: StopReason | EscalationReason;
-    suggested_action?: SuggestedAction;
-    reusability?: Reusability;
-    command?: string;
-    strategy?: string;
-    path?: string;
-    message: string;
-}
-export declare function mapOutcomeToSkillOutput(outcome: GenerateOutcome): SkillOutput;
-export declare function executeGenerateSkill(input: SkillInput, BrowserFactory: new () => IBrowserFactory): Promise<SkillOutput>;

package/dist/src/skill-generate.js

@@ -1,75 +0,0 @@
-/**
- * Generate skill: thin wrapper over generateVerifiedFromUrl.
- *
- * Maps GenerateOutcome → SkillOutput.
- * Used by `opencli generate <url>` (automated path in opencli-explorer workflow).
- *
- * Design:
- *   - Input: url + goal? (user intent, not execution strategy)
- *   - Output: machine-readable decision fields + human-readable message
- *   - Single source of truth: P1 GenerateOutcome
- *   - No re-orchestration, no auto-escalation to browser
- */
-import { generateVerifiedFromUrl, } from './generate-verified.js';
-// ── Message Templates ────────────────────────────────────────────────────────
-const BLOCKED_MESSAGES = {
-    'no-viable-api-surface': '该站点没有发现可用的 JSON API 接口，无法自动生成 CLI',
-    'auth-too-complex': '所有接口都需要超出自动化能力的认证方式（如 signature/bearer），无法自动生成',
-    'no-viable-candidate': '发现了 API 接口，但未能合成有效的 CLI 候选',
-    'execution-environment-unavailable': '浏览器未连接，请先运行 opencli doctor 检查环境',
-};
-const ESCALATION_MESSAGES = {
-    'unsupported-required-args': () => '候选需要用户提供必填参数的示例值后重试',
-    'empty-result': () => '候选验证返回空结果，建议用 opencli-browser 检查',
-    'sparse-fields': () => '候选验证结果字段不足，建议人工检查',
-    'non-array-result': () => '返回结果不是数组格式，建议用 opencli-browser 检查接口返回结构',
-    'timeout': () => '验证超时，建议用 opencli-browser 手动检查接口响应',
-    'selector-mismatch': () => '数据路径不匹配，建议用 opencli-browser 检查实际返回结构',
-    'verify-inconclusive': (ctx) => ctx?.path
-        ? `验证结果不确定，候选已保存在 ${ctx.path}，需要人工审查`
-        : '验证结果不确定，需要人工审查',
-};
-// ── Core Mapping ─────────────────────────────────────────────────────────────
-export function mapOutcomeToSkillOutput(outcome) {
-    switch (outcome.status) {
-        case 'success':
-            return {
-                conclusion: 'success',
-                reusability: outcome.reusability ?? 'verified-artifact',
-                command: outcome.adapter?.command,
-                strategy: outcome.adapter?.strategy,
-                path: outcome.adapter?.path,
-                message: `已生成 ${outcome.adapter?.command ?? 'unknown'}，可直接使用。策略: ${outcome.adapter?.strategy ?? 'unknown'}`,
-            };
-        case 'blocked':
-            return {
-                conclusion: 'blocked',
-                reason: outcome.reason,
-                message: BLOCKED_MESSAGES[outcome.reason] ?? outcome.message ?? '生成被阻断',
-            };
-        case 'needs-human-check': {
-            const escalation = outcome.escalation;
-            const reason = escalation?.reason;
-            const candidatePath = escalation?.candidate?.path ?? undefined;
-            const messageFn = reason ? ESCALATION_MESSAGES[reason] : undefined;
-            return {
-                conclusion: 'needs-human-check',
-                reason,
-                suggested_action: escalation?.suggested_action,
-                reusability: outcome.reusability,
-                path: candidatePath ?? undefined,
-                message: outcome.message ?? messageFn?.({ path: candidatePath ?? undefined }) ?? '需要人工检查',
-            };
-        }
-    }
-}
-// ── Skill Entry Point ────────────────────────────────────────────────────────
-export async function executeGenerateSkill(input, BrowserFactory) {
-    const opts = {
-        url: input.url,
-        BrowserFactory,
-        goal: input.goal ?? null,
-    };
-    const outcome = await generateVerifiedFromUrl(opts);
-    return mapOutcomeToSkillOutput(outcome);
-}

package/dist/src/skill-generate.test.js

@@ -1,173 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { mapOutcomeToSkillOutput } from './skill-generate.js';
-import { Strategy } from './registry.js';
-describe('mapOutcomeToSkillOutput', () => {
-    const baseStats = {
-        endpoint_count: 1,
-        api_endpoint_count: 1,
-        candidate_count: 1,
-        verified: false,
-        repair_attempted: false,
-        explore_dir: '/tmp/test',
-    };
-    it('maps success outcome correctly', () => {
-        const outcome = {
-            status: 'success',
-            adapter: {
-                site: 'demo',
-                name: 'hot',
-                command: 'demo/hot',
-                strategy: Strategy.PUBLIC,
-                path: '/tmp/demo/hot.verified.ts',
-                metadata_path: '/tmp/demo/hot.meta.json',
-                reusability: 'verified-artifact',
-            },
-            reusability: 'verified-artifact',
-            stats: { ...baseStats, verified: true },
-        };
-        const result = mapOutcomeToSkillOutput(outcome);
-        expect(result.conclusion).toBe('success');
-        expect(result.reusability).toBe('verified-artifact');
-        expect(result.command).toBe('demo/hot');
-        expect(result.strategy).toBe('public');
-        expect(result.path).toBe('/tmp/demo/hot.verified.ts');
-        expect(result.message).toContain('demo/hot');
-        expect(result.reason).toBeUndefined();
-        expect(result.suggested_action).toBeUndefined();
-    });
-    it('maps blocked outcome with no-viable-api-surface', () => {
-        const outcome = {
-            status: 'blocked',
-            reason: 'no-viable-api-surface',
-            stage: 'explore',
-            confidence: 'high',
-            message: 'No API endpoints',
-            stats: { ...baseStats, api_endpoint_count: 0 },
-        };
-        const result = mapOutcomeToSkillOutput(outcome);
-        expect(result.conclusion).toBe('blocked');
-        expect(result.reason).toBe('no-viable-api-surface');
-        expect(result.message).toContain('JSON API');
-        expect(result.command).toBeUndefined();
-        expect(result.suggested_action).toBeUndefined();
-    });
-    it('maps blocked outcome with auth-too-complex', () => {
-        const outcome = {
-            status: 'blocked',
-            reason: 'auth-too-complex',
-            stage: 'cascade',
-            confidence: 'high',
-            stats: baseStats,
-        };
-        const result = mapOutcomeToSkillOutput(outcome);
-        expect(result.conclusion).toBe('blocked');
-        expect(result.reason).toBe('auth-too-complex');
-        expect(result.message).toContain('认证');
-    });
-    it('maps blocked outcome with execution-environment-unavailable', () => {
-        const outcome = {
-            status: 'blocked',
-            reason: 'execution-environment-unavailable',
-            stage: 'verify',
-            confidence: 'high',
-            stats: baseStats,
-        };
-        const result = mapOutcomeToSkillOutput(outcome);
-        expect(result.conclusion).toBe('blocked');
-        expect(result.reason).toBe('execution-environment-unavailable');
-        expect(result.message).toContain('doctor');
-    });
-    it('maps needs-human-check with unsupported-required-args', () => {
-        const outcome = {
-            status: 'needs-human-check',
-            escalation: {
-                stage: 'synthesize',
-                reason: 'unsupported-required-args',
-                confidence: 'high',
-                suggested_action: 'ask-for-sample-arg',
-                candidate: {
-                    name: 'detail',
-                    command: 'demo/detail',
-                    path: '/tmp/demo/detail.verified.ts',
-                    reusability: 'unverified-candidate',
-                },
-            },
-            reusability: 'unverified-candidate',
-            message: 'required args: id',
-            stats: baseStats,
-        };
-        const result = mapOutcomeToSkillOutput(outcome);
-        expect(result.conclusion).toBe('needs-human-check');
-        expect(result.reason).toBe('unsupported-required-args');
-        expect(result.suggested_action).toBe('ask-for-sample-arg');
-        expect(result.reusability).toBe('unverified-candidate');
-        expect(result.path).toBe('/tmp/demo/detail.verified.ts');
-        expect(result.message).toContain('required args: id');
-    });
-    it('maps needs-human-check with empty-result (inspect-with-browser)', () => {
-        const outcome = {
-            status: 'needs-human-check',
-            escalation: {
-                stage: 'fallback',
-                reason: 'empty-result',
-                confidence: 'low',
-                suggested_action: 'inspect-with-browser',
-                candidate: {
-                    name: 'hot',
-                    command: 'demo/hot',
-                    path: null,
-                    reusability: 'unverified-candidate',
-                },
-            },
-            reusability: 'unverified-candidate',
-            stats: { ...baseStats, repair_attempted: true },
-        };
-        const result = mapOutcomeToSkillOutput(outcome);
-        expect(result.conclusion).toBe('needs-human-check');
-        expect(result.reason).toBe('empty-result');
-        expect(result.suggested_action).toBe('inspect-with-browser');
-        expect(result.path).toBeUndefined();
-        expect(result.message).toContain('空结果');
-    });
-    it('maps needs-human-check with verify-inconclusive and path', () => {
-        const outcome = {
-            status: 'needs-human-check',
-            escalation: {
-                stage: 'verify',
-                reason: 'verify-inconclusive',
-                confidence: 'low',
-                suggested_action: 'manual-review',
-                candidate: {
-                    name: 'hot',
-                    command: 'demo/hot',
-                    path: '/tmp/demo/hot.verified.ts',
-                    reusability: 'unverified-candidate',
-                },
-            },
-            reusability: 'unverified-candidate',
-            stats: baseStats,
-        };
-        const result = mapOutcomeToSkillOutput(outcome);
-        expect(result.conclusion).toBe('needs-human-check');
-        expect(result.reason).toBe('verify-inconclusive');
-        expect(result.suggested_action).toBe('manual-review');
-        expect(result.path).toBe('/tmp/demo/hot.verified.ts');
-        expect(result.message).toContain('/tmp/demo/hot.verified.ts');
-    });
-    it('output satisfies SkillOutput contract shape', () => {
-        const outcome = {
-            status: 'blocked',
-            reason: 'no-viable-candidate',
-            stage: 'synthesize',
-            confidence: 'medium',
-            stats: baseStats,
-        };
-        const result = mapOutcomeToSkillOutput(outcome);
-        // Every SkillOutput must have conclusion + message
-        expect(result).toHaveProperty('conclusion');
-        expect(result).toHaveProperty('message');
-        expect(['success', 'blocked', 'needs-human-check']).toContain(result.conclusion);
-        expect(typeof result.message).toBe('string');
-        expect(result.message.length).toBeGreaterThan(0);
-    });
-});

package/dist/src/synthesize.d.ts

@@ -1,97 +0,0 @@
-/**
- * Synthesize candidate CLIs from explore artifacts.
- * Generates evaluate-based pipelines (matching hand-written adapter patterns).
- */
-import type { ExploreAuthSummary, ExploreEndpointArtifact, ExploreManifest } from './explore.js';
-interface RecommendedArg {
-    name: string;
-    type?: string;
-    required?: boolean;
-    default?: unknown;
-}
-interface StoreHint {
-    store: string;
-    action: string;
-}
-export interface SynthesizeCapability {
-    name: string;
-    description: string;
-    strategy: string;
-    endpoint?: string;
-    itemPath?: string | null;
-    recommendedColumns?: string[];
-    recommendedArgs?: RecommendedArg[];
-    storeHint?: StoreHint;
-}
-export interface GeneratedArgDefinition {
-    type: string;
-    required?: boolean;
-    default?: unknown;
-    description?: string;
-}
-type CandidatePipelineStep = {
-    navigate: string;
-} | {
-    wait: number;
-} | {
-    evaluate: string;
-} | {
-    select: string;
-} | {
-    map: Record<string, string>;
-} | {
-    limit: string;
-} | {
-    fetch: {
-        url: string;
-    };
-} | {
-    tap: {
-        store: string;
-        action: string;
-        timeout: number;
-        capture?: string;
-        select?: string | null;
-    };
-};
-export interface CandidateYaml {
-    site: string;
-    name: string;
-    description: string;
-    domain: string;
-    strategy: string;
-    browser: boolean;
-    args: Record<string, GeneratedArgDefinition>;
-    pipeline: CandidatePipelineStep[];
-    columns: string[];
-}
-export interface SynthesizeCandidateSummary {
-    name: string;
-    path: string;
-    strategy: string;
-}
-export interface SynthesizeResult {
-    site: string;
-    explore_dir: string;
-    out_dir: string;
-    candidate_count: number;
-    candidates: SynthesizeCandidateSummary[];
-}
-interface LoadedExploreBundle {
-    manifest: ExploreManifest;
-    endpoints: ExploreEndpointArtifact[];
-    capabilities: SynthesizeCapability[];
-    auth: ExploreAuthSummary;
-}
-export declare function synthesizeFromExplore(target: string, opts?: {
-    outDir?: string;
-    top?: number;
-}): SynthesizeResult;
-export declare function renderSynthesizeSummary(result: SynthesizeResult): string;
-export declare function resolveExploreDir(target: string): string;
-export declare function loadExploreBundle(exploreDir: string): LoadedExploreBundle;
-export declare function buildCandidate(site: string, targetUrl: string, cap: SynthesizeCapability, endpoint: ExploreEndpointArtifact): {
-    name: string;
-    yaml: CandidateYaml;
-};
-export {};