jeopi-mnemopi 16.2.13

package/dist/types/core/veracity-consolidation.d.ts

@@ -0,0 +1,60 @@
+import type { Database } from "bun:sqlite";
+import { type DatabasePath } from "../db";
+export declare const VERACITY_WEIGHTS: Readonly<{
+    stated: 1;
+    inferred: 0.7;
+    tool: 0.5;
+    imported: 0.6;
+    unknown: 0.8;
+}>;
+export type Veracity = keyof typeof VERACITY_WEIGHTS;
+export declare const VERACITY_ALLOWED: Record<Veracity, true>;
+export interface ConsolidatedFact {
+    readonly subject: string;
+    readonly predicate: string;
+    readonly object: string;
+    readonly confidence: number;
+    readonly mention_count: number;
+    readonly first_seen: string | null;
+    readonly last_seen: string | null;
+    readonly sources: string[];
+    readonly veracity: string;
+    readonly superseded: boolean;
+    readonly id: string | null;
+}
+export interface Conflict {
+    readonly id: number;
+    readonly fact_a_id: string;
+    readonly fact_b_id: string;
+    readonly type: string | null;
+    readonly created_at: string | null;
+}
+export interface ConsolidationStats {
+    readonly active_facts: number;
+    readonly superseded_facts: number;
+    readonly unresolved_conflicts: number;
+    readonly avg_confidence: number;
+    readonly avg_mentions: number;
+}
+export declare function computeFactId(subject: string, predicate: string, object: string): string;
+export declare function clampVeracity(raw: unknown, context?: string): Veracity;
+export declare function aggregateVeracity(sourceVeracities: readonly string[] | null | undefined): Veracity;
+export declare class VeracityConsolidator {
+    readonly conn: Database;
+    readonly dbPath: DatabasePath;
+    readonly ownsConnection: boolean;
+    constructor(dbPath?: DatabasePath, conn?: Database);
+    initTables(): void;
+    serializedWrite<T>(body: () => T): T;
+    bayesianUpdate(currentConfidence: number, veracity: string): number;
+    consolidateFact(subject: string, predicate: string, object: string, veracity?: string, source?: string | null): ConsolidatedFact;
+    recordConflict(factAId: string, factBId: string, conflictType: string, commit?: boolean): void;
+    resolveConflict(conflictId: number, winningFactId: string): void;
+    getConflicts(): Conflict[];
+    getConsolidatedFacts(subject?: string | null, minConfidence?: number): ConsolidatedFact[];
+    getHighConfidenceSummary(subject: string, threshold?: number): string;
+    runConsolidationPass(): void;
+    resolveConflictByFacts(winningId: string, losingId: string): void;
+    getStats(): ConsolidationStats;
+    close(): void;
+}

package/dist/types/core/weibull.d.ts

