@jackwener/opencli 1.6.7 → 1.6.8

package/dist/src/discovery.js

@@ -15,6 +15,7 @@ import yaml from 'js-yaml';
 import { Strategy, registerCommand } from './registry.js';
 import { getErrorMessage } from './errors.js';
 import { log } from './logger.js';
+import { findPackageRoot, getCliManifestPath, getFetchAdaptersScriptPath } from './package-paths.js';
 /** User runtime directory: ~/.opencli */
 export const USER_OPENCLI_DIR = path.join(os.homedir(), '.opencli');
 /** User CLIs directory: ~/.opencli/clis */
@@ -31,18 +32,7 @@ function parseStrategy(rawStrategy, fallback = Strategy.COOKIE) {
     return Strategy[key] ?? fallback;
 }
 import { isRecord } from './utils.js';
-/**
- * Find the package root (directory containing package.json).
- * Dev: import.meta.url is in src/ → one level up.
- * Prod: import.meta.url is in dist/src/ → two levels up.
- */
-function findPackageRoot() {
-    let dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-    if (!fs.existsSync(path.join(dir, 'package.json'))) {
-        dir = path.resolve(dir, '..');
-    }
-    return dir;
-}
+const PACKAGE_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
 /**
  * Ensure ~/.opencli/node_modules/@jackwener/opencli symlink exists so that
  * user CLIs in ~/.opencli/clis/ can `import { cli } from '@jackwener/opencli/registry'`.
@@ -65,7 +55,7 @@ export async function ensureUserCliCompatShims(baseDir = USER_OPENCLI_DIR) {
         await fs.promises.writeFile(pkgJsonPath, pkgJsonContent, 'utf-8');
     }
     // Create node_modules/@jackwener/opencli symlink pointing to the installed package root.
-    const opencliRoot = findPackageRoot();
+    const opencliRoot = PACKAGE_ROOT;
     const symlinkDir = path.join(baseDir, 'node_modules', '@jackwener');
     const symlinkPath = path.join(symlinkDir, 'opencli');
     try {
@@ -116,7 +106,7 @@ export async function ensureUserAdapters() {
     log.info('First run detected — copying adapters (one-time setup)...');
     try {
         const { execFileSync } = await import('node:child_process');
-        const scriptPath = path.join(findPackageRoot(), 'scripts', 'fetch-adapters.js');
+        const scriptPath = getFetchAdaptersScriptPath(PACKAGE_ROOT);
         execFileSync(process.execPath, [scriptPath], {
             stdio: 'inherit',
             env: { ...process.env, _OPENCLI_FIRST_RUN: '1' },
@@ -135,7 +125,7 @@ export async function ensureUserAdapters() {
 export async function discoverClis(...dirs) {
     // Fast path: try manifest first (production / post-build)
     for (const dir of dirs) {
-        const manifestPath = path.resolve(dir, '..', 'cli-manifest.json');
+        const manifestPath = getCliManifestPath(dir);
         try {
             await fs.promises.access(manifestPath);
             const loaded = await loadFromManifest(manifestPath, dir);
@@ -173,7 +163,7 @@ async function loadFromManifest(manifestPath, clisDir) {
                     columns: entry.columns,
                     pipeline: entry.pipeline,
                     timeoutSeconds: entry.timeout,
-                    source: `manifest:${entry.site}/${entry.name}`,
+                    source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : `manifest:${entry.site}/${entry.name}`,
                     deprecated: entry.deprecated,
                     replacedBy: entry.replacedBy,
                     navigateBefore: entry.navigateBefore,
@@ -196,7 +186,7 @@ async function loadFromManifest(manifestPath, clisDir) {
                     args: entry.args ?? [],
                     columns: entry.columns,
                     timeoutSeconds: entry.timeout,
-                    source: modulePath,
+                    source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : modulePath,
                     deprecated: entry.deprecated,
                     replacedBy: entry.replacedBy,
                     navigateBefore: entry.navigateBefore,

package/dist/src/download/progress.js

@@ -23,8 +23,13 @@ export function formatDuration(ms) {
     if (seconds < 60)
         return `${seconds}s`;
     const minutes = Math.floor(seconds / 60);
-    const remainingSeconds = seconds % 60;
-    return `${minutes}m ${remainingSeconds}s`;
+    if (minutes < 60) {
+        const remainingSeconds = seconds % 60;
+        return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
 }
 /**
  * Create a simple progress bar for terminal display.

package/dist/src/explore.d.ts

@@ -12,7 +12,6 @@ interface InferredCapability {
     name: string;
     description: string;
     strategy: string;
-    confidence: number;
     endpoint: string;
     itemPath: string | null;
     recommendedColumns: string[];
@@ -52,7 +51,6 @@ export interface ExploreEndpointArtifact {
     url: string;
     status: number | null;
     contentType: string;
-    score: number;
     queryParams: string[];
     itemPath: string | null;
     itemCount: number;

package/dist/src/explore.js

@@ -13,7 +13,7 @@ import { detectFramework } from './scripts/framework.js';
 import { discoverStores } from './scripts/store.js';
 import { interactFuzz } from './scripts/interact.js';
 import { log } from './logger.js';
-import { urlToPattern, findArrayPath, flattenFields, detectFieldRoles, inferCapabilityName, inferStrategy, detectAuthFromHeaders, classifyQueryParams, } from './analysis.js';
+import { urlToPattern, findArrayPath, flattenFields, detectFieldRoles, inferCapabilityName, inferStrategy, detectAuthFromHeaders, classifyQueryParams, isNoiseUrl, } from './analysis.js';
 // ── Site name detection ────────────────────────────────────────────────────
 const KNOWN_SITE_ALIASES = {
     'x.com': 'twitter', 'twitter.com': 'twitter',
@@ -66,13 +66,29 @@ function parseNetworkRequests(raw) {
         return entries;
     }
     if (Array.isArray(raw)) {
-        return raw.filter(e => e && typeof e === 'object').map(e => ({
-            method: (e.method ?? 'GET').toUpperCase(),
-            url: String(e.url ?? e.request?.url ?? e.requestUrl ?? ''),
-            status: e.status ?? e.statusCode ?? null,
-            contentType: e.contentType ?? e.response?.contentType ?? '',
-            responseBody: e.responseBody, requestHeaders: e.requestHeaders,
-        }));
+        return raw.filter(e => e && typeof e === 'object').map(e => {
+            // Handle both legacy shape (status/contentType/responseBody) and
+            // extension/CDP capture shape (responseStatus/responseContentType/responsePreview)
+            let body = e.responseBody;
+            if (body === undefined && e.responsePreview !== undefined) {
+                const preview = e.responsePreview;
+                if (typeof preview === 'string') {
+                    try {
+                        body = JSON.parse(preview);
+                    }
+                    catch {
+                        body = preview;
+                    }
+                }
+            }
+            return {
+                method: (e.method ?? 'GET').toUpperCase(),
+                url: String(e.url ?? e.request?.url ?? e.requestUrl ?? ''),
+                status: e.status ?? e.responseStatus ?? e.statusCode ?? null,
+                contentType: e.contentType ?? e.responseContentType ?? e.response?.contentType ?? '',
+                responseBody: body, requestHeaders: e.requestHeaders,
+            };
+        });
     }
     return [];
 }
@@ -91,29 +107,32 @@ function isBooleanRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value)
         && Object.values(value).every(v => typeof v === 'boolean');
 }
-function scoreEndpoint(ep) {
-    let s = 0;
-    if (ep.contentType.includes('json'))
-        s += 10;
-    if (ep.responseAnalysis) {
-        s += 5;
-        s += Math.min(ep.responseAnalysis.itemCount, 10);
-        s += Object.keys(ep.responseAnalysis.detectedFields).length * 2;
-    }
+/**
+ * Deterministic sort key for endpoint ordering — transparent, observable signals only.
+ * Used by generate/synthesize to pick a stable default candidate.
+ * Not exposed externally; AI agents see the raw metadata and decide for themselves.
+ */
+function endpointSortKey(ep) {
+    let k = 0;
+    // Prefer endpoints with array data (list APIs are more useful for automation)
+    const items = ep.responseAnalysis?.itemCount ?? 0;
+    if (items > 0)
+        k += 100 + Math.min(items, 50);
+    // Prefer endpoints with detected semantic fields
+    k += Object.keys(ep.responseAnalysis?.detectedFields ?? {}).length * 10;
+    // Prefer API-style paths
     if (ep.pattern.includes('/api/') || ep.pattern.includes('/x/'))
-        s += 3;
-    if (ep.hasSearchParam)
-        s += 3;
-    if (ep.hasPaginationParam)
-        s += 2;
-    if (ep.hasLimitParam)
-        s += 2;
-    if (ep.status === 200)
-        s += 2;
-    // Anti-Bot Empty Value Detection: penalize JSON endpoints returning empty data
-    if (ep.responseAnalysis && ep.responseAnalysis.itemCount === 0 && ep.contentType.includes('json'))
-        s -= 3;
-    return s;
+        k += 5;
+    // Prefer endpoints with query params (more likely to be parameterized APIs)
+    if (ep.hasSearchParam || ep.hasPaginationParam || ep.hasLimitParam)
+        k += 5;
+    return k;
+}
+/** Check whether an endpoint carries useful structured data (any JSON response, not noise). */
+function isUsefulEndpoint(ep) {
+    if (isNoiseUrl(ep.url))
+        return false;
+    return ep.contentType.includes('json');
 }
 // ── Framework detection ────────────────────────────────────────────────────
 const FRAMEWORK_DETECT_JS = detectFramework.toString();
