@jackwener/opencli 1.7.11 → 1.7.13

package/clis/defillama/protocols.js

@@ -0,0 +1,55 @@
+// defillama protocols — top DeFi protocols by current TVL.
+//
+// Hits `https://api.llama.fi/protocols`, sorts by TVL (desc), and returns the
+// requested top-N. The API ships ~7400 entries today; we cap output at 500
+// rows so agents do not paginate their entire DeFi universe by accident.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { LLAMA_BASE, llamaFetch, requireBoundedInt, unixToDate } from './utils.js';
+
+cli({
+    site: 'defillama',
+    name: 'protocols',
+    access: 'read',
+    description: 'Top DeFi protocols on DefiLlama by current TVL (slug, name, category, TVL, mcap, change_1d/7d, chains)',
+    domain: 'defillama.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 30, help: 'Number of rows to return (1-500)' },
+    ],
+    columns: [
+        'rank', 'slug', 'name', 'category', 'tvl', 'mcap',
+        'change_1d', 'change_7d', 'chains', 'listedAt', 'url',
+    ],
+    func: async (args) => {
+        const limit = requireBoundedInt(args.limit, 30, 500, 'limit');
+        const list = await llamaFetch(`${LLAMA_BASE}/protocols`, 'defillama protocols');
+        if (!Array.isArray(list) || list.length === 0) {
+            throw new EmptyResultError('defillama protocols', 'DefiLlama returned no protocol entries.');
+        }
+        const ranked = list
+            .filter((p) => p && (p.slug || p.name) && Number.isFinite(Number(p.tvl)))
+            .sort((a, b) => Number(b.tvl) - Number(a.tvl))
+            .slice(0, limit);
+        if (ranked.length === 0) {
+            throw new EmptyResultError('defillama protocols', 'DefiLlama returned no protocols with numeric TVL.');
+        }
+        return ranked.map((p, i) => {
+            const slug = String(p.slug ?? '').trim();
+            return {
+                rank: i + 1,
+                slug,
+                name: String(p.name ?? '').trim(),
+                category: String(p.category ?? '').trim(),
+                tvl: Number(p.tvl),
+                mcap: p.mcap == null ? null : Number(p.mcap),
+                change_1d: p.change_1d == null ? null : Number(p.change_1d),
+                change_7d: p.change_7d == null ? null : Number(p.change_7d),
+                chains: Array.isArray(p.chains) ? p.chains.join(', ') : '',
+                listedAt: unixToDate(p.listedAt),
+                url: slug ? `https://defillama.com/protocol/${slug}` : '',
+            };
+        });
+    },
+});

package/clis/defillama/utils.js

@@ -0,0 +1,99 @@
+// Shared helpers for the DefiLlama adapters.
+//
+// DefiLlama serves a public REST API (no auth) over https://api.llama.fi.
+// Docs: https://defillama.com/docs/api
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const LLAMA_BASE = 'https://api.llama.fi';
+const UA = 'opencli-defillama-adapter (+https://github.com/jackwener/opencli)';
+
+// DefiLlama slugs are lowercase with hyphens / digits / dots; allow up to 100 chars.
+const SLUG = /^[a-z0-9][a-z0-9._-]{0,99}$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`defillama ${label} cannot be empty`);
+    return s;
+}
+
+export function requireSlug(value, label = 'slug') {
+    const s = String(value ?? '').trim();
+    if (!s) {
+        throw new ArgumentError(
+            `defillama ${label} is required (e.g. "aave", "lido")`,
+            'Use the protocol slug as it appears on https://defillama.com/protocol/<slug>.',
+        );
+    }
+    if (!SLUG.test(s)) {
+        throw new ArgumentError(
+            `defillama ${label} "${value}" is not a valid DefiLlama slug`,
+            'Slugs are lowercase ASCII (letters / digits / "._-"), e.g. "aave", "lido", "pancakeswap-amm".',
+        );
+    }
+    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(`defillama ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`defillama ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function llamaFetch(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.llama.fi is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `DefiLlama returned 404 for ${url}.`);
+    }
+    if (resp.status === 400) {
+        // DefiLlama returns 400 + plain-text "Protocol not found" for unknown slugs.
+        const body = await resp.text().catch(() => '');
+        if (/not\s*found/i.test(body)) {
+            throw new EmptyResultError(label, `DefiLlama: ${body.trim() || 'not found'}.`);
+        }
+        throw new CommandExecutionError(`${label} returned HTTP 400: ${body.slice(0, 200)}`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'DefiLlama throttles unauthenticated traffic; wait a few seconds and retry.',
+        );
+    }
+    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;
+}
+
+// Convert a unix-seconds timestamp (DefiLlama's listedAt convention) to YYYY-MM-DD,
+// or null when the value is missing / not a finite number.
+export function unixToDate(value) {
+    if (value == null) return null;
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n) || n <= 0) return null;
+    const ms = n > 1e12 ? n : n * 1000;
+    const d = new Date(ms);
+    if (Number.isNaN(d.getTime())) return null;
+    return d.toISOString().slice(0, 10);
+}

