lorekeep 0.1.0__py3-none-any.whl

lorekeep/config.py

@@ -0,0 +1,39 @@
+"""Load Lorekeep config. Path resolved by paths.resolve_paths() (dev .lorekeep/, LOREKEEP_HOME, or XDG)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class ProviderConfig(BaseModel):
+    backend: str = "openai"          # openai | anthropic | ollama | <litellm prefix>
+    model: str = "gpt-4o-mini"
+    api_base: str | None = None      # set for ollama or openai-compatible endpoints
+    api_key_env: str | None = None   # env var holding the api key (else litellm default)
+    api_key: str | None = None       # inline key (gitignored config only; env is safer)
+    temperature: float = 0.0
+
+
+class CompileConfig(BaseModel):
+    chunk_lines: int = 60
+
+
+class NsConfig(BaseModel):
+    default: list[str] = Field(default_factory=lambda: ["public"])
+    token_map: dict[str, list[str]] = Field(default_factory=dict)
+
+
+class Config(BaseModel):
+    provider: ProviderConfig = Field(default_factory=ProviderConfig)
+    compile: CompileConfig = Field(default_factory=CompileConfig)
+    ns: NsConfig = Field(default_factory=NsConfig)
+    install_source: str | None = None      # pypi | local | git+URL | path
+
+
+def load_config(path: Path) -> Config:
+    if not path.exists():
+        return Config()
+    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    return Config.model_validate(data)

lorekeep/defaults.py

@@ -0,0 +1,44 @@
+"""Default config + schema used by `lorekeep init` to bootstrap a fresh home."""
+from __future__ import annotations
+
+DEFAULT_SCHEMA = {
+    "version": 2,
+    "node_types": {
+        "service": {"props": {"name": "string", "lang": "string"}},
+        "team": {"props": {"name": "string"}},
+        "decision": {"props": {"title": "string"}},
+        "project": {"props": {"name": "string", "status": "string"}},
+        "person": {"props": {"name": "string", "role": "string"}},
+        "tool": {"props": {"name": "string", "category": "string"}},
+        "command": {"props": {"name": "string", "platform": "string"}},
+        "concept": {"props": {"name": "string", "domain": "string"}},
+        "note": {"props": {"title": "string", "topic": "string"}},
+        "document": {"props": {"title": "string", "kind": "string"}},
+    },
+    "edge_types": {
+        "depends_on": {"from": "service", "to": "service"},
+        "decided_by": {"from": "decision", "to": "team"},
+        "owns": {"from": "team", "to": "service"},
+        "part_of": {"from": "service", "to": "project"},
+        "uses": {"from": "service", "to": "tool"},
+        "mentions": {"from": "note", "to": "concept"},
+        "documents": {"from": "document", "to": "concept"},
+        "describes": {"from": "note", "to": "service"},
+        "relates_to": {"from": "concept", "to": "concept"},
+    },
+}
+
+DEFAULT_CONFIG_YAML = """\
+provider:
+  backend: openai
+  model: openai/gpt-4o-mini
+  api_base: null
+  api_key_env: OPENAI_API_KEY
+  api_key: null
+  temperature: 0.0
+compile:
+  chunk_lines: 60
+ns:
+  default: [public]
+install_source: pypi
+"""

lorekeep/eval/construction.py

@@ -0,0 +1,97 @@
+"""Tier-1 construction-quality evaluation vs a gold corpus."""
+from __future__ import annotations
+
+from itertools import combinations
+from pathlib import Path
+
+from lorekeep.eval.gold import edge_key, load_compiled, load_gold, node_key
+from lorekeep.models import Edge, Node
+
+
+def precision_recall_f1(gold: set, got: set) -> tuple[float, float, float]:
+    if not gold and not got:
+        return 1.0, 1.0, 1.0
+    tp = len(gold & got)
+    p = tp / len(got) if got else 0.0
+    r = tp / len(gold) if gold else 0.0
+    f1 = (2 * p * r / (p + r)) if (p + r) else 0.0
+    return p, r, f1
+
+
+def extraction_report(graph_dir: Path, gold_dir: Path) -> dict:
+    compiled = load_compiled(graph_dir)
+    gold = load_gold(gold_dir)
+
+    c_nodes = [f for f in compiled if isinstance(f, Node)]
+    c_edges = [f for f in compiled if isinstance(f, Edge)]
+    g_nodes = [f for f in gold if isinstance(f, Node)]
+    g_edges = [f for f in gold if isinstance(f, Edge)]
+
+    c_ids = {n.id: n for n in c_nodes}
+    g_ids = {n.id: n for n in g_nodes}
+
+    c_node_keys = {node_key(n) for n in c_nodes}
+    g_node_keys = {node_key(n) for n in g_nodes}
+    c_edge_keys = {edge_key(e, c_ids) for e in c_edges}
+    g_edge_keys = {edge_key(e, g_ids) for e in g_edges}
+
+    np, nr, nf = precision_recall_f1(g_node_keys, c_node_keys)
+    ep, er, ef = precision_recall_f1(g_edge_keys, c_edge_keys)
+    return {
+        "nodes": {"precision": np, "recall": nr, "f1": nf},
+        "edges": {"precision": ep, "recall": er, "f1": ef},
+    }
+
+
+def _clusters_from_aliases(alias_groups: list[dict]) -> list[set[str]]:
+    """Each gold group -> set of surface names that should be one entity."""
+    return [set(g["aliases"]) for g in alias_groups]
+
+
+def _compiled_clusters(compiled_nodes: list) -> list[set[str]]:
+    """Group compiled node names by their id (canonical entity)."""
+    by_id: dict[str, set[str]] = {}
+    for n in compiled_nodes:
+        nm = n.props.get("name", n.id)
+        by_id.setdefault(n.id, set()).add(nm)
+    return list(by_id.values())
+
+
+def entity_resolution_f1(compiled_nodes: list, gold_alias_groups: list[dict]) -> dict:
+    """Pairwise coreference F1: for every pair of mentions, did compiled agree with gold?"""
+    gold_pairs: set[frozenset] = set()
+    for cluster in _clusters_from_aliases(gold_alias_groups):
+        for a, b in combinations(sorted(cluster), 2):
+            gold_pairs.add(frozenset((a, b)))
+
+    got_pairs: set[frozenset] = set()
+    for cluster in _compiled_clusters(compiled_nodes):
+        for a, b in combinations(sorted(cluster), 2):
+            got_pairs.add(frozenset((a, b)))
+
+    p, r, f1 = precision_recall_f1(gold_pairs, got_pairs)
+    return {"precision": p, "recall": r, "f1": f1}
+
+
+def structure_report(facts_dir: Path) -> dict:
+    """Graph-shape metrics: counts, avg degree, density, dangling-edge rate."""
+    # accept either a gold dir or a compiled graph dir
+    if (facts_dir / "facts.jsonl").exists():
+        facts = load_compiled(facts_dir)
+    else:
+        facts = load_gold(facts_dir)
+    nodes = [f for f in facts if isinstance(f, Node)]
+    edges = [f for f in facts if isinstance(f, Edge)]
+    node_ids = {n.id for n in nodes}
+    dangling = sum(1 for e in edges if e.from_ not in node_ids or e.to not in node_ids)
+    n = len(nodes)
+    e = len(edges)
+    avg_degree = (e / n) if n else 0.0
+    density = (e / (n * (n - 1))) if n > 1 else 0.0
+    return {
+        "node_count": n,
+        "edge_count": e,
+        "avg_degree": round(avg_degree, 4),
+        "density": round(density, 4),
+        "dangling_edge_rate": round(dangling / e, 4) if e else 0.0,
+    }

lorekeep/eval/gold.py

@@ -0,0 +1,31 @@
+"""Load gold + compiled facts, and define match keys for evaluation."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from lorekeep.facts_io import read_facts
+from lorekeep.models import Edge, Node
+
+
+def load_gold(gold_dir: Path) -> list[Node | Edge]:
+    """Load every *.facts.jsonl under gold_dir."""
+    facts: list[Node | Edge] = []
+    for p in sorted(gold_dir.glob("**/*.facts.jsonl")):
+        facts.extend(read_facts(p))
+    return facts
+
+
+def load_compiled(graph_dir: Path) -> list[Node | Edge]:
+    return read_facts(graph_dir / "facts.jsonl")
+
+
+def node_key(n: Node) -> tuple[str, str]:
+    return (n.type, n.props.get("name", n.id))
+
+
+def edge_key(e: Edge, nodes_by_id: dict[str, Node]) -> tuple[str, str, str]:
+    f = nodes_by_id.get(e.from_)
+    t = nodes_by_id.get(e.to)
+    fn = f.props.get("name", e.from_) if f else e.from_
+    tn = t.props.get("name", e.to) if t else e.to
+    return (e.type, fn, tn)

