lorekeep 0.2.1__tar.gz → 0.3.0__tar.gz

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

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

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

@@ -1,11 +1,19 @@
 # Changelog
 
+## [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.0}/PKG-INFO

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

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

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

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

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

@@ -319,8 +319,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 +352,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 +373,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 +491,89 @@ 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 = (
+        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
+    )
+
+    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(

lorekeep-0.3.0/tests/test_init_chain.py

@@ -0,0 +1,178 @@
+"""Tests for the zero-friction init chain: import → compile → daemon."""
+import json
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+from typer.testing import CliRunner
+
+from lorekeep.cli import app
+
+runner = CliRunner()
+
+
+def _setup_env(tmp_path: Path, monkeypatch, fake_provider=True):
+    home = tmp_path / "home"
+    project = tmp_path / "project"
+    fake_home = tmp_path / "fakehome"
+    project.mkdir()
+    fake_home.mkdir()
+    monkeypatch.setenv("LOREKEEP_HOME", str(home))
+    monkeypatch.setenv("HOME", str(fake_home))
+    monkeypatch.setenv("LOREKEEP_DEV", "0")
+    monkeypatch.chdir(project)
+    monkeypatch.setattr("pathlib.Path.home", lambda: fake_home)
+    monkeypatch.setattr("lorekeep.integrations.detect.shutil.which", lambda _: None)
+    monkeypatch.delenv("OPENCODE", raising=False)
+    monkeypatch.delenv("CLAUDECODE", raising=False)
+    if fake_provider:
+        monkeypatch.setenv("LOREKEEP_PROVIDER", "fake")
+    return home, project
+
+
+# ── Init chains into compile ──────────────────────────────────────────────
+
+
+def test_init_compiles_with_fake_provider(tmp_path: Path, monkeypatch):
+    """init --yes with LOREKEEP_PROVIDER=fake should auto-compile facts.jsonl."""
+    home, project = _setup_env(tmp_path, monkeypatch)
+
+    result = runner.invoke(app, ["init", "--yes", "--no-watch"])
+    assert result.exit_code == 0, result.stdout
+
+    facts = home / "graph" / "facts.jsonl"
+    assert facts.exists(), f"facts.jsonl not created: {result.stdout}"
+    lines = [json.loads(l) for l in facts.read_text().strip().splitlines() if l.strip()]
+    assert any(f["id"] == "svc:payments-api" for f in lines)
+
+
+def test_init_skips_compile_without_api_key(tmp_path: Path, monkeypatch):
+    """init --yes without provider key should skip compile gracefully."""
+    home, project = _setup_env(tmp_path, monkeypatch, fake_provider=False)
+
+    result = runner.invoke(app, ["init", "--yes", "--no-watch"])
+    assert result.exit_code == 0, result.stdout
+
+    assert not (home / "graph" / "facts.jsonl").exists()
+    assert "compile" in result.stdout.lower() or "empty" in result.stdout.lower()
+
+
+# ── Init auto-imports Claude memory ───────────────────────────────────────
+
+
+def test_init_imports_claude_memory(tmp_path: Path, monkeypatch):
+    """init should quick-import Claude memory files if a session is found."""
+    home, project = _setup_env(tmp_path, monkeypatch)
+
+    fake_session = tmp_path / "session"
+    (fake_session / "memory").mkdir(parents=True)
+    (fake_session / "memory" / "note.md").write_text("# Important\nSession knowledge.\n")
+
+    monkeypatch.setattr(
+        "lorekeep.importer.claude.find_current_session",
+        lambda: fake_session,
+    )
+
+    result = runner.invoke(app, ["init", "--yes", "--no-watch"])
+    assert result.exit_code == 0, result.stdout
+
+    imported = home / "raw" / "claude-memory" / "note.md"
+    assert imported.exists()
+    assert "imported" in result.stdout.lower()
+
+
+# ── Init starts daemon ────────────────────────────────────────────────────
+
+
+def test_init_starts_daemon(tmp_path: Path, monkeypatch):
+    """init --watch in interactive mode should spawn agent watch."""
+    home, project = _setup_env(tmp_path, monkeypatch)
+    monkeypatch.setattr("lorekeep.cli._is_interactive", lambda: True)
+
+    mock_proc = MagicMock()
+    mock_proc.pid = 99999
+    mock_popen = MagicMock(return_value=mock_proc)
+    monkeypatch.setattr("subprocess.Popen", mock_popen)
+
+    result = runner.invoke(app, ["init", "--yes"])
+    assert result.exit_code == 0, result.stdout
+
+    mock_popen.assert_called_once()
+    cmd = mock_popen.call_args[0][0]
+    assert "agent" in cmd
+    assert "watch" in cmd
+
+    pid_file = home / "agent.pid"
+    assert pid_file.exists()
+    assert pid_file.read_text().strip() == "99999"
+
+
+def test_init_skips_daemon_in_noninteractive(tmp_path: Path, monkeypatch):
+    """init --watch in non-interactive mode should not spawn daemon."""
+    home, project = _setup_env(tmp_path, monkeypatch)
+    # _is_interactive() returns False in CliRunner by default
+
+    mock_popen = MagicMock()
+    monkeypatch.setattr("subprocess.Popen", mock_popen)
+
+    result = runner.invoke(app, ["init", "--yes"])
+    assert result.exit_code == 0, result.stdout
+
+    mock_popen.assert_not_called()
+    assert "non-interactive" in result.stdout.lower()
+
+
+def test_init_rerun_revives_dead_daemon(tmp_path: Path, monkeypatch):
+    """Re-running init should start daemon if it's not running, even if config exists."""
+    home, project = _setup_env(tmp_path, monkeypatch)
+    monkeypatch.setattr("lorekeep.cli._is_interactive", lambda: True)
+
+    # First init creates config
+    runner.invoke(app, ["init", "--yes", "--no-watch"])
+
+    # Simulate dead daemon: stale PID file pointing to nonexistent process
+    pid_path = home / "agent.pid"
+    pid_path.write_text("999999")
+
+    mock_proc = MagicMock()
+    mock_proc.pid = 88888
+    mock_popen = MagicMock(return_value=mock_proc)
+    monkeypatch.setattr("subprocess.Popen", mock_popen)
+
+    result = runner.invoke(app, ["init", "--yes"])
+    assert result.exit_code == 0, result.stdout
+
+    mock_popen.assert_called_once()
+    assert pid_path.read_text().strip() == "88888"
+
+
+# ── Init creates pending/ dir ─────────────────────────────────────────────
+
+
+def test_init_creates_pending_dir(tmp_path: Path, monkeypatch):
+    """init should create the pending/ directory for journals."""
+    home, project = _setup_env(tmp_path, monkeypatch)
+
+    result = runner.invoke(app, ["init", "--yes", "--no-watch"])
+    assert result.exit_code == 0, result.stdout
+
+    assert (home / "pending").is_dir()
+
+
+# ── Init idempotent re-run ────────────────────────────────────────────────
+
+
+def test_init_rerun_skips_chain(tmp_path: Path, monkeypatch):
+    """Re-running init on existing config should not re-chain."""
+    home, project = _setup_env(tmp_path, monkeypatch)
+
+    result1 = runner.invoke(app, ["init", "--yes", "--no-watch"])
+    assert result1.exit_code == 0
+
+    mock_popen = MagicMock()
+    monkeypatch.setattr("subprocess.Popen", mock_popen)
+
+    result2 = runner.invoke(app, ["init", "--yes"])
+    assert result2.exit_code == 0, result2.stdout
+
+    mock_popen.assert_not_called()
+    assert "already initialized" in result2.stdout.lower()

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

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