hippo-memory 1.69.0 → 1.71.0

package/dist/store/compactions.d.ts

@@ -0,0 +1,78 @@
+import type { DatabaseSyncLike } from '../db/index.js';
+export type CompactionStatus = 'started' | 'summarised' | 'done' | 'no-summary';
+export interface CompactionRow {
+    tenant_id: string;
+    id: string;
+    session_id: string;
+    origin_project: string;
+    compact_trigger: string | null;
+    cwd: string | null;
+    transcript_path: string | null;
+    snapshot_saved: number;
+    started_at: string;
+    summarised_at: string | null;
+    summary: string | null;
+    items_json: string | null;
+    items_written: number;
+    status: CompactionStatus;
+}
+export interface HeldMemoryRow {
+    id: string;
+    source_session_id: string | null;
+    content: string;
+}
+export interface StartedCompactionInput {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly originProject: string;
+    readonly trigger: string | null;
+    readonly cwd: string | null;
+    readonly transcriptPath: string | null;
+    readonly startedAt: string;
+}
+export interface SummarisedUpdate {
+    readonly summary: string;
+    readonly itemsJson: string;
+    readonly summarisedAt: string;
+    readonly requestId?: string;
+}
+export interface SummarisedInsert extends SummarisedUpdate {
+    readonly id: string;
+}
+export type SummarisedInsertMeta = Omit<StartedCompactionInput, 'id'>;
+/** A session's newest row, as an array of at most one. */
+export declare function latestCompactionRows(db: DatabaseSyncLike, tenantId: string, sessionId: string): CompactionRow[];
+export declare function compactionRowsByRequest(db: DatabaseSyncLike, tenantId: string, requestId: string): CompactionRow[];
+/** The session's newest `started` row with a start in [`notBefore`, `notAfter`], both ISO strings. */
+export declare function latestStartedRows(db: DatabaseSyncLike, tenantId: string, sessionId: string, notAfter: string, notBefore: string): CompactionRow[];
+/** `summarised` rows whose summary is older than `summarisedBefore`, an ISO string. */
+export declare function stalledSummarisedRows(db: DatabaseSyncLike, tenantId: string, summarisedBefore: string): CompactionRow[];
+/** `started` rows with a transcript whose start lies between `startedAfter` and `startedBefore`, oldest first. */
+export declare function openTranscriptRows(db: DatabaseSyncLike, tenantId: string, startedBefore: string, startedAfter: string): CompactionRow[];
+export declare function insertStartedCompaction(db: DatabaseSyncLike, tenantId: string, start: StartedCompactionInput): void;
+/** Moves a `started` row to `summarised`; false when another process already moved it. */
+export declare function markCompactionSummarised(db: DatabaseSyncLike, tenantId: string, id: string, update: SummarisedUpdate): boolean;
+export declare function insertSummarisedCompaction(db: DatabaseSyncLike, tenantId: string, meta: SummarisedInsertMeta, row: SummarisedInsert): void;
+export declare function markSnapshotSavedRow(db: DatabaseSyncLike, tenantId: string, recordId: string): void;
+export declare function compactionProgress(db: DatabaseSyncLike, tenantId: string, id: string): {
+    status: CompactionStatus;
+    items_written: number;
+} | undefined;
+export declare function markCompactionDone(db: DatabaseSyncLike, tenantId: string, id: string, itemsWritten: number): void;
+/** Rows changed: 1 when the `started` row was closed, 0 when it had already moved. */
+export declare function closeStartedWithoutSummary(db: DatabaseSyncLike, tenantId: string, id: string): number;
+export declare function nextCompactionStart(db: DatabaseSyncLike, tenantId: string, sessionId: string, after: string): string | null;
+/** Live rows of one tenant and origin set that default recall shows. */
+export declare function heldMemoryRows(db: DatabaseSyncLike, tenantId: string, origins: readonly string[]): HeldMemoryRow[];
+export declare function restampCompactionOrigin(db: DatabaseSyncLike, tenantId: string, from: string, into: string): number;
+export declare function compactionTranscripts(db: DatabaseSyncLike, tenantId: string): Array<{
+    transcript: string;
+    cwd: string | null;
+}>;
+export declare function compactionOriginsWithCwd(db: DatabaseSyncLike, tenantId: string): Array<{
+    origin: string;
+    cwd: string;
+}>;
+/** True when `table` holds a row of this tenant under the project name. */
+export declare function holdsOrigin(db: DatabaseSyncLike, table: 'memories' | 'compactions', tenantId: string, name: string): boolean;
+//# sourceMappingURL=compactions.d.ts.map

