@lowzj/news-skill 0.1.0

package/skills/news/scripts/client.js

@@ -0,0 +1,251 @@
+import { DEFAULT_API_URL, VERSION } from './meta.js';
+const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+export class NewsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'NewsError';
+    }
+}
+function invalid(message) {
+    throw new NewsError('INVALID_RESPONSE', `Invalid NEWS response: ${message}`);
+}
+function object(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        invalid(`${label} must be an object`);
+    return value;
+}
+function string(value, label) {
+    if (typeof value !== 'string')
+        invalid(`${label} must be a string`);
+    return value;
+}
+function array(value, label) {
+    if (!Array.isArray(value))
+        invalid(`${label} must be an array`);
+    return value;
+}
+function integer(value, label, minimum = 0, maximum = Number.MAX_SAFE_INTEGER) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < minimum || value > maximum) {
+        invalid(`${label} must be an integer from ${minimum} to ${maximum}`);
+    }
+    return value;
+}
+function optionalString(value, label) {
+    return value === null ? null : string(value, label);
+}
+function timestamp(value, label, nullable = true) {
+    if (value === null && nullable)
+        return null;
+    const result = string(value, label);
+    if (!/T.*(?:Z|[+-]\d{2}:\d{2})$/.test(result) || !Number.isFinite(Date.parse(result)))
+        invalid(`${label} must be an ISO timestamp`);
+    return result;
+}
+function date(value, label) {
+    const result = string(value, label);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(result) || !Number.isFinite(Date.parse(result)) || new Date(result).toISOString().slice(0, 10) !== result) {
+        invalid(`${label} must be a calendar date`);
+    }
+    return result;
+}
+function parseTopic(value) {
+    const row = object(value, 'topic');
+    const id = string(row.id, 'topic.id');
+    if (!id.trim())
+        invalid('topic.id must not be empty');
+    return {
+        id,
+        name: string(row.name, 'topic.name'),
+        name_en: string(row.name_en, 'topic.name_en'),
+        description: string(row.description, 'topic.description'),
+        latest_day: row.latest_day === null ? null : date(row.latest_day, 'topic.latest_day'),
+        updated_at: timestamp(row.updated_at, 'topic.updated_at'),
+        ...(row.today_count !== undefined ? { today_count: integer(row.today_count, 'topic.today_count') } : {}),
+    };
+}
+function parseItem(value) {
+    const row = object(value, 'item');
+    if (typeof row.pinned !== 'boolean')
+        invalid('item.pinned must be boolean');
+    const id = string(row.id, 'item.id');
+    if (!id.trim())
+        invalid('item.id must not be empty');
+    return {
+        id,
+        title: string(row.title, 'item.title'),
+        summary: string(row.summary, 'item.summary'),
+        title_en: string(row.title_en, 'item.title_en'),
+        summary_en: string(row.summary_en, 'item.summary_en'),
+        url: string(row.url, 'item.url'),
+        source: string(row.source, 'item.source'),
+        published_at: timestamp(row.published_at, 'item.published_at'),
+        first_seen_at: timestamp(row.first_seen_at, 'item.first_seen_at', false),
+        tags: array(row.tags, 'item.tags').map((tag) => string(tag, 'tag')),
+        importance: integer(row.importance, 'item.importance', 1, 5),
+        pinned: row.pinned,
+    };
+}
+export class NewsClient {
+    baseUrl;
+    timeoutMs;
+    constructor(options = {}) {
+        try {
+            this.baseUrl = new URL(options.url ?? process.env.NEWS_API_URL ?? DEFAULT_API_URL);
+        }
+        catch {
+            throw new NewsError('INVALID_ARGUMENT', '--url / NEWS_API_URL must be an absolute URL');
+        }
+        const url = this.baseUrl;
+        const loopback = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+        if (url.protocol !== 'https:' && !(url.protocol === 'http:' && loopback)) {
+            throw new NewsError('INVALID_ARGUMENT', 'Use an HTTPS API URL, or HTTP on localhost for development');
+        }
+        if (url.username || url.password || url.search || url.hash) {
+            throw new NewsError('INVALID_ARGUMENT', 'The API URL must not contain credentials, a query, or a fragment');
+        }
+        url.pathname = `${url.pathname.replace(/\/+$/, '')}/`;
+        this.timeoutMs = options.timeoutMs ?? 20_000;
+        if (!Number.isInteger(this.timeoutMs) || this.timeoutMs < 1 || this.timeoutMs > 120_000) {
+            throw new NewsError('INVALID_ARGUMENT', 'The request timeout must be between 1 and 120000 milliseconds');
+        }
+    }
+    async get(path, params = {}) {
+        const url = new URL(path, this.baseUrl);
+        for (const [key, value] of Object.entries(params))
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        const signal = AbortSignal.timeout(this.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                redirect: 'manual',
+                signal,
+                headers: { accept: 'application/json', 'user-agent': `news-skill/${VERSION}` },
+            });
+            if (response.status >= 300 && response.status < 400) {
+                await response.body?.cancel();
+                throw new NewsError('HTTP_ERROR', `NEWS returned HTTP ${response.status} for /${path}; configure the final API URL`);
+            }
+            const reader = response.body?.getReader();
+            const chunks = [];
+            let size = 0;
+            if (reader) {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        size += value.byteLength;
+                        if (size > MAX_RESPONSE_BYTES) {
+                            await reader.cancel();
+                            throw new NewsError('RESPONSE_TOO_LARGE', 'NEWS response exceeds 16 MiB');
+                        }
+                        chunks.push(value);
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            }
+            const body = Buffer.concat(chunks).toString('utf8');
+            let data;
+            try {
+                data = JSON.parse(body);
+            }
+            catch { /* Report HTTP status before JSON errors. */ }
+            if (!response.ok) {
+                let detail = '';
+                if (data && typeof data === 'object' && 'error' in data) {
+                    const error = data.error;
+                    if (error && typeof error === 'object' && 'message' in error && typeof error.message === 'string') {
+                        detail = `: ${error.message.replace(/[\x00-\x1f\x7f]/g, ' ').slice(0, 400)}`;
+                    }
+                }
+                throw new NewsError('HTTP_ERROR', `NEWS returned HTTP ${response.status} for /${path}${detail}`);
+            }
+            if (data === undefined)
+                invalid(`/${path} did not return JSON`);
+            return data;
+        }
+        catch (error) {
+            if (error instanceof NewsError)
+                throw error;
+            if (signal.aborted)
+                throw new NewsError('TIMEOUT', `NEWS request timed out after ${this.timeoutMs / 1000}s for /${path}`);
+            const cause = error instanceof Error ? error.message : 'Connection failed';
+            throw new NewsError('NETWORK_ERROR', `Could not reach ${this.baseUrl.origin}: ${cause}`);
+        }
+    }
+    async topics() {
+        const data = object(await this.get('topics'), 'topics response');
+        return { topics: array(data.topics, 'topics').map(parseTopic) };
+    }
+    async days(topic, limit = 30) {
+        const data = object(await this.get('days', { topic, limit }), 'days response');
+        return { days: array(data.days, 'days').map((value) => {
+                const row = object(value, 'day');
+                return { day: date(row.day, 'day.day'), count: integer(row.count, 'day.count') };
+            }) };
+    }
+    async digest(params = {}) {
+        const data = object(await this.get('digest', { ...params }), 'digest response');
+        const timezone = string(data.timezone, 'timezone');
+        try {
+            new Intl.DateTimeFormat('en', { timeZone: timezone });
+        }
+        catch {
+            invalid('timezone must be an IANA timezone');
+        }
+        return {
+            day: data.day === null ? null : date(data.day, 'day'),
+            timezone,
+            generated_at: timestamp(data.generated_at, 'generated_at', false),
+            topics: array(data.topics, 'topics').map((value) => {
+                const row = object(value, 'topic digest');
+                return {
+                    ...parseTopic(row),
+                    total: integer(row.total, 'topic.total'),
+                    next: optionalString(row.next, 'topic.next'),
+                    items: array(row.items, 'topic.items').map(parseItem),
+                };
+            }),
+        };
+    }
+    async insight() {
+        const data = object(await this.get('insight'), 'insight response');
+        if (data.insight === null)
+            return { insight: null };
+        const row = object(data.insight, 'insight');
+        const indexes = (value) => array(value, 'source_indexes').map((index) => integer(index, 'source index'));
+        const signals = (value) => array(value, 'signals').map((value) => {
+            const signal = object(value, 'signal');
+            return {
+                ...signal,
+                title: string(signal.title, 'signal.title'), title_en: string(signal.title_en, 'signal.title_en'),
+                summary: string(signal.summary, 'signal.summary'), summary_en: string(signal.summary_en, 'signal.summary_en'),
+                source_indexes: indexes(signal.source_indexes ?? []),
+            };
+        });
+        return { insight: {
+                ...row,
+                generated_at: timestamp(row.generated_at, 'insight.generated_at', false),
+                window_start: timestamp(row.window_start, 'insight.window_start', false),
+                headline: string(row.headline, 'headline'), headline_en: string(row.headline_en, 'headline_en'),
+                overview: string(row.overview, 'overview'), overview_en: string(row.overview_en, 'overview_en'),
+                changes: string(row.changes, 'changes'), changes_en: string(row.changes_en, 'changes_en'),
+                changes_source_indexes: indexes(row.changes_source_indexes ?? []),
+                wealth: signals(row.wealth), employment: signals(row.employment), risks: signals(row.risks), actions: signals(row.actions),
+                sources: array(row.sources, 'sources').map((value) => {
+                    const source = object(value, 'source');
+                    return { ...source, index: integer(source.index, 'source.index'), title: string(source.title, 'source.title'),
+                        title_en: string(source.title_en, 'source.title_en'), url: string(source.url, 'source.url'), source: string(source.source, 'source.source') };
+                }),
+                research_sources: array(row.research_sources ?? [], 'research_sources').map((value) => {
+                    const source = object(value, 'research source');
+                    return { title: string(source.title, 'research source.title'), url: string(source.url, 'research source.url') };
+                }),
+            } };
+    }
+}

