@jackwener/opencli 1.7.12 → 1.7.13

package/clis/nuget/package.js

@@ -0,0 +1,101 @@
+// nuget package — full version history for a NuGet package id.
+//
+// Hits the registration index `api.nuget.org/v3/registration5-semver1/<id>/index.json`.
+// The id path segment must be lowercase per NuGet's CDN routing.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { NUGET_REGISTRATION_BASE, joinAuthors, joinTags, nugetFetch, requirePackageId } from './utils.js';
+
+cli({
+    site: 'nuget',
+    name: 'package',
+    access: 'read',
+    description: 'Full NuGet package version history (catalogEntry per release)',
+    domain: 'api.nuget.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'NuGet package id (e.g. "Newtonsoft.Json", case-insensitive)' },
+    ],
+    columns: [
+        'rank',
+        'id',
+        'version',
+        'title',
+        'authors',
+        'tags',
+        'language',
+        'licenseExpression',
+        'projectUrl',
+        'published',
+        'listed',
+        'url',
+    ],
+    func: async (args) => {
+        const id = requirePackageId(args.id);
+        const url = `${NUGET_REGISTRATION_BASE}/${encodeURIComponent(id.toLowerCase())}/index.json`;
+        const body = await nugetFetch(url, 'nuget package');
+        const pages = Array.isArray(body?.items) ? body.items : [];
+        // Each page can be inline (with `items`) or a stub that needs another fetch
+        // for older packages. Inline is the common case for everything published in
+        // the last few years. We follow stub pages once each — at most ~5 round-trips.
+        const allEntries = [];
+        for (const [pageIndex, page] of pages.entries()) {
+            let pageItems = Array.isArray(page?.items) ? page.items : null;
+            if (!pageItems) {
+                // Stub page → fetch the leaf.
+                const pageUrl = typeof page?.['@id'] === 'string' ? page['@id'] : null;
+                if (!pageUrl) {
+                    throw new CommandExecutionError(
+                        `nuget package registration page ${pageIndex + 1} is missing @id for package "${id}"`,
+                    );
+                }
+                const leaf = await nugetFetch(pageUrl, 'nuget package page');
+                if (!Array.isArray(leaf?.items)) {
+                    throw new CommandExecutionError(
+                        `nuget package registration leaf ${pageUrl} did not include an items array`,
+                    );
+                }
+                pageItems = leaf.items;
+            }
+            for (const it of pageItems) {
+                if (!it || typeof it !== 'object' || !it.catalogEntry || typeof it.catalogEntry !== 'object') {
+                    throw new CommandExecutionError(
+                        `nuget package registration page ${pageIndex + 1} contains a malformed version entry`,
+                    );
+                }
+                allEntries.push(it);
+            }
+        }
+        if (!allEntries.length) {
+            throw new EmptyResultError('nuget package', `No published versions found for NuGet package "${id}".`);
+        }
+        // Sort by published desc; ties broken by version string descending.
+        const sorted = [...allEntries].sort((a, b) => {
+            const ap = a?.catalogEntry?.published ?? '';
+            const bp = b?.catalogEntry?.published ?? '';
+            if (ap !== bp) return bp.localeCompare(ap);
+            const av = a?.catalogEntry?.version ?? '';
+            const bv = b?.catalogEntry?.version ?? '';
+            return bv.localeCompare(av);
+        });
+        return sorted.map((entry, i) => {
+            const cat = entry?.catalogEntry ?? {};
+            return {
+                rank: i + 1,
+                id: typeof cat?.id === 'string' ? cat.id : id,
+                version: typeof cat?.version === 'string' ? cat.version : null,
+                title: typeof cat?.title === 'string' ? cat.title : null,
+                authors: joinAuthors(cat?.authors),
+                tags: joinTags(cat?.tags),
+                language: typeof cat?.language === 'string' ? cat.language : null,
+                licenseExpression: typeof cat?.licenseExpression === 'string' ? cat.licenseExpression : null,
+                projectUrl: typeof cat?.projectUrl === 'string' ? cat.projectUrl : null,
+                published: typeof cat?.published === 'string' ? cat.published : null,
+                listed: typeof cat?.listed === 'boolean' ? cat.listed : null,
+                url: typeof cat?.id === 'string' && typeof cat?.version === 'string'
+                    ? `https://www.nuget.org/packages/${cat.id}/${cat.version}` : '',
+            };
+        });
+    },
+});

package/clis/nuget/search.js

