hippo-memory 1.52.8 → 1.53.0

package/dist/codex-patch.d.ts

@@ -0,0 +1,12 @@
+/** Codex prints this line only when a patch applied (apply-patch lib.rs). */
+export declare const PATCH_SUCCESS_LINE = "Success. Updated the following files:";
+/** Paths a patch body adds, deletes, updates or moves to, in patch order; [] when the text holds no patch. */
+export declare function patchPaths(body: string): string[];
+export interface ShellPatch {
+    body: string;
+    /** The `cd <dir> &&` target, relative to the call's working directory. */
+    cd: string | null;
+}
+/** The patch a shell call hands to apply_patch, or null for any other command. */
+export declare function shellPatch(command: readonly string[] | string): ShellPatch | null;
+//# sourceMappingURL=codex-patch.d.ts.map

package/dist/codex-patch.js

@@ -0,0 +1,71 @@
+// Files named by a Codex apply_patch call, read the way openai/codex codex-rs/apply-patch reads them
+// (parser.rs for the body, invocation.rs for the shell forms it runs as apply_patch).
+import * as path from 'path';
+import { isStringValue } from './capture.js';
+/** Codex prints this line only when a patch applied (apply-patch lib.rs). */
+export const PATCH_SUCCESS_LINE = 'Success. Updated the following files:';
+const BEGIN_PATCH = '*** Begin Patch';
+const END_PATCH = '*** End Patch';
+const MOVE_TO = '*** Move to: ';
+const FILE_HEADER = /^\*\*\* (Add|Delete|Update) File: (.+)$/;
+/** Paths a patch body adds, deletes, updates or moves to, in patch order; [] when the text holds no patch. */
+export function patchPaths(body) {
+    const lines = body.split(/\r?\n/);
+    const start = lines.findIndex((l) => l.trim() === BEGIN_PATCH);
+    if (start < 0)
+        return [];
+    const paths = [];
+    let updating = false;
+    let canMove = false;
+    for (const line of lines.slice(start + 1)) {
+        // Inside an update hunk a leading space marks a context line, so headers match on trimEnd only there.
+        const head = updating ? line.trimEnd() : line.trim();
+        if (head === END_PATCH)
+            break;
+        const header = FILE_HEADER.exec(head);
+        if (header) {
+            paths.push(header[2].trim());
+            updating = header[1] === 'Update';
+            canMove = updating;
+            continue;
+        }
+        if (canMove && head.startsWith(MOVE_TO))
+            paths.push(head.slice(MOVE_TO.length).trim());
+        canMove = false;
+    }
+    return paths.filter(Boolean);
+}
+const HEREDOC = /^\s*(?:cd\s+(?<cd>'[^']*'|"[^"]*"|[^\s'"&|;]+)\s+&&\s+)?(?:apply_patch|applypatch)\s+<<\s*(?<q>['"]?)(?<tag>\w+)\k<q>[ \t]*\r?\n(?<body>[\s\S]*?)\r?\n\s*\k<tag>\s*$/;
+/** The script a shell argv runs, for the shells Codex checks for an apply_patch heredoc. */
+function shellScript(argv) {
+    const exe = path.basename(argv[0] ?? '').toLowerCase().replace(/\.exe$/, '');
+    if ((exe === 'bash' || exe === 'zsh' || exe === 'sh') && argv.length === 3 && (argv[1] === '-lc' || argv[1] === '-c'))
+        return argv[2];
+    if (exe === 'pwsh' || exe === 'powershell') {
+        const rest = argv.slice(1).filter((a) => a.toLowerCase() !== '-noprofile');
+        if (rest.length === 2 && rest[0].toLowerCase() === '-command')
+            return rest[1];
+    }
+    if (exe === 'cmd' && argv.length === 3 && argv[1].toLowerCase() === '/c')
+        return argv[2];
+    return null;
+}
+/** The patch a shell call hands to apply_patch, or null for any other command. */
+export function shellPatch(command) {
+    let script;
+    if (isStringValue(command)) {
+        script = command;
+    }
+    else {
+        const exe = path.basename(command[0] ?? '').toLowerCase();
+        if (command.length === 2 && (exe === 'apply_patch' || exe === 'applypatch'))
+            return { body: command[1], cd: null };
+        script = shellScript(command);
+    }
+    const match = script === null ? null : HEREDOC.exec(script);
+    if (!match?.groups)
+        return null;
+    const cd = match.groups.cd ?? null;
+    return { body: match.groups.body, cd: cd === null ? null : cd.replace(/^(['"])(.*)\1$/, '$2') };
+}
+//# sourceMappingURL=codex-patch.js.map

package/dist/compaction-items.d.ts

@@ -0,0 +1,18 @@
+export declare const COMPACTION_ITEM_MAX_CHARS = 500;
+export declare const COMPACTION_ITEM_ROW_CAP = 10;
+export interface ParsedCompactionItems {
+    found: boolean;
+    items: string[];
+}
+export interface CompactionItemRows {
+    rows: string[];
+    tooLong: number;
+    capped: number;
+}
+/** The <summary> body of a PostCompact compact_summary with any <analysis> block removed; the whole text trimmed when there is no <summary> tag. */
+export declare function compactSummaryBody(compactSummary: string): string;
+/** found=false when no "Memories for hippo" heading; items in order, "none" dropped, never cut. */
+export declare function parseCompactionItems(summaryBody: string): ParsedCompactionItems;
+/** First COMPACTION_ITEM_ROW_CAP items of at most COMPACTION_ITEM_MAX_CHARS chars become rows. */
+export declare function selectItemRows(items: readonly string[]): CompactionItemRows;
+//# sourceMappingURL=compaction-items.d.ts.map

package/dist/compaction-items.js

@@ -0,0 +1,60 @@
+// Reads the "Memories for hippo" list out of a compaction summary. Pure text in, text out: hooks and replay share it.
+export const COMPACTION_ITEM_MAX_CHARS = 500;
+export const COMPACTION_ITEM_ROW_CAP = 10;
+const HEADING = 'memories for hippo';
+const ITEM_LINE = /^\s*(?:[-*]|\d+[.)])(?:\s+(.*))?$/;
+/** The <summary> body of a PostCompact compact_summary with any <analysis> block removed; the whole text trimmed when there is no <summary> tag. */
+export function compactSummaryBody(compactSummary) {
+    const text = compactSummary.replace(/<analysis>[\s\S]*?<\/analysis>/g, '');
+    const open = text.lastIndexOf('<summary>');
+    if (open < 0)
+        return text.trim();
+    const from = open + '<summary>'.length;
+    const close = text.indexOf('</summary>', from);
+    return text.slice(from, close < 0 ? undefined : close).trim();
+}
+function isHeading(line) {
+    const bare = line.replace(/^(?:[#*\s]|\d+\.)+/, '').replace(/[*:\s]+$/, '');
+    return bare.toLowerCase() === HEADING;
+}
+/** found=false when no "Memories for hippo" heading; items in order, "none" dropped, never cut. */
+export function parseCompactionItems(summaryBody) {
+    const lines = summaryBody.split(/\r?\n/);
+    let heading = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (isHeading(lines[i])) {
+            heading = i;
+            break;
+        }
+    }
+    if (heading < 0)
+        return { found: false, items: [] };
+    const after = lines.slice(heading + 1).join('\n');
+    const end = after.indexOf('</summary>');
+    const items = [];
+    let current = -1;
+    for (const line of (end < 0 ? after : after.slice(0, end)).split('\n')) {
+        if (line.trim() === '')
+            continue;
+        const marker = ITEM_LINE.exec(line);
+        if (marker) {
+            const text = (marker[1] ?? '').trim();
+            current = text === '' ? -1 : items.push(text) - 1;
+        }
+        else if (/^\s/.test(line)) {
+            if (current >= 0)
+                items[current] += ` ${line.trim()}`;
+        }
+        else {
+            break;
+        }
+    }
+    return { found: true, items: items.filter((item) => !/^none\.?$/i.test(item)) };
+}
+/** First COMPACTION_ITEM_ROW_CAP items of at most COMPACTION_ITEM_MAX_CHARS chars become rows. */
+export function selectItemRows(items) {
+    const fitting = items.filter((item) => item.length <= COMPACTION_ITEM_MAX_CHARS);
+    const rows = fitting.slice(0, COMPACTION_ITEM_ROW_CAP);
+    return { rows, tooLong: items.length - fitting.length, capped: fitting.length - rows.length };
+}
+//# sourceMappingURL=compaction-items.js.map

package/dist/compaction-record.d.ts

@@ -0,0 +1,94 @@
+import { type DatabaseSyncLike } from './db.js';
+/** PostCompact has 10 s in all (PreCompact 30 s), so a locked store must be given up on early. */
+export declare const COMPACTION_DB_WAIT_MS = 2000;
+/** Tested verbatim: Claude Code hands PreCompact stdout to the summariser as instructions. */
+export declare const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', each lesson learned, decision made (with its reason) and correction the user gave in this session that should outlive it. Write each as a standalone sentence that names its subject. Leave out anything an earlier summary already listed under 'Memories for hippo'. Write '- none' if nothing new remains.";
+/** Long enough that a live hook has finished with its own record. */
+export declare const REPLAY_AFTER_MS: number;
+/** Claude Code deletes transcripts after 30 days, so an older gap can never be filled. */
+export declare const TRANSCRIPT_FILL_WINDOW_MS: number;
+export type CompactionStatus = 'started' | 'summarised' | 'done' | 'no-summary';
+export interface CompactionRecord {
+    id: string;
+    tenantId: string;
+    sessionId: string;
+    originProject: string;
+    trigger: string | null;
+    cwd: string | null;
+    transcriptPath: string | null;
+    snapshotSaved: boolean;
+    startedAt: string;
+    summarisedAt: string | null;
+    summary: string | null;
+    items: string[];
+    itemsWritten: number;
+    status: CompactionStatus;
+}
+export type Log = (message: string) => void;
+/** Where the session ran: rows written through the global store keep the project the session was in. */
+export declare function compactionOrigin(hippoRoot: string, cwd: string | null): string;
+interface ScrubbedSummary {
+    summary: string;
+    items: string[];
+    /** False when the summary has no memories section. */
+    found: boolean;
+}
+/** What the record keeps of a compact_summary: the scrubbed body, and every parsed item scrubbed. */
+export declare function readCompactionText(compactSummary: string): ScrubbedSummary;
+export interface CompactionStart {
+    sessionId: string;
+    originProject: string;
+    trigger: string | null;
+    cwd: string | null;
+    transcriptPath: string | null;
+}
+export declare function startCompaction(db: DatabaseSyncLike, tenantId: string, start: CompactionStart, at?: Date): string;
+/** A session's newest record, or null. */
+export declare function latestCompaction(db: DatabaseSyncLike, tenantId: string, sessionId: string): CompactionRecord | null;
+/** Best effort, never throws: a compaction must not fail because its record could not be written. */
+export declare function recordCompactionStart(hippoRoot: string, start: Omit<CompactionStart, 'originProject'>, log: Log): string | null;
+export declare function recordSnapshotSaved(hippoRoot: string, recordId: string, log: Log): void;
+export interface CompactionText {
+    summary: string;
+    items: string[];
+}
+export interface ItemContext {
+    tenantId: string;
+    /** null when the record step failed: the items still go in, with no record to close. */
+    recordId: string | null;
+    sessionId: string;
+    originProject: string;
+    items: string[];
+}
+/** Items that become rows, then the record `done`, in one transaction so two sessions cannot both insert one text. Mirrors after commit. */
+export declare function saveItems(db: DatabaseSyncLike, hippoRoot: string, ctx: ItemContext, log: Log): number;
+export interface PostCompactPayload {
+    sessionId: string;
+    trigger: string | null;
+    cwd: string | null;
+    transcriptPath: string | null;
+    /** null when Claude Code sent none; the transcript fills the record later. */
+    compactSummary: string | null;
+}
+/** null when the text is not a PostCompact payload naming a session. */
+export declare function parsePostCompactPayload(stdinText: string | undefined): PostCompactPayload | null;
+export interface CompactionSaveResult {
+    /** Memories written; null when neither the record nor the items could be saved. */
+    written: number | null;
+    /** True when the rest waits for the next sleep or post-compact. */
+    deferred: boolean;
+    snapshotSaved: boolean;
+}
+/** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or defers. Never throws. */
+export declare function saveCompaction(hippoRoot: string, payload: PostCompactPayload, log: Log): CompactionSaveResult;
+/** The one line PostCompact prints, or null when nothing was saved. */
+export declare function postCompactLine(result: CompactionSaveResult): string | null;
+/** Finishes what a killed hook or a busy store left: `summarised` records, spool files, and `started` records the transcript can fill. Returns how many compactions it saved. */
+export declare function replayCompactions(db: DatabaseSyncLike, hippoRoot: string, log: Log, deadline?: number): number;
+/** For `hippo sleep` and post-compact: opens the store itself and never throws. */
+export declare function replayCompactionsAt(hippoRoot: string, log: Log, opts?: {
+    busyWaitMs?: number;
+    deadline?: number;
+}): number;
+export {};
+//# sourceMappingURL=compaction-record.d.ts.map