march-cli 0.1.22 → 0.1.23

package/src/memory/graph.mjs

@@ -1,282 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { ROOT_NODE_UUID } from "./database.mjs";
-import {
-  getChildren,
-  getMemoryByPath,
-  getRecentMemories,
-} from "./graph/graph-read.mjs";
-import { getGraphDiagnostics } from "./graph/graph-diagnostics.mjs";
-import {
-  cascadeCreatePaths,
-  cascadeDeleteNode,
-  deprecateNodeMemories,
-} from "./graph/graph-cascades.mjs";
-import { removeGraphPath } from "./graph/graph-path-removal.mjs";
-import {
-  graphUri,
-  leafName,
-  pathExists,
-} from "./graph/graph-path-utils.mjs";
-import {
-  ensureNode,
-  getNextChildNumber,
-  getOrCreateEdge,
-  insertMemory,
-  insertPath,
-  resolveGraphPath,
-  wouldCreateCycle,
-} from "./graph/graph-primitives.mjs";
-
-export class GraphService {
-  constructor(db, { changesetStore = null, searchIndexer = null, namespace = "" } = {}) {
-    this.db = db;
-    this.changesetStore = changesetStore;
-    this.searchIndexer = searchIndexer;
-    this.namespace = namespace;
-  }
-
-  /**
-   * Resolve namespace: explicit arg takes precedence, then instance default.
-   */
-  #ns(explicit = undefined) {
-    return explicit !== undefined ? explicit : this.namespace;
-  }
-
-  // ═══════════════════════════════════════════════════════════════════
-  // Read Operations
-  // ═══════════════════════════════════════════════════════════════════
-
-  getMemoryByPath(path, domain = "core", namespace = "") {
-    return getMemoryByPath(this.db, path, domain, namespace);
-  }
-
-  getChildren(nodeUuid = ROOT_NODE_UUID, contextDomain = null, contextPath = null, namespace = "") {
-    return getChildren(this.db, nodeUuid, contextDomain, contextPath, this.#ns(namespace));
-  }
-
-  getRecentMemories(limit = 10, namespace = "") {
-    return getRecentMemories(this.db, limit, namespace);
-  }
-
-  resolvePath(path, domain = "core", namespace = "") {
-    return resolveGraphPath(this.db, path, domain, namespace);
-  }
-
-  getPathsForNode(nodeUuid, namespace = "") {
-    return this.db.prepare(
-      "SELECT * FROM paths WHERE node_uuid = ? AND namespace = ?"
-    ).all(nodeUuid, namespace);
-  }
-
-  getCurrentMemory(nodeUuid) {
-    return this.db.prepare(
-      "SELECT * FROM memories WHERE node_uuid = ? AND deprecated = 0 ORDER BY id DESC LIMIT 1"
-    ).get(nodeUuid);
-  }
-
-  touchNode(nodeUuid) {
-    this.db.prepare(
-      "UPDATE nodes SET last_accessed_at = datetime('now') WHERE uuid = ?"
-    ).run(nodeUuid);
-  }
-
-  getDiagnostics(namespace = "", daysStale = 30, maxChildren = 10) {
-    return getGraphDiagnostics(this.db, namespace, daysStale, maxChildren);
-  }
-
-  cascadeDeleteNode(nodeUuid) {
-    return cascadeDeleteNode(this.db, nodeUuid);
-  }
-
-  #createEdgeWithPaths(parentUuid, childUuid, name, domain, path, priority = 0, disclosure = null, namespace = "") {
-    const { edge, created } = getOrCreateEdge(this.db, parentUuid, childUuid, name, priority, disclosure);
-    insertPath(this.db, namespace, domain, path, edge.id, childUuid);
-    cascadeCreatePaths(this.db, childUuid, domain, path, namespace);
-    return { edge, edge_id: edge.id, edge_created: created };
-  }
-
-  // ═══════════════════════════════════════════════════════════════════
-  // Public Write API
-  // ═══════════════════════════════════════════════════════════════════
-
-  createMemory(parentPath, content, priority, { title = null, disclosure = null, domain = "core", namespace = "" } = {}) {
-    const parentUuid = parentPath === ""
-      ? ROOT_NODE_UUID
-      : resolveGraphPath(this.db, parentPath, domain, namespace)?.node_uuid;
-
-    if (!parentUuid && parentPath !== "") {
-      throw new Error(`Parent '${domain}://${parentPath}' does not exist.`);
-    }
-
-    const finalPath = title
-      ? (parentPath ? `${parentPath}/${title}` : title)
-      : `${parentPath ? parentPath + "/" : ""}${getNextChildNumber(this.db, parentUuid, this.#ns(namespace))}`;
-
-    if (pathExists(this.db, namespace, domain, finalPath)) throw new Error(`Path '${graphUri(domain, finalPath)}' already exists`);
-
-    const newUuid = randomUUID();
-    ensureNode(this.db, newUuid);
-    const memory = insertMemory(this.db, newUuid, content);
-    const edgeName = title ?? leafName(finalPath);
-
-    const created = this.#createEdgeWithPaths(parentUuid, newUuid, edgeName, domain, finalPath, priority, disclosure, namespace);
-
-    if (this.changesetStore) {
-      this.changesetStore.record({ memoryId: memory.id, nodeUuid: newUuid, beforeContent: null, afterContent: content });
-    }
-    if (this.searchIndexer) {
-      this.searchIndexer.index(newUuid, content, namespace);
-    }
-
-    return {
-      id: memory.id, node_uuid: newUuid, domain, path: finalPath,
-      uri: graphUri(domain, finalPath), priority,
-    };
-  }
-
-  updateMemory(path, { content = null, priority = null, disclosure = null, domain = "core", namespace = "" } = {}) {
-    if (path === "") throw new Error("Cannot update the root node.");
-    if (content === null && priority === null && disclosure === null) {
-      throw new Error("At least one of content, priority, or disclosure must be set.");
-    }
-
-    const resolved = resolveGraphPath(this.db, path, domain, namespace);
-    if (!resolved || !resolved.edge) {
-      throw new Error(`Path '${graphUri(domain, path)}' not found`);
-    }
-
-    const { edge, node_uuid: nodeUuid } = resolved;
-    let oldMemoryId = null;
-    let newMemoryId = null;
-
-    // Get current memory
-    const currentMem = this.db.prepare(
-      "SELECT id FROM memories WHERE node_uuid = ? AND deprecated = 0 ORDER BY created_at DESC LIMIT 1"
-    ).get(nodeUuid);
-    oldMemoryId = currentMem?.id ?? null;
-
-    // Update edge metadata
-    if (priority !== null) {
-      this.db.prepare("UPDATE edges SET priority = ? WHERE id = ?").run(priority, edge.id);
-    }
-    if (disclosure !== null) {
-      this.db.prepare("UPDATE edges SET disclosure = ? WHERE id = ?").run(disclosure, edge.id);
-    }
-
-    // Content change → new memory version
-    if (content !== null) {
-      const newMem = insertMemory(this.db, nodeUuid, content, false);
-      newMemoryId = newMem.id;
-      deprecateNodeMemories(this.db, nodeUuid, newMemoryId);
-      this.db.prepare(
-        "UPDATE memories SET deprecated = 0, migrated_to = NULL WHERE id = ?"
-      ).run(newMemoryId);
-
-      // Record changeset + re-index
-      if (this.changesetStore) {
-        const oldContent = oldMemoryId
-          ? this.db.prepare("SELECT content FROM memories WHERE id = ?").get(oldMemoryId)?.content ?? null
-          : null;
-        this.changesetStore.record({ memoryId: newMemoryId, nodeUuid, beforeContent: oldContent, afterContent: content });
-      }
-      if (this.searchIndexer) {
-        this.searchIndexer.index(nodeUuid, content, namespace);
-      }
-    }
-
-    return {
-      domain, path, uri: graphUri(domain, path),
-      old_memory_id: oldMemoryId, new_memory_id: newMemoryId ?? oldMemoryId, node_uuid: nodeUuid,
-    };
-  }
-
-  rollbackToMemory(targetMemoryId) {
-    const target = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(targetMemoryId);
-    if (!target) throw new Error(`Memory ID ${targetMemoryId} not found`);
-
-    if (!target.deprecated) {
-      return { restored_memory_id: targetMemoryId, was_already_active: true };
-    }
-
-    deprecateNodeMemories(this.db, target.node_uuid, targetMemoryId);
-    this.db.prepare(
-      "UPDATE memories SET deprecated = 0, migrated_to = NULL WHERE id = ?"
-    ).run(targetMemoryId);
-
-    return { restored_memory_id: targetMemoryId, node_uuid: target.node_uuid };
-  }
-
-  addPath(newPath, targetPath, { newDomain = "core", targetDomain = "core", priority = 0, disclosure = null, namespace = "" } = {}) {
-    if (newPath === "") throw new Error("Cannot create alias at root path.");
-
-    const target = resolveGraphPath(this.db, targetPath, targetDomain, namespace);
-    if (!target) throw new Error(`Target '${graphUri(targetDomain, targetPath)}' not found`);
-
-    const parentUuid = newPath.includes("/")
-      ? resolveGraphPath(this.db, newPath.substring(0, newPath.lastIndexOf("/")), newDomain, namespace)?.node_uuid ?? ROOT_NODE_UUID
-      : ROOT_NODE_UUID;
-
-    if (pathExists(this.db, namespace, newDomain, newPath)) throw new Error(`Path '${graphUri(newDomain, newPath)}' already exists`);
-
-    if (wouldCreateCycle(this.db, parentUuid, target.node_uuid)) {
-      throw new Error(`Cannot create alias: would create a cycle.`);
-    }
-
-    const result = this.#createEdgeWithPaths(
-      parentUuid, target.node_uuid,
-      leafName(newPath), newDomain, newPath,
-      priority, disclosure ?? target.edge?.disclosure, namespace,
-    );
-
-    return {
-      new_uri: graphUri(newDomain, newPath),
-      target_uri: graphUri(targetDomain, targetPath),
-      node_uuid: target.node_uuid,
-      edge_id: result.edge_id, edge_created: result.edge_created,
-    };
-  }
-
-  removePath(path, domain = "core", namespace = "") {
-    return removeGraphPath(this.db, path, domain, namespace);
-  }
-
-  restorePath(path, domain, nodeUuid, { parentUuid = null, priority = 0, disclosure = null, namespace = "" } = {}) {
-    if (path === "") throw new Error("Cannot restore root path.");
-
-    // Check node exists and has an active memory
-    const node = this.db.prepare("SELECT uuid FROM nodes WHERE uuid = ?").get(nodeUuid);
-    if (!node) throw new Error(`Node '${nodeUuid}' not found`);
-
-    const activeMem = this.db.prepare(
-      "SELECT id FROM memories WHERE node_uuid = ? AND deprecated = 0"
-    ).get(nodeUuid);
-    if (!activeMem) {
-      const latest = this.db.prepare(
-        "SELECT id FROM memories WHERE node_uuid = ? ORDER BY created_at DESC LIMIT 1"
-      ).get(nodeUuid);
-      if (!latest) throw new Error(`Node '${nodeUuid}' has no memory versions`);
-      this.db.prepare(
-        "UPDATE memories SET deprecated = 0, migrated_to = NULL WHERE id = ?"
-      ).run(latest.id);
-    }
-
-    if (pathExists(this.db, namespace, domain, path)) throw new Error(`Path '${graphUri(domain, path)}' already exists`);
-
-    if (!parentUuid) {
-      if (path.includes("/")) {
-        const parentPath = path.substring(0, path.lastIndexOf("/"));
-        const parent = resolveGraphPath(this.db, parentPath, domain, namespace);
-        parentUuid = parent?.node_uuid ?? ROOT_NODE_UUID;
-      } else {
-        parentUuid = ROOT_NODE_UUID;
-      }
-    }
-
-    const edgeName = leafName(path);
-    const { edge } = getOrCreateEdge(this.db, parentUuid, nodeUuid, edgeName, priority, disclosure);
-    insertPath(this.db, namespace, domain, path, edge.id, nodeUuid);
-
-    return { uri: graphUri(domain, path), node_uuid: nodeUuid };
-  }
-}
-

