@bunkercache/opencode-memoir 0.2.3 → 0.3.0

package/dist/index.js

@@ -161,12 +161,16 @@ function resolveStoragePaths(worktree, projectId, config) {
     const relativePath = getGitignoreRelativePath(memoryDb.path, worktree);
     if (relativePath) {
       gitignorePaths.push(relativePath);
+      gitignorePaths.push(`${relativePath}-shm`);
+      gitignorePaths.push(`${relativePath}-wal`);
     }
   }
   if (historyDb?.isLocal && historyDb.manageGitignore && !sharedDatabase) {
     const relativePath = getGitignoreRelativePath(historyDb.path, worktree);
     if (relativePath && !gitignorePaths.includes(relativePath)) {
       gitignorePaths.push(relativePath);
+      gitignorePaths.push(`${relativePath}-shm`);
+      gitignorePaths.push(`${relativePath}-wal`);
     }
   }
   return {
@@ -1616,6 +1620,37 @@ class ChunkService {
   getRecentSummaryChunks(limit = 5) {
     return this.repository.getRecentSummaryChunks(limit);
   }
+  getRecentChunks(options) {
+    const limit = options?.limit ?? 10;
+    let sql = `
+      SELECT id, session_id, parent_id, depth, child_refs, content, summary,
+             status, created_at, finalized_at, compacted_at, embedding
+      FROM chunks
+    `;
+    const params = [];
+    if (options?.sessionId) {
+      sql += " WHERE session_id = ?";
+      params.push(options.sessionId);
+    }
+    sql += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit);
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...params);
+    return rows.map((row) => ({
+      id: row.id,
+      sessionId: row.session_id,
+      parentId: row.parent_id,
+      depth: row.depth,
+      childRefs: row.child_refs ? JSON.parse(row.child_refs) : null,
+      content: JSON.parse(row.content),
+      summary: row.summary,
+      status: row.status,
+      createdAt: row.created_at,
+      finalizedAt: row.finalized_at,
+      compactedAt: row.compacted_at,
+      embedding: row.embedding
+    }));
+  }
 }
 var chunkService = null;
 function initializeChunkService(db, config) {
@@ -14556,28 +14591,89 @@ function estimateTokens2(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN2);
 }
 var historyTool = tool({
-  description: `Search session history for past work. Returns compact chunk summaries with IDs that can be expanded.
+  description: `Browse or search session history. Returns chunk summaries with IDs for memoir_expand.
+
+DEFAULTS: Searches current session only. Returns recent chunks if no query provided.
+
+OPTIONS:
+- query: Search text (omit to list recent chunks)
+- all_sessions: true to include past sessions  
+- limit: Max results (default 10)
 
-CONTEXT BUDGET: Results are summaries (~50-200 tokens each). To view full chunk content, use memoir_expand. For deep exploration of multiple chunks, consider delegating to a subagent.`,
+Use memoir_expand({ chunk_id }) to see full content of any chunk.`,
   args: {
-    query: tool.schema.string().describe("Search query for finding relevant history"),
-    session_id: tool.schema.string().optional().describe("Limit search to a specific session"),
-    depth: tool.schema.number().optional().describe("Minimum depth to search (0 = original chunks, higher = summaries)"),
-    limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 10, max recommended: 20)")
+    query: tool.schema.string().optional().describe("Search query (omit to list recent chunks without searching)"),
+    all_sessions: tool.schema.boolean().optional().describe("Include past sessions (default: current session only)"),
+    session_ids: tool.schema.array(tool.schema.string()).optional().describe("Search specific session IDs"),
+    depth: tool.schema.number().optional().describe("Minimum chunk depth (0=original, 1+=summaries)"),
+    limit: tool.schema.number().optional().describe("Max results (default: 10)")
   },
-  async execute(args) {
+  async execute(args, context) {
     const chunkService2 = getChunkService();
-    const results = chunkService2.search(args.query, {
-      sessionId: args.session_id,
+    let sessionId;
+    let searchScope;
+    if (args.session_ids && args.session_ids.length > 0) {
+      sessionId = args.session_ids[0];
+      searchScope = `sessions: ${args.session_ids.join(", ")}`;
+    } else if (args.all_sessions) {
+      sessionId = undefined;
+      searchScope = "all sessions";
+    } else {
+      sessionId = context.sessionID;
+      searchScope = "current session";
+    }
+    const limit = args.limit ?? 10;
+    const query = args.query?.trim();
+    if (!query) {
+      const recentChunks = chunkService2.getRecentChunks({
+        sessionId,
+        limit
+      });
+      if (recentChunks.length === 0) {
+        return JSON.stringify({
+          success: true,
+          count: 0,
+          scope: searchScope,
+          mode: "recent",
+          message: `No chunks found in ${searchScope}`,
+          hint: args.all_sessions ? undefined : "Try with all_sessions: true to see past sessions"
+        });
+      }
+      const formatted2 = recentChunks.map((c) => ({
+        id: c.id,
+        sessionId: c.sessionId,
+        depth: c.depth,
+        status: c.status,
+        summary: c.summary || `${c.content.messages.length} messages`,
+        created: new Date(c.createdAt * 1000).toISOString(),
+        stats: {
+          messages: c.content.messages.length,
+          files_modified: c.content.metadata.files_modified?.length || 0
+        }
+      }));
+      return JSON.stringify({
+        success: true,
+        count: formatted2.length,
+        scope: searchScope,
+        mode: "recent",
+        chunks: formatted2,
+        hint: 'Use memoir_expand({ chunk_id: "ch_xxx" }) to see full content.'
+      });
+    }
+    const results = chunkService2.search(query, {
+      sessionId,
       depth: args.depth,
-      limit: args.limit
+      limit
     });
     if (results.length === 0) {
       return JSON.stringify({
         success: true,
         count: 0,
-        estimated_tokens: 50,
-        message: "No matching chunks found"
+        scope: searchScope,
+        mode: "search",
+        query,
+        message: `No matches for "${query}" in ${searchScope}`,
+        hint: args.all_sessions ? undefined : "Try with all_sessions: true to search past sessions"
       });
     }
     const formatted = results.map((r) => {
@@ -14608,10 +14704,13 @@ CONTEXT BUDGET: Results are summaries (~50-200 tokens each). To view full chunk
     const response = {
       success: true,
       count: results.length,
+      scope: searchScope,
+      mode: "search",
+      query,
       estimated_tokens: estimatedTokens,
       estimated_expanded_tokens: estimatedExpandedTokens,
       chunks: formatted,
-      hint: 'Use memoir_expand({ chunk_id: "ch_xxx", preview_only: true }) to check size before full expansion.'
+      hint: 'Use memoir_expand({ chunk_id: "ch_xxx" }) to see full content.'
     };
     if (estimatedExpandedTokens > LARGE_RESULT_TOKEN_THRESHOLD && results.length > 3) {
       response.warning = `Expanding all ${results.length} results would use ~${estimatedExpandedTokens} tokens. Consider using memoir_expand with preview_only=true first, or delegate detailed analysis to a subagent.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunkercache/opencode-memoir",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "A smart memory management plugin for OpenCode that supports nested aggregation of memory, summaries, and file changes that compact in layers with upstream references for lookups.",
   "author": {
     "name": "Chris Tunbridge",