@@ -0,0 +1,69 @@
+// nuget search — full-text search the NuGet package index.
+//
+// Hits `azuresearch-usnc.nuget.org/query?q=…&take=…&prerelease=false`. The `id`
+// column round-trips into `nuget package` for full version history.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    NUGET_SEARCH_BASE,
+    joinAuthors,
+    joinTags,
+    nugetFetch,
+    requireBoundedInt,
+    requireString,
+} from './utils.js';
+
+cli({
+    site: 'nuget',
+    name: 'search',
+    access: 'read',
+    description: 'Search NuGet packages by keyword',
+    domain: 'api.nuget.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max packages (1-1000)' },
+        { name: 'prerelease', type: 'boolean', default: false, help: 'Include prerelease versions' },
+    ],
+    columns: [
+        'rank',
+        'id',
+        'version',
+        'title',
+        'description',
+        'authors',
+        'tags',
+        'totalDownloads',
+        'verified',
+        'projectUrl',
+        'url',
+    ],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 20, 1000);
+        const prerelease = args.prerelease === true ? 'true' : 'false';
+        const url = `${NUGET_SEARCH_BASE}/query?q=${encodeURIComponent(query)}&take=${limit}&prerelease=${prerelease}`;
+        const body = await nugetFetch(url, 'nuget search');
+        const list = Array.isArray(body?.data) ? body.data : [];
+        if (!list.length) {
+            throw new EmptyResultError('nuget search', `No NuGet packages matched "${query}".`);
+        }
+        return list.slice(0, limit).map((pkg, i) => {
+            const id = typeof pkg?.id === 'string' ? pkg.id : '';
+            return {
+                rank: i + 1,
+                id,
+                version: typeof pkg?.version === 'string' ? pkg.version : null,
+                title: typeof pkg?.title === 'string' ? pkg.title : null,
+                description: typeof pkg?.description === 'string' ? pkg.description : null,
+                authors: joinAuthors(pkg?.authors),
+                tags: joinTags(pkg?.tags),
+                totalDownloads: typeof pkg?.totalDownloads === 'number' ? pkg.totalDownloads : null,
+                verified: pkg?.verified === true,
+                projectUrl: typeof pkg?.projectUrl === 'string' ? pkg.projectUrl : null,
+                url: id ? `https://www.nuget.org/packages/${id}` : '',
+            };
+        });
+    },
+});

package/clis/nuget/utils.js

