@chronicle.app/hackernews 0.0.0-stage → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+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,3 +1,59 @@
-# Temporary Holding Version
+# @chronicle.app/hackernews
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Read your Hacker News submissions, comments, and the replies to them through the public [Firebase API](https://github.com/HackerNews/API). No login is needed; `--username` is the only required flag, and the CLI asks for it when it's missing.
+
+## Usage
+
+```sh
+chronicle extract hackernews --username you
+chronicle extract hackernews comments replies --username you --since 2025-01-01
+```
+
+Each kind is one record type:
+
+- `submissions` (the default): stories, polls, and job posts you submitted.
+- `comments`: comments you wrote.
+- `replies`: other people's direct replies to your submissions and comments. Your own replies are under `comments`.
+
+Your items are read newest first, so `--since` ends the `submissions` and `comments` walks at the first older item. `replies` reads every item you posted, since an old item can get a new reply, and applies `--since` to the reply's own time. Deleted items are skipped, as are removed ones the API returns with no time or text; dead (killed) items are kept, since they were still posted.
+
+Upvotes, favorites, and hidden items aren't read: Hacker News records no time for them, and upvotes also need a login and page scraping.
+
+## Schema
+
+| Hacker News activity                    | Chronicle action | `object`                       | `result`  |
+| --------------------------------------- | ---------------- | ------------------------------ | --------- |
+| You submitted a story, poll, or job     | `PublishAction`  | `Post`                         |           |
+| You commented                           | `RespondAction`  | the parent `Post` or `Comment` | `Comment` |
+| Someone replied to your post or comment | `RespondAction`  | your `Post` or `Comment`       | `Comment` |
+
+| Hacker News thing   | Chronicle entity | Key                           | Properties                                                               |
+| ------------------- | ---------------- | ----------------------------- | ------------------------------------------------------------------------ |
+| Story, poll, or job | `Post`           | `@type`, `source`, `sourceId` | `name` (title), `body` (text), `url` (item page), `author`, `references` |
+| Comment             | `Comment`        | `@type`, `source`, `sourceId` | `body`, `url` (item page), `author`, `about`                             |
+| Submitted link      | `Entity`         | `url`                         | `url`                                                                    |
+| Account             | `Agent`          | `@type`, `source`, `handle`   | `handle`, `url` (profile page), `description` (yours only)               |
+
+### Decisions
+
+**A comment is a `RespondAction`, not a `CreateAction`.** The schema defines a comment as a prose `Response`, the `result` of a `RespondAction` whose `object` is what it responds to. A reply by someone else is the same shape with a different agent, so `comments` and `replies` share one transform.
+
+**Two edges from a comment: `object` for its parent, `about` for its submission.** Hacker News gives each comment only its direct `parent`, which may be another comment. The action's `object` is that parent, preserving the thread's tree. The `Comment` is also `about` the story or poll at the top of the thread, found by walking `parent` links, so a reply deep in a discussion still links to what the discussion is about. YouTube and Are.na comments are likewise `about` their video or block. For a top-level comment, the two edges point at the same `Post`. Each item is fetched once per run, however many comments share it as an ancestor.
+
+**The submitted link is in `references`, not `about`.** The schema reserves `about` for subject matter, such as topics and tags, and defines `references` as a link from one resource to another. A link submission is a post pointing at a page, as Are.na's link blocks are. Keeping `about` for "the submission this comment's thread is on" also keeps that edge unambiguous.
+
+**The link is the shared page node.** It's an `Entity` keyed by `url` alone, with no `source`, so it is the same node that Safari, Are.na, and Obsidian produce for that page. Pinboard instead keys its page nodes by `url` and `source`, joining this one through their `url`, because its snapshots clear per-source notes and tags; Hacker News asserts no such state about the page.
+
+**`author` is set on every `Post` and `Comment`.** Parent comments, the story at the top of a thread, and the item a reply answers have no action of their own in these records, so `author` is the only edge to whoever wrote them. It's set on your own items too, so a post has the same shape wherever it appears. It sits on the Hacker News `Post`, never on the linked page: the submitter wrote the submission, not the article.
+
+**Accounts are keyed by `handle`.** A username is the only identity Hacker News gives an account; there is no separate numeric id, so there is no `sourceId`. Every `Agent` carries its profile page, `https://news.ycombinator.com/user?id=<username>`, as `url`. Yours also carries `sameAs: ['@me']` and your profile's about text as `description`.
+
+**Items are keyed by their Hacker News id.** Stories, comments, and polls share one id sequence, so the id alone identifies an item. An action and its `Post` or `Comment` share that `sourceId` and differ by `@type`.
+
+**Times are the item's post time.** Every action's `timestamp` is the item's `time`, exact to the second. Nothing is dated by when it was read.
+
+**Text is plain.** Hacker News sends comment and post text as HTML. It's converted to plain text, with each `<p>` starting a new line and links kept as `label (url)`.
+
+## Tests
+
+Tests run the extractors against a fake Firebase API on 127.0.0.1 with synthetic items. They never reach the network.

package/dist/connectors/HackerNewsCommentsExtractor.d.ts

@@ -0,0 +1,9 @@
+import { Record } from '@chronicle.app/etl';
+import HackerNewsExtractor from './HackerNewsExtractor.js';
+export default class HackerNewsCommentsExtractor extends HackerNewsExtractor {
+    static description: string;
+    static recordTypes: string[];
+    static newestFirst: boolean;
+    protected records(): AsyncGenerator<Record>;
+}
+//# sourceMappingURL=HackerNewsCommentsExtractor.d.ts.map

package/dist/connectors/HackerNewsCommentsExtractor.js

@@ -0,0 +1,17 @@
+import HackerNewsExtractor from './HackerNewsExtractor.js';
+export default class HackerNewsCommentsExtractor extends HackerNewsExtractor {
+    static description = 'Comments you wrote';
+    static recordTypes = ['comments'];
+    static newestFirst = true;
+    async *records() {
+        for await (const item of this.ownItems({ stopAtSince: true })) {
+            if (item.type !== 'comment' || !this.inRange(item))
+                continue;
+            // The direct parent is what the comment answers; the root is the
+            // submission whose discussion it belongs to.
+            const parent = item.parent === undefined ? null : await this.proxy.getItem(item.parent);
+            const root = await this.proxy.getRoot(item);
+            yield this.createRecord(item, this.context({ recordType: 'comments', parent, root }));
+        }
+    }
+}

package/dist/connectors/HackerNewsExtractor.d.ts

@@ -0,0 +1,52 @@
+import { Extractor, Record, z } from '@chronicle.app/etl';
+import HackerNewsProxy, { HackerNewsItem, HackerNewsUser } from '../utils/HackerNewsProxy.js';
+import HackerNewsTransformer from './HackerNewsTransformer.js';
+export default abstract class HackerNewsExtractor extends Extractor<typeof HackerNewsExtractor> {
+    static defaultTransformer: typeof HackerNewsTransformer;
+    static source: string;
+    static delivery: "api";
+    static strategy: string;
+    static schema: z.ZodObject<{
+        since: z.ZodOptional<z.ZodDate>;
+        until: z.ZodOptional<z.ZodDate>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    } & {
+        username: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        username: string;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        username: string;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    protected proxy: HackerNewsProxy;
+    protected user: HackerNewsUser;
+    setup(): Promise<void>;
+    /** The raw item id — Hacker News numbers every item once, across all types. */
+    keyOf(record: Record): string | null;
+    protected abstract records(): AsyncGenerator<Record>;
+    extract(): AsyncGenerator<Record>;
+    protected context(extra?: object): {
+        user: HackerNewsUser;
+    };
+    /**
+     * The user's own items, newest first. With `stopAtSince`, the walk ends at
+     * the first item older than `since`: every later id is older still.
+     */
+    protected ownItems({ stopAtSince }: {
+        stopAtSince: boolean;
+    }): AsyncGenerator<HackerNewsItem, void, unknown>;
+    /**
+     * The items in order, a batch at a time, without the missing and deleted.
+     * A removed item can also come back as just its id and type, with no time,
+     * author, or text; it is skipped too.
+     */
+    protected fetchEach(ids: number[]): AsyncGenerator<HackerNewsItem>;
+    protected isBeforeSince(item: HackerNewsItem): boolean;
+    protected inRange(item: HackerNewsItem): boolean;
+}
+//# sourceMappingURL=HackerNewsExtractor.d.ts.map

package/dist/connectors/HackerNewsExtractor.js

@@ -0,0 +1,77 @@
+import { Extractor, InputNotFound, z } from '@chronicle.app/etl';
+import HackerNewsProxy from '../utils/HackerNewsProxy.js';
+import HackerNewsTransformer from './HackerNewsTransformer.js';
+/** Items fetched at once. The Firebase API has no batch endpoint. */
+const CONCURRENCY = 8;
+export default class HackerNewsExtractor extends Extractor {
+    static defaultTransformer = HackerNewsTransformer;
+    static source = 'hackernews';
+    static delivery = 'api';
+    static strategy = 'api';
+    static schema = Extractor.schema.extend({
+        // Hacker News has no API credentials: the username is all it needs.
+        username: z.string().describe('Hacker News username'),
+    });
+    proxy;
+    user;
+    async setup() {
+        const { username } = this.config;
+        this.proxy = new HackerNewsProxy();
+        const user = await this.proxy.getUser(username);
+        if (!user) {
+            throw new InputNotFound(`Hacker News has no user named ${username}`);
+        }
+        this.user = user;
+    }
+    /** The raw item id — Hacker News numbers every item once, across all types. */
+    keyOf(record) {
+        const { id } = record.data;
+        return id === undefined ? null : String(id);
+    }
+    async *extract() {
+        let count = 0;
+        for await (const record of this.records()) {
+            if (this.shouldStopExtracting(count))
+                return;
+            yield record;
+            count++;
+        }
+    }
+    context(extra = {}) {
+        return { user: this.user, ...extra };
+    }
+    /**
+     * The user's own items, newest first. With `stopAtSince`, the walk ends at
+     * the first item older than `since`: every later id is older still.
+     */
+    async *ownItems({ stopAtSince }) {
+        for await (const item of this.fetchEach(this.user.submitted ?? [])) {
+            if (stopAtSince && this.isBeforeSince(item))
+                return;
+            yield item;
+        }
+    }
+    /**
+     * The items in order, a batch at a time, without the missing and deleted.
+     * A removed item can also come back as just its id and type, with no time,
+     * author, or text; it is skipped too.
+     */
+    async *fetchEach(ids) {
+        for (let start = 0; start < ids.length; start += CONCURRENCY) {
+            const batch = await Promise.all(ids.slice(start, start + CONCURRENCY).map(id => this.proxy.getItem(id)));
+            for (const item of batch) {
+                if (item && !item.deleted && item.time !== undefined)
+                    yield item;
+            }
+        }
+    }
+    isBeforeSince(item) {
+        return this.config.since !== undefined && time(item) < this.config.since;
+    }
+    inRange(item) {
+        return !this.isBeforeSince(item) && !(this.config.until && time(item) > this.config.until);
+    }
+}
+function time(item) {
+    return new Date((item.time ?? 0) * 1000);
+}

package/dist/connectors/HackerNewsRepliesExtractor.d.ts

@@ -0,0 +1,8 @@
+import { Record } from '@chronicle.app/etl';
+import HackerNewsExtractor from './HackerNewsExtractor.js';
+export default class HackerNewsRepliesExtractor extends HackerNewsExtractor {
+    static description: string;
+    static recordTypes: string[];
+    protected records(): AsyncGenerator<Record>;
+}
+//# sourceMappingURL=HackerNewsRepliesExtractor.d.ts.map

package/dist/connectors/HackerNewsRepliesExtractor.js

@@ -0,0 +1,19 @@
+import HackerNewsExtractor from './HackerNewsExtractor.js';
+export default class HackerNewsRepliesExtractor extends HackerNewsExtractor {
+    static description = "Other people's replies to your submissions and comments";
+    static recordTypes = ['replies'];
+    async *records() {
+        // An old item can still get a new reply, so `since` can't end the walk.
+        for await (const parent of this.ownItems({ stopAtSince: false })) {
+            if (!parent.kids?.length)
+                continue;
+            const root = parent.type === 'comment' ? await this.proxy.getRoot(parent) : parent;
+            for await (const reply of this.fetchEach(parent.kids)) {
+                // Your own replies are already under `comments`.
+                if (reply.by === this.user.id || !this.inRange(reply))
+                    continue;
+                yield this.createRecord(reply, this.context({ recordType: 'replies', parent, root }));
+            }
+        }
+    }
+}

package/dist/connectors/HackerNewsSubmissionsExtractor.d.ts

@@ -0,0 +1,12 @@
+import { Record } from '@chronicle.app/etl';
+import HackerNewsExtractor from './HackerNewsExtractor.js';
+/** Item types a user submits, as opposed to comments on them. */
+export declare const SUBMISSION_TYPES: Set<string>;
+export default class HackerNewsSubmissionsExtractor extends HackerNewsExtractor {
+    static description: string;
+    static recordTypes: string[];
+    static default: boolean;
+    static newestFirst: boolean;
+    protected records(): AsyncGenerator<Record>;
+}
+//# sourceMappingURL=HackerNewsSubmissionsExtractor.d.ts.map

package/dist/connectors/HackerNewsSubmissionsExtractor.js

@@ -0,0 +1,16 @@
+import HackerNewsExtractor from './HackerNewsExtractor.js';
+/** Item types a user submits, as opposed to comments on them. */
+export const SUBMISSION_TYPES = new Set(['story', 'poll', 'job']);
+export default class HackerNewsSubmissionsExtractor extends HackerNewsExtractor {
+    static description = 'Stories, polls, and job posts you submitted';
+    static recordTypes = ['submissions'];
+    static default = true;
+    static newestFirst = true;
+    async *records() {
+        for await (const item of this.ownItems({ stopAtSince: true })) {
+            if (!SUBMISSION_TYPES.has(item.type ?? '') || !this.inRange(item))
+                continue;
+            yield this.createRecord(item, this.context({ recordType: 'submissions' }));
+        }
+    }
+}

package/dist/connectors/HackerNewsTransformer.d.ts

@@ -0,0 +1,21 @@
+import { ChronicleTransformer, Record } from '@chronicle.app/etl';
+import { ActionAndChildren } from '@chronicle.app/schema';
+export default class HackerNewsTransformer extends ChronicleTransformer {
+    /** The account being extracted, set per record from context. */
+    private user?;
+    transform(record: Record): Promise<ActionAndChildren[]>;
+    private buildPublish;
+    /**
+     * A comment answers its direct parent (the action's `object`) and is about
+     * the submission at the top of its thread (the comment's `about`). For a
+     * top-level comment the two are the same Post.
+     */
+    private buildRespond;
+    private buildItem;
+    private buildPost;
+    private buildComment;
+    /** The submitted page: the shared `{url}` hub, as Are.na's link blocks are. */
+    private buildLink;
+    private buildUser;
+}
+//# sourceMappingURL=HackerNewsTransformer.d.ts.map

package/dist/connectors/HackerNewsTransformer.js

@@ -0,0 +1,114 @@
+import { ChronicleTransformer, htmlToText, selfAgent } from '@chronicle.app/etl';
+const SOURCE = 'hackernews';
+const KEY = ['@type', 'source', 'sourceId'];
+function itemUrl(id) {
+    return `https://news.ycombinator.com/item?id=${id}`;
+}
+function userUrl(username) {
+    return `https://news.ycombinator.com/user?id=${encodeURIComponent(username)}`;
+}
+function time(item) {
+    return new Date((item.time ?? 0) * 1000);
+}
+export default class HackerNewsTransformer extends ChronicleTransformer {
+    /** The account being extracted, set per record from context. */
+    user;
+    async transform(record) {
+        // Safe as a per-record field: everything below builds synchronously.
+        this.user = record.context.user;
+        const item = record.data;
+        switch (record.extraction.recordType) {
+            case 'submissions': {
+                return [this.buildPublish(item)];
+            }
+            // A reply is a comment by someone else; both answer their parent.
+            case 'comments':
+            case 'replies': {
+                return [this.buildRespond(item, record.context.parent, record.context.root)];
+            }
+            default: {
+                return [];
+            }
+        }
+    }
+    buildPublish(item) {
+        return {
+            '@type': 'PublishAction',
+            '@key': KEY,
+            source: SOURCE,
+            sourceId: String(item.id),
+            timestamp: time(item),
+            ...(item.by && { agent: this.buildUser(item.by) }),
+            object: this.buildPost(item),
+        };
+    }
+    /**
+     * A comment answers its direct parent (the action's `object`) and is about
+     * the submission at the top of its thread (the comment's `about`). For a
+     * top-level comment the two are the same Post.
+     */
+    buildRespond(item, parent, root) {
+        return {
+            '@type': 'RespondAction',
+            '@key': KEY,
+            source: SOURCE,
+            sourceId: String(item.id),
+            timestamp: time(item),
+            ...(item.by && { agent: this.buildUser(item.by) }),
+            ...(parent && { object: this.buildItem(parent, root) }),
+            result: this.buildComment(item, root),
+        };
+    }
+    buildItem(item, root) {
+        return item.type === 'comment' ? this.buildComment(item, root) : this.buildPost(item);
+    }
+    buildPost(item) {
+        const body = htmlToText(item.text);
+        return {
+            '@type': 'Post',
+            '@key': KEY,
+            source: SOURCE,
+            sourceId: String(item.id),
+            url: itemUrl(item.id),
+            ...(item.title && { name: item.title }),
+            ...(body && { body }),
+            ...(item.by && { author: [this.buildUser(item.by)] }),
+            ...(item.url && { references: [this.buildLink(item.url)] }),
+        };
+    }
+    buildComment(item, root) {
+        const body = htmlToText(item.text);
+        return {
+            '@type': 'Comment',
+            '@key': KEY,
+            source: SOURCE,
+            sourceId: String(item.id),
+            url: itemUrl(item.id),
+            ...(body && { body }),
+            ...(item.by && { author: [this.buildUser(item.by)] }),
+            ...(root && { about: [this.buildPost(root)] }),
+        };
+    }
+    /** The submitted page: the shared `{url}` hub, as Are.na's link blocks are. */
+    buildLink(url) {
+        return { '@type': 'Entity', '@key': ['url'], url };
+    }
+    buildUser(username) {
+        if (username !== this.user?.id) {
+            // A username is the only identity Hacker News gives an account.
+            return {
+                '@type': 'Agent',
+                '@key': ['@type', 'source', 'handle'],
+                source: SOURCE,
+                handle: username,
+                url: userUrl(username),
+            };
+        }
+        const description = htmlToText(this.user.about);
+        return {
+            ...selfAgent({ type: 'Agent', source: SOURCE, handle: username }),
+            url: userUrl(username),
+            ...(description && { description }),
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { default as HackerNewsExtractor } from './connectors/HackerNewsExtractor.js';
+export { default as HackerNewsCommentsExtractor } from './connectors/HackerNewsCommentsExtractor.js';
+export { default as HackerNewsRepliesExtractor } from './connectors/HackerNewsRepliesExtractor.js';
+export { default as HackerNewsSubmissionsExtractor } from './connectors/HackerNewsSubmissionsExtractor.js';
+export { default as HackerNewsTransformer } from './connectors/HackerNewsTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export { default as HackerNewsExtractor } from './connectors/HackerNewsExtractor.js';
+export { default as HackerNewsCommentsExtractor } from './connectors/HackerNewsCommentsExtractor.js';
+export { default as HackerNewsRepliesExtractor } from './connectors/HackerNewsRepliesExtractor.js';
+export { default as HackerNewsSubmissionsExtractor } from './connectors/HackerNewsSubmissionsExtractor.js';
+export { default as HackerNewsTransformer } from './connectors/HackerNewsTransformer.js';

package/dist/utils/HackerNewsProxy.d.ts

@@ -0,0 +1,37 @@
+import { ApiProxy } from '@chronicle.app/etl';
+/** A user profile from the Firebase API. */
+export interface HackerNewsUser {
+    id: string;
+    created: number;
+    karma?: number;
+    about?: string;
+    /** Every item the user posted, newest first. */
+    submitted?: number[];
+}
+/** An item from the Firebase API: a story, comment, poll, poll option, or job. */
+export interface HackerNewsItem {
+    id: number;
+    type?: 'story' | 'comment' | 'poll' | 'pollopt' | 'job';
+    by?: string;
+    /** Unix time in seconds. */
+    time?: number;
+    text?: string;
+    url?: string;
+    title?: string;
+    parent?: number;
+    kids?: number[];
+    deleted?: boolean;
+    dead?: boolean;
+}
+export default class HackerNewsProxy extends ApiProxy {
+    private items;
+    constructor();
+    initialize(): Promise<void>;
+    /** The profile, or null when no such user exists. */
+    getUser(username: string): Promise<HackerNewsUser | null>;
+    /** The item, or null when the id doesn't exist. */
+    getItem(id: number): Promise<HackerNewsItem | null>;
+    /** The story, poll, or job at the top of the item's thread. */
+    getRoot(item: HackerNewsItem): Promise<HackerNewsItem | undefined>;
+}
+//# sourceMappingURL=HackerNewsProxy.d.ts.map

package/dist/utils/HackerNewsProxy.js

@@ -0,0 +1,39 @@
+import { ApiProxy } from '@chronicle.app/etl';
+export default class HackerNewsProxy extends ApiProxy {
+    // Items never move between threads, so one fetch per run serves every
+    // comment that shares an ancestor.
+    items = new Map();
+    constructor() {
+        super({ baseURL: 'https://hacker-news.firebaseio.com/v0' });
+    }
+    // The API is public; there is nothing to load.
+    async initialize() { }
+    /** The profile, or null when no such user exists. */
+    async getUser(username) {
+        return this.request({
+            url: `/user/${encodeURIComponent(username)}.json`,
+            method: 'GET',
+        });
+    }
+    /** The item, or null when the id doesn't exist. */
+    getItem(id) {
+        let item = this.items.get(id);
+        if (!item) {
+            item = this.request({ url: `/item/${id}.json`, method: 'GET' });
+            this.items.set(id, item);
+        }
+        return item;
+    }
+    /** The story, poll, or job at the top of the item's thread. */
+    async getRoot(item) {
+        let current = item;
+        const seen = new Set();
+        while (current?.type === 'comment' && current.parent !== undefined) {
+            if (seen.has(current.id))
+                return undefined;
+            seen.add(current.id);
+            current = await this.getItem(current.parent);
+        }
+        return current && current.type !== 'comment' ? current : undefined;
+    }
+}

package/package.json

@@ -1,6 +1,73 @@
 {
   "name": "@chronicle.app/hackernews",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts,.js",
+    "test": "node --test src/*.test.js",
+    "shapes": "node src/shapes.test.js --update"
+  },
+  "keywords": [
+    "chronicle",
+    "hackernews"
+  ],
+  "author": "Andrew Louis",
+  "license": "MIT",
+  "type": "module",
+  "description": "Chronicle plugin for Hacker News submissions, comments, and replies",
+  "devDependencies": {
+    "@chronicle.app/etl": "0.4.0",
+    "@chronicle.app/schema": "0.4.0",
+    "@chronicle.app/tsconfig": "0.4.0",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  },
+  "homepage": "https://chronicle.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chronicle-app/chronicle.git",
+    "directory": "plugins/hackernews"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "@chronicle.app/etl": ">=0.1.0 <1.0.0",
+    "@chronicle.app/schema": ">=0.1.0 <1.0.0"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "chronicle": {
+    "plugin": true,
+    "sources": {
+      "hackernews": {
+        "strategies": {
+          "api": {
+            "delivery": "api",
+            "recordTypes": [
+              "comments",
+              "replies",
+              "submissions"
+            ],
+            "default": true
+          }
+        }
+      }
+    }
+  }
+}