fuli-context 0.4.0 → 0.7.2

package/src/storage/sqlite/facts-repository.js

@@ -1,146 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-import { FactStatus, nowIso } from '../../models.js';
-import { validateFactRecord } from '../record-validation.js';
-import { FactSearchRepository } from './fact-search-repository.js';
-import { mapFact } from './mapper.js';
-
-export class FactsRepository {
-  constructor(db) {
-    this.factSearch = new FactSearchRepository(db);
-    this.insertStatement = db.prepare(`
-      INSERT INTO facts (
-        id, space_id, subject, predicate, object, source_episode_id, status,
-        confidence, sensitivity, scope, valid_at, invalid_at, replaced_by_fact_id
-      ) VALUES (
-        @id, @spaceId, @subject, @predicate, @object, @sourceEpisodeId, @status,
-        @confidence, @sensitivity, @scope, @validAt, @invalidAt, @replacedByFactId
-      )
-    `);
-    this.getStatement = db.prepare('SELECT * FROM facts WHERE id = ?');
-    this.updateStatement = db.prepare(`
-      UPDATE facts SET
-        space_id = @spaceId,
-        subject = @subject,
-        predicate = @predicate,
-        object = @object,
-        source_episode_id = @sourceEpisodeId,
-        status = @status,
-        confidence = @confidence,
-        sensitivity = @sensitivity,
-        scope = @scope,
-        valid_at = @validAt,
-        invalid_at = @invalidAt,
-        replaced_by_fact_id = @replacedByFactId
-      WHERE id = @id
-    `);
-    this.currentStatement = db.prepare(`
-      SELECT * FROM facts
-      WHERE space_id = ?
-        AND invalid_at IS NULL
-        AND status NOT IN ('rejected', 'deprecated')
-      ORDER BY rowid
-    `);
-    this.currentListStatement = db.prepare(`
-      SELECT * FROM facts
-      WHERE invalid_at IS NULL AND status NOT IN ('rejected', 'deprecated')
-      ORDER BY rowid
-    `);
-    this.fullListStatement = db.prepare('SELECT * FROM facts ORDER BY rowid');
-    this.timelineStatement = db.prepare(`
-      SELECT * FROM facts
-      WHERE space_id = ? AND subject = ?
-      ORDER BY valid_at, rowid
-    `);
-    this.replaceLinkStatement = db.prepare(`
-      UPDATE facts SET replaced_by_fact_id = ? WHERE id = ?
-    `);
-    this.deleteStatement = db.prepare('DELETE FROM facts');
-  }
-
-  add(fact) {
-    if (fact.id && this.get(fact.id)) {
-      throw new Error(`Duplicate fact id: ${fact.id}`);
-    }
-
-    const stored = {
-      id: fact.id || randomUUID(),
-      spaceId: fact.spaceId,
-      subject: fact.subject,
-      predicate: fact.predicate,
-      object: fact.object,
-      sourceEpisodeId: fact.sourceEpisodeId,
-      status: fact.status ?? FactStatus.CONFIRMED,
-      confidence: fact.confidence ?? 1,
-      sensitivity: fact.sensitivity ?? 'normal',
-      scope: fact.scope ?? 'personal',
-      validAt: fact.validAt ?? nowIso(),
-      invalidAt: fact.invalidAt ?? null,
-      replacedByFactId: fact.replacedByFactId ?? null
-    };
-    validateFactRecord(stored);
-    this.insertStatement.run(stored);
-    return this.get(stored.id);
-  }
-
-  get(id) {
-    return mapFact(this.getStatement.get(id));
-  }
-
-  update(id, updates) {
-    const existing = this.get(id);
-    if (!existing) throw new Error(`Fact not found: ${id}`);
-
-    const stored = { ...existing, ...updates, id };
-    validateFactRecord(stored);
-    this.updateStatement.run(stored);
-    return this.get(id);
-  }
-
-  invalidate(id, replacedByFactId = null) {
-    const fact = this.get(id);
-    if (!fact || fact.invalidAt) return;
-    this.updateStatement.run({
-      ...fact,
-      invalidAt: nowIso(),
-      replacedByFactId
-    });
-  }
-
-  current(spaceId) {
-    return this.currentStatement.all(spaceId).map(mapFact);
-  }
-
-  list({ includeHistorical = false } = {}) {
-    const statement = includeHistorical ? this.fullListStatement : this.currentListStatement;
-    return statement.all().map(mapFact);
-  }
-
-  timeline(spaceId, subject) {
-    return this.timelineStatement.all(spaceId, subject).map(mapFact);
-  }
-
-  search(spaceIds, query, options = {}) {
-    return this.factSearch.search(spaceIds, query, options);
-  }
-
-  searchPage(spaceIds, query, options = {}) {
-    return this.factSearch.searchPage(spaceIds, query, options);
-  }
-
-  insertSnapshot(fact, { deferReplacement = false } = {}) {
-    validateFactRecord(fact);
-    this.insertStatement.run({
-      ...fact,
-      replacedByFactId: deferReplacement ? null : fact.replacedByFactId
-    });
-  }
-
-  restoreReplacement(id, replacedByFactId) {
-    this.replaceLinkStatement.run(replacedByFactId, id);
-  }
-
-  deleteAll() {
-    this.deleteStatement.run();
-  }
-}

