swarm-mail 0.4.0 → 1.0.0

package/dist/memory/adapter.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Memory Adapter - High-level API for semantic memory
+ *
+ * Combines Ollama embeddings + MemoryStore into a simple API matching
+ * the semantic-memory MCP tool interface.
+ *
+ * ## Key Features
+ * - Automatic embedding generation via Ollama
+ * - Semantic search with vector similarity
+ * - FTS fallback when Ollama unavailable
+ * - Graceful degradation
+ * - Decay calculation (90-day half-life)
+ *
+ * ## Usage
+ * ```typescript
+ * import { createMemoryAdapter } from './adapter.js';
+ * import { wrapPGlite } from '../pglite.js';
+ * import { PGlite } from '@electric-sql/pglite';
+ *
+ * const pglite = await PGlite.create({ dataDir: './db' });
+ * const db = wrapPGlite(pglite);
+ * const config = {
+ *   ollamaHost: 'http://localhost:11434',
+ *   ollamaModel: 'mxbai-embed-large',
+ * };
+ *
+ * const adapter = createMemoryAdapter(db, config);
+ *
+ * // Store with automatic embedding
+ * const { id } = await adapter.store("OAuth tokens need refresh buffer", {
+ *   tags: "auth,tokens",
+ *   metadata: JSON.stringify({ priority: "high" })
+ * });
+ *
+ * // Semantic search
+ * const results = await adapter.find("token refresh");
+ *
+ * // FTS fallback when Ollama down
+ * const results = await adapter.find("token refresh", { fts: true });
+ * ```
+ */
+import type { DatabaseAdapter } from "../types/database.js";
+import { type Memory, type SearchResult } from "./store.js";
+import { type MemoryConfig } from "./ollama.js";
+export type { MemoryConfig } from "./ollama.js";
+export type { Memory, SearchResult } from "./store.js";
+/**
+ * Options for storing a memory
+ */
+export interface StoreOptions {
+    /** Collection name (default: "default") */
+    readonly collection?: string;
+    /** Comma-separated tags (e.g., "auth,tokens,oauth") */
+    readonly tags?: string;
+    /** JSON string with additional metadata */
+    readonly metadata?: string;
+    /** Confidence level (0.0-1.0) affecting decay rate. Higher = slower decay. Default 0.7 */
+    readonly confidence?: number;
+}
+/**
+ * Options for searching memories
+ */
+export interface FindOptions {
+    /** Maximum number of results (default: 10) */
+    readonly limit?: number;
+    /** Collection filter */
+    readonly collection?: string;
+    /** Return full content (default: false returns preview) */
+    readonly expand?: boolean;
+    /** Use full-text search instead of vector search (default: false) */
+    readonly fts?: boolean;
+}
+/**
+ * Health check result
+ */
+export interface HealthStatus {
+    /** Whether Ollama is available */
+    readonly ollama: boolean;
+    /** Ollama model name (if available) */
+    readonly model?: string;
+}
+/**
+ * Create a memory adapter with high-level operations
+ *
+ * @param db - DatabaseAdapter for PGlite/PostgreSQL
+ * @param config - Ollama configuration
+ * @returns Memory adapter instance
+ */
+export declare function createMemoryAdapter(db: DatabaseAdapter, config: MemoryConfig): {
+    /**
+     * Store a memory with automatic embedding generation
+     *
+     * @param information - Memory content
+     * @param options - Store options
+     * @returns Memory ID
+     * @throws Error if embedding generation fails or database operation fails
+     */
+    store(information: string, options?: StoreOptions): Promise<{
+        id: string;
+    }>;
+    /**
+     * Find memories by semantic similarity or full-text search
+     *
+     * @param query - Search query
+     * @param options - Search options
+     * @returns Search results with scores
+     */
+    find(query: string, options?: FindOptions): Promise<SearchResult[]>;
+    /**
+     * Get a specific memory by ID
+     *
+     * @param id - Memory ID
+     * @returns Memory or null if not found
+     */
+    get(id: string): Promise<Memory | null>;
+    /**
+     * Remove a memory
+     *
+     * @param id - Memory ID
+     */
+    remove(id: string): Promise<void>;
+    /**
+     * Validate/refresh a memory (reset decay timer)
+     *
+     * Updates the created_at timestamp to current time, effectively
+     * resetting the 90-day decay timer.
+     *
+     * @param id - Memory ID
+     * @throws Error if memory not found
+     */
+    validate(id: string): Promise<void>;
+    /**
+     * List all memories
+     *
+     * @param options - List options
+     * @returns Array of memories
+     */
+    list(options?: {
+        collection?: string;
+    }): Promise<Memory[]>;
+    /**
+     * Get database statistics
+     *
+     * @returns Memory and embedding counts
+     */
+    stats(): Promise<{
+        memories: number;
+        embeddings: number;
+    }>;
+    /**
+     * Check if Ollama is available
+     *
+     * @returns Health status
+     */
+    checkHealth(): Promise<HealthStatus>;
+};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/memory/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/memory/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAqB,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EAA0B,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAMxE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,uDAAuD;IACvD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,0FAA0F;IAC1F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,wBAAwB;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,uCAAuC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY;IAqFzE;;;;;;;OAOG;uBAEY,MAAM,YACV,YAAY,GACpB,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IA2C1B;;;;;;OAMG;gBACe,MAAM,YAAW,WAAW,GAAQ,OAAO,CAAC,YAAY,EAAE,CAAC;IA0C7E;;;;;OAKG;YACW,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAI7C;;;;OAIG;eACc,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC;;;;;;;;OAQG;iBACgB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAczC;;;;;OAKG;mBACiB;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAQ,OAAO,CAAC,MAAM,EAAE,CAAC;IAIpE;;;;OAIG;aACY,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IAIhE;;;;OAIG;mBACkB,OAAO,CAAC,YAAY,CAAC;EAiB7C"}

