create-walle 0.9.11 → 0.9.13

package/template/wall-e/coding/acp-adapter.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { WorkspaceReplay } = require('./workspace-replay');
+
+class AcpAdapter {
+  constructor({
+    replay = null,
+    permissionService = null,
+    eventBus = null,
+    runner = null,
+    runAgentLoop = null,
+  } = {}) {
+    this.replay = replay || new WorkspaceReplay();
+    this.permissionService = permissionService || null;
+    this.eventBus = eventBus || new EventEmitter();
+    this.runner = runner || null;
+    this.runAgentLoop = runAgentLoop || null;
+    this.sessions = new Map();
+    this.subscribers = new Map();
+    this.history = new Map();
+
+    this.eventBus.on('permission.asked', (entry) => {
+      this._emit(entry.sessionId || '', 'permission', { state: 'asked', request: entry });
+    });
+    this.eventBus.on('permission.replied', (entry) => {
+      this._emit(entry.sessionId || '', 'permission', { state: 'replied', request: entry });
+    });
+  }
+
+  async createSession({ sessionId = crypto.randomUUID(), cwd = process.cwd(), prompt = '', model = '', agent = 'build', mode = 'build', run = false } = {}) {
+    this.sessions.set(sessionId, { sessionId, cwd, model, agent, mode, status: run ? 'running' : 'created' });
+    this.replay.appendRecord(sessionId, {
+      type: 'session_meta',
+      cwd,
+      modelId: model,
+      label: prompt.slice(0, 80),
+      agent,
+      mode,
+    });
+    if (prompt) {
+      this.replay.appendRecord(sessionId, {
+        type: 'user',
+        cwd,
+        message: { role: 'user', content: [{ type: 'text', text: prompt }] },
+      });
+    }
+    this._emit(sessionId, 'session.created', { sessionId, cwd, model, agent, mode });
+
+    if (run) {
+      const result = await this._runSession({ sessionId, cwd, prompt, model, agent, mode });
+      this.sessions.set(sessionId, { ...this.sessions.get(sessionId), status: result.success === false ? 'failed' : 'completed' });
+      return { sessionId, cwd, model, agent, mode, result };
+    }
+    return { sessionId, cwd, model, agent, mode };
+  }
+
+  loadSession(sessionId, opts = {}) {
+    const state = this.replay.rebuildState(sessionId, opts);
+    const existing = this.sessions.get(sessionId) || {};
+    this.sessions.set(sessionId, {
+      sessionId,
+      cwd: opts.cwd || state.cwd || existing.cwd || '',
+      model: state.meta.modelId || existing.model || '',
+      agent: state.meta.agent || existing.agent || '',
+      mode: state.meta.mode || existing.mode || '',
+      status: existing.status || 'loaded',
+    });
+    return state;
+  }
+
+  setSessionOptions(sessionId, updates = {}) {
+    const previous = this.sessions.get(sessionId) || { sessionId };
+    const next = { ...previous, ...updates, sessionId };
+    this.sessions.set(sessionId, next);
+    this.replay.appendPart(sessionId, 'session_options', updates, { cwd: next.cwd || '' });
+    this._emit(sessionId, 'session.options', next);
+    return next;
+  }
+
+  cancelSession(sessionId, reason = 'cancelled') {
+    const previous = this.sessions.get(sessionId) || { sessionId };
+    const next = { ...previous, status: 'cancelled', cancelReason: reason };
+    this.sessions.set(sessionId, next);
+    this.replay.appendPart(sessionId, 'cancelled', { reason }, { cwd: next.cwd || '' });
+    this._emit(sessionId, 'session.cancelled', { sessionId, reason });
+    return next;
+  }
+
+  subscribe(sessionId, { offset = 0, sequence = 0, onEvent } = {}) {
+    if (typeof onEvent !== 'function') throw new Error('onEvent callback is required');
+    const replay = this.replay.replayRange(sessionId, { offset, sequence });
+    for (const entry of replay.records) {
+      onEvent({ type: 'transcript', sessionId, sequence: entry.sequence, offset: entry.offset, record: entry.record });
+    }
+    for (const evt of this.history.get(sessionId) || []) {
+      onEvent(evt);
+    }
+    for (const request of this.listPermissions({ sessionId })) {
+      onEvent({ type: 'permission', sessionId, data: { state: 'pending', request } });
+    }
+
+    const set = this.subscribers.get(sessionId) || new Set();
+    set.add(onEvent);
+    this.subscribers.set(sessionId, set);
+    return () => {
+      const current = this.subscribers.get(sessionId);
+      if (!current) return;
+      current.delete(onEvent);
+      if (current.size === 0) this.subscribers.delete(sessionId);
+    };
+  }
+
+  listPermissions({ sessionId = '' } = {}) {
+    if (!this.permissionService?.list) return [];
+    return this.permissionService.list({ sessionId });
+  }
+
+  replyPermission(requestId, reply = 'once', message = '') {
+    if (!this.permissionService?.reply) return false;
+    return this.permissionService.reply({ requestId, reply, message });
+  }
+
+  writeFilesFromAcceptedDiff({ sessionId = '', workspaceRoot, files = [] } = {}) {
+    const root = realpathBestEffort(workspaceRoot);
+    if (!root) throw new Error('workspaceRoot is required');
+    const written = [];
+    for (const file of files) {
+      const target = resolveInside(root, file.path || file.filePath || file.name || '');
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, String(file.content ?? ''), 'utf8');
+      const rel = path.relative(root, target);
+      written.push(rel);
+    }
+    if (sessionId) {
+      this.replay.appendPart(sessionId, 'accepted_diff', { files: written }, { cwd: root });
+      this._emit(sessionId, 'files.written', { files: written, workspaceRoot: root });
+    }
+    return { workspaceRoot: root, files: written };
+  }
+
+  async _runSession({ sessionId, cwd, prompt, model, agent, mode }) {
+    if (this.runner) return this.runner({ sessionId, cwd, prompt, model, agent, mode, adapter: this });
+    if (!this.runAgentLoop) return { success: true, deferred: true };
+    return this.runAgentLoop(prompt, {
+      cwd,
+      model,
+      mode,
+      _resumeSessionId: sessionId,
+    });
+  }
+
+  _emit(sessionId, type, data = {}) {
+    if (!sessionId) return;
+    const event = { type, sessionId, data, timestamp: new Date().toISOString() };
+    const history = this.history.get(sessionId) || [];
+    history.push(event);
+    if (history.length > 200) history.shift();
+    this.history.set(sessionId, history);
+    const subscribers = this.subscribers.get(sessionId);
+    if (subscribers) {
+      for (const send of subscribers) send(event);
+    }
+  }
+}
+
+function resolveInside(root, requestedPath) {
+  if (!requestedPath) throw new Error('file path is required');
+  const target = path.resolve(root, requestedPath);
+  const rel = path.relative(root, target);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new Error(`Path escapes workspace: ${requestedPath}`);
+  }
+  return target;
+}
+
+function realpathBestEffort(p) {
+  if (!p) return '';
+  try { return fs.realpathSync(p); } catch { return path.resolve(p); }
+}
+
+module.exports = {
+  AcpAdapter,
+  resolveInside,
+};

