indelible-mcp 2.6.1 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "2.6.1",
+  "version": "2.8.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

@@ -27,6 +27,9 @@ import { loadProject } from './tools/load_project.js'
 import { saveStyle, saveStyleFromFile } from './tools/save_style.js'
 import { loadStyle } from './tools/load_style.js'
 import { updateVaultIndex } from './tools/update_vault_index.js'
+import { diaryConnect } from './tools/diary_connect.js'
+import { diaryChat } from './tools/diary_chat.js'
+import { diarySave } from './tools/diary_save.js'
 
 const CONTEXT_FILE = join(homedir(), '.indelible', 'indelible-context.jsonl')
 
@@ -220,7 +223,7 @@ Commands:
 
 function printHelp() {
   console.log(`
-Indelible MCP — Blockchain memory for Claude Code (v2.6.1)
+Indelible MCP — Blockchain memory for Claude Code (v2.8.0)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -243,6 +246,11 @@ Code Vault:
   indelible-mcp vault load-style [txid]                       Load an AI style
   indelible-mcp vault update-index                            Update vault index
 
+Diary AI (Codex/ChatGPT companion):
+  indelible-mcp diary connect --key=SK --model=MODEL  Connect OpenAI companion
+  indelible-mcp diary chat "message"                  Ask the AI companion
+  indelible-mcp diary save                            Save exchange to blockchain
+
 Hooks (auto-called by Claude Code):
   indelible-mcp hook pre-compact             Auto-save before compaction
   indelible-mcp hook post-compact            Auto-restore after compaction
@@ -316,7 +324,7 @@ function readStdin() {
 
 const SERVER_INFO = {
   name: 'indelible',
-  version: '2.6.1',
+  version: '2.8.0',
   description: 'Blockchain-backed memory and code storage for Claude Code'
 }
 
@@ -436,6 +444,48 @@ const TOOLS = [
       properties: {},
       required: []
     }
+  },
+  {
+    name: 'diary_connect',
+    description: 'Connect Diary AI companion (Codex/ChatGPT). Stores your OpenAI API key and model preference.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        api_key: { type: 'string', description: 'OpenAI API key (sk-...)' },
+        model: { type: 'string', description: 'Model ID (default: gpt-4o). Options: gpt-5.2, gpt-5, gpt-5-nano, gpt-4o, gpt-4o-mini, o1' },
+        name: { type: 'string', description: 'Display name for the AI companion (default: Codex)' }
+      },
+      required: ['api_key']
+    }
+  },
+  {
+    name: 'diary_chat',
+    description: 'Send a message to Diary AI (Codex/ChatGPT). Returns the response with a name badge.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'The message to send to the AI companion' },
+        context: { type: 'string', description: 'Optional context about current work' },
+        system_prompt: { type: 'string', description: 'Optional system prompt override' }
+      },
+      required: ['message']
+    }
+  },
+  {
+    name: 'diary_save',
+    description: 'Save a Diary AI (Codex) exchange to the blockchain. Same WIF, tagged with source.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        messages: {
+          type: 'array',
+          description: 'Array of message objects: [{ role: "user"|"assistant", content: "..." }]',
+          items: { type: 'object', properties: { role: { type: 'string' }, content: { type: 'string' } } }
+        },
+        summary: { type: 'string', description: 'Brief summary of the exchange' }
+      },
+      required: ['messages']
+    }
   }
 ]
 
@@ -492,6 +542,15 @@ async function handleMcpRequest(request) {
           case 'update_vault_index':
             result = await updateVaultIndex()
             break
+          case 'diary_connect':
+            result = await diaryConnect({ apiKey: args?.api_key, model: args?.model, name: args?.name })
+            break
+          case 'diary_chat':
+            result = await diaryChat({ message: args?.message, context: args?.context, systemPrompt: args?.system_prompt })
+            break
+          case 'diary_save':
+            result = await diarySave({ messages: args?.messages, summary: args?.summary })
+            break
           default:
             throw new Error(`Unknown tool: ${name}`)
         }

package/src/lib/api-client.js

@@ -89,6 +89,33 @@ export async function getStatus(config) {
   return res.json()
 }
 
+/**
+ * Check if user has Pro or Developer tier (required for Diary AI tools)
+ * @param {string} wif - User's WIF
+ * @returns {Promise<{ok: boolean, plan: string, error?: string}>}
+ */
+export async function checkProTier(wif) {
+  try {
+    const res = await fetch(`${getApiUrl()}/api/stripe/subscription-status-wif`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ wif }),
+      signal: AbortSignal.timeout(5000)
+    })
+    if (res.ok) {
+      const data = await res.json()
+      if (data.plan === 'admin' || data.plan === 'pro' || data.plan === 'developer') {
+        return { ok: true, plan: data.plan }
+      }
+      return { ok: false, plan: data.plan || 'free', error: 'Pro tier required for Diary AI companion. Upgrade at indelible.one/pricing' }
+    }
+  } catch {
+    // Server unreachable — allow (offline-first)
+    return { ok: true, plan: 'unknown' }
+  }
+  return { ok: true, plan: 'unknown' }
+}
+
 /**
  * Check if server is reachable
  */

package/src/tools/diary_chat.js

@@ -0,0 +1,130 @@
+/**
+ * diary_chat — Send a message to Diary AI (Codex/ChatGPT)
+ *
+ * Calls OpenAI chat completions API directly using the config
+ * set by diary_connect. Returns the response formatted with
+ * a name badge for display in Claude Code chat.
+ *
+ * Usage:
+ *   diary_chat({ message: 'How should we architect this?', context: 'Working on SPV bridge...' })
+ */
+
+import { loadConfig, getWif } from '../lib/config.js'
+import { checkProTier } from '../lib/api-client.js'
+// Bun has native fetch — no import needed
+
+/**
+ * @param {Object} options
+ * @param {string} options.message - The question/message to send to Codex
+ * @param {string} [options.context] - Optional context about current work
+ * @param {string} [options.systemPrompt] - Optional system prompt override
+ * @returns {Promise<Object>} - { success, response, formatted, model, name }
+ */
+export async function diaryChat({ message, context, systemPrompt }) {
+  if (!message) {
+    return {
+      success: false,
+      error: 'No message provided'
+    }
+  }
+
+  const config = loadConfig()
+  if (!config) {
+    return {
+      success: false,
+      error: 'No config found. Run setup first.'
+    }
+  }
+
+  // Check Pro tier
+  const wif = await getWif()
+  if (wif) {
+    const tier = await checkProTier(wif)
+    if (!tier.ok) return { success: false, error: tier.error }
+  }
+
+  if (!config.diary || !config.diary.apiKey) {
+    return {
+      success: false,
+      error: 'Diary AI not configured. Run diary_connect first with your OpenAI API key.'
+    }
+  }
+
+  const { apiKey, model, name } = config.diary
+  const displayName = name || 'Codex'
+
+  // Build messages array
+  const messages = []
+
+  // System prompt — use provided, or default
+  const sysPrompt = systemPrompt || `You are ${displayName}, an AI companion working alongside Claude Code in a VS Code session. You are a planner and architect. Keep responses focused and practical. The user and Claude can see your responses — speak directly to both.`
+  messages.push({ role: 'system', content: sysPrompt })
+
+  // Add context if provided
+  if (context) {
+    messages.push({ role: 'system', content: `Current context:\n${context}` })
+  }
+
+  // Add the user's message
+  messages.push({ role: 'user', content: message })
+
+  try {
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        model: model || 'gpt-4o',
+        messages,
+        max_tokens: 4096,
+        temperature: 0.7
+      })
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      if (response.status === 401) {
+        return {
+          success: false,
+          error: 'Invalid OpenAI API key. Run diary_connect with a valid key.'
+        }
+      }
+      if (response.status === 429) {
+        return {
+          success: false,
+          error: 'OpenAI rate limit exceeded. Try again in a moment.'
+        }
+      }
+      return {
+        success: false,
+        error: `OpenAI API error ${response.status}: ${errorText}`
+      }
+    }
+
+    const data = await response.json()
+    const content = data.choices?.[0]?.message?.content || ''
+
+    // Format with name badge for display in Claude Code chat
+    const formatted = `**🤖 ${displayName}:**\n> ${content.split('\n').join('\n> ')}`
+
+    return {
+      success: true,
+      response: content,
+      formatted,
+      model: data.model || model,
+      name: displayName,
+      usage: {
+        inputTokens: data.usage?.prompt_tokens || 0,
+        outputTokens: data.usage?.completion_tokens || 0
+      }
+    }
+
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to reach OpenAI: ${error.message}`
+    }
+  }
+}

