chainlesschain 0.37.12 → 0.40.1

package/src/lib/evomap-client.js

@@ -0,0 +1,135 @@
+/**
+ * EvoMap Client — GEP-A2A HTTP client for gene exchange.
+ *
+ * Communicates with EvoMap Hub servers to search, publish, and download
+ * agent capability genes (skills, prompts, tool configs).
+ *
+ * Lightweight: uses native fetch, no heavy dependencies.
+ */
+
+// Exported for test injection
+export const _deps = {
+  fetch: globalThis.fetch,
+};
+
+const DEFAULT_HUB = "https://evomap.chainlesschain.com/api/v1";
+
+export class EvoMapClient {
+  /**
+   * @param {object} options
+   * @param {string} [options.hubUrl] - EvoMap Hub URL
+   * @param {string} [options.apiKey] - Optional API key for authenticated endpoints
+   * @param {number} [options.timeout] - Request timeout in ms
+   */
+  constructor({ hubUrl, apiKey, timeout } = {}) {
+    this.hubUrl = hubUrl || process.env.EVOMAP_HUB_URL || DEFAULT_HUB;
+    this.apiKey = apiKey || process.env.EVOMAP_API_KEY || "";
+    this.timeout = timeout || 10000;
+  }
+
+  /**
+   * Search for genes on the hub.
+   * @param {string} query - Search query
+   * @param {object} [options]
+   * @param {string} [options.category] - Filter by category
+   * @param {number} [options.limit] - Max results
+   * @returns {Promise<Array<{ id, name, description, author, version, downloads, rating }>>}
+   */
+  async search(query, { category, limit = 20 } = {}) {
+    const params = new URLSearchParams({ q: query, limit: String(limit) });
+    if (category) params.set("category", category);
+
+    const data = await this._request(`/genes/search?${params}`);
+    return data.genes || data.results || [];
+  }
+
+  /**
+   * Get gene details by ID.
+   */
+  async getGene(geneId) {
+    return this._request(`/genes/${encodeURIComponent(geneId)}`);
+  }
+
+  /**
+   * Download a gene package.
+   * @returns {{ gene: object, content: string }}
+   */
+  async download(geneId) {
+    const data = await this._request(
+      `/genes/${encodeURIComponent(geneId)}/download`,
+    );
+    return data;
+  }
+
+  /**
+   * Publish a gene to the hub.
+   * @param {object} gene - Gene metadata + content
+   */
+  async publish(gene) {
+    if (!this.apiKey) throw new Error("API key required for publishing");
+    return this._request("/genes", {
+      method: "POST",
+      body: JSON.stringify(gene),
+    });
+  }
+
+  /**
+   * List hub information.
+   */
+  async getHubInfo() {
+    return this._request("/info");
+  }
+
+  /**
+   * List available hubs (returns current hub info).
+   */
+  async listHubs() {
+    try {
+      const info = await this.getHubInfo();
+      return [{ url: this.hubUrl, ...info }];
+    } catch (_err) {
+      return [{ url: this.hubUrl, status: "unreachable" }];
+    }
+  }
+
+  // ─── Internal ───
+
+  async _request(path, options = {}) {
+    const url = `${this.hubUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+    try {
+      const response = await _deps.fetch(url, {
+        method: options.method || "GET",
+        headers,
+        body: options.body || undefined,
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(
+          `EvoMap API error: ${response.status} ${response.statusText}`,
+        );
+      }
+
+      return await response.json();
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err.name === "AbortError") {
+        throw new Error(`EvoMap request timed out after ${this.timeout}ms`);
+      }
+      throw err;
+    }
+  }
+}

package/src/lib/evomap-federation.js

@@ -0,0 +1,240 @@
+/**
+ * EvoMap Federation — federated hub management, gene syncing,
+ * lineage tracking, evolutionary pressure analytics, and gene recombination.
+ */
+
+import crypto from "crypto";
+
+/* ── In-memory stores ──────────────────────────────────────── */
+const _hubs = new Map();
+const _lineage = new Map();
+
+const HUB_STATUS = {
+  ONLINE: "online",
+  OFFLINE: "offline",
+  SYNCING: "syncing",
+  DEGRADED: "degraded",
+};
+
+/* ── Schema ────────────────────────────────────────────────── */
+
+export function ensureEvoMapFederationTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS evomap_hub_federation (
+      id TEXT PRIMARY KEY,
+      hub_url TEXT NOT NULL,
+      hub_name TEXT,
+      status TEXT DEFAULT 'offline',
+      region TEXT,
+      gene_count INTEGER DEFAULT 0,
+      last_sync TEXT,
+      trust_score REAL DEFAULT 0.5,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS gene_lineage (
+      id TEXT PRIMARY KEY,
+      gene_id TEXT NOT NULL,
+      parent_gene_id TEXT,
+      hub_id TEXT,
+      generation INTEGER DEFAULT 0,
+      fitness_score REAL DEFAULT 0.0,
+      mutation_type TEXT,
+      recombination_source TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+/* ── Hub Management ────────────────────────────────────────── */
+
+export function listFederatedHubs(db, filter = {}) {
+  let hubs = [..._hubs.values()];
+  if (filter.status) {
+    hubs = hubs.filter((h) => h.status === filter.status);
+  }
+  if (filter.region) {
+    hubs = hubs.filter((h) => h.region === filter.region);
+  }
+  const limit = filter.limit || 50;
+  return hubs.slice(0, limit);
+}
+
+export function addFederatedHub(db, hubUrl, hubName, region) {
+  if (!hubUrl) throw new Error("Hub URL is required");
+
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  const hub = {
+    id,
+    hubUrl,
+    hubName: hubName || hubUrl,
+    status: HUB_STATUS.OFFLINE,
+    region: region || "global",
+    geneCount: 0,
+    lastSync: null,
+    trustScore: 0.5,
+    createdAt: now,
+  };
+
+  _hubs.set(id, hub);
+
+  db.prepare(
+    `INSERT INTO evomap_hub_federation (id, hub_url, hub_name, status, region, gene_count, last_sync, trust_score, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(id, hub.hubUrl, hub.hubName, hub.status, hub.region, 0, null, 0.5, now);
+
+  return hub;
+}
+
+/* ── Gene Syncing ──────────────────────────────────────────── */
+
+export function syncGenes(db, hubId, geneIds = []) {
+  const hub = _hubs.get(hubId);
+  if (!hub) throw new Error(`Hub not found: ${hubId}`);
+
+  const now = new Date().toISOString();
+  const synced = geneIds.length || Math.floor(Math.random() * 10) + 1;
+
+  hub.status = HUB_STATUS.ONLINE;
+  hub.geneCount += synced;
+  hub.lastSync = now;
+  hub.trustScore = Math.min(1.0, hub.trustScore + 0.05);
+
+  db.prepare(
+    `UPDATE evomap_hub_federation SET status = ?, gene_count = ?, last_sync = ?, trust_score = ? WHERE id = ?`,
+  ).run(hub.status, hub.geneCount, now, hub.trustScore, hubId);
+
+  return { hubId, synced, timestamp: now };
+}
+
+/* ── Evolutionary Pressure ────────────────────────────────── */
+
+export function getPressureReport() {
+  const lineageEntries = [..._lineage.values()];
+  if (lineageEntries.length === 0) {
+    return {
+      totalGenes: 0,
+      avgFitness: 0,
+      maxGeneration: 0,
+      mutations: 0,
+      recombinations: 0,
+    };
+  }
+
+  const totalGenes = lineageEntries.length;
+  const avgFitness =
+    lineageEntries.reduce((s, e) => s + e.fitnessScore, 0) / totalGenes;
+  const maxGeneration = Math.max(...lineageEntries.map((e) => e.generation));
+  const mutations = lineageEntries.filter(
+    (e) => e.mutationType && e.mutationType !== "recombination",
+  ).length;
+  const recombinations = lineageEntries.filter(
+    (e) => e.mutationType === "recombination",
+  ).length;
+
+  return { totalGenes, avgFitness, maxGeneration, mutations, recombinations };
+}
+
+/* ── Gene Recombination ───────────────────────────────────── */
+
+export function recombineGenes(db, geneId1, geneId2) {
+  if (!geneId1 || !geneId2) throw new Error("Two gene IDs are required");
+
+  const id = crypto.randomUUID();
+  const childGeneId = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  // Determine generation from parents
+  const parent1 = [..._lineage.values()].find((e) => e.geneId === geneId1);
+  const parent2 = [..._lineage.values()].find((e) => e.geneId === geneId2);
+  const gen = Math.max(parent1?.generation || 0, parent2?.generation || 0) + 1;
+
+  const entry = {
+    id,
+    geneId: childGeneId,
+    parentGeneId: geneId1,
+    hubId: null,
+    generation: gen,
+    fitnessScore: 0.5 + Math.random() * 0.5,
+    mutationType: "recombination",
+    recombinationSource: geneId2,
+    createdAt: now,
+  };
+
+  _lineage.set(id, entry);
+
+  db.prepare(
+    `INSERT INTO gene_lineage (id, gene_id, parent_gene_id, hub_id, generation, fitness_score, mutation_type, recombination_source, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    entry.geneId,
+    entry.parentGeneId,
+    null,
+    entry.generation,
+    entry.fitnessScore,
+    entry.mutationType,
+    entry.recombinationSource,
+    now,
+  );
+
+  return entry;
+}
+
+/* ── Lineage Tracking ─────────────────────────────────────── */
+
+export function getLineage(geneId) {
+  if (!geneId) throw new Error("Gene ID is required");
+  return [..._lineage.values()].filter(
+    (e) =>
+      e.geneId === geneId ||
+      e.parentGeneId === geneId ||
+      e.recombinationSource === geneId,
+  );
+}
+
+export function addLineageEntry(db, geneId, parentGeneId, opts = {}) {
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  const entry = {
+    id,
+    geneId,
+    parentGeneId: parentGeneId || null,
+    hubId: opts.hubId || null,
+    generation: opts.generation || 0,
+    fitnessScore: opts.fitnessScore || 0.5 + Math.random() * 0.5,
+    mutationType: opts.mutationType || "mutation",
+    recombinationSource: opts.recombinationSource || null,
+    createdAt: now,
+  };
+
+  _lineage.set(id, entry);
+
+  db.prepare(
+    `INSERT INTO gene_lineage (id, gene_id, parent_gene_id, hub_id, generation, fitness_score, mutation_type, recombination_source, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    entry.geneId,
+    entry.parentGeneId,
+    entry.hubId,
+    entry.generation,
+    entry.fitnessScore,
+    entry.mutationType,
+    entry.recombinationSource,
+    now,
+  );
+
+  return entry;
+}
+
+/* ── Reset (for testing) ───────────────────────────────────── */
+
+export function _resetState() {
+  _hubs.clear();
+  _lineage.clear();
+}

package/src/lib/evomap-governance.js

@@ -0,0 +1,250 @@
+/**
+ * EvoMap Governance — gene IP ownership, contribution tracing,
+ * and governance proposals for the EvoMap ecosystem.
+ */
+
+import crypto from "crypto";
+
+/* ── In-memory stores ──────────────────────────────────────── */
+const _ownerships = new Map();
+const _proposals = new Map();
+
+const PROPOSAL_STATUS = {
+  DRAFT: "draft",
+  ACTIVE: "active",
+  PASSED: "passed",
+  REJECTED: "rejected",
+  EXECUTED: "executed",
+};
+
+/* ── Schema ────────────────────────────────────────────────── */
+
+export function ensureEvoMapGovernanceTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS gene_ownership (
+      id TEXT PRIMARY KEY,
+      gene_id TEXT NOT NULL,
+      owner_did TEXT NOT NULL,
+      originality_proof TEXT,
+      derivation_chain TEXT,
+      revenue_split TEXT,
+      verified INTEGER DEFAULT 0,
+      plagiarism_score REAL DEFAULT 0.0,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS evomap_governance_proposals (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      proposer_did TEXT,
+      type TEXT DEFAULT 'standard',
+      status TEXT DEFAULT 'draft',
+      votes_for INTEGER DEFAULT 0,
+      votes_against INTEGER DEFAULT 0,
+      quorum_reached INTEGER DEFAULT 0,
+      voting_deadline TEXT,
+      executed_at TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+/* ── Ownership Registration ───────────────────────────────── */
+
+export function registerOwnership(db, geneId, ownerDid, opts = {}) {
+  if (!geneId) throw new Error("Gene ID is required");
+  if (!ownerDid) throw new Error("Owner DID is required");
+
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  const originalityProof = opts.originalityProof || {
+    method: "did-vc",
+    timestamp: now,
+  };
+  const revenueSplit = opts.revenueSplit || { [ownerDid]: 100 };
+  const derivationChain = opts.derivationChain || [];
+
+  const ownership = {
+    id,
+    geneId,
+    ownerDid,
+    originalityProof,
+    derivationChain,
+    revenueSplit,
+    verified: 1,
+    plagiarismScore: 0.0,
+    createdAt: now,
+  };
+
+  _ownerships.set(id, ownership);
+
+  db.prepare(
+    `INSERT INTO gene_ownership (id, gene_id, owner_did, originality_proof, derivation_chain, revenue_split, verified, plagiarism_score, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    geneId,
+    ownerDid,
+    JSON.stringify(originalityProof),
+    JSON.stringify(derivationChain),
+    JSON.stringify(revenueSplit),
+    1,
+    0.0,
+    now,
+  );
+
+  return ownership;
+}
+
+/* ── Ownership Tracing ────────────────────────────────────── */
+
+export function traceOwnership(geneId) {
+  if (!geneId) throw new Error("Gene ID is required");
+
+  const entries = [..._ownerships.values()].filter((o) => o.geneId === geneId);
+  if (entries.length === 0) {
+    return {
+      geneId,
+      owner: null,
+      contributors: [],
+      derivationChain: [],
+      revenueSplit: {},
+    };
+  }
+
+  const latest = entries[entries.length - 1];
+  const contributors = Object.keys(latest.revenueSplit);
+
+  return {
+    geneId,
+    owner: latest.ownerDid,
+    contributors,
+    derivationChain: latest.derivationChain,
+    revenueSplit: latest.revenueSplit,
+  };
+}
+
+/* ── Governance Proposals ─────────────────────────────────── */
+
+export function createGovernanceProposal(
+  db,
+  title,
+  description,
+  proposerDid,
+  opts = {},
+) {
+  if (!title) throw new Error("Title is required");
+
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+  const type = opts.type || "standard";
+  const votingDurationMs = opts.votingDurationMs || 7 * 24 * 60 * 60 * 1000;
+  const deadline = new Date(Date.now() + votingDurationMs).toISOString();
+
+  const proposal = {
+    id,
+    title,
+    description: description || "",
+    proposerDid: proposerDid || "anonymous",
+    type,
+    status: PROPOSAL_STATUS.ACTIVE,
+    votesFor: 0,
+    votesAgainst: 0,
+    quorumReached: false,
+    votingDeadline: deadline,
+    executedAt: null,
+    createdAt: now,
+  };
+
+  _proposals.set(id, proposal);
+
+  db.prepare(
+    `INSERT INTO evomap_governance_proposals (id, title, description, proposer_did, type, status, votes_for, votes_against, quorum_reached, voting_deadline, executed_at, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    proposal.title,
+    proposal.description,
+    proposal.proposerDid,
+    proposal.type,
+    proposal.status,
+    0,
+    0,
+    0,
+    deadline,
+    null,
+    now,
+  );
+
+  return proposal;
+}
+
+export function voteOnGovernanceProposal(db, proposalId, voterDid, vote) {
+  const proposal = _proposals.get(proposalId);
+  if (!proposal) throw new Error(`Proposal not found: ${proposalId}`);
+  if (proposal.status !== PROPOSAL_STATUS.ACTIVE) {
+    throw new Error(`Proposal is not active: ${proposal.status}`);
+  }
+  if (vote !== "for" && vote !== "against") {
+    throw new Error('Vote must be "for" or "against"');
+  }
+
+  if (vote === "for") {
+    proposal.votesFor++;
+  } else {
+    proposal.votesAgainst++;
+  }
+
+  const totalVotes = proposal.votesFor + proposal.votesAgainst;
+
+  // Check quorum (minimum 3 votes)
+  if (totalVotes >= 3 && !proposal.quorumReached) {
+    proposal.quorumReached = true;
+    proposal.status =
+      proposal.votesFor > proposal.votesAgainst
+        ? PROPOSAL_STATUS.PASSED
+        : PROPOSAL_STATUS.REJECTED;
+
+    db.prepare(
+      `UPDATE evomap_governance_proposals SET votes_for = ?, votes_against = ?, quorum_reached = ?, status = ? WHERE id = ?`,
+    ).run(
+      proposal.votesFor,
+      proposal.votesAgainst,
+      1,
+      proposal.status,
+      proposalId,
+    );
+  } else {
+    db.prepare(
+      `UPDATE evomap_governance_proposals SET votes_for = ?, votes_against = ? WHERE id = ?`,
+    ).run(proposal.votesFor, proposal.votesAgainst, proposalId);
+  }
+
+  return {
+    proposalId,
+    vote,
+    totalVotes,
+    status: proposal.status,
+  };
+}
+
+export function getGovernanceDashboard() {
+  const all = [..._proposals.values()];
+  return {
+    totalProposals: all.length,
+    active: all.filter((p) => p.status === PROPOSAL_STATUS.ACTIVE).length,
+    passed: all.filter((p) => p.status === PROPOSAL_STATUS.PASSED).length,
+    rejected: all.filter((p) => p.status === PROPOSAL_STATUS.REJECTED).length,
+    executed: all.filter((p) => p.status === PROPOSAL_STATUS.EXECUTED).length,
+  };
+}
+
+/* ── Reset (for testing) ───────────────────────────────────── */
+
+export function _resetState() {
+  _ownerships.clear();
+  _proposals.clear();
+}