lorekeep/eval/retrieval.py

@@ -0,0 +1,46 @@
+"""Tier-2 retrieval/temporal eval: minimal harness (not full benchmark datasets).
+
+Loads a fixture graph + a small JSON question set, runs the scoped query path,
+and checks expected node ids / edge-type presence per question. Full
+HotpotQA/CronQuestions adaptation is deferred (spec §16 Tier 2).
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from lorekeep.perm.ns import ScopedGraph
+from lorekeep.store.graph import GraphStore, parse_date
+
+
+def retrieval_report(graph_dir: Path, questions_path: Path, allowed_ns) -> dict:
+    store = GraphStore.from_jsonl(Path(graph_dir) / "facts.jsonl")
+    scoped = ScopedGraph(store, allowed_ns)
+    questions = json.loads(Path(questions_path).read_text())
+
+    total = len(questions)
+    failures = []
+    for q in questions:
+        ok = _check(scoped, q)
+        if not ok:
+            failures.append(q["id"])
+    return {"total": total, "passed": total - len(failures), "failures": failures}
+
+
+def _check(scoped: ScopedGraph, q: dict) -> bool:
+    kind = q["kind"]
+    if kind == "multihop":
+        res = scoped.neighbors(q["start"], depth=q.get("depth", 1))
+        got = {n.id for n in res["nodes"]}
+        return set(q["expect_node_ids"]).issubset(got)
+    if kind == "temporal":
+        _, edges = scoped.snapshot(parse_date(q["time"]))
+        types = {e.type for e in edges}
+        if "expect_edge_types_present" in q:
+            if not set(q["expect_edge_types_present"]).issubset(types):
+                return False
+        if "expect_edge_types_absent" in q:
+            if set(q["expect_edge_types_absent"]) & types:
+                return False
+        return True
+    return False

lorekeep/facts_io.py

@@ -0,0 +1,22 @@
+"""Shared loader for facts.jsonl -> list[Node|Edge]. Used by store + eval."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from lorekeep.models import Edge, Node
+
+
+def read_facts(path: Path) -> list[Node | Edge]:
+    """Read a facts.jsonl file (one JSON object per line) into typed facts."""
+    facts: list[Node | Edge] = []
+    for line in Path(path).read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        d = json.loads(line)
+        if d["kind"] == "node":
+            facts.append(Node.model_validate(d))
+        else:
+            facts.append(Edge.model_validate(d))
+    return facts

lorekeep/integrations/claude_code.py

@@ -0,0 +1,19 @@
+"""Claude Code MCP config writer (.mcp.json)."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def write_config(target_dir: Path, command: str, args: list[str], ns: str | None) -> Path:
+    entry = {"command": command, "args": args}
+    if ns:
+        entry["env"] = {"LOREKEEP_NS": ns}
+    path = Path(target_dir) / ".mcp.json"
+    existing = {}
+    if path.exists():
+        existing = json.loads(path.read_text())
+    servers = existing.get("mcpServers", {})
+    servers["lorekeep"] = entry
+    path.write_text(json.dumps({"mcpServers": servers}, indent=2))
+    return path

lorekeep/integrations/codex.py

@@ -0,0 +1,56 @@
+"""Codex MCP config writer (config.toml [mcp_servers.lorekeep]).
+
+Idempotent: re-running replaces the existing [mcp_servers.lorekeep] block instead
+of appending a duplicate. Values are escaped so a stray quote/backslash in the
+namespace or command can't break the generated TOML.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+_HEADER = "[mcp_servers.lorekeep]"
+
+
+def _toml_escape(s: str) -> str:
+    return s.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def _toml_quote_list(items: list[str]) -> str:
+    return "[" + ", ".join(f'"{_toml_escape(i)}"' for i in items) + "]"
+
+
+def _lorekeep_block(command: str, args: list[str], ns: str | None) -> str:
+    lines = [
+        _HEADER,
+        f'command = "{_toml_escape(command)}"',
+        f"args = {_toml_quote_list(args)}",
+    ]
+    if ns:
+        lines.append(f'env = {{ LOREKEEP_NS = "{_toml_escape(ns)}" }}')
+    return "\n".join(lines)
+
+
+def write_config(target_dir: Path, command: str, args: list[str], ns: str | None) -> Path:
+    if ns and ("\n" in ns or "\r" in ns):
+        raise ValueError("namespace must not contain newlines")
+    path = Path(target_dir) / "config.toml"
+    block = _lorekeep_block(command, args, ns)
+    text = path.read_text() if path.exists() else ""
+    lines = text.splitlines()
+    header_idx = next((i for i, l in enumerate(lines) if l.strip() == _HEADER), -1)
+    if header_idx == -1:
+        sep = "\n\n" if text.strip() else ""
+        new_text = text + sep + block + "\n"
+    else:
+        end = len(lines)
+        for i in range(header_idx + 1, len(lines)):
+            if lines[i].startswith("["):   # next top-level table
+                end = i
+                break
+        before = lines[:header_idx]
+        after = lines[end:]
+        rebuilt = before + [block] + ([""] + after if after else [])
+        new_text = "\n".join(rebuilt) + "\n"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(new_text)
+    return path