@@ -122,7 +141,7 @@ const STORE_DISCOVER_JS = discoverStores.toString();
 // ── Auto-Interaction (Fuzzing) ─────────────────────────────────────────────
 const INTERACT_FUZZ_JS = interactFuzz.toString();
 // ── Analysis helpers (extracted from exploreUrl) ───────────────────────────
-/** Filter, deduplicate, and score network endpoints. */
+/** Filter and deduplicate network endpoints, keeping only useful structured-data APIs. */
 function analyzeEndpoints(networkEntries) {
     const seen = new Map();
     for (const entry of networkEntries) {
@@ -145,12 +164,13 @@ function analyzeEndpoints(networkEntries) {
             hasLimitParam: hasLimit || qp.some(p => LIMIT_PARAMS.has(p)),
             authIndicators: detectAuthFromHeaders(entry.requestHeaders),
             responseAnalysis: entry.responseBody ? analyzeResponseBody(entry.responseBody) : null,
-            score: 0,
         };
-        ep.score = scoreEndpoint(ep);
         seen.set(key, ep);
     }
-    const analyzed = [...seen.values()].filter(ep => ep.score >= 5).sort((a, b) => b.score - a.score);
+    // Filter to useful endpoints; deterministic ordering by observable metadata signals
+    const analyzed = [...seen.values()]
+        .filter(isUsefulEndpoint)
+        .sort((a, b) => endpointSortKey(b) - endpointSortKey(a));
     return { analyzed, totalCount: seen.size };
 }
 /** Infer CLI capabilities from analyzed endpoints. */
