create-walle 0.9.11 → 0.9.13

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

@@ -0,0 +1,155 @@
+'use strict';
+
+const path = require('node:path');
+const { SnapshotManager } = require('../tools/snapshot');
+const { newId } = require('./model-message');
+
+const MUTATING_TOOLS = new Set(['write_file', 'edit_file', 'multi_edit', 'apply_patch']);
+
+class SnapshotService {
+  constructor({ cwd = process.cwd(), snapshot = null, now } = {}) {
+    this.cwd = path.resolve(cwd);
+    this.snapshot = snapshot || new SnapshotManager(this.cwd);
+    this.now = now || (() => new Date().toISOString());
+    this.boundaries = new Map();
+    this.activeBoundaryId = null;
+  }
+
+  async captureStepStart({ sessionId = '', cwd = this.cwd, messageId = '' } = {}) {
+    this.cwd = path.resolve(cwd || this.cwd);
+    const boundaryId = newId('boundary');
+    const record = {
+      snapshotId: newId('snapshot'),
+      boundaryId,
+      kind: 'step_start',
+      sessionId,
+      cwd: this.cwd,
+      messageId,
+      timestamp: this.now(),
+      stackDepths: this.snapshot.getStackDepths ? this.snapshot.getStackDepths() : {},
+      capturedFiles: [],
+    };
+    this.boundaries.set(boundaryId, record);
+    this.activeBoundaryId = boundaryId;
+    return publicBoundary(record);
+  }
+
+  async captureToolInput({ toolName, input = {}, sessionId = '', cwd = this.cwd, messageId = '' } = {}) {
+    if (!MUTATING_TOOLS.has(toolName)) return null;
+    this.cwd = path.resolve(cwd || this.cwd);
+    const files = inferMutatingPaths(toolName, input, this.cwd);
+    if (files.length === 0) return null;
+
+    const captured = [];
+    for (const filePath of files) {
+      try {
+        if (this.snapshot.capture(filePath)) captured.push(filePath);
+      } catch (err) {
+        captured.push({ filePath, error: err.message });
+      }
+    }
+    const boundary = this.boundaries.get(this.activeBoundaryId);
+    if (boundary) {
+      for (const file of captured) {
+        const filePath = typeof file === 'string' ? file : file.filePath;
+        if (filePath && !boundary.capturedFiles.includes(filePath)) boundary.capturedFiles.push(filePath);
+      }
+    }
+
+    return {
+      snapshotId: newId('snapshot'),
+      boundaryId: this.activeBoundaryId,
+      kind: 'tool_pre_mutation',
+      sessionId,
+      cwd: this.cwd,
+      messageId,
+      toolName,
+      files: captured,
+      timestamp: this.now(),
+    };
+  }
+
+  async captureStepFinish({ sessionId = '', cwd = this.cwd, messageId = '' } = {}) {
+    this.cwd = path.resolve(cwd || this.cwd);
+    const summary = this.snapshot.summary();
+    return {
+      snapshotId: newId('snapshot'),
+      boundaryId: this.activeBoundaryId,
+      kind: 'step_finish',
+      sessionId,
+      cwd: this.cwd,
+      messageId,
+      timestamp: this.now(),
+      files: summary.files,
+      totalAdditions: summary.totalAdditions,
+      totalDeletions: summary.totalDeletions,
+      diffs: summary.diffs,
+    };
+  }
+
+  revertToBoundary(boundaryId = this.activeBoundaryId) {
+    const boundary = this.boundaries.get(boundaryId);
+    if (!boundary) throw new Error(`No snapshot boundary: ${boundaryId}`);
+    const restoredFiles = this.snapshot.restoreToStackDepths
+      ? this.snapshot.restoreToStackDepths(boundary.stackDepths)
+      : fallbackRestoreAll(this.snapshot);
+    return {
+      boundaryId,
+      restoredFiles,
+      timestamp: this.now(),
+    };
+  }
+
+  getBoundary(boundaryId = this.activeBoundaryId) {
+    const boundary = this.boundaries.get(boundaryId);
+    return boundary ? publicBoundary(boundary) : null;
+  }
+}
+
+function inferMutatingPaths(toolName, input = {}, cwd = process.cwd()) {
+  if (!MUTATING_TOOLS.has(toolName)) return [];
+  if (toolName === 'apply_patch') return inferPatchPaths(input.patch_text || input.patch || '', cwd);
+  const raw = input.file_path || input.path;
+  if (!raw) return [];
+  return [resolveToolPath(raw, input.projectRoot || cwd)];
+}
+
+function inferPatchPaths(patchText, cwd = process.cwd()) {
+  const files = [];
+  for (const line of String(patchText || '').split('\n')) {
+    const match = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/);
+    if (!match) continue;
+    files.push(resolveToolPath(match[1].trim(), cwd));
+  }
+  return [...new Set(files)];
+}
+
+function resolveToolPath(filePath, root) {
+  if (path.isAbsolute(filePath)) return path.resolve(filePath);
+  return path.resolve(root || process.cwd(), filePath);
+}
+
+function publicBoundary(record) {
+  return {
+    snapshotId: record.snapshotId,
+    boundaryId: record.boundaryId,
+    kind: record.kind,
+    sessionId: record.sessionId,
+    cwd: record.cwd,
+    messageId: record.messageId,
+    timestamp: record.timestamp,
+    capturedFiles: [...record.capturedFiles],
+  };
+}
+
+function fallbackRestoreAll(snapshot) {
+  snapshot.revertAll();
+  return snapshot.files ? snapshot.files() : [];
+}
+
+module.exports = {
+  SnapshotService,
+  inferMutatingPaths,
+  inferPatchPaths,
+  MUTATING_TOOLS,
+};