@@ -0,0 +1,96 @@
+export type MemoryType = keyof typeof WEIBULL_PARAMS;
+export interface WeibullParams {
+    readonly k: number;
+    readonly eta: number;
+}
+export declare const WEIBULL_PARAMS: {
+    readonly profile: {
+        readonly k: 0.3;
+        readonly eta: 8760;
+    };
+    readonly preference: {
+        readonly k: 0.4;
+        readonly eta: 4380;
+    };
+    readonly relationship: {
+        readonly k: 0.35;
+        readonly eta: 8760;
+    };
+    readonly learning: {
+        readonly k: 0.7;
+        readonly eta: 1440;
+    };
+    readonly fact: {
+        readonly k: 0.8;
+        readonly eta: 720;
+    };
+    readonly entity: {
+        readonly k: 0.5;
+        readonly eta: 4380;
+    };
+    readonly setup: {
+        readonly k: 0.6;
+        readonly eta: 2160;
+    };
+    readonly pattern: {
+        readonly k: 0.6;
+        readonly eta: 1680;
+    };
+    readonly context: {
+        readonly k: 0.85;
+        readonly eta: 360;
+    };
+    readonly observation: {
+        readonly k: 0.9;
+        readonly eta: 480;
+    };
+    readonly artifact: {
+        readonly k: 0.75;
+        readonly eta: 2160;
+    };
+    readonly project: {
+        readonly k: 0.85;
+        readonly eta: 1080;
+    };
+    readonly goal: {
+        readonly k: 0.9;
+        readonly eta: 720;
+    };
+    readonly decision: {
+        readonly k: 1;
+        readonly eta: 336;
+    };
+    readonly commitment: {
+        readonly k: 1;
+        readonly eta: 240;
+    };
+    readonly event: {
+        readonly k: 1.2;
+        readonly eta: 168;
+    };
+    readonly instruction: {
+        readonly k: 0.9;
+        readonly eta: 480;
+    };
+    readonly error: {
+        readonly k: 1.1;
+        readonly eta: 336;
+    };
+    readonly issue: {
+        readonly k: 1.1;
+        readonly eta: 336;
+    };
+    readonly request: {
+        readonly k: 1.5;
+        readonly eta: 72;
+    };
+    readonly general: {
+        readonly k: 1;
+        readonly eta: 168;
+    };
+};
+export declare const DEFAULT_HALFLIFE_HOURS = 168;
+type TimestampInput = string | Date | null | undefined;
+export declare function weibullBoost(timestamp: TimestampInput, queryTime?: Date | null, memoryType?: string, halflifeHours?: number | null): number;
+export declare function weibullDecayFactor(ageHours: number, memoryType?: string): number;
+export {};

package/dist/types/db.d.ts

@@ -0,0 +1,16 @@
+import { Database } from "bun:sqlite";
+export type DatabasePath = string | ":memory:";
+export interface OpenDatabaseOptions {
+    readonly create?: boolean;
+    readonly readwrite?: boolean;
+    readonly strict?: boolean;
+    readonly loadExtension?: string | readonly string[];
+    readonly pragmas?: boolean;
+}
+export declare function openDatabase(path?: DatabasePath, options?: OpenDatabaseOptions): Database;
+export declare function enablePragmas(db: Database, path?: DatabasePath): void;
+export declare function loadExtensions(db: Database, extensions: string | readonly string[]): void;
+export declare function transaction<T>(db: Database, fn: () => T): T;
+export declare const deferredTransaction: typeof transaction;
+export declare function transactionAsync<T>(db: Database, fn: () => Promise<T>): Promise<T>;
+export declare function closeQuietly(db: Database | undefined | null): void;

package/dist/types/diagnose.d.ts

@@ -0,0 +1,24 @@
+import type { Database } from "bun:sqlite";
+export interface DiagnosticEntry {
+    readonly ts: string;
+    readonly category: string;
+    readonly check: string;
+    readonly status: string;
+    readonly detail?: string;
+}
+export interface DiagnosticSummary {
+    readonly checks_total: number;
+    readonly checks_passed: number;
+    readonly checks_failed: number;
+    readonly key_findings: string[];
+    readonly entries: DiagnosticEntry[];
+    readonly database: string;
+}
+export interface DiagnosticOptions {
+    readonly db?: Database;
+    readonly dbPath?: string;
+    readonly dataDir?: string;
+    readonly initialize?: boolean;
+}
+export declare function inspectDatabase(options?: DiagnosticOptions): DiagnosticSummary;
+export declare function runDiagnostics(options?: DiagnosticOptions): DiagnosticSummary;

package/dist/types/dr/index.d.ts

@@ -0,0 +1 @@
+export * from "./recovery";

package/dist/types/dr/recovery.d.ts

