@hasna/mementos 0.8.0 → 0.9.0

package/dist/lib/session-auto-resolve.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Auto-resolve agent_id and project_id from session metadata.
+ * When a session is ingested without explicit agent/project context,
+ * try to detect them from available metadata fields.
+ */
+import type { Database } from "bun:sqlite";
+export interface AutoResolveResult {
+    agentId: string | null;
+    projectId: string | null;
+    confidence: "high" | "low" | "none";
+    method: string;
+}
+/**
+ * Attempt to resolve agent_id and project_id from metadata fields.
+ *
+ * Strategy:
+ * 1. If metadata.agentName matches an existing agent → agentId = agent.id, confidence=high
+ * 2. If metadata.workingDir matches a registered project path → projectId = project.id, confidence=high
+ * 3. If metadata.gitRemote contains a repo name that matches a project name → confidence=low
+ * 4. Otherwise confidence=none
+ */
+export declare function autoResolveAgentProject(metadata: {
+    workingDir?: string;
+    agentName?: string;
+    gitRemote?: string;
+    sessionSource?: string;
+}, db?: Database): AutoResolveResult;
+//# sourceMappingURL=session-auto-resolve.d.ts.map

package/dist/lib/session-auto-resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-auto-resolve.d.ts","sourceRoot":"","sources":["../../src/lib/session-auto-resolve.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAQ3C,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;CAChB;AAMD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE;IACR,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,EACD,EAAE,CAAC,EAAE,QAAQ,GACZ,iBAAiB,CAsFnB"}

package/dist/lib/session-processor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Session transcript processor.
+ * Takes a full session transcript, chunks it, calls LLM to extract memories,
+ * saves extracted memories tagged with session_id + source.
+ * All failures are silently caught — never throws.
+ */
+import type { Database } from "bun:sqlite";
+export interface ChunkResult {
+    chunkIndex: number;
+    memoriesExtracted: number;
+}
+export interface ProcessingResult {
+    jobId: string;
+    chunksProcessed: number;
+    memoriesExtracted: number;
+    errors: string[];
+}
+/**
+ * Split a transcript into chunks with overlap.
+ */
+export declare function chunkTranscript(transcript: string, chunkSize?: number, overlap?: number): string[];
+/**
+ * Extract memories from a single chunk using the available LLM provider.
+ * Returns the count of memories saved.
+ */
+export declare function extractMemoriesFromChunk(chunk: string, context: {
+    sessionId: string;
+    agentId?: string;
+    projectId?: string;
+    source?: string;
+}, db?: Database): Promise<number>;
+/**
+ * Process a session memory job end-to-end.
+ * Fetches the job, marks it processing, chunks transcript, extracts memories.
+ * Updates job status to completed or failed.
+ */
+export declare function processSessionJob(jobId: string, db?: Database): Promise<ProcessingResult>;
+//# sourceMappingURL=session-processor.d.ts.map

package/dist/lib/session-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-processor.d.ts","sourceRoot":"","sources":["../../src/lib/session-processor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAa3C,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAaD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,SAAS,SAAO,EAChB,OAAO,SAAM,GACZ,MAAM,EAAE,CAeV;AAMD;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IACP,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,EACD,EAAE,CAAC,EAAE,QAAQ,GACZ,OAAO,CAAC,MAAM,CAAC,CAyHjB;AAMD;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,MAAM,EACb,EAAE,CAAC,EAAE,QAAQ,GACZ,OAAO,CAAC,gBAAgB,CAAC,CA+F3B"}

package/dist/lib/session-queue.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Background queue for session memory job processing.
+ * Polls for pending jobs every 5 seconds, processes one at a time (concurrency=1).
+ * Fire-and-forget: enqueueSessionJob() returns immediately, processing happens async.
+ */
+export interface SessionQueueStats {
+    pending: number;
+    processing: number;
+    completed: number;
+    failed: number;
+}
+/**
+ * Enqueue a job ID for processing. Fire-and-forget.
+ * The background worker will pick it up within the next polling interval.
+ */
+export declare function enqueueSessionJob(jobId: string): void;
+/**
+ * Get in-memory queue stats.
+ * Note: pending/completed/failed counts come from DB when a full scan is needed;
+ * this returns a lightweight in-memory snapshot.
+ */
+export declare function getSessionQueueStats(): SessionQueueStats;
+/**
+ * Start the background polling worker.
+ * Idempotent — safe to call multiple times (only starts once).
+ */
+export declare function startSessionQueueWorker(): void;
+//# sourceMappingURL=session-queue.d.ts.map

