create-walle 0.9.25 → 0.9.26

package/template/wall-e/coding/acceptance-contract.js

@@ -1,7 +1,32 @@
 'use strict';
 
 const VERIFICATION_TOOL_NAME_RE = /(?:test|verify|screenshot|smoke|diagnostic|lint|build|check_url|url_check|pdf_info|pdf_render_pages|make_pdf)/i;
-const VERIFICATION_COMMAND_RE = /\b(?:test|spec|lint|build|typecheck|tsc|pytest|jest|mocha|vitest|playwright|node\s+--(?:test|check)|npm\s+(?:test|run)|pnpm\s+(?:test|run)|yarn\s+(?:test|run)|git\s+diff\s+--check|curl\s+.*(?:localhost|127\.0\.0\.1)|check_url|pdfinfo|pdftoppm|pdftotext)\b/i;
+// A run_shell command counts as verification ONLY when it invokes a real
+// test/lint/build runner. The old pattern matched the bare words
+// test|spec|lint|build|typecheck anywhere in the command JSON, so the
+// shell-builtin existence probe `test -d node_modules && echo ...` (and any
+// path containing "test") classified as a SUCCESSFUL verification — which both
+// over-credited acceptance evidence and tripped the stream loop's
+// verified-after-edit early exit, ending coding turns with no final answer
+// (session c3f3af97: reply stopped at "...Let me check package.json").
+const VERIFICATION_COMMAND_RE = new RegExp([
+  // package-manager script runners (`npm test`, `npm run build`, `bun run lint`, …)
+  String.raw`\b(?:npm|pnpm|yarn|bun)\s+(?:test\b|run\s+\S+)`,
+  // direct test/lint/type runners
+  String.raw`\b(?:pytest|jest|mocha|vitest|playwright|tsc|eslint|stylelint|ruff|mypy|flake8|rspec|phpunit)\b`,
+  String.raw`\bnode\s+--(?:test|check)\b`,
+  // language toolchains
+  String.raw`\b(?:cargo|go)\s+(?:test|build|check|vet)\b`,
+  String.raw`\bmake\s+(?:test|check|lint|build)\b`,
+  String.raw`\bmvn\s+(?:test|verify|package)\b`,
+  String.raw`\bgradlew?\s+(?:test|build|check)\b`,
+  // frontend build/lint CLIs
+  String.raw`\b(?:vue-cli-service|vite|webpack|rollup|esbuild|next|nuxt|ng)\s+(?:test|lint|build|typecheck|e2e)\b`,
+  // misc verification probes
+  String.raw`\bgit\s+diff\s+--check\b`,
+  String.raw`\bcurl\s+[^|;&]*(?:localhost|127\.0\.0\.1)`,
+  String.raw`\b(?:check_url|pdfinfo|pdftoppm|pdftotext)\b`,
+].join('|'), 'i');
 
 function callName(call = {}) {
   return String(call.name || call.tool || '');

package/template/wall-e/coding/action-memory-policy.js

@@ -0,0 +1,353 @@
+'use strict';
+
+const DEFAULT_MIN_SCORE = 120;
+const DEFAULT_MIN_MARGIN = 15;
+const DEFAULT_LIMIT = 8;
+const MODES = new Set(['off', 'audit', 'assist', 'apply']);
+const SELECTORS = new Set(['store', 'replay', 'auto']);
+const REPLAY_SELECTOR_TOOLS = new Set(['run_shell', 'apply_patch', 'edit_file', 'write_file']);
+
+class ActionMemoryPolicy {
+  constructor({
+    store = null,
+    mode = 'audit',
+    selector = 'store',
+    minScore = DEFAULT_MIN_SCORE,
+    minMargin = DEFAULT_MIN_MARGIN,
+    limit = DEFAULT_LIMIT,
+    maxCandidates = DEFAULT_LIMIT,
+    memoryLimit = 200,
+    logger = console,
+  } = {}) {
+    this.store = store;
+    this.mode = normalizeMode(mode);
+    this.selector = normalizeSelector(selector);
+    this.minScore = finiteNumber(minScore, DEFAULT_MIN_SCORE);
+    this.minMargin = finiteNumber(minMargin, DEFAULT_MIN_MARGIN);
+    this.limit = Math.max(1, Math.trunc(finiteNumber(limit, DEFAULT_LIMIT)));
+    this.maxCandidates = Math.max(1, Math.trunc(finiteNumber(maxCandidates, this.limit)));
+    this.memoryLimit = Math.max(1, Math.trunc(finiteNumber(memoryLimit, 200)));
+    this.logger = logger;
+  }
+
+  async evaluateToolCall({
+    call = {},
+    context = {},
+    model = {},
+    sessionId = '',
+    prompt = '',
+  } = {}) {
+    const clonedCall = cloneToolCall(call);
+    const toolName = toolNameFromCall(clonedCall);
+    const prediction = { name: toolName, input: clonedCall.input || {} };
+    const baseDecision = {
+      mode: this.mode,
+      selector: this.selector,
+      action: 'skip',
+      accepted: false,
+      selectedEntryId: '',
+      selectedScore: null,
+      candidateCount: 0,
+      reasons: [],
+      reason: '',
+    };
+
+    if (!this.store || this.mode === 'off' || !toolName) {
+      return { call: clonedCall, decision: { ...baseDecision, reason: 'disabled_or_unavailable' }, candidates: [] };
+    }
+
+    const selected = await this.selectCandidate({ context, prediction, toolName });
+    const selection = selected.selection || null;
+    const candidates = selected.candidates || [];
+    const selectedInput = safeObject(selection?.input);
+    const canUseSelection = Boolean(selection?.accepted && selection?.tool === toolName && Object.keys(selectedInput).length);
+    const decision = {
+      ...baseDecision,
+      selectedEntryId: selection?.id || '',
+      selectedScore: Number.isFinite(Number(selection?.score)) ? Number(selection.score) : null,
+      candidateCount: candidates.length,
+      reasons: Array.isArray(selection?.reasons) ? selection.reasons.slice() : [],
+      reason: canUseSelection ? 'candidate_selected' : 'no_accepted_candidate',
+    };
+
+    let preparedCall = clonedCall;
+    if (this.mode === 'audit') {
+      decision.action = 'observe';
+      decision.accepted = false;
+      decision.reason = selection?.id ? 'audit_only' : 'no_candidate';
+    } else if (canUseSelection && this.mode === 'assist') {
+      const mergedInput = fillMissingFields(clonedCall.input || {}, selectedInput);
+      preparedCall = { ...clonedCall, input: mergedInput };
+      decision.action = 'assist';
+      decision.accepted = true;
+    } else if (canUseSelection && this.mode === 'apply') {
+      preparedCall = { ...clonedCall, input: cloneJson(selectedInput) };
+      decision.action = 'apply';
+      decision.accepted = true;
+    }
+
+    this.recordAudit({
+      mode: this.mode,
+      context,
+      prediction,
+      selected: selection ? { ...selection, accepted: decision.accepted } : null,
+      candidates,
+      reason: decision.reason,
+      model,
+      sessionId,
+      prompt,
+    });
+
+    return { call: preparedCall, decision, candidates };
+  }
+
+  async selectCandidate({ context, prediction, toolName }) {
+    if ((this.selector === 'replay' || this.selector === 'auto') && REPLAY_SELECTOR_TOOLS.has(toolName)) {
+      const replaySelected = this.selectReplayCandidate({ context, prediction, toolName });
+      if (replaySelected.selection || replaySelected.candidates?.length || this.selector === 'replay') {
+        return replaySelected;
+      }
+    }
+    if (!this.store?.selectActionMemoryCandidate) return { selection: null, candidates: [] };
+    return this.store.selectActionMemoryCandidate({
+      context,
+      prediction,
+      toolName,
+      minScore: this.minScore,
+      minMargin: this.minMargin,
+      limit: this.limit,
+    }) || { selection: null, candidates: [] };
+  }
+
+  selectReplayCandidate({ context = {}, prediction = null, toolName = '' } = {}) {
+    if (!this.store?.searchActionMemoryCandidates) return { selection: null, candidates: [] };
+    const example = replayExampleFromRuntimeContext(context, { toolName, prediction });
+    try {
+      if (toolName === 'run_shell') {
+        const {
+          applyRunShellCommandSelection,
+        } = require('../training/run-shell-command-selector');
+        const selected = applyRunShellCommandSelection(example, prediction, {
+          actionMemoryStore: this.store,
+          maxCandidates: this.maxCandidates,
+          memoryLimit: this.memoryLimit,
+        });
+        return normalizeRunShellPolicySelection(selected, prediction);
+      }
+      const {
+        applyTrajectoryActionSelection,
+      } = require('../training/trajectory-action-selector');
+      return applyTrajectoryActionSelection(example, prediction, {
+        actionMemoryStore: this.store,
+        maxCandidates: this.maxCandidates,
+        memoryLimit: this.memoryLimit,
+        minScore: this.minScore,
+      });
+    } catch (err) {
+      this.logger?.warn?.(`[action-memory] replay selector failed: ${err.message}`);
+      return { selection: null, candidates: [] };
+    }
+  }
+
+  recordAudit(row) {
+    if (!this.store?.recordSelectionAudit) return null;
+    try {
+      return this.store.recordSelectionAudit(row);
+    } catch (err) {
+      this.logger?.warn?.(`[action-memory] failed to record selection audit: ${err.message}`);
+      return null;
+    }
+  }
+}
+
+async function executeToolCallWithActionMemoryPolicy({
+  call = {},
+  context = {},
+  model = {},
+  sessionId = '',
+  prompt = '',
+  policy = null,
+  execute,
+} = {}) {
+  if (typeof execute !== 'function') throw new Error('executeToolCallWithActionMemoryPolicy requires execute');
+  const evaluated = policy?.evaluateToolCall
+    ? await policy.evaluateToolCall({ call, context, model, sessionId, prompt })
+    : { call: cloneToolCall(call), decision: { mode: 'off', action: 'skip', accepted: false }, candidates: [] };
+  const execution = await execute(evaluated.call, evaluated.decision);
+  if (execution && typeof execution === 'object') {
+    execution.actionMemory = {
+      decision: evaluated.decision,
+      candidateCount: evaluated.candidates.length,
+    };
+  }
+  return execution;
+}
+
+function cloneToolCall(call = {}) {
+  return {
+    ...call,
+    input: cloneJson(call.input || {}),
+  };
+}
+
+function toolNameFromCall(call = {}) {
+  return String(call.name || call.tool || '').trim();
+}
+
+function fillMissingFields(originalInput = {}, memoryInput = {}) {
+  const merged = cloneJson(originalInput || {});
+  for (const [key, value] of Object.entries(memoryInput || {})) {
+    if (merged[key] === undefined || merged[key] === null || merged[key] === '') {
+      merged[key] = cloneJson(value);
+    }
+  }
+  return merged;
+}
+
+function cloneJson(value) {
+  try {
+    return JSON.parse(JSON.stringify(value ?? null));
+  } catch {
+    return value;
+  }
+}
+
+function safeObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function finiteNumber(value, fallback) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function normalizeMode(mode) {
+  const value = String(mode || 'audit').trim().toLowerCase();
+  return MODES.has(value) ? value : 'audit';
+}
+
+function normalizeSelector(selector) {
+  const value = String(selector || 'store').trim().toLowerCase();
+  return SELECTORS.has(value) ? value : 'store';
+}
+
+function normalizeRunShellPolicySelection(selected = {}, prediction = null) {
+  const candidates = (selected.candidates || []).map((candidate) => ({
+    ...candidate,
+    tool: 'run_shell',
+    input: { command: candidate.command },
+    id: candidate.memoryEntryId || '',
+    candidateId: candidate.id || '',
+    reasons: [
+      candidate.reason,
+      candidate.source,
+      ...(candidate.memoryReasons || []),
+    ].filter(Boolean),
+  }));
+  const selection = selected.selection || null;
+  if (!selection?.command) return { selection: null, candidates };
+  const matched = candidates.find((candidate) => candidate.command === selection.command) || {};
+  return {
+    selection: {
+      id: selection.memoryEntryId || matched.id || '',
+      candidateId: selection.id || matched.candidateId || '',
+      tool: 'run_shell',
+      input: {
+        ...(prediction?.input || {}),
+        command: selection.command,
+      },
+      score: finiteNumber(selection.score ?? matched.score, null),
+      reasons: [
+        selection.reason,
+        selection.source,
+        ...(selection.memoryReasons || matched.memoryReasons || []),
+      ].filter(Boolean),
+      sourceKind: selection.source,
+      sourceRowId: selection.sourceRowId || matched.sourceRowId,
+      sourceSessionId: selection.sourceSessionId || matched.sourceSessionId,
+      sourceToolCallId: selection.sourceToolCallId || matched.sourceToolCallId,
+      targetHint: selection.command,
+      accepted: true,
+    },
+    candidates,
+  };
+}
+
+function replayExampleFromRuntimeContext(context = {}, { toolName = '', prediction = null } = {}) {
+  const labels = {
+    workflow_family_id: context.familyId || context.workflowFamilyId || context.workflow_family_id || null,
+    workflow_repo: context.repoKey || context.repo || context.workflowRepo || context.workflow_repo || null,
+    workflow_intent: context.intent || context.workflowIntent || context.workflow_intent || null,
+    tool_name: toolName || prediction?.name || null,
+  };
+  const verificationCommands = normalizeCommandList(
+    context.verificationCommands || context.verification_commands || context.rememberedTaskCommands
+  );
+  if (verificationCommands.length) labels.verification_commands = verificationCommands;
+
+  const stateLines = [
+    ['tool sequence', context.sequence || context.stateSequence || context.toolSequence],
+    ['last tool', context.lastTool || context.last_tool],
+    ['recent shell commands', formatRecentShellCommands(context.recentShellCommands || context.recent_shell_commands)],
+    ['known failures', formatListValue(context.knownFailures || context.known_failures)],
+    ['verification status', context.verificationStatus || context.verification_status],
+    ['remembered task commands', formatCommandList(context.rememberedTaskCommands || context.remembered_task_commands)],
+    ['remembered workflow commands', formatCommandList(context.rememberedWorkflowCommands || context.remembered_workflow_commands)],
+  ]
+    .filter(([, value]) => value)
+    .map(([label, value]) => `- ${label}: ${value}`);
+
+  const taskText = String(context.taskText || context.task || context.userTask || context.taskPreview || '').trim();
+  const content = [
+    `Task:\n${taskText}`,
+    '',
+    'Current Wall-E state:',
+    ...stateLines,
+  ].join('\n').trim();
+
+  return {
+    labels,
+    messages: [{ role: 'user', content }],
+  };
+}
+
+function normalizeCommandList(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map((item) => String(item || '').trim()).filter(Boolean);
+  return String(value).split(/\n|,\s+(?=(?:cd |git |npm |node |pnpm |yarn |uv |rg |sed |python|pytest|cargo|go |make ))/i)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function formatCommandList(value) {
+  return normalizeCommandList(value).join(', ');
+}
+
+function formatRecentShellCommands(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value.trim();
+  if (!Array.isArray(value)) return '';
+  return value.map((item) => {
+    if (typeof item === 'string') return item.trim();
+    const command = item.command || item.input?.command || item.args?.command || '';
+    if (!command) return '';
+    const status = item.status || (item.ok === false ? 'tool_error' : 'tool_result');
+    return `${status}: ${command}`;
+  }).filter(Boolean).join(', ');
+}
+
+function formatListValue(value) {
+  if (!value) return '';
+  if (Array.isArray(value)) return value.map((item) => String(item || '').trim()).filter(Boolean).join(', ');
+  return String(value || '').trim();
+}
+
+module.exports = {
+  ActionMemoryPolicy,
+  DEFAULT_LIMIT,
+  DEFAULT_MIN_MARGIN,
+  DEFAULT_MIN_SCORE,
+  executeToolCallWithActionMemoryPolicy,
+  fillMissingFields,
+  replayExampleFromRuntimeContext,
+};