youtube-knowledge-mcp 2.2.0 → 3.0.0

package/dist/utils/store-migrations.js

@@ -0,0 +1,41 @@
+import { STORE_VERSION } from './store-schema.js';
+import { writeUserVersion } from './store.js';
+/**
+ * Empty on purpose at v1: `STORE_SCHEMA` is `CREATE TABLE IF NOT EXISTS`
+ * throughout, so a fresh database and an existing v1 database converge without
+ * one. The list exists so the second schema change is a one-line addition
+ * rather than a retrofit.
+ */
+export const STORE_MIGRATIONS = [];
+/**
+ * Brings a database up to STORE_VERSION.
+ *
+ * Each migration runs inside its own transaction so a failure leaves the
+ * store at the last version that fully applied, rather than half-way through
+ * one. A newer-than-known version is rejected before this is reached, in
+ * `store.ts`.
+ */
+export function runStoreMigrations(database, fromVersion) {
+    let current = fromVersion;
+    for (const migration of STORE_MIGRATIONS) {
+        if (migration.to <= current)
+            continue;
+        database.exec('BEGIN');
+        try {
+            migration.apply(database);
+            writeUserVersion(database, migration.to);
+            database.exec('COMMIT');
+        }
+        catch (error) {
+            database.exec('ROLLBACK');
+            throw error;
+        }
+        current = migration.to;
+    }
+    if (current !== STORE_VERSION) {
+        writeUserVersion(database, STORE_VERSION);
+        current = STORE_VERSION;
+    }
+    return current;
+}
+//# sourceMappingURL=store-migrations.js.map

package/dist/utils/store-migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-migrations.js","sourceRoot":"","sources":["../../src/utils/store-migrations.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAmB9C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA8B,EAAE,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,QAAsB,EAAE,WAAmB;IAC5E,IAAI,OAAO,GAAG,WAAW,CAAC;IAE1B,KAAK,MAAM,SAAS,IAAI,gBAAgB,EAAE,CAAC;QACzC,IAAI,SAAS,CAAC,EAAE,IAAI,OAAO;YAAE,SAAS;QAEtC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,IAAI,CAAC;YACH,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAC1B,gBAAgB,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;YACzC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC1B,MAAM,KAAK,CAAC;QACd,CAAC;QACD,OAAO,GAAG,SAAS,CAAC,EAAE,CAAC;IACzB,CAAC;IAED,IAAI,OAAO,KAAK,aAAa,EAAE,CAAC;QAC9B,gBAAgB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QAC1C,OAAO,GAAG,aAAa,CAAC;IAC1B,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/utils/store-paths.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Every file the harvested store is made of.
+ *
+ * The only module that names `dataDir('store')`, so a later decision to shard
+ * the database by channel touches one file rather than every caller — the same
+ * reason `brain-paths.ts` exists.
+ *
+ * The `-wal` and `-shm` sidecars are created and removed by SQLite itself, not
+ * by us. They are the one place in this codebase where a file under the data
+ * directory is not written through `writeJsonAtomic`, and that exception is
+ * confined to the `store*.ts` modules.
+ */
+export declare function storeDir(): string;
+export declare function storeDatabasePath(): string;
+/**
+ * Where a database that failed its integrity check is moved to.
+ *
+ * Renamed rather than deleted: a harvest costs hours of network that no local
+ * cache can replay, so nothing here removes one without the user asking.
+ */
+export declare function corruptStorePath(at: number): string;
+/** Taken before a migration that would change an existing `user_version`. */
+export declare function preMigrationBackupPath(fromVersion: number): string;
+/**
+ * Job-level exclusion, which WAL does not provide.
+ *
+ * WAL keeps concurrent writes consistent; it does not stop two harvests of the
+ * same channel from spawning yt-dlp twice and doubling the request rate at the
+ * one thing that throttles us.
+ */
+export declare function channelHarvestLockPath(channelId: string): string;
+export declare function videoHarvestLockPath(videoId: string): string;
+//# sourceMappingURL=store-paths.d.ts.map

package/dist/utils/store-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-paths.d.ts","sourceRoot":"","sources":["../../src/utils/store-paths.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AAEH,wBAAgB,QAAQ,IAAI,MAAM,CAEjC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,6EAA6E;AAC7E,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D"}

package/dist/utils/store-paths.js

