create-walle 0.9.11 → 0.9.13

package/template/wall-e/coding/prompt-bundle.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  buildChildScopeSection,
+  buildPromptEnvelope,
+  buildReviewerEnvelope,
+  createPromptSection,
+  redactPromptContent,
+  renderPromptEnvelope,
+} = require('./prompt-runtime');
+
+const PROMPT_DIR = path.join(__dirname, '..', 'prompts', 'coding');
+
+function loadPromptText(name) {
+  try {
+    return fs.readFileSync(path.join(PROMPT_DIR, name), 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
+
+function selectPromptFiles({ mode = 'build', provider = '', model = '' } = {}) {
+  const files = ['base.txt'];
+  if (mode === 'plan') files.push('plan.txt');
+  if (/deepseek/i.test(`${provider} ${model}`)) files.push('deepseek.txt');
+  return files;
+}
+
+function buildPromptBundle({ body = '', mode = 'build', provider = '', model = '', extraInstructions = [], returnEnvelope = false } = {}) {
+  const bundleText = selectPromptFiles({ mode, provider, model })
+    .map(loadPromptText)
+    .filter(Boolean)
+    .join('\n\n');
+  const extras = (extraInstructions || [])
+    .filter((item) => item?.content)
+    .map((item) => createPromptSection({
+      id: `instruction:${item.path || 'inline'}`,
+      source: item.path || 'extra-instructions',
+      content: `## Instruction: ${item.path}\n${item.content}`,
+      cacheable: true,
+      redactionPolicy: 'secrets',
+    }));
+
+  const envelope = buildPromptEnvelope({
+    stablePolicy: bundleText,
+    toolPolicy: body,
+    sections: extras,
+    metadata: { mode, provider, model },
+  });
+
+  return returnEnvelope ? envelope : renderPromptEnvelope(envelope);
+}
+
+module.exports = {
+  PROMPT_DIR,
+  loadPromptText,
+  selectPromptFiles,
+  buildPromptBundle,
+  buildChildScopeSection,
+  buildPromptEnvelope,
+  buildReviewerEnvelope,
+  createPromptSection,
+  redactPromptContent,
+  renderPromptEnvelope,
+};

package/template/wall-e/coding/prompt-runtime.js

@@ -0,0 +1,243 @@
+'use strict';
+
+const DEFAULT_RECIPIENT = 'agent';
+
+function estimateTokens(content) {
+  const text = String(content || '');
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+
+function createPromptSection({
+  id,
+  source = 'runtime',
+  content = '',
+  recipient = DEFAULT_RECIPIENT,
+  cacheable = true,
+  visibility = 'llm',
+  mutableByHooks = true,
+  tokenEstimate = null,
+  redactionPolicy = 'none',
+  metadata = {},
+} = {}) {
+  if (!id) throw new Error('Prompt section id is required');
+  const text = String(content || '');
+  return {
+    id,
+    source,
+    content: text,
+    recipient,
+    cacheable: Boolean(cacheable),
+    visibility,
+    mutableByHooks: Boolean(mutableByHooks),
+    tokenEstimate: tokenEstimate != null && Number.isFinite(Number(tokenEstimate))
+      ? Number(tokenEstimate)
+      : estimateTokens(text),
+    redactionPolicy,
+    metadata: { ...metadata },
+  };
+}
+
+function redactPromptContent(content, policy = 'none') {
+  const text = String(content || '');
+  if (policy === 'none') return text;
+  let redacted = text;
+  if (policy === 'secrets' || policy === 'standard') {
+    redacted = redacted
+      .replace(/\b(sk-[A-Za-z0-9_-]{8,})\b/g, '[REDACTED_API_KEY]')
+      .replace(/\b(AKIA[0-9A-Z]{16})\b/g, '[REDACTED_AWS_KEY]')
+      .replace(/(token|secret|password)\s*[:=]\s*["'][^"']+["']/gi, '$1="[REDACTED]"');
+  }
+  if (policy === 'standard') {
+    redacted = redacted.replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, '[REDACTED_EMAIL]');
+  }
+  return redacted;
+}
+
+function normalizePromptSection(section) {
+  if (!section) return null;
+  if (typeof section === 'string') {
+    return createPromptSection({ id: `inline-${hashString(section)}`, content: section });
+  }
+  return createPromptSection(section);
+}
+
+function buildPromptEnvelope({
+  recipient = DEFAULT_RECIPIENT,
+  stablePolicy = '',
+  workspacePersona = '',
+  projectContext = '',
+  toolPolicy = '',
+  providerContribution = '',
+  channelContext = '',
+  parentRunContext = '',
+  childScope = '',
+  runtimeOnlyContext = '',
+  nextTurnContext = '',
+  userTask = '',
+  sections = [],
+  metadata = {},
+} = {}) {
+  const built = [];
+  addSection(built, {
+    id: 'stable-policy',
+    source: 'prompt-runtime',
+    content: stablePolicy,
+    recipient,
+    cacheable: true,
+    mutableByHooks: false,
+  });
+  addSection(built, {
+    id: 'workspace-persona',
+    source: 'workspace',
+    content: workspacePersona,
+    recipient,
+    cacheable: true,
+    redactionPolicy: 'standard',
+  });
+  addSection(built, {
+    id: 'project-context',
+    source: 'project',
+    content: projectContext,
+    recipient,
+    cacheable: true,
+  });
+  addSection(built, {
+    id: 'tool-policy',
+    source: 'tools',
+    content: toolPolicy,
+    recipient,
+    cacheable: true,
+  });
+  addSection(built, {
+    id: 'provider-contribution',
+    source: 'provider',
+    content: providerContribution,
+    recipient,
+    cacheable: true,
+  });
+  addSection(built, {
+    id: 'channel-context',
+    source: 'channel',
+    content: channelContext,
+    recipient,
+    cacheable: false,
+    redactionPolicy: 'standard',
+  });
+  addSection(built, {
+    id: 'parent-run-context',
+    source: 'runtime',
+    content: parentRunContext,
+    recipient,
+    cacheable: false,
+  });
+  addSection(built, {
+    id: 'child-scope',
+    source: 'runtime',
+    content: childScope,
+    recipient,
+    cacheable: false,
+  });
+  addSection(built, {
+    id: 'runtime-only-context',
+    source: 'runtime',
+    content: runtimeOnlyContext,
+    recipient,
+    cacheable: false,
+    visibility: 'runtime-only',
+  });
+  addSection(built, {
+    id: 'next-turn-context',
+    source: 'runtime',
+    content: nextTurnContext,
+    recipient,
+    cacheable: false,
+  });
+  addSection(built, {
+    id: 'user-task',
+    source: 'user',
+    content: userTask,
+    recipient,
+    cacheable: false,
+    mutableByHooks: false,
+    redactionPolicy: 'standard',
+  });
+  for (const section of sections || []) {
+    const normalized = normalizePromptSection(section);
+    if (normalized && normalized.content) built.push(normalized);
+  }
+  return {
+    version: 1,
+    recipient,
+    sections: built,
+    metadata: { ...metadata },
+    tokenEstimate: built.reduce((sum, section) => sum + section.tokenEstimate, 0),
+  };
+}
+
+function addSection(target, section) {
+  const normalized = normalizePromptSection(section);
+  if (normalized && normalized.content) target.push(normalized);
+}
+
+function renderPromptEnvelope(envelope, { includeMetadata = false, includeRuntimeOnly = true } = {}) {
+  const sections = (envelope?.sections || [])
+    .filter(section => includeRuntimeOnly || section.visibility !== 'runtime-only')
+    .map((section) => {
+      const content = redactPromptContent(section.content, section.redactionPolicy);
+      if (!includeMetadata) return content;
+      const cache = section.cacheable ? 'cacheable' : 'dynamic';
+      return `<!-- prompt-section:${section.id} source:${section.source} ${cache} -->\n${content}`;
+    })
+    .filter(Boolean);
+  return sections.join('\n\n');
+}
+
+function buildChildScopeSection({ writeScope = [], mode = 'build', parentRunId = '', instructions = '' } = {}) {
+  const scopes = Array.isArray(writeScope) ? writeScope : (writeScope ? [writeScope] : []);
+  return createPromptSection({
+    id: 'child-scope',
+    source: 'agent-runtime',
+    cacheable: false,
+    content: [
+      `Child mode: ${mode}`,
+      parentRunId ? `Parent run: ${parentRunId}` : '',
+      scopes.length ? `Write scope: ${scopes.join(', ')}` : '',
+      instructions,
+    ].filter(Boolean).join('\n'),
+  });
+}
+
+function buildReviewerEnvelope({ diff = '', tests = '', context = '', builder = '', instructions = '' } = {}) {
+  return buildPromptEnvelope({
+    recipient: 'reviewer',
+    stablePolicy: 'You are reviewing coding work. Identify correctness, safety, and maintainability issues. Prefer actionable findings over style comments.',
+    parentRunContext: builder ? `Builder: ${builder}` : '',
+    runtimeOnlyContext: context,
+    userTask: [
+      instructions,
+      diff ? `Diff:\n${diff}` : '',
+      tests ? `Tests:\n${tests}` : '',
+    ].filter(Boolean).join('\n\n'),
+  });
+}
+
+function hashString(text) {
+  let hash = 0;
+  const input = String(text || '');
+  for (let i = 0; i < input.length; i += 1) {
+    hash = ((hash << 5) - hash + input.charCodeAt(i)) | 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+module.exports = {
+  buildChildScopeSection,
+  buildPromptEnvelope,
+  buildReviewerEnvelope,
+  createPromptSection,
+  estimateTokens,
+  normalizePromptSection,
+  redactPromptContent,
+  renderPromptEnvelope,
+};

package/template/wall-e/coding/provider-transform.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const { textFromContent, normalizeToolCall } = require('./model-message');
+
+function providerId(provider) {
+  if (!provider) return 'unknown';
+  if (typeof provider === 'string') return provider;
+  return provider.type || provider.provider || provider.id || 'unknown';
+}
+
+function modelId(model, provider) {
+  return model || provider?.model || '';
+}
+
+function isOpenAIStyle(provider) {
+  return ['openai', 'deepseek', 'lmstudio', 'ollama', 'mlx'].includes(providerId(provider));
+}
+
+function isAnthropicStyle(provider) {
+  return ['anthropic', 'claude-cli'].includes(providerId(provider));
+}
+
+function normalizeMessagesForProvider(messages = [], { provider, model } = {}) {
+  const pid = providerId(provider);
+  const out = [];
+  let lastRole = null;
+
+  for (const raw of messages || []) {
+    if (!raw || !raw.role) continue;
+    const msg = { ...raw };
+    if (msg.content == null) msg.content = '';
+
+    // Some OpenAI-compatible providers reject empty text messages.
+    if (isOpenAIStyle(pid) && textFromContent(msg.content).trim() === '' && !hasToolPayload(msg)) {
+      msg.content = '[empty]';
+    }
+
+    // Anthropic rejects consecutive user/tool-result formatting less often than
+    // OpenAI-style providers, but merging same-role plain text keeps history
+    // smaller and deterministic for every provider.
+    if (lastRole === msg.role && canMergeMessages(out[out.length - 1], msg)) {
+      out[out.length - 1].content = mergeContent(out[out.length - 1].content, msg.content);
+      continue;
+    }
+
+    // DeepSeek thinking mode cannot currently continue a tool loop with
+    // reasoning_content carried in prior assistant messages. Strip reasoning
+    // blocks when the history already contains tools; the final visible answer
+    // stays intact.
+    if (pid === 'deepseek' && hasToolHistory(messages) && hasToolPayload(msg) && Array.isArray(msg.content)) {
+      msg.content = msg.content.filter((part) => part?.type !== 'reasoning');
+    }
+
+    out.push(msg);
+    lastRole = msg.role;
+  }
+
+  if (isOpenAIStyle(pid)) {
+    ensureToolResultOrdering(out);
+  }
+
+  return out;
+}
+
+function normalizeToolsForProvider(tools = [], { provider, allowSyntheticNoop = false } = {}) {
+  const pid = providerId(provider);
+  const normalized = [];
+  const seen = new Set();
+  for (const tool of tools || []) {
+    if (!tool || !tool.name || seen.has(tool.name)) continue;
+    seen.add(tool.name);
+    const copy = { ...tool };
+    if (pid === 'anthropic' && copy.parameters && !copy.input_schema) {
+      copy.input_schema = copy.parameters;
+      delete copy.parameters;
+    }
+    if (isOpenAIStyle(pid) && copy.input_schema && !copy.parameters) {
+      copy.parameters = copy.input_schema;
+    }
+    normalized.push(copy);
+  }
+
+  // OpenAI-compatible histories with prior tool calls can error if the next
+  // request has no tools. A harmless no-op tool preserves the tool-capable shape.
+  if (isOpenAIStyle(pid) && normalized.length === 0 && allowSyntheticNoop) {
+    normalized.push({
+      name: 'noop',
+      description: 'No operation. Use only when no tool action is required.',
+      input_schema: { type: 'object', properties: {} },
+      parameters: { type: 'object', properties: {} },
+      execute: async () => ({ ok: true }),
+      _synthetic: true,
+    });
+  }
+  return normalized;
+}
+
+function normalizeResponse(response = {}, { provider, model } = {}) {
+  const toolCalls = (response.toolCalls || []).map(normalizeToolCall);
+  return {
+    content: response.content || '',
+    reasoningContent: response.reasoningContent || '',
+    toolCalls,
+    stopReason: response.stopReason || (toolCalls.length > 0 ? 'tool_use' : 'end_turn'),
+    usage: response.usage || { input: 0, output: 0 },
+    model: response.model || modelId(model, provider),
+    provider: response.provider || providerId(provider),
+    latencyMs: response.latencyMs || 0,
+    raw: response.raw,
+  };
+}
+
+function transformRequest({ provider, model, messages, tools, system, ...rest } = {}) {
+  const normalizedMessages = normalizeMessagesForProvider(messages, { provider, model });
+  return {
+    ...rest,
+    provider: providerId(provider),
+    model,
+    system,
+    messages: normalizedMessages,
+    tools: normalizeToolsForProvider(tools, {
+      provider,
+      model,
+      allowSyntheticNoop: hasToolHistory(normalizedMessages),
+    }),
+  };
+}
+
+function hasToolPayload(msg) {
+  if (Array.isArray(msg?.tool_calls) && msg.tool_calls.length > 0) return true;
+  if (!Array.isArray(msg?.content)) return false;
+  return msg.content.some((part) => part?.type === 'tool_use' || part?.type === 'tool_result');
+}
+
+function hasToolHistory(messages = []) {
+  return messages.some((msg) => msg?.role === 'tool' || hasToolPayload(msg));
+}
+
+function canMergeMessages(left, right) {
+  if (!left || !right) return false;
+  return typeof left.content === 'string' && typeof right.content === 'string';
+}
+
+function mergeContent(left, right) {
+  const a = textFromContent(left);
+  const b = textFromContent(right);
+  if (!a) return b;
+  if (!b) return a;
+  return `${a}\n\n${b}`;
+}
+
+function ensureToolResultOrdering(messages) {
+  // Convert Anthropic-style tool_result user content into OpenAI-style tool
+  // messages only when the provider adapter has not already done it. This is a
+  // conservative transform used by tests and future stream paths; existing
+  // provider adapters may still do richer conversion.
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== 'user' || !Array.isArray(msg.content)) continue;
+    const toolResults = msg.content.filter((part) => part?.type === 'tool_result');
+    if (toolResults.length === 0) continue;
+    const textParts = msg.content.filter((part) => part?.type !== 'tool_result');
+    const replacements = toolResults.map((part) => ({
+      role: 'tool',
+      tool_call_id: part.tool_use_id,
+      content: textFromContent(part.content),
+    }));
+    if (textParts.length > 0) {
+      msg.content = textParts;
+      messages.splice(i + 1, 0, ...replacements);
+      i += replacements.length;
+    } else {
+      messages.splice(i, 1, ...replacements);
+      i += replacements.length - 1;
+    }
+  }
+}
+
+module.exports = {
+  providerId,
+  isOpenAIStyle,
+  isAnthropicStyle,
+  normalizeMessagesForProvider,
+  normalizeToolsForProvider,
+  normalizeResponse,
+  transformRequest,
+  hasToolHistory,
+};

package/template/wall-e/coding/runtime-mode.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const READ_ONLY_TOOL_NAMES = new Set([
+  'read_file',
+  'glob',
+  'grep_files',
+  'list_directory',
+  'lsp_symbols',
+  'lsp_definition',
+  'lsp_references',
+  'lsp_diagnostics',
+  'lsp_hover',
+  'lsp_implementation',
+]);
+
+const COORDINATION_TOOL_NAMES = new Set([
+  'task',
+  'update_todos',
+  'ask_user',
+  'run_shell',
+  'mcp_call',
+  'skill',
+]);
+
+const WRITE_TOOL_NAMES = new Set([
+  'write_file',
+  'edit_file',
+  'apply_patch',
+  'multi_edit',
+]);
+
+const MODES = {
+  agent: {
+    id: 'agent',
+    canEdit: true,
+    canDelegate: false,
+    description: 'Act as one coding agent. Edit and verify directly; do not delegate through task unless explicitly reconfigured.',
+  },
+  master: {
+    id: 'master',
+    canEdit: false,
+    canDelegate: true,
+    description: 'Act as a master of coding agents. Inspect, plan, verify, and delegate implementation to child agents.',
+  },
+  mixed: {
+    id: 'mixed',
+    canEdit: true,
+    canDelegate: true,
+    description: 'Act as both coding agent and master. Edit directly for tight work and delegate separable work to child agents.',
+  },
+};
+
+function resolveRuntimeMode(opts = {}, env = process.env) {
+  const raw = String(
+    opts.runtimeMode
+      || opts.codingRole
+      || opts.agentRole
+      || opts.role
+      || (['agent', 'master', 'mixed'].includes(opts.mode) ? opts.mode : '')
+      || env.WALLE_CODING_RUNTIME_MODE
+      || ''
+  ).trim().toLowerCase();
+  const id = normalizeRuntimeMode(raw || 'mixed');
+  return { ...MODES[id] };
+}
+
+function normalizeRuntimeMode(value) {
+  const v = String(value || '').trim().toLowerCase();
+  if (v === 'delegate' || v === 'delegator' || v === 'orchestrator' || v === 'supervisor') return 'master';
+  if (v === 'builder' || v === 'coder' || v === 'single') return 'agent';
+  if (v === 'hybrid') return 'mixed';
+  if (MODES[v]) return v;
+  return 'mixed';
+}
+
+function filterToolsForRuntimeMode(tools = [], runtimeMode = resolveRuntimeMode()) {
+  const mode = typeof runtimeMode === 'string' ? resolveRuntimeMode({ runtimeMode }) : runtimeMode;
+  const list = Array.isArray(tools) ? tools : [];
+  if (mode.id === 'mixed') return [...list];
+  if (mode.id === 'agent') return list.filter((tool) => tool?.name !== 'task');
+  if (mode.id === 'master') {
+    return list.filter((tool) => {
+      const name = tool?.name || '';
+      if (WRITE_TOOL_NAMES.has(name)) return false;
+      return READ_ONLY_TOOL_NAMES.has(name) || COORDINATION_TOOL_NAMES.has(name);
+    });
+  }
+  return [...list];
+}
+
+function runtimeModeInstructions(runtimeMode = resolveRuntimeMode()) {
+  const mode = typeof runtimeMode === 'string' ? resolveRuntimeMode({ runtimeMode }) : runtimeMode;
+  if (mode.id === 'master') {
+    return [
+      'Runtime role: master of coding agents.',
+      '- Use task for implementation/review/exploration work that can be delegated.',
+      '- You may inspect files and run verification commands, but direct file-editing tools are intentionally unavailable.',
+      '- Split work into the fewest independent child tasks; integrate their results and decide final status.',
+    ].join('\n');
+  }
+  if (mode.id === 'agent') {
+    return [
+      'Runtime role: coding agent.',
+      '- Do the coding work directly in this session.',
+      '- Delegation is unavailable in this role; use local tools to inspect, edit, and verify.',
+    ].join('\n');
+  }
+  return [
+    'Runtime role: mixed coding agent and coordinator.',
+    '- Do compact/local edits directly.',
+    '- Use task to delegate independent, parallelizable, review, or exploration work.',
+    '- Keep the parent session responsible for integration, verification, and final status.',
+  ].join('\n');
+}
+
+function shouldUseStreamProcessor(opts = {}, env = process.env) {
+  if (opts.useStreamProcessor === false) return false;
+  if (String(env.WALLE_CODING_STREAM_PROCESSOR || '').trim() === '0') return false;
+  return true;
+}
+
+module.exports = {
+  READ_ONLY_TOOL_NAMES,
+  COORDINATION_TOOL_NAMES,
+  WRITE_TOOL_NAMES,
+  MODES,
+  normalizeRuntimeMode,
+  resolveRuntimeMode,
+  filterToolsForRuntimeMode,
+  runtimeModeInstructions,
+  shouldUseStreamProcessor,
+};