@@ -0,0 +1,68 @@
+import { type Env } from "../config";
+export interface RecoveryPaths {
+    readonly dataDir: string;
+    readonly backupDir: string;
+    readonly dbPath: string;
+}
+export interface BackupMetadata {
+    readonly timestamp: string;
+    readonly original_size: number;
+    readonly backup_size: number;
+    readonly db_checksum: string;
+    readonly backup_checksum: string;
+    readonly compressed: true;
+}
+export interface BackupResult extends BackupMetadata {
+    readonly backup_path: string;
+    readonly metadata_path: string;
+}
+export interface RestoreResult {
+    readonly restored: true;
+    readonly backup_used: string;
+    readonly database_path: string;
+    readonly integrity_check: boolean;
+}
+export interface EmergencyRestoreResult {
+    readonly restored: true;
+    readonly backup_used: string;
+    readonly attempts: number;
+}
+export interface BackupInfo {
+    readonly file: string;
+    readonly name: string;
+    readonly size: number;
+    readonly modified: string;
+    readonly metadata?: BackupMetadata;
+}
+export interface RotateBackupsResult {
+    readonly total_backups: number;
+    readonly kept: number;
+    readonly deleted: number;
+    readonly deleted_files: string[];
+}
+export interface HealthCheckResult {
+    readonly database: {
+        readonly exists: boolean;
+        readonly valid: boolean;
+        readonly path: string;
+        readonly message: string;
+    };
+    readonly backups: {
+        readonly total: number;
+        readonly latest: string | null;
+        readonly directory: string;
+    };
+    readonly status: "healthy" | "unhealthy";
+}
+export declare function getDefaultPaths(env?: Env): RecoveryPaths;
+export declare function createBackup(dbPath?: string | null, backupDir?: string | null): BackupResult;
+export declare function restoreBackup(backupPath: string, dbPath?: string | null): RestoreResult;
+export declare function emergencyRestore(backupDir?: string | null, dbPath?: string | null): EmergencyRestoreResult;
+export declare function verifyIntegrity(dbPath?: string | null): boolean;
+export declare function listBackups(backupDir?: string | null): BackupInfo[];
+export declare function rotateBackups(backupDir?: string | null, keep?: number): RotateBackupsResult;
+export declare function healthCheck(): HealthCheckResult;
+export declare class FileNotFoundError extends Error {
+    constructor(message: string);
+}
+export declare function resetRecoveryForTests(): void;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { configureRecallFeatures, type RecallFeatureFlags } from "./config";
+export * from "./core/beam/index";
+export * from "./core/embeddings";
+export * from "./core/llm-backends";
+export * from "./core/memory";
+export { addMemory, flushExtractions, forget, get, getBank, getContext, getDefaultInstance, getStats, Mnemopi, query, recall, recallEnhanced, remember, resetDefaultInstanceForTests, resetMemoryForTests, resetModuleStateForTests, saveMemory, scratchpadClear, scratchpadRead, scratchpadWrite, search, setBank, sleep, sleepAllSessions, storeMemory, update, } from "./core/memory";

package/dist/types/mcp-server.d.ts

@@ -0,0 +1,40 @@
+import { type ToolArguments, type ToolDefinition } from "./mcp-tools";
+export interface JsonRpcRequest {
+    readonly jsonrpc?: string;
+    readonly id?: string | number | null;
+    readonly method?: string;
+    readonly params?: Record<string, unknown>;
+}
+export interface JsonRpcResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: string | number | null;
+    readonly result?: unknown;
+    readonly error?: {
+        readonly code: number;
+        readonly message: string;
+    };
+}
+export interface ListToolsResponse {
+    readonly tools: readonly ToolDefinition[];
+}
+export interface CallToolContent {
+    readonly type: "text";
+    readonly text: string;
+}
+export interface CallToolResponse {
+    readonly content: readonly CallToolContent[];
+    readonly isError?: boolean;
+}
+export interface WritableOutput {
+    write(chunk: string): unknown;
+}
+export declare function listToolsJson(): ListToolsResponse;
+export declare function callToolJson(name: string, args?: ToolArguments): Promise<CallToolResponse>;
+export declare function handleJsonRpc(request: JsonRpcRequest): Promise<JsonRpcResponse | null>;
+export declare function runStdio(input?: ReadableStream<Uint8Array>, output?: WritableOutput): Promise<void>;
+export declare function runMcpServer(transport?: string, options?: {
+    port?: number;
+    bank?: string;
+    host?: string;
+}): Promise<void>;
+export declare function main(argv?: readonly string[]): Promise<void>;