@jackwener/opencli 1.6.9 → 1.6.10

package/dist/src/clis/binance/pairs.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'pairs',
+    description: 'List active trading pairs on Binance',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of trading pairs' },
+    ],
+    columns: ['symbol', 'base', 'quote', 'status'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/exchangeInfo' } },
+        { select: 'symbols' },
+        { filter: 'item.status === \'TRADING\'' },
+        { map: { symbol: '${{ item.symbol }}', base: '${{ item.baseAsset }}', quote: '${{ item.quoteAsset }}', status: '${{ item.status }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/price.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/price.js

@@ -0,0 +1,17 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'price',
+    description: 'Quick price check for a trading pair',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
+    ],
+    columns: ['symbol', 'price', 'change', 'change_pct', 'high', 'low', 'volume', 'quote_volume', 'trades'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr?symbol=${{ args.symbol }}' } },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change: '${{ item.priceChange }}', change_pct: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.volume }}', quote_volume: '${{ item.quoteVolume }}', trades: '${{ item.count }}' } },
+    ],
+});

package/dist/src/clis/binance/prices.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/prices.js

@@ -0,0 +1,18 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'prices',
+    description: 'Latest prices for all trading pairs',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of prices' },
+    ],
+    columns: ['rank', 'symbol', 'price'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/price' } },
+        { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.price }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/ticker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/ticker.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'ticker',
+    description: '24h ticker statistics for top trading pairs by volume',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of tickers' },
+    ],
+    columns: ['symbol', 'price', 'change_pct', 'high', 'low', 'volume', 'quote_vol', 'trades'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_pct: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.volume }}', quote_vol: '${{ item.quoteVolume }}', trades: '${{ item.count }}', sort_volume: '${{ Number(item.quoteVolume) }}' } },
+        { sort: { by: 'sort_volume', order: 'desc' } },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_pct: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.volume }}', quote_vol: '${{ item.quoteVolume }}', trades: '${{ item.count }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/top.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/top.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'top',
+    description: 'Top trading pairs by 24h volume on Binance',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of trading pairs' },
+    ],
+    columns: ['rank', 'symbol', 'price', 'change_24h', 'high', 'low', 'volume'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.quoteVolume }}', sort_volume: '${{ Number(item.quoteVolume) }}' } },
+        { sort: { by: 'sort_volume', order: 'desc' } },
+        { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.quoteVolume }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/trades.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/trades.js

