lorekeep 0.2.1__tar.gz → 0.3.1__tar.gz

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

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

{lorekeep-0.2.1 → lorekeep-0.3.1}/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.2.1 → lorekeep-0.3.1}/CHANGELOG.md

@@ -1,11 +1,26 @@
 # Changelog
 
+## [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)
+
+
+### Features
+
+* zero-friction init — wire, import, compile, daemon in one command ([#55](https://github.com/manhhailua/lorekeep/issues/55)) ([26e27ad](https://github.com/manhhailua/lorekeep/commit/26e27ad70e9eae90d4ac490694b891eda01b563b))
+
 ## [0.2.1](https://github.com/manhhailua/lorekeep/compare/v0.2.0...v0.2.1) (2026-06-28)
 
 
 ### Bug Fixes
 
 * repair daemon auto-compile provider construction and re-merge journals after standalone compile ([#48](https://github.com/manhhailua/lorekeep/issues/48)) ([fb05b29](https://github.com/manhhailua/lorekeep/commit/fb05b290c5c673cc36891790d62036b8b6f65c7e))
+* resolve doc contradictions and false cadence claims ([#53](https://github.com/manhhailua/lorekeep/issues/53)) ([10fc794](https://github.com/manhhailua/lorekeep/commit/10fc79406b02d1fa5735274b3dd89c62653ed3ba))
 
 
 ### Documentation

{lorekeep-0.2.1 → lorekeep-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lorekeep
-Version: 0.2.1
+Version: 0.3.1
 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.2.1 → lorekeep-0.3.1}/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.2.1 → lorekeep-0.3.1}/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.2.1 → lorekeep-0.3.1}/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.2.1 → lorekeep-0.3.1}/pyproject.toml

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

{lorekeep-0.2.1 → lorekeep-0.3.1}/src/lorekeep/__init__.py

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

{lorekeep-0.2.1 → lorekeep-0.3.1}/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,34 +39,24 @@ 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."""
@@ -319,8 +309,12 @@ def init(
         False, "--yes", "-y",
         help="Skip interactive prompts, use defaults",
     ),
+    watch: bool = typer.Option(
+        True, "--watch/--no-watch",
+        help="Start the daemon (agent watch) in background after setup",
+    ),
 ) -> None:
-    """Bootstrap the data home: config + schema + raw/graph dirs."""
+    """Bootstrap the data home, wire agents, import sessions, compile, and start daemon."""
     p = resolve_paths()
     created = []
     p["config"].parent.mkdir(parents=True, exist_ok=True)
@@ -348,6 +342,7 @@ def init(
 
     p["raw"].mkdir(parents=True, exist_ok=True)
     p["out"].mkdir(parents=True, exist_ok=True)
+    p["pending"].mkdir(parents=True, exist_ok=True)
 
     typer.echo(f"home ready: config={p['config']}")
     typer.echo(f"  schema={p['schema']}  raw={p['raw']}  graph={p['out']}")
@@ -368,12 +363,20 @@ def init(
         (ns_dir / "about.md").write_text(about_md)
         typer.echo(f"  wrote: {ns_dir / 'about.md'}")
 
-    # Auto-detect and wire coding agents (active session or installed).
+    # --- One-click chain: wire → import → compile → daemon -----------------
     if not config_existed:
         _auto_wire_agents(p, ns)
-        typer.echo("\nNext steps:")
-        typer.echo("  1. Compile:           uvx lorekeep compile   (or LOREKEEP_PROVIDER=fake)")
-        typer.echo("  2. More agents:       uvx lorekeep mcp add --agent <claude|cursor|codex|opencode>")
+        _auto_import_and_compile(p)
+        typer.echo("\nRestart your agent → lorekeep tools are available.")
+
+    # Daemon: start on fresh init or revive if dead (regardless of config_existed)
+    if watch and _is_interactive():
+        _start_daemon(p)
+    elif watch and not _is_interactive():
+        typer.echo("\n  (skipped daemon start in non-interactive mode — run `lorekeep agent watch` manually)")
+
+    if config_existed:
+        typer.echo("\nAlready initialized.")
 
 
 def _interactive_init(p: dict) -> tuple[str, str, str]:
@@ -478,6 +481,85 @@ def _agent_writers() -> dict:
     }
 
 
+def _auto_import_and_compile(p: dict) -> None:
+    """Quick-import Claude memory files, then compile if provider is available."""
+    imported = 0
+
+    # --- Quick import: Claude memory files (zero LLM cost) ----------------
+    try:
+        from lorekeep.importer.claude import find_current_session, import_memories
+        session_dir = find_current_session()
+        if session_dir is not None and (session_dir / "memory").is_dir():
+            written = import_memories(session_dir, p["raw"], "claude-memory")
+            imported = len(written)
+            if imported:
+                typer.echo(f"  imported {imported} memory file(s) from Claude session")
+    except Exception as exc:
+        if os.environ.get("LOREKEEP_DEBUG"):
+            typer.echo(f"  import error: {exc}")
+
+    # --- Compile (if provider is usable) ----------------------------------
+    schema = load_schema(p["schema"])
+    config = load_config(p["config"])
+
+    has_key = _has_provider(config)
+
+    if not has_key:
+        if imported:
+            typer.echo("  memory files imported to raw/ — compile pending (add API key to config.yaml)")
+        else:
+            typer.echo("  graph empty — run `lorekeep compile` after adding docs or importing sessions")
+        return
+
+    try:
+        provider = _make_provider(config)
+        manifest = compile_graph(
+            raw_root=p["raw"], out_dir=p["out"], schema=schema,
+            provider=provider, cache_path=p["cache"],
+            chunk_lines=config.compile.chunk_lines,
+        )
+        pending_dir = p.get("pending")
+        if pending_dir and pending_dir.exists():
+            _do_auto_resolve(p["out"], pending_dir)
+        typer.echo(f"  compiled: {manifest.node_count} nodes, {manifest.edge_count} edges")
+    except Exception as exc:
+        typer.echo(f"  compile skipped: {exc}")
+
+
+def _start_daemon(p: dict) -> None:
+    """Start agent watch as a background process with PID + log files."""
+    import subprocess
+    import sys
+
+    pid_path = p["home"] / "agent.pid"
+    log_path = p["home"] / "agent.log"
+
+    # Check if already running
+    if pid_path.exists():
+        old_pid = pid_path.read_text().strip()
+        try:
+            os.kill(int(old_pid), 0)
+            typer.echo(f"  daemon already running (pid={old_pid})")
+            return
+        except (ProcessLookupError, ValueError):
+            pass
+
+    cmd = [sys.executable, "-m", "lorekeep.cli", "agent", "watch", "--interval", "60"]
+    log_file = open(log_path, "a")
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdout=log_file,
+            stderr=subprocess.STDOUT,
+            stdin=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    finally:
+        log_file.close()
+    pid_path.write_text(str(proc.pid))
+    typer.echo(f"  daemon started (pid={proc.pid}, log={log_path})")
+
+
 @app.command()
 def backup(
     init_remote: str = typer.Option(
@@ -544,15 +626,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:
@@ -577,7 +650,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:
@@ -601,7 +674,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.2.1 → lorekeep-0.3.1}/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.2.1 → lorekeep-0.3.1}/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.3.1/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.2.1 → lorekeep-0.3.1}/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.2.1 → lorekeep-0.3.1}/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)

{lorekeep-0.2.1 → lorekeep-0.3.1}/tests/test_import_claude.py

@@ -193,6 +193,61 @@ def test_import_session_deep_handles_empty_transcript(tmp_path: Path):
     assert result == []
 
 
+def test_import_session_deep_is_idempotent(tmp_path: Path, fixtures: Path):
+    """Re-importing the same transcript skips LLM summarization."""
+    session_dir = fixtures / "claude-session"
+    raw_root = tmp_path / "raw"
+    provider = FakeProvider(responses=["# Summary\n\n## Decisions\n- Use FastAPI\n"] * 50)
+
+    first = import_session_deep(session_dir, raw_root, namespace="test-session",
+                                provider=provider)
+    assert len(first) >= 1
+    assert len(provider.calls) >= 1
+
+    # Second call: same transcript, should skip entirely
+    call_before = len(provider.calls)
+    second = import_session_deep(session_dir, raw_root, namespace="test-session",
+                                 provider=provider)
+    assert second == []
+    assert len(provider.calls) == call_before  # no new LLM calls
+
+
+def test_import_session_deep_re_imports_on_change(tmp_path: Path):
+    """Transcript changed → re-import triggers LLM call."""
+    session_dir = tmp_path / "session"
+    session_dir.mkdir()
+    transcript = session_dir / "sess.jsonl"
+    transcript.write_text('{"role":"user","message":{"content":"what is FastAPI?"}}\n'
+                          '{"role":"assistant","message":{"content":[{"type":"text","text":"a web framework"}]}}\n')
+
+    raw_root = tmp_path / "raw"
+    provider = FakeProvider(responses=["# Summary\n\n## Decisions\n- Use FastAPI\n"] * 50)
+
+    first = import_session_deep(session_dir, raw_root, namespace="ns", provider=provider)
+    assert len(first) >= 1
+
+    # Modify transcript
+    transcript.write_text('{"role":"user","message":{"content":"what is Flask?"}}\n'
+                          '{"role":"assistant","message":{"content":[{"type":"text","text":"a web framework"}]}}\n')
+
+    call_before = len(provider.calls)
+    second = import_session_deep(session_dir, raw_root, namespace="ns", provider=provider)
+    assert len(second) >= 1
+    assert len(provider.calls) > call_before  # LLM called again
+
+
+def test_import_session_deep_dry_run_skips_manifest(tmp_path: Path, fixtures: Path):
+    """Dry run should not write manifest (so real import still processes)."""
+    session_dir = fixtures / "claude-session"
+    raw_root = tmp_path / "raw"
+    provider = FakeProvider(responses=["dummy"] * 50)
+
+    import_session_deep(session_dir, raw_root, namespace="ns",
+                        provider=provider, dry_run=True)
+    manifest_path = raw_root / "ns" / ".import-manifest.json"
+    assert not manifest_path.exists()
+
+
 # ---------------------------------------------------------------------------
 # orchestrator
 # ---------------------------------------------------------------------------

{lorekeep-0.2.1 → lorekeep-0.3.1}/tests/test_import_cursor.py

@@ -191,11 +191,10 @@ def test_import_cursor_missing_db_errors(tmp_path: Path):
 # ---------------------------------------------------------------------------
 
 
-def test_cli_import_cursor_runs(monkeypatch, tmp_path: Path, state_db: Path):
+def test_cli_import_cursor_runs(patch_make_import_provider, monkeypatch, tmp_path: Path, state_db: Path):
     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_PROVIDER", "fake")
     monkeypatch.setenv("CURSOR_STATE_DB", str(state_db))
 
     result = runner.invoke(app, ["import", "--from", "cursor"])
@@ -205,7 +204,6 @@ def test_cli_import_cursor_runs(monkeypatch, tmp_path: Path, state_db: Path):
 
 def test_cli_import_cursor_rejects_quick(monkeypatch, tmp_path: Path, state_db: Path):
     monkeypatch.setenv("CURSOR_STATE_DB", str(state_db))
-    monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
     result = runner.invoke(app, ["import", "--from", "cursor", "--quick"])
     assert result.exit_code == 1
     assert "deep-only" in result.stdout