@@ -0,0 +1,48 @@
+import { join } from 'node:path';
+import { dataDir } from './paths.js';
+import { assertChannelId, assertVideoId } from './validate.js';
+/**
+ * Every file the harvested store is made of.
+ *
+ * The only module that names `dataDir('store')`, so a later decision to shard
+ * the database by channel touches one file rather than every caller — the same
+ * reason `brain-paths.ts` exists.
+ *
+ * The `-wal` and `-shm` sidecars are created and removed by SQLite itself, not
+ * by us. They are the one place in this codebase where a file under the data
+ * directory is not written through `writeJsonAtomic`, and that exception is
+ * confined to the `store*.ts` modules.
+ */
+export function storeDir() {
+    return dataDir('store');
+}
+export function storeDatabasePath() {
+    return join(storeDir(), 'knowledge.db');
+}
+/**
+ * Where a database that failed its integrity check is moved to.
+ *
+ * Renamed rather than deleted: a harvest costs hours of network that no local
+ * cache can replay, so nothing here removes one without the user asking.
+ */
+export function corruptStorePath(at) {
+    return join(storeDir(), `knowledge.corrupt-${String(at)}.db`);
+}
+/** Taken before a migration that would change an existing `user_version`. */
+export function preMigrationBackupPath(fromVersion) {
+    return join(storeDir(), `knowledge.pre-v${String(fromVersion)}.db`);
+}
+/**
+ * Job-level exclusion, which WAL does not provide.
+ *
+ * WAL keeps concurrent writes consistent; it does not stop two harvests of the
+ * same channel from spawning yt-dlp twice and doubling the request rate at the
+ * one thing that throttles us.
+ */
+export function channelHarvestLockPath(channelId) {
+    return join(storeDir(), `harvest.${assertChannelId(channelId)}.lock`);
+}
+export function videoHarvestLockPath(videoId) {
+    return join(storeDir(), `harvest.${assertVideoId(videoId)}.lock`);
+}
+//# sourceMappingURL=store-paths.js.map

package/dist/utils/store-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-paths.js","sourceRoot":"","sources":["../../src/utils/store-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;;;;;;;;GAWG;AAEH,MAAM,UAAU,QAAQ;IACtB,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC;AAC1B,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC/B,OAAO,IAAI,CAAC,QAAQ,EAAE,EAAE,cAAc,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAU;IACzC,OAAO,IAAI,CAAC,QAAQ,EAAE,EAAE,qBAAqB,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,sBAAsB,CAAC,WAAmB;IACxD,OAAO,IAAI,CAAC,QAAQ,EAAE,EAAE,kBAAkB,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,SAAiB;IACtD,OAAO,IAAI,CAAC,QAAQ,EAAE,EAAE,WAAW,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AACxE,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,OAAe;IAClD,OAAO,IAAI,CAAC,QAAQ,EAAE,EAAE,WAAW,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AACpE,CAAC"}

package/dist/utils/store-rows.d.ts

@@ -0,0 +1,22 @@
+import type { StatementSync } from 'node:sqlite';
+import { z } from 'zod';
+/**
+ * Reading rows back out of the store, validated.
+ *
+ * `StatementSync.all()` is typed `Record<string, SQLOutputValue>[]` — usefully
+ * honest, and unusable directly. Every read goes through a zod schema here,
+ * the same contract `readJsonFile` and `parseYtDlpJson` already apply to the
+ * other two places untyped data enters this server. No `as` anywhere.
+ */
+/**
+ * SQLite `STRICT` tables have no BOOLEAN, so flags are stored as 0 or 1.
+ * Decoded with an explicit transform rather than a cast, which also rejects a
+ * 2 that some future writer might smuggle in.
+ */
+export declare const sqliteBoolean: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>, boolean, 0 | 1>;
+export declare function queryRows<T extends z.ZodTypeAny>(statement: StatementSync, schema: T, ...params: readonly (string | number | null)[]): z.output<T>[];
+/** The single-row form. Returns undefined when the statement matched nothing. */
+export declare function queryRow<T extends z.ZodTypeAny>(statement: StatementSync, schema: T, ...params: readonly (string | number | null)[]): z.output<T> | undefined;
+/** `SELECT COUNT(*)` is the one query whose shape is always the same. */
+export declare function countRows(statement: StatementSync, ...params: readonly (string | number | null)[]): number;
+//# sourceMappingURL=store-rows.d.ts.map

package/dist/utils/store-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-rows.d.ts","sourceRoot":"","sources":["../../src/utils/store-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;GAOG;AAEH;;;;GAIG;AACH,eAAO,MAAM,aAAa,8EAEU,CAAC;AA8BrC,wBAAgB,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAC9C,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,CAAC,EACT,GAAG,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,EAAE,GAC7C,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAEf;AAED,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAC7C,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,CAAC,EACT,GAAG,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,EAAE,GAC7C,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAQzB;AAED,yEAAyE;AACzE,wBAAgB,SAAS,CACvB,SAAS,EAAE,aAAa,EACxB,GAAG,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,EAAE,GAC7C,MAAM,CAMR"}