package/dist/lib/session-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-queue.d.ts","sourceRoot":"","sources":["../../src/lib/session-queue.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAeD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMrD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CA6BxD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAQ9C"}

package/dist/mcp/index.js

@@ -491,7 +491,30 @@ var init_database = __esm(() => {
   CREATE INDEX IF NOT EXISTS idx_webhook_hooks_type ON webhook_hooks(type);
   CREATE INDEX IF NOT EXISTS idx_webhook_hooks_enabled ON webhook_hooks(enabled);
   INSERT OR IGNORE INTO _migrations (id) VALUES (10);
-  `
+  `,
+    `
+CREATE TABLE IF NOT EXISTS session_memory_jobs (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  agent_id TEXT,
+  project_id TEXT,
+  source TEXT NOT NULL DEFAULT 'manual' CHECK(source IN ('claude-code','codex','manual','open-sessions')),
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','processing','completed','failed')),
+  transcript TEXT NOT NULL,
+  chunk_count INTEGER NOT NULL DEFAULT 0,
+  memories_extracted INTEGER NOT NULL DEFAULT 0,
+  error TEXT,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  started_at TEXT,
+  completed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_status ON session_memory_jobs(status);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_agent ON session_memory_jobs(agent_id);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_project ON session_memory_jobs(project_id);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_session ON session_memory_jobs(session_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (13);
+`
   ];
 });
 