package/src/tools/diary_connect.js

@@ -0,0 +1,62 @@
+/**
+ * diary_connect — Configure Diary AI companion (Codex/ChatGPT)
+ *
+ * Stores OpenAI API key, model preference, and display name
+ * in the MCP config under a "diary" section.
+ *
+ * Usage:
+ *   diary_connect({ apiKey: 'sk-...', model: 'gpt-4o', name: 'Codex' })
+ */
+
+import { loadConfig, saveConfig, getWif } from '../lib/config.js'
+import { checkProTier } from '../lib/api-client.js'
+
+/**
+ * @param {Object} options
+ * @param {string} options.apiKey - OpenAI API key (sk-...)
+ * @param {string} [options.model] - Model ID (default: gpt-4o)
+ * @param {string} [options.name] - Display name (default: Codex)
+ * @returns {Promise<Object>} - { success, message, diary }
+ */
+export async function diaryConnect({ apiKey, model, name }) {
+  if (!apiKey || !apiKey.startsWith('sk-')) {
+    return {
+      success: false,
+      error: 'Invalid API key. Must start with sk-'
+    }
+  }
+
+  const config = loadConfig()
+  if (!config) {
+    return {
+      success: false,
+      error: 'No config found. Run setup first.'
+    }
+  }
+
+  // Check Pro tier
+  const wif = await getWif()
+  if (wif) {
+    const tier = await checkProTier(wif)
+    if (!tier.ok) return { success: false, error: tier.error }
+  }
+
+  // Store diary settings in config
+  config.diary = {
+    apiKey,
+    model: model || 'gpt-4o',
+    name: name || 'Codex'
+  }
+
+  saveConfig(config)
+
+  return {
+    success: true,
+    message: `Diary AI connected! Using ${config.diary.model} as "${config.diary.name}"`,
+    diary: {
+      model: config.diary.model,
+      name: config.diary.name,
+      hasKey: true
+    }
+  }
+}