package/dist/utils/store-rows.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { YouTubeError } from './errors.js';
+/**
+ * Reading rows back out of the store, validated.
+ *
+ * `StatementSync.all()` is typed `Record<string, SQLOutputValue>[]` — usefully
+ * honest, and unusable directly. Every read goes through a zod schema here,
+ * the same contract `readJsonFile` and `parseYtDlpJson` already apply to the
+ * other two places untyped data enters this server. No `as` anywhere.
+ */
+/**
+ * SQLite `STRICT` tables have no BOOLEAN, so flags are stored as 0 or 1.
+ * Decoded with an explicit transform rather than a cast, which also rejects a
+ * 2 that some future writer might smuggle in.
+ */
+export const sqliteBoolean = z
+    .union([z.literal(0), z.literal(1)])
+    .transform((value) => value === 1);
+function describe(error) {
+    return error.issues
+        .slice(0, 3)
+        .map((issue) => `${issue.path.join('.') || '(row)'}: ${issue.message}`)
+        .join('; ');
+}
+/**
+ * Runs a statement and validates every row.
+ *
+ * A row that does not match is a bug in this server, not something a caller
+ * can fix, so it fails loudly rather than being skipped — the opposite of
+ * `recordOfValid`, which drops a bad entry because there the bad entry came
+ * from YouTube.
+ */
+function parseAll(schema, rows) {
+    const parsed = z.array(schema).safeParse(rows);
+    if (parsed.success)
+        return parsed.data;
+    throw new YouTubeError('MALFORMED_RESPONSE', 'A row in the harvested store had an unexpected shape.', {
+        nextStep: `This is a bug in the server, not in your request. Details: ${describe(parsed.error)}`,
+    });
+}
+export function queryRows(statement, schema, ...params) {
+    return parseAll(schema, statement.all(...params));
+}
+/** The single-row form. Returns undefined when the statement matched nothing. */
+export function queryRow(statement, schema, ...params) {
+    const row = statement.get(...params);
+    if (row === undefined)
+        return undefined;
+    // Parsed through `z.array(schema)` rather than `schema` directly: a bare
+    // generic `safeParse` widens its result to `any`, which would let every
+    // later misuse through unchecked. This also shares one error message.
+    return parseAll(schema, [row])[0];
+}
+/** `SELECT COUNT(*)` is the one query whose shape is always the same. */
+export function countRows(statement, ...params) {
+    const row = queryRow(statement, z.object({}).passthrough(), ...params);
+    if (row === undefined)
+        return 0;
+    const first = Object.values(row)[0];
+    return typeof first === 'number' ? first : 0;
+}
+//# sourceMappingURL=store-rows.js.map

package/dist/utils/store-rows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-rows.js","sourceRoot":"","sources":["../../src/utils/store-rows.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;;;;GAOG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC;KAC3B,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACnC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;AAErC,SAAS,QAAQ,CAAC,KAAiB;IACjC,OAAO,KAAK,CAAC,MAAM;SAChB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;SACX,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,OAAO,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;SACtE,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,QAAQ,CAAyB,MAAS,EAAE,IAAe;IAClE,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC/C,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC;IAEvC,MAAM,IAAI,YAAY,CACpB,oBAAoB,EACpB,uDAAuD,EACvD;QACE,QAAQ,EAAE,8DAA8D,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;KACjG,CACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,SAAS,CACvB,SAAwB,EACxB,MAAS,EACT,GAAG,MAA2C;IAE9C,OAAO,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AACpD,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,QAAQ,CACtB,SAAwB,EACxB,MAAS,EACT,GAAG,MAA2C;IAE9C,MAAM,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;IACrC,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAExC,yEAAyE;IACzE,wEAAwE;IACxE,sEAAsE;IACtE,OAAO,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACpC,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,SAAS,CACvB,SAAwB,EACxB,GAAG,MAA2C;IAE9C,MAAM,GAAG,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,EAAE,GAAG,MAAM,CAAC,CAAC;IACvE,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,CAAC,CAAC;IAEhC,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/C,CAAC"}