package/src/storage/sqlite/imports-repository.js

@@ -1,39 +0,0 @@
-import { mapImport } from './mapper.js';
-
-export class ImportsRepository {
-  constructor(db) {
-    this.insertStatement = db.prepare(`
-      INSERT INTO imports (content_hash, source_path, imported_at)
-      VALUES (@contentHash, @sourcePath, @importedAt)
-    `);
-    this.hasStatement = db.prepare(`
-      SELECT 1 FROM imports WHERE content_hash = ?
-    `);
-    this.listStatement = db.prepare('SELECT * FROM imports ORDER BY rowid');
-    this.deleteStatement = db.prepare('DELETE FROM imports');
-  }
-
-  has(contentHash) {
-    return this.hasStatement.get(contentHash) !== undefined;
-  }
-
-  record(record) {
-    if (this.has(record.contentHash)) {
-      throw new Error(`Duplicate import content hash: ${record.contentHash}`);
-    }
-    this.insertStatement.run(record);
-    return { ...record };
-  }
-
-  listAll() {
-    return this.listStatement.all().map(mapImport);
-  }
-
-  insertSnapshot(record) {
-    this.insertStatement.run(record);
-  }
-
-  deleteAll() {
-    this.deleteStatement.run();
-  }
-}

package/src/storage/sqlite/mapper.js