package/src/tools/diary_save.js

@@ -0,0 +1,137 @@
+/**
+ * diary_save — Save Codex exchanges to blockchain
+ *
+ * Saves Diary AI (Codex) conversations to the same blockchain
+ * as Claude sessions, using the same WIF. Tagged with source: 'codex'
+ * so load_context can tell who said what.
+ *
+ * Usage:
+ *   diary_save({ messages: [...], summary: 'Architecture discussion' })
+ */
+
+import { loadConfig, saveConfig, getWif } from '../lib/config.js'
+import { encrypt, sha256 } from '../lib/crypto.js'
+import * as spv from '../lib/spv.js'
+import { indexSession, checkProTier } from '../lib/api-client.js'
+
+/**
+ * @param {Object} options
+ * @param {Array} options.messages - Array of { role: 'user'|'assistant', content: string }
+ * @param {string} [options.summary] - Brief summary of the exchange
+ * @returns {Promise<Object>} - { success, txId, sessionId, messageCount }
+ */
+export async function diarySave({ messages, summary }) {
+  if (!messages || !Array.isArray(messages) || messages.length === 0) {
+    return {
+      success: false,
+      error: 'No messages provided. Pass an array of { role, content } objects.'
+    }
+  }
+
+  const config = loadConfig()
+  if (!config) {
+    return {
+      success: false,
+      error: 'No config found. Run setup first.'
+    }
+  }
+
+  const wif = await getWif()
+  if (!wif) {
+    return {
+      success: false,
+      error: 'No WIF found. Run setup first.'
+    }
+  }
+
+  // Check Pro tier
+  const tier = await checkProTier(wif)
+  if (!tier.ok) return { success: false, error: tier.error }
+
+  const diaryName = config.diary?.name || 'Codex'
+
+  // Add timestamps to messages if missing
+  const timestampedMessages = messages.map(m => ({
+    role: m.role,
+    content: m.content,
+    timestamp: m.timestamp || new Date().toISOString()
+  }))
+
+  // Build session object — same structure as save_session but tagged as codex
+  const sessionId = sha256(JSON.stringify(messages) + Date.now())
+  const prevSessionId = config.last_session_id || null
+
+  const session = {
+    id: sessionId,
+    type: 'diary',
+    source: 'codex',
+    source_name: diaryName,
+    prev_session_id: prevSessionId,
+    summary: summary || `${diaryName} exchange (${messages.length} messages)`,
+    message_count: messages.length,
+    created_at: new Date().toISOString(),
+    messages: timestampedMessages
+  }
+
+  // Encrypt with same WIF as Claude sessions
+  const encrypted = encrypt(JSON.stringify(session), wif)
+
+  // Build blockchain payload
+  const payload = {
+    protocol: 'indelible.claude-code',
+    version: 2,
+    address: config.address,
+    session_id: sessionId,
+    prev_session_id: prevSessionId,
+    summary: session.summary,
+    message_count: session.message_count,
+    encrypted,
+    timestamp: session.created_at
+  }
+
+  // Build + sign transaction locally, broadcast via SPV bridge
+  try {
+    const utxos = await spv.getUtxos(config.address)
+    const { txHex, txId } = await spv.buildOpReturnTx(wif, utxos, JSON.stringify(payload))
+    const broadcastResult = await spv.broadcastTx(txHex)
+    const finalTxId = broadcastResult.txid || txId
+
+    // Index on server for web app retrieval (best effort)
+    try {
+      await indexSession({
+        txId: finalTxId,
+        address: config.address,
+        session_id: sessionId,
+        prev_session_id: prevSessionId,
+        summary: session.summary,
+        message_count: session.message_count,
+        save_type: 'diary',
+        encrypted,
+        timestamp: session.created_at
+      }, config)
+    } catch { /* indexing failure doesn't block save */ }
+
+    // Update config with new session chain
+    saveConfig({
+      ...config,
+      last_session_id: sessionId,
+      last_tx_id: finalTxId
+    })
+
+    return {
+      success: true,
+      txId: finalTxId,
+      sessionId,
+      prevSessionId,
+      messageCount: messages.length,
+      source: diaryName,
+      message: `${diaryName} exchange saved! ${messages.length} messages committed to blockchain.`
+    }
+
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to save: ${error.message}`
+    }
+  }
+}

package/src/tools/load_context.js

@@ -30,6 +30,7 @@ function mergeDeltaSessions(sessions) {
       parent.summary = session.summary
       parent.created_at = session.created_at
       parent.id = session.id
+      parent.structured_context = session.structured_context || parent.structured_context
     } else {
       merged.push({ ...session })
     }
@@ -56,6 +57,22 @@ function formatCurrentConversation(session) {
   lines.push(`Last saved: ${session.created_at ? new Date(session.created_at).toLocaleString() : 'Unknown'}`)
   lines.push('')
 
+  // Render structured context if present (todos, plan, git branch)
+  if (session.structured_context) {
+    const sc = session.structured_context
+    if (sc.git_branch) lines.push(`Git branch: \`${sc.git_branch}\``)
+    if (sc.plan_slug) lines.push(`Active plan: \`${sc.plan_slug}\``)
+    if (sc.todos && sc.todos.length > 0) {
+      lines.push('')
+      lines.push('### Active Tasks (at time of save):')
+      for (const t of sc.todos) {
+        const icon = t.status === 'completed' ? '[x]' : t.status === 'in_progress' ? '[~]' : '[ ]'
+        lines.push(`- ${icon} ${t.content}`)
+      }
+    }
+    lines.push('')
+  }
+
   if (total === 0) return lines.join('\n')
 
   const recentStart = Math.max(0, total - RECENT_MESSAGES_FULL)

