create-walle 0.9.21 → 0.9.23

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

@@ -0,0 +1,170 @@
+'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;
+
+function callName(call = {}) {
+  return String(call.name || call.tool || '');
+}
+
+function callInput(call = {}) {
+  return call.input || call.args || {};
+}
+
+function inputHashFor(call = {}) {
+  if (call.inputHash) return String(call.inputHash);
+  try {
+    return JSON.stringify(callInput(call)).slice(0, 500);
+  } catch {
+    return String(callInput(call)).slice(0, 500);
+  }
+}
+
+function hasResultEvidence(call = {}) {
+  return Object.prototype.hasOwnProperty.call(call, 'result')
+    || Object.prototype.hasOwnProperty.call(call, 'ok')
+    || Object.prototype.hasOwnProperty.call(call, 'success')
+    || Object.prototype.hasOwnProperty.call(call, 'exitCode')
+    || Boolean(call.error);
+}
+
+function toolResultSucceeded(call = {}) {
+  const result = Object.prototype.hasOwnProperty.call(call, 'result') ? call.result : call;
+  if (call.error === true || typeof call.error === 'string') return false;
+  if (!hasResultEvidence(call)) return false;
+  if (result && typeof result === 'object') {
+    if (result.error) return false;
+    if (result.ok === false || result.success === false) return false;
+    if (typeof result.exitCode === 'number' && result.exitCode !== 0) return false;
+  }
+  if (call.ok === false || call.success === false) return false;
+  if (typeof call.exitCode === 'number' && call.exitCode !== 0) return false;
+  return true;
+}
+
+function isVerificationToolCall(call = {}) {
+  const name = callName(call);
+  const input = String(inputHashFor(call));
+  if (name === 'browser_screenshot' || name === 'browser_smoke_test' || name === 'check_url' || name === 'url_check'
+      || name === 'pdf_info' || name === 'pdf_render_pages' || name === 'make_pdf') return true;
+  if (name === 'run_shell') return VERIFICATION_COMMAND_RE.test(input);
+  return VERIFICATION_TOOL_NAME_RE.test(name);
+}
+
+function isSuccessfulVerificationToolCall(call = {}) {
+  return isVerificationToolCall(call) && toolResultSucceeded(call);
+}
+
+function hasVerificationEvidence(toolCallHistory = []) {
+  return (toolCallHistory || []).some(isSuccessfulVerificationToolCall);
+}
+
+function hasFailedVerificationAttempt(toolCallHistory = []) {
+  return (toolCallHistory || [])
+    .some((call) => isVerificationToolCall(call) && hasResultEvidence(call) && !toolResultSucceeded(call));
+}
+
+function normalizeToolCallEvidence(call = {}, result) {
+  const normalized = {
+    name: callName(call),
+    inputHash: inputHashFor(call),
+  };
+  if (call.id || call.toolCallId) normalized.id = call.id || call.toolCallId;
+  if (Object.prototype.hasOwnProperty.call(call, 'input')) normalized.input = call.input;
+  if (Object.prototype.hasOwnProperty.call(call, 'args')) normalized.args = call.args;
+  if (Object.prototype.hasOwnProperty.call(call, 'error')) normalized.error = call.error;
+  if (arguments.length > 1) normalized.result = result;
+  else if (Object.prototype.hasOwnProperty.call(call, 'result')) normalized.result = call.result;
+  if (hasResultEvidence(normalized)) normalized.ok = toolResultSucceeded(normalized);
+  return normalized;
+}
+
+function hasSuccessfulToolEvidence(toolCallHistory = [], toolName = '') {
+  const expected = String(toolName || '');
+  if (!expected) return false;
+  return (toolCallHistory || []).some((call) => callName(call) === expected && toolResultSucceeded(call));
+}
+
+function collectToolEvidence(toolCallHistory = [], toolName = '') {
+  const expected = String(toolName || '');
+  return (toolCallHistory || [])
+    .filter((call) => callName(call) === expected)
+    .map((call) => ({
+      name: callName(call),
+      ok: toolResultSucceeded(call),
+      result: call.result && typeof call.result === 'object' ? call.result : call,
+    }));
+}
+
+function buildAcceptanceContract({
+  request = '',
+  subtask = {},
+  changedFiles = [],
+  frontend = false,
+  requiresFileChanges = false,
+} = {}) {
+  const explicit = subtask.acceptance && typeof subtask.acceptance === 'object' ? subtask.acceptance : {};
+  const text = `${request}\n${subtask.title || ''}\n${subtask.prompt || ''}`;
+  const frontendTask = frontend || /\b(?:website|web\s?page|frontend|ui|ux|html|css|javascript|responsive|layout|browser)\b/i.test(text);
+  const validators = new Set(Array.isArray(explicit.validators) ? explicit.validators : []);
+  if (frontendTask) {
+    validators.add('frontend.static_contract');
+    validators.add('frontend.screenshot_evidence');
+    validators.add('frontend.browser_runtime');
+  }
+  const writePolicy = explicit.write_policy || explicit.writePolicy || (
+    requiresFileChanges ? 'must-write' : 'may-write'
+  );
+  return {
+    taskKind: explicit.task_kind || explicit.taskKind || (frontendTask ? 'frontend-ui' : 'code'),
+    writePolicy,
+    validators: [...validators],
+    requiresFrontendValidation: frontendTask,
+    changedFiles: [...new Set(changedFiles || [])],
+    recoveryPolicy: explicit.recovery_policy || explicit.recoveryPolicy || 'retry-with-validator-failure',
+  };
+}
+
+function validatorFailure(name, message, detail = {}) {
+  return {
+    name,
+    ok: false,
+    message,
+    detail,
+  };
+}
+
+function validatorPass(name, message, detail = {}) {
+  return {
+    name,
+    ok: true,
+    message,
+    detail,
+  };
+}
+
+function summarizeValidatorFailures(report = {}) {
+  return (report.validators || [])
+    .filter((item) => item && item.ok === false)
+    .map((item) => item.message || item.name)
+    .filter(Boolean);
+}
+
+module.exports = {
+  callName,
+  callInput,
+  inputHashFor,
+  hasResultEvidence,
+  toolResultSucceeded,
+  isVerificationToolCall,
+  isSuccessfulVerificationToolCall,
+  hasVerificationEvidence,
+  hasFailedVerificationAttempt,
+  normalizeToolCallEvidence,
+  hasSuccessfulToolEvidence,
+  collectToolEvidence,
+  buildAcceptanceContract,
+  validatorFailure,
+  validatorPass,
+  summarizeValidatorFailures,
+};

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

