quantum-spherifier 1.0.0

package/src/modules/MemorySystem.js

@@ -0,0 +1,210 @@
+/**
+ * MemorySystem.js — FUSIONARY (v1.0)
+ * Three-tier persistent memory specialised for scientific research.
+ *
+ *   Episodic:  Records of past research cycles (hypothesis → design → patent)
+ *   Semantic:  Facts extracted from the KG and external literature
+ *   Working:   Short-term buffer for the current research cycle
+ *
+ * Embeddings: simple deterministic hash-based (384-dim) when no LLM is
+ * configured; if an LLM adapter with embed() is supplied, it is used.
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { v4 as uuidv4 } from 'uuid';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+function hashEmbed(text, dim = 384) {
+  const e = new Float64Array(dim);
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    const slot = (i * 31 + code) % dim;
+    e[slot] += Math.sin(code * 0.01 + i * 0.1) * (1 + (code % 5));
+  }
+  let n = 0;
+  for (const v of e) n += v * v;
+  n = Math.sqrt(n) || 1;
+  for (let i = 0; i < dim; i++) e[i] /= n;
+  return Array.from(e);
+}
+
+function cosine(a, b) {
+  let s = 0;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) s += a[i] * b[i];
+  return s;
+}
+
+export class MemorySystem extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.storageDir = opts.storageDir ?? join(process.cwd(), 'data', 'memory');
+    this.llm = opts.llm ?? null;
+    this.episodic = [];
+    this.semantic = new Map();
+    this.working = new Map();
+    this.maxWorking = opts.maxWorking ?? 50;
+    this.ttlMs = opts.ttlMs ?? 30 * 60 * 1000;
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+    if (!existsSync(this.storageDir)) mkdirSync(this.storageDir, { recursive: true });
+    await this._loadEpisodic();
+    await this._loadSemantic();
+    // Prune expired working memory on init
+    this._pruneWorking();
+    this.initialized = true;
+    this.emit('ready');
+  }
+
+  // ── Episodic ───────────────────────────────────────────────────────────────
+
+  async store(topic, payload, metadata = {}) {
+    const id = uuidv4();
+    const text = `${topic} ${JSON.stringify(payload)}`;
+    const embedding = this.llm ? (await this._safeEmbed(text)) : hashEmbed(text);
+    const record = {
+      id,
+      topic,
+      payload,
+      embedding,
+      metadata,
+      timestamp: Date.now(),
+    };
+    this.episodic.push(record);
+    if (this.episodic.length > 1000) this.episodic = this.episodic.slice(-1000);
+    await this._persistEpisodicRecord(record);
+    this.emit('episodicStored', { id, topic });
+    return record;
+  }
+
+  async recall(query, opts = {}) {
+    const limit = opts.limit ?? 5;
+    const minSim = opts.minSimilarity ?? 0.3;
+    const text = `${query} ${JSON.stringify(opts.context ?? {})}`;
+    const qe = this.llm ? (await this._safeEmbed(text)) : hashEmbed(text);
+
+    const scored = this.episodic.map(rec => ({
+      rec,
+      score: cosine(qe, rec.embedding ?? []),
+    }));
+    return scored
+      .filter(s => s.score >= minSim)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit)
+      .map(s => ({ ...s.rec, similarity: s.score }));
+  }
+
+  // ── Semantic ───────────────────────────────────────────────────────────────
+
+  async storeSemantic(key, value, confidence = 0.5) {
+    const text = `${key} ${JSON.stringify(value)}`;
+    const embedding = this.llm ? (await this._safeEmbed(text)) : hashEmbed(text);
+    const record = {
+      key,
+      value,
+      confidence,
+      embedding,
+      updatedAt: Date.now(),
+    };
+    this.semantic.set(key, record);
+    await this._persistSemanticRecord(record);
+    this.emit('semanticStored', { key });
+    return record;
+  }
+
+  retrieveSemantic(key) {
+    return this.semantic.get(key);
+  }
+
+  // ── Working memory ─────────────────────────────────────────────────────────
+
+  setWorking(key, value, ttl = this.ttlMs) {
+    this.working.set(key, {
+      value,
+      expires: ttl > 0 ? Date.now() + ttl : 0,
+    });
+    if (this.working.size > this.maxWorking) {
+      const oldest = this.working.keys().next().value;
+      this.working.delete(oldest);
+    }
+    this.emit('workingSet', { key });
+  }
+
+  getWorking(key) {
+    const entry = this.working.get(key);
+    if (!entry) return null;
+    if (entry.expires && entry.expires < Date.now()) {
+      this.working.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+
+  _pruneWorking() {
+    const now = Date.now();
+    for (const [k, v] of this.working) {
+      if (v.expires && v.expires < now) this.working.delete(k);
+    }
+  }
+
+  // ── Persistence ────────────────────────────────────────────────────────────
+
+  async _safeEmbed(text) {
+    try {
+      const r = await this.llm.embed(text);
+      if (r?.ok && Array.isArray(r.embedding)) return r.embedding;
+    } catch (err) {
+      this.emit('warning', { stage: 'embed', error: err.message });
+    }
+    return hashEmbed(text);
+  }
+
+  async _persistEpisodicRecord(rec) {
+    const file = join(this.storageDir, 'episodic', `${rec.id}.json`);
+    if (!existsSync(dirname(file))) mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(rec, null, 2));
+  }
+
+  async _loadEpisodic() {
+    const dir = join(this.storageDir, 'episodic');
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir)) {
+      try {
+        const rec = JSON.parse(readFileSync(join(dir, entry), 'utf8'));
+        this.episodic.push(rec);
+      } catch (err) {
+        this.emit('warning', { stage: 'loadEpisodic', file: entry, error: err.message });
+      }
+    }
+  }
+
+  async _persistSemanticRecord(rec) {
+    const file = join(this.storageDir, 'semantic', `${rec.key.replace(/[^a-zA-Z0-9_]/g, '_')}.json`);
+    if (!existsSync(dirname(file))) mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(rec, null, 2));
+  }
+
+  async _loadSemantic() {
+    const dir = join(this.storageDir, 'semantic');
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir)) {
+      try {
+        const rec = JSON.parse(readFileSync(join(dir, entry), 'utf8'));
+        this.semantic.set(rec.key, rec);
+      } catch (err) {
+        this.emit('warning', { stage: 'loadSemantic', file: entry, error: err.message });
+      }
+    }
+  }
+
+  stats() {
+    return {
+      episodic: this.episodic.length,
+      semantic: this.semantic.size,
+      working: this.working.size,
+    };
+  }
+}

package/src/modules/MetricsCollector.js

@@ -0,0 +1,139 @@
+/**
+ * MetricsCollector.js — FUSIONARY (v1.0)
+ * Observability stack: counters, gauges, histograms, timers, time-series.
+ *
+ * FUSIONARY-specific KPIs:
+ *   - documents_produced
+ *   - hypotheses_generated
+ *   - patents_drafted
+ *   - feasibility_check_passes
+ *   - llm_calls_by_adapter
+ *   - average_quality
+ *   - average_novelty
+ *   - average_feasibility
+ *   - average_patentability
+ */
+
+import { EventEmitter } from 'eventemitter3';
+
+export class MetricsCollector extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.counters = new Map();
+    this.gauges = new Map();
+    this.histograms = new Map();
+    this.timers = new Map();
+    this.timeseries = new Map();
+    this.enableConsole = opts.enableConsole ?? false;
+    this._timerStarts = new Map();
+    this.started = false;
+  }
+
+  start() {
+    this.started = true;
+    if (this.enableConsole) {
+      this._consoleTimer = setInterval(() => this._dump(), 30_000);
+    }
+    this.emit('started');
+  }
+
+  stop() {
+    if (this._consoleTimer) clearInterval(this._consoleTimer);
+    this.started = false;
+    this.emit('stopped');
+  }
+
+  incrementCounter(name, value = 1) {
+    this.counters.set(name, (this.counters.get(name) ?? 0) + value);
+    this._pushTimeseries(name, value);
+  }
+
+  setGauge(name, value) {
+    this.gauges.set(name, value);
+    this._pushTimeseries(name, value);
+  }
+
+  observeHistogram(name, value) {
+    if (!this.histograms.has(name)) this.histograms.set(name, []);
+    const arr = this.histograms.get(name);
+    arr.push(value);
+    if (arr.length > 1000) arr.shift();
+    this._pushTimeseries(name, value);
+  }
+
+  startTimer(name) {
+    const id = `${name}_${Date.now()}_${Math.random()}`;
+    this._timerStarts.set(id, Date.now());
+    return id;
+  }
+
+  stopTimer(name, id) {
+    const start = this._timerStarts.get(id);
+    if (!start) return 0;
+    const elapsed = Date.now() - start;
+    if (!this.timers.has(name)) this.timers.set(name, []);
+    const arr = this.timers.get(name);
+    arr.push(elapsed);
+    if (arr.length > 500) arr.shift();
+    this._timerStarts.delete(id);
+    this._pushTimeseries(name, elapsed);
+    return elapsed;
+  }
+
+  _pushTimeseries(name, value) {
+    if (!this.timeseries.has(name)) this.timeseries.set(name, []);
+    const arr = this.timeseries.get(name);
+    arr.push({ t: Date.now(), v: value });
+    if (arr.length > 1440) arr.shift(); // keep 24h at 1-min resolution
+  }
+
+  getSummary() {
+    const histogramStats = {};
+    for (const [name, arr] of this.histograms) {
+      if (arr.length === 0) continue;
+      const sorted = [...arr].sort((a, b) => a - b);
+      histogramStats[name] = {
+        count: arr.length,
+        min: sorted[0],
+        max: sorted[sorted.length - 1],
+        mean: arr.reduce((s, v) => s + v, 0) / arr.length,
+        p50: sorted[Math.floor(arr.length * 0.5)],
+        p95: sorted[Math.floor(arr.length * 0.95)],
+      };
+    }
+    const timerStats = {};
+    for (const [name, arr] of this.timers) {
+      if (arr.length === 0) continue;
+      timerStats[name] = {
+        count: arr.length,
+        meanMs: arr.reduce((s, v) => s + v, 0) / arr.length,
+        lastMs: arr[arr.length - 1],
+      };
+    }
+    return {
+      counters: Object.fromEntries(this.counters),
+      gauges: Object.fromEntries(this.gauges),
+      histograms: histogramStats,
+      timers: timerStats,
+      timeseriesKeys: [...this.timeseries.keys()],
+    };
+  }
+
+  resetAll() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+    this.timers.clear();
+    this.timeseries.clear();
+    this._timerStarts.clear();
+    this.emit('reset');
+  }
+
+  _dump() {
+    const s = this.getSummary();
+    console.log('[Metrics]', JSON.stringify({
+      counters: s.counters,
+      gauges: s.gauges,
+    }));
+  }
+}