package/src/tools/save_session.js

@@ -13,8 +13,9 @@
  *   9. Local backups (LOCAL)
  */
 
-import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'node:fs'
-import { dirname } from 'node:path'
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync, readdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { homedir } from 'node:os'
 import { loadConfig, saveConfig, getWif } from '../lib/config.js'
 import { encrypt, sha256 } from '../lib/crypto.js'
 import { findCurrentTranscript, parseTranscript } from '../lib/transcript.js'
@@ -65,6 +66,43 @@ function ensureJsonlBackup(path, messages) {
   } catch { /* don't block */ }
 }
 
+/**
+ * Extract structured context (todos, plan slug, git branch) from transcript.
+ */
+function getStructuredContext(transcriptPath) {
+  const ctx = { todos: null, plan_slug: null, git_branch: null, session_id: null }
+  try {
+    const content = readFileSync(transcriptPath, 'utf-8')
+    const lines = content.trim().split('\n')
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const entry = JSON.parse(lines[i])
+        if (entry.sessionId) {
+          ctx.session_id = entry.sessionId
+          ctx.git_branch = entry.gitBranch || null
+          ctx.plan_slug = entry.slug || null
+          break
+        }
+      } catch {}
+    }
+  } catch {}
+
+  const todosDir = join(homedir(), '.claude', 'todos')
+  if (ctx.session_id && existsSync(todosDir)) {
+    try {
+      const files = readdirSync(todosDir)
+      const match = files.find(f => f.startsWith(ctx.session_id))
+      if (match) {
+        const todos = JSON.parse(readFileSync(join(todosDir, match), 'utf-8'))
+        if (Array.isArray(todos) && todos.length > 0) {
+          ctx.todos = todos
+        }
+      }
+    } catch {}
+  }
+  return ctx
+}
+
 /**
  * Save current session to blockchain.
  * Builds + signs transaction locally, broadcasts via SPV bridge.
@@ -133,6 +171,14 @@ export async function saveSession(transcriptPath, summary) {
     messages: messagesToCommit
   }
 
+  // Attach structured context (todos, active plan, git branch)
+  try {
+    const structuredCtx = getStructuredContext(actualPath)
+    if (structuredCtx.todos || structuredCtx.plan_slug) {
+      session.structured_context = structuredCtx
+    }
+  } 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)
   if (transcriptPath) ensureJsonlBackup(transcriptPath, allMessages)