Asset Store

function loadGenes()

const { loadGenes } = require('./gep/assetStore');

const genes = loadGenes();
console.log('Loaded genes:', genes.length);
// Output: Loaded genes: 12

function loadCapsules()

function readAllEvents()

function getLastEventId()

function appendEventJsonl(eventObj)

const { appendEventJsonl } = require('./gep/assetStore');

const event = {
  type: 'EvolutionEvent',
  schema_version: 3,
  id: 'evt_' + Date.now(),
  intent: 'repair',
  signals: ['log_error'],
  genes_used: ['gene_gep_repair'],
  outcome: { status: 'success', score: 0.85 },
  // ...
};

appendEventJsonl(event);

function appendCandidateJsonl(candidateObj)

function readRecentCandidates(limit = 20)

function upsertGene(geneObj)

const { upsertGene, computeAssetId } = require('./gep/assetStore');

const gene = {
  type: 'Gene',
  schema_version: 3,
  id: 'gene_custom_repair',
  category: 'repair',
  signals_match: ['custom_error'],
  preconditions: ['signals contains custom_error'],
  strategy: ['Analyze custom error', 'Apply targeted fix'],
  constraints: { max_files: 5, forbidden_paths: ['.git'] },
  validation: ['node scripts/validate.js'],
};

gene.asset_id = computeAssetId(gene);
upsertGene(gene);

function upsertCapsule(capsuleObj)

function appendFailedCapsule(capsuleObj)

const FAILED_CAPSULES_MAX = 200;
const FAILED_CAPSULES_TRIM_TO = 100;

if (list.length > FAILED_CAPSULES_MAX) {
  list = list.slice(list.length - FAILED_CAPSULES_TRIM_TO);
}

function readRecentFailedCapsules(limit = 50)

function ensureAssetFiles()

function ensureSchemaFields(obj) {
  if (!obj || typeof obj !== 'object') return obj;
  if (!obj.schema_version) obj.schema_version = SCHEMA_VERSION;
  if (!obj.asset_id) {
    try {
      obj.asset_id = computeAssetId(obj);
    } catch (e) {}
  }
  return obj;
}

function getDefaultGenes() {
  return {
    version: 1,
    genes: [
      {
        type: 'Gene',
        id: 'gene_gep_repair_from_errors',
        category: 'repair',
        signals_match: ['error', 'exception', 'failed', 'unstable'],
        preconditions: ['signals contains error-related indicators'],
        strategy: [
          'Extract structured signals from logs',
          'Select existing Gene by signals match',
          'Estimate blast radius before editing',
          'Apply smallest reversible patch',
          'Validate using declared validation steps',
          'Solidify: append EvolutionEvent, update Gene/Capsule store',
        ],
        constraints: {
          max_files: 12,
          forbidden_paths: ['.git', 'node_modules'],
        },
        validation: [
          buildValidationCmd(['src/evolve', 'src/gep/solidify']),
          buildValidationCmd(['src/gep/selector', 'src/gep/memoryGraph']),
        ],
      },
      // ...
    ],
  };
}

function buildValidationCmd(relModules) {
  const paths = relModules.map(m => `./${m}`);
  return `node scripts/validate-modules.js ${paths.join(' ')}`;
}

function genesPath() {
  return path.join(getGepAssetsDir(), 'genes.json');
}

function capsulesPath() {
  return path.join(getGepAssetsDir(), 'capsules.json');
}

function capsulesJsonlPath() {
  return path.join(getGepAssetsDir(), 'capsules.jsonl');
}

function eventsPath() {
  return path.join(getGepAssetsDir(), 'events.jsonl');
}

function candidatesPath() {
  return path.join(getGepAssetsDir(), 'candidates.jsonl');
}

function externalCandidatesPath() {
  return path.join(getGepAssetsDir(), 'external_candidates.jsonl');
}

function failedCapsulesPath() {
  return path.join(getGepAssetsDir(), 'failed_capsules.json');
}

const assetStore = require('./gep/assetStore');
const { computeAssetId, SCHEMA_VERSION } = require('./gep/contentHash');

// Ensure asset files exist
assetStore.ensureAssetFiles();

// Load genes and capsules
const genes = assetStore.loadGenes();
const capsules = assetStore.loadCapsules();
console.log('Loaded:', genes.length, 'genes,', capsules.length, 'capsules');

// Create a new gene
const newGene = {
  type: 'Gene',
  schema_version: SCHEMA_VERSION,
  id: 'gene_custom_' + Date.now(),
  category: 'optimize',
  signals_match: ['perf_bottleneck'],
  strategy: ['Profile performance', 'Apply optimization'],
  constraints: { max_files: 8 },
  validation: ['node scripts/validate.js'],
};
newGene.asset_id = computeAssetId(newGene);
assetStore.upsertGene(newGene);

// Append an event
const event = {
  type: 'EvolutionEvent',
  schema_version: SCHEMA_VERSION,
  id: 'evt_' + Date.now(),
  intent: 'optimize',
  signals: ['perf_bottleneck'],
  genes_used: [newGene.id],
  outcome: { status: 'success', score: 0.75 },
  blast_radius: { files: 3, lines: 45 },
};
event.asset_id = computeAssetId(event);
assetStore.appendEventJsonl(event);

// Read recent events
const recentEvents = assetStore.readAllEvents().slice(-10);
console.log('Recent events:', recentEvents.length);

// Get last event ID
const lastId = assetStore.getLastEventId();
console.log('Last event ID:', lastId);