package/template/wall-e/coding/stream-processor.js

@@ -0,0 +1,268 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const {
+  newId,
+  textFromContent,
+  normalizeToolCall,
+  assistantMessageFromResponse,
+  toolResultMessage,
+} = require('./model-message');
+const { normalizeResponse, transformRequest, providerId } = require('./provider-transform');
+
+async function* streamFromChat(provider, request) {
+  const response = normalizeResponse(await provider.chat(request), {
+    provider,
+    model: request.model,
+  });
+  const messageId = newId('assistant');
+  if (response.reasoningContent) {
+    yield { type: 'reasoning_delta', messageId, partId: newId('reasoning'), data: { text: response.reasoningContent } };
+  }
+  if (response.content) {
+    yield { type: 'text_delta', messageId, partId: newId('text'), data: { text: textFromContent(response.content) } };
+  }
+  for (const call of response.toolCalls || []) {
+    yield { type: 'tool_call', messageId, partId: newId('tool'), toolCallId: call.id, data: call };
+  }
+  yield {
+    type: 'finish',
+    messageId,
+    data: {
+      stopReason: response.stopReason,
+      usage: response.usage,
+      model: response.model,
+      provider: response.provider,
+      latencyMs: response.latencyMs,
+      response,
+    },
+  };
+}
+
+class StreamProcessor extends EventEmitter {
+  constructor({ provider, model, transcript, toolExecutor, snapshotService, permissionService, now } = {}) {
+    super();
+    if (!provider) throw new Error('provider is required');
+    this.provider = provider;
+    this.model = model;
+    this.transcript = transcript || null;
+    this.toolExecutor = toolExecutor || null;
+    this.snapshotService = snapshotService || null;
+    this.permissionService = permissionService || null;
+    this.now = now || (() => new Date().toISOString());
+  }
+
+  async runTurn({ sessionId, cwd, system, messages = [], tools = [], signal, maxTokens, temperature, ...requestOptions } = {}) {
+    const request = transformRequest({
+      ...requestOptions,
+      provider: this.provider,
+      model: this.model,
+      system,
+      messages,
+      tools,
+      cwd,
+      maxTokens,
+      temperature,
+      signal,
+    });
+    const stream = typeof this.provider.chatStream === 'function'
+      ? this.provider.chatStream(request)
+      : streamFromChat(this.provider, request);
+
+    const assistantMessageId = newId('assistant');
+    const state = {
+      sessionId,
+      cwd,
+      messageId: assistantMessageId,
+      provider: providerId(this.provider),
+      model: this.model,
+      text: '',
+      reasoning: '',
+      toolCalls: [],
+      toolResults: [],
+      usage: { input: 0, output: 0 },
+      stopReason: '',
+      status: 'running',
+      errors: [],
+      events: [],
+    };
+
+    await this._record(sessionId, cwd, 'step_start', {
+      messageId: assistantMessageId,
+      provider: state.provider,
+      model: state.model,
+    });
+    this._emit({ type: 'step_start', sessionId, messageId: assistantMessageId });
+    if (this.snapshotService?.captureStepStart) {
+      const snapshot = await this.snapshotService.captureStepStart({ sessionId, cwd, messageId: assistantMessageId });
+      if (snapshot) await this._record(sessionId, cwd, 'snapshot', snapshot);
+    }
+
+    try {
+      for await (const event of stream) {
+        await this._handleEvent(event, state, { sessionId, cwd, tools });
+      }
+      if (state.toolCalls.length > 0 && this.toolExecutor) {
+        for (const call of state.toolCalls) {
+          await this._runTool(call, state, { sessionId, cwd });
+        }
+      }
+      if (this.snapshotService?.captureStepFinish) {
+        const snapshot = await this.snapshotService.captureStepFinish({ sessionId, cwd, messageId: assistantMessageId });
+        if (snapshot) await this._record(sessionId, cwd, 'snapshot', snapshot);
+      }
+      state.status = state.errors.length > 0 ? 'error' : 'finished';
+    } catch (err) {
+      state.status = 'error';
+      state.errors.push(err.message);
+      await this._record(sessionId, cwd, 'error', { message: err.message });
+      this._emit({ type: 'error', sessionId, messageId: assistantMessageId, error: err.message });
+    } finally {
+      await this._record(sessionId, cwd, 'step_finish', {
+        messageId: assistantMessageId,
+        status: state.status,
+        stopReason: state.stopReason,
+        usage: state.usage,
+      });
+      this._emit({ type: 'step_finish', sessionId, messageId: assistantMessageId, status: state.status });
+    }
+
+    return {
+      ...state,
+      assistantMessage: assistantMessageFromResponse({
+        content: state.text,
+        reasoningContent: state.reasoning,
+        toolCalls: state.toolCalls,
+      }),
+      toolResultMessage: state.toolResults.length > 0 ? toolResultMessage(state.toolResults) : null,
+      next: state.status === 'error' ? 'stop' : state.toolResults.length > 0 ? 'continue' : 'stop',
+    };
+  }
+
+  async _handleEvent(event, state, ctx) {
+    if (!event || !event.type) return;
+    state.events.push(event);
+    this._emit({ ...event, sessionId: ctx.sessionId });
+    if (event.type === 'text_delta') {
+      const text = textFromContent(event.data?.text ?? event.text ?? event.delta ?? '');
+      if (!text) return;
+      state.text += text;
+      await this._record(ctx.sessionId, ctx.cwd, 'text', { text, messageId: state.messageId, partId: event.partId || newId('text') });
+      return;
+    }
+    if (event.type === 'reasoning_delta') {
+      const text = textFromContent(event.data?.text ?? event.text ?? event.delta ?? '');
+      if (!text) return;
+      state.reasoning += text;
+      await this._record(ctx.sessionId, ctx.cwd, 'reasoning', { text, messageId: state.messageId, partId: event.partId || newId('reasoning') });
+      return;
+    }
+    if (event.type === 'tool_input_delta') {
+      await this._record(ctx.sessionId, ctx.cwd, 'tool', {
+        state: 'input_delta',
+        toolCallId: event.toolCallId,
+        delta: event.data?.delta ?? event.delta ?? '',
+      });
+      return;
+    }
+    if (event.type === 'tool_call') {
+      const call = normalizeToolCall(event.data || event);
+      state.toolCalls.push(call);
+      await this._record(ctx.sessionId, ctx.cwd, 'tool', {
+        state: 'pending',
+        toolCallId: call.id,
+        name: call.name,
+        input: call.input,
+      });
+      return;
+    }
+    if (event.type === 'finish') {
+      const data = event.data || {};
+      state.stopReason = data.stopReason || data.response?.stopReason || '';
+      state.usage = data.usage || data.response?.usage || state.usage;
+      if (data.model) state.model = data.model;
+      if (data.provider) state.provider = data.provider;
+    }
+  }
+
+  async _runTool(call, state, { sessionId, cwd }) {
+    try {
+      if (this.permissionService?.authorize) {
+        await this._record(sessionId, cwd, 'tool', {
+          state: 'permission_check',
+          toolCallId: call.id,
+          name: call.name,
+          input: call.input,
+        });
+        const permission = await this.permissionService.authorize({
+          sessionId,
+          tool: call.name,
+          input: call.input,
+          cwd,
+          projectRoot: cwd,
+          metadata: { toolCallId: call.id },
+        });
+        if (permission.decision !== 'allow') {
+          throw new Error(`Permission denied: ${permission.reason || permission.message || permission.decision}`);
+        }
+      }
+      if (this.snapshotService?.captureToolInput) {
+        const snapshot = await this.snapshotService.captureToolInput({
+          toolName: call.name,
+          input: call.input,
+          sessionId,
+          cwd,
+          messageId: state.messageId,
+        });
+        if (snapshot) await this._record(sessionId, cwd, 'snapshot', snapshot);
+      }
+      await this._record(sessionId, cwd, 'tool', {
+        state: 'running',
+        toolCallId: call.id,
+        name: call.name,
+        input: call.input,
+      });
+      const result = await this.toolExecutor(call, { sessionId, cwd, model: state.model, provider: state.provider });
+      state.toolResults.push({ toolCallId: call.id, name: call.name, result });
+      await this._record(sessionId, cwd, 'tool', {
+        state: 'completed',
+        toolCallId: call.id,
+        name: call.name,
+        result,
+      });
+    } catch (err) {
+      state.errors.push(err.message);
+      state.toolResults.push({ toolCallId: call.id, name: call.name, error: err.message });
+      await this._record(sessionId, cwd, 'tool', {
+        state: 'error',
+        toolCallId: call.id,
+        name: call.name,
+        error: err.message,
+      });
+    }
+  }
+
+  async _record(sessionId, cwd, partType, data) {
+    const payload = {
+      type: 'walle_part',
+      provider: 'walle',
+      sessionId,
+      cwd,
+      timestamp: this.now(),
+      partType,
+      data,
+    };
+    if (this.transcript?.appendPart) return this.transcript.appendPart(payload);
+    if (this.transcript?.append) return this.transcript.append(payload);
+    return null;
+  }
+
+  _emit(event) {
+    this.emit('event', event);
+  }
+}
+
+module.exports = {
+  StreamProcessor,
+  streamFromChat,
+};

