@davesheffer/hunch 1.31.1 → 1.32.0

package/dist/store/compact.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Record compaction (bounds unbounded Hunch growth). Auto-captured drafts
+ * accumulate forever; `hunch compact` prunes the LOW-VALUE ones — never an
+ * accepted/human-confirmed decision, never an open bug, never a constraint
+ * (invariants are sacred), and never a record another record still points to.
+ *
+ * planCompaction is PURE (takes `now`) so it is fully testable; the CLI supplies
+ * Date.now(). Reference safety uses a greatest-fixpoint so records being pruned in
+ * the same pass don't keep each other (or a cycle of dead drafts) alive.
+ */
+import type { Bug, Constraint, Decision, EntityKind } from "../core/types.js";
+export interface CompactionCandidate {
+    kind: EntityKind;
+    id: string;
+    title: string;
+    reason: string;
+}
+export interface CompactionPlan {
+    remove: CompactionCandidate[];
+    /** how many records were considered (decisions + bugs). */
+    considered: number;
+}
+export interface CompactionInput {
+    decisions: Decision[];
+    bugs: Bug[];
+    constraints: Constraint[];
+}
+export interface CompactionOpts {
+    now: number;
+    maxAgeDays?: number;
+    minConfidence?: number;
+}
+export declare function planCompaction(input: CompactionInput, opts: CompactionOpts): CompactionPlan;

package/dist/store/db.d.ts

@@ -0,0 +1,9 @@
+export type DB = import("node:sqlite").DatabaseSync;
+export declare function openDb(sqlitePath: string): DB;
+/** In-memory db (tests / ephemeral queries). */
+export declare function openMemoryDb(options?: {
+    forcePlainSearch?: boolean;
+}): DB;
+/** Run `fn` inside one transaction: BEGIN → fn → COMMIT, ROLLBACK on throw.
+ *  (node:sqlite has no better-sqlite3-style transaction() helper.) */
+export declare function withTx<T>(db: DB, fn: () => T): T;

package/dist/store/embedder.d.ts

@@ -0,0 +1,32 @@
+export interface Embedder {
+    /** Embed each text → an L2-normalized Float32Array of length `dim`. */
+    embed(texts: string[]): Promise<Float32Array[]>;
+    readonly dim: number;
+    /** Stable id; also the `embeddings.model` key, so vectors from different models
+     *  never get compared. */
+    readonly id: string;
+}
+export declare class TransformersEmbedder implements Embedder {
+    readonly dim = 384;
+    readonly id = "all-MiniLM-L6-v2";
+    private extractor;
+    private load;
+    embed(texts: string[]): Promise<Float32Array[]>;
+}
+/** Deterministic, dependency-free embedder for tests (no model download).
+ *  Bag-of-token-hashes → L2-normalized vector: shared tokens ⇒ similar vectors,
+ *  enough to exercise hybrid ranking without semantics. Intentionally returns
+ *  SUBARRAY VIEWS into one backing buffer, so any caller that fails to copy
+ *  tightly before persisting will corrupt data — that keeps the BLOB round-trip
+ *  honest. */
+export declare class StubEmbedder implements Embedder {
+    readonly dim: number;
+    readonly id = "stub-v1";
+    constructor(dim?: number);
+    embed(texts: string[]): Promise<Float32Array[]>;
+}
+/** Choose an embedder, or null to signal "no semantic search → use pure FTS".
+ *  Never throws. `HUNCH_EMBEDDER=stub` forces the test stub; `=none` forces the
+ *  null (FTS-only) path; otherwise use the local model iff its optional dep is
+ *  installed. */
+export declare function selectEmbedder(): Promise<Embedder | null>;