@@ -0,0 +1,19 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'trades',
+    description: 'Recent trades for a trading pair',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of trades (max 1000)' },
+    ],
+    columns: ['id', 'price', 'qty', 'quote_qty', 'buyer_maker'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/trades?symbol=${{ args.symbol }}&limit=${{ args.limit }}' } },
+        { map: { id: '${{ item.id }}', price: '${{ item.price }}', qty: '${{ item.qty }}', quote_qty: '${{ item.quoteQty }}', buyer_maker: '${{ item.isBuyerMaker }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/completion-fast.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Lightweight manifest-based completion for the fast path.
+ *
+ * This module MUST NOT import registry, discovery, or any heavy module.
+ * It only reads pre-compiled cli-manifest.json files synchronously.
+ */
+/**
+ * Returns true only if ALL manifest files exist and are readable.
+ * If any source lacks a manifest (e.g. user adapters without a compiled manifest),
+ * the fast path must not be used — otherwise those adapters would silently
+ * disappear from completion results.
+ */
+export declare function hasAllManifests(manifestPaths: string[]): boolean;
+/**
+ * Lightweight completion that reads directly from manifest JSON files,
+ * bypassing full CLI discovery and adapter loading.
+ */
+export declare function getCompletionsFromManifest(words: string[], cursor: number, manifestPaths: string[]): string[];
+export declare function bashCompletionScript(): string;
+export declare function zshCompletionScript(): string;
+export declare function fishCompletionScript(): string;
+/**
+ * Print completion script for the given shell. Returns true if handled, false if unknown shell.
+ */
+export declare function printCompletionScriptFast(shell: string): boolean;

package/dist/src/completion-fast.js

@@ -0,0 +1,140 @@
+/**
+ * Lightweight manifest-based completion for the fast path.
+ *
+ * This module MUST NOT import registry, discovery, or any heavy module.
+ * It only reads pre-compiled cli-manifest.json files synchronously.
+ */
+import * as fs from 'node:fs';
+const BUILTIN_COMMANDS = [
+    'list',
+    'validate',
+    'verify',
+    'explore',
+    'probe',
+    'synthesize',
+    'generate',
+    'cascade',
+    'doctor',
+    'plugin',
+    'install',
+    'register',
+    'completion',
+];
+/**
+ * Returns true only if ALL manifest files exist and are readable.
+ * If any source lacks a manifest (e.g. user adapters without a compiled manifest),
+ * the fast path must not be used — otherwise those adapters would silently
+ * disappear from completion results.
+ */
+export function hasAllManifests(manifestPaths) {
+    for (const p of manifestPaths) {
+        try {
+            fs.accessSync(p);
+        }
+        catch {
+            return false;
+        }
+    }
+    return manifestPaths.length > 0;
+}
+/**
+ * Lightweight completion that reads directly from manifest JSON files,
+ * bypassing full CLI discovery and adapter loading.
+ */
+export function getCompletionsFromManifest(words, cursor, manifestPaths) {
+    const entries = loadManifestEntries(manifestPaths);
+    if (entries === null) {
+        return [];
+    }
+    if (cursor <= 1) {
+        const sites = new Set();
+        for (const entry of entries) {
+            sites.add(entry.site);
+        }
+        return [...BUILTIN_COMMANDS, ...sites].sort();
+    }
+    const site = words[0];
+    if (BUILTIN_COMMANDS.includes(site)) {
+        return [];
+    }
+    if (cursor === 2) {
+        const subcommands = [];
+        for (const entry of entries) {
+            if (entry.site === site) {
+                subcommands.push(entry.name);
+                if (entry.aliases?.length)
+                    subcommands.push(...entry.aliases);
+            }
+        }
+        return [...new Set(subcommands)].sort();
+    }
+    return [];
+}
+// ── Shell script generators (pure strings, no registry dependency) ───────
+export function bashCompletionScript() {
+    return `# Bash completion for opencli
+# Add to ~/.bashrc:  eval "$(opencli completion bash)"
+_opencli_completions() {
+  local cur words cword
+  _get_comp_words_by_ref -n : cur words cword
+
+  local completions
+  completions=$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)
+
+  COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
+  __ltrim_colon_completions "$cur"
+}
+complete -F _opencli_completions opencli
+`;
+}
+export function zshCompletionScript() {
+    return `# Zsh completion for opencli
+# Add to ~/.zshrc:  eval "$(opencli completion zsh)"
+_opencli() {
+  local -a completions
+  local cword=$((CURRENT - 1))
+  completions=(\${(f)"$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)"})
+  compadd -a completions
+}
+compdef _opencli opencli
+`;
+}
+export function fishCompletionScript() {
+    return `# Fish completion for opencli
+# Add to ~/.config/fish/config.fish:  opencli completion fish | source
+complete -c opencli -f -a '(
+  set -l tokens (commandline -cop)
+  set -l cursor (count (commandline -cop))
+  opencli --get-completions --cursor $cursor $tokens[2..] 2>/dev/null
+)'
+`;
+}
+const SHELL_SCRIPTS = {
+    bash: bashCompletionScript,
+    zsh: zshCompletionScript,
+    fish: fishCompletionScript,
+};
+/**
+ * Print completion script for the given shell. Returns true if handled, false if unknown shell.
+ */
+export function printCompletionScriptFast(shell) {
+    const gen = SHELL_SCRIPTS[shell];
+    if (!gen)
+        return false;
+    process.stdout.write(gen());
+    return true;
+}
+function loadManifestEntries(manifestPaths) {
+    const entries = [];
+    let found = false;
+    for (const manifestPath of manifestPaths) {
+        try {
+            const raw = fs.readFileSync(manifestPath, 'utf-8');
+            const manifest = JSON.parse(raw);
+            entries.push(...manifest);
+            found = true;
+        }
+        catch { /* skip missing/unreadable */ }
+    }
+    return found ? entries : null;
+}

package/dist/src/completion.d.ts

@@ -7,6 +7,7 @@
  */
 /**
  * Return completion candidates given the current command-line words and cursor index.
+ * Requires full CLI discovery to have been run (uses getRegistry()).
  *
  * @param words  - The argv after 'opencli' (words[0] is the first arg, e.g. site name)
  * @param cursor - 1-based position of the word being completed (1 = first arg)

package/dist/src/completion.js

@@ -28,6 +28,7 @@ const BUILTIN_COMMANDS = [
 ];
 /**
  * Return completion candidates given the current command-line words and cursor index.
+ * Requires full CLI discovery to have been run (uses getRegistry()).
  *
  * @param words  - The argv after 'opencli' (words[0] is the first arg, e.g. site name)
  * @param cursor - 1-based position of the word being completed (1 = first arg)

package/dist/src/diagnostic.test.js

@@ -83,8 +83,8 @@ describe('redactText', () => {
 });
 describe('resolveAdapterSourcePath', () => {
     it('returns source when it is a real file path (not manifest:)', () => {
-        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.yaml' });
-        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.yaml');
+        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.ts' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.ts');
     });
     it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
         const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/dist/clis/arxiv/search.js' });

package/dist/src/discovery.d.ts

@@ -1,10 +1,10 @@
 /**
- * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ * CLI discovery: finds TS CLI definitions and registers them.
  *
  * Supports two modes:
  * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
- *    registers all YAML commands instantly without runtime YAML parsing.
- *    TS modules are loaded lazily only when their command is executed.
+ *    registers commands instantly. TS modules are loaded lazily only
+ *    when their command is executed.
  * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 /** User runtime directory: ~/.opencli */

package/dist/src/discovery.js

@@ -1,17 +1,16 @@
 /**
- * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ * CLI discovery: finds TS CLI definitions and registers them.
  *
  * Supports two modes:
  * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
- *    registers all YAML commands instantly without runtime YAML parsing.
- *    TS modules are loaded lazily only when their command is executed.
+ *    registers commands instantly. TS modules are loaded lazily only
+ *    when their command is executed.
  * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import yaml from 'js-yaml';
 import { Strategy, registerCommand } from './registry.js';
 import { getErrorMessage } from './errors.js';
 import { log } from './logger.js';
@@ -24,14 +23,12 @@ export const USER_CLIS_DIR = path.join(USER_OPENCLI_DIR, 'clis');
 export const PLUGINS_DIR = path.join(USER_OPENCLI_DIR, 'plugins');
 /** Matches files that register commands via cli() or lifecycle hooks */
 const PLUGIN_MODULE_PATTERN = /\b(?:cli|onStartup|onBeforeExecute|onAfterExecute)\s*\(/;
-import { parseYamlArgs } from './yaml-schema.js';
 function parseStrategy(rawStrategy, fallback = Strategy.COOKIE) {
     if (!rawStrategy)
         return fallback;
     const key = rawStrategy.toUpperCase();
     return Strategy[key] ?? fallback;
 }
-import { isRecord } from './utils.js';
 const PACKAGE_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
 /**
  * Ensure ~/.opencli/node_modules/@jackwener/opencli symlink exists so that
@@ -140,7 +137,6 @@ export async function discoverClis(...dirs) {
 }
 /**
  * Fast-path: register commands from pre-compiled manifest.
- * YAML pipelines are inlined — zero YAML parsing at runtime.
  * TS modules are deferred — loaded lazily on first execution.
  */
 async function loadFromManifest(manifestPath, clisDir) {
@@ -148,53 +144,30 @@ async function loadFromManifest(manifestPath, clisDir) {
         const raw = await fs.promises.readFile(manifestPath, 'utf-8');
         const manifest = JSON.parse(raw);
         for (const entry of manifest) {
-            if (entry.type === 'yaml') {
-                // YAML pipelines fully inlined in manifest — register directly
-                const strategy = parseStrategy(entry.strategy);
-                const cmd = {
-                    site: entry.site,
-                    name: entry.name,
-                    aliases: entry.aliases,
-                    description: entry.description ?? '',
-                    domain: entry.domain,
-                    strategy,
-                    browser: entry.browser,
-                    args: entry.args ?? [],
-                    columns: entry.columns,
-                    pipeline: entry.pipeline,
-                    timeoutSeconds: entry.timeout,
-                    source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : `manifest:${entry.site}/${entry.name}`,
-                    deprecated: entry.deprecated,
-                    replacedBy: entry.replacedBy,
-                    navigateBefore: entry.navigateBefore,
-                };
-                registerCommand(cmd);
-            }
-            else if (entry.type === 'ts' && entry.modulePath) {
-                // TS adapters: register a lightweight stub.
-                // The actual module is loaded lazily on first executeCommand().
-                const strategy = parseStrategy(entry.strategy ?? 'cookie');
-                const modulePath = path.resolve(clisDir, entry.modulePath);
-                const cmd = {
-                    site: entry.site,
-                    name: entry.name,
-                    aliases: entry.aliases,
-                    description: entry.description ?? '',
-                    domain: entry.domain,
-                    strategy,
-                    browser: entry.browser ?? true,
-                    args: entry.args ?? [],
-                    columns: entry.columns,
-                    timeoutSeconds: entry.timeout,
-                    source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : modulePath,
-                    deprecated: entry.deprecated,
-                    replacedBy: entry.replacedBy,
-                    navigateBefore: entry.navigateBefore,
-                    _lazy: true,
-                    _modulePath: modulePath,
-                };
-                registerCommand(cmd);
-            }
+            if (!entry.modulePath)
+                continue;
+            const strategy = parseStrategy(entry.strategy ?? 'cookie');
+            const modulePath = path.resolve(clisDir, entry.modulePath);
+            const cmd = {
+                site: entry.site,
+                name: entry.name,
+                aliases: entry.aliases,
+                description: entry.description ?? '',
+                domain: entry.domain,
+                strategy,
+                browser: entry.browser ?? true,
+                args: entry.args ?? [],
+                columns: entry.columns,
+                pipeline: entry.pipeline,
+                timeoutSeconds: entry.timeout,
+                source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : modulePath,
+                deprecated: entry.deprecated,
+                replacedBy: entry.replacedBy,
+                navigateBefore: entry.navigateBefore,
+                _lazy: true,
+                _modulePath: modulePath,
+            };
+            registerCommand(cmd);
         }
         return true;
     }
@@ -223,9 +196,10 @@ async function discoverClisFromFs(dir) {
         await Promise.all(files.map(async (file) => {
             const filePath = path.join(siteDir, file);
             if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                await registerYamlCli(filePath, site);
+                log.warn(`Ignoring YAML adapter ${filePath} — YAML format is no longer supported. Convert to TypeScript using cli() from '@jackwener/opencli/registry'.`);
+                return;
             }
-            else if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
+            if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
                 (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))) {
                 if (!(await isCliModule(filePath)))
                     return;
@@ -237,44 +211,6 @@ async function discoverClisFromFs(dir) {
     });
     await Promise.all(sitePromises);
 }
-async function registerYamlCli(filePath, defaultSite) {
-    try {
-        const raw = await fs.promises.readFile(filePath, 'utf-8');
-        const def = yaml.load(raw);
-        if (!isRecord(def))
-            return;
-        const cliDef = def;
-        const site = cliDef.site ?? defaultSite;
-        const name = cliDef.name ?? path.basename(filePath, path.extname(filePath));
-        const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
-        const strategy = parseStrategy(strategyStr);
-        const browser = cliDef.browser ?? (strategy !== Strategy.PUBLIC);
-        const args = parseYamlArgs(cliDef.args);
-        const cmd = {
-            site,
-            name,
-            aliases: isRecord(cliDef) && Array.isArray(cliDef.aliases)
-                ? cliDef.aliases.filter((value) => typeof value === 'string')
-                : undefined,
-            description: cliDef.description ?? '',
-            domain: cliDef.domain,
-            strategy,
-            browser,
-            args,
-            columns: cliDef.columns,
-            pipeline: cliDef.pipeline,
-            timeoutSeconds: cliDef.timeout,
-            source: filePath,
-            deprecated: cliDef.deprecated,
-            replacedBy: cliDef.replacedBy,
-            navigateBefore: cliDef.navigateBefore,
-        };
-        registerCommand(cmd);
-    }
-    catch (err) {
-        log.warn(`Failed to load ${filePath}: ${getErrorMessage(err)}`);
-    }
-}
 /**
  * Discover and register plugins from ~/.opencli/plugins/.
  * Each subdirectory is treated as a plugin (site = directory name).
@@ -296,7 +232,7 @@ export async function discoverPlugins() {
     }));
 }
 /**
- * Flat scan: read yaml/ts files directly in a plugin directory.
+ * Flat scan: read ts/js files directly in a plugin directory.
  * Unlike discoverClisFromFs, this does NOT expect nested site subdirectories.
  */
 async function discoverPluginDir(dir, site) {
@@ -305,9 +241,10 @@ async function discoverPluginDir(dir, site) {
     await Promise.all(files.map(async (file) => {
         const filePath = path.join(dir, file);
         if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-            await registerYamlCli(filePath, site);
+            log.warn(`Ignoring YAML plugin ${filePath} — YAML format is no longer supported. Convert to TypeScript using cli() from '@jackwener/opencli/registry'.`);
+            return;
         }
-        else if (file.endsWith('.js') && !file.endsWith('.d.js')) {
+        if (file.endsWith('.js') && !file.endsWith('.d.js')) {
             if (!(await isCliModule(filePath)))
                 return;
             await import(pathToFileURL(filePath).href).catch((err) => {

package/dist/src/download/index.d.ts

@@ -52,7 +52,7 @@ export declare function ytdlpDownload(url: string, destPath: string, options?: Y
 /**
  * Save document content to file.
  */
-export declare function saveDocument(content: string, destPath: string, format?: 'json' | 'markdown' | 'html' | 'text', metadata?: Record<string, any>): Promise<{
+export declare function saveDocument(content: string, destPath: string, format?: 'json' | 'markdown' | 'html' | 'text', metadata?: Record<string, unknown>): Promise<{
     success: boolean;
     size: number;
     error?: string;

package/dist/src/engine.test.js

@@ -127,8 +127,7 @@ describe('discoverPlugins', () => {
         }
         catch { }
     });
-    it('discovers YAML plugins from ~/.opencli/plugins/', async () => {
-        // Create a simple YAML adapter in the plugins directory
+    it('ignores YAML files in plugin directories (YAML format removed)', async () => {
         await fs.promises.mkdir(testPluginDir, { recursive: true });
         await fs.promises.writeFile(yamlPath, `
 site: __test-plugin__
@@ -136,25 +135,17 @@ name: greeting
 description: Test plugin greeting
 strategy: public
 browser: false
-
-pipeline:
-  - evaluate: "() => [{ message: 'hello from plugin' }]"
-
-columns: [message]
 `);
         await discoverPlugins();
         const registry = getRegistry();
         const cmd = registry.get('__test-plugin__/greeting');
-        expect(cmd).toBeDefined();
-        expect(cmd.site).toBe('__test-plugin__');
-        expect(cmd.name).toBe('greeting');
-        expect(cmd.description).toBe('Test plugin greeting');
+        expect(cmd).toBeUndefined();
     });
     it('handles non-existent plugins directory gracefully', async () => {
         // discoverPlugins should not throw if ~/.opencli/plugins/ does not exist
         await expect(discoverPlugins()).resolves.not.toThrow();
     });
-    it('discovers YAML plugins from symlinked plugin directories', async () => {
+    it('ignores YAML files in symlinked plugin directories (YAML format removed)', async () => {
         await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
         await fs.promises.mkdir(symlinkTargetDir, { recursive: true });
         await fs.promises.writeFile(path.join(symlinkTargetDir, 'hello.yaml'), `
@@ -163,17 +154,11 @@ name: hello
 description: Test plugin greeting via symlink
 strategy: public
 browser: false
-
-pipeline:
-  - evaluate: "() => [{ message: 'hello from symlink plugin' }]"
-
-columns: [message]
 `);
         await fs.promises.symlink(symlinkTargetDir, symlinkPluginDir, 'dir');
         await discoverPlugins();
         const cmd = getRegistry().get('__test-plugin-symlink__/hello');
-        expect(cmd).toBeDefined();
-        expect(cmd.description).toBe('Test plugin greeting via symlink');
+        expect(cmd).toBeUndefined();
     });
     it('skips broken plugin symlinks without throwing', async () => {
         await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });