@tyroneross/build-loop 0.30.3

package/scripts/lessons_index/__main__.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2025-2026 Tyrone Ross, Jr <46267523+tyroneross@users.noreply.github.com>
+# SPDX-License-Identifier: Apache-2.0
+"""CLI for the lessons_index package.
+
+Usage:
+  python3 scripts/lessons_index ingest [--project X] [--db PATH]
+  python3 scripts/lessons_index query --goal "<text>" [--project X] [--limit N] [--json]
+  python3 scripts/lessons_index stats [--db PATH]
+
+Default DB: $BUILD_LOOP_MEMORY_STORE_ROOT/indexes/lessons_index.db
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+_SCRIPTS_DIR = HERE.parent
+for _p in (str(HERE), str(_SCRIPTS_DIR)):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+import lessons_index as li  # noqa: E402  (intra-package via __init__)
+
+
+def _cmd_ingest(args: argparse.Namespace) -> int:
+    project = args.project or None
+    db_path = args.db or None
+    result = li.ingest(project=project, db_path=db_path)
+    if args.json:
+        json.dump(result, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+    else:
+        print(
+            f"ingest complete: upserted={result['upserted']} "
+            f"skipped={result['skipped']} errors={len(result['errors'])} "
+            f"scanned={result['total_scanned']}"
+        )
+        if result["errors"]:
+            for e in result["errors"]:
+                print(f"  ERROR: {e['file']}: {e['error']}", file=sys.stderr)
+    return 1 if result["errors"] else 0
+
+
+def _cmd_query(args: argparse.Namespace) -> int:
+    results = li.query(
+        args.goal,
+        project=args.project or None,
+        limit=args.limit,
+        db_path=args.db or None,
+    )
+    if args.json:
+        json.dump(results, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+    else:
+        if not results:
+            print("No results.")
+            return 0
+        for i, r in enumerate(results, 1):
+            print(f"\n[{i}] {r['name']}")
+            if r["description"]:
+                print(f"    {r['description']}")
+            if r["snippet"]:
+                print(f"    {r['snippet']}")
+            print(f"    lane={r['lane']}  score={r['score']:.4f}")
+            print(f"    {r['source_path']}")
+    return 0
+
+
+def _cmd_stats(args: argparse.Namespace) -> int:
+    s = li.stats(db_path=args.db or None)
+    if args.json:
+        json.dump(s, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+    else:
+        print(f"total_facts:    {s['total_facts']}")
+        print(f"schema_version: {s['schema_version']}")
+        print(f"last_ingest_ts: {s['last_ingest_ts']}")
+    return 0
+
+
+def _db_arg(parser: argparse.ArgumentParser) -> None:
+    """Add --db and --json to a subcommand parser."""
+    parser.add_argument(
+        "--db", default=None, metavar="PATH",
+        help="Override DB path (default: $MEMORY_STORE_ROOT/indexes/lessons_index.db)",
+    )
+    parser.add_argument("--json", action="store_true", help="Output JSON")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="python3 -m lessons_index",
+        description="Portable SQLite/FTS5 lessons index for build-loop.",
+    )
+
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    # ingest
+    ing = sub.add_parser("ingest", help="Walk memory lanes and upsert into DB")
+    ing.add_argument("--project", default=None,
+                     help="Project tag (default: top-level lanes)")
+    _db_arg(ing)
+
+    # query
+    qry = sub.add_parser("query", help="Query the index by goal text")
+    qry.add_argument("--goal", required=True, help="Free-text retrieval goal")
+    qry.add_argument("--project", default=None, help="Scope to project (+ _unscoped)")
+    qry.add_argument("--limit", type=int, default=5, help="Max results (default 5)")
+    _db_arg(qry)
+
+    # stats
+    sta = sub.add_parser("stats", help="Print index statistics")
+    _db_arg(sta)
+
+    return p
+
+
+def main(argv=None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    # Propagate --db and --json to subcommand args (they're on the parent).
+    dispatch = {
+        "ingest": _cmd_ingest,
+        "query": _cmd_query,
+        "stats": _cmd_stats,
+    }
+    return dispatch[args.cmd](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/lessons_index/ingest.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2025-2026 Tyrone Ross, Jr <46267523+tyroneross@users.noreply.github.com>
+# SPDX-License-Identifier: Apache-2.0
+"""Ingest markdown memory files into the SQLite lessons index.
+
+Walks the memory lanes for a project (or top-level) and upserts facts
+into the SQLite DB, skipping files whose sha256 is unchanged (incremental).
+
+Embeddings are computed lazily: if the embed backend is available AND the
+fact's sha256 is new/changed, a vector is stored in `embeddings`. If the
+backend is unavailable (MLX not installed, Ollama down, etc.) ingest
+continues silently in FTS-only mode — graceful degradation is mandatory.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import struct
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+HERE = Path(__file__).resolve().parent
+_SCRIPTS_DIR = HERE.parent
+# Insert scripts/ for _paths, embed_backend deps.
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+# Import open_db via importlib to avoid collision with write_decision/schema.py
+# which is also named 'schema' and appears on sys.path in the full test suite.
+import importlib.util as _iutil  # noqa: E402
+
+def _load_schema_module():
+    spec = _iutil.spec_from_file_location(
+        "lessons_index._schema", HERE / "schema.py"
+    )
+    mod = _iutil.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+_schema_mod = _load_schema_module()
+open_db = _schema_mod.open_db
+
+
+# ---------------------------------------------------------------------------
+# Frontmatter parser — reuse the same tiny YAML subset as memory_writer.py.
+# Imported from write_decision/frontmatter if available, otherwise inline.
+# ---------------------------------------------------------------------------
+
+def _split_frontmatter(text: str) -> tuple[dict, str]:
+    """Return (frontmatter_dict, body). Empty dict if no frontmatter.
+
+    Identical subset as memory_writer._split_frontmatter: handles key: value,
+    key: ["list"], booleans, null, int, float, quoted strings.
+    """
+    if not text.startswith("---\n"):
+        return {}, text
+    end = text.find("\n---\n", 4)
+    if end == -1:
+        return {}, text
+    block = text[4:end]
+    body = text[end + 5:]
+    fm: dict[str, Any] = {}
+    for line in block.splitlines():
+        line = line.rstrip()
+        if not line or line.lstrip().startswith("#"):
+            continue
+        m = re.match(r"^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$", line)
+        if not m:
+            continue
+        fm[m.group(1)] = _coerce(m.group(2).strip())
+    return fm, body
+
+
+def _coerce(val: str) -> Any:
+    if val == "" or val == "~" or val.lower() == "null":
+        return None
+    if val.lower() == "true":
+        return True
+    if val.lower() == "false":
+        return False
+    if val.startswith("[") and val.endswith("]"):
+        try:
+            return json.loads(val)
+        except json.JSONDecodeError:
+            return val
+    if (val.startswith('"') and val.endswith('"')) or (
+        val.startswith("'") and val.endswith("'")
+    ):
+        return val[1:-1]
+    try:
+        return int(val)
+    except ValueError:
+        pass
+    try:
+        return float(val)
+    except ValueError:
+        pass
+    return val
+
+
+def _sha256(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def _pack_floats(vec: list[float]) -> bytes:
+    """Pack a list of float32 into a BLOB."""
+    return struct.pack(f"{len(vec)}f", *vec)
+
+
+# ---------------------------------------------------------------------------
+# Embed backend — lazy import, fail-safe
+# ---------------------------------------------------------------------------
+
+def _try_embed(text: str) -> tuple[list[float] | None, str | None]:
+    """Return (vector, model_name) or (None, None) if backend unavailable.
+
+    Checks EMBED_BACKEND_UNAVAILABLE env var first so tests can force the
+    no-embedding path without complex mocking.
+    """
+    if os.environ.get("EMBED_BACKEND_UNAVAILABLE"):
+        return None, None
+    try:
+        import embed_backend as _eb  # type: ignore  # noqa: PLC0415
+        vec = _eb.embed(text)
+        model = _eb.active_model()
+        return vec, model
+    except Exception:  # noqa: BLE001
+        return None, None
+
+
+# ---------------------------------------------------------------------------
+# Lane discovery
+# ---------------------------------------------------------------------------
+
+def _lane_dirs(project: str | None) -> list[tuple[str, Path]]:
+    """Return [(lane_name, directory)] pairs to walk for the given project.
+
+    Lane names correspond to the memory lane taxonomy:
+      lessons, decisions, product, architecture (per project or top-level).
+    """
+    from _paths import (  # type: ignore  # noqa: PLC0415
+        project_decisions_dir,
+        project_lessons_dir,
+        project_product_dir,
+        top_level_lessons_dir,
+    )
+    if project:
+        return [
+            ("lessons", project_lessons_dir(project)),
+            ("decisions", project_decisions_dir(project)),
+            ("product", project_product_dir(project)),
+        ]
+    else:
+        return [
+            ("lessons", top_level_lessons_dir()),
+        ]
+
+
+# ---------------------------------------------------------------------------
+# Core ingest
+# ---------------------------------------------------------------------------
+
+def ingest(
+    project: str | None = None,
+    db_path: str | Path | None = None,
+) -> dict:
+    """Walk memory lanes and upsert markdown → SQLite.
+
+    Returns a summary dict: {upserted, skipped, errors, total_scanned}.
+
+    Rules:
+    - Skip files whose sha256 is unchanged (incremental).
+    - Skip non-.md files and INDEX.md / MEMORY.md / TELEMETRY.jsonl.
+    - Embeddings: computed lazily; silently skipped if backend unavailable.
+    - Idempotent: safe to call multiple times.
+    """
+    from _paths import memory_store_root  # type: ignore  # noqa: PLC0415
+
+    if db_path is None:
+        db_path = memory_store_root() / "indexes" / "lessons_index.db"
+    db_path = Path(db_path)
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    conn = open_db(db_path)
+    summary = {"upserted": 0, "skipped": 0, "errors": [], "total_scanned": 0}
+
+    try:
+        lanes = _lane_dirs(project)
+        for lane_name, lane_dir in lanes:
+            if not lane_dir.exists():
+                continue
+            for md_path in sorted(lane_dir.glob("*.md")):
+                if md_path.name in {"INDEX.md", "MEMORY.md", "README.md"}:
+                    continue
+                summary["total_scanned"] += 1
+                try:
+                    _ingest_file(conn, md_path, lane_name,
+                                 project or "_unscoped", summary)
+                except Exception as exc:  # noqa: BLE001
+                    summary["errors"].append(
+                        {"file": str(md_path), "error": str(exc)}
+                    )
+    finally:
+        # Update last_ingest_ts.
+        now_ts = datetime.now(timezone.utc).isoformat()
+        conn.execute(
+            "INSERT OR REPLACE INTO meta(key, value) VALUES ('last_ingest_ts', ?)",
+            (now_ts,),
+        )
+        conn.commit()
+        conn.close()
+
+    return summary
+
+
+def _ingest_file(
+    conn,
+    path: Path,
+    lane: str,
+    project: str,
+    summary: dict,
+) -> None:
+    """Upsert one markdown file into the DB."""
+    text = path.read_text(encoding="utf-8")
+    sha = _sha256(text)
+    source_path = str(path)
+    mtime = path.stat().st_mtime
+
+    # Check if sha256 is unchanged — skip if so.
+    row = conn.execute(
+        "SELECT id, sha256 FROM facts WHERE source_path = ?", (source_path,)
+    ).fetchone()
+
+    if row is not None and row["sha256"] == sha:
+        summary["skipped"] += 1
+        return
+
+    # Parse frontmatter + body.
+    fm, body = _split_frontmatter(text)
+    name = str(fm.get("name") or path.stem)
+    description = str(fm.get("description") or "")
+    fm_json = json.dumps(fm, ensure_ascii=False, default=str)
+
+    # Upsert into facts.
+    if row is None:
+        # New row.
+        cur = conn.execute(
+            """INSERT INTO facts
+               (lane, project, name, description, body, frontmatter_json,
+                source_path, mtime, sha256)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (lane, project, name, description, body.strip(),
+             fm_json, source_path, mtime, sha),
+        )
+        fact_id = cur.lastrowid
+        # FTS triggers handle INSERT automatically.
+    else:
+        fact_id = row["id"]
+        conn.execute(
+            """UPDATE facts SET
+               lane=?, project=?, name=?, description=?, body=?,
+               frontmatter_json=?, mtime=?, sha256=?
+               WHERE id=?""",
+            (lane, project, name, description, body.strip(),
+             fm_json, mtime, sha, fact_id),
+        )
+        # FTS triggers handle UPDATE automatically.
+
+    conn.commit()
+    summary["upserted"] += 1
+
+    # Embeddings: lazy, skip on any failure.
+    vec, model = _try_embed(f"{name}\n{description}\n{body}")
+    if vec is not None and model is not None:
+        packed = _pack_floats(vec)
+        dim = len(vec)
+        conn.execute(
+            """INSERT INTO embeddings(fact_id, model, dim, vec)
+               VALUES (?, ?, ?, ?)
+               ON CONFLICT(fact_id) DO UPDATE SET
+               model=excluded.model, dim=excluded.dim, vec=excluded.vec""",
+            (fact_id, model, dim, packed),
+        )
+        conn.commit()

package/scripts/lessons_index/query.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2025-2026 Tyrone Ross, Jr <46267523+tyroneross@users.noreply.github.com>
+# SPDX-License-Identifier: Apache-2.0
+"""Query the SQLite lessons index with progressive disclosure.
+
+query(goal_text, project, limit) flow:
+  1. FTS5 BM25 match on goal_text, scoped to project + _unscoped.
+  2. If embeddings table is populated AND embed backend is available,
+     compute goal embedding and cosine-rerank the BM25 candidates (hybrid).
+  3. Return top-N results as list of dicts.
+
+Graceful degradation: if the embed backend is unavailable or the embeddings
+table is empty, returns pure BM25 results with no error.
+"""
+from __future__ import annotations
+
+import math
+import os
+import struct
+import sys
+from pathlib import Path
+from typing import Any
+
+HERE = Path(__file__).resolve().parent
+_SCRIPTS_DIR = HERE.parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+import importlib.util as _iutil  # noqa: E402
+
+def _load_schema_module():
+    spec = _iutil.spec_from_file_location(
+        "lessons_index._schema", HERE / "schema.py"
+    )
+    mod = _iutil.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+_schema_mod = _load_schema_module()
+open_db = _schema_mod.open_db
+
+_SNIPPET_TOKENS = 64  # chars for snippet extraction
+
+
+def _snippet(text: str, query_words: list[str], max_chars: int = _SNIPPET_TOKENS * 4) -> str:
+    """Return a short excerpt near the first query word hit."""
+    text_lower = text.lower()
+    best_pos = len(text)
+    for word in query_words:
+        pos = text_lower.find(word.lower())
+        if 0 <= pos < best_pos:
+            best_pos = pos
+    start = max(0, best_pos - 80)
+    end = min(len(text), start + max_chars)
+    excerpt = text[start:end].strip()
+    if start > 0:
+        excerpt = "…" + excerpt
+    if end < len(text):
+        excerpt = excerpt + "…"
+    return excerpt
+
+
+def _cosine(a: list[float], b: list[float]) -> float:
+    dot = sum(x * y for x, y in zip(a, b))
+    mag_a = math.sqrt(sum(x * x for x in a))
+    mag_b = math.sqrt(sum(x * x for x in b))
+    if mag_a == 0 or mag_b == 0:
+        return 0.0
+    return dot / (mag_a * mag_b)
+
+
+def _unpack_floats(blob: bytes) -> list[float]:
+    n = len(blob) // 4
+    return list(struct.unpack(f"{n}f", blob))
+
+
+def _try_embed(text: str) -> list[float] | None:
+    """Return embedding vector or None if backend unavailable."""
+    if os.environ.get("EMBED_BACKEND_UNAVAILABLE"):
+        return None
+    try:
+        import embed_backend as _eb  # type: ignore  # noqa: PLC0415
+        vec = _eb.embed(text)
+        return list(vec)
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def query(
+    goal_text: str,
+    project: str | None = None,
+    limit: int = 5,
+    db_path: str | Path | None = None,
+) -> list[dict[str, Any]]:
+    """Return top-N lessons matching goal_text.
+
+    Scoping: includes rows where project matches AND rows where
+    project='_unscoped' (top-level lanes). When project is None, returns
+    results from all projects.
+
+    Each result dict: {name, description, snippet, score, source_path, lane}.
+    """
+    from _paths import memory_store_root  # type: ignore  # noqa: PLC0415
+
+    if db_path is None:
+        db_path = memory_store_root() / "indexes" / "lessons_index.db"
+    db_path = Path(db_path)
+
+    if not db_path.exists():
+        return []
+
+    conn = open_db(db_path)
+    try:
+        return _run_query(conn, goal_text, project, limit)
+    finally:
+        conn.close()
+
+
+def _run_query(
+    conn,
+    goal_text: str,
+    project: str | None,
+    limit: int,
+) -> list[dict[str, Any]]:
+    # Check if FTS table has any content.
+    fts_count = conn.execute("SELECT COUNT(*) FROM facts_fts").fetchone()[0]
+    if fts_count == 0:
+        # FTS table may be behind facts (e.g. if triggers weren't active).
+        # Rebuild from facts.
+        _rebuild_fts(conn)
+        fts_count = conn.execute("SELECT COUNT(*) FROM facts_fts").fetchone()[0]
+    if fts_count == 0:
+        return []
+
+    # Sanitize goal_text for FTS5: escape special chars, wrap in quotes for
+    # phrase matching fallback if the raw query fails.
+    fts_query = _sanitize_fts_query(goal_text)
+
+    # BM25 candidates: fetch up to limit*4 for reranking headroom.
+    candidates = _fts_candidates(conn, fts_query, project, limit * 4)
+    if not candidates:
+        # FTS found nothing — last resort LIKE on name + description.
+        candidates = _like_fallback(conn, goal_text, project, limit)
+
+    if not candidates:
+        return []
+
+    # Hybrid rerank if embeddings are available.
+    goal_vec = _try_embed(goal_text)
+    if goal_vec is not None and _embeddings_populated(conn):
+        candidates = _cosine_rerank(conn, candidates, goal_vec)
+
+    # Trim to limit.
+    results = candidates[:limit]
+
+    # Build output dicts.
+    query_words = [w for w in goal_text.lower().split() if len(w) > 2]
+    out = []
+    for row in results:
+        out.append({
+            "name": row["name"],
+            "description": row["description"],
+            "snippet": _snippet(row["body"], query_words),
+            "score": float(row.get("score", 0.0)),
+            "source_path": row["source_path"],
+            "lane": row["lane"],
+        })
+    return out
+
+
+def _sanitize_fts_query(text: str) -> str:
+    """Strip FTS5 syntax chars and return a safe query string."""
+    # Remove FTS5 special operators to avoid syntax errors on raw user input.
+    sanitized = text.replace('"', " ").replace("'", " ")
+    sanitized = sanitized.replace("^", " ").replace("*", " ")
+    # Collapse whitespace, take individual tokens.
+    tokens = [t for t in sanitized.split() if t]
+    if not tokens:
+        return '""'
+    # Simple OR: each token must match somewhere.
+    return " OR ".join(tokens)
+
+
+def _fts_candidates(conn, fts_query: str, project: str | None, n: int) -> list:
+    """Run BM25 FTS5 query, return rows ordered by relevance."""
+    try:
+        if project is not None:
+            sql = """
+                SELECT f.id, f.lane, f.project, f.name, f.description,
+                       f.body, f.source_path,
+                       bm25(facts_fts) AS score
+                FROM facts_fts
+                JOIN facts f ON facts_fts.rowid = f.id
+                WHERE facts_fts MATCH ?
+                  AND (f.project = ? OR f.project = '_unscoped')
+                ORDER BY score
+                LIMIT ?
+            """
+            rows = conn.execute(sql, (fts_query, project, n)).fetchall()
+        else:
+            sql = """
+                SELECT f.id, f.lane, f.project, f.name, f.description,
+                       f.body, f.source_path,
+                       bm25(facts_fts) AS score
+                FROM facts_fts
+                JOIN facts f ON facts_fts.rowid = f.id
+                WHERE facts_fts MATCH ?
+                ORDER BY score
+                LIMIT ?
+            """
+            rows = conn.execute(sql, (fts_query, n)).fetchall()
+        return [dict(r) for r in rows]
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def _like_fallback(conn, text: str, project: str | None, n: int) -> list:
+    """Simple LIKE fallback when FTS returns nothing."""
+    pattern = f"%{text[:50]}%"
+    try:
+        if project is not None:
+            sql = """
+                SELECT id, lane, project, name, description, body, source_path,
+                       0.0 AS score
+                FROM facts
+                WHERE (name LIKE ? OR description LIKE ? OR body LIKE ?)
+                  AND (project = ? OR project = '_unscoped')
+                LIMIT ?
+            """
+            rows = conn.execute(sql, (pattern, pattern, pattern, project, n)).fetchall()
+        else:
+            sql = """
+                SELECT id, lane, project, name, description, body, source_path,
+                       0.0 AS score
+                FROM facts
+                WHERE name LIKE ? OR description LIKE ? OR body LIKE ?
+                LIMIT ?
+            """
+            rows = conn.execute(sql, (pattern, pattern, pattern, n)).fetchall()
+        return [dict(r) for r in rows]
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def _embeddings_populated(conn) -> bool:
+    """True if there are any rows in the embeddings table."""
+    count = conn.execute("SELECT COUNT(*) FROM embeddings").fetchone()[0]
+    return count > 0
+
+
+def _cosine_rerank(conn, candidates: list[dict], goal_vec: list[float]) -> list[dict]:
+    """Rerank BM25 candidates by cosine similarity of stored embeddings.
+
+    Returns candidates sorted by cosine similarity (descending). Candidates
+    without an embedding retain their BM25 rank at the end.
+    """
+    ids = [r["id"] for r in candidates]
+    placeholders = ",".join("?" * len(ids))
+    emb_rows = conn.execute(
+        f"SELECT fact_id, vec FROM embeddings WHERE fact_id IN ({placeholders})",
+        ids,
+    ).fetchall()
+    emb_map = {row["fact_id"]: _unpack_floats(row["vec"]) for row in emb_rows}
+
+    scored = []
+    unscored = []
+    for r in candidates:
+        if r["id"] in emb_map:
+            cos = _cosine(goal_vec, emb_map[r["id"]])
+            scored.append({**r, "score": cos})
+        else:
+            unscored.append(r)
+
+    scored.sort(key=lambda x: x["score"], reverse=True)
+    return scored + unscored
+
+
+def _rebuild_fts(conn) -> None:
+    """Populate FTS from the facts table (recovery path)."""
+    conn.execute("DELETE FROM facts_fts")
+    conn.execute(
+        "INSERT INTO facts_fts(rowid, name, description, body) "
+        "SELECT id, name, description, body FROM facts"
+    )
+    conn.commit()