@@ -1,84 +0,0 @@
-export function mapSpace(row) {
-  return row ? {
-    id: row.id,
-    name: row.name,
-    kind: row.kind,
-    description: row.description,
-    createdAt: row.created_at
-  } : null;
-}
-
-export function mapSubscription(row) {
-  return row ? {
-    personalSpaceId: row.personal_space_id,
-    spaceId: row.space_id,
-    mode: row.mode,
-    createdAt: row.created_at
-  } : null;
-}
-
-export function mapEpisode(row) {
-  return row ? {
-    id: row.id,
-    spaceId: row.space_id,
-    sourceKind: row.source_kind,
-    body: row.body,
-    sourceUri: row.source_uri,
-    metadata: JSON.parse(row.metadata_json),
-    createdAt: row.created_at
-  } : null;
-}
-
-export function mapFact(row) {
-  return row ? {
-    id: row.id,
-    spaceId: row.space_id,
-    subject: row.subject,
-    predicate: row.predicate,
-    object: row.object,
-    sourceEpisodeId: row.source_episode_id,
-    status: row.status,
-    confidence: row.confidence,
-    sensitivity: row.sensitivity,
-    scope: row.scope,
-    validAt: row.valid_at,
-    invalidAt: row.invalid_at,
-    replacedByFactId: row.replaced_by_fact_id
-  } : null;
-}
-
-export function mapCandidate(row) {
-  return row ? {
-    id: row.id,
-    personalSpaceId: row.personal_space_id,
-    targetSpaceId: row.target_space_id,
-    episodeId: row.episode_id,
-    reason: row.reason,
-    status: row.status,
-    createdAt: row.created_at,
-    decidedAt: row.decided_at
-  } : null;
-}
-
-export function mapOutbox(row) {
-  return row ? {
-    id: row.id,
-    kind: row.kind,
-    aggregateId: row.aggregate_id,
-    payload: JSON.parse(row.payload_json),
-    status: row.status,
-    attempts: row.attempts,
-    nextAttemptAt: row.next_attempt_at,
-    createdAt: row.created_at,
-    sentAt: row.sent_at,
-    lastError: row.last_error
-  } : null;
-}
-
-export function mapImport(row) {
-  return row ? {
-    contentHash: row.content_hash,
-    sourcePath: row.source_path,
-    importedAt: row.imported_at
-  } : null;
-}

package/src/storage/sqlite/open-database.js