@@ -8494,6 +8517,351 @@ function getSynthesisStatus(runId, projectId, db) {
 
 // src/mcp/index.ts
 init_synthesis();
+
+// src/db/session-jobs.ts
+init_database();
+function parseJobRow(row) {
+  return {
+    id: row["id"],
+    session_id: row["session_id"],
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    source: row["source"],
+    status: row["status"],
+    transcript: row["transcript"],
+    chunk_count: row["chunk_count"],
+    memories_extracted: row["memories_extracted"],
+    error: row["error"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"],
+    started_at: row["started_at"] || null,
+    completed_at: row["completed_at"] || null
+  };
+}
+function createSessionJob(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const source = input.source ?? "manual";
+  const metadata = JSON.stringify(input.metadata ?? {});
+  d.run(`INSERT INTO session_memory_jobs
+      (id, session_id, agent_id, project_id, source, status, transcript, chunk_count, memories_extracted, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, 'pending', ?, 0, 0, ?, ?)`, [
+    id,
+    input.session_id,
+    input.agent_id ?? null,
+    input.project_id ?? null,
+    source,
+    input.transcript,
+    metadata,
+    timestamp
+  ]);
+  return getSessionJob(id, d);
+}
+function getSessionJob(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM session_memory_jobs WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return parseJobRow(row);
+}
+function listSessionJobs(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filter.agent_id);
+  }
+  if (filter?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter?.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  if (filter?.session_id) {
+    conditions.push("session_id = ?");
+    params.push(filter.session_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filter?.limit ?? 20;
+  const offset = filter?.offset ?? 0;
+  const rows = d.query(`SELECT * FROM session_memory_jobs ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  return rows.map(parseJobRow);
+}
+function updateSessionJob(id, updates, db) {
+  const d = db || getDatabase();
+  const setClauses = [];
+  const params = [];
+  if (updates.status !== undefined) {
+    setClauses.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.chunk_count !== undefined) {
+    setClauses.push("chunk_count = ?");
+    params.push(updates.chunk_count);
+  }
+  if (updates.memories_extracted !== undefined) {
+    setClauses.push("memories_extracted = ?");
+    params.push(updates.memories_extracted);
+  }
+  if ("error" in updates) {
+    setClauses.push("error = ?");
+    params.push(updates.error ?? null);
+  }
+  if ("started_at" in updates) {
+    setClauses.push("started_at = ?");
+    params.push(updates.started_at ?? null);
+  }
+  if ("completed_at" in updates) {
+    setClauses.push("completed_at = ?");
+    params.push(updates.completed_at ?? null);
+  }
+  if (setClauses.length === 0)
+    return getSessionJob(id, d);
+  params.push(id);
+  d.run(`UPDATE session_memory_jobs SET ${setClauses.join(", ")} WHERE id = ?`, params);
+  return getSessionJob(id, d);
+}
+function getNextPendingJob(db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM session_memory_jobs WHERE status = 'pending' ORDER BY created_at ASC LIMIT 1").get();
+  if (!row)
+    return null;
+  return parseJobRow(row);
+}
+
+// src/lib/session-queue.ts
+init_database();
+
+// src/lib/session-processor.ts
+init_memories();
+init_registry();
+var SESSION_EXTRACTION_USER_TEMPLATE = (chunk, sessionId) => `Extract memories from this session chunk (session: ${sessionId}):
+
+${chunk}
+
+Return JSON array: [{"key": "...", "value": "...", "category": "knowledge|fact|preference|history", "importance": 1-10, "tags": [...]}]`;
+function chunkTranscript(transcript, chunkSize = 2000, overlap = 200) {
+  if (!transcript || transcript.length === 0)
+    return [];
+  if (transcript.length <= chunkSize)
+    return [transcript];
+  const chunks = [];
+  let start = 0;
+  while (start < transcript.length) {
+    const end = Math.min(start + chunkSize, transcript.length);
+    chunks.push(transcript.slice(start, end));
+    if (end === transcript.length)
+      break;
+    start += chunkSize - overlap;
+  }
+  return chunks;
+}
+async function extractMemoriesFromChunk(chunk, context, db) {
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return 0;
+  try {
+    const extracted = await provider.extractMemories(SESSION_EXTRACTION_USER_TEMPLATE(chunk, context.sessionId), {
+      sessionId: context.sessionId,
+      agentId: context.agentId,
+      projectId: context.projectId
+    });
+    let savedCount = 0;
+    const sourceTag = context.source ? `source:${context.source}` : "source:manual";
+    for (const memory of extracted) {
+      if (!memory.content || !memory.content.trim())
+        continue;
+      try {
+        createMemory({
+          key: memory.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
+          value: memory.content,
+          category: memory.category,
+          scope: memory.suggestedScope ?? "shared",
+          importance: memory.importance,
+          tags: [
+            ...memory.tags,
+            "session-extracted",
+            sourceTag,
+            `session:${context.sessionId}`
+          ],
+          source: "auto",
+          agent_id: context.agentId,
+          project_id: context.projectId,
+          session_id: context.sessionId,
+          metadata: {
+            auto_extracted: true,
+            session_source: context.source ?? "manual",
+            extracted_at: new Date().toISOString(),
+            reasoning: memory.reasoning
+          }
+        }, "merge", db);
+        savedCount++;
+      } catch {}
+    }
+    return savedCount;
+  } catch {
+    try {
+      const fallbacks = providerRegistry.getFallbacks();
+      for (const fallback of fallbacks) {
+        try {
+          const extracted = await fallback.extractMemories(SESSION_EXTRACTION_USER_TEMPLATE(chunk, context.sessionId), {
+            sessionId: context.sessionId,
+            agentId: context.agentId,
+            projectId: context.projectId
+          });
+          let savedCount = 0;
+          const sourceTag = context.source ? `source:${context.source}` : "source:manual";
+          for (const memory of extracted) {
+            if (!memory.content || !memory.content.trim())
+              continue;
+            try {
+              createMemory({
+                key: memory.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
+                value: memory.content,
+                category: memory.category,
+                scope: memory.suggestedScope ?? "shared",
+                importance: memory.importance,
+                tags: [
+                  ...memory.tags,
+                  "session-extracted",
+                  sourceTag,
+                  `session:${context.sessionId}`
+                ],
+                source: "auto",
+                agent_id: context.agentId,
+                project_id: context.projectId,
+                session_id: context.sessionId,
+                metadata: {
+                  auto_extracted: true,
+                  session_source: context.source ?? "manual",
+                  extracted_at: new Date().toISOString(),
+                  reasoning: memory.reasoning
+                }
+              }, "merge", db);
+              savedCount++;
+            } catch {}
+          }
+          if (savedCount > 0)
+            return savedCount;
+        } catch {
+          continue;
+        }
+      }
+    } catch {}
+    return 0;
+  }
+}
+async function processSessionJob(jobId, db) {
+  const result = {
+    jobId,
+    chunksProcessed: 0,
+    memoriesExtracted: 0,
+    errors: []
+  };
+  let job;
+  try {
+    job = getSessionJob(jobId, db);
+    if (!job) {
+      result.errors.push(`Job not found: ${jobId}`);
+      return result;
+    }
+  } catch (e) {
+    result.errors.push(`Failed to fetch job: ${String(e)}`);
+    return result;
+  }
+  try {
+    updateSessionJob(jobId, { status: "processing", started_at: new Date().toISOString() }, db);
+  } catch (e) {
+    result.errors.push(`Failed to mark job as processing: ${String(e)}`);
+    return result;
+  }
+  const chunks = chunkTranscript(job.transcript);
+  try {
+    updateSessionJob(jobId, { chunk_count: chunks.length }, db);
+  } catch {}
+  let totalMemories = 0;
+  for (let i = 0;i < chunks.length; i++) {
+    const chunk = chunks[i];
+    try {
+      const count = await extractMemoriesFromChunk(chunk, {
+        sessionId: job.session_id,
+        agentId: job.agent_id ?? undefined,
+        projectId: job.project_id ?? undefined,
+        source: job.source
+      }, db);
+      totalMemories += count;
+      result.chunksProcessed++;
+    } catch (e) {
+      result.errors.push(`Chunk ${i} failed: ${String(e)}`);
+    }
+  }
+  result.memoriesExtracted = totalMemories;
+  try {
+    if (result.errors.length > 0 && result.chunksProcessed === 0) {
+      updateSessionJob(jobId, {
+        status: "failed",
+        error: result.errors.join("; "),
+        completed_at: new Date().toISOString(),
+        memories_extracted: totalMemories,
+        chunk_count: chunks.length
+      }, db);
+    } else {
+      updateSessionJob(jobId, {
+        status: "completed",
+        completed_at: new Date().toISOString(),
+        memories_extracted: totalMemories,
+        chunk_count: chunks.length
+      }, db);
+    }
+  } catch (e) {
+    result.errors.push(`Failed to update job status: ${String(e)}`);
+  }
+  return result;
+}
+
+// src/lib/session-queue.ts
+var _pendingQueue = new Set;
+var _isProcessing = false;
+function enqueueSessionJob(jobId) {
+  _pendingQueue.add(jobId);
+  if (!_isProcessing) {
+    _processNext();
+  }
+}
+async function _processNext() {
+  if (_isProcessing)
+    return;
+  let jobId;
+  if (_pendingQueue.size > 0) {
+    jobId = [..._pendingQueue][0];
+    _pendingQueue.delete(jobId);
+  } else {
+    try {
+      const job = getNextPendingJob();
+      if (job)
+        jobId = job.id;
+    } catch {
+      return;
+    }
+  }
+  if (!jobId)
+    return;
+  _isProcessing = true;
+  try {
+    await processSessionJob(jobId);
+  } catch {} finally {
+    _isProcessing = false;
+    if (_pendingQueue.size > 0) {
+      _processNext();
+    }
+  }
+}
+
+// src/mcp/index.ts
 init_auto_memory();
 init_registry();
 import { createRequire } from "module";
@@ -10712,6 +11080,50 @@ server.tool("memory_auto_test", "Test memory extraction on text WITHOUT saving a
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("memory_ingest_session", "Submit a session transcript for async memory extraction. Returns job_id to track progress.", {
+  transcript: exports_external.string(),
+  session_id: exports_external.string(),
+  agent_id: exports_external.string().optional(),
+  project_id: exports_external.string().optional(),
+  source: exports_external.enum(["claude-code", "codex", "manual", "open-sessions"]).optional()
+}, async (args) => {
+  try {
+    const job = createSessionJob({
+      session_id: args.session_id,
+      transcript: args.transcript,
+      source: args.source ?? "manual",
+      agent_id: args.agent_id,
+      project_id: args.project_id
+    });
+    enqueueSessionJob(job.id);
+    return { content: [{ type: "text", text: JSON.stringify({ job_id: job.id, status: "queued" }, null, 2) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
+server.tool("memory_session_status", "Get the status of a session memory extraction job.", { job_id: exports_external.string() }, async (args) => {
+  try {
+    const job = getSessionJob(args.job_id);
+    if (!job)
+      return { content: [{ type: "text", text: `Job not found: ${args.job_id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(job, null, 2) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
+server.tool("memory_session_list", "List session memory extraction jobs.", {
+  agent_id: exports_external.string().optional(),
+  project_id: exports_external.string().optional(),
+  status: exports_external.enum(["pending", "processing", "completed", "failed"]).optional(),
+  limit: exports_external.coerce.number().optional()
+}, async (args) => {
+  try {
+    const jobs = listSessionJobs({ agent_id: args.agent_id, project_id: args.project_id, status: args.status, limit: args.limit ?? 20 });
+    return { content: [{ type: "text", text: JSON.stringify(jobs, null, 2) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 async function main() {
   loadWebhooksFromDb();
   const transport = new StdioServerTransport;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":";AACA;;;GAGG;AAs9CH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAgI9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":";AACA;;;GAGG;AA6gDH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAkI9C"}