create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/walle-session-cache.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const WALLE_SESSION_CACHE_PARSER_VERSION = 2;
+
 function extractText(value) {
   if (value === undefined || value === null) return '';
   if (typeof value === 'string') return value;
@@ -44,6 +46,9 @@ function normalizeMessage(message) {
   if (latency !== undefined && latency !== null) out.latency_ms = latency;
   if (Array.isArray(message.toolCalls)) out.toolCalls = JSON.parse(JSON.stringify(message.toolCalls));
   if (Array.isArray(message.tool_calls)) out.toolCalls = JSON.parse(JSON.stringify(message.tool_calls));
+  if (message.metadata && typeof message.metadata === 'object') {
+    out.metadata = JSON.parse(JSON.stringify(message.metadata));
+  }
   if (message.attachments) {
     try {
       out.attachments = typeof message.attachments === 'string'
@@ -79,6 +84,105 @@ function statTimestamp(fileStat) {
   return '';
 }
 
+function walleConversationCacheIdsForSource(source) {
+  const ids = [];
+  const add = (value) => {
+    const clean = String(value || '').trim();
+    if (clean && !ids.includes(clean)) ids.push(clean);
+  };
+
+  // Prefer the active provider transcript identity. CTM-id cache rows are a
+  // durable fallback, but they can outlive a Wall-E restart that moved the
+  // active transcript from <ctm>.jsonl to walle-<ctm>.jsonl.
+  add(source?.agentSessionId);
+  add(source?.chatSessionId);
+  add(source?.conversationSessionId);
+  add(source?.ctmSessionId);
+  add(source?.id);
+  return ids;
+}
+
+function walleConversationCacheFreshness(conversation, source, fileStat, options = {}) {
+  if (!conversation || typeof conversation !== 'object') {
+    return { fresh: false, reason: 'missing-cache', cachedSize: 0, expectedSize: 0 };
+  }
+  const minParserVersion = Number.isFinite(Number(options.minParserVersion))
+    ? Number(options.minParserVersion)
+    : WALLE_SESSION_CACHE_PARSER_VERSION;
+  const parserVersion = Number(conversation.import_parser_version || 0) || 0;
+  if (minParserVersion > 0 && parserVersion < minParserVersion) {
+    return {
+      fresh: false,
+      reason: 'parser-version-stale',
+      parserVersion,
+      expectedParserVersion: minParserVersion,
+      cachedSize: Number(conversation.file_size || 0) || 0,
+      expectedSize: statSize(fileStat),
+      sourcePath: source?.jsonlPath || '',
+    };
+  }
+  const expectedSize = statSize(fileStat);
+  if (!expectedSize) {
+    return {
+      fresh: true,
+      reason: 'no-active-file-stat',
+      cachedSize: Number(conversation.file_size || 0) || 0,
+      expectedSize: 0,
+    };
+  }
+  const cachedSize = Number(conversation.file_size || 0) || 0;
+  if (cachedSize !== expectedSize) {
+    return {
+      fresh: false,
+      reason: 'active-jsonl-size-mismatch',
+      cachedSize,
+      expectedSize,
+      sourcePath: source?.jsonlPath || '',
+    };
+  }
+  return { fresh: true, reason: 'active-jsonl-size-match', cachedSize, expectedSize };
+}
+
+function selectFreshWalleSessionConversationCache({
+  source,
+  fileStat,
+  getConversation,
+  parseMessages,
+  minParserVersion,
+} = {}) {
+  if (!source || typeof getConversation !== 'function' || typeof parseMessages !== 'function') {
+    return { messages: null, sourceId: '', stale: [], checkedIds: [] };
+  }
+  const ids = walleConversationCacheIdsForSource(source);
+  const stale = [];
+  for (const id of ids) {
+    let conversation = null;
+    try {
+      conversation = getConversation(id);
+    } catch (e) {
+      stale.push({ id, reason: 'cache-read-error', error: e.message });
+      continue;
+    }
+    if (!conversation || !conversation.messages) continue;
+    const freshness = walleConversationCacheFreshness(conversation, source, fileStat, { minParserVersion });
+    if (!freshness.fresh) {
+      stale.push({ id, ...freshness });
+      continue;
+    }
+    let messages = null;
+    try {
+      messages = parseMessages(conversation);
+    } catch (e) {
+      stale.push({ id, reason: 'cache-parse-error', error: e.message });
+      continue;
+    }
+    if (Array.isArray(messages) && messages.length > 0) {
+      return { messages, sourceId: id, stale, checkedIds: ids };
+    }
+  }
+  return { messages: null, sourceId: '', stale, checkedIds: ids };
+}
+
 function buildWalleSessionConversation({
   source,
   history,
@@ -109,6 +213,7 @@ function buildWalleSessionConversation({
     hostname: hostname || source?.hostname || '',
     model_provider: modelProvider,
     model_id: modelId,
+    import_parser_version: WALLE_SESSION_CACHE_PARSER_VERSION,
     last_user_content: lastUser,
     first_assistant_text: firstAssistant,
     rename_name: source?.rename_name || source?.renameName || '',
@@ -135,6 +240,10 @@ function persistWalleSessionConversation({
 
 module.exports = {
   buildWalleSessionConversation,
+  selectFreshWalleSessionConversationCache,
+  WALLE_SESSION_CACHE_PARSER_VERSION,
+  walleConversationCacheFreshness,
+  walleConversationCacheIdsForSource,
   normalizeMessage,
   persistWalleSessionConversation,
 };

package/template/claude-task-manager/lib/walle-session-context.js

@@ -19,32 +19,65 @@ function sessionLabel(session) {
   return session?.label || session?.meta?.label || '';
 }
 
-function resolveWalleChatContext({ session, contextSession, requestedCwd } = {}) {
-  const candidates = [];
-  if (requestedCwd) candidates.push({ cwd: requestedCwd, source: 'request', sessionId: null, label: '' });
-  if (contextSession && contextSession.id !== session?.id) {
-    candidates.push(
-      { cwd: contextSession.worktree_path, source: 'context_worktree', sessionId: contextSession.id, label: sessionLabel(contextSession) },
-      { cwd: contextSession.cwd, source: 'context_session', sessionId: contextSession.id, label: sessionLabel(contextSession) },
-      { cwd: contextSession.meta?.worktree_path, source: 'context_worktree', sessionId: contextSession.id, label: sessionLabel(contextSession) },
-      { cwd: contextSession.meta?.cwd, source: 'context_session', sessionId: contextSession.id, label: sessionLabel(contextSession) },
-    );
-  }
-  candidates.push(
-    { cwd: session?.worktree_path, source: 'walle_worktree', sessionId: session?.id || null, label: sessionLabel(session) },
-    { cwd: session?.cwd, source: 'walle_session', sessionId: session?.id || null, label: sessionLabel(session) },
-    { cwd: session?.meta?.worktree_path, source: 'walle_worktree', sessionId: session?.id || null, label: sessionLabel(session) },
-    { cwd: session?.meta?.cwd, source: 'walle_session', sessionId: session?.id || null, label: sessionLabel(session) },
-  );
+function buildSessionPathCandidates(session, prefix) {
+  if (!session) return [];
+  const label = sessionLabel(session);
+  return [
+    { cwd: session.worktree_path, source: `${prefix}_worktree`, sessionId: session.id || null, label },
+    { cwd: session.cwd, source: `${prefix}_session`, sessionId: session.id || null, label },
+    { cwd: session.meta?.worktree_path, source: `${prefix}_worktree`, sessionId: session.id || null, label },
+    { cwd: session.meta?.cwd, source: `${prefix}_session`, sessionId: session.id || null, label },
+    { cwd: session.project_path, source: `${prefix}_project`, sessionId: session.id || null, label },
+    { cwd: session.meta?.project_path, source: `${prefix}_project`, sessionId: session.id || null, label },
+  ];
+}
 
+function firstExistingCandidate(candidates) {
   for (const candidate of candidates) {
     const cwd = firstExistingPath([candidate.cwd]);
     if (!cwd) continue;
+    return { ...candidate, cwd };
+  }
+  return null;
+}
+
+function resolveWalleChatContext({ session, contextSession, requestedCwd } = {}) {
+  const contextCandidate = contextSession && contextSession.id !== session?.id
+    ? firstExistingCandidate(buildSessionPathCandidates(contextSession, 'context'))
+    : null;
+  const requestCandidate = requestedCwd
+    ? firstExistingCandidate([{ cwd: requestedCwd, source: 'request', sessionId: null, label: '' }])
+    : null;
+  const sessionCandidate = firstExistingCandidate(buildSessionPathCandidates(session, 'walle'));
+
+  if (sessionCandidate) {
+    const ignoredContextCwd = contextCandidate && contextCandidate.cwd !== sessionCandidate.cwd
+      ? contextCandidate.cwd
+      : '';
+    const ignoredRequestedCwd = requestCandidate && requestCandidate.cwd !== sessionCandidate.cwd
+      ? requestCandidate.cwd
+      : '';
+    return {
+      cwd: sessionCandidate.cwd,
+      source: sessionCandidate.source,
+      contextSessionId: contextCandidate?.sessionId || null,
+      contextSessionLabel: contextCandidate?.label || '',
+      contextCwd: contextCandidate?.cwd || '',
+      ignoredContextCwd,
+      ignoredRequestedCwd,
+    };
+  }
+
+  const fallback = contextCandidate || requestCandidate;
+  if (fallback) {
     return {
-      cwd,
-      source: candidate.source,
-      contextSessionId: candidate.sessionId,
-      contextSessionLabel: candidate.label,
+      cwd: fallback.cwd,
+      source: fallback.source,
+      contextSessionId: fallback.sessionId,
+      contextSessionLabel: fallback.label,
+      contextCwd: fallback.source.startsWith('context_') ? fallback.cwd : '',
+      ignoredContextCwd: '',
+      ignoredRequestedCwd: '',
     };
   }
 
@@ -53,6 +86,9 @@ function resolveWalleChatContext({ session, contextSession, requestedCwd } = {})
     source: 'none',
     contextSessionId: null,
     contextSessionLabel: '',
+    contextCwd: '',
+    ignoredContextCwd: '',
+    ignoredRequestedCwd: '',
   };
 }
 

package/template/claude-task-manager/lib/walle-session-model-catalog.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const SESSION_MODEL_PROVIDER_TYPES = new Set([
+  'anthropic',
+  'openai',
+  'google',
+  'deepseek',
+  'moonshot',
+  'ollama',
+  'mlx',
+]);
+
+function stripSessionModelAlias(modelId = '') {
+  return String(modelId || '').trim()
+    .replace(/@(default|latest)$/i, '')
+    .replace(/@20\d{6}$/i, '');
+}
+
+function canonicalModelId(modelId = '', providerType = '') {
+  let id = String(modelId || '').trim();
+  const namespaced = /^@([^/]+)\/(.+)$/.exec(id);
+  if (namespaced && SESSION_MODEL_PROVIDER_TYPES.has(namespaced[1].toLowerCase())) {
+    id = namespaced[2];
+  }
+  if (String(providerType || '').toLowerCase() === 'bedrock') {
+    id = id.replace(/^anthropic\./, '');
+  }
+  return stripSessionModelAlias(id);
+}
+
+module.exports = {
+  canonicalModelId,
+  stripSessionModelAlias,
+};