package/src/memory/search.mjs

@@ -1,142 +0,0 @@
-export class SearchIndexer {
-  constructor(db) {
-    this.db = db;
-    this.#ensureSchema();
-  }
-
-  #ensureSchema() {
-    this.db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS search_fts USING fts5(
-        node_uuid,
-        namespace,
-        content,
-        tokenize = 'porter unicode61'
-      );
-    `);
-  }
-
-  /**
-   * Index a memory's content for full-text search.
-   * Replaces any existing entry for the same (node_uuid, namespace).
-   */
-  index(nodeUuid, content, namespace = "") {
-    this.remove(nodeUuid, namespace);
-    this.db.prepare(
-      "INSERT INTO search_fts (node_uuid, namespace, content) VALUES (?, ?, ?)",
-    ).run(nodeUuid, namespace, content);
-  }
-
-  /**
-   * Remove a document from the FTS index.
-   */
-  remove(nodeUuid, namespace = "") {
-    this.db.prepare(
-      "DELETE FROM search_fts WHERE node_uuid = ? AND namespace = ?",
-    ).run(nodeUuid, namespace);
-  }
-
-  /**
-   * Full-text search with ranking.
-   * Returns matching node UUIDs, ranked by relevance.
-   */
-  search(query, { namespace = "", limit = 20, offset = 0 } = {}) {
-    // Sanitize FTS5 query: escape special chars, wrap in quotes for phrase matching
-    const sanitized = query.replace(/["*()]/g, "").trim();
-    if (!sanitized) return [];
-
-    const ftsQuery = sanitized.split(/\s+/).map(w => `"${w}"`).join(" OR ");
-
-    let sql;
-    let params;
-    if (namespace) {
-      sql = `
-        SELECT node_uuid, namespace, content,
-               rank AS score,
-               snippet(search_fts, 1, '<mark>', '</mark>', '...', 32) AS snippet
-        FROM search_fts
-        WHERE search_fts MATCH ? AND namespace = ?
-        ORDER BY rank
-        LIMIT ? OFFSET ?
-      `;
-      params = [ftsQuery, namespace, limit, offset];
-    } else {
-      sql = `
-        SELECT node_uuid, namespace, content,
-               rank AS score,
-               snippet(search_fts, 1, '<mark>', '</mark>', '...', 32) AS snippet
-        FROM search_fts
-        WHERE search_fts MATCH ?
-        ORDER BY rank
-        LIMIT ? OFFSET ?
-      `;
-      params = [ftsQuery, limit, offset];
-    }
-
-    return this.db.prepare(sql).all(...params);
-  }
-
-  /**
-   * Quick count of indexed documents.
-   */
-  count(namespace = "") {
-    if (namespace) {
-      return this.db.prepare("SELECT COUNT(*) AS cnt FROM search_fts WHERE namespace = ?").get(namespace).cnt;
-    }
-    return this.db.prepare("SELECT COUNT(*) AS cnt FROM search_fts").get().cnt;
-  }
-
-  /**
-   * Delete all entries for a namespace.
-   */
-  clearNamespace(namespace) {
-    const result = this.db.prepare("DELETE FROM search_fts WHERE namespace = ?").run(namespace);
-    return result.changes;
-  }
-
-  /**
-   * Rebuild the FTS index from the search_documents table.
-   */
-  rebuildFromDocuments() {
-    this.db.exec("DELETE FROM search_fts");
-    const docs = this.db.prepare("SELECT * FROM search_documents").all();
-    const insert = this.db.prepare(
-      "INSERT INTO search_fts (node_uuid, namespace, content) VALUES (?, ?, ?)",
-    );
-    for (const doc of docs) {
-      insert.run(doc.node_uuid, doc.namespace, doc.content);
-    }
-    return docs.length;
-  }
-
-  /**
-   * Suggest completions based on prefix matching.
-   */
-  suggest(prefix, { namespace = "", limit = 8 } = {}) {
-    const sanitized = prefix.replace(/[*"]/g, "").trim();
-    if (!sanitized || sanitized.length < 2) return [];
-
-    let sql;
-    let params;
-    if (namespace) {
-      sql = `
-        SELECT DISTINCT content
-        FROM search_fts
-        WHERE search_fts MATCH ? AND namespace = ?
-        ORDER BY rank
-        LIMIT ?
-      `;
-      params = [`"${sanitized}"*`, namespace, limit];
-    } else {
-      sql = `
-        SELECT DISTINCT content
-        FROM search_fts
-        WHERE search_fts MATCH ?
-        ORDER BY rank
-        LIMIT ?
-      `;
-      params = [`"${sanitized}"*`, limit];
-    }
-
-    return this.db.prepare(sql).all(...params).map(r => r.content);
-  }
-}

package/src/memory/snapshot.mjs

@@ -1,86 +0,0 @@
-export class ChangesetStore {
-  constructor(db) {
-    this.db = db;
-    this.#ensureSchema();
-  }
-
-  #ensureSchema() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS changesets (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        memory_id INTEGER NOT NULL REFERENCES memories(id),
-        node_uuid TEXT NOT NULL REFERENCES nodes(uuid),
-        before_content TEXT,
-        after_content TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-      CREATE INDEX IF NOT EXISTS idx_changesets_node ON changesets(node_uuid);
-      CREATE INDEX IF NOT EXISTS idx_changesets_memory ON changesets(memory_id);
-    `);
-  }
-
-  /**
-   * Record a before/after snapshot for a memory update.
-   * @param {number} memoryId - the NEW memory id
-   * @param {string} nodeUuid
-   * @param {string|null} beforeContent - previous content (null if creation)
-   * @param {string} afterContent - new content
-   */
-  record({ memoryId, nodeUuid, beforeContent, afterContent }) {
-    const result = this.db.prepare(
-      "INSERT INTO changesets (memory_id, node_uuid, before_content, after_content) VALUES (?, ?, ?, ?)",
-    ).run(memoryId, nodeUuid, beforeContent ?? null, afterContent);
-    return { id: Number(result.lastInsertRowid), memory_id: memoryId, node_uuid: nodeUuid };
-  }
-
-  /**
-   * Get all changesets for a node, most recent first.
-   */
-  getHistory(nodeUuid, limit = 50) {
-    return this.db.prepare(
-      "SELECT * FROM changesets WHERE node_uuid = ? ORDER BY id DESC LIMIT ?",
-    ).all(nodeUuid, limit);
-  }
-
-  /**
-   * Get the most recent changesets across all nodes.
-   */
-  getRecent(limit = 30) {
-    return this.db.prepare(
-      "SELECT * FROM changesets ORDER BY id DESC LIMIT ?",
-    ).all(limit);
-  }
-
-  /**
-   * Get a specific changeset by id.
-   */
-  getById(id) {
-    return this.db.prepare("SELECT * FROM changesets WHERE id = ?").get(id);
-  }
-
-  /**
-   * Get the diff summary for a changeset — useful for display.
-   */
-  diff(changeset) {
-    const before = changeset.before_content ?? "";
-    const after = changeset.after_content ?? "";
-    if (!before) return { type: "create", linesAdded: after.split("\n").length };
-    if (!after) return { type: "delete", linesRemoved: before.split("\n").length };
-
-    const beforeLines = before.split("\n");
-    const afterLines = after.split("\n");
-    const added = afterLines.filter((l) => !before.includes(l)).length;
-    const removed = beforeLines.filter((l) => !after.includes(l)).length;
-    return { type: "update", linesAdded: Math.max(0, afterLines.length - beforeLines.length), linesRemoved: Math.max(0, beforeLines.length - afterLines.length), changedLines: added + removed };
-  }
-
-  /**
-   * Delete changesets older than the given number of days.
-   */
-  pruneOlderThan(days) {
-    const result = this.db.prepare(
-      "DELETE FROM changesets WHERE created_at < datetime('now', ?)",
-    ).run(`-${days} days`);
-    return result.changes;
-  }
-}

