@chenpengfei/daily-brief 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes for Formal Releases are recorded here. GitHub Release notes should be derived from the matching version entry.
+
+## 0.1.0 - 2026-05-31
+
+Initial Formal Release candidate for the Daily Brief Agent.
+
+### User-visible Changes
+
+- Ships the `daily-brief` Operational CLI as the npm package `@chenpengfei/daily-brief`.
+- Supports first-use setup through `daily-brief setup`.
+- Supports source management, model configuration, delivery configuration, status inspection, and manual workflow runs from the installed CLI.
+- Generates Chinese Daily Brief output from configured Sources through the Agent-driven brief generation workflow.
+
+### Installation and Upgrade Notes
+
+- Install with `npm install -g @chenpengfei/daily-brief`.
+- Run `daily-brief setup` after installation to initialize user configuration and generated-data directories.
+- Generated data and user configuration live under the user Daily Brief home by default, not in the repository checkout.
+
+### Known Limitations
+
+- The first release does not include a built-in scheduler; use cron, launchd, systemd, GitHub Actions, or another external scheduler.
+- Discord is the initial Delivery Channel.
+- Source discovery remains manual through the Source Registry; the agent does not add Sources autonomously.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 陈鹏飞 chenpengfei
+
+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

@@ -0,0 +1,28 @@
+# Daily Brief
+
+Daily Brief is a personal intelligence workflow for generating a recurring brief about Agent architecture, AI Coding, and related ecosystem signals from manually configured Sources.
+
+## Install
+
+Daily Brief is distributed as the npm package `@chenpengfei/daily-brief` and installs the `daily-brief` command.
+
+```bash
+npm install -g @chenpengfei/daily-brief
+daily-brief setup
+```
+
+Daily Brief requires Node.js 22 or newer.
+
+## Use
+
+```bash
+daily-brief run-once
+daily-brief status
+daily-brief sources list
+daily-brief model status
+daily-brief delivery status
+```
+
+For installation, setup, configuration, upgrade, and troubleshooting, see `docs/user-manual.md`.
+
+For maintainer release gates and publication steps, see `docs/release-workflow.md`.

package/config/sources.example.yaml

@@ -0,0 +1,20 @@
+# Example Source Registry for Daily Brief.
+#
+# User-specific Source Registry lives outside the repository, normally at:
+# ~/.daily-brief/sources.yaml
+#
+# Each Source has:
+# - id: stable unique identifier
+# - platform: content platform, such as x, blog, github, or youtube
+# - adapter: logical Fetch Adapter name
+# - target: adapter-specific locator or query
+# - enabled: collection switch
+# - notes: human-readable reason for including the Source
+
+sources:
+  - id: github-trending-daily
+    platform: github
+    adapter: github-trending
+    target: https://github.com/trending?since=daily
+    enabled: true
+    notes: Site-wide daily GitHub Trending; Brief generation filters for Agent Architecture and AI Coding signals

package/dist/src/adapters/fixture.js

