@evomap/evolver 1.90.0 → 2.0.0-beta.0

package/src/gep/skill2recipes.js

@@ -1,511 +0,0 @@
-'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,
-};