hippo-memory 1.56.0 → 1.58.0

package/dist/index.js

@@ -7,10 +7,13 @@ export { Layer, calculateStrength, resolveConfidence, confidenceFacets, applyOut
 export function createMemory(content, options = {}) {
     return createStoreMemory(content, { ...options, baseHalfLifeDays: options.baseHalfLifeDays ?? DEFAULT_HALF_LIFE_DAYS });
 }
-export { search, hybridSearch, physicsSearch, markRetrieved, estimateTokens, textOverlap, tokenize, explainMatch, detectTemporalDirection, temporalBoost, computeTemporalRange } from './search.js';
+export { search, hybridSearch, physicsSearch, estimateTokens, textOverlap, explainMatch, detectTemporalDirection, temporalBoost, computeTemporalRange } from './search.js';
+export { tokenize } from './tokenize.js';
+export { markRetrieved } from './memory.js';
 export { multihopSearch } from './multihop.js';
 export { graphExpandRecall, MAX_HOPS, DEFAULT_MAX_NEIGHBORS } from './graph-recall.js';
-export { initStore, loadAllEntries, loadSearchEntries, loadRecallSearchEntries, writeEntry, readEntry, deleteEntry, loadIndex, rebuildIndex, saveActiveTaskSnapshot, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, SNAPSHOT_AMBIENT_MAX_AGE_MS, closeTaskSnapshotsForSession, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, replaceDetectedConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome, writeSessionEndHandoff, loadSessionDecayContext, createCard, loadCard, listCards, loadCardDeps, loadCardRuns, loadCardComments, claimCard, heartbeatCard, blockCard, reviewCard, completeCard, reclaimExpiredCards, addCardComment, loadLatestHandoffForCard, } from './store.js';
+export { initStore, loadAllEntries, loadSearchEntries, loadRecallSearchEntries, writeEntry, readEntry, deleteEntry, loadIndex, rebuildIndex, saveActiveTaskSnapshot, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, SNAPSHOT_AMBIENT_MAX_AGE_MS, closeTaskSnapshotsForSession, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, replaceDetectedConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome, writeSessionEndHandoff, loadSessionDecayContext, } from './store.js';
+export { createCard, loadCard, listCards, loadCardDeps, loadCardRuns, loadCardComments, claimCard, heartbeatCard, blockCard, reviewCard, completeCard, reclaimExpiredCards, addCardComment, loadLatestHandoffForCard, } from './store-cards.js';
 // Feature 5: Session handoff
 export { isHandoffOutcome } from './handoff.js';
 // W2a: work-queue cards

package/dist/judgment.js

@@ -1,10 +1,10 @@
 /** Typed judgment over capture candidates via TypeSafe's Jev (System One).
  *  Regex picks WHAT is a candidate; it cannot say what is worth keeping, so
  *  every captured memory currently lands on a flat schema_fit of 0.5. */
+import { fetchWithRetry } from './http-retry.js';
 const ENDPOINT = 'https://api.typesafe.ai/v1/systemone';
 const DEFAULT_MODEL = 'jev-1.13.0';
 const MAX_CONCURRENCY = 8;
-const RETRY_STATUS = new Set([429, 529]);
 const QUESTIONS = {
     durable: {
         type: 'noul',
@@ -48,11 +48,12 @@ function toConfidenceTier(kindConfidence) {
         return 'observed';
     return 'inferred';
 }
-async function postOnce(content, opts) {
-    const fetchFn = opts.fetcher ?? fetch;
+/** Capture-time judging must not hold a write for long: one budget per attempt, shorter than the LLM calls. */
+const JUDGE_TIMEOUT_MS = 15_000;
+async function post(content, opts) {
     let res;
     try {
-        res = await fetchFn(ENDPOINT, {
+        res = await fetchWithRetry(ENDPOINT, {
             method: 'POST',
             headers: {
                 'content-type': 'application/json',
@@ -63,16 +64,12 @@ async function postOnce(content, opts) {
                 model: opts.model ?? DEFAULT_MODEL,
                 questions: QUESTIONS,
             }),
-        });
+        }, { timeoutMs: JUDGE_TIMEOUT_MS, fetchFn: opts.fetcher });
     }
     catch {
         return null;
     }
-    if (RETRY_STATUS.has(res.status))
-        return { retryable: true };
-    if (!res.ok)
-        return null;
-    return { res };
+    return res.ok ? res : null;
 }
 /** `null` on any failure, so a Jev outage degrades capture to today's
  *  behaviour instead of blocking the write. */
@@ -80,19 +77,15 @@ export async function judge(content, opts) {
     const trimmed = content.trim();
     if (trimmed.length < 3)
         return null;
-    let attempt = await postOnce(trimmed, opts);
-    if (attempt && 'retryable' in attempt) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        attempt = await postOnce(trimmed, opts);
-    }
-    if (!attempt || 'retryable' in attempt)
+    const res = await post(trimmed, opts);
+    if (!res)
         return null;
     let data;
     try {
         // SAFETY: the documented Jev response is `{ answers: { <name>: Answer } }`
         // keyed by the question names posted above; every field read below is
         // optional-chained and range-checked before use, so a lie here returns null.
-        data = await attempt.res.json();
+        data = await res.json();
     }
     catch {
         return null;

package/dist/log.d.ts

@@ -0,0 +1,25 @@
+/** Leveled stderr logger. `HIPPO_LOG` picks the threshold (error, warn, info, debug); unset or unknown means warn. */
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+/** Extra key=value pairs appended to the line; `requestId` ties a line to one HTTP request. */
+export interface LogFields {
+    requestId?: string;
+    [key: string]: string | number | boolean | undefined;
+}
+/** The active threshold, read on every call so a test or a long-lived server can change it without a restart. */
+export declare function logThreshold(): LogLevel;
+export declare function isLevelEnabled(level: LogLevel): boolean;
+/** Same `[hippo] ` prefix the existing stderr lines use, so default-level output reads as before. */
+export declare function formatLogLine(level: LogLevel, message: string, fields?: LogFields): string;
+/** Write `message` at `level` the first time `key` is seen in this process; later calls are dropped. */
+declare function once(key: string, level: LogLevel, message: string, fields?: LogFields): void;
+export declare const log: {
+    readonly error: (message: string, fields?: LogFields) => void;
+    readonly warn: (message: string, fields?: LogFields) => void;
+    readonly info: (message: string, fields?: LogFields) => void;
+    readonly debug: (message: string, fields?: LogFields) => void;
+    readonly once: typeof once;
+};
+/** Test hook: forget which once-keys have fired. */
+export declare function resetLogOnce(): void;
+export {};
+//# sourceMappingURL=log.d.ts.map

package/dist/log.js

@@ -0,0 +1,48 @@
+/** Leveled stderr logger. `HIPPO_LOG` picks the threshold (error, warn, info, debug); unset or unknown means warn. */
+const RANK = { error: 0, warn: 1, info: 2, debug: 3 };
+function isLogLevel(value) {
+    return Object.hasOwn(RANK, value);
+}
+/** The active threshold, read on every call so a test or a long-lived server can change it without a restart. */
+export function logThreshold() {
+    const raw = process.env.HIPPO_LOG?.trim().toLowerCase() ?? '';
+    return isLogLevel(raw) ? raw : 'warn';
+}
+export function isLevelEnabled(level) {
+    return RANK[level] <= RANK[logThreshold()];
+}
+// A field value is caller data; flattening newlines keeps one event on one line.
+const oneLine = (value) => value.replace(/[\r\n]+/g, ' ');
+/** Same `[hippo] ` prefix the existing stderr lines use, so default-level output reads as before. */
+export function formatLogLine(level, message, fields = {}) {
+    const extras = Object.entries(fields)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => ` ${k}=${oneLine(String(v))}`)
+        .join('');
+    return `[hippo] ${level}: ${oneLine(message)}${extras}`;
+}
+function write(level, message, fields) {
+    if (!isLevelEnabled(level))
+        return;
+    process.stderr.write(`${formatLogLine(level, message, fields)}\n`);
+}
+const onceKeys = new Set();
+/** Write `message` at `level` the first time `key` is seen in this process; later calls are dropped. */
+function once(key, level, message, fields) {
+    if (onceKeys.has(key))
+        return;
+    onceKeys.add(key);
+    write(level, message, fields);
+}
+export const log = {
+    error: (message, fields) => write('error', message, fields),
+    warn: (message, fields) => write('warn', message, fields),
+    info: (message, fields) => write('info', message, fields),
+    debug: (message, fields) => write('debug', message, fields),
+    once,
+};
+/** Test hook: forget which once-keys have fired. */
+export function resetLogOnce() {
+    onceKeys.clear();
+}
+//# sourceMappingURL=log.js.map