lorekeep/integrations/common.py

@@ -0,0 +1,23 @@
+"""Shared integration helpers: resolve install command + agent-memory snippet."""
+from __future__ import annotations
+
+
+def resolve_command(install_source: str | None) -> tuple[str, list[str]]:
+    """Return (command, args) to launch `lorekeep serve --transport stdio`."""
+    serve_args = ["serve", "--transport", "stdio"]
+    if not install_source or install_source == "pypi":
+        return ("uvx", ["lorekeep", *serve_args])
+    if install_source == "local":
+        return ("lorekeep", serve_args)
+    # anything else (git+URL, local path) -> uvx --from <source>
+    return ("uvx", ["--from", install_source, "lorekeep", *serve_args])
+
+
+def agent_memory_snippet() -> str:
+    return (
+        "## Lorekeep knowledge base (MCP)\n"
+        "Before answering architecture/code/domain questions, query Lorekeep:\n"
+        "search(q) -> get_node(id) -> neighbors / at_time / history as needed.\n"
+        "Always cite `src` provenance. Knowledge is namespace-scoped - if a fact is\n"
+        "missing, it may be outside your scope, not nonexistent.\n"
+    )

lorekeep/integrations/cursor.py

@@ -0,0 +1,21 @@
+"""Cursor MCP config writer (.cursor/mcp.json)."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def write_config(target_dir: Path, command: str, args: list[str], ns: str | None) -> Path:
+    entry = {"command": command, "args": args}
+    if ns:
+        entry["env"] = {"LOREKEEP_NS": ns}
+    d = Path(target_dir) / ".cursor"
+    d.mkdir(parents=True, exist_ok=True)
+    path = d / "mcp.json"
+    existing = {}
+    if path.exists():
+        existing = json.loads(path.read_text())
+    servers = existing.get("mcpServers", {})
+    servers["lorekeep"] = entry
+    path.write_text(json.dumps({"mcpServers": servers}, indent=2))
+    return path

lorekeep/mcp_server.py

@@ -0,0 +1,120 @@
+"""FastMCP server exposing the scoped temporal graph, read-only.
+
+Tools are plain module functions using a module-global ScopedGraph set by
+configure(). @mcp.tool() registers them with FastMCP but they remain directly
+callable, so tests invoke them without the MCP transport.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+from lorekeep.models import Schema
+from lorekeep.perm.ns import ScopedGraph
+from lorekeep.schema_io import load_schema
+from lorekeep.store.graph import GraphStore, parse_date
+
+mcp = FastMCP("lorekeep")
+
+_state: dict = {}          # graph_dir, allowed_ns, schema_path, facts_mtime
+_scope: ScopedGraph | None = None
+_schema: Schema | None = None
+
+
+def configure(graph_dir, allowed_ns, schema_path=None, fts_path=None) -> None:
+    """Set the graph location + scope, then build. Safe to call again to refresh."""
+    _state["graph_dir"] = Path(graph_dir)
+    _state["allowed_ns"] = list(allowed_ns)
+    _state["schema_path"] = Path(schema_path) if schema_path else None
+    _rebuild()
+
+
+def _rebuild() -> None:
+    """(Re)load the graph + schema from disk into a fresh ScopedGraph."""
+    global _scope, _schema
+    facts = _state["graph_dir"] / "facts.jsonl"
+    store = GraphStore.from_jsonl(facts)
+    sp = _state.get("schema_path")
+    _schema = load_schema(sp) if sp else None
+    _scope = ScopedGraph(store, _state["allowed_ns"])
+    _state["facts_mtime"] = facts.stat().st_mtime if facts.exists() else 0
+
+
+def _require() -> ScopedGraph:
+    """Return the scoped graph, lazy-reloading if facts.jsonl changed on disk."""
+    if not _state:
+        raise RuntimeError("mcp_server not configured; call configure() first")
+    facts = _state["graph_dir"] / "facts.jsonl"
+    mtime = facts.stat().st_mtime if facts.exists() else 0
+    if _scope is None or mtime != _state.get("facts_mtime"):
+        _rebuild()
+    return _scope
+
+
+@mcp.tool()
+def get_node(id: str) -> dict:
+    """Return a node by id (props + provenance), or error if absent/out of scope."""
+    node = _require().get_node(id)
+    if node is None:
+        return {"error": "not found or out of scope"}
+    return node.model_dump(mode="json", by_alias=True)
+
+
+@mcp.tool()
+def neighbors(id: str, edge_type: str = "", depth: int = 1) -> dict:
+    """Traverse neighbors up to depth (both directions), scoped to the caller."""
+    scoped = _require()
+    depth = max(1, min(int(depth), 5))   # bound BFS cost; 5 hops spans any realistic graph
+    res = scoped.neighbors(id, edge_type or None, depth)
+    return {
+        "nodes": [n.model_dump(mode="json", by_alias=True) for n in res["nodes"]],
+        "edges": [e.model_dump(mode="json", by_alias=True) for e in res["edges"]],
+    }
+
+
+@mcp.tool()
+def schema() -> dict:
+    """Return the graph schema (node/edge types)."""
+    if _schema is None:
+        return {"error": "no schema loaded"}
+    return _schema.model_dump(mode="json", by_alias=True)
+
+
+@mcp.tool()
+def list_namespaces() -> list:
+    """Namespaces visible to this caller."""
+    return _require().list_namespaces()
+
+
+@mcp.tool()
+def at_time(time: str) -> dict:
+    """Snapshot of facts valid at an ISO date (half-open [valid_from, valid_to))."""
+    scoped = _require()
+    nodes, edges = scoped.snapshot(parse_date(time))
+    return {
+        "nodes": [n.model_dump(mode="json", by_alias=True) for n in nodes],
+        "edges": [e.model_dump(mode="json", by_alias=True) for e in edges],
+    }
+
+
+@mcp.tool()
+def history(id: str) -> list:
+    """All versions of an entity + edges touching it, ordered by valid_from."""
+    return _require().history(id)
+
+
+@mcp.tool()
+def changes(from_t: str, to_t: str) -> dict:
+    """Edges whose validity began or ended within [from_t, to_t)."""
+    return _require().changes(parse_date(from_t), parse_date(to_t))
+
+
+@mcp.tool()
+def search(query: str, limit: int = 10) -> list:
+    """Text search over node ids/props, scoped to the caller."""
+    return _require().search(query, limit)
+
+
+if __name__ == "__main__":
+    mcp.run()