package/template/wall-e/coding/task-tool.js

@@ -0,0 +1,255 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const { AgentCatalog } = require('./agent-catalog');
+
+class TaskTool {
+  constructor({ agentCatalog = null, runner = null, agentRuntime = null, brain = null, transcript = null } = {}) {
+    this.agentCatalog = agentCatalog || new AgentCatalog();
+    this.runner = runner || null;
+    this.agentRuntime = agentRuntime || null;
+    this.brain = brain || null;
+    this.transcript = transcript || null;
+  }
+
+  definition() {
+    return {
+      name: 'task',
+      description: `Create or resume a child Wall-E coding task with a selected agent.\nAvailable agents:\n${this.agentCatalog.describeForTool()}`,
+      input_schema: {
+        type: 'object',
+        properties: {
+          prompt: { type: 'string', description: 'Task prompt for the child agent' },
+          agent: { type: 'string', description: 'Agent id, such as build, plan, review, or explore' },
+          task_id: { type: 'string', description: 'Existing task id to resume' },
+          action: { type: 'string', enum: ['run', 'create', 'status', 'resume', 'cancel'], description: 'Lifecycle action. run is default; create/defer queues without running.' },
+          defer: { type: 'boolean', description: 'Create the child task but do not run it yet.' },
+          async: { type: 'boolean', description: 'Alias for defer.' },
+          resume: { type: 'boolean', description: 'Resume task_id instead of creating a new task' },
+        },
+        required: [],
+      },
+    };
+  }
+
+  async execute(args = {}, ctx = {}) {
+    const taskConfig = args.task_id ? this._loadTaskConfig(args.task_id) : {};
+    const agentId = args.agent || taskConfig.agent || 'build';
+    const agent = this.agentCatalog.get(agentId);
+    if (!agent) return { error: `Unknown agent: ${agentId}`, invalid: true };
+    const action = normalizeAction(args);
+    if (!VALID_ACTIONS.has(action)) return { error: `Unknown task action: ${action}`, invalid: true };
+
+    if (action === 'status') {
+      if (!args.task_id) return { error: 'task_id is required for status', invalid: true };
+      const task = this._loadTask(args.task_id);
+      await this._appendPart(ctx, {
+        task_id: args.task_id,
+        parent_id: ctx.sessionId || '',
+        agent: agentId,
+        state: 'status',
+        status: task?.status || 'unknown',
+      });
+      return { task_id: args.task_id, agent: agentId, status: task?.status || 'unknown', task: publicTask(task) };
+    }
+
+    if (action === 'cancel') {
+      if (!args.task_id) return { error: 'task_id is required for cancel', invalid: true };
+      this._cancelTask(args.task_id, args.reason || 'Canceled by parent agent');
+      const task = this._loadTask(args.task_id);
+      await this._appendPart(ctx, {
+        task_id: args.task_id,
+        parent_id: ctx.sessionId || '',
+        agent: agentId,
+        state: 'canceled',
+        reason: args.reason || '',
+      });
+      return { task_id: args.task_id, agent: agentId, status: task?.status || 'canceled', task: publicTask(task) };
+    }
+
+    const taskId = args.task_id || this._createTask(args, agent, ctx);
+    const prompt = args.prompt || taskConfig.prompt || this._loadPrompt(taskId) || '';
+    if (!prompt) return { error: 'prompt is required for new task', task_id: taskId };
+
+    await this._appendPart(ctx, {
+      task_id: taskId,
+      parent_id: ctx.sessionId || '',
+      agent: agentId,
+      state: args.task_id || args.resume ? 'resumed' : 'created',
+      prompt,
+    });
+
+    if (action === 'create' || args.defer || args.async) {
+      await this._appendPart(ctx, {
+        task_id: taskId,
+        parent_id: ctx.sessionId || '',
+        agent: agentId,
+        state: 'deferred',
+        prompt,
+      });
+      return {
+        task_id: taskId,
+        agent: agentId,
+        status: this._loadTask(taskId)?.status || 'pending',
+        result: { success: true, deferred: true, output: 'Task created and deferred.' },
+      };
+    }
+
+    this._markRunning(taskId);
+    let result;
+    try {
+      if (this.agentRuntime) {
+        result = await this.agentRuntime.spawnAgentSession({
+          parentRunId: ctx.runId || ctx.sessionId || '',
+          runnerId: agent.runnerId || agent.id,
+          providerType: agent.providerType,
+          mode: agent.mode,
+          task: prompt,
+          cwd: ctx.cwd || '',
+          sessionId: args.session_id || args.agent_session_id,
+          persistent: Boolean(args.persistent),
+          cleanupPolicy: args.cleanup_policy,
+        });
+      } else {
+        result = this.runner
+          ? await this.runner({ prompt, agent, taskId, ctx })
+          : { success: true, output: 'Task created but no runner is configured.', deferred: true };
+      }
+    } catch (err) {
+      result = { success: false, error: err.message };
+    }
+    if (!result || typeof result !== 'object') result = { success: true, output: String(result ?? '') };
+
+    this._updateTask(taskId, result);
+    await this._appendPart(ctx, {
+      task_id: taskId,
+      parent_id: ctx.sessionId || '',
+      agent: agentId,
+      state: result.success === false ? 'error' : 'completed',
+      result,
+    });
+
+    return { task_id: taskId, agent: agentId, result };
+  }
+
+  _createTask(args, agent, ctx) {
+    if (!this.brain?.insertTask) return `task_${crypto.randomUUID().slice(0, 8)}`;
+    const inserted = this.brain.insertTask({
+      title: args.prompt ? args.prompt.slice(0, 80) : `Child task: ${agent.id}`,
+      description: args.prompt || '',
+      priority: 'normal',
+      type: 'once',
+      execution: 'skill',
+      skill: 'coding-agent',
+      skill_config: JSON.stringify({
+        parent_id: ctx.sessionId || '',
+        agent: agent.id,
+        mode: agent.mode,
+        prompt: args.prompt || '',
+        cwd: ctx.cwd || '',
+      }),
+      source: 'walle-task-tool',
+      source_ref: ctx.sessionId || '',
+    });
+    return inserted.id;
+  }
+
+  _loadTaskConfig(taskId) {
+    if (!taskId || !this.brain?.getTask) return {};
+    const task = this.brain.getTask(taskId);
+    if (!task?.skill_config) return {};
+    try {
+      return JSON.parse(task.skill_config) || {};
+    } catch {
+      return {};
+    }
+  }
+
+  _loadTask(taskId) {
+    if (!taskId || !this.brain?.getTask) return null;
+    return this.brain.getTask(taskId);
+  }
+
+  _loadPrompt(taskId) {
+    if (!taskId || !this.brain?.getTask) return '';
+    const task = this.brain.getTask(taskId);
+    if (!task?.skill_config) return task?.description || '';
+    try {
+      return JSON.parse(task.skill_config).prompt || task.description || '';
+    } catch {
+      return task.description || '';
+    }
+  }
+
+  _markRunning(taskId) {
+    if (!taskId || !this.brain?.updateTask) return;
+    const updates = {
+      status: 'running',
+      started_at: new Date().toISOString(),
+      error: null,
+    };
+    this.brain.updateTask(taskId, updates);
+  }
+
+  _updateTask(taskId, result) {
+    if (!taskId || !this.brain?.updateTask) return;
+    const deferred = Boolean(result.deferred);
+    const failed = result.success === false || Boolean(result.error);
+    this.brain.updateTask(taskId, {
+      status: deferred ? 'pending' : failed ? 'failed' : 'completed',
+      result: JSON.stringify(result),
+      error: failed ? String(result.error || 'Task failed') : null,
+      completed_at: deferred ? null : new Date().toISOString(),
+    });
+  }
+
+  _cancelTask(taskId, reason) {
+    if (!taskId || !this.brain?.updateTask) return;
+    this.brain.updateTask(taskId, {
+      status: 'canceled',
+      error: reason || null,
+      completed_at: new Date().toISOString(),
+    });
+  }
+
+  async _appendPart(ctx, data) {
+    const target = ctx.transcript || this.transcript;
+    if (target?.appendPart) {
+      await target.appendPart({ sessionId: ctx.sessionId || '', cwd: ctx.cwd || '', partType: 'subtask', data });
+    } else if (target?.append) {
+      await target.append({ type: 'walle_part', sessionId: ctx.sessionId || '', cwd: ctx.cwd || '', partType: 'subtask', data });
+    }
+  }
+}
+
+function normalizeAction(args = {}) {
+  if (args.action) return String(args.action).toLowerCase();
+  if (args.resume) return 'resume';
+  if (args.defer || args.async) return 'create';
+  return 'run';
+}
+
+const VALID_ACTIONS = new Set(['run', 'create', 'status', 'resume', 'cancel']);
+
+function publicTask(task) {
+  if (!task) return null;
+  let result = task.result || null;
+  if (typeof result === 'string' && result.trim()) {
+    try {
+      result = JSON.parse(result);
+    } catch {}
+  }
+  return {
+    id: task.id,
+    title: task.title || '',
+    status: task.status || '',
+    error: task.error || null,
+    started_at: task.started_at || null,
+    completed_at: task.completed_at || null,
+    result,
+  };
+}
+
+module.exports = {
+  TaskTool,
+};