lorekeep 0.3.0__tar.gz → 0.4.0__tar.gz

lorekeep-0.4.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.4.0"
+}

{lorekeep-0.3.0 → lorekeep-0.4.0}/AGENTS.md

@@ -35,7 +35,7 @@ uv run lorekeep <command>                    # run the CLI in dev mode
 | `backup [--init <remote-url>]` | Commit + push `.lorekeep/` to your private backup git repo |
 | `version` | Print version |
 
-**Offline / no-LLM mode:** set `LOREKEEP_PROVIDER=fake` to make `compile` and `import` use `FakeProvider` with canned responses. **All CLI/compile/import tests use this** — no API key or real model required.
+**Offline / no-LLM mode:** tests inject `FakeProvider` via monkeypatch (`patch_make_provider` / `patch_make_import_provider` fixtures in `conftest.py`). **All CLI/compile/import tests use this** — no API key or real model required.
 
 ## Architecture: two strictly separated phases
 
@@ -83,7 +83,7 @@ Pure (no I/O), 4-tier precedence high→low: explicit `LOREKEEP_RAW/OUT/CACHE/SC
 
 ## Tests
 
-`~140` tests, no network. Gold corpus in `tests/fixtures/gold/`, raw fixtures in `tests/fixtures/raw/`. Compile/serve/import tests set `LOREKEEP_*` env vars and `LOREKEEP_PROVIDER=fake` to pin paths and avoid the LLM — follow this pattern for any new CLI test rather than hitting a real provider.
+`~140` tests, no network. Gold corpus in `tests/fixtures/gold/`, raw fixtures in `tests/fixtures/raw/`. Compile/serve/import tests inject `FakeProvider` via `patch_make_provider` / `patch_make_import_provider` conftest fixtures to pin paths and avoid the LLM — follow this pattern for any new CLI test rather than hitting a real provider.
 
 ## Cursor Cloud specific instructions
 
@@ -91,7 +91,7 @@ The startup update script already runs `uv sync`; the toolchain (Python 3.11+ vi
 
 Non-obvious caveats for running/testing here:
 
-- **No API key needed for any dev work.** Export `LOREKEEP_PROVIDER=fake` to run `compile`/`import` and the full end-to-end flow offline with `FakeProvider` (canned facts). To avoid polluting the repo's `.lorekeep/` data home, run demos against a throwaway data home: `LOREKEEP_HOME=/tmp/lk uv run lorekeep <cmd>`.
+- **No API key needed for tests.** Tests inject `FakeProvider` via `patch_make_provider` / `patch_make_import_provider` conftest fixtures. For manual smoke testing, configure a real provider in `config.yaml`. To avoid polluting the repo's `.lorekeep/` data home, run demos against a throwaway data home: `LOREKEEP_HOME=/tmp/lk uv run lorekeep <cmd>`.
 - **End-to-end smoke flow** (offline): `init` → drop a markdown file under `.lorekeep/raw/<ns>/` → `compile` → `check`/`doctor`. Then query the graph by calling the `mcp_server.py` tools directly after `ms.configure(graph_dir=..., allowed_ns=[...], schema_path=...)` — the read tools (`search`, `get_node`, `neighbors`, `at_time`, `history`, `list_namespaces`) are plain functions, no MCP transport required. `search` returns a list of node-id strings; `get_node` returns a dict; `neighbors`/`at_time`/`changes` return `{"nodes": [...], "edges": [...]}`.
 - **`lorekeep serve` blocks on stdio** waiting for an MCP client — it won't return on its own. To just confirm it boots, run it under `timeout` with stdin closed (`timeout 3 uv run lorekeep serve --transport stdio </dev/null`); a clean timeout with no error output means success.
 - **`tests/test_mcp_reload.py::test_lazy_reload_on_facts_change` is timing-flaky** — lazy-reload triggers off `facts.jsonl` mtime, and the test can rewrite the file within one mtime tick on fast filesystems, so it intermittently fails then passes on re-run. Treat an isolated failure of just this test as a flake, not a regression.

{lorekeep-0.3.0 → lorekeep-0.4.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.4.0](https://github.com/manhhailua/lorekeep/compare/v0.3.1...v0.4.0) (2026-06-28)
+
+
+### Features
+
+* trigger memory import on Claude session end via SessionEnd hook ([#64](https://github.com/manhhailua/lorekeep/issues/64)) ([5914663](https://github.com/manhhailua/lorekeep/commit/5914663a5c02f76e1085a1f9d663066979396d77))
+
+## [0.3.1](https://github.com/manhhailua/lorekeep/compare/v0.3.0...v0.3.1) (2026-06-28)
+
+
+### Bug Fixes
+
+* add manifest dedup to deep-mode session import ([#61](https://github.com/manhhailua/lorekeep/issues/61)) ([a9a074f](https://github.com/manhhailua/lorekeep/commit/a9a074f901c9a8f8e4cd2e3f906fdf4be7a773d6))
+
 ## [0.3.0](https://github.com/manhhailua/lorekeep/compare/v0.2.1...v0.3.0) (2026-06-28)
 
 

{lorekeep-0.3.0 → lorekeep-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lorekeep
-Version: 0.3.0
+Version: 0.4.0
 Summary: Temporal knowledge graph for AI agents via MCP
 Project-URL: Homepage, https://github.com/manhhailua/lorekeep
 Project-URL: Repository, https://github.com/manhhailua/lorekeep

{lorekeep-0.3.0 → lorekeep-0.4.0}/docs/architecture/evaluation.md

@@ -13,7 +13,7 @@
 - **Golden tests:** snapshot `facts.jsonl` for a fixture corpus; diffs catch regressions.
 - Compile-only ⇒ no concurrency to test.
 
-All compile/serve/import tests set `LOREKEEP_PROVIDER=fake` to avoid a real LLM — no API key required.
+All compile/serve/import tests inject `FakeProvider` via monkeypatch to avoid a real LLM — no API key required.
 
 ## Evaluation
 

{lorekeep-0.3.0 → lorekeep-0.4.0}/docs/guides/getting-started.md

@@ -108,8 +108,9 @@ provider:
 Prefer an env var instead? Set `api_key_env: DEEPSEEK_API_KEY` (and
 `api_key: null`), then `export DEEPSEEK_API_KEY=sk-...`. Both work.
 
-> **Offline / no key?** `export LOREKEEP_PROVIDER=fake` makes `compile` use a
-> canned response — enough to try the rest of the flow with zero API cost.
+> **No provider yet?** `init` wires agents and imports memory files
+> regardless. Compile is skipped until you add an API key — the graph
+> will be empty but the MCP tools are wired and ready.
 
 ## 5. Compile
 
@@ -188,8 +189,7 @@ recovery — is in [Backing up the data home](backup.md).
 - **`lorekeep serve` hangs** — it blocks on stdio waiting for an MCP client.
   To just confirm it boots, run it under a timeout with stdin closed:
   `timeout 3 uvx lorekeep serve --transport stdio </dev/null`.
-- **Compile gave 0 nodes** — the provider wasn't reached. Either
-  `export LOREKEEP_PROVIDER=fake` for an offline test, or check
+- **Compile gave 0 nodes** — the provider wasn't reached. Check
   `api_key_env` / `api_base` in `config.yaml`. If you switched provider or
   model after a first compile, delete `<data-home>/cache.json` (the cache key
   doesn't include the model) and recompile.

{lorekeep-0.3.0 → lorekeep-0.4.0}/docs/guides/serve.md

@@ -5,9 +5,9 @@ Path resolution (env > `LOREKEEP_HOME` > dev mode > XDG) is covered in [data-hom
 ## Installed use (recommended)
 
 ```bash
