indelible-mcp 2.8.2 → 2.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "2.8.2",
+  "version": "2.9.0",
   "description": "Blockchain-backed memory and code storage for Claude Code. Save AI conversations and source code permanently on BSV.",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -223,7 +223,7 @@ Commands:
 
 function printHelp() {
   console.log(`
-Indelible MCP — Blockchain memory for Claude Code (v2.8.2)
+Indelible MCP — Blockchain memory for Claude Code (v2.9.0)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -324,7 +324,7 @@ function readStdin() {
 
 const SERVER_INFO = {
   name: 'indelible',
-  version: '2.8.2',
+  version: '2.9.0',
   description: 'Blockchain-backed memory and code storage for Claude Code'
 }
 

package/src/tools/save_session.js

@@ -16,11 +16,22 @@
 import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync, readdirSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { homedir } from 'node:os'
+import { execSync } from 'node:child_process'
 import { loadConfig, saveConfig, getWif } from '../lib/config.js'
 import { encrypt, sha256 } from '../lib/crypto.js'
 import { findCurrentTranscript, parseTranscript } from '../lib/transcript.js'
 import * as spv from '../lib/spv.js'
 import { indexSession } from '../lib/api-client.js'
+import { saveFile } from './save_file.js'
+
+/**
+ * Derive memory directory from transcript path.
+ * Transcript lives at ~/.claude/projects/<slug>/UUID.jsonl
+ * Memory dir is ~/.claude/projects/<slug>/memory/
+ */
+function getMemoryDir(transcriptPath) {
+  return join(dirname(transcriptPath), 'memory')
+}
 
 function createSummary(messages, userSummary) {
   if (userSummary) return userSummary
@@ -34,9 +45,21 @@ function createSummary(messages, userSummary) {
   return 'Claude Code session'
 }
 
-function updateDiary(diaryPath, summary, timestamp) {
+/**
+ * Append session entry to diary file (local backup).
+ * Searches for *DIARY*.md in the project working directory.
+ * If no diary file exists, skips silently.
+ */
+function updateDiary(summary, timestamp, transcriptPath) {
   try {
-    if (!diaryPath || !existsSync(diaryPath)) return
+    // Find diary file dynamically — look in project root (2 levels up from transcript)
+    const projectDir = dirname(dirname(transcriptPath))
+    let files
+    try { files = readdirSync(projectDir) } catch { return }
+    const diaryFile = files.find(f => /diary/i.test(f) && f.endsWith('.md'))
+    if (!diaryFile) return
+    const diaryPath = join(projectDir, diaryFile)
+    if (!existsSync(diaryPath)) return
     const diary = readFileSync(diaryPath, 'utf-8')
     const date = new Date(timestamp)
     const dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })
@@ -53,6 +76,99 @@ function updateDiary(diaryPath, summary, timestamp) {
   } catch { /* don't block */ }
 }
 
+/**
+ * Update MEMORY.md with latest session info (local backup).
+ * Derives memory path from transcript path — works for any user.
+ * Also scans recent git commits to auto-update feature statuses.
+ */
+function updateMemory(summary, timestamp, messageCount, transcriptPath) {
+  try {
+    const memoryDir = getMemoryDir(transcriptPath)
+    const memoryPath = join(memoryDir, 'MEMORY.md')
+    if (!existsSync(memoryPath)) return
+    let memory = readFileSync(memoryPath, 'utf-8')
+    const date = new Date(timestamp)
+    const dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })
+    const timeStr = date.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true })
+    // Update or insert last session tracking block
+    const sessionBlock = `## Last Session\n- **Date:** ${dateStr} @ ${timeStr}\n- **Summary:** ${summary}\n- **Messages:** ${messageCount}`
+    const marker = '## Last Session'
+    const idx = memory.indexOf(marker)
+    if (idx !== -1) {
+      const nextHeading = memory.indexOf('\n## ', idx + marker.length)
+      const end = nextHeading !== -1 ? nextHeading : memory.length
+      memory = memory.slice(0, idx) + sessionBlock + memory.slice(end)
+    } else {
+      const firstNewline = memory.indexOf('\n')
+      memory = memory.slice(0, firstNewline + 1) + '\n' + sessionBlock + '\n' + memory.slice(firstNewline + 1)
+    }
+
+    // Git commit scanning — auto-update feature statuses
+    try {
+      const cwd = process.cwd()
+      if (existsSync(join(cwd, '.git'))) {
+        const gitLog = execSync('git log --oneline -10', { cwd, encoding: 'utf-8', timeout: 5000 })
+        const commits = gitLog.trim().split('\n').map(l => l.toLowerCase())
+
+        const doneKeywords = ['complete', 'done', 'finish', 'fix', 'deploy', 'ship', 'release']
+        const sectionRegex = /^## (.+?)(?:\s*\(.*?IN PROGRESS.*?\))/gm
+        let match
+        while ((match = sectionRegex.exec(memory)) !== null) {
+          const sectionName = match[1].toLowerCase().trim()
+          const sectionWords = sectionName.split(/[\s—\-:]+/).filter(w => w.length > 2)
+          const hasMatch = commits.some(commit =>
+            sectionWords.some(word => commit.includes(word)) &&
+            doneKeywords.some(word => commit.includes(word))
+          )
+          if (hasMatch) {
+            memory = memory.replace(match[0], match[0].replace('IN PROGRESS', 'COMPLETE'))
+          }
+        }
+      }
+    } catch { /* git scan is best-effort */ }
+
+    // Line count warning
+    const lineCount = memory.split('\n').length
+    if (lineCount > 195) {
+      process.stderr.write(`[MCP] Warning: MEMORY.md is ${lineCount} lines (limit: 200). Consider trimming.\n`)
+    }
+
+    writeFileSync(memoryPath, memory)
+  } catch { /* don't block save on memory failure */ }
+}
+
+/**
+ * Append a timestamped session recap to session-history.md.
+ * Full rolling log — no line limit. Creates file if it doesn't exist.
+ */
+function updateSessionHistory(transcriptPath, summary, timestamp, messageCount, saveType, newMessages, txId, structuredCtx) {
+  try {
+    const memoryDir = getMemoryDir(transcriptPath)
+    if (!existsSync(memoryDir)) mkdirSync(memoryDir, { recursive: true })
+    const historyPath = join(memoryDir, 'session-history.md')
+
+    const date = new Date(timestamp)
+    const dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })
+    const timeStr = date.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true })
+
+    const lines = [`### ${dateStr} @ ${timeStr}`]
+    lines.push(`- **Summary:** ${summary}`)
+    lines.push(`- **Messages:** ${messageCount}${newMessages ? ` (${saveType}: ${newMessages} new)` : ''}`)
+    if (structuredCtx?.git_branch) lines.push(`- **Git branch:** ${structuredCtx.git_branch}`)
+    if (txId) lines.push(`- **Tx:** ${txId.slice(0, 12)}...`)
+    lines.push('')
+
+    let existing = ''
+    if (existsSync(historyPath)) {
+      existing = readFileSync(historyPath, 'utf-8')
+    } else {
+      existing = '# Session History\n\nTimestamped session recaps — full rolling log.\n\n'
+    }
+
+    writeFileSync(historyPath, existing + lines.join('\n'))
+  } catch { /* don't block save on history failure */ }
+}
+
 function ensureJsonlBackup(path, messages) {
   try {
     const dir = dirname(path)
@@ -180,7 +296,8 @@ export async function saveSession(transcriptPath, summary) {
   } catch { /* don't block save on structured context failure */ }
 
   // Local backups (fire-and-forget)
-  if (config.diary_path) updateDiary(config.diary_path, session.summary, session.created_at)
+  updateDiary(session.summary, session.created_at, actualPath)
+  updateMemory(session.summary, session.created_at, allMessages.length, actualPath)
   if (transcriptPath) ensureJsonlBackup(transcriptPath, allMessages)
 
   // Encrypt locally — WIF never leaves
@@ -202,7 +319,7 @@ export async function saveSession(transcriptPath, summary) {
   // Build + sign transaction LOCALLY with @bsv/sdk
   try {
     const utxos = await spv.getUtxos(config.address)
-    const { txHex, txId } = await spv.buildOpReturnTx(wif, utxos, JSON.stringify(payload))
+    const { txHex, txId, changeUtxos } = await spv.buildOpReturnTxWithChange(wif, utxos, JSON.stringify(payload))
 
     // Broadcast via SPV bridge (gated by API key)
     const broadcastResult = await spv.broadcastTx(txHex)
@@ -223,18 +340,67 @@ export async function saveSession(transcriptPath, summary) {
       }, config)
     } catch { /* indexing failure doesn't block save */ }
 
+    // Update session history with txId now that we have it
+    const structuredCtx = session.structured_context || {}
+    updateSessionHistory(
+      actualPath, session.summary, session.created_at,
+      allMessages.length, isDelta ? 'delta' : 'full',
+      messagesToCommit.length, finalTxId, structuredCtx
+    )
+
+    // Save memory files to blockchain via vault pipeline (UTXO chaining)
+    let memoryTxId = config.memory_file_txid || null
+    let historyTxId = config.session_history_txid || null
+    let memChangeUtxos = changeUtxos || []
+
+    if (config.memory_auto_save !== false && memChangeUtxos.length > 0) {
+      try {
+        const memoryDir = getMemoryDir(actualPath)
+        const memoryPath = join(memoryDir, 'MEMORY.md')
+        const historyPath = join(memoryDir, 'session-history.md')
+
+        // Save MEMORY.md to chain
+        if (existsSync(memoryPath)) {
+          const memResult = await saveFile(memoryPath, {
+            relativePath: 'memory/MEMORY.md',
+            utxos: memChangeUtxos
+          })
+          if (memResult.success) {
+            memoryTxId = memResult.txId
+            memChangeUtxos = memResult.changeUtxos || []
+          }
+        }
+
+        // Save session-history.md to chain (using change from MEMORY.md tx)
+        if (existsSync(historyPath) && memChangeUtxos.length > 0) {
+          const histResult = await saveFile(historyPath, {
+            relativePath: 'memory/session-history.md',
+            utxos: memChangeUtxos
+          })
+          if (histResult.success) {
+            historyTxId = histResult.txId
+          }
+        }
+      } catch {
+        // Memory file saves are best-effort — session save already succeeded
+      }
+    }
+
     // Update config for next delta
     saveConfig({
       ...config,
       last_session_id: sessionId,
       last_tx_id: finalTxId,
       last_saved_message_count: allMessages.length,
-      last_saved_transcript: actualPath
+      last_saved_transcript: actualPath,
+      memory_file_txid: memoryTxId,
+      session_history_txid: historyTxId
     })
 
     const deltaInfo = isDelta
       ? ` (delta: ${messagesToCommit.length} new, ${allMessages.length} total)`
       : ` (full: ${allMessages.length} messages)`
+    const memInfo = memoryTxId ? ' Memory files saved.' : ''
 
     return {
       success: true,
@@ -245,7 +411,9 @@ export async function saveSession(transcriptPath, summary) {
       newMessages: messagesToCommit.length,
       saveType: isDelta ? 'delta' : 'full',
       summary: session.summary,
-      message: `Session saved!${deltaInfo} committed to blockchain.${prevSessionId ? ' Linked to previous session.' : ' (First session)'}`
+      memoryTxId,
+      historyTxId,
+      message: `Session saved!${deltaInfo} committed to blockchain.${prevSessionId ? ' Linked to previous session.' : ' (First session)'}${memInfo}`
     }
   } catch (error) {
     return { success: false, error: `Failed to commit: ${error.message}` }