quantum-spherifier 1.0.0

package/src/modules/CascadeMonitor.js

@@ -0,0 +1,84 @@
+/**
+ * CascadeMonitor.js — FUSIONARY (v1.0)
+ * Predictive, self-healing cascade monitor. Detects when neuron
+ * extinctions or layer failures are trending toward a cascade and
+ * injects learned stimulus patterns to recover.
+ */
+
+import { EventEmitter } from 'eventemitter3';
+
+export class CascadeMonitor extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.warnThreshold  = opts.warnThreshold  ?? 0.6;
+    this.criticalThreshold = opts.criticalThreshold ?? 0.85;
+    this.windowSize     = opts.windowSize ?? 50;
+    this.history        = [];
+    this.learnedPatterns = new Map();
+    this.cascadeRisk    = 0;
+  }
+
+  record(event) {
+    this.history.push({
+      timestamp: Date.now(),
+      ...event,
+    });
+    if (this.history.length > this.windowSize) this.history.shift();
+    this._updateRisk();
+  }
+
+  _updateRisk() {
+    if (this.history.length === 0) {
+      this.cascadeRisk = 0;
+      return;
+    }
+    // Risk = weighted combination of failure/extinction events
+    const recent = this.history.slice(-this.windowSize);
+    const extinctions = recent.filter(e => e.type === 'extinction').length;
+    const errors = recent.filter(e => e.type === 'error').length;
+    const successes = recent.filter(e => e.type === 'success').length;
+    const total = recent.length;
+    const failureRate = (extinctions + errors) / total;
+    const successRate = successes / total;
+
+    // EMA for smoothing
+    const alpha = 0.3;
+    this.cascadeRisk = (1 - alpha) * this.cascadeRisk + alpha * (failureRate * 0.8 + (1 - successRate) * 0.2);
+    this.cascadeRisk = Math.max(0, Math.min(1, this.cascadeRisk));
+
+    if (this.cascadeRisk > this.criticalThreshold) {
+      this.emit('critical', { risk: this.cascadeRisk, extinctions, errors });
+    } else if (this.cascadeRisk > this.warnThreshold) {
+      this.emit('warning', { risk: this.cascadeRisk, extinctions, errors });
+    }
+  }
+
+  /** Learn a stimulus pattern that previously led to success. */
+  learnPattern(name, pattern) {
+    this.learnedPatterns.set(name, {
+      pattern,
+      learnedAt: Date.now(),
+      hits: 0,
+    });
+    this.emit('patternLearned', { name });
+  }
+
+  /** Suggest a recovery pattern. */
+  suggestRecovery() {
+    if (this.learnedPatterns.size === 0) return null;
+    const entries = [...this.learnedPatterns.values()];
+    return entries[Math.floor(Math.random() * entries.length)].pattern;
+  }
+
+  getCascadeRiskHistory() {
+    return this.history.slice(-100);
+  }
+
+  status() {
+    return {
+      cascadeRisk: this.cascadeRisk,
+      historyLength: this.history.length,
+      learnedPatterns: this.learnedPatterns.size,
+    };
+  }
+}

package/src/modules/CitationGraph.js