package/clis/devto/devto.test.js

@@ -0,0 +1,236 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './top.js';
+import './tag.js';
+import './user.js';
+import './read.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('devto listing adapters surface id + reading_time + published_at', () => {
+    it('devto/top has the agent-native column shape and pipeline mapping', () => {
+        const cmd = getRegistry().get('devto/top');
+        expect(cmd?.columns).toEqual([
+            'rank', 'id', 'title', 'author', 'reactions', 'comments',
+            'reading_time', 'published_at', 'tags', 'url',
+        ]);
+        const mapStep = cmd?.pipeline?.find((step) => step.map);
+        expect(mapStep?.map).toMatchObject({
+            id: '${{ item.id }}',
+            reading_time: '${{ item.reading_time_minutes }}',
+            published_at: '${{ item.published_at }}',
+            url: '${{ item.url }}',
+        });
+    });
+
+    it('devto/tag has the agent-native column shape and pipeline mapping', () => {
+        const cmd = getRegistry().get('devto/tag');
+        expect(cmd?.columns).toEqual([
+            'rank', 'id', 'title', 'author', 'reactions', 'comments',
+            'reading_time', 'published_at', 'tags', 'url',
+        ]);
+        const mapStep = cmd?.pipeline?.find((step) => step.map);
+        expect(mapStep?.map).toMatchObject({
+            id: '${{ item.id }}',
+            reading_time: '${{ item.reading_time_minutes }}',
+            published_at: '${{ item.published_at }}',
+        });
+    });
+
+    it('devto/user has the agent-native column shape (no author column, since user-specific)', () => {
+        const cmd = getRegistry().get('devto/user');
+        expect(cmd?.columns).toEqual([
+            'rank', 'id', 'title', 'reactions', 'comments',
+            'reading_time', 'published_at', 'tags', 'url',
+        ]);
+        const mapStep = cmd?.pipeline?.find((step) => step.map);
+        expect(mapStep?.map).toMatchObject({
+            id: '${{ item.id }}',
+            reading_time: '${{ item.reading_time_minutes }}',
+            published_at: '${{ item.published_at }}',
+        });
+    });
+});
+
+describe('devto/read adapter', () => {
+    const cmd = getRegistry().get('devto/read');
+
+    it('registers the article-detail row shape', () => {
+        expect(cmd?.columns).toEqual([
+            'id', 'title', 'author', 'reactions', 'reading_time',
+            'tags', 'published_at', 'body', 'url',
+        ]);
+    });
+
+    it('takes a positional id plus a tunable max-length', () => {
+        const argNames = (cmd?.args || []).map((a) => a.name);
+        expect(argNames).toEqual(['id', 'max-length']);
+        const idArg = cmd?.args?.find((a) => a.name === 'id');
+        expect(idArg?.required).toBe(true);
+        expect(idArg?.positional).toBe(true);
+    });
+
+    it('uses the public dev.to JSON endpoint (no browser, public strategy)', () => {
+        expect(cmd?.browser).toBe(false);
+        expect(cmd?.strategy).toBe('public');
+    });
+
+    it('fails fast with ArgumentError for non-numeric id before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: 'not-a-number', 'max-length': 20000 }))
+            .rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('fails fast with ArgumentError for max-length below 100 before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: '12345', 'max-length': 50 }))
+            .rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('accepts numeric max-length strings on the direct func path', async () => {
+        const article = {
+            id: 1,
+            title: 't',
+            user: { username: 'u' },
+            public_reactions_count: 0,
+            reading_time_minutes: 1,
+            tag_list: [],
+            published_at: '',
+            body_markdown: 'x'.repeat(150),
+            url: 'https://dev.to/u/t-1',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(article), { status: 200 })));
+
+        const rows = await cmd.func({ id: '1', 'max-length': '100' });
+        expect(rows[0].body).toBe('x'.repeat(100) + '\n\n... [truncated]');
+    });
+
+    it('fails fast with ArgumentError for invalid max-length strings before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: '12345', 'max-length': 'abc' }))
+            .rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('fails fast with EmptyResultError on 404', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('Not found', { status: 404 })));
+
+        await expect(cmd.func({ id: '99999999', 'max-length': 20000 }))
+            .rejects.toThrow(EmptyResultError);
+    });
+
+    it('fails fast with CommandExecutionError on non-404 HTTP failures', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('Server error', { status: 500 })));
+
+        await expect(cmd.func({ id: '12345', 'max-length': 20000 }))
+            .rejects.toThrow(CommandExecutionError);
+    });
+
+    it('fails fast with CommandExecutionError on invalid JSON responses', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not json', { status: 200 })));
+
+        await expect(cmd.func({ id: '12345', 'max-length': 20000 }))
+            .rejects.toThrow(CommandExecutionError);
+    });
+
+    it('fails fast when the full article body is missing instead of returning a summary', async () => {
+        const article = {
+            id: 1,
+            title: 't',
+            user: { username: 'u' },
+            public_reactions_count: 0,
+            reading_time_minutes: 1,
+            tag_list: [],
+            published_at: '',
+            description: 'summary only',
+            url: 'https://dev.to/u/t-1',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(article), { status: 200 })));
+
+        await expect(cmd.func({ id: '1', 'max-length': 20000 }))
+            .rejects.toThrow(CommandExecutionError);
+    });
+
+    it('returns a single article row with body_markdown extracted', async () => {
+        // Real /api/articles/<id> returns tag_list as a comma string and tags as an array.
+        const article = {
+            id: 3605688,
+            title: 'How to do thing X in Rust',
+            user: { username: 'jdoe' },
+            public_reactions_count: 42,
+            reading_time_minutes: 7,
+            tag_list: 'rust, webdev',
+            tags: ['rust', 'webdev'],
+            published_at: '2026-05-01T00:00:00Z',
+            body_markdown: '# Hello\n\nThis is the article body.',
+            url: 'https://dev.to/jdoe/how-to-do-thing-x-in-rust-1234',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(article), { status: 200 })));
+
+        const rows = await cmd.func({ id: '3605688', 'max-length': 20000 });
+
+        expect(rows).toEqual([
+            {
+                id: 3605688,
+                title: 'How to do thing X in Rust',
+                author: 'jdoe',
+                reactions: 42,
+                reading_time: 7,
+                tags: 'rust, webdev',
+                published_at: '2026-05-01T00:00:00Z',
+                body: '# Hello\n\nThis is the article body.',
+                url: 'https://dev.to/jdoe/how-to-do-thing-x-in-rust-1234',
+            },
+        ]);
+    });
+
+    it('handles the alternate shape where tag_list is an array (defensive)', async () => {
+        const article = {
+            id: 1,
+            title: 't',
+            user: { username: 'u' },
+            public_reactions_count: 0,
+            reading_time_minutes: 1,
+            tag_list: ['javascript', 'webdev'],
+            published_at: '',
+            body_markdown: 'body',
+            url: 'https://dev.to/u/t-1',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(article), { status: 200 })));
+
+        const rows = await cmd.func({ id: '1', 'max-length': 20000 });
+        expect(rows[0].tags).toBe('javascript, webdev');
+    });
+
+    it('truncates body when over max-length and appends a marker', async () => {
+        const longBody = 'x'.repeat(500);
+        const article = {
+            id: 1,
+            title: 't',
+            user: { username: 'u' },
+            public_reactions_count: 0,
+            reading_time_minutes: 1,
+            tag_list: [],
+            published_at: '',
+            body_markdown: longBody,
+            url: 'https://dev.to/u/t-1',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(article), { status: 200 })));
+
+        const rows = await cmd.func({ id: '1', 'max-length': 100 });
+
+        expect(rows[0].body).toBe('x'.repeat(100) + '\n\n... [truncated]');
+    });
+});