@@ -193,7 +193,7 @@ class AcpAdapter {
       cwd,
       model,
       mode,
-      _resumeSessionId: sessionId,
+      runSessionId: sessionId,
     });
   }
 

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

@@ -16,6 +16,9 @@ const READ_ONLY_TOOL_NAMES = new Set([
 const DELEGATE_TOOL_NAMES = new Set([
   ...READ_ONLY_TOOL_NAMES,
   'run_shell',
+  'check_url',
+  'start_static_server',
+  'stop_static_server',
   'update_todos',
   'ask_user',
   'task',

package/template/wall-e/coding/artifact-store.js

@@ -64,6 +64,72 @@ class ArtifactStore {
       metadata: safeJsonValue(metadata),
     };
   }
+
+  storeArtifact({
+    sessionId = '',
+    toolCallId = '',
+    toolName = '',
+    kind = 'artifact',
+    sourcePath = '',
+    path: artifactPath = '',
+    content = null,
+    mimeType = 'application/octet-stream',
+    bytes = null,
+    sha256 = '',
+    metadata = {},
+  } = {}) {
+    const inputPath = sourcePath || artifactPath || '';
+    let buffer = null;
+    let ext = extensionForArtifact(inputPath, mimeType);
+    if (content !== null && content !== undefined) {
+      buffer = Buffer.isBuffer(content) ? content : Buffer.from(String(content));
+    } else if (inputPath && fs.existsSync(inputPath) && fs.statSync(inputPath).isFile()) {
+      buffer = fs.readFileSync(inputPath);
+      if (!mimeType || mimeType === 'application/octet-stream') mimeType = mimeTypeForPath(inputPath, mimeType);
+    } else if (Number.isFinite(Number(bytes)) && sha256) {
+      return {
+        artifactId: `art_${String(sha256).slice(0, 16)}`,
+        kind: String(kind || 'artifact'),
+        sessionId: String(sessionId || ''),
+        toolCallId: String(toolCallId || ''),
+        toolName: String(toolName || ''),
+        path: String(inputPath || ''),
+        bytes: Number(bytes),
+        sha256: String(sha256),
+        mimeType,
+        createdAt: this.now(),
+        metadata: safeJsonValue(metadata),
+      };
+    } else {
+      throw new Error('storeArtifact requires content, an existing sourcePath/path, or bytes+sha256 metadata');
+    }
+
+    const realBytes = buffer.length;
+    const realSha = sha256 || crypto.createHash('sha256').update(buffer).digest('hex');
+    const artifactId = `art_${realSha.slice(0, 16)}`;
+    const dir = path.join(this.artifactsDir, safeName(sessionId || 'session'));
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, `${safeName(toolCallId || toolName || kind || artifactId)}-${realSha.slice(0, 12)}.${ext}`);
+    if (inputPath && path.resolve(inputPath) === path.resolve(filePath)) {
+      // Already in the artifact store.
+    } else {
+      fs.writeFileSync(filePath, buffer);
+    }
+    return {
+      artifactId,
+      kind: String(kind || 'artifact'),
+      sessionId: String(sessionId || ''),
+      toolCallId: String(toolCallId || ''),
+      toolName: String(toolName || ''),
+      path: filePath,
+      originalPath: inputPath ? String(inputPath) : '',
+      bytes: realBytes,
+      sha256: realSha,
+      mimeType,
+      createdAt: this.now(),
+      metadata: safeJsonValue(metadata),
+    };
+  }
 }
 
 function defaultArtifactsDir(env = process.env) {
@@ -109,12 +175,16 @@ function publicArtifactRef(artifact) {
   return {
     artifactId: artifact.artifactId,
     kind: artifact.kind,
+    sessionId: artifact.sessionId,
     path: artifact.path,
+    originalPath: artifact.originalPath,
     bytes: artifact.bytes,
     sha256: artifact.sha256,
     mimeType: artifact.mimeType,
     toolCallId: artifact.toolCallId,
     toolName: artifact.toolName,
+    createdAt: artifact.createdAt,
+    metadata: safeJsonValue(artifact.metadata || {}),
   };
 }
 
@@ -139,6 +209,29 @@ function safeName(value) {
     .slice(0, 80) || 'artifact';
 }
 
+function extensionForArtifact(filePath, mimeType) {
+  const ext = path.extname(String(filePath || '')).replace(/^\./, '').toLowerCase();
+  if (ext) return safeName(ext).slice(0, 12) || 'bin';
+  if (/pdf/i.test(mimeType)) return 'pdf';
+  if (/png/i.test(mimeType)) return 'png';
+  if (/jpe?g/i.test(mimeType)) return 'jpg';
+  if (/html/i.test(mimeType)) return 'html';
+  if (/json/i.test(mimeType)) return 'json';
+  if (/text/i.test(mimeType)) return 'txt';
+  return 'bin';
+}
+
+function mimeTypeForPath(filePath, fallback) {
+  const ext = path.extname(String(filePath || '')).toLowerCase();
+  if (ext === '.pdf') return 'application/pdf';
+  if (ext === '.png') return 'image/png';
+  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg';
+  if (ext === '.html' || ext === '.htm') return 'text/html';
+  if (ext === '.json') return 'application/json';
+  if (ext === '.txt' || ext === '.md') return 'text/plain';
+  return fallback || 'application/octet-stream';
+}
+
 function safeJsonValue(value) {
   try {
     return JSON.parse(JSON.stringify(value));

package/template/wall-e/coding/capability-router.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const FRONTEND_EXT_RE = /\.(html?|css|scss|sass|less|jsx|tsx|vue|svelte|astro)$/i;
+const PDF_EXT_RE = /\.pdf$/i;
+
+const FRONTEND_KEYWORDS_RE = new RegExp([
+  '\\b(',
+  'website|webpage|web\\s?page|landing\\s?page|homepage|portfolio\\s?(site|website|page)?',
+  '|hero\\s?(section|banner|image)|nav(igation)?\\s?bar|gallery|lightbox|carousel',
+  '|UI|UX|user\\s?interface|user\\s?experience|front[\\s-]?end|frontend',
+  '|stylesheet|stylesheets|responsive\\s?(design|layout)|design\\s?system',
+  ')\\b',
+].join(''), 'i');
+const FRONTEND_NEGATIVE_RE = /\b(schema|algorithm|protocol|api|grpc|sql|migration|pipeline|backend\s?service|microservice)\b/i;
+
+const PDF_KEYWORDS_RE = /\b(?:pdf|portable document|document export|print(?:able)? document|export as pdf|make (?:a )?pdf|generate (?:a )?pdf|render (?:a )?pdf)\b/i;
+const PDF_GENERATION_RE = /\b(?:make|generate|create|export|render|design|format|style|polish|typeset|print)\b[\s\S]{0,80}\bpdf\b|\bpdf\b[\s\S]{0,80}\b(?:make|generate|create|export|render|design|format|style|polish|typeset|print)\b/i;
+const PDF_INGESTION_RE = /\b(?:read|inspect|summari[sz]e|analy[sz]e|extract|review)\b[\s\S]{0,80}\bpdf\b|\bpdf\b[\s\S]{0,80}\b(?:read|inspect|summari[sz]e|analy[sz]e|extract|review)\b/i;
+
+const MANIFESTS = Object.freeze({
+  frontend_design: Object.freeze({
+    id: 'frontend_design',
+    label: 'Web/UI visual artifact work',
+    promptSections: ['frontend-design', 'browser-verification'],
+    tools: ['start_static_server', 'check_url', 'browser_screenshot'],
+    requiredArtifacts: ['screenshot.desktop', 'screenshot.mobile'],
+    completionGate: 'visual_artifact_verified',
+  }),
+  pdf_document: Object.freeze({
+    id: 'pdf_document',
+    label: 'PDF document generation and design',
+    promptSections: ['document-design', 'pdf-generation', 'pdf-verification'],
+    tools: ['make_pdf', 'pdf_info', 'pdf_render_pages', 'pdf_read_pages'],
+    requiredArtifacts: ['pdf.file', 'pdf.page_preview'],
+    completionGate: 'document_artifact_verified',
+  }),
+  pdf_ingestion: Object.freeze({
+    id: 'pdf_ingestion',
+    label: 'PDF ingestion and page inspection',
+    promptSections: ['pdf-ingestion'],
+    tools: ['pdf_info', 'pdf_read_pages', 'pdf_render_pages'],
+    requiredArtifacts: ['pdf.file'],
+    completionGate: 'source_document_verified',
+  }),
+});
+
+function routeArtifactCapabilities({ prompt = '', taskFileHints = [], projectInfo = null } = {}) {
+  const hints = Array.isArray(taskFileHints) ? taskFileHints.map(String) : [];
+  const text = String(prompt || '');
+  const capabilities = [];
+
+  if (detectFrontend(text, hints, projectInfo)) capabilities.push(MANIFESTS.frontend_design);
+
+  if (detectPdf(text, hints)) {
+    const mode = detectPdfMode(text, hints);
+    capabilities.push(mode === 'ingestion' ? MANIFESTS.pdf_ingestion : MANIFESTS.pdf_document);
+  }
+
+  return dedupeCapabilities(capabilities);
+}
+
+function detectFrontend(text, hints, projectInfo) {
+  if (hints.some((hint) => FRONTEND_EXT_RE.test(hint))) return true;
+  if (projectInfo?.framework && /\b(?:react|vue|svelte|astro|next|vite)\b/i.test(projectInfo.framework)) {
+    if (FRONTEND_KEYWORDS_RE.test(text)) return true;
+  }
+  if (!FRONTEND_KEYWORDS_RE.test(text)) return false;
+  if (FRONTEND_NEGATIVE_RE.test(text) && !hints.some((hint) => FRONTEND_EXT_RE.test(hint))) return false;
+  return true;
+}
+
+function detectPdf(text, hints) {
+  return hints.some((hint) => PDF_EXT_RE.test(hint)) || PDF_KEYWORDS_RE.test(text);
+}
+
+function detectPdfMode(text, hints) {
+  if (PDF_GENERATION_RE.test(text)) return 'generation';
+  if (hints.some((hint) => PDF_EXT_RE.test(hint)) || PDF_INGESTION_RE.test(text)) return 'ingestion';
+  return 'generation';
+}
+
+function buildArtifactCapabilityContext(capabilities = []) {
+  const routed = dedupeCapabilities(capabilities);
+  if (!routed.length) return '';
+  const lines = ['# Artifact Capability Routes'];
+  lines.push('This task was routed to typed artifact capabilities. Treat their tools and evidence gates as part of the completion contract, not optional suggestions.');
+  for (const capability of routed) {
+    lines.push('');
+    lines.push(`## ${capability.label}`);
+    lines.push(`- id: \`${capability.id}\``);
+    lines.push(`- use tools: ${capability.tools.map((tool) => `\`${tool}\``).join(', ')}`);
+    lines.push(`- required evidence before claiming success: ${capability.requiredArtifacts.map((item) => `\`${item}\``).join(', ')}`);
+    lines.push(`- completion gate: \`${capability.completionGate}\``);
+  }
+  lines.push('');
+  lines.push('For generated visual/document artifacts, create or verify the artifact with tools, then inspect the rendered output or report the exact tool-backed blocker.');
+  return lines.join('\n');
+}
+
+function dedupeCapabilities(capabilities = []) {
+  const seen = new Set();
+  const out = [];
+  for (const capability of capabilities || []) {
+    if (!capability?.id || seen.has(capability.id)) continue;
+    seen.add(capability.id);
+    out.push({ ...capability });
+  }
+  return out;
+}
+
+function hasCapability(capabilities, id) {
+  return (capabilities || []).some((capability) => capability?.id === id);
+}
+
+module.exports = {
+  MANIFESTS,
+  routeArtifactCapabilities,
+  buildArtifactCapabilityContext,
+  hasCapability,
+};