@@ -0,0 +1,87 @@
+// Shared helpers for the NuGet adapters.
+//
+// NuGet exposes two complementary endpoints:
+//   • `azuresearch-usnc.nuget.org/query` — full-text package search (V3)
+//   • `api.nuget.org/v3/registration5-semver1/<id>/index.json` — package detail
+// No API key required. Anonymous traffic is generous; we set a polite UA.
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const NUGET_SEARCH_BASE = 'https://azuresearch-usnc.nuget.org';
+export const NUGET_REGISTRATION_BASE = 'https://api.nuget.org/v3/registration5-semver1';
+const UA = 'opencli-nuget-adapter/1.0 (+https://github.com/jackwener/opencli; mailto:opencli@example.com)';
+
+// NuGet ID grammar (NuGet docs §package-id): up to 100 chars, alnum + `.` + `_` + `-`,
+// must start with letter/digit. Case-insensitive; we lowercase for the registration URL
+// because NuGet's CDN is case-sensitive on the path.
+const PACKAGE_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,99})$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`nuget ${label} cannot be empty`);
+    return s;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`nuget ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`nuget ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export function requirePackageId(value) {
+    const raw = String(value ?? '').trim();
+    if (!raw) throw new ArgumentError('nuget package id is required (e.g. "Newtonsoft.Json")');
+    if (!PACKAGE_ID_PATTERN.test(raw)) {
+        throw new ArgumentError(
+            `nuget package id "${value}" is not a valid NuGet identifier`,
+            'NuGet IDs are 1-100 chars: letters/digits/`.`/`_`/`-`, starting with letter or digit.',
+        );
+    }
+    return raw;
+}
+
+export async function nugetFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that api.nuget.org is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `NuGet returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(`${label} returned HTTP 429 (rate limited)`);
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}
+
+export function joinTags(tags) {
+    if (!Array.isArray(tags)) return '';
+    return tags.filter((t) => typeof t === 'string' && t.trim()).join(', ');
+}
+
+export function joinAuthors(authors) {
+    if (Array.isArray(authors)) return authors.filter((a) => typeof a === 'string' && a.trim()).join(', ');
+    if (typeof authors === 'string') return authors.trim();
+    return '';
+}

package/clis/nvd/cve.js

@@ -0,0 +1,121 @@
+// nvd cve — fetch a single CVE from the NIST National Vulnerability Database.
+//
+// Hits the CVE API 2.0 (`services.nvd.nist.gov/rest/json/cves/2.0?cveId=…`).
+// Returns the agent-useful projection: id, published / last-modified dates,
+// vuln status, English description, CVSS v3.1 base score / severity / vector,
+// CWE id(s), CISA KEV flag.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const NVD_BASE = 'https://services.nvd.nist.gov/rest/json/cves/2.0';
+const UA = 'opencli-nvd-adapter (+https://github.com/jackwener/opencli)';
+const CVE_ID = /^CVE-\d{4}-\d{4,}$/i;
+
+function requireCveId(value) {
+    const s = String(value ?? '').trim().toUpperCase();
+    if (!s) throw new ArgumentError('nvd CVE id is required (e.g. "CVE-2021-44228")');
+    if (!CVE_ID.test(s)) {
+        throw new ArgumentError(
+            `nvd CVE id "${value}" is not a valid CVE identifier`,
+            'Expected the form "CVE-YYYY-N..." with at least 4 sequence digits.',
+        );
+    }
+    return s;
+}
+
+function pickEnglishDescription(descriptions) {
+    if (!Array.isArray(descriptions)) return '';
+    const en = descriptions.find((d) => d?.lang === 'en');
+    return String(en?.value ?? descriptions[0]?.value ?? '').trim();
+}
+
+function pickPrimaryCvss(metrics) {
+    if (!metrics || typeof metrics !== 'object') return null;
+    const candidates = [
+        ...(Array.isArray(metrics.cvssMetricV31) ? metrics.cvssMetricV31 : []),
+        ...(Array.isArray(metrics.cvssMetricV30) ? metrics.cvssMetricV30 : []),
+        ...(Array.isArray(metrics.cvssMetricV2) ? metrics.cvssMetricV2 : []),
+    ];
+    return candidates.find((m) => m?.type === 'Primary') || candidates[0] || null;
+}
+
+function joinCwes(weaknesses) {
+    if (!Array.isArray(weaknesses)) return '';
+    const ids = new Set();
+    for (const w of weaknesses) {
+        for (const desc of w?.description ?? []) {
+            if (desc?.value) ids.add(String(desc.value));
+        }
+    }
+    return [...ids].join(', ');
+}
+
+cli({
+    site: 'nvd',
+    name: 'cve',
+    access: 'read',
+    description: 'NIST NVD CVE detail (description, CVSS, CWE, KEV flag)',
+    domain: 'services.nvd.nist.gov',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'CVE identifier (e.g. "CVE-2021-44228")' },
+    ],
+    columns: [
+        'id', 'published', 'lastModified', 'vulnStatus', 'baseScore', 'severity',
+        'attackVector', 'cwe', 'kevAdded', 'description', 'url',
+    ],
+    func: async (args) => {
+        const id = requireCveId(args.id);
+        const url = `${NVD_BASE}?cveId=${encodeURIComponent(id)}`;
+        let resp;
+        try {
+            resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+        }
+        catch (err) {
+            throw new CommandExecutionError(`nvd cve request failed: ${err?.message ?? err}`);
+        }
+        if (resp.status === 403) {
+            throw new CommandExecutionError(
+                'nvd cve returned HTTP 403',
+                'NVD enforces aggressive rate limits without an API key. Wait, then retry or set NVD_API_KEY (not yet wired).',
+            );
+        }
+        if (resp.status === 429) {
+            throw new CommandExecutionError(
+                'nvd cve returned HTTP 429 (rate limited)',
+                'NVD throttles unauthenticated traffic; wait several seconds before retry.',
+            );
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`nvd cve returned HTTP ${resp.status}`);
+        }
+        let body;
+        try {
+            body = await resp.json();
+        }
+        catch (err) {
+            throw new CommandExecutionError(`nvd cve returned malformed JSON: ${err?.message ?? err}`);
+        }
+        const list = Array.isArray(body?.vulnerabilities) ? body.vulnerabilities : [];
+        const cve = list[0]?.cve;
+        if (!cve || !cve.id) {
+            throw new EmptyResultError('nvd cve', `NVD has no record for "${id}".`);
+        }
+        const cvss = pickPrimaryCvss(cve.metrics);
+        const cvssData = cvss?.cvssData ?? {};
+        return [{
+            id: String(cve.id),
+            published: String(cve.published ?? '').slice(0, 10),
+            lastModified: String(cve.lastModified ?? '').slice(0, 10),
+            vulnStatus: String(cve.vulnStatus ?? ''),
+            baseScore: cvssData.baseScore != null ? Number(cvssData.baseScore) : null,
+            severity: String(cvssData.baseSeverity ?? cvss?.baseSeverity ?? ''),
+            attackVector: String(cvssData.attackVector ?? ''),
+            cwe: joinCwes(cve.weaknesses),
+            kevAdded: cve.cisaExploitAdd ? String(cve.cisaExploitAdd).slice(0, 10) : '',
+            description: pickEnglishDescription(cve.descriptions),
+            url: `https://nvd.nist.gov/vuln/detail/${cve.id}`,
+        }];
+    },
+});