package/dist/utils/store-schema.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The shape of the harvested store, as one reviewable unit.
+ *
+ * Kept apart from the module that opens the database so the schema can be read
+ * end to end without the connection handling in the way.
+ *
+ * `STRICT` on every table: SQLite's default type affinity would silently accept
+ * a string where a count belongs, and this store exists to make claims about
+ * counts. It has no BOOLEAN, so flags are 0/1 integers decoded explicitly on
+ * the way out (see store-rows.ts) rather than cast.
+ */
+/** Bumped only by a migration in store-migrations.ts. Independent of the server's semver. */
+export declare const STORE_VERSION = 1;
+export declare const STORE_PRAGMAS: readonly ["PRAGMA journal_mode = WAL", "PRAGMA synchronous = NORMAL", "PRAGMA foreign_keys = ON", "PRAGMA temp_store = MEMORY"];
+export declare const STORE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS meta (\n  key   TEXT PRIMARY KEY,\n  value TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS channel (\n  channel_id       TEXT PRIMARY KEY,\n  handle           TEXT    NOT NULL DEFAULT '',\n  name             TEXT    NOT NULL DEFAULT '',\n  channel_url      TEXT    NOT NULL DEFAULT '',\n  subscriber_count INTEGER,\n  description      TEXT    NOT NULL DEFAULT '',\n  avatar_url       TEXT,\n  banner_url       TEXT,\n  first_seen_at    INTEGER NOT NULL,\n  updated_at       INTEGER NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS video (\n  video_id      TEXT PRIMARY KEY,\n  channel_id    TEXT REFERENCES channel(channel_id) ON DELETE CASCADE,\n  title         TEXT    NOT NULL DEFAULT '',\n  duration_s    INTEGER,\n  -- 'YYYY-MM-DD'. NULL, never '', when a flat listing carried none: a date\n  -- filter must be able to tell \"not known yet\" from \"known to be empty\".\n  upload_date   TEXT,\n  view_count    INTEGER,\n  like_count    INTEGER,\n  -- YouTube's own claim, read WITHOUT --write-comments, which overwrites it\n  -- with the number extracted. This is the denominator every comment receipt\n  -- is measured against, so it may only ever come from a metadata pass.\n  comment_count INTEGER,\n  live_status   TEXT,\n  availability  TEXT,\n  thumbnail_url TEXT,\n  tab           TEXT,\n  also_in_tabs  TEXT    NOT NULL DEFAULT '[]',\n  catalog_rank  INTEGER,\n  listed_at     INTEGER,\n  detail_at     INTEGER,\n  -- Stripped before storage: formats, automatic_captions, subtitles,\n  -- thumbnails and comments are 96% of a raw -j payload and are mostly\n  -- expiring URLs. See MAX_DETAIL_JSON_BYTES.\n  detail_json   TEXT,\n  heatmap_json  TEXT\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS video_by_channel ON video(channel_id, catalog_rank);\nCREATE INDEX IF NOT EXISTS video_by_date    ON video(channel_id, upload_date DESC);\n\nCREATE TABLE IF NOT EXISTS comment (\n  comment_id         TEXT PRIMARY KEY,\n  video_id           TEXT    NOT NULL REFERENCES video(video_id) ON DELETE CASCADE,\n  -- NULL for a top-level comment. yt-dlp writes the string 'root'; normalising\n  -- it here means a reply count is a COUNT(parent_id) rather than a filter\n  -- everyone has to remember.\n  parent_id          TEXT,\n  text               TEXT    NOT NULL DEFAULT '',\n  like_count         INTEGER NOT NULL DEFAULT 0,\n  author             TEXT    NOT NULL DEFAULT '',\n  author_id          TEXT,\n  author_url         TEXT,\n  author_thumbnail   TEXT,\n  author_is_uploader INTEGER NOT NULL DEFAULT 0,\n  author_is_verified INTEGER NOT NULL DEFAULT 0,\n  is_pinned          INTEGER NOT NULL DEFAULT 0,\n  is_favorited       INTEGER NOT NULL DEFAULT 0,\n  time_text          TEXT,\n  published_at       INTEGER,\n  harvested_at       INTEGER NOT NULL\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS comment_by_video  ON comment(video_id, parent_id, like_count DESC);\nCREATE INDEX IF NOT EXISTS comment_by_parent ON comment(parent_id);\nCREATE INDEX IF NOT EXISTS comment_by_author ON comment(author_id);\nCREATE INDEX IF NOT EXISTS comment_by_time   ON comment(video_id, published_at);\n\nCREATE VIRTUAL TABLE IF NOT EXISTS comment_fts USING fts5(\n  text,\n  content       = 'comment',\n  content_rowid = 'rowid',\n  tokenize      = \"unicode61 remove_diacritics 2\"\n);\n\n-- Triggers rather than a periodic 'rebuild'. Measured: triggers cost 6.2x on\n-- bulk insert (2.3s vs 366ms per 200k rows) while 'rebuild' is O(whole table)\n-- and would take seconds per checkpoint at millions of rows. Against a network\n-- that delivers ~17 comments/second, the trigger cost is noise, and there is no\n-- \"did we remember to rebuild\" failure mode.\nCREATE TRIGGER IF NOT EXISTS comment_ai AFTER INSERT ON comment BEGIN\n  INSERT INTO comment_fts(rowid, text) VALUES (new.rowid, new.text);\nEND;\nCREATE TRIGGER IF NOT EXISTS comment_ad AFTER DELETE ON comment BEGIN\n  INSERT INTO comment_fts(comment_fts, rowid, text) VALUES ('delete', old.rowid, old.text);\nEND;\nCREATE TRIGGER IF NOT EXISTS comment_au AFTER UPDATE ON comment BEGIN\n  INSERT INTO comment_fts(comment_fts, rowid, text) VALUES ('delete', old.rowid, old.text);\n  INSERT INTO comment_fts(rowid, text) VALUES (new.rowid, new.text);\nEND;\n\n-- What this store can prove about one target. Written in the SAME transaction\n-- as the rows it describes, so there is no interval in which a receipt can\n-- claim something the store does not hold.\nCREATE TABLE IF NOT EXISTS harvest_receipt (\n  scope             TEXT    NOT NULL,\n  target_id         TEXT    NOT NULL,\n  state             TEXT    NOT NULL,\n  reason            TEXT    NOT NULL,\n  have              INTEGER NOT NULL DEFAULT 0,\n  -- What the SOURCE stated. NULL when it stated nothing; never derived from\n  -- 'have', which would turn \"we stopped\" into \"there was nothing more\".\n  expected          INTEGER,\n  expected_source   TEXT,\n  source            TEXT    NOT NULL,\n  limit_applied     INTEGER,\n  sort_applied      TEXT,\n  ran_to_exhaustion INTEGER,\n  resume_token      TEXT,\n  started_at        INTEGER NOT NULL,\n  finished_at       INTEGER,\n  attempts          INTEGER NOT NULL DEFAULT 0,\n  error_code        TEXT,\n  note              TEXT,\n  PRIMARY KEY (scope, target_id)\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS receipt_by_state ON harvest_receipt(state, finished_at DESC);\n\n-- Append-only audit trail: cheap, and it is what makes a receipt defensible\n-- after the fact rather than merely asserted.\nCREATE TABLE IF NOT EXISTS harvest_event (\n  event_id  INTEGER PRIMARY KEY AUTOINCREMENT,\n  scope     TEXT    NOT NULL,\n  target_id TEXT    NOT NULL,\n  at        INTEGER NOT NULL,\n  state     TEXT    NOT NULL,\n  delta     INTEGER NOT NULL DEFAULT 0,\n  note      TEXT\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS event_by_target ON harvest_event(scope, target_id, at DESC);\n";
+//# sourceMappingURL=store-schema.d.ts.map

package/dist/utils/store-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-schema.d.ts","sourceRoot":"","sources":["../../src/utils/store-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,6FAA6F;AAC7F,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,eAAO,MAAM,aAAa,iIAUhB,CAAC;AAEX,eAAO,MAAM,YAAY,0vLA8IxB,CAAC"}

package/dist/utils/store-schema.js

@@ -0,0 +1,168 @@
+/**
+ * The shape of the harvested store, as one reviewable unit.
+ *
+ * Kept apart from the module that opens the database so the schema can be read
+ * end to end without the connection handling in the way.
+ *
+ * `STRICT` on every table: SQLite's default type affinity would silently accept
+ * a string where a count belongs, and this store exists to make claims about
+ * counts. It has no BOOLEAN, so flags are 0/1 integers decoded explicitly on
+ * the way out (see store-rows.ts) rather than cast.
+ */
+/** Bumped only by a migration in store-migrations.ts. Independent of the server's semver. */
+export const STORE_VERSION = 1;
+export const STORE_PRAGMAS = [
+    // One writer and many readers across processes, which rollback journalling
+    // cannot do. Required for the "kill the server mid-harvest" guarantee.
+    'PRAGMA journal_mode = WAL',
+    // A crash loses at most the last committed transaction and can never corrupt
+    // the file. FULL would fsync per commit for a store whose worst case is
+    // re-fetching one video.
+    'PRAGMA synchronous = NORMAL',
+    'PRAGMA foreign_keys = ON',
+    'PRAGMA temp_store = MEMORY',
+];
+export const STORE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+) STRICT;
+
+CREATE TABLE IF NOT EXISTS channel (
+  channel_id       TEXT PRIMARY KEY,
+  handle           TEXT    NOT NULL DEFAULT '',
+  name             TEXT    NOT NULL DEFAULT '',
+  channel_url      TEXT    NOT NULL DEFAULT '',
+  subscriber_count INTEGER,
+  description      TEXT    NOT NULL DEFAULT '',
+  avatar_url       TEXT,
+  banner_url       TEXT,
+  first_seen_at    INTEGER NOT NULL,
+  updated_at       INTEGER NOT NULL
+) STRICT;
+
+CREATE TABLE IF NOT EXISTS video (
+  video_id      TEXT PRIMARY KEY,
+  channel_id    TEXT REFERENCES channel(channel_id) ON DELETE CASCADE,
+  title         TEXT    NOT NULL DEFAULT '',
+  duration_s    INTEGER,
+  -- 'YYYY-MM-DD'. NULL, never '', when a flat listing carried none: a date
+  -- filter must be able to tell "not known yet" from "known to be empty".
+  upload_date   TEXT,
+  view_count    INTEGER,
+  like_count    INTEGER,
+  -- YouTube's own claim, read WITHOUT --write-comments, which overwrites it
+  -- with the number extracted. This is the denominator every comment receipt
+  -- is measured against, so it may only ever come from a metadata pass.
+  comment_count INTEGER,
+  live_status   TEXT,
+  availability  TEXT,
+  thumbnail_url TEXT,
+  tab           TEXT,
+  also_in_tabs  TEXT    NOT NULL DEFAULT '[]',
+  catalog_rank  INTEGER,
+  listed_at     INTEGER,
+  detail_at     INTEGER,
+  -- Stripped before storage: formats, automatic_captions, subtitles,
+  -- thumbnails and comments are 96% of a raw -j payload and are mostly
+  -- expiring URLs. See MAX_DETAIL_JSON_BYTES.
+  detail_json   TEXT,
+  heatmap_json  TEXT
+) STRICT;
+
+CREATE INDEX IF NOT EXISTS video_by_channel ON video(channel_id, catalog_rank);
+CREATE INDEX IF NOT EXISTS video_by_date    ON video(channel_id, upload_date DESC);
+
+CREATE TABLE IF NOT EXISTS comment (
+  comment_id         TEXT PRIMARY KEY,
+  video_id           TEXT    NOT NULL REFERENCES video(video_id) ON DELETE CASCADE,
+  -- NULL for a top-level comment. yt-dlp writes the string 'root'; normalising
+  -- it here means a reply count is a COUNT(parent_id) rather than a filter
+  -- everyone has to remember.
+  parent_id          TEXT,
+  text               TEXT    NOT NULL DEFAULT '',
+  like_count         INTEGER NOT NULL DEFAULT 0,
+  author             TEXT    NOT NULL DEFAULT '',
+  author_id          TEXT,
+  author_url         TEXT,
+  author_thumbnail   TEXT,
+  author_is_uploader INTEGER NOT NULL DEFAULT 0,
+  author_is_verified INTEGER NOT NULL DEFAULT 0,
+  is_pinned          INTEGER NOT NULL DEFAULT 0,
+  is_favorited       INTEGER NOT NULL DEFAULT 0,
+  time_text          TEXT,
+  published_at       INTEGER,
+  harvested_at       INTEGER NOT NULL
+) STRICT;
+
+CREATE INDEX IF NOT EXISTS comment_by_video  ON comment(video_id, parent_id, like_count DESC);
+CREATE INDEX IF NOT EXISTS comment_by_parent ON comment(parent_id);
+CREATE INDEX IF NOT EXISTS comment_by_author ON comment(author_id);
+CREATE INDEX IF NOT EXISTS comment_by_time   ON comment(video_id, published_at);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS comment_fts USING fts5(
+  text,
+  content       = 'comment',
+  content_rowid = 'rowid',
+  tokenize      = "unicode61 remove_diacritics 2"
+);
+
+-- Triggers rather than a periodic 'rebuild'. Measured: triggers cost 6.2x on
+-- bulk insert (2.3s vs 366ms per 200k rows) while 'rebuild' is O(whole table)
+-- and would take seconds per checkpoint at millions of rows. Against a network
+-- that delivers ~17 comments/second, the trigger cost is noise, and there is no
+-- "did we remember to rebuild" failure mode.
+CREATE TRIGGER IF NOT EXISTS comment_ai AFTER INSERT ON comment BEGIN
+  INSERT INTO comment_fts(rowid, text) VALUES (new.rowid, new.text);
+END;
+CREATE TRIGGER IF NOT EXISTS comment_ad AFTER DELETE ON comment BEGIN
+  INSERT INTO comment_fts(comment_fts, rowid, text) VALUES ('delete', old.rowid, old.text);
+END;
+CREATE TRIGGER IF NOT EXISTS comment_au AFTER UPDATE ON comment BEGIN
+  INSERT INTO comment_fts(comment_fts, rowid, text) VALUES ('delete', old.rowid, old.text);
+  INSERT INTO comment_fts(rowid, text) VALUES (new.rowid, new.text);
+END;
+
+-- What this store can prove about one target. Written in the SAME transaction
+-- as the rows it describes, so there is no interval in which a receipt can
+-- claim something the store does not hold.
+CREATE TABLE IF NOT EXISTS harvest_receipt (
+  scope             TEXT    NOT NULL,
+  target_id         TEXT    NOT NULL,
+  state             TEXT    NOT NULL,
+  reason            TEXT    NOT NULL,
+  have              INTEGER NOT NULL DEFAULT 0,
+  -- What the SOURCE stated. NULL when it stated nothing; never derived from
+  -- 'have', which would turn "we stopped" into "there was nothing more".
+  expected          INTEGER,
+  expected_source   TEXT,
+  source            TEXT    NOT NULL,
+  limit_applied     INTEGER,
+  sort_applied      TEXT,
+  ran_to_exhaustion INTEGER,
+  resume_token      TEXT,
+  started_at        INTEGER NOT NULL,
+  finished_at       INTEGER,
+  attempts          INTEGER NOT NULL DEFAULT 0,
+  error_code        TEXT,
+  note              TEXT,
+  PRIMARY KEY (scope, target_id)
+) STRICT;
+
+CREATE INDEX IF NOT EXISTS receipt_by_state ON harvest_receipt(state, finished_at DESC);
+
+-- Append-only audit trail: cheap, and it is what makes a receipt defensible
+-- after the fact rather than merely asserted.
+CREATE TABLE IF NOT EXISTS harvest_event (
+  event_id  INTEGER PRIMARY KEY AUTOINCREMENT,
+  scope     TEXT    NOT NULL,
+  target_id TEXT    NOT NULL,
+  at        INTEGER NOT NULL,
+  state     TEXT    NOT NULL,
+  delta     INTEGER NOT NULL DEFAULT 0,
+  note      TEXT
+) STRICT;
+
+CREATE INDEX IF NOT EXISTS event_by_target ON harvest_event(scope, target_id, at DESC);
+`;
+//# sourceMappingURL=store-schema.js.map

package/dist/utils/store-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-schema.js","sourceRoot":"","sources":["../../src/utils/store-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,6FAA6F;AAC7F,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC;AAE/B,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,2EAA2E;IAC3E,uEAAuE;IACvE,2BAA2B;IAC3B,6EAA6E;IAC7E,wEAAwE;IACxE,yBAAyB;IACzB,6BAA6B;IAC7B,0BAA0B;IAC1B,4BAA4B;CACpB,CAAC;AAEX,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8I3B,CAAC"}

package/dist/utils/store.d.ts

@@ -0,0 +1,34 @@
+import type { DatabaseSync } from 'node:sqlite';
+/**
+ * The one connection to the harvested store.
+ *
+ * `node:sqlite` is a runtime builtin, so this adds nothing to package.json —
+ * the same category as `node:fs`. It is reached through a dynamic import
+ * behind an async accessor so that a Node without it still loads every module
+ * and still serves the tools that do not touch the store; only the harvest
+ * tools fail, with a sentence naming the version to install.
+ *
+ * The reason for a database rather than more JSON files is transactional
+ * receipts. `brain-build.ts` carries a long comment explaining that its
+ * manifest and its chunks are two documents, only one can be written first,
+ * and a crash in between strands a brain. Here the rows and the receipt that
+ * describes them commit together, so that failure is not representable.
+ */
+/** The exact Node where `node:sqlite` is unflagged and `StatementSync.iterate()` exists. */
+export declare const MIN_NODE_VERSION = "22.13.0";
+export declare function readUserVersion(database: DatabaseSync): number;
+export declare function writeUserVersion(database: DatabaseSync, version: number): void;
+/** The process-wide store connection, opened on first use. */
+export declare function getStore(): Promise<DatabaseSync>;
+export declare function closeStore(): void;
+/**
+ * Moves a damaged database aside and starts a fresh one.
+ *
+ * Renames rather than deletes. Unlike `search-index.json`, which is derivable
+ * and is correctly rebuilt from disk, a harvest costs hours of network that no
+ * local cache can replay — so nothing here removes one without being asked.
+ */
+export declare function quarantineStore(now?: number): Promise<string>;
+/** Runs `work` in a transaction, rolling back if it throws. */
+export declare function inTransaction<T>(database: DatabaseSync, work: () => T): T;
+//# sourceMappingURL=store.d.ts.map

package/dist/utils/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/utils/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAQhD;;;;;;;;;;;;;;GAcG;AAEH,4FAA4F;AAC5F,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAsG1C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAI9D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAI9E;AAED,8DAA8D;AAC9D,wBAAsB,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC,CAGtD;AAED,wBAAgB,UAAU,IAAI,IAAI,CAGjC;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,GAAG,SAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAKvE;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAUzE"}

package/dist/utils/store.js

@@ -0,0 +1,157 @@
+import { chmod, rename } from 'node:fs/promises';
+import { YouTubeError } from './errors.js';
+import { ensurePrivateDir } from './paths.js';
+import { corruptStorePath, storeDatabasePath, storeDir } from './store-paths.js';
+import { STORE_PRAGMAS, STORE_SCHEMA, STORE_VERSION } from './store-schema.js';
+import { runStoreMigrations } from './store-migrations.js';
+/**
+ * The one connection to the harvested store.
+ *
+ * `node:sqlite` is a runtime builtin, so this adds nothing to package.json —
+ * the same category as `node:fs`. It is reached through a dynamic import
+ * behind an async accessor so that a Node without it still loads every module
+ * and still serves the tools that do not touch the store; only the harvest
+ * tools fail, with a sentence naming the version to install.
+ *
+ * The reason for a database rather than more JSON files is transactional
+ * receipts. `brain-build.ts` carries a long comment explaining that its
+ * manifest and its chunks are two documents, only one can be written first,
+ * and a crash in between strands a brain. Here the rows and the receipt that
+ * describes them commit together, so that failure is not representable.
+ */
+/** The exact Node where `node:sqlite` is unflagged and `StatementSync.iterate()` exists. */
+export const MIN_NODE_VERSION = '22.13.0';
+const BUSY_TIMEOUT_MS = 5_000;
+const PRIVATE_FILE_MODE = 0o600;
+let db;
+let warningFilterInstalled = false;
+/**
+ * Silence only Node's own "SQLite is experimental" notice.
+ *
+ * It goes to stderr, so it cannot corrupt the stdio protocol, but it is noise
+ * in every client's log. Matched on both the name and the message so that an
+ * unrelated ExperimentalWarning still reaches whoever was listening for it.
+ *
+ * Only listeners registered before the first store open are wrapped — which is
+ * the one that matters, Node's own default printer. A listener added later
+ * sees every warning, including this one, and that is the right trade: this
+ * exists to quieten a default, not to hide a warning from someone who went
+ * looking for it.
+ */
+function installWarningFilter() {
+    if (warningFilterInstalled)
+        return;
+    warningFilterInstalled = true;
+    const existing = process.listeners('warning');
+    for (const listener of existing)
+        process.removeListener('warning', listener);
+    process.on('warning', (warning) => {
+        if (warning.name === 'ExperimentalWarning' && warning.message.includes('SQLite'))
+            return;
+        for (const listener of existing)
+            listener(warning);
+    });
+}
+async function loadSqlite() {
+    try {
+        installWarningFilter();
+        // Annotated rather than inferred: a bare dynamic import widens to `any`,
+        // which would let every later misuse of the module through unchecked.
+        const sqlite = await import('node:sqlite');
+        return sqlite;
+    }
+    catch {
+        throw new YouTubeError('STORE_UNAVAILABLE', 'This Node build has no node:sqlite, which the harvest tools need.', {
+            nextStep: `Install Node ${MIN_NODE_VERSION} or newer (this process is ${process.version}). Every other tool works without it.`,
+        });
+    }
+}
+function isCorruption(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /malformed|not a database|SQLITE_CORRUPT|SQLITE_NOTADB/i.test(message);
+}
+function assertUsableVersion(found) {
+    if (found <= STORE_VERSION)
+        return;
+    // Operating on a schema written by a newer server is how data gets
+    // destroyed. Refusing is the only safe move, and naming both versions is
+    // what makes the refusal actionable.
+    throw new YouTubeError('STORE_CORRUPT', `This store was written by a newer version of the server (store v${String(found)}; this build understands v${String(STORE_VERSION)}).`, { nextStep: 'Upgrade youtube-knowledge-mcp, or point HOME at a different data directory.' });
+}
+async function openDatabase() {
+    const sqlite = await loadSqlite();
+    await ensurePrivateDir(storeDir());
+    const path = storeDatabasePath();
+    let opened;
+    try {
+        opened = new sqlite.DatabaseSync(path, {
+            timeout: BUSY_TIMEOUT_MS,
+            enableForeignKeyConstraints: true,
+        });
+        for (const pragma of STORE_PRAGMAS)
+            opened.exec(pragma);
+    }
+    catch (error) {
+        if (!isCorruption(error))
+            throw error;
+        throw new YouTubeError('STORE_CORRUPT', 'The harvested store could not be opened.', {
+            nextStep: 'Call repair_store to move the damaged file aside and start a fresh store.',
+            cause: error,
+        });
+    }
+    const version = readUserVersion(opened);
+    assertUsableVersion(version);
+    opened.exec(STORE_SCHEMA);
+    runStoreMigrations(opened, version);
+    // The database holds harvested personal data — commenter names, ids and
+    // free text — so it gets the same bits as the transcript cache rather than
+    // the umask default.
+    await chmod(path, PRIVATE_FILE_MODE).catch(() => undefined);
+    return opened;
+}
+export function readUserVersion(database) {
+    const row = database.prepare('PRAGMA user_version').get();
+    const value = row?.user_version;
+    return typeof value === 'number' ? value : 0;
+}
+export function writeUserVersion(database, version) {
+    // PRAGMA does not accept a bound parameter, so the value is constrained to an
+    // integer here rather than interpolated from anything a caller controls.
+    database.exec(`PRAGMA user_version = ${String(Math.trunc(version))}`);
+}
+/** The process-wide store connection, opened on first use. */
+export async function getStore() {
+    db ??= await openDatabase();
+    return db;
+}
+export function closeStore() {
+    db?.close();
+    db = undefined;
+}
+/**
+ * Moves a damaged database aside and starts a fresh one.
+ *
+ * Renames rather than deletes. Unlike `search-index.json`, which is derivable
+ * and is correctly rebuilt from disk, a harvest costs hours of network that no
+ * local cache can replay — so nothing here removes one without being asked.
+ */
+export async function quarantineStore(now = Date.now()) {
+    closeStore();
+    const target = corruptStorePath(now);
+    await rename(storeDatabasePath(), target);
+    return target;
+}
+/** Runs `work` in a transaction, rolling back if it throws. */
+export function inTransaction(database, work) {
+    database.exec('BEGIN');
+    try {
+        const result = work();
+        database.exec('COMMIT');
+        return result;
+    }
+    catch (error) {
+        database.exec('ROLLBACK');
+        throw error;
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/utils/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../src/utils/store.ts"],"names":[],"mappings":"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"}