cli-community-intelligence 0.1.5

package/dist/index.js

@@ -0,0 +1,844 @@
+// src/corpus-db.js
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+
+// ../functional/src/lookup-table.js
+var LookupTable = (items, ItemType, idField = "id") => {
+  const addNonEnumerable = (target, key, value) => Object.defineProperty(target, key, { value, enumerable: false });
+  const validateTypes = () => {
+    if (!ItemType || !ItemType.is) {
+      console.error(`You must pass a tagged Type when creating a LookupTable`);
+      return;
+    }
+    if (items.every((item) => ItemType.is(item))) return;
+    const found = JSON.stringify(items);
+    const w = `Expected each item passed to LookupTable to be a(n) '${ItemType.toString()}'; found ${found}.`;
+    console.error(w);
+  };
+  if (!Array.isArray(items)) items = Object.values(items);
+  validateTypes();
+  const array = Array.from(items);
+  items.forEach((o) => addNonEnumerable(array, o[idField], o));
+  addNonEnumerable(array, "ItemType", ItemType);
+  addNonEnumerable(array, "idField", idField);
+  Object.setPrototypeOf(array, LookupTablePrototype);
+  return array;
+};
+LookupTable.is = (o) => !!o?.idField;
+var LookupTablePrototype = Object.create(Array.prototype);
+LookupTablePrototype.get = function(key) {
+  return this[key];
+};
+LookupTablePrototype.getById = function(key) {
+  return this[key];
+};
+LookupTablePrototype.elementHavingSameIdAsItem = function(item) {
+  const id = item[this.idField];
+  return this[id];
+};
+LookupTablePrototype.hasItemEqualTo = function(item) {
+  return equals_default(this.elementHavingSameIdAsItem(item), item);
+};
+LookupTablePrototype.includesWithId = function(id) {
+  return this.some((item) => item.id === id);
+};
+LookupTablePrototype.filter = function(predicate) {
+  return LookupTable(Array.prototype.filter.call(this, predicate), this.ItemType, this.idField);
+};
+LookupTablePrototype.sort = function(sortFunc) {
+  return LookupTable(Array.prototype.sort.call(Array.from(this), sortFunc), this.ItemType, this.idField);
+};
+LookupTablePrototype.prepend = function(o) {
+  return LookupTable([o, ...this], this.ItemType, this.idField);
+};
+LookupTablePrototype.addItem = function(item, sort) {
+  if (this.hasItemEqualTo(item)) return this;
+  const newItems = [...this, item];
+  if (sort) Array.prototype.sort.call(newItems, sort);
+  return LookupTable(newItems, this.ItemType, this.idField);
+};
+LookupTablePrototype.addItemWithId = function(item, sort) {
+  if (this.hasItemEqualTo(item)) return this;
+  const oldItem = this.elementHavingSameIdAsItem(item);
+  let newItems;
+  if (oldItem) newItems = this.map((existingItem) => existingItem === oldItem ? item : existingItem);
+  else newItems = [...this, item];
+  if (sort) Array.prototype.sort.call(newItems, sort);
+  return LookupTable(newItems, this.ItemType, this.idField);
+};
+LookupTablePrototype.removeItem = function(item) {
+  if (!this.elementHavingSameIdAsItem(item)) return this;
+  return LookupTable(without_default(item, this), this.ItemType, this.idField);
+};
+LookupTablePrototype.removeItemWithId = function(id) {
+  const item = this[id];
+  if (!item) return this;
+  return LookupTable(without_default(item, this), this.ItemType, this.idField);
+};
+LookupTablePrototype.toggleItem = function(item, sort) {
+  const hasItem = this.elementHavingSameIdAsItem(item) === item;
+  return hasItem ? this.removeItem(item) : this.addItem(item, sort);
+};
+LookupTablePrototype.pick = function(ids) {
+  const subset = ids.map((id) => this[id]);
+  return LookupTable(subset, this.ItemType, this.idField);
+};
+LookupTablePrototype.moveElement = function(fromIndex, toIndex) {
+  if (fromIndex < 0 || fromIndex >= this.length || toIndex < 0 || toIndex >= this.length) return this;
+  const newArray = [...this];
+  const [item] = newArray.splice(fromIndex, 1);
+  newArray.splice(toIndex, 0, item);
+  return LookupTable(newArray, this.ItemType, this.idField);
+};
+LookupTablePrototype.updateAll = function(fn) {
+  return LookupTable(Array.prototype.map.call(this, fn), this.ItemType, this.idField);
+};
+LookupTablePrototype.updateWhere = function(predicate, fn) {
+  const updated = Array.prototype.map.call(this, (item) => predicate(item) ? fn(item) : item);
+  return LookupTable(updated, this.ItemType, this.idField);
+};
+LookupTablePrototype.idForItem = function(item) {
+  return item[this.idField];
+};
+var lookup_table_default = LookupTable;
+
+// ../functional/src/ramda-like/keys.js
+var keys = (obj) => Object(obj) !== obj ? [] : Object.keys(obj);
+var keys_default = keys;
+
+// ../functional/src/ramda-like/type.js
+var type = (val) => val === null ? "Null" : val === void 0 ? "Undefined" : Object.prototype.toString.call(val).slice(8, -1);
+var type_default = type;
+
+// ../functional/src/ramda-like/equals.js
+var _has = (prop, obj) => Object.prototype.hasOwnProperty.call(obj, prop);
+var _functionName = (f) => {
+  const match2 = String(f).match(/^function (\w*)/);
+  return match2 == null ? "" : match2[1];
+};
+var _arrayFromIterator = (iterator) => {
+  const result = [];
+  let next;
+  while (!(next = iterator.next()).done) result.push(next.value);
+  return result;
+};
+var _includesWith = (f, x, list) => {
+  const len = list.length;
+  for (let i = 0; i < len; i++) if (f(x, list[i])) return true;
+  return false;
+};
+var _uniqContentEquals = (aIterator, bIterator, stackA, stackB) => {
+  const a = _arrayFromIterator(aIterator);
+  const b = _arrayFromIterator(bIterator);
+  const eq = (_a, _b) => _equals(_a, _b, stackA.slice(), stackB.slice());
+  return !_includesWith((b2, aItem) => !_includesWith(eq, aItem, b2), b, a);
+};
+function _equals(a, b, stackA, stackB) {
+  if (Object.is(a, b)) return true;
+  const typeA = type_default(a);
+  if (typeA !== type_default(b)) return false;
+  if (a == null || b == null) return false;
+  if (typeof a.equals === "function" || typeof b.equals === "function")
+    return typeof a.equals === "function" && a.equals(b) && typeof b.equals === "function" && b.equals(a);
+  switch (typeA) {
+    case "Arguments":
+    case "Array":
+    case "Object":
+      if (typeof a.constructor === "function" && _functionName(a.constructor) === "Promise") return a === b;
+      break;
+    case "Boolean":
+    case "Number":
+    case "String":
+      if (!(typeof a === typeof b && Object.is(a.valueOf(), b.valueOf()))) return false;
+      break;
+    case "Date":
+      if (!Object.is(a.valueOf(), b.valueOf())) return false;
+      break;
+    case "Error":
+      return a.name === b.name && a.message === b.message;
+    case "RegExp":
+      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode))
+        return false;
+      break;
+  }
+  for (let i = stackA.length - 1; i >= 0; i--) if (stackA[i] === a) return stackB[i] === b;
+  switch (typeA) {
+    case "Map":
+      if (a.size !== b.size) return false;
+      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));
+    case "Set":
+      if (a.size !== b.size) return false;
+      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));
+    case "Arguments":
+    case "Array":
+    case "Object":
+    case "Boolean":
+    case "Number":
+    case "String":
+    case "Date":
+    case "Error":
+    case "RegExp":
+    case "Int8Array":
+    case "Uint8Array":
+    case "Uint8ClampedArray":
+    case "Int16Array":
+    case "Uint16Array":
+    case "Int32Array":
+    case "Uint32Array":
+    case "Float32Array":
+    case "Float64Array":
+    case "ArrayBuffer":
+      break;
+    default:
+      return false;
+  }
+  const keysA = keys_default(a);
+  if (keysA.length !== keys_default(b).length) return false;
+  const extendedStackA = stackA.concat([a]);
+  const extendedStackB = stackB.concat([b]);
+  for (let i = keysA.length - 1; i >= 0; i--) {
+    const key = keysA[i];
+    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) return false;
+  }
+  return true;
+}
+var equals = (a, b) => _equals(a, b, [], []);
+var equals_default = equals;
+
+// ../functional/src/ramda-like/pick.js
+var pick = function pick2(names, o) {
+  const result = {};
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i];
+    if (name in o) result[name] = o[name];
+  }
+  return result;
+};
+var pick_default = pick;
+
+// ../functional/src/ramda-like/memoize-redux-state.js
+var memoizeReduxState = (keys2, f) => {
+  const stateMatches = (state) => {
+    if (keys2.length === 0) return state === previousState;
+    return keys2.every((key) => state[key] === previousState[key]);
+  };
+  let previousState = {};
+  let previousArgsStringified;
+  let previousValue;
+  return (state, ...args) => {
+    const newArgsStringified = JSON.stringify(args);
+    if (stateMatches(state) && newArgsStringified === previousArgsStringified) return previousValue;
+    previousState = pick_default(keys2, state);
+    previousArgsStringified = newArgsStringified;
+    previousValue = f(state, ...args);
+    return previousValue;
+  };
+};
+var memoizeReduxStatePerKey = (globalKeys, keyedStateKey, f) => {
+  const globalStateChanged = (state) => (
+    // eslint-disable-next-line no-restricted-syntax -- memoizer must access state directly
+    globalKeys.some((key) => state[key] !== previousGlobalState[key])
+  );
+  const cacheByKey = /* @__PURE__ */ new Map();
+  let previousGlobalState = {};
+  return (state, key, ...rest) => {
+    const keyedState = state[keyedStateKey];
+    const keyedValue = keyedState?.get ? keyedState.get(key) : keyedState?.[key];
+    if (globalStateChanged(state)) {
+      cacheByKey.clear();
+      previousGlobalState = pick_default(globalKeys, state);
+    }
+    const cached = cacheByKey.get(key);
+    const { keyedValue: cachedKeyed, restStringified: cachedRest, value: cachedValue } = cached || {};
+    const cheapHit = cached && cachedKeyed === keyedValue;
+    const restMatch = cheapHit && (rest.length > 0 ? JSON.stringify(rest) : "") === cachedRest;
+    if (restMatch) return cachedValue;
+    const value = f(state, key, ...rest);
+    const restStringified = rest.length > 0 ? JSON.stringify(rest) : "";
+    cacheByKey.set(key, { keyedValue, restStringified, value });
+    return value;
+  };
+};
+var MemoizeReduxState = { memoizeReduxState, memoizeReduxStatePerKey };
+
+// ../functional/src/ramda-like/list.js
+var reject = (f, a) => a.filter((a2) => !f(a2));
+
+// ../functional/src/ramda-like/without.js
+var without = (toBeRemoved, list) => {
+  if (!Array.isArray(toBeRemoved)) toBeRemoved = [toBeRemoved];
+  return reject((o) => toBeRemoved.includes(o), list);
+};
+var without_default = without;
+
+// ../functional/index.js
+var { memoizeReduxState: memoizeReduxState2, memoizeReduxStatePerKey: memoizeReduxStatePerKey2 } = MemoizeReduxState;
+
+// ../cli-type-generator/runtime-for-generated-types.js
+var match = (tagNames) => {
+  const validateVariants = (variants) => {
+    const missing = tagNames.find((variant) => !variants[variant]);
+    if (missing) throw new TypeError(`Constructors given to match didn't include: ${missing}`);
+  };
+  return function(variants) {
+    validateVariants(variants);
+    const variant = variants[this["@@tagName"]];
+    return variant.call(variants, this);
+  };
+};
+var _toString = (value) => {
+  if (typeof value === "undefined") return "undefined";
+  if (value === null) return "null";
+  if (value["@@typeName"]) return value.toString();
+  if (Array.isArray(value)) return "[" + value.map((item) => _toString(item)).join(", ") + "]";
+  if (typeof value === "string") return '"' + value + '"';
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof RegExp) return value.toString();
+  if (typeof value === "object") return JSON.stringify(value);
+  return value;
+};
+var lookupTableToFirestore = (Type, idField, encodeTimestamps, lookupTable) => {
+  const itemToFirestoreEntry = (item, index) => [
+    item[idField],
+    { ...Type.toFirestore(item, encodeTimestamps), _order: index }
+  ];
+  return Object.fromEntries(lookupTable.map(itemToFirestoreEntry));
+};
+var lookupTableFromFirestore = (Type, idField, decodeTimestamps, o) => {
+  const firestoreItemToDomain = (item) => {
+    const { _order, ...rest } = item;
+    return Type.fromFirestore(rest, decodeTimestamps);
+  };
+  return lookup_table_default(
+    Object.values(o || {}).sort((a, b) => (a._order ?? 0) - (b._order ?? 0)).map(firestoreItemToDomain),
+    Type,
+    idField
+  );
+};
+var validateArgumentLength = (constructorName, expectedCount, args) => {
+  if (args.length === expectedCount) return;
+  debugger;
+  const message = `In constructor ${constructorName}: expected ${expectedCount} arguments, found ${args.length}`;
+  throw new TypeError(message);
+};
+var validateRegex = (constructorName, regex, field, optional, s) => {
+  validateString(constructorName, field, optional, s);
+  if (optional && (s === void 0 || s === null)) return;
+  if (s.match(regex)) return;
+  debugger;
+  const message = `In constructor ${constructorName}: expected ${field} to match ${regex}; found ${_toString(s)})`;
+  throw new TypeError(message);
+};
+var validateNumber = (constructorName, field, optional, n) => {
+  if (optional && (n === void 0 || n === null)) return;
+  if (typeof n === "number") return;
+  debugger;
+  const message = `In constructor ${constructorName}: expected ${field} to have type Number; found ${_toString(n)})`;
+  throw new TypeError(message);
+};
+var validateString = (constructorName, field, optional, s) => {
+  if (optional && (s === void 0 || s === null)) return;
+  if (typeof s === "string") return;
+  debugger;
+  const message = `In constructor ${constructorName}: expected ${field} to have type String; found ${_toString(s)})`;
+  throw new TypeError(message);
+};
+var validateObject = (constructorName, field, optional, o) => {
+  if (optional && (o === void 0 || o === null)) return;
+  if (typeof o === "object" && o !== null) return;
+  debugger;
+  const message = `In constructor ${constructorName}: expected ${field} to have type Object; found ${_toString(o)})`;
+  throw new TypeError(message);
+};
+var validateDate = (constructorName, field, optional, d) => {
+  if (optional && (d === void 0 || d === null)) return;
+  if (d instanceof Date) return;
+  debugger;
+  const message = `In constructor ${constructorName}: expected ${field} to have type Date; found ${_toString(d)})`;
+  throw new TypeError(message);
+};
+var validateBoolean = (constructorName, field, optional, b) => {
+  if (optional && (b === void 0 || b === null)) return;
+  if (typeof b === "boolean") return;
+  debugger;
+  const message = `In constructor ${constructorName}: expected ${field} to have type Boolean; found ${_toString(b)})`;
+  throw new TypeError(message);
+};
+var validateTag = (constructorName, expectedType, field, optional, o) => {
+  if (optional && (o === void 0 || o === null)) return;
+  if (o?.["@@typeName"] === expectedType) return;
+  debugger;
+  const found = _toString(o);
+  const message = `In constructor ${constructorName}: expected ${field} to have type ${expectedType}; found ${found}`;
+  throw new TypeError(message);
+};
+var validateArray = (constructorName, arrayDepth, baseType, taggedType, field, optional, a) => {
+  const repeatCharacter = (char, n) => Array(n).fill(char).join("");
+  const buildNestedTypeString = () => repeatCharacter("[", arrayDepth) + (taggedType ?? baseType) + repeatCharacter("]", arrayDepth);
+  const checkArrayAtDepth = (value, currentDepth) => {
+    if (!Array.isArray(value)) return { valid: false, element: void 0 };
+    if (value.length === 0) return { valid: true, element: void 0, empty: true };
+    if (currentDepth + 1 >= arrayDepth) return { valid: true, element: value[0] };
+    return checkArrayAtDepth(value[0], currentDepth + 1);
+  };
+  const isValidBaseType = (element2) => {
+    if (baseType === "String") return typeof element2 === "string";
+    if (baseType === "Number") return typeof element2 === "number";
+    if (baseType === "Object") return typeof element2 === "object";
+    if (baseType === "Date") return element2 instanceof Date;
+    if (baseType === "Any") return true;
+    if (baseType === "Tagged") return element2?.["@@typeName"] === taggedType;
+    return false;
+  };
+  if (optional && (a === void 0 || a === null)) return;
+  const { valid, empty, element } = checkArrayAtDepth(a, 0);
+  const nestedType = buildNestedTypeString();
+  const found = _toString(a);
+  const prefix = `In constructor ${constructorName}`;
+  const expected = `expected ${field} to have type ${nestedType}`;
+  if (!valid) {
+    debugger;
+    throw new TypeError(`${prefix}: ${expected}; found ${found}`);
+  }
+  if (empty) return;
+  if (isValidBaseType(element)) return;
+  debugger;
+  throw new TypeError(`${prefix}: ${expected}; found ${found}`);
+};
+var validateLookupTable = (constructorName, expectedItemType, field, optional, lt) => {
+  if (optional && (lt === void 0 || lt === null)) return;
+  if (!lt || typeof lt !== "object" || !lt.idField) {
+    debugger;
+    const found = _toString(lt);
+    const message = `In constructor ${constructorName}: expected ${field} to be a LookupTable; found ${found}`;
+    throw new TypeError(message);
+  }
+  if (lt.length === 0) return;
+  const firstItem = lt[0];
+  if (firstItem?.["@@typeName"] === expectedItemType) return;
+  debugger;
+  const actualType = firstItem?.["@@typeName"] || "unknown";
+  const expected = `a LookupTable<${expectedItemType}>`;
+  const actual = `LookupTable<${actualType}>`;
+  throw new TypeError(`In constructor ${constructorName}: expected ${field} to be ${expected}; found ${actual}`);
+};
+var piiRedactions = {
+  email: (v) => v.replace(/(.).*(@.*)/, "$1***$2"),
+  displayName: (v) => v.replace(/\b(\w)\w*/g, "$1***"),
+  phoneNumber: (v) => v.replace(/(\+?\d{1,3}[-.\s]?)?(\(?\d{3}\)?[-.\s]?)(\d{3}[-.\s]?)(\d{4})/, "***-***-$4")
+};
+var redact = (value) => {
+  const hasPii = (v) => {
+    const fieldHasPii = (fieldValue) => {
+      if (Array.isArray(fieldValue)) return fieldValue.some(hasPii);
+      if (typeof fieldValue === "object") return hasPii(fieldValue);
+      return false;
+    };
+    if (v === void 0 || v === null) return false;
+    const hasDirectPii = Object.keys(piiRedactions).some((field) => v[field] && typeof v[field] === "string");
+    if (hasDirectPii) return true;
+    return Object.values(v).some(fieldHasPii);
+  };
+  const redactField = (k, v) => {
+    if (piiRedactions[k] && typeof v === "string") return piiRedactions[k](v);
+    if (v?.["@@typeName"]) return redact(v);
+    if (lookup_table_default.is(v)) return lookup_table_default(v.map(redact), v.ItemType, v.idField);
+    if (Array.isArray(v) && v[0]?.["@@typeName"]) return v.map(redact);
+    return v;
+  };
+  const markAsRedacted = (obj) => {
+    Object.defineProperty(obj, "__redacted", {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+    return obj;
+  };
+  if (value?.__redacted) return value;
+  if (!value?.["@@typeName"]) return value;
+  if (!hasPii(value)) return markAsRedacted(value);
+  const redactedObject = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactField(k, v)]));
+  const constructor = Object.getPrototypeOf(value).constructor;
+  return markAsRedacted(constructor.from(redactedObject));
+};
+var parseTaggedValue = (plain, variantMap) => {
+  if (plain === void 0 || plain === null) return plain;
+  const tagName = plain["@@tagName"];
+  if (!tagName) throw new TypeError(`parseTaggedValue: missing @@tagName on ${_toString(plain)}`);
+  const Constructor = variantMap[tagName];
+  if (!Constructor)
+    throw new TypeError(
+      `parseTaggedValue: unknown variant '${tagName}' (known: ${Object.keys(variantMap).join(", ")})`
+    );
+  return Constructor._from(plain);
+};
+var RuntimeForGeneratedTypes = {
+  validateArgumentLength,
+  validateArray,
+  validateBoolean,
+  validateDate,
+  validateNumber,
+  validateObject,
+  validateString,
+  validateTag,
+  validateRegex,
+  validateLookupTable,
+  lookupTableToFirestore,
+  lookupTableFromFirestore,
+  match,
+  _toString,
+  redact,
+  parseTaggedValue
+};
+
+// src/types/post.js
+var Post = function Post2(source, sourceId, channel, author, title, body, parentId, url, score, createdAt, postType) {
+  const constructorName = "Post(source, sourceId, channel, author, title, body, parentId, url, score, createdAt, postType)";
+  RuntimeForGeneratedTypes.validateString(constructorName, "source", false, source);
+  RuntimeForGeneratedTypes.validateString(constructorName, "sourceId", false, sourceId);
+  RuntimeForGeneratedTypes.validateString(constructorName, "channel", false, channel);
+  RuntimeForGeneratedTypes.validateString(constructorName, "author", true, author);
+  RuntimeForGeneratedTypes.validateString(constructorName, "title", true, title);
+  RuntimeForGeneratedTypes.validateString(constructorName, "body", false, body);
+  RuntimeForGeneratedTypes.validateString(constructorName, "parentId", true, parentId);
+  RuntimeForGeneratedTypes.validateString(constructorName, "url", true, url);
+  RuntimeForGeneratedTypes.validateNumber(constructorName, "score", true, score);
+  RuntimeForGeneratedTypes.validateString(constructorName, "createdAt", false, createdAt);
+  RuntimeForGeneratedTypes.validateRegex(constructorName, /^(post|comment)$/, "postType", false, postType);
+  const result = Object.create(prototype);
+  result.source = source;
+  result.sourceId = sourceId;
+  result.channel = channel;
+  if (author !== void 0) result.author = author;
+  if (title !== void 0) result.title = title;
+  result.body = body;
+  if (parentId !== void 0) result.parentId = parentId;
+  if (url !== void 0) result.url = url;
+  if (score !== void 0) result.score = score;
+  result.createdAt = createdAt;
+  result.postType = postType;
+  return result;
+};
+var postToString = function() {
+  return `Post(${RuntimeForGeneratedTypes._toString(this.source)},
+        ${RuntimeForGeneratedTypes._toString(this.sourceId)},
+        ${RuntimeForGeneratedTypes._toString(this.channel)},
+        ${RuntimeForGeneratedTypes._toString(this.author)},
+        ${RuntimeForGeneratedTypes._toString(this.title)},
+        ${RuntimeForGeneratedTypes._toString(this.body)},
+        ${RuntimeForGeneratedTypes._toString(this.parentId)},
+        ${RuntimeForGeneratedTypes._toString(this.url)},
+        ${RuntimeForGeneratedTypes._toString(this.score)},
+        ${RuntimeForGeneratedTypes._toString(this.createdAt)},
+        ${RuntimeForGeneratedTypes._toString(this.postType)})`;
+};
+var postToJSON = function() {
+  return this;
+};
+var prototype = Object.create(Object.prototype, {
+  "@@typeName": { value: "Post", enumerable: false },
+  toString: { value: postToString, enumerable: false },
+  toJSON: { value: postToJSON, enumerable: false },
+  constructor: { value: Post, enumerable: false, writable: true, configurable: true }
+});
+Post.prototype = prototype;
+Post.toString = () => "Post";
+Post.is = (v) => v && v["@@typeName"] === "Post";
+Post._from = (_input) => {
+  const { source, sourceId, channel, author, title, body, parentId, url, score, createdAt, postType } = _input;
+  return Post(source, sourceId, channel, author, title, body, parentId, url, score, createdAt, postType);
+};
+Post.from = Post._from;
+Post.fromJSON = (json) => json == null ? json : Post._from(json);
+
+// src/types/revisit-reason.js
+var RevisitReason = { toString: () => "RevisitReason" };
+Object.defineProperty(RevisitReason, "@@typeName", { value: "RevisitReason", enumerable: false });
+Object.defineProperty(RevisitReason, "@@tagNames", { value: ["Recent", "HighScore", "HasMore"], enumerable: false });
+var RevisitReasonPrototype = {};
+Object.defineProperty(RevisitReasonPrototype, "match", {
+  value: RuntimeForGeneratedTypes.match(RevisitReason["@@tagNames"]),
+  enumerable: false
+});
+Object.defineProperty(RevisitReasonPrototype, "constructor", {
+  value: RevisitReason,
+  enumerable: false,
+  writable: true,
+  configurable: true
+});
+RevisitReason.prototype = RevisitReasonPrototype;
+var toString = {
+  recent: function() {
+    return `RevisitReason.Recent()`;
+  },
+  highScore: function() {
+    return `RevisitReason.HighScore()`;
+  },
+  hasMore: function() {
+    return `RevisitReason.HasMore()`;
+  }
+};
+var toJSON = {
+  recent: function() {
+    return Object.assign({ "@@tagName": this["@@tagName"] }, this);
+  },
+  highScore: function() {
+    return Object.assign({ "@@tagName": this["@@tagName"] }, this);
+  },
+  hasMore: function() {
+    return Object.assign({ "@@tagName": this["@@tagName"] }, this);
+  }
+};
+var RecentConstructor = function Recent() {
+  const constructorName = "RevisitReason.Recent()";
+  RuntimeForGeneratedTypes.validateArgumentLength(constructorName, 0, arguments);
+  const result = Object.create(RecentPrototype);
+  return result;
+};
+RevisitReason.Recent = RecentConstructor;
+var HighScoreConstructor = function HighScore() {
+  const constructorName = "RevisitReason.HighScore()";
+  RuntimeForGeneratedTypes.validateArgumentLength(constructorName, 0, arguments);
+  const result = Object.create(HighScorePrototype);
+  return result;
+};
+RevisitReason.HighScore = HighScoreConstructor;
+var HasMoreConstructor = function HasMore() {
+  const constructorName = "RevisitReason.HasMore()";
+  RuntimeForGeneratedTypes.validateArgumentLength(constructorName, 0, arguments);
+  const result = Object.create(HasMorePrototype);
+  return result;
+};
+RevisitReason.HasMore = HasMoreConstructor;
+var RecentPrototype = Object.create(RevisitReasonPrototype, {
+  "@@tagName": { value: "Recent", enumerable: false },
+  "@@typeName": { value: "RevisitReason", enumerable: false },
+  toString: { value: toString.recent, enumerable: false },
+  toJSON: { value: toJSON.recent, enumerable: false },
+  constructor: { value: RecentConstructor, enumerable: false, writable: true, configurable: true }
+});
+var HighScorePrototype = Object.create(RevisitReasonPrototype, {
+  "@@tagName": { value: "HighScore", enumerable: false },
+  "@@typeName": { value: "RevisitReason", enumerable: false },
+  toString: { value: toString.highScore, enumerable: false },
+  toJSON: { value: toJSON.highScore, enumerable: false },
+  constructor: { value: HighScoreConstructor, enumerable: false, writable: true, configurable: true }
+});
+var HasMorePrototype = Object.create(RevisitReasonPrototype, {
+  "@@tagName": { value: "HasMore", enumerable: false },
+  "@@typeName": { value: "RevisitReason", enumerable: false },
+  toString: { value: toString.hasMore, enumerable: false },
+  toJSON: { value: toJSON.hasMore, enumerable: false },
+  constructor: { value: HasMoreConstructor, enumerable: false, writable: true, configurable: true }
+});
+RecentConstructor.prototype = RecentPrototype;
+HighScoreConstructor.prototype = HighScorePrototype;
+HasMoreConstructor.prototype = HasMorePrototype;
+RecentConstructor.is = (val) => val != null && typeof val === "object" && val["@@tagName"] === "Recent";
+HighScoreConstructor.is = (val) => val != null && typeof val === "object" && val["@@tagName"] === "HighScore";
+HasMoreConstructor.is = (val) => val != null && typeof val === "object" && val["@@tagName"] === "HasMore";
+RecentConstructor.toString = () => "RevisitReason.Recent";
+HighScoreConstructor.toString = () => "RevisitReason.HighScore";
+HasMoreConstructor.toString = () => "RevisitReason.HasMore";
+RecentConstructor._from = (_input) => RevisitReason.Recent();
+HighScoreConstructor._from = (_input) => RevisitReason.HighScore();
+HasMoreConstructor._from = (_input) => RevisitReason.HasMore();
+RecentConstructor.from = RecentConstructor._from;
+HighScoreConstructor.from = HighScoreConstructor._from;
+HasMoreConstructor.from = HasMoreConstructor._from;
+RevisitReason.is = (v) => v != null && typeof v === "object" && v["@@typeName"] === "RevisitReason";
+RevisitReason.fromJSON = (json) => {
+  if (json == null) return json;
+  const tag = json["@@tagName"];
+  if (!tag) throw new TypeError(`RevisitReason.fromJSON: missing @@tagName on ${RuntimeForGeneratedTypes._toString(json)}`);
+  if (!RevisitReason["@@tagNames"].includes(tag))
+    throw new TypeError(`RevisitReason.fromJSON: unknown variant "${tag}"`);
+  return RevisitReason[tag]._from(json);
+};
+
+// src/corpus-db.js
+var T = {
+  // Convert a Post Tagged type to a row object for SQLite insertion
+  // @sig toRow :: Post -> Object
+  toRow: ({ source, sourceId, channel, author, title, body, parentId, url, score, createdAt, postType }) => ({
+    source,
+    sourceId,
+    channel,
+    author,
+    title,
+    body,
+    parentId,
+    url,
+    score,
+    createdAt,
+    postType
+  }),
+  // Accumulate source counts from query rows into an object
+  // @sig toSourceCounts :: ([Object]) -> Object
+  toSourceCounts: (rows) => rows.reduce((acc, row) => ({ ...acc, [row.source]: row.count }), {}),
+  // Convert a RevisitReason TaggedSum to its database text representation
+  // @sig toReasonText :: RevisitReason -> String
+  toReasonText: (reason) => reason.match({ Recent: () => "recent", HighScore: () => "high_score", HasMore: () => "has_more" }),
+  // Convert a database reason text to a RevisitReason TaggedSum
+  // @sig toRevisitReason :: String -> RevisitReason
+  toRevisitReason: (text) => {
+    if (text === "recent") return RevisitReason.Recent();
+    if (text === "high_score") return RevisitReason.HighScore();
+    if (text === "has_more") return RevisitReason.HasMore();
+    throw new Error(`Unknown revisit reason: ${text}`);
+  },
+  // Convert a revisit_queue row to a domain object with RevisitReason TaggedSum
+  // @sig toQueueEntry :: Object -> Object
+  toQueueEntry: (row) => ({ ...row, reason: T.toRevisitReason(row.reason) })
+};
+var F = {
+  // Prepare the upsert statement — inserts new posts, updates score/scrapedAt on conflict
+  // @sig buildUpsertStmt :: Database -> Statement
+  buildUpsertStmt: (db) => db.prepare(upsertSql),
+  // Prepare the scrape run insert statement
+  // @sig buildScrapeRunStmt :: Database -> Statement
+  buildScrapeRunStmt: (db) => db.prepare(scrapeRunSql),
+  // Prepare the revisit queue upsert statement
+  // WHY: one entry per post — reason upgrades (most specific wins) but never downgrades
+  // @sig buildEnqueueStmt :: Database -> Statement
+  buildEnqueueStmt: (db) => db.prepare(enqueueSql)
+};
+var A = {
+  // Count truly new inserts within a transaction (upserts that update don't count)
+  // WHY: ON CONFLICT DO UPDATE reports changes=1 for both insert and update,
+  // so we compare total row count before/after to get actual insert count
+  // @sig countInserted :: (Database, Statement, [Object]) -> Number
+  countInserted: (db, stmt, rows) => {
+    const before = db.prepare("SELECT COUNT(*) as c FROM posts").get().c;
+    rows.forEach((row) => stmt.run(row));
+    const after = db.prepare("SELECT COUNT(*) as c FROM posts").get().c;
+    return after - before;
+  }
+};
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var schemaPath = resolve(__dirname, "../schema.sql");
+var defaultDbPath = resolve(homedir(), ".community-intelligence", "corpus.db");
+var upsertColumns = "source, sourceId, channel, author, title, body, parentId, url, score, createdAt, postType";
+var upsertParams = "@source, @sourceId, @channel, @author, @title, @body, @parentId, @url, @score, @createdAt, @postType";
+var upsertSql = `INSERT INTO posts (${upsertColumns}) VALUES (${upsertParams})
+    ON CONFLICT(source, sourceId) DO UPDATE SET score = excluded.score, scrapedAt = datetime('now')`;
+var scrapeRunColumns = "source, channel, startedAt, completedAt, postsFound, postsInserted, commentsFound, commentsInserted";
+var scrapeRunParams = "@source, @channel, @startedAt, @completedAt, @postsFound, @postsInserted, @commentsFound, @commentsInserted";
+var scrapeRunSql = `INSERT INTO scrape_runs (${scrapeRunColumns}) VALUES (${scrapeRunParams})`;
+var enqueueSql = `INSERT INTO revisit_queue (source, sourceId, reason, moreCount)
+    VALUES (@source, @sourceId, @reason, @moreCount)
+    ON CONFLICT(source, sourceId) DO UPDATE SET
+        reason = CASE
+            WHEN excluded.reason = 'has_more' THEN 'has_more'
+            WHEN excluded.reason = 'high_score' AND revisit_queue.reason != 'has_more' THEN 'high_score'
+            ELSE revisit_queue.reason
+        END,
+        moreCount = CASE
+            WHEN excluded.moreCount > revisit_queue.moreCount THEN excluded.moreCount
+            ELSE revisit_queue.moreCount
+        END`;
+var topChannelsSql = "SELECT channel, source, COUNT(*) as count FROM posts GROUP BY channel, source ORDER BY count DESC LIMIT 10";
+var createDb = (dbPath) => {
+  const resolvedPath = dbPath || defaultDbPath;
+  const dir = dirname(resolvedPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const db = Database(resolvedPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(readFileSync(schemaPath, "utf-8"));
+  return db;
+};
+var persistPost = (db, post) => F.buildUpsertStmt(db).run(T.toRow(post));
+var persistPosts = (db, posts) => {
+  const stmt = F.buildUpsertStmt(db);
+  const runAll = db.transaction((rows) => A.countInserted(db, stmt, rows));
+  return runAll(posts.map(T.toRow));
+};
+var persistScrapeRun = (db, run) => F.buildScrapeRunStmt(db).run(run);
+var persistRevisitEntry = (db, { source, sourceId, reason, moreCount }) => F.buildEnqueueStmt(db).run({ source, sourceId, reason: T.toReasonText(reason), moreCount: moreCount || 0 });
+var queryRevisitQueue = (db, source, channel) => {
+  const sql = channel ? `SELECT rq.* FROM revisit_queue rq JOIN posts p ON rq.source = p.source AND rq.sourceId = p.sourceId
+           WHERE rq.source = ? AND p.channel = ?` : "SELECT * FROM revisit_queue WHERE source = ?";
+  const params = channel ? [source, channel] : [source];
+  return db.prepare(sql).all(...params).map(T.toQueueEntry);
+};
+var updateQueueEntry = (db, { source, sourceId, unchangedCount, lastCheckedAt }) => db.prepare("UPDATE revisit_queue SET unchangedCount = ?, lastCheckedAt = ? WHERE source = ? AND sourceId = ?").run(unchangedCount, lastCheckedAt, source, sourceId);
+var removeFromQueue = (db, source, sourceId) => db.prepare("DELETE FROM revisit_queue WHERE source = ? AND sourceId = ?").run(source, sourceId);
+var queryPostBySourceId = (db, source, sourceId) => db.prepare("SELECT * FROM posts WHERE source = ? AND sourceId = ?").get(source, sourceId);
+var countChildPosts = (db, parentId) => db.prepare("SELECT COUNT(*) as c FROM posts WHERE parentId = ?").get(parentId).c;
+var queryScrapeRuns = (db, source, channel, limit) => {
+  const sql = channel ? "SELECT * FROM scrape_runs WHERE source = ? AND channel = ? ORDER BY completedAt DESC LIMIT ?" : "SELECT * FROM scrape_runs WHERE source = ? ORDER BY completedAt DESC LIMIT ?";
+  const params = channel ? [source, channel, limit || 10] : [source, limit || 10];
+  return db.prepare(sql).all(...params);
+};
+var queryLastCreatedAt = (db, source, channel) => {
+  const row = db.prepare("SELECT MAX(createdAt) as maxCreatedAt FROM posts WHERE source = ? AND channel = ?").get(source, channel);
+  return row?.maxCreatedAt ?? void 0;
+};
+var queryStatus = (db) => {
+  const totalRow = db.prepare("SELECT COUNT(*) as total FROM posts").get();
+  const dateRange = db.prepare("SELECT MIN(createdAt) as earliest, MAX(createdAt) as latest FROM posts").get();
+  const countRows = db.prepare("SELECT source, COUNT(*) as count FROM posts GROUP BY source").all();
+  const bySource = T.toSourceCounts(countRows);
+  const topChannels = db.prepare(topChannelsSql).all();
+  return { total: totalRow.total, earliest: dateRange.earliest, latest: dateRange.latest, bySource, topChannels };
+};
+var queryPosts = (db, { source, channel, text, author, since, until, minScore, limit } = {}) => {
+  const conditions = [];
+  const params = [];
+  if (source) {
+    conditions.push("source = ?");
+    params.push(source);
+  }
+  if (channel) {
+    conditions.push("channel = ?");
+    params.push(channel);
+  }
+  if (text) {
+    conditions.push("(body LIKE ? OR title LIKE ?)");
+    params.push(`%${text}%`, `%${text}%`);
+  }
+  if (author) {
+    conditions.push("author = ?");
+    params.push(author);
+  }
+  if (since) {
+    conditions.push("createdAt >= ?");
+    params.push(since);
+  }
+  if (until) {
+    conditions.push("createdAt <= ?");
+    params.push(until);
+  }
+  if (minScore !== void 0) {
+    conditions.push("score >= ?");
+    params.push(minScore);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limitClause = limit ? "LIMIT ?" : "";
+  if (limit) params.push(Number(limit));
+  const sql = `SELECT * FROM posts ${where} ORDER BY createdAt DESC ${limitClause}`;
+  return db.prepare(sql).all(...params);
+};
+var CorpusDb = {
+  createDb,
+  persistPost,
+  persistPosts,
+  persistScrapeRun,
+  persistRevisitEntry,
+  queryLastCreatedAt,
+  queryStatus,
+  queryPosts,
+  queryPostBySourceId,
+  queryRevisitQueue,
+  queryScrapeRuns,
+  updateQueueEntry,
+  removeFromQueue,
+  countChildPosts
+};
+export {
+  CorpusDb
+};