lorekeep/models.py

@@ -0,0 +1,130 @@
+"""Core data models for Lorekeep. The shared contract across compile + eval."""
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import date
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class DocChunk(BaseModel):
+    """A slice of a raw document, with provenance back to path:line."""
+    model_config = ConfigDict(frozen=True)
+
+    path: str
+    start_line: int          # 1-based
+    end_line: int
+    text: str
+    namespace: str           # e.g. "teams/backend"
+
+    @property
+    def src(self) -> str:
+        return f"{self.path}:{self.start_line}"
+
+    @property
+    def hash(self) -> str:
+        h = hashlib.sha256()
+        h.update(self.path.encode("utf-8"))
+        h.update(b"\n")
+        h.update(self.text.encode("utf-8"))
+        return h.hexdigest()
+
+
+class Node(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+    kind: Literal["node"] = "node"
+    id: str
+    type: str
+    ns: tuple[str, ...]
+    valid_from: date | None = None
+    valid_to: date | None = None
+    props: dict[str, Any] = Field(default_factory=dict)
+    src: tuple[str, ...] = Field(default_factory=tuple)
+
+    def to_json_line(self) -> str:
+        d = self.model_dump(mode="json", by_alias=True)
+        return json.dumps(d, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
+
+
+class Edge(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid", populate_by_name=True)
+    kind: Literal["edge"] = "edge"
+    id: str
+    type: str
+    from_: str = Field(alias="from")
+    to: str
+    ns: tuple[str, ...]
+    valid_from: date | None = None
+    valid_to: date | None = None
+    props: dict[str, Any] = Field(default_factory=dict)
+    src: tuple[str, ...] = Field(default_factory=tuple)
+
+    def to_json_line(self) -> str:
+        d = self.model_dump(mode="json", by_alias=True)
+        return json.dumps(d, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
+
+
+Fact = Node | Edge
+
+
+class TypeSpec(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+    props: dict[str, str] = Field(default_factory=dict)
+
+
+class EndpointSpec(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid", populate_by_name=True)
+    from_: str = Field(alias="from")
+    to: str
+
+
+class Schema(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+    version: int
+    node_types: dict[str, TypeSpec]
+    edge_types: dict[str, EndpointSpec]
+
+    @classmethod
+    def load(cls, data: dict[str, Any]) -> "Schema":
+        return cls.model_validate(data)
+
+    def is_valid_node_type(self, t: str) -> bool:
+        return t in self.node_types
+
+    def is_valid_edge_type(self, t: str) -> bool:
+        return t in self.edge_types
+
+
+class CompileError(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    path: str
+    line: int
+    message: str
+
+
+class QuarantineItem(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    fact: dict[str, Any]
+    reason: str
+
+
+class Manifest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    schema_version: int
+    chunk_count: int
+    node_count: int
+    edge_count: int
+    run_id: str
+    facts_hash: str
+    chunk_hashes: dict[str, list[str]] = Field(default_factory=dict)
+    errors: list[CompileError] = Field(default_factory=list)
+    quarantine: list[QuarantineItem] = Field(default_factory=list)
+
+    def to_json(self) -> str:
+        return json.dumps(self.model_dump(mode="json"), sort_keys=True, indent=2)
+
+    @classmethod
+    def from_json(cls, text: str) -> "Manifest":
+        return cls.model_validate(json.loads(text))