package/template/wall-e/coding/agent-catalog.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const READ_ONLY_TOOL_NAMES = new Set([
+  'read_file',
+  'glob',
+  'grep_files',
+  'list_directory',
+  'lsp_symbols',
+  'lsp_definition',
+  'lsp_references',
+]);
+
+const DELEGATE_TOOL_NAMES = new Set([
+  ...READ_ONLY_TOOL_NAMES,
+  'run_shell',
+  'update_todos',
+  'ask_user',
+  'task',
+  'mcp_call',
+  'skill',
+]);
+
+const BUILTIN_AGENTS = {
+  build: { id: 'build', mode: 'build', description: 'Implement code changes and verify them.', tools: 'all' },
+  plan: { id: 'plan', mode: 'plan', description: 'Plan changes without editing files.', tools: 'read-only' },
+  review: { id: 'review', mode: 'review', description: 'Review code and diffs without editing files.', tools: 'read-only' },
+  explore: { id: 'explore', mode: 'plan', description: 'Explore the repository and report findings.', tools: 'read-only' },
+  master: { id: 'master', mode: 'master', description: 'Coordinate child coding agents and verify their work.', tools: 'delegate' },
+  mixed: { id: 'mixed', mode: 'mixed', description: 'Implement directly while delegating separable work to child agents.', tools: 'all' },
+  general: { id: 'general', mode: 'build', description: 'General coding assistant.', tools: 'all' },
+  compaction: { id: 'compaction', mode: 'summary', description: 'Summarize long coding histories.', hidden: true, tools: [] },
+  summary: { id: 'summary', mode: 'summary', description: 'Produce concise session summaries.', hidden: true, tools: [] },
+  title: { id: 'title', mode: 'summary', description: 'Generate session titles.', hidden: true, tools: [] },
+};
+
+class AgentCatalog {
+  constructor({ projectRoot = process.cwd(), overrides = null } = {}) {
+    this.projectRoot = projectRoot;
+    this.overrides = overrides;
+    this.agents = new Map();
+    this.reload();
+  }
+
+  reload() {
+    this.agents.clear();
+    for (const [id, agent] of Object.entries(BUILTIN_AGENTS)) {
+      this.agents.set(id, normalizeAgent({ ...agent, id }));
+    }
+    const overrides = this.overrides || loadAgentOverrides(this.projectRoot);
+    for (const [id, override] of Object.entries(overrides || {})) {
+      const base = this.agents.get(id) || { id };
+      this.agents.set(id, normalizeAgent({ ...base, ...override, id }));
+    }
+  }
+
+  get(id = 'build') {
+    return this.agents.get(id) || null;
+  }
+
+  list({ includeHidden = false } = {}) {
+    return [...this.agents.values()]
+      .filter((agent) => includeHidden || !agent.hidden)
+      .map((agent) => ({ ...agent }));
+  }
+
+  describeForTool() {
+    return this.list()
+      .map((agent) => `${agent.id}: ${agent.description}`)
+      .join('\n');
+  }
+
+  toolsForAgent(toolDefinitions = [], agentOrId = 'build') {
+    const agent = typeof agentOrId === 'string' ? this.get(agentOrId) : agentOrId;
+    if (!agent) return [];
+    const policy = agent.tools ?? 'all';
+    if (policy === 'all') return [...toolDefinitions];
+    if (policy === 'none' || (Array.isArray(policy) && policy.length === 0)) return [];
+    if (policy === 'delegate' || agent.mode === 'master') {
+      return toolDefinitions.filter((tool) => DELEGATE_TOOL_NAMES.has(tool.name));
+    }
+    if (policy === 'read-only' || agent.mode === 'plan' || agent.mode === 'review') {
+      return toolDefinitions.filter((tool) => READ_ONLY_TOOL_NAMES.has(tool.name));
+    }
+    if (Array.isArray(policy)) {
+      const allowed = new Set(policy);
+      return toolDefinitions.filter((tool) => allowed.has(tool.name));
+    }
+    return [...toolDefinitions];
+  }
+}
+
+function loadAgentOverrides(projectRoot = process.cwd()) {
+  const filePath = path.join(projectRoot, '.walle', 'agents.json');
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizeAgent(agent = {}) {
+  const mode = String(agent.mode || 'build');
+  return {
+    id: String(agent.id || ''),
+    mode,
+    description: String(agent.description || `${agent.id || 'Agent'} coding agent.`),
+    prompt: typeof agent.prompt === 'string' ? agent.prompt : '',
+    model: typeof agent.model === 'string' ? agent.model : '',
+    temperature: agent.temperature,
+    topP: agent.topP ?? agent.top_p,
+    maxSteps: Number.isFinite(agent.maxSteps) ? agent.maxSteps : agent.max_steps,
+    permissionRules: agent.permissionRules || agent.permission_rules || null,
+    hidden: Boolean(agent.hidden),
+    tools: agent.tools ?? (mode === 'plan' || mode === 'review' ? 'read-only' : 'all'),
+  };
+}
+
+module.exports = {
+  AgentCatalog,
+  BUILTIN_AGENTS,
+  READ_ONLY_TOOL_NAMES,
+  DELEGATE_TOOL_NAMES,
+  loadAgentOverrides,
+  normalizeAgent,
+};

package/template/wall-e/coding/compaction-service.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const { estimateTokens, estimateMessagesTokens } = require('../context/token-counter');
+const { recordContextCompaction } = require('./execution-trace');
+const { newId, textFromContent } = require('./model-message');
+
+const DEFAULT_CONTEXT_WINDOW = 200000;
+const DEFAULT_THRESHOLD = 0.75;
+const DEFAULT_TAIL_TOKEN_BUDGET = 40000;
+const DEFAULT_KEEP_RECENT_USER_TURNS = 4;
+
+class CompactionService {
+  constructor({
+    provider,
+    model,
+    contextWindow = DEFAULT_CONTEXT_WINDOW,
+    threshold = DEFAULT_THRESHOLD,
+    tailTokenBudget = DEFAULT_TAIL_TOKEN_BUDGET,
+    keepRecentUserTurns = DEFAULT_KEEP_RECENT_USER_TURNS,
+    now,
+  } = {}) {
+    this.provider = provider || null;
+    this.model = model || provider?.model || '';
+    this.contextWindow = contextWindow;
+    this.threshold = threshold;
+    this.tailTokenBudget = tailTokenBudget;
+    this.keepRecentUserTurns = keepRecentUserTurns;
+    this.now = now || (() => new Date().toISOString());
+  }
+
+  shouldCompact({ messages = [], systemTokens = 0, usage = null, contextWindow = this.contextWindow } = {}) {
+    const actualInput = Number.isFinite(usage?.input) ? usage.input
+      : Number.isFinite(usage?.inputTokens) ? usage.inputTokens
+        : null;
+    const tokens = actualInput == null
+      ? systemTokens + estimateMessagesTokens(messages)
+      : actualInput;
+    return tokens >= contextWindow * this.threshold;
+  }
+
+  selectTail(messages = [], {
+    tailTokenBudget = this.tailTokenBudget,
+    keepRecentUserTurns = this.keepRecentUserTurns,
+  } = {}) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return { head: [], tail: [], tailStartIndex: -1, tailStartId: null, tailTokens: 0, headTokens: 0 };
+    }
+
+    let tailStartIndex = messages.length;
+    let tailTokens = 0;
+    let userTurns = 0;
+
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      const msgTokens = estimateMessagesTokens([msg]);
+      const stillProtectingTurns = userTurns < keepRecentUserTurns;
+      if (!stillProtectingTurns && tailStartIndex < messages.length && tailTokens + msgTokens > tailTokenBudget) {
+        break;
+      }
+
+      tailStartIndex = i;
+      tailTokens += msgTokens;
+      if (msg?.role === 'user') userTurns++;
+
+      if (!stillProtectingTurns && tailTokens >= tailTokenBudget) break;
+    }
+
+    if (tailStartIndex <= 0) {
+      return {
+        head: [],
+        tail: cloneMessages(messages),
+        tailStartIndex: 0,
+        tailStartId: getMessageId(messages[0], 0),
+        tailTokens,
+        headTokens: 0,
+      };
+    }
+
+    const head = messages.slice(0, tailStartIndex);
+    const tail = messages.slice(tailStartIndex);
+    return {
+      head: cloneMessages(head),
+      tail: cloneMessages(tail),
+      tailStartIndex,
+      tailStartId: getMessageId(messages[tailStartIndex], tailStartIndex),
+      tailTokens,
+      headTokens: estimateMessagesTokens(head),
+    };
+  }
+
+  async compact(messages = [], {
+    sessionId = '',
+    cwd = '',
+    reason = 'context_overflow',
+    transcript = null,
+    trace = null,
+    sessionMemory = null,
+    tailTokenBudget,
+    keepRecentUserTurns,
+  } = {}) {
+    if (sessionMemory && typeof sessionMemory.precompact === 'function') {
+      await sessionMemory.precompact({ messages, sessionId, cwd, reason });
+    }
+
+    const selection = this.selectTail(messages, { tailTokenBudget, keepRecentUserTurns });
+    const tokensBefore = estimateMessagesTokens(messages);
+    if (selection.head.length === 0) {
+      const noCompaction = {
+        compacted: false,
+        reason: 'no_compactable_head',
+        messages: cloneMessages(messages),
+        tokensBeforeCompaction: tokensBefore,
+        tokensAfterCompaction: tokensBefore,
+      };
+      recordContextCompaction(trace, noCompaction);
+      return noCompaction;
+    }
+
+    const compactionId = newId('compaction');
+    const summary = await this._summarize(selection.head, selection);
+    const timestamp = this.now();
+    const userMessage = {
+      role: 'user',
+      content: `[Compaction:${compactionId}] Earlier Wall-E context was compacted. Recent tail starts at ${selection.tailStartId}.`,
+    };
+    const assistantMessage = {
+      role: 'assistant',
+      content: `Compaction summary:\n${summary}`,
+    };
+    const compactedMessages = [userMessage, assistantMessage, ...selection.tail];
+    const tokensAfter = estimateMessagesTokens(compactedMessages);
+    const metadata = {
+      compactionId,
+      reason,
+      sessionId,
+      cwd,
+      timestamp,
+      compaction_user_id: newId('compaction_user'),
+      compaction_assistant_id: newId('compaction_assistant'),
+      tail_start_id: selection.tailStartId,
+      tail_start_index: selection.tailStartIndex,
+      tail_message_ids: selection.tail.map((msg, index) => getMessageId(msg, selection.tailStartIndex + index)),
+      compacted_message_count: selection.head.length,
+      retained_message_count: selection.tail.length,
+      tokens_before: tokensBefore,
+      tokens_after: tokensAfter,
+      summary,
+    };
+
+    if (transcript?.appendPart) {
+      await transcript.appendPart({ sessionId, cwd, partType: 'compaction', data: metadata });
+    } else if (transcript?.append) {
+      await transcript.append({ type: 'walle_part', sessionId, cwd, partType: 'compaction', data: metadata });
+    }
+
+    const result = {
+      compacted: true,
+      messages: compactedMessages,
+      summary,
+      userMessage,
+      assistantMessage,
+      tailStartId: selection.tailStartId,
+      metadata,
+      tokensBeforeCompaction: tokensBefore,
+      tokensAfterCompaction: tokensAfter,
+    };
+    recordContextCompaction(trace, result);
+    return result;
+  }
+
+  remapTailStartId(compaction, idMap = {}, forkMessages = []) {
+    return remapTailStartId(compaction, idMap, forkMessages);
+  }
+
+  async _summarize(messages, selection) {
+    const historyText = messages.map(formatMessageForSummary).join('\n\n');
+    const fallback = fallbackSummary(historyText, selection);
+    if (!this.provider || typeof this.provider.chat !== 'function') return fallback;
+
+    const prompt = `Summarize the compacted Wall-E coding history. Preserve decisions, file paths, commands, tool findings, failures, and unfinished work. Do not include a preamble.\n\nCOMPACTED HISTORY:\n${historyText.slice(0, 60000)}`;
+    try {
+      const response = await this.provider.chat({
+        model: this.model,
+        messages: [{ role: 'user', content: prompt }],
+        maxTokens: 1200,
+        metadata: { purpose: 'compaction' },
+      });
+      const content = textFromContent(response?.content || '');
+      return content.trim() || fallback;
+    } catch {
+      return fallback;
+    }
+  }
+}
+
+function remapTailStartId(compaction, idMap = {}, forkMessages = []) {
+  const oldTailId = compaction?.tailStartId || compaction?.tail_start_id || compaction?.metadata?.tail_start_id || null;
+  if (!oldTailId) return null;
+  if (idMap[oldTailId]) return idMap[oldTailId];
+
+  const forkIds = new Set((forkMessages || []).map((msg, index) => getMessageId(msg, index)).filter(Boolean));
+  if (forkIds.has(oldTailId)) return oldTailId;
+
+  const tailIds = compaction?.tailMessageIds || compaction?.tail_message_ids || compaction?.metadata?.tail_message_ids || [];
+  for (const id of tailIds) {
+    if (idMap[id]) return idMap[id];
+    if (forkIds.has(id)) return id;
+  }
+  return forkMessages.length > 0 ? getMessageId(forkMessages[0], 0) : null;
+}
+
+function getMessageId(message, index = 0) {
+  return message?.id || message?.uuid || message?.messageId || message?.message_id || `msg_${index}`;
+}
+
+function cloneMessages(messages) {
+  return (messages || []).map((msg) => cloneValue(msg));
+}
+
+function cloneValue(value) {
+  if (value == null) return value;
+  return JSON.parse(JSON.stringify(value));
+}
+
+function formatMessageForSummary(message, index) {
+  const role = message?.role || 'unknown';
+  const id = getMessageId(message, index);
+  return `${role} (${id}): ${textFromContent(message?.content || '').slice(0, 12000)}`;
+}
+
+function fallbackSummary(historyText, selection) {
+  const line = `Compacted ${selection.head.length} older messages before tail ${selection.tailStartId}.`;
+  if (!historyText) return line;
+  const max = 4000;
+  return `${line}\n\n${historyText.length > max ? historyText.slice(-max) : historyText}`;
+}
+
+module.exports = {
+  CompactionService,
+  remapTailStartId,
+  getMessageId,
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_THRESHOLD,
+  DEFAULT_TAIL_TOKEN_BUDGET,
+  DEFAULT_KEEP_RECENT_USER_TURNS,
+  estimateTokens,
+};

package/template/wall-e/coding/execution-trace.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../runtime/execution-trace');