package/dist/memory/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Memory Module - Semantic memory with vector embeddings
+ *
+ * Provides Ollama-based embedding generation and memory storage.
+ */
+export { createMemoryAdapter, type FindOptions, type HealthStatus, type Memory, type MemoryConfig, type SearchResult, type StoreOptions, } from "./adapter.js";
+export { getDefaultConfig, makeOllamaLive, Ollama, OllamaError, } from "./ollama.js";
+export { createMemoryStore, EMBEDDING_DIM } from "./store.js";
+export { memoryMigration, memoryMigrations } from "./migrations.js";
+export { getDefaultLegacyPath, getMigrationStatus, legacyDatabaseExists, migrateLegacyMemories, type MigrationOptions, type MigrationResult, } from "./migrate-legacy.js";
+export { exportMemories, importMemories, syncMemories, parseMemoryJSONL, serializeMemoryToJSONL, type ExportOptions as MemoryExportOptions, type ImportOptions as MemoryImportOptions, type MemoryExport, type MemoryImportResult, } from "./sync.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACN,mBAAmB,EACnB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,YAAY,GACjB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACN,gBAAgB,EAChB,cAAc,EACd,MAAM,EACN,WAAW,GACX,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG9D,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGpE,OAAO,EACN,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACpB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACN,cAAc,EACd,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,aAAa,IAAI,mBAAmB,EACzC,KAAK,aAAa,IAAI,mBAAmB,EACzC,KAAK,YAAY,EACjB,KAAK,kBAAkB,GACvB,MAAM,WAAW,CAAC"}