package/clis/oeis/oeis.test.js

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './search.js';
+import './sequence.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('oeis search adapter', () => {
+    const cmd = getRegistry().get('oeis/search');
+
+    it('rejects bad args before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        await expect(cmd.func({ query: '' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 999 })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 429 to CommandExecutionError', async () => {
+        // Fresh Response per call so we don't tickle "Body has already been read" between pages.
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(() => Promise.resolve(new Response('throttled', { status: 429 }))));
+        await expect(cmd.func({ query: 'fibonacci', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when first page is empty', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(() => Promise.resolve(new Response(JSON.stringify([]), { status: 200 }))));
+        await expect(cmd.func({ query: 'no-results', limit: 5 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('round-trips A-id from search row into oeis.org URL', async () => {
+        const result = [{
+            number: 45, name: 'Fibonacci numbers', keyword: 'core,nonn,nice',
+            data: '0,1,1,2,3,5,8,13,21,34,55,89',
+            author: 'Sloane', created: '1991-04-30T03:00:00-04:00',
+        }];
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(() => Promise.resolve(new Response(JSON.stringify(result), { status: 200 }))));
+        const rows = await cmd.func({ query: 'fibonacci', limit: 1 });
+        expect(rows[0]).toMatchObject({
+            rank: 1, id: 'A000045', name: 'Fibonacci numbers',
+            keywords: 'core,nonn,nice',
+            preview: '0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89',
+            url: 'https://oeis.org/A000045',
+        });
+    });
+});
+
+describe('oeis sequence adapter', () => {
+    const cmd = getRegistry().get('oeis/sequence');
+
+    it('rejects malformed sequence ids before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        await expect(cmd.func({ id: '' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'B000045' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'A' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('throws EmptyResultError when search returns null/empty list', async () => {
+        // OEIS returns empty list (or sometimes null body) for unknown id.
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify([]), { status: 200 })));
+        await expect(cmd.func({ id: 'A9999999' })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('counts comments / formulas / xrefs without dumping the full graph', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify([{
+            number: 40, name: 'The prime numbers.', keyword: 'core,nonn',
+            data: '2,3,5,7,11,13,17,19,23',
+            offset: '1,1', author: 'Sloane', created: '1991-04-30T03:00:00-04:00', revision: 100,
+            comment: ['c1', 'c2', 'c3'],
+            formula: ['f1', 'f2'],
+            reference: ['r1'],
+            xref: ['A000001', 'A000002'],
+            link: ['l1', 'l2', 'l3', 'l4'],
+        }]), { status: 200 })));
+        const rows = await cmd.func({ id: 'A000040' });
+        expect(rows[0]).toMatchObject({
+            id: 'A000040', name: 'The prime numbers.',
+            termCount: 9, offset: '1,1', revision: 100,
+            commentCount: 3, formulaCount: 2, referenceCount: 1, xrefCount: 2, linkCount: 4,
+            url: 'https://oeis.org/A000040',
+        });
+    });
+});

package/clis/oeis/search.js

