@evomap/evolver 1.89.19 → 1.89.20

package/src/gep/skill2recipes.js

@@ -0,0 +1,511 @@
+'use strict';
+
+// skill2recipes.js -- Compose a published GEP *Recipe* out of one or more
+// locally-invoked Skills.
+//
+// This is the layer ABOVE skill2gep.js:
+//   skill2gep.js     : 1 SKILL.md (+ run)         -> Gene + Capsule (assets)
+//   skill2recipes.js : N SKILL.md hydrolyzed+verified -> ordered Recipe on Hub
+//
+// Pipeline per step (the "水解 -> 验证 -> 资产" half is delegated to skill2gep):
+//   1. 水解 (hydrolyze): parseSkillMd + synthesizeGene  -> validated draft Gene
+//   2. 验证 (verify):   policyCheck.runValidations(gene) actually EXECUTES the
+//                       gene's validation commands in repoRoot and produces a
+//                       real execution trace. assembleCapsule + detectForgery
+//                       then refuse to mint a Capsule without that evidence.
+//   3. 资产 (assets):   buildPublishBundle stamps the authoritative asset_id
+//                       (computeAssetId) on Gene+Capsule and POSTs them to
+//                       /a2a/publish; the Gene's asset_id is what the recipe
+//                       step will reference.
+//
+// Why Gene+Capsule is mandatory, not optional:
+//   The Hub's /a2a/publish ONLY accepts a Gene+Capsule bundle (validateBundle
+//   rejects assets.length < 2), and that bundle path is the only thing that
+//   writes an Asset row. recipeService.validateStepAssets requires every
+//   step.asset_id to already exist as an Asset of the matching type. So a Gene
+//   can only become a recipe-referenceable asset_id if it was published next to
+//   a Capsule -- which, per the forgery guard, requires real execution
+//   evidence. "Prefer Gene, add Capsule only with evidence" therefore resolves
+//   to: every step IS verified, the Capsule is the evidence, and the recipe
+//   step points at the Gene. Skills with no runnable validation cannot enter a
+//   recipe -- by design, not by accident.
+//
+// Compose & upload:
+//   4. POST /a2a/recipe        with steps=[{asset_id, asset_type:'Gene', ...}]
+//   5. POST /a2a/recipe/:id/publish  -> appears at evomap.ai/market?tab=recipes
+//
+// Recipe is a plain REST resource on the Hub (NOT an A2A message_type), so we
+// talk to it with a direct fetch + buildHubHeaders (Bearer node_secret), unlike
+// publish/fetch which ride a2a.httpTransportSend.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const paths = require('./paths');
+const assetStore = require('./assetStore');
+const policyCheck = require('./policyCheck');
+const skill2gep = require('./skill2gep');
+const a2a = require('./a2aProtocol');
+const { computeAssetId } = require('./contentHash');
+
+const LOG_FILE = 'skill2recipes_log.jsonl';
+const STATE_FILE = 'skill2recipes_state.json';
+const VALIDATION_TIMEOUT_MS = 180000;
+const RECIPE_TIMEOUT_MS = 20000;
+const MAX_STEPS = 20; // mirrors recipeService.MAX_STEPS_PER_RECIPE
+
+function ensureDir(p) { if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true }); }
+
+function readJsonSafe(p, fallback) {
+  try {
+    if (!fs.existsSync(p)) return fallback;
+    const raw = fs.readFileSync(p, 'utf8');
+    if (!raw.trim()) return fallback;
+    return JSON.parse(raw);
+  } catch (_) { return fallback; }
+}
+
+function appendJsonl(p, obj) {
+  ensureDir(path.dirname(p));
+  fs.appendFileSync(p, JSON.stringify(obj) + '\n', 'utf8');
+}
+
+function logPath() { return path.join(paths.getMemoryDir(), LOG_FILE); }
+function statePath() { return path.join(paths.getMemoryDir(), STATE_FILE); }
+
+function readState() { return readJsonSafe(statePath(), { recipes: {} }); }
+function writeState(s) {
+  ensureDir(path.dirname(statePath()));
+  const tmp = statePath() + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(s, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmp, statePath());
+}
+
+function shortHash(s) {
+  return crypto.createHash('sha256').update(String(s || '')).digest('hex').slice(0, 12);
+}
+
+// ---------------------------------------------------------------------------
+// Normalize a manifest into a list of steps. Accepts either:
+//   { title, description, steps: [{ skill_path, optional?, condition?, ... }] }
+//   { title, steps: ["./a", "./b"] }                       (bare paths)
+// or a bare array of paths (CLI shorthand, title supplied separately).
+// ---------------------------------------------------------------------------
+function normalizeManifest(manifest, opts) {
+  opts = opts || {};
+  let m = manifest;
+  if (Array.isArray(manifest)) m = { steps: manifest };
+  m = m || {};
+
+  const rawSteps = Array.isArray(m.steps) ? m.steps
+    : Array.isArray(m.skills) ? m.skills
+      : [];
+  const steps = rawSteps.map((s, i) => {
+    const step = (typeof s === 'string') ? { skill_path: s } : (s || {});
+    const skillPath = step.skill_path || step.skillPath || step.path;
+    return {
+      skill_path: skillPath,
+      skill_name: step.skill_name || step.skillName || null,
+      platform: step.platform || null,
+      position: Number.isInteger(step.position) ? step.position : i,
+      optional: Boolean(step.optional),
+      condition: step.condition != null ? String(step.condition) : null,
+      parameters: step.parameters || null,
+    };
+  });
+
+  return {
+    title: opts.title || m.title || null,
+    description: opts.description || m.description || '',
+    price_per_execution: opts.pricePerExecution != null ? opts.pricePerExecution
+      : (m.price_per_execution != null ? m.price_per_execution : undefined),
+    currency: m.currency || undefined,
+    max_concurrent: m.max_concurrent != null ? m.max_concurrent : undefined,
+    input_schema: m.input_schema || null,
+    output_schema: m.output_schema || null,
+    steps: steps,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Hydrolyze + verify a single skill into a published Gene asset.
+//
+// Returns { ok, gene, capsule, asset_id, asset_type, diagnostic }.
+// asset_id is the *Gene* asset_id (sha256:...) once the bundle has been built;
+// the recipe step references the Gene, with the Capsule riding along as the
+// execution evidence that let it through the forgery guard.
+// ---------------------------------------------------------------------------
+function hydrolyzeAndVerify(step, opts) {
+  opts = opts || {};
+  const skillPath = step.skill_path;
+  if (!skillPath || !fs.existsSync(skillPath)) {
+    return { ok: false, diagnostic: { reason: 'skill_path_missing', skill_path: skillPath } };
+  }
+
+  let skillMdPath = skillPath;
+  try {
+    if (fs.statSync(skillPath).isDirectory()) skillMdPath = path.join(skillPath, 'SKILL.md');
+  } catch (_) { return { ok: false, diagnostic: { reason: 'skill_path_unreadable', skill_path: skillPath } }; }
+  if (!fs.existsSync(skillMdPath)) {
+    return { ok: false, diagnostic: { reason: 'skill_md_missing', tried: skillMdPath } };
+  }
+
+  let skillMd;
+  try { skillMd = fs.readFileSync(skillMdPath, 'utf8'); }
+  catch (err) { return { ok: false, diagnostic: { reason: 'skill_md_read_failed', error: errMsg(err) } }; }
+  const skillHash = shortHash(skillMd);
+
+  // -- 水解: parse + synthesize a validated Gene. strict=true here, because a
+  // recipe step with a fallback "node --version" validation would verify
+  // nothing -- we want every step to carry a real, runnable check.
+  const parsed = skill2gep.parseSkillMd(skillMd);
+  const geneRes = skill2gep.synthesizeGene(parsed, {}, {
+    skillName: step.skill_name || parsed.name,
+    platform: step.platform || null,
+    skillHash: skillHash,
+    strict: opts.strict !== false,
+  });
+  if (!geneRes.valid) {
+    return { ok: false, diagnostic: { reason: 'gene_validation_failed', errors: geneRes.errors } };
+  }
+  const gene = geneRes.gene;
+
+  // -- 验证: actually run the gene's validation commands in repoRoot. This is
+  // what produces the real execution trace that the Capsule needs.
+  const repoRoot = opts.repoRoot || paths.getRepoRoot();
+  const valRes = policyCheck.runValidations(gene, { repoRoot, timeoutMs: VALIDATION_TIMEOUT_MS });
+
+  const trace = (valRes.results || []).map((r, i) => ({
+    step: i + 1,
+    cmd: r.cmd,
+    exit: r.ok ? 0 : 1,
+    stdout_tail: String(r.out || r.err || '').slice(0, 300),
+  }));
+  const allPassed = Boolean(valRes.ok);
+  const execution = {
+    status: allPassed ? 'success' : 'failed',
+    score: allPassed ? 0.85 : 0.2,
+    started_at: new Date().toISOString(),
+    trace: trace,
+    // Blast radius for a verification-only run is the commands we executed;
+    // the forgery guard only needs *some* evidence (non-zero files/lines or a
+    // recorded exit), so we attribute one "file touched" per command run plus
+    // the gene's declared validation surface.
+    blast_radius: { files: Math.max(1, trace.length), lines: trace.length },
+    trigger: (gene.signals_match || []).slice(0, 6),
+    signals: gene.signals_match || [],
+    summary: 'Verified skill "' + (parsed.name || gene.id) + '": '
+      + trace.filter((t) => t.exit === 0).length + '/' + trace.length + ' validation command(s) passed.',
+    success_reason: allPassed ? 'All declared validation commands exited 0 in repoRoot.' : null,
+  };
+
+  // A step only earns a place in the recipe if its validation actually
+  // passed. Whether a failure aborts the recipe or is silently skipped is the
+  // caller's decision (based on step.optional) -- here we just report it
+  // unverified. (Without this, assembleCapsule would happily mint a
+  // failed-outcome Capsule, since the failing command is still "covered" by
+  // the trace, and the dud step would slip into the genome.)
+  if (!allPassed) {
+    return {
+      ok: false,
+      gene: gene,
+      diagnostic: { reason: 'validation_failed', failed: trace.filter((t) => t.exit !== 0).map((t) => t.cmd) },
+    };
+  }
+
+  // Forgery guard + capsule assembly (delegated to skill2gep's hardened logic).
+  const forgery = skill2gep.detectForgery(execution);
+  if (forgery) {
+    return { ok: false, gene: gene, diagnostic: { reason: 'capsule_rejected_forgery', detail: forgery } };
+  }
+  const capRes = skill2gep.assembleCapsule(gene, execution, { scenario: parsed.name });
+  if (!capRes.ok) {
+    return { ok: false, gene: gene, diagnostic: { reason: 'capsule_assembly_failed', detail: capRes } };
+  }
+
+  return {
+    ok: true,
+    gene: gene,
+    capsule: capRes.capsule,
+    skill_name: parsed.name,
+    skill_hash: skillHash,
+    execution: execution,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Publish a Gene+Capsule bundle to the Hub and return the authoritative
+// asset_ids.
+//
+// asset_id is content-addressed (computeAssetId), so we can stamp it WITHOUT a
+// node_secret -- that lets dry runs (--no-publish) produce the exact same ids
+// the Hub will store, without requiring node registration. The signed bundle
+// (which needs the secret) is only built when we actually POST. Our capsule
+// already carries a non-empty execution_trace from assembleCapsule, so
+// buildPublishBundle's trace-synthesis path never fires and the id it computes
+// matches the one we stamped here.
+// ---------------------------------------------------------------------------
+async function publishStepBundle(gene, capsule, opts) {
+  opts = opts || {};
+  const geneClone = JSON.parse(JSON.stringify(gene));
+  const capsuleClone = JSON.parse(JSON.stringify(capsule));
+
+  // Stamp content-addressed ids up front (no secret needed).
+  geneClone.asset_id = computeAssetId(geneClone);
+  capsuleClone.asset_id = computeAssetId(capsuleClone);
+  const geneAssetId = geneClone.asset_id;
+  const capsuleAssetId = capsuleClone.asset_id;
+
+  // Persist locally before/independently of the network round-trip so the
+  // assets survive a Hub outage (mirrors skill2gep's persist-then-publish).
+  const persistErrors = [];
+  try { assetStore.upsertGene(geneClone); }
+  catch (err) { persistErrors.push({ step: 'upsertGene', error: errMsg(err) }); }
+  try { assetStore.appendCapsule(capsuleClone); }
+  catch (err) { persistErrors.push({ step: 'appendCapsule', error: errMsg(err) }); }
+
+  if (opts.publish === false) {
+    return {
+      ok: true,
+      gene_asset_id: geneAssetId,
+      capsule_asset_id: capsuleAssetId,
+      publish: { skipped: 'publish_disabled' },
+      persist_errors: persistErrors,
+    };
+  }
+
+  let message;
+  try {
+    message = a2a.buildPublishBundle({ gene: geneClone, capsule: capsuleClone, nodeId: a2a.getNodeId() });
+  } catch (err) {
+    return { ok: false, reason: 'build_publish_bundle_failed', error: errMsg(err), gene_asset_id: geneAssetId, capsule_asset_id: capsuleAssetId, persist_errors: persistErrors };
+  }
+
+  let sendRes;
+  try {
+    sendRes = await Promise.resolve(a2a.httpTransportSend(message, {
+      hubUrl: a2a.getHubUrl(),
+      timeoutMs: 15000,
+    }));
+  } catch (err) {
+    sendRes = { ok: false, error: errMsg(err) };
+  }
+
+  return {
+    ok: Boolean(sendRes && sendRes.ok),
+    gene_asset_id: geneAssetId,
+    capsule_asset_id: capsuleAssetId,
+    publish: sendRes,
+    persist_errors: persistErrors,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Create + publish the recipe on the Hub. Recipe is a REST resource, not an
+// A2A message_type, so we POST directly with buildHubHeaders (Bearer
+// node_secret). Returns { ok, recipe_id, create, publish }.
+// ---------------------------------------------------------------------------
+async function postRecipe(recipeBody, opts) {
+  opts = opts || {};
+  // Dry run: build the body and report it, but make no network calls at all.
+  if (opts.publish === false) {
+    return { ok: true, recipe_id: null, dry_run: true, body: recipeBody, publish: { skipped: 'publish_disabled' } };
+  }
+  const hubUrl = a2a.getHubUrl();
+  if (!hubUrl) return { ok: false, reason: 'no_hub_url' };
+  const base = hubUrl.replace(/\/+$/, '');
+  const headers = a2a.buildHubHeaders();
+
+  let createJson;
+  try {
+    const res = await fetch(base + '/a2a/recipe', {
+      method: 'POST',
+      headers: headers,
+      body: JSON.stringify(recipeBody),
+      signal: AbortSignal.timeout(RECIPE_TIMEOUT_MS),
+    });
+    const text = await res.text();
+    try { createJson = JSON.parse(text); } catch (_) { createJson = { raw: text }; }
+    if (!res.ok) return { ok: false, reason: 'recipe_create_failed', status: res.status, body: createJson };
+  } catch (err) {
+    return { ok: false, reason: 'recipe_create_request_failed', error: errMsg(err) };
+  }
+
+  const recipeId = createJson && createJson.recipe && (createJson.recipe.id || createJson.recipe.recipe_id);
+  if (!recipeId) return { ok: false, reason: 'recipe_id_missing', create: createJson };
+
+  if (opts.publish === false) {
+    return { ok: true, recipe_id: recipeId, create: createJson, publish: { skipped: 'publish_disabled' } };
+  }
+
+  let publishJson;
+  try {
+    const res = await fetch(base + '/a2a/recipe/' + encodeURIComponent(recipeId) + '/publish', {
+      method: 'POST',
+      headers: a2a.buildHubHeaders(),
+      body: JSON.stringify({ sender_id: recipeBody.sender_id }),
+      signal: AbortSignal.timeout(RECIPE_TIMEOUT_MS),
+    });
+    const text = await res.text();
+    try { publishJson = JSON.parse(text); } catch (_) { publishJson = { raw: text }; }
+    if (!res.ok) {
+      return { ok: false, reason: 'recipe_publish_failed', recipe_id: recipeId, status: res.status, body: publishJson, create: createJson };
+    }
+  } catch (err) {
+    return { ok: false, reason: 'recipe_publish_request_failed', recipe_id: recipeId, error: errMsg(err), create: createJson };
+  }
+
+  return { ok: true, recipe_id: recipeId, create: createJson, publish: publishJson };
+}
+
+function errMsg(err) { return err && err.message ? err.message : String(err); }
+
+// ---------------------------------------------------------------------------
+// Main entrypoint: composeRecipeFromSkills(manifest, opts)
+//
+// opts = {
+//   title, description, pricePerExecution   -- override manifest fields
+//   repoRoot      -- where validation commands run (default paths.getRepoRoot())
+//   publish       -- false to do everything locally but skip Hub network calls
+//   strict        -- default true: require real runnable validation per step
+// }
+//
+// Returns {
+//   ok, recipe_id, steps: [{ skill_path, asset_id, asset_type, position, ... }],
+//   skipped: [{ skill_path, reason }],     // optional steps that didn't verify
+//   gene_publish, recipe, errors
+// }
+// ---------------------------------------------------------------------------
+async function composeRecipeFromSkills(manifest, opts) {
+  opts = opts || {};
+  const norm = normalizeManifest(manifest, opts);
+
+  if (!norm.title || norm.title.trim().length < 3) {
+    return { ok: false, reason: 'title_min_3_chars' };
+  }
+  if (!norm.steps.length) return { ok: false, reason: 'no_steps' };
+  if (norm.steps.length > MAX_STEPS) {
+    return { ok: false, reason: 'too_many_steps', max: MAX_STEPS, got: norm.steps.length };
+  }
+
+  const recipeSteps = [];
+  const skipped = [];
+  const genePublishResults = [];
+  const errors = [];
+
+  for (const step of norm.steps) {
+    const hv = hydrolyzeAndVerify(step, { repoRoot: opts.repoRoot, strict: opts.strict });
+    if (!hv.ok) {
+      if (step.optional) {
+        skipped.push({ skill_path: step.skill_path, reason: hv.diagnostic });
+        appendJsonl(logPath(), { timestamp: new Date().toISOString(), status: 'step_skipped_optional', skill_path: step.skill_path, diagnostic: hv.diagnostic });
+        continue;
+      }
+      // A required step that failed to hydrolyze/verify aborts the whole
+      // recipe -- we never publish a half-built genome.
+      appendJsonl(logPath(), { timestamp: new Date().toISOString(), status: 'step_failed_abort', skill_path: step.skill_path, diagnostic: hv.diagnostic });
+      return { ok: false, reason: 'step_failed', skill_path: step.skill_path, diagnostic: hv.diagnostic, steps_done: recipeSteps };
+    }
+
+    const pub = await publishStepBundle(hv.gene, hv.capsule, { publish: opts.publish });
+    genePublishResults.push({ skill_path: step.skill_path, gene_id: hv.gene.id, result: pub });
+    if (!pub.ok && opts.publish !== false) {
+      appendJsonl(logPath(), { timestamp: new Date().toISOString(), status: 'gene_publish_failed', skill_path: step.skill_path, result: pub });
+      if (step.optional) { skipped.push({ skill_path: step.skill_path, reason: { reason: 'gene_publish_failed', detail: pub } }); continue; }
+      return { ok: false, reason: 'gene_publish_failed', skill_path: step.skill_path, detail: pub, steps_done: recipeSteps };
+    }
+
+    recipeSteps.push({
+      asset_id: pub.gene_asset_id,
+      asset_type: 'Gene',
+      position: recipeSteps.length,
+      optional: step.optional,
+      condition: step.condition,
+      parameters: step.parameters,
+      _skill_path: step.skill_path,
+      _capsule_asset_id: pub.capsule_asset_id,
+    });
+  }
+
+  if (!recipeSteps.length) {
+    return { ok: false, reason: 'all_steps_skipped', skipped: skipped };
+  }
+
+  const senderId = a2a.getNodeId();
+  const recipeBody = {
+    sender_id: senderId,
+    title: norm.title,
+    description: norm.description || undefined,
+    steps: recipeSteps.map((s) => ({
+      asset_id: s.asset_id,
+      asset_type: s.asset_type,
+      position: s.position,
+      optional: s.optional,
+      condition: s.condition,
+      parameters: s.parameters,
+    })),
+  };
+  if (norm.price_per_execution != null) recipeBody.price_per_execution = norm.price_per_execution;
+  if (norm.currency) recipeBody.currency = norm.currency;
+  if (norm.max_concurrent != null) recipeBody.max_concurrent = norm.max_concurrent;
+  if (norm.input_schema) recipeBody.input_schema = norm.input_schema;
+  if (norm.output_schema) recipeBody.output_schema = norm.output_schema;
+
+  const recipeRes = await postRecipe(recipeBody, { publish: opts.publish });
+
+  const state = readState();
+  state.recipes = state.recipes || {};
+  const key = shortHash(norm.title + '|' + recipeSteps.map((s) => s.asset_id).join(','));
+  state.recipes[key] = {
+    at: new Date().toISOString(),
+    title: norm.title,
+    recipe_id: recipeRes.recipe_id || null,
+    step_asset_ids: recipeSteps.map((s) => s.asset_id),
+    published: Boolean(recipeRes.ok),
+  };
+  try { writeState(state); } catch (err) { errors.push({ step: 'writeState', error: errMsg(err) }); }
+
+  appendJsonl(logPath(), {
+    timestamp: new Date().toISOString(),
+    status: recipeRes.ok ? 'recipe_published' : 'recipe_failed',
+    title: norm.title,
+    recipe_id: recipeRes.recipe_id || null,
+    step_count: recipeSteps.length,
+    skipped_count: skipped.length,
+    recipe_result: recipeRes,
+  });
+
+  return {
+    ok: Boolean(recipeRes.ok),
+    recipe_id: recipeRes.recipe_id || null,
+    title: norm.title,
+    market_url: recipeRes.recipe_id ? 'https://evomap.ai/market?tab=recipes' : null,
+    steps: recipeSteps.map((s) => ({
+      skill_path: s._skill_path,
+      asset_id: s.asset_id,
+      asset_type: s.asset_type,
+      position: s.position,
+      optional: s.optional,
+      condition: s.condition,
+      capsule_asset_id: s._capsule_asset_id,
+    })),
+    skipped: skipped,
+    gene_publish: genePublishResults,
+    recipe: recipeRes,
+    errors: errors,
+  };
+}
+
+module.exports = {
+  LOG_FILE,
+  STATE_FILE,
+  MAX_STEPS,
+  normalizeManifest,
+  hydrolyzeAndVerify,
+  publishStepBundle,
+  postRecipe,
+  composeRecipeFromSkills,
+  logPath,
+  statePath,
+};