package/clis/devto/latest.js

@@ -0,0 +1,74 @@
+// devto latest — newest dev.to articles, regardless of tag.
+//
+// Hits the public `/api/articles/latest` endpoint. Complements the existing
+// `devto top` (most-reactioned) and `devto tag` (filtered) commands by
+// surfacing the firehose of brand-new posts.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+function requireBoundedInt(value, defaultValue, maxValue) {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError('devto limit must be a positive integer');
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`devto limit must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+cli({
+    site: 'devto',
+    name: 'latest',
+    access: 'read',
+    description: 'Newest dev.to articles (firehose, all tags)',
+    domain: 'dev.to',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Articles per page (1-100)' },
+        { name: 'page', type: 'int', default: 1, help: 'Page number (1-based)' },
+    ],
+    columns: ['rank', 'id', 'title', 'author', 'tags', 'reactions', 'comments', 'published', 'url'],
+    func: async (args) => {
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const page = requireBoundedInt(args.page, 1, 1000);
+        const url = `https://dev.to/api/articles/latest?per_page=${limit}&page=${page}`;
+        let resp;
+        try {
+            resp = await fetch(url, { headers: { accept: 'application/json' } });
+        }
+        catch (err) {
+            throw new CommandExecutionError(
+                `devto latest request failed: ${err?.message ?? err}`,
+                'Check that dev.to is reachable from this network.',
+            );
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`devto latest returned HTTP ${resp.status}`);
+        }
+        let body;
+        try {
+            body = await resp.json();
+        }
+        catch (err) {
+            throw new CommandExecutionError(`devto latest returned malformed JSON: ${err?.message ?? err}`);
+        }
+        const list = Array.isArray(body) ? body : [];
+        if (!list.length) {
+            throw new EmptyResultError('devto latest', `dev.to /articles/latest returned no items at page ${page}.`);
+        }
+        return list.map((item, i) => ({
+            rank: (page - 1) * limit + i + 1,
+            id: item.id != null ? String(item.id) : '',
+            title: String(item.title ?? ''),
+            author: String(item?.user?.username ?? ''),
+            tags: String(item.tag_list ?? '').replace(/,\s*/g, ', '),
+            reactions: item.public_reactions_count != null ? Number(item.public_reactions_count) : null,
+            comments: item.comments_count != null ? Number(item.comments_count) : null,
+            published: String(item.published_at ?? '').slice(0, 10),
+            url: String(item.url ?? ''),
+        }));
+    },
+});