@@ -0,0 +1,63 @@
+// oeis search — keyword / pattern search against the OEIS index.
+//
+// OEIS' search supports both natural-language queries ("fibonacci") and
+// numeric pattern queries ("1,1,2,3,5,8"). Returns up to 10 results per
+// page; we honor `--limit` by paginating via `&start=`.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { OEIS_BASE, formatId, oeisFetch, previewTerms, requireBoundedInt, requireString } from './utils.js';
+
+cli({
+    site: 'oeis',
+    name: 'search',
+    access: 'read',
+    description: 'Search OEIS sequences by keyword or numeric pattern',
+    domain: 'oeis.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword or comma-separated terms (e.g. "fibonacci", "1,1,2,3,5,8")' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max sequences (1-100)' },
+    ],
+    columns: ['rank', 'id', 'name', 'keywords', 'preview', 'author', 'created', 'url'],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 10, 100);
+        // OEIS returns 10 per page; paginate via `&start=` until we have `limit` rows
+        // or run out of pages. No silent clamp — if upstream has fewer results, surface
+        // every row that came back.
+        const collected = [];
+        let start = 0;
+        const pageSize = 10;
+        // Cap iterations defensively at limit/pageSize + 1 so we never spin forever.
+        const maxPages = Math.ceil(limit / pageSize) + 1;
+        for (let page = 0; page < maxPages && collected.length < limit; page++) {
+            const url = `${OEIS_BASE}/search?q=${encodeURIComponent(query)}&fmt=json&start=${start}`;
+            const body = await oeisFetch(url, 'oeis search');
+            const list = Array.isArray(body) ? body : [];
+            if (!list.length) break;
+            for (const r of list) {
+                if (collected.length >= limit) break;
+                collected.push(r);
+            }
+            if (list.length < pageSize) break;
+            start += pageSize;
+        }
+        if (!collected.length) {
+            throw new EmptyResultError('oeis search', `No OEIS sequences matched "${query}".`);
+        }
+        return collected.map((r, i) => {
+            const id = formatId(r?.number);
+            return {
+                rank: i + 1,
+                id,
+                name: typeof r?.name === 'string' ? r.name : null,
+                keywords: typeof r?.keyword === 'string' ? r.keyword : null,
+                preview: previewTerms(r?.data),
+                author: typeof r?.author === 'string' ? r.author : null,
+                created: typeof r?.created === 'string' ? r.created : null,
+                url: id ? `${OEIS_BASE}/${id}` : '',
+            };
+        });
+    },
+});

package/clis/oeis/sequence.js

@@ -0,0 +1,71 @@
+// oeis sequence — full detail for a single OEIS sequence (A-number).
+//
+// OEIS' search endpoint, when given `q=id:Annnnnn`, returns one full record
+// with all sub-fields populated. We surface formula / xref / reference counts
+// instead of dumping the full graph.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { OEIS_BASE, formatId, oeisFetch, previewTerms, requireSequenceId } from './utils.js';
+
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+
+cli({
+    site: 'oeis',
+    name: 'sequence',
+    access: 'read',
+    description: 'Full OEIS sequence detail by A-number (terms, name, keywords, formula counts)',
+    domain: 'oeis.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'OEIS sequence id (e.g. "A000045" for Fibonacci)' },
+    ],
+    columns: [
+        'id',
+        'name',
+        'keywords',
+        'preview',
+        'termCount',
+        'offset',
+        'author',
+        'created',
+        'revision',
+        'commentCount',
+        'formulaCount',
+        'referenceCount',
+        'xrefCount',
+        'linkCount',
+        'url',
+    ],
+    func: async (args) => {
+        const id = requireSequenceId(args.id);
+        const url = `${OEIS_BASE}/search?q=id:${encodeURIComponent(id)}&fmt=json`;
+        const body = await oeisFetch(url, 'oeis sequence');
+        const list = Array.isArray(body) ? body : [];
+        if (!list.length) {
+            throw new EmptyResultError('oeis sequence', `OEIS sequence "${id}" not found.`);
+        }
+        const r = list[0];
+        const data = typeof r?.data === 'string' ? r.data : '';
+        const termCount = data ? data.split(',').filter(Boolean).length : 0;
+        return [{
+            id: formatId(r?.number) ?? id,
+            name: typeof r?.name === 'string' ? r.name : null,
+            keywords: typeof r?.keyword === 'string' ? r.keyword : null,
+            preview: previewTerms(data),
+            termCount,
+            offset: typeof r?.offset === 'string' ? r.offset : null,
+            author: typeof r?.author === 'string' ? r.author : null,
+            created: typeof r?.created === 'string' ? r.created : null,
+            revision: typeof r?.revision === 'number' ? r.revision : null,
+            commentCount: asArray(r?.comment).length,
+            formulaCount: asArray(r?.formula).length,
+            referenceCount: asArray(r?.reference).length,
+            xrefCount: asArray(r?.xref).length,
+            linkCount: asArray(r?.link).length,
+            url: `${OEIS_BASE}/${formatId(r?.number) ?? id}`,
+        }];
+    },
+});