package/src/memory/system-views.mjs

@@ -1,120 +0,0 @@
-import { ROOT_NODE_UUID } from "./database.mjs";
-
-export class SystemViews {
-  constructor(db, graph, glossaryService, namespace = "") {
-    this.db = db;
-    this.graph = graph;
-    this.glossarySvc = glossaryService;
-    this.namespace = namespace;
-  }
-
-  /**
-   * system://boot — children of the root node (project boot entries).
-   */
-  boot() {
-    const children = this.graph.getChildren(ROOT_NODE_UUID, null, null, this.namespace);
-    return children.map(c => ({
-      name: c.name,
-      node_uuid: c.node_uuid,
-      priority: c.priority,
-      disclosure: c.disclosure,
-      content: c.content_snippet ?? null,
-    }));
-  }
-
-  /**
-   * system://index — all paths with their node UUIDs, grouped by domain.
-   */
-  index() {
-    const rows = this.db.prepare(
-      "SELECT domain, path, node_uuid, namespace FROM paths WHERE namespace = ? OR namespace = 'global' ORDER BY domain, path",
-    ).all(this.namespace);
-    const domains = {};
-    for (const row of rows) {
-      const d = row.domain || "core";
-      if (!domains[d]) domains[d] = [];
-      domains[d].push({ path: row.path, node_uuid: row.node_uuid, namespace: row.namespace });
-    }
-    return domains;
-  }
-
-  /**
-   * system://recent — most recently updated memories.
-   */
-  recent(limit = 20) {
-    return this.graph.getRecentMemories(limit, this.namespace);
-  }
-
-  /**
-   * system://glossary — all glossary keywords with linked nodes.
-   */
-  glossaryList() {
-    return this.glossarySvc.getAllKeywords();
-  }
-
-  /**
-   * system://diagnostic — health and stats overview.
-   */
-  diagnostic() {
-    const ns = this.namespace;
-    const nodeCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM nodes").get().cnt;
-    const memoryCount = this.db.prepare("SELECT COUNT(DISTINCT m.id) AS cnt FROM memories m JOIN paths p ON p.node_uuid = m.node_uuid WHERE m.deprecated = 0 AND (p.namespace = ? OR p.namespace = 'global')").get(ns).cnt;
-    const deprecatedCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE deprecated = 1").get().cnt;
-    const edgeCount = this.db.prepare("SELECT COUNT(DISTINCT e.id) AS cnt FROM edges e JOIN paths p ON p.edge_id = e.id WHERE p.namespace = ? OR p.namespace = 'global'").get(ns).cnt;
-    const pathCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM paths WHERE namespace = ? OR namespace = 'global'").get(ns).cnt;
-    const keywordCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM glossary_keywords WHERE namespace = ? OR namespace = 'global'").get(ns).cnt;
-    const ftsCount = this.#ftsCount();
-    const changesetCount = this.#changesetCount();
-
-    // Stale nodes: no access in 30 days
-    const cutoff = new Date(Date.now() - 30 * 86400000).toISOString();
-    const staleNodes = this.db.prepare(
-      "SELECT COUNT(*) AS cnt FROM nodes WHERE last_accessed_at IS NOT NULL AND last_accessed_at < ?",
-    ).get(cutoff).cnt;
-
-    // Orphan nodes: nodes with no paths pointing to them
-    const orphanNodes = this.db.prepare(`
-      SELECT COUNT(*) AS cnt FROM nodes n
-      WHERE n.uuid != ?
-      AND NOT EXISTS (SELECT 1 FROM paths WHERE node_uuid = n.uuid)
-      AND NOT EXISTS (SELECT 1 FROM edges WHERE child_uuid = n.uuid)
-    `).get(ROOT_NODE_UUID).cnt;
-
-    // Version chain depth stats
-    const versionStats = this.db.prepare(`
-      SELECT MAX(vc) AS max_depth, AVG(vc) AS avg_depth
-      FROM (SELECT COUNT(*) AS vc FROM memories GROUP BY node_uuid)
-    `).get();
-
-    return {
-      counts: {
-        nodes: nodeCount,
-        memories: memoryCount,
-        deprecated_memories: deprecatedCount,
-        edges: edgeCount,
-        paths: pathCount,
-        keywords: keywordCount,
-        fts_documents: ftsCount,
-        changesets: changesetCount,
-      },
-      health: {
-        stale_nodes: staleNodes,
-        orphan_nodes: orphanNodes,
-        max_version_depth: versionStats.max_depth ?? 0,
-        avg_version_depth: Math.round((versionStats.avg_depth ?? 0) * 100) / 100,
-      },
-    };
-  }
-
-  #ftsCount() {
-    try {
-      return this.db.prepare("SELECT COUNT(*) AS cnt FROM search_fts").get().cnt;
-    } catch { return 0; }
-  }
-
-  #changesetCount() {
-    try {
-      return this.db.prepare("SELECT COUNT(*) AS cnt FROM changesets").get().cnt;
-    } catch { return 0; }
-  }
-}