package/dist/memory/migrate-legacy.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Legacy Semantic Memory Migration Tool
+ *
+ * Migrates memories from the standalone semantic-memory MCP server
+ * (~/.semantic-memory/memory) to the consolidated swarm-mail database.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { migrateLegacyMemories } from 'swarm-mail';
+ *
+ * const result = await migrateLegacyMemories({
+ *   legacyPath: '~/.semantic-memory/memory',
+ *   targetAdapter: swarmMailAdapter,
+ *   dryRun: false,
+ * });
+ *
+ * console.log(`Migrated ${result.migrated} memories`);
+ * ```
+ *
+ * ## What Gets Migrated
+ *
+ * - All memories from the `memories` table
+ * - All embeddings from the `memory_embeddings` table
+ * - Metadata, collections, and timestamps preserved
+ *
+ * ## Conflict Handling
+ *
+ * - Duplicate IDs are skipped (existing memories take precedence)
+ * - Migration is idempotent - safe to run multiple times
+ *
+ * @module memory/migrate-legacy
+ */
+import type { DatabaseAdapter } from "../types/database.js";
+/**
+ * Migration options
+ */
+export interface MigrationOptions {
+    /** Path to legacy semantic-memory database directory */
+    legacyPath?: string;
+    /** Target database adapter (from swarm-mail) */
+    targetDb: DatabaseAdapter;
+    /** If true, only report what would be migrated without making changes */
+    dryRun?: boolean;
+    /** Callback for progress updates */
+    onProgress?: (message: string) => void;
+}
+/**
+ * Migration result
+ */
+export interface MigrationResult {
+    /** Number of memories successfully migrated */
+    migrated: number;
+    /** Number of memories skipped (already exist) */
+    skipped: number;
+    /** Number of memories that failed to migrate */
+    failed: number;
+    /** Error messages for failed migrations */
+    errors: string[];
+    /** Whether this was a dry run */
+    dryRun: boolean;
+}
+/**
+ * Default path to legacy semantic-memory database
+ */
+export declare function getDefaultLegacyPath(): string;
+/**
+ * Check if legacy database exists
+ */
+export declare function legacyDatabaseExists(path?: string): boolean;
+/**
+ * Migrate memories from legacy semantic-memory database
+ *
+ * @param options - Migration options
+ * @returns Migration result with counts and errors
+ */
+export declare function migrateLegacyMemories(options: MigrationOptions): Promise<MigrationResult>;
+/**
+ * Get migration status without actually migrating
+ *
+ * @param legacyPath - Path to legacy database
+ * @returns Count of memories that would be migrated
+ */
+export declare function getMigrationStatus(legacyPath?: string): Promise<{
+    total: number;
+    withEmbeddings: number;
+} | null>;
+//# sourceMappingURL=migrate-legacy.d.ts.map

package/dist/memory/migrate-legacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-legacy.d.ts","sourceRoot":"","sources":["../../src/memory/migrate-legacy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,EAAE,eAAe,CAAC;IAC1B,yEAAyE;IACzE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,iCAAiC;IACjC,MAAM,EAAE,OAAO,CAAC;CACjB;AAsBD;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAG3D;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA4I1B;AAwBD;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAiC3D"}

package/dist/memory/migrations.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Memory Schema Migration
+ *
+ * Adds semantic memory tables to the shared PGLite database.
+ * This migration extends the existing swarm-mail schema.
+ *
+ * ## Migration Strategy
+ * - Migration v9 adds memory tables to existing swarm-mail schema (v0-v8)
+ * - Shares same PGLite database instance and migration system
+ * - Uses same schema_version table for tracking
+ *
+ * ## Tables Created
+ * - memories: Core memory records with content, metadata, collection
+ * - memory_embeddings: Vector embeddings for semantic search (pgvector)
+ *
+ * ## Indexes
+ * - HNSW index on embeddings for fast approximate nearest neighbor search
+ * - GIN index on content for full-text search
+ * - B-tree index on collection for filtering
+ *
+ * ## Design Notes
+ * - Uses TEXT for IDs (like hive/beads)
+ * - Uses TIMESTAMPTZ for timestamps (Postgres standard)
+ * - Uses JSONB for metadata (flexible key-value storage)
+ * - Uses vector(1024) for embeddings (mxbai-embed-large dimension)
+ * - CASCADE deletes for referential integrity
+ *
+ * @module memory/migrations
+ */
+import type { Migration } from "../streams/migrations.js";
+/**
+ * Migration v9: Add memory tables
+ *
+ * This migration is designed to be appended to the existing migrations array
+ * in src/streams/migrations.ts.
+ */
+export declare const memoryMigration: Migration;
+/**
+ * Export memory migrations array
+ */
+export declare const memoryMigrations: Migration[];
+//# sourceMappingURL=migrations.d.ts.map

package/dist/memory/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../src/memory/migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,SAkD7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,EAAsB,CAAC"}

package/dist/memory/ollama.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Ollama Embedding Service
+ *
+ * Provides embedding generation via local Ollama server.
+ * Uses Effect-TS patterns: Context.Tag for DI, Layer for instantiation.
+ *
+ * @example
+ * ```typescript
+ * import { Ollama, makeOllamaLive } from './memory/ollama';
+ * import { Effect } from 'effect';
+ *
+ * const config = {
+ *   ollamaHost: process.env.OLLAMA_HOST || 'http://localhost:11434',
+ *   ollamaModel: process.env.OLLAMA_MODEL || 'mxbai-embed-large',
+ * };
+ *
+ * const program = Effect.gen(function* () {
+ *   const ollama = yield* Ollama;
+ *   const embedding = yield* ollama.embed("hello world");
+ *   return embedding;
+ * });
+ *
+ * const layer = makeOllamaLive(config);
+ * const result = await Effect.runPromise(program.pipe(Effect.provide(layer)));
+ * ```
+ */
+import { Context, Effect, Layer } from "effect";
+import { Schema } from "effect";
+/**
+ * Configuration for Ollama embedding service
+ */
+export interface MemoryConfig {
+    /** Ollama server URL (default: http://localhost:11434) */
+    readonly ollamaHost: string;
+    /** Ollama model name (default: mxbai-embed-large) */
+    readonly ollamaModel: string;
+}
+declare const OllamaError_base: Schema.TaggedErrorClass<OllamaError, "OllamaError", {
+    readonly _tag: Schema.tag<"OllamaError">;
+} & {
+    reason: typeof Schema.String;
+}>;
+/**
+ * Ollama operation failure
+ */
+export declare class OllamaError extends OllamaError_base {
+}
+declare const Ollama_base: Context.TagClass<Ollama, "swarm-mail/Ollama", {
+    /** Generate embedding for a single text */
+    readonly embed: (text: string) => Effect.Effect<number[], OllamaError>;
+    /** Generate embeddings for multiple texts with controlled concurrency */
+    readonly embedBatch: (texts: string[], concurrency?: number) => Effect.Effect<number[][], OllamaError>;
+    /** Verify Ollama is running and model is available */
+    readonly checkHealth: () => Effect.Effect<void, OllamaError>;
+}>;
+/**
+ * Ollama service for generating embeddings from text.
+ *
+ * @example
+ * ```ts
+ * const embedding = yield* Ollama.embed("hello world");
+ * // => number[] (1024 dims for mxbai-embed-large)
+ * ```
+ */
+export declare class Ollama extends Ollama_base {
+}
+/**
+ * Create Ollama service layer from config.
+ *
+ * @param config - Memory configuration with ollamaHost and ollamaModel
+ * @returns Layer providing the Ollama service
+ */
+export declare const makeOllamaLive: (config: MemoryConfig) => Layer.Layer<Ollama, never, never>;
+/**
+ * Get default Ollama configuration from environment variables.
+ * Falls back to sensible defaults if env vars not set.
+ */
+export declare const getDefaultConfig: () => MemoryConfig;
+export {};
+//# sourceMappingURL=ollama.d.ts.map

package/dist/memory/ollama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../../src/memory/ollama.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAS,OAAO,EAAY,MAAM,EAAE,KAAK,EAAoB,MAAM,QAAQ,CAAC;AACnF,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,qDAAqD;IACrD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC7B;;;;;;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAGhC;CAAG;;IAkBF,2CAA2C;oBAC3B,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,WAAW,CAAC;IACtE,yEAAyE;yBACpD,CACpB,KAAK,EAAE,MAAM,EAAE,EACf,WAAW,CAAC,EAAE,MAAM,KAChB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,WAAW,CAAC;IAC3C,sDAAsD;0BAChC,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC;;AApB9D;;;;;;;;GAQG;AACH,qBAAa,MAAO,SAAQ,WAazB;CAAG;AAcN;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,YAAY,sCA+FjD,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB,QAAO,YAGlC,CAAC"}

package/dist/memory/store.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Memory Store - PGlite + pgvector operations
+ *
+ * Provides CRUD operations and semantic search for memories using
+ * an existing shared PGlite instance. Does NOT create its own database.
+ *
+ * ## Design Pattern
+ * - Accept DatabaseAdapter via factory parameter (dependency injection)
+ * - Share PGlite instance with other swarm-mail services
+ * - Schema migrations handled separately (by migrations task)
+ *
+ * ## Key Operations
+ * - store: Insert or update memory with embedding
+ * - search: Vector similarity search with threshold/limit/collection filters
+ * - ftsSearch: Full-text search with PostgreSQL FTS
+ * - list: List all memories, optionally filtered by collection
+ * - get: Retrieve single memory by ID
+ * - delete: Remove memory and its embedding
+ * - getStats: Memory and embedding counts
+ *
+ * ## Vector Search Query
+ * Uses pgvector's <=> operator for cosine distance, where:
+ * - 0 = identical vectors
+ * - 2 = opposite vectors
+ * - Score = 1 - distance (higher is more similar)
+ */
+import type { DatabaseAdapter } from "../types/database.js";
+/** Embedding dimension for mxbai-embed-large */
+export declare const EMBEDDING_DIM = 1024;
+/** Memory data structure */
+export interface Memory {
+    readonly id: string;
+    readonly content: string;
+    readonly metadata: Record<string, unknown>;
+    readonly collection: string;
+    readonly createdAt: Date;
+    /** Confidence level (0.0-1.0) affecting decay rate. Higher = slower decay. Default 0.7 */
+    readonly confidence?: number;
+}
+/** Search result with similarity score */
+export interface SearchResult {
+    readonly memory: Memory;
+    readonly score: number;
+    readonly matchType: "vector" | "fts";
+}
+/** Search options for queries */
+export interface SearchOptions {
+    readonly limit?: number;
+    readonly threshold?: number;
+    readonly collection?: string;
+}
+/**
+ * Create a memory store using a shared DatabaseAdapter
+ *
+ * @param db - DatabaseAdapter instance (shared PGLite, SQLite, PostgreSQL, etc.)
+ * @returns Memory store operations
+ *
+ * @example
+ * ```typescript
+ * import { wrapPGlite } from '../pglite.js';
+ * import { PGlite } from '@electric-sql/pglite';
+ * import { vector } from '@electric-sql/pglite/vector';
+ *
+ * const pglite = await PGlite.create({ dataDir: './db', extensions: { vector } });
+ * const db = wrapPGlite(pglite);
+ * const store = createMemoryStore(db);
+ *
+ * await store.store(memory, embedding);
+ * const results = await store.search(queryEmbedding);
+ * ```
+ */
+export declare function createMemoryStore(db: DatabaseAdapter): {
+    /**
+     * Store a memory with its embedding
+     *
+     * Uses UPSERT (INSERT ... ON CONFLICT DO UPDATE) to handle both
+     * new memories and updates to existing ones atomically.
+     *
+     * @param memory - Memory to store
+     * @param embedding - 1024-dimensional vector
+     * @throws Error if database operation fails
+     */
+    store(memory: Memory, embedding: number[]): Promise<void>;
+    /**
+     * Vector similarity search
+     *
+     * Finds memories with embeddings similar to the query embedding.
+     * Uses cosine distance (<=> operator) with HNSW index for performance.
+     *
+     * @param queryEmbedding - 1024-dimensional query vector
+     * @param options - Search options (limit, threshold, collection)
+     * @returns Array of search results sorted by similarity (highest first)
+     */
+    search(queryEmbedding: number[], options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Full-text search
+     *
+     * Searches memory content using PostgreSQL's full-text search.
+     * Uses GIN index on to_tsvector('english', content) for performance.
+     *
+     * @param searchQuery - Text query string
+     * @param options - Search options (limit, collection)
+     * @returns Array of search results ranked by ts_rank
+     */
+    ftsSearch(searchQuery: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * List memories
+     *
+     * @param collection - Optional collection filter
+     * @returns Array of memories sorted by created_at DESC
+     */
+    list(collection?: string): Promise<Memory[]>;
+    /**
+     * Get a single memory by ID
+     *
+     * @param id - Memory ID
+     * @returns Memory or null if not found
+     */
+    get(id: string): Promise<Memory | null>;
+    /**
+     * Delete a memory
+     *
+     * Cascade delete handles memory_embeddings automatically.
+     *
+     * @param id - Memory ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Get database statistics
+     *
+     * @returns Memory and embedding counts
+     */
+    getStats(): Promise<{
+        memories: number;
+        embeddings: number;
+    }>;
+};
+//# sourceMappingURL=store.d.ts.map

package/dist/memory/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/memory/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAM5D,gDAAgD;AAChD,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC,4BAA4B;AAC5B,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,0FAA0F;IAC1F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,0CAA0C;AAC1C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,KAAK,CAAC;CACtC;AAED,iCAAiC;AACjC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,eAAe;IAcjD;;;;;;;;;OASG;kBACiB,MAAM,aAAa,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAuC/D;;;;;;;;;OASG;2BAEe,MAAM,EAAE,YACf,aAAa,GACrB,OAAO,CAAC,YAAY,EAAE,CAAC;IAmD1B;;;;;;;;;OASG;2BAEY,MAAM,YACV,aAAa,GACrB,OAAO,CAAC,YAAY,EAAE,CAAC;IAqC1B;;;;;OAKG;sBACqB,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAelD;;;;;OAKG;YACW,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAQ7C;;;;;;OAMG;eACc,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC;;;;OAIG;gBACe,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;EActE"}

package/dist/memory/sync.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Memory Sync - JSONL Export/Import for Git Sync
+ *
+ * Implements git-synced memory persistence, similar to how hive syncs issues.jsonl.
+ * Memories travel with the repo so team members share learnings.
+ *
+ * ## Architecture
+ * ```
+ * .hive/
+ *   issues.jsonl      # existing
+ *   memories.jsonl    # NEW
+ * ```
+ *
+ * ## JSONL Format
+ * ```json
+ * {"id":"mem_abc123","information":"OAuth tokens need 5min buffer...","metadata":"auth,tokens","tags":"oauth,refresh","confidence":0.9,"created_at":"2024-12-19T00:00:00Z"}
+ * ```
+ *
+ * Note: Embeddings are NOT stored (too large). Regenerated on import if Ollama available.
+ *
+ * @module memory/sync
+ */
+import type { DatabaseAdapter } from "../types/database.js";
+/**
+ * JSONL export format for memories
+ *
+ * Embeddings are NOT included - they're too large and can be regenerated.
+ */
+export interface MemoryExport {
+    id: string;
+    information: string;
+    metadata?: string;
+    tags?: string;
+    confidence?: number;
+    created_at: string;
+}
+export interface ExportOptions {
+    /** Filter by collection */
+    collection?: string;
+}
+export interface ImportOptions {
+    /** Skip existing memories (default: true) */
+    skipExisting?: boolean;
+}
+export interface MemoryImportResult {
+    created: number;
+    skipped: number;
+    errors: Array<{
+        memoryId: string;
+        error: string;
+    }>;
+}
+/**
+ * Serialize a memory to a JSONL line
+ */
+export declare function serializeMemoryToJSONL(memory: MemoryExport): string;
+/**
+ * Parse JSONL string to memory exports
+ *
+ * Skips empty lines. Throws on invalid JSON.
+ */
+export declare function parseMemoryJSONL(jsonl: string): MemoryExport[];
+/**
+ * Export all memories to JSONL string
+ *
+ * Embeddings are NOT included - they're too large for git sync.
+ * They can be regenerated on import if Ollama is available.
+ */
+export declare function exportMemories(db: DatabaseAdapter, options?: ExportOptions): Promise<string>;
+/**
+ * Import memories from JSONL string
+ *
+ * Features:
+ * - Creates new memories
+ * - Skips existing memories (by ID)
+ * - Embeddings NOT imported (regenerate with Ollama if needed)
+ */
+export declare function importMemories(db: DatabaseAdapter, jsonl: string, options?: ImportOptions): Promise<MemoryImportResult>;
+/**
+ * Bidirectional sync between database and .hive/memories.jsonl
+ *
+ * 1. Import from file (new memories only)
+ * 2. Export all to file (overwrites)
+ *
+ * This ensures:
+ * - Memories from git are imported
+ * - Local memories are exported for git commit
+ */
+export declare function syncMemories(db: DatabaseAdapter, hivePath: string): Promise<{
+    imported: MemoryImportResult;
+    exported: number;
+}>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/memory/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/memory/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAM5D;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpD;AAMD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAmBnE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,EAAE,CAyB9D;AAMD;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,eAAe,EACnB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,MAAM,CAAC,CA6EjB;AAMD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,kBAAkB,CAAC,CAsB7B;AA4ED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAChC,EAAE,EAAE,eAAe,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,QAAQ,EAAE,kBAAkB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAsB7D"}

package/dist/pglite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pglite.d.ts","sourceRoot":"","sources":["../src/pglite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAM9C,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAIjE;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAQ1D;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAQjE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAkB5D;AAoHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,YAAY,CAChC,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAmD3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAS3B;AA0DD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,uBAAuB,CAC3C,UAAU,SAAS,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYxE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUvD;AAGD,OAAO,EAAE,MAAM,EAAE,CAAC"}
+{"version":3,"file":"pglite.d.ts","sourceRoot":"","sources":["../src/pglite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAO9C,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAIjE;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAQ1D;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAQjE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAkB5D;AA0HD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,YAAY,CAChC,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAmD3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAS3B;AA0DD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,uBAAuB,CAC3C,UAAU,SAAS,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAQ3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYxE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUvD;AAGD,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/streams/events.d.ts

@@ -186,6 +186,8 @@ export declare const SubtaskOutcomeEventSchema: z.ZodObject<{
     error_count: z.ZodDefault<z.ZodNumber>;
     retry_count: z.ZodDefault<z.ZodNumber>;
     success: z.ZodBoolean;
+    scope_violation: z.ZodOptional<z.ZodBoolean>;
+    violation_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export declare const HumanFeedbackEventSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodNumber>;
@@ -389,6 +391,8 @@ export declare const AgentEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     error_count: z.ZodDefault<z.ZodNumber>;
     retry_count: z.ZodDefault<z.ZodNumber>;
     success: z.ZodBoolean;
+    scope_violation: z.ZodOptional<z.ZodBoolean>;
+    violation_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodObject<{
     id: z.ZodOptional<z.ZodNumber>;
     project_key: z.ZodString;