@@ -0,0 +1,119 @@
+/**
+ * CitationGraph.js — FUSIONARY (v1.0)
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Tracks citation relationships between archived documents, external
+ * papers (arXiv, DOI), and KG concepts. Used by:
+ *   - PatentDraftAssistant to verify novelty against prior art
+ *   - HypothesisGenerator to identify orphan concepts (no citations)
+ *   - The web UI to render a citation network visualisation
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { v4 as uuidv4 } from 'uuid';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export class CitationGraph extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.storagePath = opts.storagePath ?? join(process.cwd(), 'data', 'citation_graph.json');
+    this.papers = new Map();   // id -> { id, title, doi, arxiv, year, authors, type }
+    this.citations = new Map(); // id -> { id, from, to, type: 'cite'|'extends'|'contradicts'|'patent_blocks' }
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+    if (existsSync(this.storagePath)) {
+      try {
+        const raw = readFileSync(this.storagePath, 'utf8');
+        const data = JSON.parse(raw);
+        for (const p of data.papers ?? []) this.papers.set(p.id, p);
+        for (const c of data.citations ?? []) this.citations.set(c.id, c);
+      } catch (err) {
+        this.emit('error', { stage: 'load', error: err.message });
+      }
+    }
+    this.initialized = true;
+  }
+
+  addPaper(opts = {}) {
+    const id = opts.id ?? `paper_${uuidv4().slice(0, 8)}`;
+    const paper = {
+      id,
+      title: opts.title ?? id,
+      doi: opts.doi ?? null,
+      arxiv: opts.arxiv ?? null,
+      year: opts.year ?? new Date().getFullYear(),
+      authors: Array.isArray(opts.authors) ? opts.authors : [],
+      type: opts.type ?? 'paper',  // paper | patent | fusionary_doc | book
+      url: opts.url ?? null,
+    };
+    this.papers.set(id, paper);
+    this.emit('paperAdded', paper);
+    return paper;
+  }
+
+  cite(opts = {}) {
+    const id = opts.id ?? uuidv4();
+    if (!this.papers.has(opts.from) || !this.papers.has(opts.to)) {
+      throw new Error('Citation endpoints must exist');
+    }
+    const c = {
+      id,
+      from: opts.from,
+      to: opts.to,
+      type: ['cite', 'extends', 'contradicts', 'patent_blocks', 'enables'].includes(opts.type) ? opts.type : 'cite',
+      context: opts.context ?? '',
+      createdAt: Date.now(),
+    };
+    this.citations.set(id, c);
+    this.emit('citationAdded', c);
+    return c;
+  }
+
+  /** Prior art blocking search — used by PatentDraftAssistant. */
+  priorArt(claimText) {
+    const results = [];
+    const text = (claimText ?? '').toLowerCase();
+    for (const paper of this.papers.values()) {
+      const title = (paper.title ?? '').toLowerCase();
+      // Very simple keyword match; LLM can refine later
+      const keywords = title.split(/\s+/).filter(w => w.length > 4).slice(0, 5);
+      const hits = keywords.filter(k => text.includes(k));
+      if (hits.length >= 2) {
+        results.push({ paper, hits, score: hits.length / keywords.length });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score);
+  }
+
+  /** Orphan concepts — papers with no inbound citations (under-discovered). */
+  orphans() {
+    const cited = new Set();
+    for (const c of this.citations.values()) cited.add(c.to);
+    return [...this.papers.values()].filter(p => !cited.has(p.id));
+  }
+
+  async persist() {
+    const dir = dirname(this.storagePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const data = {
+      version: '1.0',
+      updatedAt: Date.now(),
+      papers: [...this.papers.values()],
+      citations: [...this.citations.values()],
+    };
+    writeFileSync(this.storagePath, JSON.stringify(data, null, 2));
+    this.emit('persisted', { path: this.storagePath });
+  }
+
+  stats() {
+    return {
+      papers: this.papers.size,
+      citations: this.citations.size,
+      orphans: this.orphans().length,
+    };
+  }
+}

package/src/modules/DocumentArchivist.js

@@ -0,0 +1,326 @@
+/**
+ * DocumentArchivist.js — quantum-spherifier (v1.0)
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Hierarchical document archive manager. Stores every artifact produced
+ * by qSpherifier under /research/<category>/<topic>/<id>/ with a manifest.json
+ * that records metadata, tags, references, patent-eligibility flags, and
+ * cross-links to other documents.
+ *
+ * Categories:
+ *   - topics/         Background research notes on a specific concept
+ *   - hypotheses/     Formalised hypothesis records (LLM or template)
+ *   - designs/        Quantum-processor or algorithm design proposals
+ *   - simulations/    Numerical simulation reports (error rates, resource estimates)
+ *   - patents/        Patent application drafts (claims + drawings + spec)
+ *   - cross_refs/     Cross-reference indices that link documents together
+ *   - indices/        Top-level indices (master.md, patent_queue.md, ...)
+ *
+ * Each document directory contains:
+ *   - manifest.json   – machine-readable metadata (with crossLinks array)
+ *   - main.tex        – LaTeX source (when applicable)
+ *   - main.pdf        – compiled PDF (when LaTeX is available)
+ *   - figures/        – embedded figures
+ *   - references.bib  – BibTeX bibliography
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { v4 as uuidv4 } from 'uuid';
+import {
+  existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, statSync,
+} from 'node:fs';
+import { join, dirname } from 'node:path';
+
+const CATEGORIES = Object.freeze([
+  'topics',
+  'hypotheses',
+  'designs',
+  'simulations',
+  'patents',
+  'cross_refs',
+  'indices',
+]);
+
+const TAG_PALETTE = new Set([
+  // Research lines
+  'qec', 'qubits', 'algorithms', 'molecular_simulation',
+  // QEC-specific
+  'surface_code', 'qldpc', 'color_code', 'magic_state', 'bacon_shor', 'threshold',
+  // Qubit modalities
+  'transmon', 'fluxonium', 'cat_qubit', 'trapped_ion', 'neutral_atom', 'photonic',
+  'topological', 'silicon_spin', 'nv_center',
+  // Algorithms
+  'shor', 'grover', 'vqe', 'qaoa', 'qft', 'hhl', 'qpe', 'qml', 'qsvt',
+  // Simulation
+  'fermionic', 'femoco', 'catalysis', 'drug_discovery', 'materials', 'trotter', 'qubitization',
+  // Hardware anchors
+  'ibm', 'google', 'ionq', 'quantinuum', 'quera', 'atom_computing', 'psiquantum', 'xanadu', 'microsoft',
+  // Status / patent
+  'patent_ready', 'patent_pending', 'intermediate_result', 'final_result',
+  'cross_cutting', 'baseline_knowledge', 'human_directed', 'cross_linked',
+]);
+
+export class DocumentArchivist extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.rootDir = opts.rootDir ?? join(process.cwd(), 'research');
+    this.ensureLayout();
+    this._indexCache = null;
+  }
+
+  ensureLayout() {
+    if (!existsSync(this.rootDir)) mkdirSync(this.rootDir, { recursive: true });
+    for (const cat of CATEGORIES) {
+      const dir = join(this.rootDir, cat);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    }
+    // Create per-line subdirectories under topics
+    for (const line of ['qec', 'qubits', 'algorithms', 'molecular_simulation']) {
+      const dir = join(this.rootDir, 'topics', line);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    }
+    // Master index file
+    const masterIndex = join(this.rootDir, 'INDEX.md');
+    if (!existsSync(masterIndex)) {
+      writeFileSync(masterIndex, [
+        '# quantum-spherifier Research Archive — Master Index',
+        '',
+        '> Auto-generated by DocumentArchivist. Do not edit by hand;',
+        '> run `npm run archive` to regenerate.',
+        '',
+        '## Categories',
+        '',
+        ...CATEGORIES.map(c => `- [${c}](./${c}/)`),
+        '',
+        '## Research Lines',
+        '',
+        '- [Quantum Error Correction](./topics/qec/)',
+        '- [New Qubit Modalities](./topics/qubits/)',
+        '- [Quantum Algorithms](./topics/algorithms/)',
+        '- [Molecular Simulation](./topics/molecular_simulation/)',
+        '',
+        '## Patent Queue',
+        '',
+        'See [indices/patent_queue.md](./indices/patent_queue.md) for documents',
+        'flagged as patent-ready.',
+        '',
+      ].join('\n'));
+    }
+  }
+
+  /**
+   * Archive a document.
+   * @param {object} doc
+   * @returns {object} record – Manifest record with paths
+   */
+  archive(doc) {
+    if (!CATEGORIES.includes(doc.category)) {
+      throw new Error(`Invalid category: ${doc.category}. Must be one of ${CATEGORIES.join(', ')}`);
+    }
+    const id = doc.id ?? `doc_${uuidv4().slice(0, 8)}`;
+    const topic = doc.topic ? doc.topic.replace(/[^a-zA-Z0-9_-]/g, '_') : 'general';
+    const dir = join(this.rootDir, doc.category, topic, id);
+    mkdirSync(dir, { recursive: true });
+    mkdirSync(join(dir, 'figures'), { recursive: true });
+
+    // Sanitise tags
+    const tags = Array.isArray(doc.tags)
+      ? doc.tags.filter(t => TAG_PALETTE.has(t) || t.startsWith('custom:'))
+      : [];
+
+    const manifest = {
+      id,
+      version: '1.0',
+      title: doc.title ?? 'Untitled',
+      category: doc.category,
+      topic,
+      researchLine: doc.researchLine ?? null,
+      tags,
+      references: Array.isArray(doc.references) ? doc.references : [],
+      crossLinks: Array.isArray(doc.crossLinks) ? doc.crossLinks : [],
+      patent: doc.patent ?? { eligible: false, claims: [] },
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      extra: doc.extra ?? {},
+      files: {},
+    };
+
+    if (doc.latexSource) {
+      writeFileSync(join(dir, 'main.tex'), doc.latexSource);
+      manifest.files.latex = 'main.tex';
+    }
+    if (doc.markdownSource) {
+      writeFileSync(join(dir, 'main.md'), doc.markdownSource);
+      manifest.files.markdown = 'main.md';
+    }
+    if (doc.bibliography) {
+      writeFileSync(join(dir, 'references.bib'), doc.bibliography);
+      manifest.files.bibliography = 'references.bib';
+    }
+
+    writeFileSync(join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+
+    this._indexCache = null;
+    this.emit('archived', { id, dir, manifest });
+    return { id, dir, manifest };
+  }
+
+  /** Recursively list all manifests in a category. */
+  list(category = null) {
+    const results = [];
+    const cats = category ? [category] : CATEGORIES;
+    for (const cat of cats) {
+      const catDir = join(this.rootDir, cat);
+      if (!existsSync(catDir)) continue;
+      this._walkManifests(catDir, results);
+    }
+    return results;
+  }
+
+  _walkManifests(dir, results) {
+    let entries;
+    try { entries = readdirSync(dir); } catch { return; }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      let stat;
+      try { stat = statSync(fullPath); } catch { continue; }
+      if (stat.isDirectory()) {
+        this._walkManifests(fullPath, results);
+      } else if (entry === 'manifest.json') {
+        try {
+          const manifest = JSON.parse(readFileSync(fullPath, 'utf8'));
+          results.push({ manifest, dir: dirname(fullPath) });
+        } catch (err) {
+          this.emit('warning', { stage: 'list', file: fullPath, error: err.message });
+        }
+      }
+    }
+  }
+
+  /** Find documents eligible for patent filing. */
+  patentQueue() {
+    return this.list().filter(r => r.manifest.patent?.eligible === true);
+  }
+
+  /** Find documents by research line. */
+  byResearchLine(line) {
+    return this.list().filter(r => r.manifest.researchLine === line);
+  }
+
+  /** Full-text search over titles and tags. */
+  search(query) {
+    const q = (query ?? '').toLowerCase().trim();
+    if (!q) return [];
+    return this.list().filter(r => {
+      const m = r.manifest;
+      const haystack = `${m.title} ${m.tags.join(' ')} ${m.topic}`.toLowerCase();
+      return haystack.includes(q);
+    });
+  }
+
+  /** Add a cross-link between two documents. */
+  addCrossLink(fromId, toId, relationship = 'builds_on') {
+    const from = this.list().find(r => r.manifest.id === fromId);
+    const to = this.list().find(r => r.manifest.id === toId);
+    if (!from || !to) return false;
+    from.manifest.crossLinks = from.manifest.crossLinks ?? [];
+    from.manifest.crossLinks.push({ to: toId, relationship, addedAt: Date.now() });
+    from.manifest.updatedAt = Date.now();
+    writeFileSync(join(from.dir, 'manifest.json'), JSON.stringify(from.manifest, null, 2));
+    this.emit('crossLinkAdded', { from: fromId, to: toId, relationship });
+    return true;
+  }
+
+  /** Regenerate the master INDEX.md and the patent queue. */
+  rebuildIndices() {
+    const all = this.list();
+    const byCategory = new Map();
+    for (const r of all) {
+      if (!byCategory.has(r.manifest.category)) byCategory.set(r.manifest.category, []);
+      byCategory.get(r.manifest.category).push(r);
+    }
+
+    const lines = [
+      '# quantum-spherifier Research Archive — Master Index',
+      '',
+      `> Auto-generated by DocumentArchivist on ${new Date().toISOString()}`,
+      `> Total documents: ${all.length}`,
+      '',
+      '## Categories',
+      '',
+      ...CATEGORIES.map(c => {
+        const count = byCategory.get(c)?.length ?? 0;
+        return `- [${c}](./${c}/) — ${count} document${count === 1 ? '' : 's'}`;
+      }),
+      '',
+      '## By Research Line',
+      '',
+      ...['qec', 'qubits', 'algorithms', 'molecular_simulation'].map(line => {
+        const count = all.filter(r => r.manifest.researchLine === line).length;
+        return `- **${line}**: ${count} document${count === 1 ? '' : 's'}`;
+      }),
+      '',
+      '## Patent Queue',
+      '',
+      `See [indices/patent_queue.md](./indices/patent_queue.md) for ${this.patentQueue().length} patent-ready documents.`,
+      '',
+      '## Recent Documents (last 20)',
+      '',
+      ...all
+        .sort((a, b) => b.manifest.createdAt - a.manifest.createdAt)
+        .slice(0, 20)
+        .map(r => {
+          const m = r.manifest;
+          const date = new Date(m.createdAt).toISOString().slice(0, 10);
+          const line = m.researchLine ? `[${m.researchLine}]` : '';
+          return `- ${date} ${line} [${m.title}](./${m.category}/${m.topic}/${m.id}/)  \`${m.tags.join(', ')}\``;
+        }),
+      '',
+    ];
+    writeFileSync(join(this.rootDir, 'INDEX.md'), lines.join('\n'));
+
+    // Patent queue
+    const pq = this.patentQueue();
+    const pqLines = [
+      '# quantum-spherifier Patent Queue',
+      '',
+      `> ${pq.length} document${pq.length === 1 ? '' : 's'} flagged as patent-eligible.`,
+      '',
+      '| Date | Title | Line | Topic | Claims | Path |',
+      '|------|-------|------|-------|--------|------|',
+      ...pq.map(r => {
+        const m = r.manifest;
+        const date = new Date(m.createdAt).toISOString().slice(0, 10);
+        const claims = (m.patent.claims ?? []).length;
+        const path = `../${m.category}/${m.topic}/${m.id}/`;
+        return `| ${date} | ${m.title} | ${m.researchLine ?? '—'} | ${m.topic} | ${claims} | [open](./${path}) |`;
+      }),
+      '',
+    ];
+    mkdirSync(join(this.rootDir, 'indices'), { recursive: true });
+    writeFileSync(join(this.rootDir, 'indices', 'patent_queue.md'), pqLines.join('\n'));
+
+    this.emit('indicesRebuilt', { total: all.length, patents: pq.length });
+    return { total: all.length, patents: pq.length };
+  }
+
+  stats() {
+    const all = this.list();
+    const byCategory = {};
+    for (const cat of CATEGORIES) byCategory[cat] = 0;
+    for (const r of all) byCategory[r.manifest.category] = (byCategory[r.manifest.category] ?? 0) + 1;
+    const byLine = {};
+    for (const line of ['qec', 'qubits', 'algorithms', 'molecular_simulation']) {
+      byLine[line] = all.filter(r => r.manifest.researchLine === line).length;
+    }
+    return {
+      total: all.length,
+      byCategory,
+      byResearchLine: byLine,
+      patentEligible: this.patentQueue().length,
+      crossLinked: all.filter(r => (r.manifest.crossLinks ?? []).length > 0).length,
+    };
+  }
+}
+
+export { CATEGORIES, TAG_PALETTE };