-uvx lorekeep init                     # bootstrap ~/.config/lorekeep + ~/.local/share/lorekeep
+uvx lorekeep init                     # bootstrap + wire agents + compile + start daemon
 # add your docs under ~/.local/share/lorekeep/raw/<ns>/
-LOREKEEP_PROVIDER=fake uvx lorekeep compile  # (or set a real provider in config)
+uvx lorekeep compile                  # requires a real provider in config.yaml
 uvx lorekeep mcp add --agent claude --ns <ns>
 uvx lorekeep doctor
 

{lorekeep-0.3.0 → lorekeep-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lorekeep"
-version = "0.3.0"
+version = "0.4.0"
 description = "Temporal knowledge graph for AI agents via MCP"
 readme = "README.md"
 license = {text = "MIT"}

{lorekeep-0.3.0 → lorekeep-0.4.0}/src/lorekeep/__init__.py

@@ -1,3 +1,3 @@
 """Lorekeep — temporal knowledge graph for AI agents via MCP."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{lorekeep-0.3.0 → lorekeep-0.4.0}/src/lorekeep/cli.py

@@ -8,7 +8,7 @@ from pathlib import Path
 import typer
 
 from lorekeep import __version__
-from lorekeep.compile.providers import FakeProvider, LiteLLMProvider
+from lorekeep.compile.providers import LiteLLMProvider
 from lorekeep.config import Config, load_config
 from lorekeep.pipeline import compile_graph
 from lorekeep.paths import resolve_paths
@@ -39,40 +39,71 @@ def _build_provider(config: Config) -> LiteLLMProvider:
     )
 
 
-_FAKE_CANNED = json.dumps({
-    "nodes": [
-        {"id": "svc:payments-api", "type": "service", "name": "payments-api",
-         "props": {"lang": "go"}, "valid_from": "2024-01-15"},
-        {"id": "svc:auth", "type": "service", "name": "auth"},
-        {"id": "team:backend", "type": "team", "name": "team-backend"},
-        {"id": "dec:adr-007", "type": "decision",
-         "props": {"title": "payments-api adopts internal signing"}},
-    ],
-    "edges": [
-        {"type": "depends_on", "from": "svc:payments-api", "to": "svc:auth",
-         "valid_from": "2024-01-15", "valid_to": "2025-03-01"},
-        {"type": "decided_by", "from": "dec:adr-007", "to": "team:backend"},
-    ],
-    "aliases": {},
-})
-
-
-def _make_provider(config: Config) -> FakeProvider | LiteLLMProvider:
-    """Create provider honoring LOREKEEP_PROVIDER=fake for offline/test use.
-
-    Shared by standalone compile, daemon auto-compile, and import.
-    """
-    if os.environ.get("LOREKEEP_PROVIDER") == "fake":
-        return FakeProvider(responses=[_FAKE_CANNED])
+def _make_provider(config: Config) -> LiteLLMProvider:
+    """Create provider for compile.  Tests monkeypatch this to inject FakeProvider."""
+    return _build_provider(config)
+
+
+def _make_import_provider(config: Config) -> LiteLLMProvider:
+    """Create provider for import deep mode.  Tests monkeypatch this."""
     return _build_provider(config)
 
 
+def _has_provider(config: Config) -> bool:
+    """Check if a provider API key is available.  Tests monkeypatch this."""
+    return bool(
+        (config.provider.api_key_env and os.environ.get(config.provider.api_key_env))
+        or config.provider.api_key
+    )
+
+
 @app.command()
 def version() -> None:
     """Print the Lorekeep version."""
     typer.echo(f"lorekeep {__version__}")
 
 
+@app.command(hidden=True)
+def hook() -> None:
+    """SessionEnd hook: quick-import Claude memory files to raw/.
+
+    Designed to be registered as a Claude Code SessionEnd hook.
+    Reads hook JSON from stdin (transcript_path), imports memory files,
+    and lets the daemon pick up the raw/ change for compile.
+    """
+    import sys
+
+    session_dir = None
+    try:
+        raw_stdin = sys.stdin.read()
+        if raw_stdin.strip():
+            data = json.loads(raw_stdin)
+            transcript_path = data.get("transcript_path", "")
+            if transcript_path:
+                session_dir = Path(transcript_path).expanduser().parent
+    except Exception:
+        pass
+
+    if session_dir is None:
+        try:
+            from lorekeep.importer.claude import find_current_session
+            session_dir = find_current_session()
+        except Exception:
+            return
+
+    if session_dir is None or not (session_dir / "memory").is_dir():
+        return
+
+    p = resolve_paths()
+    try:
+        from lorekeep.importer.claude import import_memories
+        written = import_memories(session_dir, p["raw"], "claude-memory")
+        if written:
+            typer.echo(f"lorekeep: imported {len(written)} memory file(s)")
+    except Exception:
+        pass
+
+
 @app.command()
 def compile() -> None:
     """Compile raw/ into graph/facts.jsonl."""
@@ -249,6 +280,7 @@ def mcp_add(
     p = resolve_paths()
     config = load_config(p["config"])
     command, args = resolve_command(config.install_source)
+    hook_cmd, hook_args = resolve_command(config.install_source, ["hook"])
 
     target = Path.cwd() if scope == "project" else Path.home()
     writers = _agent_writers()
@@ -257,6 +289,9 @@ def mcp_add(
         raise typer.Exit(code=1)
     written = writers[agent].write_config(target, command, args, ns)
     typer.echo(f"wrote {agent} config -> {written}")
+    if agent in ("claude", "cursor") and hasattr(writers[agent], "write_hook"):
+        hook_path = writers[agent].write_hook(target, hook_cmd, hook_args)
+        typer.echo(f"wrote session-end hook -> {hook_path}")
     typer.echo("\n" + agent_memory_snippet())
 
 
@@ -462,6 +497,7 @@ def _auto_wire_agents(p: dict, ns: str) -> None:
 
     config = load_config(p["config"])
     command, args = resolve_command(config.install_source)
+    hook_cmd, hook_args = resolve_command(config.install_source, ["hook"])
 
     writers = _agent_writers()
     target = Path.cwd()
@@ -474,6 +510,9 @@ def _auto_wire_agents(p: dict, ns: str) -> None:
         try:
             written = writer.write_config(target, command, args, ns)
             typer.echo(f"  wired {agent_name} -> {written}")
+            if agent_name in ("claude", "cursor") and hasattr(writer, "write_hook"):
+                hook_path = writer.write_hook(target, hook_cmd, hook_args)
+                typer.echo(f"  hooked {agent_name} session-end -> {hook_path}")
         except Exception as exc:
             typer.echo(f"  {agent_name}: failed ({exc})")
 
@@ -512,11 +551,7 @@ def _auto_import_and_compile(p: dict) -> None:
     schema = load_schema(p["schema"])
     config = load_config(p["config"])
 
-    has_key = (
-        os.environ.get("LOREKEEP_PROVIDER") == "fake"
-        or (config.provider.api_key_env and os.environ.get(config.provider.api_key_env))
-        or config.provider.api_key
-    )
+    has_key = _has_provider(config)
 
     if not has_key:
         if imported:
@@ -640,15 +675,6 @@ def import_cmd(
     p = resolve_paths()
     config = load_config(p["config"])
 
-    def _build_import_provider():
-        """Deep-mode provider (fake under LOREKEEP_PROVIDER=fake, else config)."""
-        if os.environ.get("LOREKEEP_PROVIDER") == "fake":
-            from lorekeep.compile.providers import FakeProvider
-            # Provide enough canned responses for deep mode batches
-            canned = "# Knowledge Summary\n\n## Decisions\n- No real session data imported (fake provider).\n"
-            return FakeProvider(responses=[canned] * 50)
-        return _build_provider(config)
-
     # --- Cursor: global composer conversations, deep-only ------------------
     if from_source == "cursor":
         if quick:
@@ -673,7 +699,7 @@ def import_cmd(
         ns = session_ns or "cursor-session"
         result = import_cursor(
             raw_root=p["raw"], db_path=db, namespace=ns,
-            provider=_build_import_provider(), dry_run=dry_run,
+            provider=_make_import_provider(config), dry_run=dry_run,
         )
         ses_count = len(result.get("session", []))
         if dry_run:
@@ -697,7 +723,7 @@ def import_cmd(
                        "Run Claude Code in this project first.")
             raise typer.Exit(code=1)
 
-    provider = None if quick else _build_import_provider()
+    provider = None if quick else _make_import_provider(config)
 
     from lorekeep.importer.claude import import_claude
     result = import_claude(

{lorekeep-0.3.0 → lorekeep-0.4.0}/src/lorekeep/defaults.py

@@ -73,7 +73,7 @@ PROVIDER_PRESETS: dict[str, dict] = {
         "api_key_env": None,
     },
     "5": {
-        "label": "Skip — offline/fake mode (set LOREKEEP_PROVIDER=fake to compile)",
+        "label": "Skip — configure provider later (edit config.yaml)",
         "backend": "openai",
         "model": "openai/gpt-4o-mini",
         "api_base": None,

{lorekeep-0.3.0 → lorekeep-0.4.0}/src/lorekeep/importer/claude.py

@@ -342,6 +342,17 @@ def import_session_deep(
 
     jsonl = transcripts[0]
     session_id = session_dir.name
+
+    # Dedup: skip if transcript content unchanged since last import
+    transcript_hash = hashlib.sha256(
+        jsonl.read_bytes()
+    ).hexdigest()
+    manifest = load_import_manifest(raw_root, namespace)
+    manifest_key = str(jsonl)
+
+    if not dry_run and manifest.get(manifest_key) == transcript_hash:
+        return []
+
     turns = parse_transcript(jsonl)
     if not turns:
         return []
@@ -374,6 +385,10 @@ def import_session_deep(
         previous_summary = md[:1000]   # carry short context forward
         written.append(dest)
 
+    if not dry_run and written:
+        manifest[manifest_key] = transcript_hash
+        save_import_manifest(raw_root, namespace, manifest)
+
     return written
 
 

lorekeep-0.4.0/src/lorekeep/integrations/claude_code.py

@@ -0,0 +1,50 @@
+"""Claude Code MCP config writer (.mcp.json) + SessionEnd hook writer."""
+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
+
+
+def write_hook(target_dir: Path, command: str, args: list[str]) -> Path:
+    """Write a SessionEnd hook to .claude/settings.json.
+
+    The hook calls ``lorekeep hook`` which quick-imports Claude memory
+    files into raw/ on session end. The daemon (if running) picks up the
+    raw/ change and compiles automatically.
+    """
+    settings_path = Path(target_dir) / ".claude" / "settings.json"
+    existing = {}
+    if settings_path.exists():
+        try:
+            existing = json.loads(settings_path.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    hooks = existing.get("hooks", {})
+    hooks["SessionEnd"] = [{
+        "hooks": [{
+            "type": "command",
+            "command": command,
+            "args": args,
+            "timeout": 30,
+        }]
+    }]
+    existing["hooks"] = hooks
+
+    settings_path.parent.mkdir(parents=True, exist_ok=True)
+    settings_path.write_text(json.dumps(existing, indent=2))
+    return settings_path

{lorekeep-0.3.0 → lorekeep-0.4.0}/src/lorekeep/integrations/common.py

@@ -2,15 +2,18 @@
 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"]
+def resolve_command(install_source: str | None, subcommand: list[str] | None = None) -> tuple[str, list[str]]:
+    """Return (command, args) to launch a lorekeep subcommand.
+
+    Defaults to ``serve --transport stdio``.  Pass ``subcommand`` for others
+    (e.g. ``["hook"]``).
+    """
+    cmd_args = subcommand or ["serve", "--transport", "stdio"]
     if not install_source or install_source == "pypi":
-        return ("uvx", ["lorekeep", *serve_args])
+        return ("uvx", ["lorekeep", *cmd_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])
+        return ("lorekeep", cmd_args)
+    return ("uvx", ["--from", install_source, "lorekeep", *cmd_args])
 
 
 def agent_memory_snippet() -> str:

lorekeep-0.4.0/src/lorekeep/integrations/cursor.py

@@ -0,0 +1,45 @@
+"""Cursor MCP config writer (.cursor/mcp.json) + sessionEnd hook writer."""
+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
+
+
+def write_hook(target_dir: Path, command: str, args: list[str]) -> Path:
+    """Write a sessionEnd hook to .cursor/hooks.json.
+
+    Cursor's hook format uses a single command string (shell form).
+    """
+    cmd_str = " ".join([command, *args])
+    path = Path(target_dir) / ".cursor" / "hooks.json"
+    existing = {}
+    if path.exists():
+        try:
+            existing = json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    hooks = existing.get("hooks", {})
+    hooks["sessionEnd"] = [{"command": cmd_str, "timeout": 30}]
+    existing["version"] = existing.get("version", 1)
+    existing["hooks"] = hooks
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(existing, indent=2))
+    return path

lorekeep-0.4.0/tests/conftest.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+import json
+import pytest
+
+from lorekeep.compile.providers import FakeProvider
+
+
+@pytest.fixture
+def fixtures() -> Path:
+    return Path(__file__).parent / "fixtures"
+
+
+CANNED_EXTRACTION = json.dumps({
+    "nodes": [
+        {"id": "svc:payments-api", "type": "service", "name": "payments-api",
+         "props": {"lang": "go"}, "valid_from": "2024-01-15"},
+        {"id": "svc:auth", "type": "service", "name": "auth"},
+        {"id": "team:backend", "type": "team", "name": "team-backend"},
+        {"id": "dec:adr-007", "type": "decision",
+         "props": {"title": "payments-api adopts internal signing"}},
+    ],
+    "edges": [
+        {"type": "depends_on", "from": "svc:payments-api", "to": "svc:auth",
+         "valid_from": "2024-01-15", "valid_to": "2025-03-01"},
+        {"type": "decided_by", "from": "dec:adr-007", "to": "team:backend"},
+    ],
+    "aliases": {},
+})
+
+
+@pytest.fixture
+def fake_provider():
+    """FakeProvider with canned extraction responses for compile/ingest tests."""
+    return FakeProvider(responses=[CANNED_EXTRACTION] * 50)
+
+
+@pytest.fixture
+def fake_extraction():
+    """Canned extraction JSON string for tests that build their own FakeProvider."""
+    return CANNED_EXTRACTION
+
+
+@pytest.fixture
+def patch_make_provider(monkeypatch, fake_provider):
+    """Monkeypatch cli._make_provider + _has_provider to return a FakeProvider."""
+    monkeypatch.setattr("lorekeep.cli._make_provider", lambda config: fake_provider)
+    monkeypatch.setattr("lorekeep.cli._has_provider", lambda config: True)
+
+
+@pytest.fixture
+def patch_make_import_provider(monkeypatch):
+    """Monkeypatch cli._make_import_provider to return a FakeProvider for import deep mode."""
+    canned = "# Knowledge Summary\n\n## Decisions\n- Test import summary.\n"
+    monkeypatch.setattr(
+        "lorekeep.cli._make_import_provider",
+        lambda config: FakeProvider(responses=[canned] * 50),
+    )

{lorekeep-0.3.0 → lorekeep-0.4.0}/tests/test_agent_cli.py

@@ -6,14 +6,13 @@ from lorekeep.cli import app
 runner = CliRunner()
 
 
-def test_agent_ingest_yes_flag(monkeypatch, tmp_path: Path, fixtures: Path):
+def test_agent_ingest_yes_flag(patch_make_provider, monkeypatch, tmp_path: Path, fixtures: Path):
     """agent ingest --yes: approve all facts, journal is created."""
     monkeypatch.setenv("LOREKEEP_RAW", str(tmp_path / "raw"))
     monkeypatch.setenv("LOREKEEP_OUT", str(tmp_path / "graph"))
     monkeypatch.setenv("LOREKEEP_CACHE", str(tmp_path / "cache.json"))
     monkeypatch.setenv("LOREKEEP_SCHEMA", str(fixtures / "schema.json"))
     monkeypatch.setenv("LOREKEEP_PENDING", str(tmp_path / "pending"))
-    monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
 
     raw_file = tmp_path / "raw" / "backend" / "payments.md"
     raw_file.parent.mkdir(parents=True)
@@ -35,14 +34,13 @@ def test_agent_ingest_yes_flag(monkeypatch, tmp_path: Path, fixtures: Path):
         assert entry["status"] == "pending"
 
 
-def test_agent_ingest_interactive_approve_all(monkeypatch, tmp_path: Path, fixtures: Path):
+def test_agent_ingest_interactive_approve_all(patch_make_provider, monkeypatch, tmp_path: Path, fixtures: Path):
     """agent ingest: interactive mode, approve all nodes and edges."""
     monkeypatch.setenv("LOREKEEP_RAW", str(tmp_path / "raw"))
     monkeypatch.setenv("LOREKEEP_OUT", str(tmp_path / "graph"))
     monkeypatch.setenv("LOREKEEP_CACHE", str(tmp_path / "cache.json"))
     monkeypatch.setenv("LOREKEEP_SCHEMA", str(fixtures / "schema.json"))
     monkeypatch.setenv("LOREKEEP_PENDING", str(tmp_path / "pending"))
-    monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
 
     raw_file = tmp_path / "raw" / "backend" / "payments.md"
     raw_file.parent.mkdir(parents=True)
@@ -61,14 +59,13 @@ def test_agent_ingest_interactive_approve_all(monkeypatch, tmp_path: Path, fixtu
     assert len(lines) == 6  # 4 nodes + 2 edges
 
 
-def test_agent_ingest_interactive_reject_all(monkeypatch, tmp_path: Path, fixtures: Path):
+def test_agent_ingest_interactive_reject_all(patch_make_provider, monkeypatch, tmp_path: Path, fixtures: Path):
     """agent ingest: interactive mode, reject all → no journal entries."""
     monkeypatch.setenv("LOREKEEP_RAW", str(tmp_path / "raw"))
     monkeypatch.setenv("LOREKEEP_OUT", str(tmp_path / "graph"))
     monkeypatch.setenv("LOREKEEP_CACHE", str(tmp_path / "cache.json"))
     monkeypatch.setenv("LOREKEEP_SCHEMA", str(fixtures / "schema.json"))
     monkeypatch.setenv("LOREKEEP_PENDING", str(tmp_path / "pending"))
-    monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
 
     raw_file = tmp_path / "raw" / "backend" / "payments.md"
     raw_file.parent.mkdir(parents=True)
@@ -82,14 +79,13 @@ def test_agent_ingest_interactive_reject_all(monkeypatch, tmp_path: Path, fixtur
     assert "nothing approved" in result.stdout
 
 
-def test_agent_ingest_interactive_review_individual(monkeypatch, tmp_path: Path, fixtures: Path):
+def test_agent_ingest_interactive_review_individual(patch_make_provider, monkeypatch, tmp_path: Path, fixtures: Path):
     """agent ingest: interactive mode, reject all-at-once but approve individually."""
     monkeypatch.setenv("LOREKEEP_RAW", str(tmp_path / "raw"))
     monkeypatch.setenv("LOREKEEP_OUT", str(tmp_path / "graph"))
     monkeypatch.setenv("LOREKEEP_CACHE", str(tmp_path / "cache.json"))
     monkeypatch.setenv("LOREKEEP_SCHEMA", str(fixtures / "schema.json"))
     monkeypatch.setenv("LOREKEEP_PENDING", str(tmp_path / "pending"))
-    monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
 
     raw_file = tmp_path / "raw" / "backend" / "payments.md"
     raw_file.parent.mkdir(parents=True)
@@ -111,12 +107,11 @@ def test_agent_ingest_interactive_review_individual(monkeypatch, tmp_path: Path,
     assert len(lines) == 4  # 4 nodes approved, 0 edges
 
 
-def test_agent_ingest_missing_source(monkeypatch, tmp_path: Path, fixtures: Path):
+def test_agent_ingest_missing_source(patch_make_provider, monkeypatch, tmp_path: Path, fixtures: Path):
     """agent ingest: missing source file errors out."""
     monkeypatch.setenv("LOREKEEP_RAW", str(tmp_path / "raw"))
     monkeypatch.setenv("LOREKEEP_SCHEMA", str(fixtures / "schema.json"))
     monkeypatch.setenv("LOREKEEP_PENDING", str(tmp_path / "pending"))
-    monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
 
     raw_root = tmp_path / "raw"
     raw_root.mkdir(parents=True)
@@ -126,12 +121,11 @@ def test_agent_ingest_missing_source(monkeypatch, tmp_path: Path, fixtures: Path
     assert "not found" in result.stdout
 
 
-def test_agent_ingest_source_outside_raw(monkeypatch, tmp_path: Path, fixtures: Path):
+def test_agent_ingest_source_outside_raw(patch_make_provider, monkeypatch, tmp_path: Path, fixtures: Path):
     """agent ingest: source outside raw/ errors out."""
     monkeypatch.setenv("LOREKEEP_RAW", str(tmp_path / "raw"))
     monkeypatch.setenv("LOREKEEP_SCHEMA", str(fixtures / "schema.json"))
     monkeypatch.setenv("LOREKEEP_PENDING", str(tmp_path / "pending"))
-    monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
 
     raw_root = tmp_path / "raw"
     raw_root.mkdir(parents=True)

{lorekeep-0.3.0 → lorekeep-0.4.0}/tests/test_compile_cli.py

@@ -6,13 +6,12 @@ from lorekeep.cli import app
 runner = CliRunner()
 
 
-def test_compile_command_uses_config_provider(monkeypatch, tmp_path: Path, fixtures: Path):
+def test_compile_command_uses_config_provider(patch_make_provider, monkeypatch, tmp_path: Path, fixtures: Path):
     # point the CLI at temp dirs via env
     monkeypatch.setenv("LOREKEEP_RAW", str(tmp_path / "raw"))
     monkeypatch.setenv("LOREKEEP_OUT", str(tmp_path / "graph"))
     monkeypatch.setenv("LOREKEEP_CACHE", str(tmp_path / "cache.json"))
     monkeypatch.setenv("LOREKEEP_SCHEMA", str(fixtures / "schema.json"))
-    monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
 
     raw = tmp_path / "raw/backend/payments.md"
     raw.parent.mkdir(parents=True)