package/clis/devto/read.js

@@ -0,0 +1,103 @@
+/**
+ * DEV.to article reader.
+ *
+ * Public API: https://dev.to/api/articles/<id>
+ * Returns the full article including `body_markdown` (and `body_html`).
+ *
+ * The DEV.to API does not currently expose article comments — this reader
+ * therefore emits one row with the article body. If/when comments become
+ * available we can extend to a POST + L0/L1 shape like `hackernews read`.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const DEVTO_ARTICLE_BASE = 'https://dev.to/api/articles';
+
+async function fetchArticle(id) {
+    let res;
+    try {
+        res = await fetch(`${DEVTO_ARTICLE_BASE}/${id}`);
+    } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new CommandExecutionError(`DEV.to API request failed for article ${id}`, detail);
+    }
+    if (res.status === 404) {
+        throw new EmptyResultError(`devto/${id}`, 'Article not found');
+    }
+    if (!res.ok) {
+        throw new CommandExecutionError(`DEV.to API HTTP ${res.status} for article ${id}`, 'Check the article id');
+    }
+    try {
+        return await res.json();
+    } catch {
+        throw new CommandExecutionError(`DEV.to API returned invalid JSON for article ${id}`, 'Retry later or open the article URL directly');
+    }
+}
+
+function requireMinInt(value, min, label) {
+    const number = typeof value === 'number' ? value : Number(value);
+    if (!Number.isInteger(number) || number < min) {
+        throw new ArgumentError(`${label} must be an integer >= ${min}`);
+    }
+    return number;
+}
+
+function requireArticleBody(article, id) {
+    if (typeof article.body_markdown === 'string' && article.body_markdown.trim()) {
+        return article.body_markdown;
+    }
+    throw new CommandExecutionError(
+        `DEV.to article ${id} did not include body_markdown`,
+        'DEV.to API response shape may have changed. Open the article URL directly or retry later.',
+    );
+}
+
+cli({
+    site: 'devto',
+    name: 'read',
+    access: 'read',
+    description: 'Read a DEV.to article body by id',
+    domain: 'dev.to',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'DEV.to article id (numeric, e.g. 3605688)' },
+        { name: 'max-length', type: 'int', default: 20000, help: 'Max characters of body to return (min 100)' },
+    ],
+    columns: ['id', 'title', 'author', 'reactions', 'reading_time', 'tags', 'published_at', 'body', 'url'],
+    func: async (args) => {
+        const id = String(args.id || '').trim();
+        if (!/^\d+$/.test(id)) {
+            throw new ArgumentError(`Invalid DEV.to article id: ${args.id}`, 'Pass a numeric id like 3605688');
+        }
+        const maxLength = requireMinInt(args['max-length'] ?? 20000, 100, 'devto read --max-length');
+
+        const article = await fetchArticle(id);
+        if (!article || !article.id) {
+            throw new EmptyResultError(`devto/${id}`, 'Article not found');
+        }
+
+        const body = requireArticleBody(article, id);
+        const truncated = body.length > maxLength
+            ? body.slice(0, maxLength) + '\n\n... [truncated]'
+            : body;
+
+        // The single-article endpoint returns `tag_list` as a comma-separated
+        // string and `tags` as an array — the opposite of the listing endpoints.
+        // Normalize either shape into a single comma-separated string.
+        const tagsRaw = article.tag_list ?? article.tags ?? '';
+        const tags = Array.isArray(tagsRaw) ? tagsRaw.join(', ') : String(tagsRaw);
+
+        return [{
+            id: article.id,
+            title: article.title || '',
+            author: article.user?.username || '[deleted]',
+            reactions: article.public_reactions_count ?? 0,
+            reading_time: article.reading_time_minutes ?? 0,
+            tags,
+            published_at: article.published_at || '',
+            body: truncated,
+            url: article.url || '',
+        }];
+    },
+});

package/clis/devto/tag.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'devto',
     name: 'tag',
+    access: 'read',
     description: 'Latest DEV.to articles for a specific tag',
     domain: 'dev.to',
     strategy: Strategy.PUBLIC,
@@ -15,15 +16,18 @@ cli({
         },
         { name: 'limit', type: 'int', default: 20, help: 'Number of articles' },
     ],
-    columns: ['rank', 'title', 'author', 'reactions', 'comments', 'tags'],
+    columns: ['rank', 'id', 'title', 'author', 'reactions', 'comments', 'reading_time', 'published_at', 'tags', 'url'],
     pipeline: [
         { fetch: { url: 'https://dev.to/api/articles?tag=${{ args.tag }}&per_page=${{ args.limit }}' } },
         { map: {
                 rank: '${{ index + 1 }}',
+                id: '${{ item.id }}',
                 title: '${{ item.title }}',
                 author: '${{ item.user.username }}',
                 reactions: '${{ item.public_reactions_count }}',
                 comments: '${{ item.comments_count }}',
+                reading_time: '${{ item.reading_time_minutes }}',
+                published_at: '${{ item.published_at }}',
                 tags: `\${{ item.tag_list | join(', ') }}`,
                 url: '${{ item.url }}',
             } },

package/clis/devto/top.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'devto',
     name: 'top',
+    access: 'read',
     description: 'Top DEV.to articles of the day',
     domain: 'dev.to',
     strategy: Strategy.PUBLIC,
@@ -9,15 +10,18 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Number of articles' },
     ],
-    columns: ['rank', 'title', 'author', 'reactions', 'comments', 'tags'],
+    columns: ['rank', 'id', 'title', 'author', 'reactions', 'comments', 'reading_time', 'published_at', 'tags', 'url'],
     pipeline: [
         { fetch: { url: 'https://dev.to/api/articles?top=1&per_page=${{ args.limit }}' } },
         { map: {
                 rank: '${{ index + 1 }}',
+                id: '${{ item.id }}',
                 title: '${{ item.title }}',
                 author: '${{ item.user.username }}',
                 reactions: '${{ item.public_reactions_count }}',
                 comments: '${{ item.comments_count }}',
+                reading_time: '${{ item.reading_time_minutes }}',
+                published_at: '${{ item.published_at }}',
                 tags: `\${{ item.tag_list | join(', ') }}`,
                 url: '${{ item.url }}',
             } },

package/clis/devto/user.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'devto',
     name: 'user',
+    access: 'read',
     description: 'Recent DEV.to articles from a specific user',
     domain: 'dev.to',
     strategy: Strategy.PUBLIC,
@@ -15,14 +16,17 @@ cli({
         },
         { name: 'limit', type: 'int', default: 20, help: 'Number of articles' },
     ],
-    columns: ['rank', 'title', 'reactions', 'comments', 'tags'],
+    columns: ['rank', 'id', 'title', 'reactions', 'comments', 'reading_time', 'published_at', 'tags', 'url'],
     pipeline: [
         { fetch: { url: 'https://dev.to/api/articles?username=${{ args.username }}&per_page=${{ args.limit }}' } },
         { map: {
                 rank: '${{ index + 1 }}',
+                id: '${{ item.id }}',
                 title: '${{ item.title }}',
                 reactions: '${{ item.public_reactions_count }}',
                 comments: '${{ item.comments_count }}',
+                reading_time: '${{ item.reading_time_minutes }}',
+                published_at: '${{ item.published_at }}',
                 tags: `\${{ item.tag_list | join(', ') }}`,
                 url: '${{ item.url }}',
             } },