@@ -192,7 +212,7 @@ function inferCapabilitiesFromEndpoints(endpoints, stores, opts) {
         capabilities.push({
             name: capName, description: `${opts.site ?? detectSiteName(opts.url)} ${capName}`,
             strategy: storeHint ? 'store-action' : epStrategy,
-            confidence: Math.min(ep.score / 20, 1.0), endpoint: ep.pattern,
+            endpoint: ep.pattern,
             itemPath: ep.responseAnalysis?.itemPath ?? null,
             recommendedColumns: cols.length ? cols : ['title', 'url'],
             recommendedArgs: args,
@@ -216,7 +236,7 @@ async function writeExploreArtifacts(targetDir, result, analyzedEndpoints, store
         }, null, 2)),
         fs.promises.writeFile(path.join(targetDir, 'endpoints.json'), JSON.stringify(analyzedEndpoints.map(ep => ({
             pattern: ep.pattern, method: ep.method, url: ep.url, status: ep.status,
-            contentType: ep.contentType, score: ep.score, queryParams: ep.queryParams,
+            contentType: ep.contentType, queryParams: ep.queryParams,
             itemPath: ep.responseAnalysis?.itemPath ?? null, itemCount: ep.responseAnalysis?.itemCount ?? 0,
             detectedFields: ep.responseAnalysis?.detectedFields ?? {}, authIndicators: ep.authIndicators,
         })), null, 2)),
@@ -237,6 +257,7 @@ export async function exploreUrl(url, opts) {
     return browserSession(opts.BrowserFactory, async (page) => {
         return runWithTimeout((async () => {
             // Step 1: Navigate
+            await page.startNetworkCapture?.();
             await page.goto(url);
             await page.wait(waitSeconds);
             // Step 2: Auto-scroll to trigger lazy loading intelligently
@@ -269,7 +290,9 @@ export async function exploreUrl(url, opts) {
             // Step 3: Read page metadata
             const metadata = await readPageMetadata(page);
             // Step 4: Capture network traffic
-            const rawNetwork = await page.networkRequests(false);
+            const rawNetwork = page.readNetworkCapture
+                ? await page.readNetworkCapture()
+                : await page.networkRequests(false);
             const networkEntries = parseNetworkRequests(rawNetwork);
             // Step 5: For JSON endpoints missing a body, carefully re-fetch in-browser via a pristine iframe
             const jsonEndpoints = networkEntries.filter(e => e.contentType.includes('json') && e.method === 'GET' && e.status === 200 && !e.responseBody);
@@ -348,7 +371,7 @@ export function renderExploreSummary(result) {
     ];
     for (const cap of (result.capabilities ?? []).slice(0, 5)) {
         const storeInfo = cap.storeHint ? ` → ${cap.storeHint.store}.${cap.storeHint.action}()` : '';
-        lines.push(`  • ${cap.name} (${cap.strategy}, ${(cap.confidence * 100).toFixed(0)}%)${storeInfo}`);
+        lines.push(`  • ${cap.name} (${cap.strategy})${storeInfo}`);
     }
     const fw = result.framework ?? {};
     const fwNames = Object.entries(fw).filter(([, v]) => v).map(([k]) => k);

package/dist/src/extension-manifest-regression.test.js

@@ -7,7 +7,6 @@ describe('extension manifest regression', () => {
         const raw = await fs.readFile(manifestPath, 'utf8');
         const manifest = JSON.parse(raw);
         expect(manifest.permissions).toContain('cookies');
-        expect(manifest.permissions).toContain('scripting');
         expect(manifest.host_permissions).toContain('<all_urls>');
     });
 });

package/dist/src/generate.d.ts

@@ -34,7 +34,7 @@ export interface GenerateCliResult {
     };
     synthesize: {
         candidate_count: number;
-        candidates: Array<Pick<SynthesizeCandidateSummary, 'name' | 'strategy' | 'confidence'>>;
+        candidates: Array<Pick<SynthesizeCandidateSummary, 'name' | 'strategy'>>;
     };
 }
 export declare function generateCliFromUrl(opts: GenerateCliOptions): Promise<GenerateCliResult>;

package/dist/src/generate.js

@@ -40,7 +40,7 @@ function selectCandidate(candidates, goal) {
     if (!candidates.length)
         return null;
     if (!goal)
-        return candidates[0]; // highest confidence first
+        return candidates[0];
     const normalized = normalizeGoal(goal);
     if (normalized) {
         const exact = candidates.find(c => c.name === normalized);
@@ -90,7 +90,6 @@ export async function generateCliFromUrl(opts) {
             candidates: (synthesizeResult.candidates ?? []).map((c) => ({
                 name: c.name,
                 strategy: c.strategy,
-                confidence: c.confidence,
             })),
         },
     };
@@ -111,7 +110,7 @@ export function renderGenerateSummary(r) {
         `  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)}%)`);
+        lines.push(`    • ${c.name} (${c.strategy})`);
     }
     const fw = r.explore?.framework ?? {};
     const fwNames = Object.entries(fw).filter(([, v]) => v).map(([k]) => k);

package/dist/src/package-paths.d.ts

@@ -0,0 +1,8 @@
+export interface PackageJsonLike {
+    bin?: string | Record<string, string>;
+    main?: string;
+}
+export declare function findPackageRoot(startFile: string, fileExists?: (candidate: string) => boolean): string;
+export declare function getBuiltEntryCandidates(packageRoot: string, readFile?: (filePath: string) => string): string[];
+export declare function getCliManifestPath(clisDir: string): string;
+export declare function getFetchAdaptersScriptPath(packageRoot: string): string;

package/dist/src/package-paths.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function findPackageRoot(startFile, fileExists = fs.existsSync) {
+    let dir = path.dirname(startFile);
+    while (true) {
+        if (fileExists(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error(`Could not find package.json above ${startFile}`);
+        }
+        dir = parent;
+    }
+}
+export function getBuiltEntryCandidates(packageRoot, readFile = (filePath) => fs.readFileSync(filePath, 'utf-8')) {
+    const candidates = [];
+    try {
+        const pkg = JSON.parse(readFile(path.join(packageRoot, 'package.json')));
+        if (typeof pkg.bin === 'string') {
+            candidates.push(path.join(packageRoot, pkg.bin));
+        }
+        else if (pkg.bin && typeof pkg.bin === 'object' && typeof pkg.bin.opencli === 'string') {
+            candidates.push(path.join(packageRoot, pkg.bin.opencli));
+        }
+        if (typeof pkg.main === 'string') {
+            candidates.push(path.join(packageRoot, pkg.main));
+        }
+    }
+    catch {
+        // Fall through to compatibility candidates below.
+    }
+    // Compatibility fallback for partially-built trees or older layouts.
+    candidates.push(path.join(packageRoot, 'dist', 'src', 'main.js'), path.join(packageRoot, 'dist', 'main.js'));
+    return [...new Set(candidates)];
+}
+export function getCliManifestPath(clisDir) {
+    return path.resolve(clisDir, '..', 'cli-manifest.json');
+}
+export function getFetchAdaptersScriptPath(packageRoot) {
+    return path.join(packageRoot, 'scripts', 'fetch-adapters.js');
+}

package/dist/src/plugin-scaffold.js

@@ -68,9 +68,7 @@ pipeline:
   - fetch:
       url: "https://httpbin.org/get?greeting=hello"
       method: GET
-  - extract:
-      type: json
-      selector: "$.args"
+  - select: "args"
 `;
     writeFile(targetDir, 'hello.yaml', yamlContent);
     files.push('hello.yaml');

package/dist/src/record.d.ts

@@ -45,7 +45,6 @@ type RecordedCandidateKind = 'read' | 'write';
 export interface RecordedCandidate {
     kind: RecordedCandidateKind;
     req: RecordedRequest;
-    score: number;
     arrayResult: ReturnType<typeof findArrayPath> | null;
 }
 interface GeneratedRecordedCandidate {
@@ -70,7 +69,7 @@ export declare function createRecordedEntry(input: {
  * for every JSON response. No URL pattern filter — captures everything.
  */
 export declare function generateFullCaptureInterceptorJs(): string;
-/** Analyze recorded requests into read and write candidates. */
+/** Analyze recorded requests into read and write candidates, filtering out noise. */
 export declare function analyzeRecordedRequests(requests: RecordedRequest[]): {
     candidates: RecordedCandidate[];
 };

package/dist/src/record.js

@@ -18,26 +18,11 @@ import chalk from 'chalk';
 import yaml from 'js-yaml';
 import { sendCommand } from './browser/daemon-client.js';
 import { SEARCH_PARAMS, PAGINATION_PARAMS, FIELD_ROLES } from './constants.js';
-import { urlToPattern, findArrayPath, inferCapabilityName, inferStrategy, detectAuthFromContent, classifyQueryParams, } from './analysis.js';
-/** Keep the stronger candidate when multiple recordings share one bucket. */
-function preferRecordedCandidate(current, next) {
-    if (next.score > current.score)
-        return next;
-    if (next.score < current.score)
-        return current;
+import { urlToPattern, findArrayPath, inferCapabilityName, inferStrategy, detectAuthFromContent, classifyQueryParams, isNoiseUrl, } from './analysis.js';
+/** Keep the later candidate when multiple recordings share one bucket (prefer fresher data). */
+function preferRecordedCandidate(_current, next) {
     return next;
 }
-/** Apply shared endpoint score tweaks. */
-function applyCommonEndpointScoreAdjustments(req, score) {
-    let adjusted = score;
-    if (req.url.includes('/api/'))
-        adjusted += 3;
-    if (req.url.match(/\/(track|log|analytics|beacon|pixel|stats|metric)/i))
-        adjusted -= 10;
-    if (req.url.match(/\/(ping|heartbeat|keep.?alive)/i))
-        adjusted -= 10;
-    return adjusted;
-}
 /** Build a candidate-level dedupe key. */
 function getRecordedCandidateKey(candidate) {
     return `${candidate.kind} ${getRecordedRequestKey(candidate.req)}`;
@@ -262,23 +247,6 @@ function generateReadRecordedJs() {
   `;
 }
 // ── Analysis helpers ───────────────────────────────────────────────────────
-function scoreRequest(req, arrayResult) {
-    let s = 0;
-    if (arrayResult) {
-        s += 10;
-        s += Math.min(arrayResult.items.length, 10);
-        // Bonus for detected semantic fields
-        const sample = arrayResult.items[0];
-        if (sample && typeof sample === 'object') {
-            const keys = Object.keys(sample).map(k => k.toLowerCase());
-            for (const aliases of Object.values(FIELD_ROLES)) {
-                if (aliases.some(a => keys.includes(a)))
-                    s += 2;
-            }
-        }
-    }
-    return applyCommonEndpointScoreAdjustments(req, s);
-}
 /** Check whether one recorded request is safe to treat as a write candidate. */
 function isWriteCandidate(req) {
     return ['POST', 'PUT', 'PATCH'].includes(req.method)
@@ -290,25 +258,19 @@ function isWriteCandidate(req) {
         && typeof req.responseBody === 'object'
         && !Array.isArray(req.responseBody);
 }
-/** Score replayable write requests while keeping tracking and heartbeat traffic suppressed. */
-function scoreWriteRequest(req) {
-    return applyCommonEndpointScoreAdjustments(req, 6);
-}
-/** Analyze recorded requests into read and write candidates. */
+/** Analyze recorded requests into read and write candidates, filtering out noise. */
 export function analyzeRecordedRequests(requests) {
     const candidates = [];
     for (const req of requests) {
+        if (isNoiseUrl(req.url))
+            continue;
         const arrayResult = findArrayPath(req.responseBody);
         if (isWriteCandidate(req)) {
-            const score = scoreWriteRequest(req);
-            if (score > 0)
-                candidates.push({ kind: 'write', req, score, arrayResult: null });
+            candidates.push({ kind: 'write', req, arrayResult: null });
             continue;
         }
         if (arrayResult) {
-            const score = scoreRequest(req, arrayResult);
-            if (score > 0)
-                candidates.push({ kind: 'read', req, score, arrayResult });
+            candidates.push({ kind: 'read', req, arrayResult });
         }
     }
     return { candidates };
@@ -465,9 +427,9 @@ export function generateRecordedCandidates(site, pageUrl, requests) {
         const current = deduped.get(key);
         deduped.set(key, current ? preferRecordedCandidate(current, candidate) : candidate);
     }
+    // Sort reads by array item count (richer data first), then take top 5
     const selected = [...deduped.values()]
-        .filter((candidate) => candidate.kind === 'read' ? candidate.score >= 8 : candidate.score >= 6)
-        .sort((a, b) => b.score - a.score)
+        .sort((a, b) => (b.arrayResult?.items.length ?? 0) - (a.arrayResult?.items.length ?? 0))
         .slice(0, 5);
     const usedNames = new Set();
     return selected.map((candidate) => {
@@ -636,13 +598,13 @@ function analyzeAndWrite(site, pageUrl, requests, outDir) {
     // Generate candidate YAMLs (top 5)
     const candidates = [];
     const usedNames = new Set();
-    console.log(chalk.bold('\n  Captured endpoints (scored):\n'));
-    for (const entry of analysis.candidates.sort((a, b) => b.score - a.score).slice(0, 8)) {
+    console.log(chalk.bold('\n  Captured endpoints:\n'));
+    for (const entry of analysis.candidates.sort((a, b) => (b.arrayResult?.items.length ?? 0) - (a.arrayResult?.items.length ?? 0)).slice(0, 8)) {
         const itemCount = entry.arrayResult?.items.length ?? 0;
         const strategy = entry.kind === 'write'
             ? 'cookie'
             : inferStrategy(detectAuthFromContent(entry.req.url, entry.req.responseBody));
-        const marker = entry.score >= 15 ? chalk.green('★') : entry.score >= 8 ? chalk.yellow('◆') : chalk.dim('·');
+        const marker = entry.kind === 'write' ? chalk.magenta('✎') : itemCount > 5 ? chalk.green('★') : chalk.dim('·');
         console.log(`  ${marker} ${chalk.white(urlToPattern(entry.req.url))}` +
             chalk.dim(` [${strategy}]`) +
             (entry.kind === 'write'
@@ -664,7 +626,7 @@ function analyzeAndWrite(site, pageUrl, requests, outDir) {
         console.log(chalk.dim(`    → ${filePath}`));
     }
     if (candidates.length === 0) {
-        console.log(chalk.yellow('  No high-confidence candidates found.'));
+        console.log(chalk.yellow('  No candidates found.'));
         console.log(chalk.dim('  Tip: make sure you triggered JSON API calls (open lists, search, scroll).'));
     }
     return {

package/dist/src/synthesize.d.ts

@@ -17,7 +17,6 @@ export interface SynthesizeCapability {
     name: string;
     description: string;
     strategy: string;
-    confidence?: number;
     endpoint?: string;
     itemPath?: string | null;
     recommendedColumns?: string[];
@@ -70,7 +69,6 @@ export interface SynthesizeCandidateSummary {
     name: string;
     path: string;
     strategy: string;
-    confidence?: number;
 }
 export interface SynthesizeResult {
     site: string;

package/dist/src/synthesize.js

@@ -13,7 +13,6 @@ export function synthesizeFromExplore(target, opts = {}) {
     fs.mkdirSync(targetDir, { recursive: true });
     const site = bundle.manifest.site;
     const capabilities = (bundle.capabilities ?? [])
-        .sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0))
         .slice(0, opts.top ?? 3);
     const candidates = [];
     for (const cap of capabilities) {
@@ -23,7 +22,7 @@ export function synthesizeFromExplore(target, opts = {}) {
         const candidate = buildCandidateYaml(site, bundle.manifest, cap, endpoint);
         const filePath = path.join(targetDir, `${candidate.name}.yaml`);
         fs.writeFileSync(filePath, yaml.dump(candidate.yaml, { sortKeys: false, lineWidth: 120 }));
-        candidates.push({ name: candidate.name, path: filePath, strategy: cap.strategy, confidence: cap.confidence });
+        candidates.push({ name: candidate.name, path: filePath, strategy: cap.strategy });
     }
     const index = { site, target_url: bundle.manifest.target_url, generated_from: exploreDir, candidate_count: candidates.length, candidates };
     fs.writeFileSync(path.join(targetDir, 'candidates.json'), JSON.stringify(index, null, 2));
@@ -32,7 +31,7 @@ export function synthesizeFromExplore(target, opts = {}) {
 export function renderSynthesizeSummary(result) {
     const lines = ['opencli synthesize: OK', `Site: ${result.site}`, `Source: ${result.explore_dir}`, `Candidates: ${result.candidate_count}`];
     for (const c of result.candidates ?? [])
-        lines.push(`  • ${c.name} (${c.strategy}, ${((c.confidence ?? 0) * 100).toFixed(0)}% confidence) → ${c.path}`);
+        lines.push(`  • ${c.name} (${c.strategy}) → ${c.path}`);
     return lines.join('\n');
 }
 export function resolveExploreDir(target) {
@@ -61,7 +60,12 @@ function chooseEndpoint(cap, endpoints) {
         if (match)
             return match;
     }
-    return [...endpoints].sort((a, b) => (b.score ?? 0) - (a.score ?? 0))[0];
+    // Fallback: prefer endpoint with most data (item count + detected fields)
+    return [...endpoints].sort((a, b) => {
+        const aKey = (a.itemCount ?? 0) * 10 + Object.keys(a.detectedFields ?? {}).length;
+        const bKey = (b.itemCount ?? 0) * 10 + Object.keys(b.detectedFields ?? {}).length;
+        return bKey - aKey;
+    })[0];
 }
 // ── URL templating ─────────────────────────────────────────────────────────
 function buildTemplatedUrl(rawUrl, cap, _endpoint) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.6.7",
+  "version": "1.6.8",
   "publishConfig": {
     "access": "public"
   },