@jackwener/opencli 1.4.1 → 1.5.0

package/src/clis/linux-do/categories.yaml

@@ -2,9 +2,14 @@ site: linux-do
 name: categories
 description: linux.do 分类列表
 domain: linux.do
+strategy: cookie
 browser: true
 
 args:
+  subcategories:
+    type: boolean
+    default: false
+    description: Include subcategories
   limit:
     type: int
     default: 20
@@ -20,13 +25,39 @@ pipeline:
         let data;
         try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
         const cats = data?.category_list?.categories || [];
-        return cats.slice(0, ${{ args.limit }}).map(c => ({
-          name: c.name,
-          slug: c.slug,
-          id: c.id,
-          topics: c.topic_count,
-          description: (c.description_text || '').slice(0, 80),
-        }));
+        const showSub = ${{ args.subcategories }};
+        const results = [];
+        const limit = ${{ args.limit }};
+        for (const c of cats.slice(0, ${{ args.limit }})) {
+          results.push({
+            name: c.name,
+            slug: c.slug,
+            id: c.id,
+            topics: c.topic_count,
+            description: (c.description_text || '').slice(0, 80),
+          });
+          if (results.length >= limit) break;
+          if (showSub && c.subcategory_ids && c.subcategory_ids.length > 0) {
+            const subRes = await fetch('/categories.json?parent_category_id=' + c.id, { credentials: 'include' });
+            if (subRes.ok) {
+              let subData;
+              try { subData = await subRes.json(); } catch { continue; }
+              const subCats = subData?.category_list?.categories || [];
+              for (const sc of subCats) {
+                results.push({
+                  name: c.name + ' / ' + sc.name,
+                  slug: sc.slug,
+                  id: sc.id,
+                  topics: sc.topic_count,
+                  description: (sc.description_text || '').slice(0, 80),
+                });
+                if (results.length >= limit) break;
+              }
+            }
+          }
+          if (results.length >= limit) break;
+        }
+        return results;
       })()
 
   - map:
@@ -36,6 +67,4 @@ pipeline:
       topics: ${{ item.topics }}
       description: ${{ item.description }}
 
-  - limit: ${{ args.limit }}
-
 columns: [name, slug, id, topics, description]

package/src/clis/linux-do/category.ts

@@ -0,0 +1,37 @@
+import { cli, Strategy } from '../../registry.js';
+import { buildLinuxDoCompatFooter, executeLinuxDoFeed } from './feed.js';
+
+cli({
+  site: 'linux-do',
+  name: 'category',
+  description: 'linux.do 分类内话题',
+  domain: 'linux.do',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  columns: ['title', 'replies', 'created', 'likes', 'views', 'url'],
+  deprecated: 'opencli linux-do category is kept for backward compatibility.',
+  replacedBy: 'opencli linux-do feed --category <id-or-name>',
+  args: [
+    {
+      name: 'slug',
+      positional: true,
+      type: 'str',
+      required: true,
+      help: 'Category slug (legacy compatibility argument)',
+    },
+    {
+      name: 'id',
+      positional: true,
+      type: 'int',
+      required: true,
+      help: 'Category ID',
+    },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of items (per_page)' },
+  ],
+  func: async (page, kwargs) => executeLinuxDoFeed(page, {
+    limit: kwargs.limit,
+    category: String(kwargs.id),
+    view: 'latest',
+  }),
+  footerExtra: (kwargs) => buildLinuxDoCompatFooter(`opencli linux-do feed --category ${kwargs.id ?? '<id>'}`),
+});

package/src/clis/linux-do/feed.test.ts

@@ -0,0 +1,132 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { __test__ } from './feed.js';
+
+describe('linux-do feed metadata resolution', () => {
+  afterEach(() => {
+    __test__.resetMetadataCaches();
+  });
+
+  it('prefers live tag metadata over the bundled snapshot', async () => {
+    __test__.setLiveMetadataForTests({
+      tags: [{ id: 9999, slug: 'fresh-tag', name: 'Fresh Tag' }],
+    });
+
+    const request = await __test__.resolveFeedRequest(null, {
+      tag: 'Fresh Tag',
+      view: 'latest',
+      limit: 20,
+    });
+
+    expect(request.url).toBe('/tag/fresh-tag/9999.json?per_page=20');
+  });
+
+  it('uses live category metadata with parent paths for subcategories', async () => {
+    __test__.setLiveMetadataForTests({
+      categories: [
+        {
+          id: 10,
+          name: 'Parent',
+          description: '',
+          slug: 'parent',
+          parentCategoryId: null,
+          parent: null,
+        },
+        {
+          id: 11,
+          name: 'Fresh Child',
+          description: '',
+          slug: 'fresh-child',
+          parentCategoryId: 10,
+          parent: {
+            id: 10,
+            name: 'Parent',
+            description: '',
+            slug: 'parent',
+            parentCategoryId: null,
+          },
+        },
+      ],
+    });
+
+    const request = await __test__.resolveFeedRequest(null, {
+      category: 'Fresh Child',
+      view: 'hot',
+      limit: 20,
+    });
+
+    expect(request.url).toBe('/c/parent/fresh-child/11/l/hot.json?per_page=20');
+  });
+
+  it('accepts parent/name category paths for subcategories', async () => {
+    __test__.setLiveMetadataForTests({
+      categories: [
+        {
+          id: 10,
+          name: 'Parent',
+          description: '',
+          slug: 'parent',
+          parentCategoryId: null,
+          parent: null,
+        },
+        {
+          id: 11,
+          name: 'Fresh Child',
+          description: '',
+          slug: 'fresh-child',
+          parentCategoryId: 10,
+          parent: {
+            id: 10,
+            name: 'Parent',
+            description: '',
+            slug: 'parent',
+            parentCategoryId: null,
+          },
+        },
+      ],
+    });
+
+    const request = await __test__.resolveFeedRequest(null, {
+      category: 'Parent / Fresh Child',
+      view: 'latest',
+      limit: 20,
+    });
+
+    expect(request.url).toBe('/c/parent/fresh-child/11.json?per_page=20');
+  });
+
+  it('falls back to cached metadata when live metadata is unavailable', async () => {
+    const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-linux-do-cache-'));
+    __test__.setCacheDirForTests(cacheDir);
+
+    fs.writeFileSync(path.join(cacheDir, 'tags.json'), JSON.stringify({
+      fetchedAt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
+      data: [{ id: 3, slug: 'chatgpt', name: 'ChatGPT' }],
+    }));
+    fs.writeFileSync(path.join(cacheDir, 'categories.json'), JSON.stringify({
+      fetchedAt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
+      data: [{
+        id: 4,
+        name: '开发调优',
+        description: '',
+        slug: 'develop',
+        parentCategoryId: null,
+        parent: null,
+      }],
+    }));
+
+    const request = await __test__.resolveFeedRequest(null, {
+      tag: 'ChatGPT',
+      category: '开发调优',
+      view: 'top',
+      period: 'monthly',
+      limit: 20,
+    });
+
+    expect(request.url).toContain('/tags/c/develop/4/chatgpt/3/l/top.json');
+    expect(request.url).toContain('per_page=20');
+    expect(request.url).toContain('period=monthly');
+  });
+});