package/skills/news/scripts/format.js

@@ -0,0 +1,119 @@
+/** Render service text as text, not HTML, terminal escapes, or new Markdown blocks. */
+export function escapeMarkdown(value) {
+    return value.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ').replace(/[\\`*_[\]<>#|]/g, '\\$&');
+}
+function link(title, url) {
+    const label = escapeMarkdown(title);
+    try {
+        const parsed = new URL(url);
+        if (!['https:', 'http:'].includes(parsed.protocol) || parsed.username || parsed.password)
+            return label;
+        const href = parsed.href.replace(/[<>\\]/g, (char) => encodeURIComponent(char));
+        return `[${label}](<${href}>)`;
+    }
+    catch {
+        return label;
+    }
+}
+function localized(row, key, lang) {
+    const english = row[`${key}_en`];
+    const native = row[key];
+    return lang === 'en' && typeof english === 'string' && english.trim()
+        ? english : typeof native === 'string' ? native : '';
+}
+function timestamp(value, timezone) {
+    const formatted = new Intl.DateTimeFormat('sv-SE', {
+        timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+    }).format(new Date(value));
+    return `${formatted} (${timezone})`;
+}
+export function formatTopics(data, lang) {
+    const lines = [lang === 'zh' ? '# NEWS 主题' : '# NEWS topics', ''];
+    for (const topic of data.topics) {
+        lines.push(`- **${escapeMarkdown(lang === 'en' ? topic.name_en || topic.name : topic.name)}** — \`${escapeMarkdown(topic.id)}\``);
+        if (topic.description)
+            lines.push(`  ${escapeMarkdown(topic.description)}`);
+        lines.push(`  ${lang === 'zh' ? '最近收录日期' : 'Latest collection day'}: ${topic.latest_day ?? '—'}`);
+    }
+    if (!data.topics.length)
+        lines.push(lang === 'zh' ? '暂无公开主题。' : 'No public topics available.');
+    return lines.join('\n');
+}
+export function formatDays(data, lang) {
+    return [lang === 'zh' ? '# NEWS 收录日期' : '# NEWS collection days', '',
+        ...data.days.map((day) => `- ${day.day}: ${day.count} ${lang === 'zh' ? '条' : 'items'}`),
+        ...(!data.days.length ? [lang === 'zh' ? '暂无收录。' : 'No archived items.'] : []),
+    ].join('\n');
+}
+export function formatNews(data, lang) {
+    const en = lang === 'en';
+    const dates = data.coverage.days;
+    const range = dates.length > 1 ? `${dates.at(-1)} – ${dates[0]}` : dates[0] ?? (en ? 'No collection date' : '暂无收录日期');
+    const lines = [data.query ? `# NEWS · ${escapeMarkdown(data.query)}` : '# NEWS', '',
+        `${en ? 'Collection dates' : '收录日期'}: ${range} · ${escapeMarkdown(data.timezone)}`,
+        `${en ? 'Retrieved' : '查询时间'}: ${timestamp(data.retrieved_at, data.timezone)}`,
+        `${en ? 'Returned / matched in scanned content' : '返回 / 已扫描内容中的匹配数'}: ${data.returned} / ${data.matched}`, ''];
+    if (!data.coverage.complete) {
+        lines.push(en
+            ? `> Partial results: reached the ${data.coverage.max_pages}-page scan limit. More matches may exist. Increase --max-pages or narrow the selection.`
+            : `> 结果不完整：已达到 ${data.coverage.max_pages} 页扫描上限，可能还有匹配新闻。可增加 --max-pages 或缩小查询范围。`, '');
+    }
+    if (!data.items.length)
+        lines.push(en ? 'No matches in the scanned NEWS content.' : '已扫描的 NEWS 内容中没有匹配项。', '');
+    for (const [index, item] of data.items.entries()) {
+        const title = en ? item.title_en || item.title : item.title;
+        const summary = en ? item.summary_en || item.summary : item.summary;
+        lines.push(`${index + 1}. **${link(title, item.url)}**`, `   ${escapeMarkdown(summary)}`);
+        const when = item.published_at ? timestamp(item.published_at, data.timezone) : (en ? 'Unknown' : '未知');
+        lines.push(`   ${escapeMarkdown(item.source)} · ${en ? 'Published' : '发布'}: ${when} · ${en ? 'Importance' : '重要性'}: ${item.importance}/5`);
+        lines.push(`   ${en ? 'Collected' : '收录'}: ${timestamp(item.first_seen_at, data.timezone)} · ${item.topic_ids.map(escapeMarkdown).join(', ')}`, '');
+    }
+    if (data.sources.length) {
+        const updates = new Map();
+        for (const source of data.sources) {
+            if (source.updated_at && source.updated_at > (updates.get(source.topic_id) ?? ''))
+                updates.set(source.topic_id, source.updated_at);
+        }
+        if (updates.size) {
+            lines.push(en ? 'Source snapshot updates (within the selected dates):' : '来源快照更新时间（所选日期内）：');
+            for (const [topic, updatedAt] of updates)
+                lines.push(`- ${escapeMarkdown(topic)}: ${timestamp(updatedAt, data.timezone)}`);
+        }
+    }
+    return lines.join('\n');
+}
+function references(indexes, insight) {
+    return indexes.filter((index) => insight.sources.some((source) => source.index === index)).map((index) => `[${index}]`).join(' ');
+}
+export function formatInsight(data, lang) {
+    const en = lang === 'en';
+    const insight = data.insight;
+    if (!insight)
+        return en ? 'No NEWS analysis is available yet.' : 'NEWS 暂无综合研判。';
+    const lines = [`# ${escapeMarkdown(localized(insight, 'headline', lang))}`, '',
+        `${en ? 'NEWS AI analysis · Generated' : 'NEWS AI 综合研判 · 生成时间'}: ${escapeMarkdown(insight.generated_at)}`,
+        `${en ? 'Analysis window starts' : '分析窗口起点'}: ${escapeMarkdown(insight.window_start)}`, '',
+        escapeMarkdown(localized(insight, 'overview', lang)), '',
+        `${escapeMarkdown(localized(insight, 'changes', lang))} ${references(insight.changes_source_indexes, insight)}`, ''];
+    const sections = [['wealth', '商业与机遇', 'Business and opportunities'], ['employment', '就业与技能', 'Employment and skills'],
+        ['risks', '风险预警', 'Risks'], ['actions', '观察方向', 'What to watch']];
+    for (const [key, chinese, english] of sections) {
+        if (!insight[key].length)
+            continue;
+        lines.push(`## ${en ? english : chinese}`, '');
+        for (const signal of insight[key]) {
+            lines.push(`- **${escapeMarkdown(localized(signal, 'title', lang))}** — ${escapeMarkdown(localized(signal, 'summary', lang))} ${references(signal.source_indexes, insight)}`);
+        }
+        lines.push('');
+    }
+    if (insight.sources.length || insight.research_sources.length) {
+        lines.push(en ? '## Sources' : '## 来源', '');
+        for (const source of insight.sources) {
+            lines.push(`- [${source.index}] ${link(localized(source, 'title', lang), source.url)} — ${escapeMarkdown(source.source)}`);
+        }
+        for (const source of insight.research_sources)
+            lines.push(`- ${link(source.title, source.url)}`);
+    }
+    return lines.join('\n');
+}