package/src/modules/PatentClusterManager.js

@@ -0,0 +1,199 @@
+/**
+ * PatentClusterManager.js — quantum-spherifier (v1.0)
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Groups patent-eligible documents into coherent clusters for filing.
+ * A cluster represents a COMPLETE solution that combines advances from
+ * multiple research lines (e.g. "qLDPC on neutral atoms for FeMoco
+ * simulation" = QEC + Qubits + Simulation).
+ *
+ * Clustering policy:
+ *   - Two documents join the same cluster if they share ≥2 KG concepts
+ *     or one is cross-linked to the other.
+ *   - A cluster is "filing-ready" when it contains at least one document
+ *     from each of: QEC or Qubits (hardware foundation), and Algorithms
+ *     or Simulation (application layer).
+ *   - Each cluster gets a cluster_id, a title, a summary, and a claim tree.
+ *
+ * This ensures that successful solutions (intermediate or final) are
+ * grouped coherently and tagged for patenting — nothing stays isolated.
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { v4 as uuidv4 } from 'uuid';
+
+const LINE_ROLE = {
+  quantum_error_correction: 'foundation',   // hardware foundation
+  new_qubit_modalities: 'foundation',        // hardware foundation
+  quantum_algorithms: 'application',         // application layer
+  molecular_simulation: 'application',       // application layer
+};
+
+export class PatentClusterManager extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.archivist = opts.archivist ?? null;
+    this.kg = opts.kg ?? null;
+    this.llm = opts.llm ?? null;
+    this.clusters = new Map();  // clusterId -> cluster
+  }
+
+  /**
+   * Rebuild clusters from the current patent queue.
+   */
+  rebuildClusters() {
+    if (!this.archivist) return [];
+    const patents = this.archivist.patentQueue();
+    this.clusters.clear();
+
+    // Union-Find structure
+    const parent = new Map();
+    const find = (x) => {
+      if (!parent.has(x)) parent.set(x, x);
+      while (parent.get(x) !== x) {
+        parent.set(x, parent.get(parent.get(x)));
+        x = parent.get(x);
+      }
+      return x;
+    };
+    const union = (a, b) => {
+      const ra = find(a), rb = find(b);
+      if (ra !== rb) parent.set(ra, rb);
+    };
+
+    // Initialise each patent as its own cluster
+    for (const r of patents) {
+      parent.set(r.manifest.id, r.manifest.id);
+    }
+
+    // Merge patents that share KG concepts or cross-links
+    for (let i = 0; i < patents.length; i++) {
+      for (let j = i + 1; j < patents.length; j++) {
+        const a = patents[i].manifest;
+        const b = patents[j].manifest;
+        // Check cross-links
+        const aLinks = (a.crossLinks ?? []).map(c => c.to);
+        const bLinks = (b.crossLinks ?? []).map(c => c.to);
+        if (aLinks.includes(b.id) || bLinks.includes(a.id)) {
+          union(a.id, b.id);
+          continue;
+        }
+        // Check shared KG concepts (from extra.hypothesis.supportingConcepts)
+        const aConcepts = a.extra?.hypothesis?.supportingConcepts ?? [];
+        const bConcepts = b.extra?.hypothesis?.supportingConcepts ?? [];
+        const shared = aConcepts.filter(c => bConcepts.includes(c));
+        if (shared.length >= 2) {
+          union(a.id, b.id);
+        }
+        // Same research line + same topic → likely related
+        if (a.researchLine === b.researchLine && a.topic === b.topic) {
+          union(a.id, b.id);
+        }
+      }
+    }
+
+    // Group by root
+    const groups = new Map();
+    for (const r of patents) {
+      const root = find(r.manifest.id);
+      if (!groups.has(root)) groups.set(root, []);
+      groups.get(root).push(r);
+    }
+
+    // Build cluster objects
+    for (const [, members] of groups) {
+      const cluster = this._buildCluster(members);
+      this.clusters.set(cluster.id, cluster);
+    }
+
+    this.emit('clustersRebuilt', { count: this.clusters.size });
+    return [...this.clusters.values()];
+  }
+
+  _buildCluster(members) {
+    const lines = new Set(members.map(m => m.manifest.researchLine).filter(Boolean));
+    const roles = new Set([...lines].map(l => LINE_ROLE[l]));
+    const hasFoundation = roles.has('foundation');
+    const hasApplication = roles.has('application');
+    const filingReady = hasFoundation && hasApplication && members.length >= 2;
+
+    const concepts = new Set();
+    for (const m of members) {
+      const c = m.manifest.extra?.hypothesis?.supportingConcepts ?? [];
+      c.forEach(x => concepts.add(x));
+    }
+
+    const title = this._synthesiseTitle(members, lines);
+    const summary = this._synthesiseSummary(members, lines, concepts);
+
+    return {
+      id: `cluster_${uuidv4().slice(0, 8)}`,
+      title,
+      summary,
+      memberIds: members.map(m => m.manifest.id),
+      members: members.map(m => ({
+        id: m.manifest.id,
+        title: m.manifest.title,
+        researchLine: m.manifest.researchLine,
+        topic: m.manifest.topic,
+        claimsCount: (m.manifest.patent?.claims ?? []).length,
+        path: `${m.manifest.category}/${m.manifest.topic}/${m.manifest.id}`,
+      })),
+      researchLines: [...lines],
+      sharedConcepts: [...concepts],
+      filingReady,
+      createdAt: Date.now(),
+    };
+  }
+
+  _synthesiseTitle(members, lines) {
+    const lineLabels = [...lines].map(l => l.replace(/_/g, ' '));
+    if (members.length === 1) {
+      return members[0].manifest.title;
+    }
+    const first = members[0].manifest.title;
+    if (lineLabels.length >= 3) {
+      return `Integrated Quantum Computing Solution Spanning ${lineLabels.slice(0, 3).join(', ')} — ${first.slice(0, 60)}`;
+    }
+    return `Coherent Patent Cluster: ${first.slice(0, 80)} (+${members.length - 1} related)`;
+  }
+
+  _synthesiseSummary(members, lines, concepts) {
+    const lineLabels = [...lines].map(l => l.replace(/_/g, ' '));
+    const parts = [
+      `This patent cluster groups ${members.length} patent-eligible document(s) into a coherent solution`,
+      `spanning the research line(s): ${lineLabels.join(', ')}.`,
+      ``,
+      `The cluster references ${concepts.size} shared knowledge-graph concepts:`,
+      [...concepts].slice(0, 10).map(c => `- ${c}`).join('\n'),
+      ``,
+      `Member documents:`,
+      ...members.map(m => `- [${m.manifest.researchLine ?? 'general'}] ${m.manifest.title}`),
+      ``,
+      `This cluster ensures that the proposed quantum-computing solution is not isolated:`,
+      `hardware (qubit/QEC) advances are enlaced with application (algorithm/simulation) advances,`,
+      `forming a complete path from physical qubits to useful computation.`,
+    ];
+    return parts.join('\n');
+  }
+
+  async _llmSynthesiseSummary(members, lines, concepts) {
+    if (!this.llm) return this._synthesiseSummary(members, lines, concepts);
+    const system = 'You are a patent-portfolio summariser. Produce a 3-paragraph executive summary of a patent cluster.';
+    const user = JSON.stringify({ members: members.map(m => m.manifest.title), lines, concepts: [...concepts] });
+    const r = await this.llm.chat(user, system, { task: 'patent_drafting' });
+    return r?.ok ? r.content : this._synthesiseSummary(members, lines, concepts);
+  }
+
+  filingReadyClusters() {
+    return [...this.clusters.values()].filter(c => c.filingReady);
+  }
+
+  stats() {
+    return {
+      totalClusters: this.clusters.size,
+      filingReady: this.filingReadyClusters().length,
+      totalMembers: [...this.clusters.values()].reduce((s, c) => s + c.memberIds.length, 0),
+    };
+  }
+}