create-walle 0.9.13 → 0.9.14

package/template/wall-e/mcp-server.js

@@ -4,6 +4,7 @@ const path = require('node:path');
 const { v4: uuidv4 } = require('uuid');
 const brain = require('./brain');
 const { createSessionIngestService } = require('./memory/session-ingest-service');
+const ctmSessionContext = require('./memory/ctm-session-context');
 const { collectIngestRecords } = require('./sources/base');
 const { ensureBuiltinSourceAdapters } = require('./sources/builtin');
 const sourceRegistry = require('./sources/registry');
@@ -13,6 +14,36 @@ try { _embeddings = require('./embeddings'); } catch { _embeddings = null; }
 
 const PROTOCOL_VERSION = '2025-03-26';
 
+const MCP_RESOURCES = [
+  {
+    uri: 'walle://status/session-memory',
+    name: 'Wall-E session memory status',
+    description: 'Operational status for Wall-E brain memory and CTM cached session-context access.',
+    mimeType: 'application/json',
+  },
+];
+
+const MCP_RESOURCE_TEMPLATES = [
+  {
+    uriTemplate: 'walle-session://ctm/{session_id}/full',
+    name: 'CTM session full context',
+    description: 'Full cached CTM session context from session_conversations/session_messages. Use for explicit session transfer.',
+    mimeType: 'application/json',
+  },
+  {
+    uriTemplate: 'walle-session://ctm/{session_id}/compact',
+    name: 'CTM session compact context',
+    description: 'Prompt-friendly markdown view of cached CTM session context.',
+    mimeType: 'text/markdown',
+  },
+  {
+    uriTemplate: 'walle-context://task/{query}',
+    name: 'Task-scoped CTM context pack',
+    description: 'Search cached CTM sessions for a task prompt and return a deduplicated context pack.',
+    mimeType: 'text/markdown',
+  },
+];
+
 const MCP_TOOLS = [
   {
     name: 'search_memories',
@@ -199,30 +230,54 @@ const MCP_TOOLS = [
   },
   {
     name: 'walle_search_sessions',
-    description: 'Search ingested coding sessions and Wall-E diary entries. Returns attributed snippets plus session pointers.',
+    description: 'Search coding-session history. Tries cached CTM DB session messages first, then ingested Wall-E memories/diary entries. Returns deduplicated attributed snippets plus session pointers.',
     inputSchema: {
       type: 'object',
       properties: {
         query: { type: 'string', description: 'Search query' },
         limit: { type: 'number', description: 'Max session snippets (default 10, max 50)' },
+        prefer_db: { type: 'boolean', description: 'Try cached CTM DB tables before Wall-E memory (default true)' },
+        include_memory: { type: 'boolean', description: 'Also search Wall-E ingested memories and diary entries (default true)' },
       },
       required: ['query'],
     },
   },
   {
     name: 'walle_get_session',
-    description: 'Retrieve session snippets from ingested memory, or parse a JSONL session directly when adapter_id and uri are provided.',
+    description: 'Retrieve cached CTM session context by session id/source id, or parse a JSONL session directly when adapter_id and uri are provided. DB tables are preferred for full context transfer.',
     inputSchema: {
       type: 'object',
       properties: {
+        session_id: { type: 'string', description: 'CTM session id or agent session id to retrieve from cached DB tables' },
+        session_ids: { type: 'array', items: { type: 'string' }, description: 'Several CTM/agent session ids to retrieve together' },
         source_id: { type: 'string', description: 'Stable source/session id to retrieve from memory' },
         adapter_id: { type: 'string', description: 'Optional adapter id for direct JSONL parse' },
         uri: { type: 'string', description: 'Optional JSONL path for direct parse' },
-        limit: { type: 'number', description: 'Max records (default 50, max 200)' },
+        limit: { type: 'number', description: 'Max records/messages (default 50 for memory, 200 for CTM DB; use 0/full/all for all cached DB messages)' },
+        cursor: { type: 'number', description: 'Message offset for cached DB pagination' },
+        format: { type: 'string', description: 'Cached DB output format: messages, markdown, or compact' },
+        dedupe: { type: 'boolean', description: 'Deduplicate repeated message content (default true)' },
+        prefer_db: { type: 'boolean', description: 'Use cached CTM DB tables before Wall-E memory fallback (default true)' },
         include_raw: { type: 'boolean', description: 'Include raw content when available' },
       },
     },
   },
+  {
+    name: 'walle_context_pack',
+    description: 'Build a deduplicated task-scoped context pack from cached CTM session history. Use before starting a coding task to discover prior attempts and relevant implementation context.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task: { type: 'string', description: 'Current user prompt or task description' },
+        query: { type: 'string', description: 'Optional explicit search query; defaults to task' },
+        session_ids: { type: 'array', items: { type: 'string' }, description: 'Optional CTM/agent session ids to force include' },
+        limit: { type: 'number', description: 'Max sessions to include (default 5, max 50)' },
+        token_budget: { type: 'number', description: 'Approximate context-pack token budget (default 12000)' },
+        mode: { type: 'string', description: 'auto, compact, or full' },
+        include_raw: { type: 'boolean', description: 'Include raw cached messages when mode/full transfer needs exact source payloads' },
+      },
+    },
+  },
   {
     name: 'walle_diary_write',
     description: 'Write an idempotent agent diary entry for a coding session stop, handoff, or compaction boundary.',
@@ -412,6 +467,11 @@ async function executeTool(name, args) {
       return {
         ok: true,
         stats,
+        ctm_db: getCtmDbStatus(),
+        resources: {
+          static: MCP_RESOURCES.map((resource) => resource.uri),
+          templates: MCP_RESOURCE_TEMPLATES.map((template) => template.uriTemplate),
+        },
         source_adapters: sourceRegistry.list().map(formatSourceAdapter),
         diary_count: countDiaryEntries(),
         tools: MCP_TOOLS.filter((tool) => tool.name.startsWith('walle_')).map((tool) => tool.name),
@@ -446,11 +506,45 @@ async function executeTool(name, args) {
     }
     case 'walle_search_sessions': {
       const limit = clampLimit(args.limit, 10, 50);
-      const results = brain.searchMemories({ query: args.query, limit: limit * 4 })
-        .filter(isSessionMemory)
-        .slice(0, limit)
-        .map(formatSessionMemory);
-      return { results };
+      const ctmResults = args.prefer_db === false
+        ? { ok: false, results: [], skipped: true, reason: 'prefer_db_false' }
+        : safeCtmSearchSessions({ query: args.query, limit });
+      const memoryResults = args.include_memory === false
+        ? []
+        : brain.searchMemories({ query: args.query, limit: limit * 4 })
+          .filter(isSessionMemory)
+          .slice(0, limit * 2)
+          .map((memory, index) => ({
+            ...formatSessionMemory(memory),
+            source_layer: 'wall-e-memory',
+            rank: 10000 + index,
+          }));
+      const dbResults = (ctmResults.results || []).map((result, index) => ({
+        ...result,
+        source_layer: 'ctm-db',
+        rank: Number.isFinite(result.rank) ? result.rank : index,
+      }));
+      const results = ctmSessionContext.dedupeItems([...dbResults, ...memoryResults], {
+        limit,
+        contentFields: ['snippet', 'content'],
+        keyPrefix: (item) => `${item.session_id || item.source_id || ''}:${item.role || item.memory_type || ''}`,
+      }).map(stripRank);
+      return {
+        results,
+        sources: {
+          ctm_db: {
+            ok: Boolean(ctmResults.ok),
+            unavailable: Boolean(ctmResults.unavailable),
+            reason: ctmResults.reason || '',
+            count: (ctmResults.results || []).length,
+          },
+          wall_e_memory: {
+            searched: args.include_memory !== false,
+            count: memoryResults.length,
+          },
+        },
+        deduped: true,
+      };
     }
     case 'walle_get_session': {
       const limit = clampLimit(args.limit, 50, 200);
@@ -475,12 +569,47 @@ async function executeTool(name, args) {
             .map((record) => formatSourceRecord(record, { includeRaw: Boolean(args.include_raw) })),
         };
       }
+      const wantsDb = args.prefer_db !== false;
+      const dbSessionIds = args.session_ids || args.session_id || args.source_id;
+      if (wantsDb && dbSessionIds) {
+        const dbContext = safeCtmSessionContext({
+          session_ids: args.session_ids,
+          session_id: args.session_id,
+          source_id: args.source_id,
+          limit: args.limit ?? 200,
+          cursor: args.cursor || 0,
+          include_raw: Boolean(args.include_raw),
+          dedupe: args.dedupe !== false,
+          format: args.format || 'messages',
+        });
+        if (dbContext.ok && (dbContext.sessions.length > 0 || dbContext.messages.length > 0)) {
+          return dbContext;
+        }
+        if (args.session_id || args.session_ids) return dbContext;
+      }
       if (!args.source_id) throw new Error('source_id is required when adapter_id and uri are not provided');
       return {
         source_id: args.source_id,
+        transfer: {
+          full_context_supported: false,
+          served_from: 'wall-e-memory',
+          jsonl_fallback_used: false,
+          ctm_db_preferred: wantsDb,
+        },
         records: getSessionMemories(args.source_id, { limit }).map(formatSessionMemory),
       };
     }
+    case 'walle_context_pack': {
+      return safeCtmContextPack({
+        task: args.task || '',
+        query: args.query || '',
+        session_ids: args.session_ids,
+        limit: args.limit || 5,
+        token_budget: args.token_budget || 12000,
+        mode: args.mode || 'auto',
+        include_raw: Boolean(args.include_raw),
+      });
+    }
     case 'walle_diary_write': {
       return writeDiaryEntry(args);
     }
@@ -514,6 +643,46 @@ function clampLimit(value, fallback, max) {
   return Math.min(Math.max(Math.trunc(n), 1), max);
 }
 
+function stripRank(item) {
+  if (!item || typeof item !== 'object') return item;
+  const { rank, ...rest } = item;
+  return rest;
+}
+
+function getCtmDbStatus() {
+  const dbPath = ctmSessionContext.resolveCtmDbPath();
+  return {
+    available: fs.existsSync(dbPath),
+    db_path: dbPath,
+    serving_priority: 'ctm-db-first',
+    cached_tables: ['session_conversations', 'session_messages', 'session_messages_fts', 'ctm_sessions', 'agent_sessions'],
+  };
+}
+
+function safeCtmSearchSessions(args) {
+  try {
+    return ctmSessionContext.searchCtmSessions(args);
+  } catch (err) {
+    return { ok: false, source: 'ctm-db', results: [], reason: err.message };
+  }
+}
+
+function safeCtmSessionContext(args) {
+  try {
+    return ctmSessionContext.getCtmSessionContext(args);
+  } catch (err) {
+    return { ok: false, source: 'ctm-db', sessions: [], messages: [], reason: err.message };
+  }
+}
+
+function safeCtmContextPack(args) {
+  try {
+    return ctmSessionContext.buildContextPack(args);
+  } catch (err) {
+    return { ok: false, source: 'ctm-db', sessions: [], messages: [], reason: err.message };
+  }
+}
+
 function assertJsonlPath(filePath) {
   if (!filePath || typeof filePath !== 'string') throw new Error('uri must be a JSONL file path');
   if (filePath.split(/[\\/]+/).includes('..')) throw new Error('uri cannot contain traversal segments');
@@ -748,6 +917,63 @@ function jsonResponse(res, data, status = 200) {
   res.end(body);
 }
 
+async function readMcpResource(uri) {
+  if (!uri || typeof uri !== 'string') throw new Error('resource uri is required');
+
+  if (uri === 'walle://status/session-memory') {
+    return {
+      uri,
+      mimeType: 'application/json',
+      text: JSON.stringify(await executeTool('walle_memory_status', {})),
+    };
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(uri);
+  } catch {
+    throw new Error(`Invalid resource uri: ${uri}`);
+  }
+
+  if (parsed.protocol === 'walle-session:' && parsed.hostname === 'ctm') {
+    const [rawSessionId, rawMode] = parsed.pathname.split('/').filter(Boolean);
+    if (!rawSessionId) throw new Error('walle-session resource requires a session id');
+    const sessionId = decodeURIComponent(rawSessionId);
+    const mode = rawMode || 'full';
+    const context = ctmSessionContext.getCtmSessionContext({
+      session_id: sessionId,
+      limit: mode === 'full' || mode === 'messages' ? 0 : 200,
+      format: mode === 'compact' || mode === 'summary' ? 'compact' : 'messages',
+      dedupe: true,
+    });
+    if (mode === 'compact' || mode === 'summary') {
+      return {
+        uri,
+        mimeType: 'text/markdown',
+        text: context.text || ctmSessionContext.renderContextMarkdown(context, { compact: true }),
+      };
+    }
+    return {
+      uri,
+      mimeType: 'application/json',
+      text: JSON.stringify(context),
+    };
+  }
+
+  if (parsed.protocol === 'walle-context:' && parsed.hostname === 'task') {
+    const task = decodeURIComponent(parsed.pathname.replace(/^\/+/, ''));
+    if (!task) throw new Error('walle-context task resource requires an encoded task query');
+    const pack = ctmSessionContext.buildContextPack({ task, mode: 'compact' });
+    return {
+      uri,
+      mimeType: 'text/markdown',
+      text: pack.text || ctmSessionContext.renderContextMarkdown(pack, { compact: true }),
+    };
+  }
+
+  throw new Error(`Unknown resource uri: ${uri}`);
+}
+
 async function handleMcp(req, res) {
   let msg;
   try {
@@ -775,7 +1001,7 @@ async function handleMcp(req, res) {
         jsonrpc: '2.0', id,
         result: {
           protocolVersion: PROTOCOL_VERSION,
-          capabilities: { tools: {} },
+          capabilities: { tools: {}, resources: {} },
           serverInfo: { name: 'wall-e', version: (() => { try { return require('./package.json').version; } catch { return '0.0.0'; } })() },
         },
       });
@@ -788,6 +1014,35 @@ async function handleMcp(req, res) {
       });
     }
 
+    case 'resources/list': {
+      return jsonResponse(res, {
+        jsonrpc: '2.0', id,
+        result: { resources: MCP_RESOURCES },
+      });
+    }
+
+    case 'resources/templates/list': {
+      return jsonResponse(res, {
+        jsonrpc: '2.0', id,
+        result: { resourceTemplates: MCP_RESOURCE_TEMPLATES },
+      });
+    }
+
+    case 'resources/read': {
+      try {
+        const content = await readMcpResource(params?.uri);
+        return jsonResponse(res, {
+          jsonrpc: '2.0', id,
+          result: { contents: [{ uri: content.uri, mimeType: content.mimeType, text: content.text }] },
+        });
+      } catch (err) {
+        return jsonResponse(res, {
+          jsonrpc: '2.0', id,
+          result: { contents: [{ uri: params?.uri || '', mimeType: 'text/plain', text: `Error: ${err.message}` }], isError: true },
+        });
+      }
+    }
+
     case 'tools/call': {
       const toolName = params?.name;
       const toolArgs = params?.arguments || {};
@@ -819,4 +1074,11 @@ async function handleMcp(req, res) {
   }
 }
 
-module.exports = { handleMcp, MCP_TOOLS, executeTool };
+module.exports = {
+  handleMcp,
+  MCP_TOOLS,
+  MCP_RESOURCES,
+  MCP_RESOURCE_TEMPLATES,
+  executeTool,
+  readMcpResource,
+};