package/skills/news/scripts/meta.js

@@ -0,0 +1,4 @@
+import { readFileSync } from 'node:fs';
+// The build copies only this metadata into the installed, self-contained skill.
+export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+export const DEFAULT_API_URL = 'https://news.xairouter.com';

package/skills/news/scripts/news.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { NewsClient, NewsError } from './client.js';
+import { formatDays, formatInsight, formatNews, formatTopics } from './format.js';
+import { VERSION } from './meta.js';
+import { queryNews } from './query.js';
+import { installSkills, readSkill } from './skills.js';
+const HELP = `NEWS — public news in your agent (Node.js 22.12+)
+
+Usage:
+  news topics
+  news days [--topic ID] [--limit N]
+  news read [selection options]
+  news search "KEYWORDS" [selection options]
+  news insight
+  news skills show
+  news skills install --agent codex|claude|opencode|pi|all
+                      [--scope user|project] [--force]
+
+Selection options:
+  --topic ID             One public topic ID (discover with news topics)
+  --day DATE             YYYY-MM-DD, today, or yesterday
+  --days N               Last N calendar days including today (1–31)
+  --from DATE --to DATE  Inclusive collection-date range (at most 31 days)
+                        Use one date selector; default: latest available day
+  --limit N              Global output limit (default 10, max 100)
+  --sort latest|importance   Default: latest
+  --min-importance N     Minimum importance, 1–5 (default 1)
+  --max-pages N          Total digest scan requests (default 20, max 200)
+
+Common options:
+  --format json|markdown  Default: JSON; Markdown source needs a renderer
+  --lang zh|en            Markdown language (default zh)
+  --url URL              API base URL (or NEWS_API_URL)
+  --timeout SECONDS      Per-request timeout (default 20, max 120)
+  -h, --help             Show this help
+  -v, --version          Show version
+
+Examples:
+  news read --topic openai --day today --limit 5 --format markdown
+  news search "Claude Code" --days 3 --format markdown
+  news read --topic github --sort importance --lang en --format markdown
+
+Search matches a literal phrase in existing bilingual titles, summaries,
+sources and tags. It does not request fresh crawling or web search.
+Dates select collection days in the API timezone. Incomplete scans are
+marked in coverage.complete; no matches need not mean no news exists.
+
+Skills are copied with the CLI included. Reload skills or start a new
+agent session after installation. Existing unrelated skills are preserved.
+`;
+const definition = {
+    help: { type: 'boolean', short: 'h' }, version: { type: 'boolean', short: 'v' },
+    topic: { type: 'string' }, day: { type: 'string' }, days: { type: 'string' },
+    from: { type: 'string' }, to: { type: 'string' }, limit: { type: 'string' },
+    sort: { type: 'string' }, 'min-importance': { type: 'string' }, 'max-pages': { type: 'string' },
+    format: { type: 'string' }, lang: { type: 'string' }, url: { type: 'string' }, timeout: { type: 'string' },
+    agent: { type: 'string' }, scope: { type: 'string' }, force: { type: 'boolean' },
+};
+function number(value, option, max) {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)) || Number(value) < 1 || Number(value) > max) {
+        throw new NewsError('INVALID_ARGUMENT', `--${option} must be an integer from 1 to ${max}`);
+    }
+    return Number(value);
+}
+function print(data, markdown, format) {
+    process.stdout.write(`${format === 'markdown' ? markdown() : JSON.stringify(data, null, 2)}\n`);
+}
+export async function main(args = process.argv.slice(2)) {
+    let parsed;
+    try {
+        parsed = parseArgs({ args, options: definition, allowPositionals: true, tokens: true });
+    }
+    catch (error) {
+        throw new NewsError('INVALID_ARGUMENT', error instanceof Error ? error.message : 'Invalid arguments');
+    }
+    const { values, positionals, tokens } = parsed;
+    if (values.help || args.length === 0) {
+        process.stdout.write(HELP);
+        return;
+    }
+    if (values.version) {
+        process.stdout.write(`${VERSION}\n`);
+        return;
+    }
+    const seen = new Set();
+    for (const token of tokens) {
+        if (token.kind !== 'option')
+            continue;
+        if (seen.has(token.name))
+            throw new NewsError('INVALID_ARGUMENT', `--${token.name} must only be provided once`);
+        seen.add(token.name);
+    }
+    const [command, ...rest] = positionals;
+    const format = values.format ?? 'json';
+    if (!['json', 'markdown'].includes(format))
+        throw new NewsError('INVALID_ARGUMENT', '--format must be json or markdown');
+    const lang = values.lang ?? 'zh';
+    if (!['zh', 'en'].includes(lang))
+        throw new NewsError('INVALID_ARGUMENT', '--lang must be zh or en');
+    const language = lang;
+    const common = ['help', 'version', 'format', 'lang', 'url', 'timeout'];
+    const selectionFlags = ['topic', 'day', 'days', 'from', 'to', 'limit', 'sort', 'min-importance', 'max-pages'];
+    const allowed = {
+        topics: [], days: ['topic', 'limit'], read: selectionFlags, search: selectionFlags,
+        insight: [], skills: rest[0] === 'install' ? ['agent', 'scope', 'force'] : [],
+    };
+    if (!command || !(command in allowed))
+        throw new NewsError('INVALID_ARGUMENT', `Unknown command: ${command ?? '(missing)'}. Run news --help.`);
+    for (const flag of seen) {
+        if (!common.includes(flag) && !allowed[command].includes(flag))
+            throw new NewsError('INVALID_ARGUMENT', `--${flag} is not supported by ${command}`);
+    }
+    if (command === 'skills') {
+        if (rest.length !== 1)
+            throw new NewsError('INVALID_ARGUMENT', 'Use news skills show or news skills install --agent AGENT');
+        if (rest[0] === 'show') {
+            process.stdout.write(await readSkill());
+            return;
+        }
+        if (rest[0] !== 'install')
+            throw new NewsError('INVALID_ARGUMENT', 'Unknown skills command');
+        if (!values.agent)
+            throw new NewsError('INVALID_ARGUMENT', 'Specify --agent codex|claude|opencode|pi|all');
+        const result = await installSkills({ agent: values.agent, scope: values.scope, force: values.force });
+        print(result, () => result.installations.map((item) => `- ${item.agent}: ${item.status} — ${item.path}`).join('\n'), format);
+        return;
+    }
+    if (command === 'search' ? rest.length !== 1 || !rest[0]?.trim() : rest.length !== 0) {
+        throw new NewsError('INVALID_ARGUMENT', command === 'search' ? 'Supply one quoted search phrase: news search "Claude Code"' : `${command} does not accept positional arguments`);
+    }
+    if (values.topic !== undefined && !values.topic.trim())
+        throw new NewsError('INVALID_ARGUMENT', '--topic must not be empty');
+    const timeout = number(values.timeout, 'timeout', 120) ?? 20;
+    const client = new NewsClient({ url: values.url, timeoutMs: timeout * 1000 });
+    if (command === 'topics') {
+        const result = await client.topics();
+        print(result, () => formatTopics(result, language), format);
+    }
+    else if (command === 'days') {
+        const result = await client.days(values.topic, number(values.limit, 'limit', 366) ?? 30);
+        print(result, () => formatDays(result, language), format);
+    }
+    else if (command === 'insight') {
+        const result = await client.insight();
+        print(result, () => formatInsight(result, language), format);
+    }
+    else {
+        if (values.sort && !['latest', 'importance'].includes(values.sort))
+            throw new NewsError('INVALID_ARGUMENT', '--sort must be latest or importance');
+        const options = {
+            topic: values.topic, day: values.day, days: number(values.days, 'days', 31), from: values.from, to: values.to,
+            limit: number(values.limit, 'limit', 100), sort: values.sort,
+            minImportance: number(values['min-importance'], 'min-importance', 5), maxPages: number(values['max-pages'], 'max-pages', 200),
+            ...(command === 'search' ? { query: rest[0] } : {}),
+        };
+        const result = await queryNews(client, options);
+        print(result, () => formatNews(result, language), format);
+    }
+}
+// Pipe consumers such as head may close stdout early. That is a successful read.
+process.stdout.on('error', (error) => {
+    if (error.code === 'EPIPE')
+        process.exit(0);
+    throw error;
+});
+main().catch((error) => {
+    const code = error instanceof NewsError ? error.code : 'COMMAND_FAILED';
+    const message = error instanceof Error ? error.message : 'NEWS command failed';
+    process.stderr.write(`${JSON.stringify({ error: { code, message } })}\n`);
+    process.exitCode = 1;
+});