package/dist/store/compactions.js

@@ -0,0 +1,93 @@
+import { originInSql } from '../core/project-identity.js';
+import { scopeAdmitSql } from './recall-scope.js';
+const COLUMNS = 'tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, snapshot_saved, started_at, summarised_at, summary, items_json, items_written, status';
+function selectRows(db, where, ...params) {
+    // SAFETY: the SELECT names exactly COLUMNS, matching CompactionRow's field set.
+    return db.prepare(`SELECT ${COLUMNS} FROM compactions WHERE ${where}`).all(...params);
+}
+/** A session's newest row, as an array of at most one. */
+export function latestCompactionRows(db, tenantId, sessionId) {
+    return selectRows(db, 'tenant_id = ? AND session_id = ? ORDER BY started_at DESC, id DESC LIMIT 1', tenantId, sessionId);
+}
+export function compactionRowsByRequest(db, tenantId, requestId) {
+    return selectRows(db, 'tenant_id = ? AND request_id = ?', tenantId, requestId);
+}
+/** The session's newest `started` row with a start in [`notBefore`, `notAfter`], both ISO strings. */
+export function latestStartedRows(db, tenantId, sessionId, notAfter, notBefore) {
+    return selectRows(db, `tenant_id = ? AND session_id = ? AND status = 'started' AND started_at <= ? AND started_at >= ? ORDER BY started_at DESC, id DESC LIMIT 1`, tenantId, sessionId, notAfter, notBefore);
+}
+/** `summarised` rows whose summary is older than `summarisedBefore`, an ISO string. */
+export function stalledSummarisedRows(db, tenantId, summarisedBefore) {
+    return selectRows(db, `tenant_id = ? AND status = 'summarised' AND summarised_at < ?`, tenantId, summarisedBefore);
+}
+/** `started` rows with a transcript whose start lies between `startedAfter` and `startedBefore`, oldest first. */
+export function openTranscriptRows(db, tenantId, startedBefore, startedAfter) {
+    return selectRows(db, `tenant_id = ? AND status = 'started' AND started_at < ? AND started_at > ? AND transcript_path IS NOT NULL ORDER BY started_at`, tenantId, startedBefore, startedAfter);
+}
+export function insertStartedCompaction(db, tenantId, start) {
+    db.prepare(`INSERT INTO compactions(tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, started_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(tenantId, start.id, start.sessionId, start.originProject, start.trigger, start.cwd, start.transcriptPath, start.startedAt);
+}
+/** Moves a `started` row to `summarised`; false when another process already moved it. */
+export function markCompactionSummarised(db, tenantId, id, update) {
+    const { summary, itemsJson, summarisedAt, requestId } = update;
+    // Only a caller names the column, so a store from before it was added still takes local writes.
+    const stamp = requestId === undefined ? [] : [requestId];
+    const result = db.prepare(`UPDATE compactions SET summary = ?, items_json = ?, summarised_at = ?, status = 'summarised'${stamp.length === 0 ? '' : ', request_id = ?'}
+     WHERE tenant_id = ? AND id = ? AND status = 'started'`).run(summary, itemsJson, summarisedAt, ...stamp, tenantId, id);
+    return (result.changes ?? 0) > 0;
+}
+export function insertSummarisedCompaction(db, tenantId, meta, row) {
+    const { id, summary, itemsJson, summarisedAt, requestId } = row;
+    // Only a caller names the column, so a store from before it was added still takes local writes.
+    const stamp = requestId === undefined ? [] : [requestId];
+    const [col, mark] = stamp.length === 0 ? ['', ''] : [', request_id', ', ?'];
+    db.prepare(`INSERT INTO compactions(tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, started_at, summarised_at, summary, items_json, status${col})
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'summarised'${mark})`).run(tenantId, id, meta.sessionId, meta.originProject, meta.trigger, meta.cwd, meta.transcriptPath, meta.startedAt, summarisedAt, summary, itemsJson, ...stamp);
+}
+export function markSnapshotSavedRow(db, tenantId, recordId) {
+    db.prepare(`UPDATE compactions SET snapshot_saved = 1 WHERE tenant_id = ? AND id = ?`).run(tenantId, recordId);
+}
+export function compactionProgress(db, tenantId, id) {
+    return db.prepare(`SELECT status, items_written FROM compactions WHERE tenant_id = ? AND id = ?`)
+        .get(tenantId, id);
+}
+export function markCompactionDone(db, tenantId, id, itemsWritten) {
+    db.prepare(`UPDATE compactions SET items_written = ?, status = 'done' WHERE tenant_id = ? AND id = ?`).run(itemsWritten, tenantId, id);
+}
+/** Rows changed: 1 when the `started` row was closed, 0 when it had already moved. */
+export function closeStartedWithoutSummary(db, tenantId, id) {
+    const result = db.prepare(`UPDATE compactions SET status = 'no-summary' WHERE tenant_id = ? AND id = ? AND status = 'started'`).run(tenantId, id);
+    return Number(result.changes ?? 0);
+}
+export function nextCompactionStart(db, tenantId, sessionId, after) {
+    const row = db.prepare(`SELECT MIN(started_at) AS at FROM compactions WHERE tenant_id = ? AND session_id = ? AND started_at > ?`)
+        .get(tenantId, sessionId, after);
+    return row?.at ?? null;
+}
+/** Live rows of one tenant and origin set that default recall shows. */
+export function heldMemoryRows(db, tenantId, origins) {
+    const deny = scopeAdmitSql('');
+    // SAFETY: the SELECT names the id, source_session_id and content columns.
+    return db.prepare(`SELECT id, source_session_id, content FROM memories WHERE tenant_id = ? AND ${originInSql(origins)} AND superseded_by IS NULL AND kind != 'raw'
+       AND ${deny.sql}`).all(tenantId, ...origins, ...deny.params);
+}
+export function restampCompactionOrigin(db, tenantId, from, into) {
+    return Number(db.prepare(`UPDATE compactions SET origin_project = ? WHERE tenant_id = ? AND origin_project = ?`)
+        .run(into, tenantId, from).changes ?? 0);
+}
+export function compactionTranscripts(db, tenantId) {
+    // SAFETY: the SELECT names the two columns of the row type.
+    return db.prepare(`SELECT DISTINCT transcript_path AS transcript, cwd FROM compactions WHERE tenant_id = ? AND transcript_path IS NOT NULL`)
+        .all(tenantId);
+}
+export function compactionOriginsWithCwd(db, tenantId) {
+    // SAFETY: the SELECT names the two columns of the row type.
+    return db.prepare(`SELECT DISTINCT origin_project AS origin, cwd FROM compactions WHERE tenant_id = ? AND origin_project <> '' AND cwd IS NOT NULL`)
+        .all(tenantId);
+}
+/** True when `table` holds a row of this tenant under the project name. */
+export function holdsOrigin(db, table, tenantId, name) {
+    return db.prepare(`SELECT 1 FROM ${table} WHERE tenant_id = ? AND origin_project = ? LIMIT 1`).get(tenantId, name) !== undefined;
+}
+//# sourceMappingURL=compactions.js.map

package/dist/store/conflicts.d.ts

@@ -1,6 +1,16 @@
-import { type DatabaseSyncLike } from '../db.js';
+import { type DatabaseSyncLike } from '../db/index.js';
+import type { MemoryEntry } from '../core/memory.js';
 import { type MemoryConflict } from './rows.js';
 export declare function listMemoryConflicts(hippoRoot: string, status?: string, tenantId?: string): MemoryConflict[];
+/** How many open conflicts listMemoryConflicts returns for a tenant, without loading one. */
+export declare function countOpenConflicts(hippoRoot: string, tenantId: string): number;
+/** One open conflict of a memory, with the row on its other side. */
+export interface OpenConflictOf {
+    conflict: MemoryConflict;
+    other: MemoryEntry;
+}
+/** A tenant's open conflicts naming `memoryId`, in listMemoryConflicts' order, each with its other member read in one batch. */
+export declare function loadOpenConflictsOf(hippoRoot: string, tenantId: string, memoryId: string): OpenConflictOf[];
 /** Conflicts whose two rows `actor` may both touch; someone else's personal row hides its whole pair. */
 export declare function listTouchableConflicts(hippoRoot: string, status: string, tenantId: string, actor: {
     owner?: string;
@@ -13,20 +23,12 @@ type DetectedConflict = {
 };
 type SameTenant = (a: string, b: string) => boolean;
 export declare function replaceDetectedConflicts(hippoRoot: string, detected: Array<DetectedConflict>, detectedAt?: string): void;
-/** Every memory's tenant, and each stored conflicts_with_json other than '[]', read before the refresh takes the write lock. */
+/** The tenant of every memory the refresh can compare, and each stored conflicts_with_json other than '[]', read before the refresh takes the write lock. */
 export interface ConflictRefreshReads {
     sameTenant: SameTenant;
     storedRefs: ReadonlyMap<string, string | null>;
 }
-/** The refresh's read of the whole memories table, kept out of the write lock because it grows with the store. */
-export declare function readConflictRefresh(db: DatabaseSyncLike): ConflictRefreshReads;
-/** Under the write lock: the memory_conflicts rows, then each memory whose refs change; returns the ids it rewrote. */
-export declare function writeConflictRefresh(db: DatabaseSyncLike, reads: ConflictRefreshReads, detected: readonly DetectedConflict[], detectedAt: string): string[];
-/**
- * AT1 (plan §5): additive-optional opts for resolveConflict.
- * `rejectLoserValue` implies removal of the loser regardless of
- * `forgetLoser` — you cannot tombstone a value and leave it live.
- */
+/** `rejectLoserValue` implies removal of the loser regardless of `forgetLoser`: a tombstoned value cannot stay live. */
 export interface ResolveConflictOpts {
     /** Tombstone the loser's normalized digest + kind-aware remove it. */
     rejectLoserValue?: boolean;
@@ -36,24 +38,22 @@ export interface ResolveConflictOpts {
      *  loser is kind='raw'). Defaults to a conflict-context string. */
     reason?: string;
 }
-/**
- * Resolve a conflict by keeping one memory and weakening the other.
- * Sets conflict status to 'resolved' and halves the loser's half-life.
- * If --forget is used, the loser is removed entirely (kind-aware: raw rows
- * are archived via archiveRawMemory, others deleted via deleteEntryCore —
- * AT1 fix for the pre-existing crash where a raw loser aborted the whole
- * resolve transaction against the append-only trigger). `opts.rejectLoserValue`
- * additionally tombstones the loser's normalized digest so it cannot be
- * re-asserted later.
- *
- * Every resolution path (weaken / forget / reject) emits a `conflict_resolve`
- * audit row (AT1 — previously resolveConflict wrote zero audit rows on any path).
- *
- * Returns the resolved conflict, or null if not found.
- */
+/** Resolve a conflict by keeping one memory and halving the loser's half-life; `--forget` removes the loser, `opts.rejectLoserValue` also tombstones its
+ * digest. Every path emits a `conflict_resolve` audit row. Returns the resolved conflict, or null if not found. */
 export declare function resolveConflict(hippoRoot: string, conflictId: number, keepId: string, forgetLoser?: boolean, tenantId?: string, opts?: ResolveConflictOpts): {
     conflict: MemoryConflict;
     loserId: string;
 } | null;
+/** The conflict and loser ids every conflict_resolve audit row names. */
+export declare function conflictResolveAuditsAt(db: DatabaseSyncLike): Array<{
+    conflictId: number;
+    loserId: string;
+}>;
+/** Every resolved conflict with both sides. */
+export declare function resolvedConflictsAt(db: DatabaseSyncLike): Array<{
+    id: number;
+    memory_a_id: string;
+    memory_b_id: string;
+}>;
 export {};
 //# sourceMappingURL=conflicts.d.ts.map