@@ -1,15 +0,0 @@
-import { mkdirSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-
-import Database from 'better-sqlite3';
-
-export function openDatabase(filePath) {
-  if (isFileDatabase(filePath)) {
-    mkdirSync(dirname(resolve(filePath)), { recursive: true });
-  }
-  return new Database(filePath);
-}
-
-export function isFileDatabase(filePath) {
-  return typeof filePath === 'string' && filePath !== ':memory:' && filePath !== '';
-}

package/src/storage/sqlite/outbox-repository.js

@@ -1,103 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-import { nowIso } from '../../models.js';
-import { validateOutboxRecord } from '../record-validation.js';
-import { mapOutbox } from './mapper.js';
-
-export class OutboxRepository {
-  constructor(db) {
-    this.insertStatement = db.prepare(`
-      INSERT INTO outbox (
-        id, kind, aggregate_id, payload_json, status, attempts,
-        next_attempt_at, created_at, sent_at, last_error
-      ) VALUES (
-        @id, @kind, @aggregateId, @payloadJson, @status, @attempts,
-        @nextAttemptAt, @createdAt, @sentAt, @lastError
-      )
-    `);
-    this.getStatement = db.prepare('SELECT * FROM outbox WHERE id = ?');
-    this.listStatement = db.prepare('SELECT * FROM outbox ORDER BY rowid');
-    this.pendingStatement = db.prepare(`
-      SELECT * FROM outbox
-      WHERE status = 'pending'
-        AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
-      ORDER BY created_at, rowid
-    `);
-    this.markSentStatement = db.prepare(`
-      UPDATE outbox SET
-        status = 'sent', next_attempt_at = NULL, sent_at = ?, last_error = NULL
-      WHERE id = ?
-    `);
-    this.markFailedStatement = db.prepare(`
-      UPDATE outbox SET
-        status = 'pending', attempts = attempts + 1,
-        next_attempt_at = ?, last_error = ?
-      WHERE id = ?
-    `);
-    this.deleteStatement = db.prepare('DELETE FROM outbox');
-  }
-
-  enqueue(entry) {
-    if (entry.id && this.get(entry.id)) {
-      throw new Error(`Duplicate outbox id: ${entry.id}`);
-    }
-
-    const stored = {
-      id: entry.id || randomUUID(),
-      kind: entry.kind,
-      aggregateId: entry.aggregateId,
-      payloadJson: JSON.stringify(entry.payload),
-      status: entry.status ?? 'pending',
-      attempts: entry.attempts ?? 0,
-      nextAttemptAt: entry.nextAttemptAt ?? null,
-      createdAt: entry.createdAt ?? nowIso(),
-      sentAt: entry.sentAt ?? null,
-      lastError: entry.lastError ?? null
-    };
-    validateOutboxRecord(stored);
-    this.insertStatement.run(stored);
-    return this.get(stored.id);
-  }
-
-  listPending(at = nowIso()) {
-    return this.pendingStatement.all(at).map(mapOutbox);
-  }
-
-  markSent(id, sentAt = nowIso()) {
-    this.require(id);
-    this.markSentStatement.run(sentAt, id);
-    return this.get(id);
-  }
-
-  markFailed(id, error, nextAttemptAt = null) {
-    this.require(id);
-    this.markFailedStatement.run(nextAttemptAt, error, id);
-    return this.get(id);
-  }
-
-  get(id) {
-    return mapOutbox(this.getStatement.get(id));
-  }
-
-  listAll() {
-    return this.listStatement.all().map(mapOutbox);
-  }
-
-  insertSnapshot(entry) {
-    validateOutboxRecord(entry);
-    this.insertStatement.run({
-      ...entry,
-      payloadJson: JSON.stringify(entry.payload)
-    });
-  }
-
-  deleteAll() {
-    this.deleteStatement.run();
-  }
-
-  require(id) {
-    const row = this.get(id);
-    if (!row) throw new Error(`Outbox row not found: ${id}`);
-    return row;
-  }
-}

package/src/storage/sqlite/snapshot-repository.js

@@ -1,69 +0,0 @@
-import { cloneSnapshot, normalizeSnapshot } from '../snapshot-defaults.js';
-
-export class SnapshotRepository {
-  constructor(db, repositories) {
-    this.db = db;
-    this.repositories = repositories;
-  }
-
-  export() {
-    const repositories = this.repositories;
-    return cloneSnapshot({
-      spaces: repositories.spaces.list(),
-      subscriptions: repositories.subscriptions.list(),
-      episodes: repositories.episodes.list(),
-      facts: repositories.facts.list({ includeHistorical: true }),
-      candidates: repositories.candidates.list(),
-      outbox: repositories.outbox.listAll(),
-      imports: repositories.imports.listAll()
-    });
-  }
-
-  import(snapshot) {
-    const current = this.export();
-    const normalized = normalizeSnapshot(snapshot, {
-      outbox: current.outbox,
-      imports: current.imports
-    });
-    const replaceOutbox = Object.hasOwn(snapshot, 'outbox');
-    const replaceImports = Object.hasOwn(snapshot, 'imports');
-    const apply = () => this.replace(normalized, { replaceOutbox, replaceImports });
-
-    if (this.db.inTransaction) apply();
-    else this.db.transaction(apply)();
-  }
-
-  replace(snapshot, { replaceOutbox, replaceImports }) {
-    const repositories = this.repositories;
-    repositories.subscriptions.deleteAll();
-    repositories.candidates.deleteAll();
-    repositories.facts.deleteAll();
-    repositories.episodes.deleteAll();
-    if (replaceOutbox) repositories.outbox.deleteAll();
-    if (replaceImports) repositories.imports.deleteAll();
-    repositories.spaces.deleteAll();
-
-    for (const space of snapshot.spaces) repositories.spaces.insertSnapshot(space);
-    for (const subscription of snapshot.subscriptions) {
-      repositories.subscriptions.insertSnapshot(subscription);
-    }
-    for (const episode of snapshot.episodes) repositories.episodes.insertSnapshot(episode);
-    for (const fact of snapshot.facts) {
-      repositories.facts.insertSnapshot(fact, { deferReplacement: true });
-    }
-    for (const fact of snapshot.facts) {
-      if (fact.replacedByFactId) {
-        repositories.facts.restoreReplacement(fact.id, fact.replacedByFactId);
-      }
-    }
-    for (const candidate of snapshot.candidates) {
-      repositories.candidates.insertSnapshot(candidate);
-    }
-    if (replaceOutbox) {
-      for (const entry of snapshot.outbox) repositories.outbox.insertSnapshot(entry);
-    }
-    if (replaceImports) {
-      for (const record of snapshot.imports) repositories.imports.insertSnapshot(record);
-    }
-  }
-}

package/src/storage/sqlite/spaces-repository.js

@@ -1,52 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-import { nowIso } from '../../models.js';
-import { mapSpace } from './mapper.js';
-
-export class SpacesRepository {
-  constructor(db) {
-    this.insertStatement = db.prepare(`
-      INSERT INTO spaces (id, name, kind, description, created_at)
-      VALUES (@id, @name, @kind, @description, @createdAt)
-    `);
-    this.listStatement = db.prepare('SELECT * FROM spaces ORDER BY rowid');
-    this.findByNameStatement = db.prepare('SELECT * FROM spaces WHERE name = ?');
-    this.getStatement = db.prepare('SELECT * FROM spaces WHERE id = ?');
-    this.deleteStatement = db.prepare('DELETE FROM spaces');
-  }
-
-  create(name, kind, description = null) {
-    const existing = this.findByName(name);
-    if (existing) return existing;
-
-    const space = {
-      id: randomUUID(),
-      name,
-      kind,
-      description,
-      createdAt: nowIso()
-    };
-    this.insertStatement.run(space);
-    return this.get(space.id);
-  }
-
-  list() {
-    return this.listStatement.all().map(mapSpace);
-  }
-
-  findByName(name) {
-    return mapSpace(this.findByNameStatement.get(name));
-  }
-
-  get(id) {
-    return mapSpace(this.getStatement.get(id));
-  }
-
-  insertSnapshot(space) {
-    this.insertStatement.run(space);
-  }
-
-  deleteAll() {
-    this.deleteStatement.run();
-  }
-}

package/src/storage/sqlite/subscriptions-repository.js

@@ -1,54 +0,0 @@
-import { nowIso } from '../../models.js';
-import { mapSubscription } from './mapper.js';
-
-export class SubscriptionsRepository {
-  constructor(db) {
-    this.insertStatement = db.prepare(`
-      INSERT INTO subscriptions (personal_space_id, space_id, mode, created_at)
-      VALUES (@personalSpaceId, @spaceId, @mode, @createdAt)
-    `);
-    this.getStatement = db.prepare(`
-      SELECT * FROM subscriptions
-      WHERE personal_space_id = ? AND space_id = ?
-    `);
-    this.listStatement = db.prepare('SELECT * FROM subscriptions ORDER BY rowid');
-    this.forPersonalSpaceStatement = db.prepare(`
-      SELECT * FROM subscriptions WHERE personal_space_id = ? ORDER BY rowid
-    `);
-    this.deleteStatement = db.prepare('DELETE FROM subscriptions');
-  }
-
-  subscribe(personalSpaceId, spaceId, mode = 'latest') {
-    const existing = this.get(personalSpaceId, spaceId);
-    if (existing) return existing;
-
-    const subscription = {
-      personalSpaceId,
-      spaceId,
-      mode,
-      createdAt: nowIso()
-    };
-    this.insertStatement.run(subscription);
-    return this.get(personalSpaceId, spaceId);
-  }
-
-  list() {
-    return this.listStatement.all().map(mapSubscription);
-  }
-
-  forPersonalSpace(personalSpaceId) {
-    return this.forPersonalSpaceStatement.all(personalSpaceId).map(mapSubscription);
-  }
-
-  insertSnapshot(subscription) {
-    this.insertStatement.run(subscription);
-  }
-
-  deleteAll() {
-    this.deleteStatement.run();
-  }
-
-  get(personalSpaceId, spaceId) {
-    return mapSubscription(this.getStatement.get(personalSpaceId, spaceId));
-  }
-}