@@ -0,0 +1,70 @@
+import { readFile } from "node:fs/promises";
+import { createSourceItem } from "../domain/index.js";
+export const fixtureFetchAdapter = {
+    name: "fixture",
+    async fetch(source, context) {
+        const contents = await readFile(source.target, "utf8");
+        const fixture = parseFixtureFile(JSON.parse(contents));
+        return fixture.items.map((item) => {
+            const input = {
+                id: `${source.id}:${item.id}`,
+                sourceId: source.id,
+                platform: source.platform,
+                url: item.url,
+                title: item.title,
+                fetchedAt: context.fetchedAt.toISOString(),
+                analyzableText: item.analyzableText,
+                ...(item.author ? { author: item.author } : {}),
+                ...(item.publishedAt ? { publishedAt: item.publishedAt } : {})
+            };
+            return createSourceItem(input);
+        });
+    }
+};
+function parseFixtureFile(value) {
+    if (!isRecord(value) || !Array.isArray(value.items)) {
+        throw new Error("Fixture adapter target must be a JSON object with an items list");
+    }
+    return {
+        items: value.items.map(parseFixtureSourceItem)
+    };
+}
+function parseFixtureSourceItem(value) {
+    if (!isRecord(value)) {
+        throw new Error("Fixture Source Item must be an object");
+    }
+    const id = readString(value, "id");
+    const url = readString(value, "url");
+    const title = readString(value, "title");
+    const analyzableText = readString(value, "analyzableText");
+    const author = readOptionalString(value, "author");
+    const publishedAt = readOptionalString(value, "publishedAt");
+    return {
+        id,
+        url,
+        title,
+        ...(author ? { author } : {}),
+        ...(publishedAt ? { publishedAt } : {}),
+        analyzableText
+    };
+}
+function readString(source, key) {
+    const value = source[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Fixture Source Item ${key} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function readOptionalString(source, key) {
+    const value = source[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Fixture Source Item ${key} must be a non-empty string when present`);
+    }
+    return value.trim();
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/adapters/github-trending.js

@@ -0,0 +1,183 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { createSourceItem } from "../domain/index.js";
+export function createGitHubTrendingFetchAdapter(options = {}) {
+    return {
+        name: "github-trending",
+        async fetch(source, context) {
+            const candidates = await readGitHubCandidates(source.target, options.fetchImpl);
+            const observedForDate = (context.collectionDate ?? context.fetchedAt).toISOString().slice(0, 10);
+            const trendingRange = readTrendingRange(source.target);
+            return candidates.map((candidate) => {
+                const input = {
+                    id: `${source.id}:${stableRepoId(candidate, observedForDate)}`,
+                    sourceId: source.id,
+                    platform: source.platform,
+                    url: candidate.url,
+                    title: candidate.fullName,
+                    fetchedAt: context.fetchedAt.toISOString(),
+                    analyzableText: buildAnalyzableText(candidate),
+                    metadata: {
+                        repoName: candidate.fullName,
+                        ...(candidate.description ? { description: candidate.description } : {}),
+                        stars: candidate.stars,
+                        forks: candidate.forks,
+                        watchers: candidate.watchers,
+                        starsToday: candidate.starsToday,
+                        previousStars: candidate.previousStars,
+                        observedForDate,
+                        ...(trendingRange ? { trendingRange } : {})
+                    },
+                    ...(candidate.owner ? { author: candidate.owner } : {}),
+                    ...(candidate.pushedAt ? { publishedAt: candidate.pushedAt } : {})
+                };
+                return createSourceItem(input);
+            });
+        }
+    };
+}
+export const githubTrendingFetchAdapter = createGitHubTrendingFetchAdapter();
+async function readGitHubCandidates(target, fetchImpl = fetch) {
+    if (target.startsWith("http://") || target.startsWith("https://")) {
+        const response = await fetchImpl(target);
+        if (!response.ok) {
+            throw new Error(`GitHub target returned ${response.status}`);
+        }
+        const body = await response.text();
+        return target.includes("github.com/trending") ? parseTrendingHtml(body) : parseGitHubJson(body);
+    }
+    return parseGitHubJson(await readFile(target, "utf8"));
+}
+function parseGitHubJson(body) {
+    const parsed = JSON.parse(body);
+    const items = isRecord(parsed) && Array.isArray(parsed.items) ? parsed.items : Array.isArray(parsed) ? parsed : undefined;
+    if (!items) {
+        throw new Error("GitHub fixture/API response must contain an items list");
+    }
+    return items.map(parseGitHubRepoCandidate);
+}
+function parseGitHubRepoCandidate(value) {
+    if (!isRecord(value)) {
+        throw new Error("GitHub repository candidate must be an object");
+    }
+    const fullName = readString(value, "full_name", "fullName");
+    const url = readString(value, "html_url", "url");
+    const owner = isRecord(value.owner) ? optionalString(value.owner.login) : optionalString(value.owner);
+    const description = optionalString(value.description);
+    const stars = optionalNumber(value.stargazers_count ?? value.stars);
+    const forks = optionalNumber(value.forks_count ?? value.forks);
+    const watchers = optionalNumber(value.watchers_count ?? value.watchers);
+    const starsToday = optionalNumber(value.stars_today ?? value.starsToday);
+    const previousStars = optionalNumber(value.previous_stargazers_count ?? value.previousStars);
+    const pushedAt = optionalString(value.pushed_at ?? value.pushedAt);
+    return {
+        fullName,
+        url,
+        ...(description ? { description } : {}),
+        ...(owner ? { owner } : {}),
+        ...(stars !== undefined ? { stars } : {}),
+        ...(forks !== undefined ? { forks } : {}),
+        ...(watchers !== undefined ? { watchers } : {}),
+        ...(starsToday !== undefined ? { starsToday } : {}),
+        ...(previousStars !== undefined ? { previousStars } : {}),
+        ...(pushedAt ? { pushedAt } : {})
+    };
+}
+function parseTrendingHtml(body) {
+    const articlePattern = /<article[\s\S]*?<\/article>/g;
+    const articles = body.match(articlePattern) ?? [];
+    return articles.flatMap((article) => {
+        const repoMatch = article.match(/<h2[\s\S]*?href="\/([^/"]+\/[^/"]+)"/);
+        if (!repoMatch?.[1]) {
+            return [];
+        }
+        const fullName = repoMatch[1].replace(/\s+/g, "");
+        const description = stripMarkup(article.match(/<p[^>]*>([\s\S]*?)<\/p>/)?.[1] ?? "");
+        const stars = numberFromText(article.match(/aria-label="([\d,]+) stars"/)?.[1]);
+        const forks = numberFromText(article.match(/aria-label="([\d,]+) forks"/)?.[1]);
+        const starsToday = numberFromText(article.match(/([\d,]+)\s+stars today/)?.[1]);
+        return [
+            {
+                fullName,
+                url: `https://github.com/${fullName}`,
+                ...(fullName.split("/")[0] ? { owner: fullName.split("/")[0] } : {}),
+                ...(description ? { description } : {}),
+                ...(stars !== undefined ? { stars } : {}),
+                ...(forks !== undefined ? { forks } : {}),
+                ...(stars !== undefined ? { watchers: stars } : {}),
+                ...(starsToday !== undefined ? { starsToday } : {})
+            }
+        ];
+    });
+}
+function buildAnalyzableText(candidate) {
+    const metrics = [
+        candidate.stars !== undefined ? `${candidate.stars} stars` : undefined,
+        candidate.forks !== undefined ? `${candidate.forks} forks` : undefined,
+        candidate.watchers !== undefined ? `${candidate.watchers} watchers` : undefined
+    ].filter(Boolean);
+    const momentum = candidate.starsToday
+        ? `Momentum: +${candidate.starsToday} stars today.`
+        : candidate.previousStars !== undefined && candidate.stars !== undefined
+            ? `Momentum: ${candidate.stars - candidate.previousStars >= 0 ? "+" : ""}${candidate.stars - candidate.previousStars} stars since previous collection.`
+            : "Momentum: no recent star delta available.";
+    return [
+        candidate.description ?? "GitHub repository candidate.",
+        metrics.length > 0 ? `Metrics: ${metrics.join(", ")}.` : undefined,
+        momentum,
+        "Ordinary commits are not treated as Source Items by this adapter."
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+function stableRepoId(candidate, observedForDate) {
+    return createHash("sha256").update(`${candidate.url}|${observedForDate}`).digest("hex").slice(0, 16);
+}
+function readTrendingRange(target) {
+    try {
+        const url = new URL(target);
+        if (!url.hostname.endsWith("github.com") || url.pathname !== "/trending") {
+            return undefined;
+        }
+        return url.searchParams.get("since") ?? "daily";
+    }
+    catch {
+        return undefined;
+    }
+}
+function readString(source, primary, fallback) {
+    const value = optionalString(source[primary] ?? source[fallback]);
+    if (!value) {
+        throw new Error(`GitHub repository candidate requires ${primary}`);
+    }
+    return value;
+}
+function optionalString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function optionalNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        return numberFromText(value);
+    }
+    return undefined;
+}
+function numberFromText(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value.replaceAll(",", ""));
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function stripMarkup(value) {
+    return value.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/adapters/index.js

@@ -0,0 +1,5 @@
+export * from "./fixture.js";
+export * from "./github-trending.js";
+export * from "./rss.js";
+export * from "./types.js";
+export * from "./x.js";

package/dist/src/adapters/rss.js

@@ -0,0 +1,156 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { XMLParser } from "fast-xml-parser";
+import { createSourceItem } from "../domain/index.js";
+export function createRssFetchAdapter(options = {}) {
+    return {
+        name: "rss",
+        async fetch(source, context) {
+            const feed = await readFeedTarget(source.target, options.fetchImpl);
+            const entries = parseFeedEntries(feed);
+            return entries.map((entry) => createSourceItem({
+                id: `${source.id}:${stableEntryId(entry)}`,
+                sourceId: source.id,
+                platform: source.platform,
+                url: entry.url,
+                title: entry.title,
+                fetchedAt: context.fetchedAt.toISOString(),
+                analyzableText: entry.analyzableText,
+                ...(entry.author ? { author: entry.author } : {}),
+                ...(entry.publishedAt ? { publishedAt: entry.publishedAt } : {})
+            }));
+        }
+    };
+}
+export const rssFetchAdapter = createRssFetchAdapter();
+async function readFeedTarget(target, fetchImpl = fetch) {
+    if (target.startsWith("http://") || target.startsWith("https://")) {
+        const response = await fetchImpl(target);
+        if (!response.ok) {
+            throw new Error(`RSS target returned ${response.status}`);
+        }
+        return response.text();
+    }
+    return readFile(target, "utf8");
+}
+function parseFeedEntries(feed) {
+    const parser = new XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: "@_",
+        textNodeName: "#text"
+    });
+    const parsed = parser.parse(feed);
+    if (!isRecord(parsed)) {
+        throw new Error("RSS/Atom feed did not parse into an object");
+    }
+    if (isRecord(parsed.rss)) {
+        return parseRssEntries(parsed.rss);
+    }
+    if (isRecord(parsed.feed)) {
+        return parseAtomEntries(parsed.feed);
+    }
+    throw new Error("Unsupported feed format: expected RSS or Atom");
+}
+function parseRssEntries(rss) {
+    const channel = rss.channel;
+    if (!isRecord(channel)) {
+        throw new Error("RSS feed missing channel");
+    }
+    return toArray(channel.item).map((item) => {
+        if (!isRecord(item)) {
+            throw new Error("RSS item must be an object");
+        }
+        const title = textValue(item.title, "RSS item title");
+        const url = textValue(item.link, "RSS item link");
+        const analyzableText = textValue(item.description ?? item["content:encoded"] ?? title, "RSS item description");
+        const author = optionalTextValue(item.author ?? item["dc:creator"]);
+        const publishedAt = normalizeDate(optionalTextValue(item.pubDate));
+        return {
+            title,
+            url,
+            analyzableText: stripMarkup(analyzableText),
+            ...(author ? { author } : {}),
+            ...(publishedAt ? { publishedAt } : {})
+        };
+    });
+}
+function parseAtomEntries(feed) {
+    return toArray(feed.entry).map((entry) => {
+        if (!isRecord(entry)) {
+            throw new Error("Atom entry must be an object");
+        }
+        const title = textValue(entry.title, "Atom entry title");
+        const url = atomLink(entry.link);
+        const analyzableText = textValue(entry.summary ?? entry.content ?? title, "Atom entry summary");
+        const author = atomAuthor(entry.author);
+        const publishedAt = normalizeDate(optionalTextValue(entry.published ?? entry.updated));
+        return {
+            title,
+            url,
+            analyzableText: stripMarkup(analyzableText),
+            ...(author ? { author } : {}),
+            ...(publishedAt ? { publishedAt } : {})
+        };
+    });
+}
+function atomLink(value) {
+    const links = toArray(value);
+    const alternate = links.find((link) => isRecord(link) && (link["@_rel"] === "alternate" || link["@_rel"] === undefined));
+    const selected = alternate ?? links[0];
+    if (isRecord(selected)) {
+        return textValue(selected["@_href"] ?? selected.href, "Atom entry link");
+    }
+    return textValue(selected, "Atom entry link");
+}
+function atomAuthor(value) {
+    if (isRecord(value)) {
+        return optionalTextValue(value.name);
+    }
+    return optionalTextValue(value);
+}
+function stableEntryId(entry) {
+    return createHash("sha256")
+        .update(JSON.stringify({ url: entry.url, title: entry.title, publishedAt: entry.publishedAt }))
+        .digest("hex")
+        .slice(0, 16);
+}
+function normalizeDate(value) {
+    if (!value) {
+        return undefined;
+    }
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return value;
+    }
+    return date.toISOString();
+}
+function stripMarkup(value) {
+    return value.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function textValue(value, label) {
+    const text = optionalTextValue(value);
+    if (!text) {
+        throw new Error(`${label} must be present`);
+    }
+    return text;
+}
+function optionalTextValue(value) {
+    if (typeof value === "string" || typeof value === "number") {
+        const text = String(value).trim();
+        return text.length > 0 ? text : undefined;
+    }
+    if (isRecord(value) && typeof value["#text"] === "string") {
+        const text = value["#text"].trim();
+        return text.length > 0 ? text : undefined;
+    }
+    return undefined;
+}
+function toArray(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/adapters/x.js

@@ -0,0 +1,115 @@
+import { readFile } from "node:fs/promises";
+import { createSourceItem } from "../domain/index.js";
+export function createXFetchAdapter(options = {}) {
+    return {
+        name: "x",
+        async fetch(source, context) {
+            const posts = await readXPosts(source.target, options.fetchImpl);
+            return posts.filter(shouldKeepPost).map((post) => createSourceItem({
+                id: `${source.id}:${post.id}`,
+                sourceId: source.id,
+                platform: source.platform,
+                url: post.url,
+                title: `${post.author ?? source.id}: ${firstLine(post.addedText ?? post.text)}`,
+                fetchedAt: context.fetchedAt.toISOString(),
+                analyzableText: post.addedText ? `${post.addedText}\n\nQuoted context: ${post.text}` : post.text,
+                metadata: {
+                    postType: post.type ?? "original",
+                    sourceTarget: source.target
+                },
+                ...(post.author ? { author: post.author } : {}),
+                ...(post.createdAt ? { publishedAt: post.createdAt } : {})
+            }));
+        }
+    };
+}
+export const xFetchAdapter = createXFetchAdapter();
+async function readXPosts(target, fetchImpl = fetch) {
+    const body = target.startsWith("http://") || target.startsWith("https://")
+        ? await readRemoteTarget(target, fetchImpl)
+        : await readFile(target, "utf8");
+    const parsed = JSON.parse(body);
+    const posts = isRecord(parsed) && Array.isArray(parsed.posts) ? parsed.posts : Array.isArray(parsed) ? parsed : undefined;
+    if (!posts) {
+        throw new Error("X adapter fixture/response must contain a posts list");
+    }
+    return posts.map(parseXPost);
+}
+async function readRemoteTarget(target, fetchImpl) {
+    const response = await fetchImpl(target);
+    if (!response.ok) {
+        throw new Error(`X target returned ${response.status}`);
+    }
+    return response.text();
+}
+function parseXPost(value) {
+    if (!isRecord(value)) {
+        throw new Error("X post must be an object");
+    }
+    const id = readString(value, "id");
+    const url = readString(value, "url");
+    const text = readString(value, "text");
+    const type = optionalPostType(value.type);
+    const author = optionalString(value.author);
+    const createdAt = optionalString(value.createdAt ?? value.created_at);
+    const addedText = optionalString(value.addedText ?? value.added_text);
+    return {
+        id,
+        url,
+        text,
+        ...(type ? { type } : {}),
+        ...(author ? { author } : {}),
+        ...(createdAt ? { createdAt } : {}),
+        ...(addedText ? { addedText } : {})
+    };
+}
+function shouldKeepPost(post) {
+    const type = post.type ?? "original";
+    if (type === "repost") {
+        return false;
+    }
+    if (type === "quote" || type === "reply") {
+        return isFocusRelevant(`${post.addedText ?? ""} ${post.text}`);
+    }
+    return isFocusRelevant(post.text);
+}
+function isFocusRelevant(text) {
+    const normalized = text.toLowerCase();
+    const terms = [
+        "agent architecture",
+        "agent runtime",
+        "coding agent",
+        "ai coding",
+        "tool execution",
+        "eval",
+        "memory",
+        "mcp"
+    ];
+    return terms.some((term) => normalized.includes(term));
+}
+function firstLine(text) {
+    return text.replace(/\s+/g, " ").trim().slice(0, 96);
+}
+function readString(source, key) {
+    const value = optionalString(source[key]);
+    if (!value) {
+        throw new Error(`X post ${key} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function optionalPostType(value) {
+    if (value === "original" || value === "repost" || value === "quote" || value === "reply") {
+        return value;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}