newsnow 1.0.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025-present ChenCheng (sorrycc@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,5 +1,10 @@
 # newsnow
 
+[![npm version](https://img.shields.io/npm/v/newsnow.svg)](https://www.npmjs.com/package/newsnow)
+[![npm downloads](https://img.shields.io/npm/dm/newsnow.svg)](https://www.npmjs.com/package/newsnow)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![clawhub](https://img.shields.io/badge/clawhub-view-blue)](https://clawhub.ai/sorrycc/newsnow)
+
 A command-line tool to fetch trending news and hot topics from 66 sources across 44 platforms. Built with TypeScript, runs on Bun.
 
 Ported from [ourongxing/newsnow](https://github.com/ourongxing/newsnow) server sources.
@@ -7,26 +12,32 @@ Ported from [ourongxing/newsnow](https://github.com/ourongxing/newsnow) server s
 ## Install
 
 ```bash
-bun install
+npm install -g newsnow
+```
+
+Or use directly with npx:
+
+```bash
+npx newsnow
 ```
 
 ## Usage
 
 ```bash
 # Show help
-bun src/cli.ts --help
+newsnow --help
 
 # List all available sources
-bun src/cli.ts list
+newsnow list
 
 # Fetch news from a source
-bun src/cli.ts hackernews
+newsnow hackernews
 
 # Output as JSON (pipeable to jq, etc.)
-bun src/cli.ts hackernews --json
+newsnow hackernews --json
 
 # List sources as JSON
-bun src/cli.ts list --json
+newsnow list --json
 ```
 
 ## Sources
@@ -94,30 +105,6 @@ Some sources may be blocked by Cloudflare or require authentication:
 bun test
 ```
 
-## Project Structure
-
-```
-src/
-  cli.ts              # CLI entry point (raw process.argv)
-  types.ts            # NewsItem type definitions
-  fetch.ts            # HTTP client (ofetch wrapper)
-  crypto.ts           # md5, SHA-1, base64 helpers
-  utils.ts            # Date parsing utilities
-  rss.ts              # RSS feed parser
-  sources/
-    index.ts          # Source registry (all sources merged)
-    baidu.ts          # One file per platform
-    bilibili.ts
-    cls/              # Multi-file sources
-      index.ts
-      utils.ts
-    coolapk/
-      index.ts
-    ...
-test/
-  cli.test.ts
-```
-
 ## Dependencies
 
 - [cheerio](https://github.com/cheeriojs/cheerio) - HTML parsing
@@ -127,4 +114,4 @@ test/
 
 ## License
 
-ISC
+MIT

package/dist/src/cli.js

@@ -1,35 +1,98 @@
 #!/usr/bin/env bun
 import { sources } from "./sources/index.js";
-const args = process.argv.slice(2);
-const jsonFlag = args.includes("--json");
-const filteredArgs = args.filter(a => a !== "--json");
-const command = filteredArgs[0];
+import { NEWS_ITEM_FIELDS } from "./types.js";
+function parseArgs(argv) {
+    const raw = argv.slice(2);
+    let json = false;
+    let pretty = false;
+    const fields = [];
+    let limit;
+    let command;
+    for (let i = 0; i < raw.length; i++) {
+        const arg = raw[i];
+        if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--output" && raw[i + 1] === "json") {
+            json = true;
+            i++;
+        }
+        else if (arg === "--pretty") {
+            pretty = true;
+        }
+        else if (arg === "--fields" && raw[i + 1]) {
+            fields.push(...raw[++i].split(",").map(f => f.trim()).filter(Boolean));
+        }
+        else if (arg === "--limit" && raw[i + 1]) {
+            limit = parseInt(raw[++i], 10);
+        }
+        else if (!arg.startsWith("-") && command === undefined) {
+            command = arg;
+        }
+    }
+    return { command, json, pretty, fields, limit };
+}
+const opts = parseArgs(process.argv);
+function jsonOut(data) {
+    console.log(opts.pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data));
+}
+function emitError(msg, code, exitCode, suggestions) {
+    if (opts.json) {
+        const envelope = { error: msg, code };
+        if (suggestions?.length)
+            envelope.suggestions = suggestions;
+        process.stderr.write(JSON.stringify(envelope) + "\n");
+    }
+    else {
+        console.error(`Error: ${msg}`);
+        if (suggestions?.length) {
+            console.error(`Did you mean: ${suggestions.join(", ")}?`);
+        }
+    }
+    process.exit(exitCode);
+}
 function printHelp() {
-    console.log(`Usage: newsnow <source> [--json]
-       newsnow list [--json]
+    console.log(`Usage: newsnow <source> [options]
+       newsnow list [--json | --output json] [--pretty]
+       newsnow schema [--pretty]
 
 Commands:
   list          List all available sources
+  schema        Print machine-readable JSON Schema for this CLI
   <source>      Fetch news from the given source
 
 Options:
-  --json        Output as JSON
+  --json            Output as JSON
+  --output json     Alias for --json
+  --pretty          Pretty-print JSON output
+  --fields f1,f2    Filter output fields (JSON mode only)
+  --limit N         Limit number of items returned
 
 Sources: ${Object.keys(sources).length} available. Run "newsnow list" to see all.`);
 }
+function buildSourceMeta() {
+    const envVarMap = {
+        producthunt: ["PRODUCTHUNT_API_TOKEN"],
+    };
+    return Object.keys(sources).sort().map(name => ({
+        name,
+        category: name.split("-")[0],
+        envVars: envVarMap[name] || [],
+    }));
+}
 function printList() {
-    const names = Object.keys(sources).sort();
-    if (jsonFlag) {
-        console.log(JSON.stringify(names, null, 2));
+    const metas = buildSourceMeta();
+    if (opts.json) {
+        const envelope = { count: metas.length, sources: metas };
+        jsonOut(envelope);
     }
     else {
-        console.log(`Available sources (${names.length}):\n`);
+        console.log(`Available sources (${metas.length}):\n`);
         const groups = {};
-        for (const name of names) {
-            const base = name.split("-")[0];
-            if (!groups[base])
-                groups[base] = [];
-            groups[base].push(name);
+        for (const m of metas) {
+            if (!groups[m.category])
+                groups[m.category] = [];
+            groups[m.category].push(m.name);
         }
         for (const [base, items] of Object.entries(groups).sort(([a], [b]) => a.localeCompare(b))) {
             if (items.length === 1) {
@@ -41,6 +104,74 @@ function printList() {
         }
     }
 }
+function printSchema() {
+    const metas = buildSourceMeta();
+    const categories = {};
+    for (const m of metas) {
+        if (!categories[m.category])
+            categories[m.category] = [];
+        categories[m.category].push(m.name);
+    }
+    const schema = {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        name: "newsnow",
+        commands: {
+            list: { description: "List all available news sources" },
+            schema: { description: "Print this JSON Schema" },
+            "<source>": { description: "Fetch news items from the named source" },
+        },
+        flags: {
+            "--json": { description: "Output as JSON" },
+            "--output": { description: "Output format", values: ["json"] },
+            "--pretty": { description: "Pretty-print JSON output" },
+            "--fields": { description: "Comma-separated list of fields to include", values: [...NEWS_ITEM_FIELDS] },
+            "--limit": { description: "Maximum number of items to return", type: "integer" },
+        },
+        categories,
+        $defs: {
+            NewsItem: {
+                type: "object",
+                properties: {
+                    id: { type: ["string", "number"] },
+                    title: { type: "string" },
+                    url: { type: "string" },
+                    mobileUrl: { type: "string" },
+                    pubDate: { type: ["string", "number"] },
+                    extra: { type: "object" },
+                },
+                required: ["id", "title"],
+            },
+            FetchEnvelope: {
+                type: "object",
+                properties: {
+                    source: { type: "string" },
+                    count: { type: "integer" },
+                    items: { type: "array", items: { $ref: "#/$defs/NewsItem" } },
+                },
+                required: ["source", "count", "items"],
+            },
+            ListEnvelope: {
+                type: "object",
+                properties: {
+                    count: { type: "integer" },
+                    sources: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                name: { type: "string" },
+                                category: { type: "string" },
+                                envVars: { type: "array", items: { type: "string" } },
+                            },
+                        },
+                    },
+                },
+                required: ["count", "sources"],
+            },
+        },
+    };
+    console.log(opts.pretty ? JSON.stringify(schema, null, 2) : JSON.stringify(schema));
+}
 function suggestSimilar(input) {
     const names = Object.keys(sources);
     return names.filter(n => n.includes(input) || input.includes(n) || levenshtein(n, input) <= 3).slice(0, 5);
@@ -61,16 +192,35 @@ async function fetchSource(name) {
     const handler = sources[name];
     if (!handler) {
         const similar = suggestSimilar(name);
-        console.error(`Error: Unknown source "${name}"`);
-        if (similar.length) {
-            console.error(`Did you mean: ${similar.join(", ")}?`);
+        emitError(`Unknown source "${name}"`, "UNKNOWN_SOURCE", 1, similar.length ? similar : undefined);
+    }
+    // Validate --fields before fetching
+    if (opts.fields.length) {
+        const validFields = new Set(NEWS_ITEM_FIELDS);
+        const invalid = opts.fields.filter(f => !validFields.has(f));
+        if (invalid.length) {
+            emitError(`Invalid field(s): ${invalid.join(", ")}. Valid fields: ${NEWS_ITEM_FIELDS.join(", ")}`, "INVALID_FIELD", 1);
         }
-        process.exit(1);
     }
     try {
-        const items = await handler();
-        if (jsonFlag) {
-            console.log(JSON.stringify(items, null, 2));
+        let items = await handler();
+        if (opts.limit !== undefined && opts.limit > 0) {
+            items = items.slice(0, opts.limit);
+        }
+        if (opts.json) {
+            let projected = items;
+            if (opts.fields.length) {
+                projected = items.map(item => {
+                    const picked = {};
+                    for (const f of opts.fields) {
+                        if (f in item)
+                            picked[f] = item[f];
+                    }
+                    return picked;
+                });
+            }
+            const envelope = { source: name, count: projected.length, items: projected };
+            jsonOut(envelope);
         }
         else {
             if (!items.length) {
@@ -89,16 +239,18 @@ async function fetchSource(name) {
         }
     }
     catch (err) {
-        console.error(`Error fetching "${name}": ${err.message}`);
-        process.exit(1);
+        emitError(`Fetch failed for "${name}": ${err.message}`, "FETCH_ERROR", 2);
     }
 }
-if (!command || command === "help" || command === "--help" || command === "-h") {
+if (!opts.command || opts.command === "help" || opts.command === "--help" || opts.command === "-h") {
     printHelp();
 }
-else if (command === "list") {
+else if (opts.command === "list") {
     printList();
 }
+else if (opts.command === "schema") {
+    printSchema();
+}
 else {
-    fetchSource(command);
+    fetchSource(opts.command);
 }

package/dist/src/types.js

@@ -1 +1 @@
-export {};
+export const NEWS_ITEM_FIELDS = ["id", "title", "url", "mobileUrl", "pubDate", "extra"];

package/dist/test/cli.test.js

@@ -1,5 +1,13 @@
 import { describe, test, expect } from "bun:test";
 import { sources } from "../src/sources/index.js";
+const cwd = import.meta.dir + "/..";
+function run(args) {
+    return Bun.spawn(["bun", "src/cli.ts", ...args], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+}
 describe("registry", () => {
     test("has sources registered", () => {
         const names = Object.keys(sources);
@@ -21,32 +29,85 @@ describe("registry", () => {
     });
 });
 describe("cli", () => {
-    test("list command outputs sources", async () => {
-        const proc = Bun.spawn(["bun", "src/cli.ts", "list", "--json"], {
-            cwd: import.meta.dir + "/..",
-            stdout: "pipe",
-        });
-        const output = await new Response(proc.stdout).text();
-        const names = JSON.parse(output);
-        expect(Array.isArray(names)).toBe(true);
-        expect(names.length).toBeGreaterThan(40);
-        expect(names).toContain("hackernews");
+    test("list --json returns ListEnvelope", async () => {
+        const proc = run(["list", "--json"]);
+        const output = await new Response(proc.stdout).text();
+        const envelope = JSON.parse(output);
+        expect(envelope).toHaveProperty("count");
+        expect(envelope).toHaveProperty("sources");
+        expect(Array.isArray(envelope.sources)).toBe(true);
+        expect(envelope.count).toBeGreaterThan(40);
+        expect(envelope.sources[0]).toHaveProperty("name");
+        expect(envelope.sources[0]).toHaveProperty("category");
+        expect(envelope.sources[0]).toHaveProperty("envVars");
+    });
+    test("--output json alias works", async () => {
+        const proc = run(["list", "--output", "json"]);
+        const output = await new Response(proc.stdout).text();
+        const envelope = JSON.parse(output);
+        expect(envelope).toHaveProperty("count");
+        expect(envelope).toHaveProperty("sources");
     });
     test("help command works", async () => {
-        const proc = Bun.spawn(["bun", "src/cli.ts", "--help"], {
-            cwd: import.meta.dir + "/..",
-            stdout: "pipe",
-        });
+        const proc = run(["--help"]);
         const output = await new Response(proc.stdout).text();
         expect(output).toContain("Usage:");
+        expect(output).toContain("--fields");
+        expect(output).toContain("--limit");
+        expect(output).toContain("schema");
     });
-    test("unknown source shows error", async () => {
-        const proc = Bun.spawn(["bun", "src/cli.ts", "nonexistent_xyz"], {
-            cwd: import.meta.dir + "/..",
-            stderr: "pipe",
-        });
+    test("schema command returns valid JSON Schema", async () => {
+        const proc = run(["schema"]);
+        const output = await new Response(proc.stdout).text();
+        const schema = JSON.parse(output);
+        expect(schema).toHaveProperty("$schema");
+        expect(schema).toHaveProperty("commands");
+        expect(schema).toHaveProperty("flags");
+        expect(schema).toHaveProperty("categories");
+        expect(schema).toHaveProperty("$defs");
+        expect(schema.$defs).toHaveProperty("NewsItem");
+        expect(schema.$defs).toHaveProperty("FetchEnvelope");
+        expect(schema.$defs).toHaveProperty("ListEnvelope");
+    });
+    test("unknown source shows error with exitCode", async () => {
+        const proc = run(["nonexistent_xyz"]);
         const err = await new Response(proc.stderr).text();
         expect(err).toContain("Unknown source");
+        const code = await proc.exited;
+        expect(code).toBe(1);
+    });
+    test("unknown source --json emits ErrorEnvelope to stderr", async () => {
+        const proc = run(["nonexistent_xyz", "--json"]);
+        const err = await new Response(proc.stderr).text();
+        const envelope = JSON.parse(err);
+        expect(envelope).toHaveProperty("error");
+        expect(envelope.code).toBe("UNKNOWN_SOURCE");
+        const code = await proc.exited;
+        expect(code).toBe(1);
+    });
+    test("--fields with invalid field returns INVALID_FIELD error", async () => {
+        const proc = run(["hackernews", "--json", "--fields", "bogus"]);
+        const err = await new Response(proc.stderr).text();
+        const envelope = JSON.parse(err);
+        expect(envelope.code).toBe("INVALID_FIELD");
+        expect(envelope.error).toContain("bogus");
+        const code = await proc.exited;
+        expect(code).toBe(1);
+    });
+    test("--pretty produces indented output", async () => {
+        const proc = run(["list", "--json", "--pretty"]);
+        const output = await new Response(proc.stdout).text();
+        expect(output).toContain("\n  ");
+        // Should still parse as valid JSON
+        const parsed = JSON.parse(output);
+        expect(parsed).toHaveProperty("count");
+    });
+    test("compact JSON is default (no indentation)", async () => {
+        const proc = run(["list", "--json"]);
+        const output = await new Response(proc.stdout).text();
+        // Compact JSON is a single line
+        const lines = output.trim().split("\n");
+        expect(lines.length).toBe(1);
     });
 });
 describe("fetch source", () => {
@@ -58,4 +119,23 @@ describe("fetch source", () => {
         expect(items[0]).toHaveProperty("id");
         expect(items[0]).toHaveProperty("url");
     }, 15000);
+    test("--fields filters output fields", async () => {
+        const proc = run(["hackernews", "--json", "--fields", "id,title", "--limit", "3"]);
+        const output = await new Response(proc.stdout).text();
+        const envelope = JSON.parse(output);
+        expect(envelope.source).toBe("hackernews");
+        expect(envelope.count).toBeLessThanOrEqual(3);
+        for (const item of envelope.items) {
+            expect(item).toHaveProperty("id");
+            expect(item).toHaveProperty("title");
+            expect(item).not.toHaveProperty("url");
+        }
+    }, 15000);
+    test("--limit caps item count", async () => {
+        const proc = run(["hackernews", "--json", "--limit", "2"]);
+        const output = await new Response(proc.stdout).text();
+        const envelope = JSON.parse(output);
+        expect(envelope.count).toBeLessThanOrEqual(2);
+        expect(envelope.items.length).toBeLessThanOrEqual(2);
+    }, 15000);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newsnow",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "bin": {
     "newsnow": "./dist/src/cli.js"
@@ -12,7 +12,7 @@
     "start": "bun src/cli.ts",
     "test": "bun test",
     "build": "tsc",
-    "release": "bun run build && npm publish"
+    "release": "bun scripts/release.ts"
   },
   "dependencies": {
     "cheerio": "^1.0.0",
@@ -24,5 +24,6 @@
     "@types/bun": "latest",
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0"
-  }
+  },
+  "license": "MIT"
 }