argus-code 0.5.0__tar.gz → 0.5.1__tar.gz

{argus_code-0.5.0 → argus_code-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: argus-code
-Version: 0.5.0
+Version: 0.5.1
 Summary: Local-first dashboard for Claude Code cost, token, tool-usage, and full-text search analytics
 Project-URL: Homepage, https://github.com/KrishBhimani/argus-code
 Project-URL: Repository, https://github.com/KrishBhimani/argus-code.git

{argus_code-0.5.0 → argus_code-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "argus-code"
-version = "0.5.0"
+version = "0.5.1"
 description = "Local-first dashboard for Claude Code cost, token, tool-usage, and full-text search analytics"
 readme = "README.md"
 requires-python = ">=3.11"

{argus_code-0.5.0 → argus_code-0.5.1}/python/argus/AGENTS.md

@@ -29,6 +29,16 @@ Delegated subtrees (see their own AGENTS.md): `store/`, `collector/`, `adapters/
   user-facing command, keep the old name as a `hidden=True` alias and nudge to the
   new one (precedent: `search` → `indexing`). Update help strings, the daemon
   read-only API hint, and dashboard copy together.
+- **A missing `~/.claude` is fatal for `argus start` but not for `argusd`.**
+  `CoreRuntime.start(require_adapters=True)` (the foreground default) raises
+  `NoAdaptersError` — immediate, readable feedback. The daemon
+  (`daemon/service.py`) passes `require_adapters=False`, comes up idle with the
+  DB open, and polls `CoreRuntime.try_activate()` every `adapter_poll_sec`
+  (30 s) so ingest starts by itself once the directory appears (issue #11).
+  `try_activate()` is idempotent and returns `True` only on the idle→running
+  transition, so callers can log it once. Keep `_FakeRuntime` in
+  `tests/daemon/test_service.py` signature-compatible with `CoreRuntime` — it
+  asserts the daemon requests the tolerant mode.
 - **Privacy stays intact:** no network calls or telemetry beyond opt-in
   `argus pricing refresh`. Don't add outbound calls.
 

{argus_code-0.5.0 → argus_code-0.5.1}/python/argus/__init__.py

@@ -1,3 +1,3 @@
 """Argus — local-first analytics for Claude Code and other coding agents."""
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"

{argus_code-0.5.0 → argus_code-0.5.1}/python/argus/core/runtime.py

@@ -58,18 +58,53 @@ class CoreRuntime:
         self._watcher = None
         self._scheduler = None
 
-    def start(self) -> None:
+    def start(self, *, require_adapters: bool = True) -> None:
+        """Open the DB and begin ingesting.
+
+        ``require_adapters=False`` is for long-running services (argusd): a
+        missing ``~/.claude`` is a "not yet" rather than an error, so we come up
+        idle and let :meth:`try_activate` pick things up when the directory
+        appears. The foreground ``argus start`` keeps the default, because
+        failing immediately with a clear message is better feedback there.
+        """
         self._db = open_db(self._data_dir / "argus.db", read_only=self.read_only)
         self.repo = Repository(self._db)
+        self.pricing_table = load_pricing_table()
 
         self.adapters = available_adapters()
         if not self.adapters:
-            raise NoAdaptersError(
-                "No adapter data found. Argus expects ~/.claude/ (Claude Code) "
-                "to be present at minimum."
+            if require_adapters:
+                raise NoAdaptersError(
+                    "No adapter data found. Argus expects ~/.claude/ (Claude Code) "
+                    "to be present at minimum."
+                )
+            logger.warning(
+                "No agent data found (~/.claude/ is missing). Staying up and "
+                "watching for it — ingest starts automatically once it appears."
             )
+            return
+
+        self._activate()
+
+    def try_activate(self) -> bool:
+        """Start ingesting if adapters have appeared since startup.
+
+        Returns True only on the transition from "nothing to do" to "running",
+        so callers can log it once. Cheap and idempotent — safe to poll.
+        """
+        if self.adapters or self.repo is None or self.read_only:
+            return False
+        found = available_adapters()
+        if not found:
+            return False
+        self.adapters = found
+        self._activate()
+        return True
+
+    def _activate(self) -> None:
+        """Kick off first-pass ingest, the watcher, and the detector scheduler."""
+        assert self.repo is not None and self.pricing_table is not None
         logger.info("Detected adapters: %s", ", ".join(a.agent for a in self.adapters))
-        self.pricing_table = load_pricing_table()
 
         if self.read_only:
             logger.info("argusd active — dashboard read-only (no ingest/scheduler).")

{argus_code-0.5.0 → argus_code-0.5.1}/python/argus/daemon/service.py

@@ -33,6 +33,7 @@ def run_foreground(
     *,
     stop_event: threading.Event | None = None,
     install_signals: bool = True,
+    adapter_poll_sec: float = 30.0,
 ) -> None:
     data_dir = Path(data_dir)
     stop_event = stop_event or threading.Event()
@@ -61,9 +62,16 @@ def run_foreground(
     pidfile.write(data_dir, me)
     runtime = CoreRuntime(data_dir, read_only=False)
     try:
-        runtime.start()
+        # A missing ~/.claude must not kill the service. On a fresh machine, or
+        # one where Claude Code simply hasn't been launched yet, argusd comes up
+        # idle and waits for the directory instead of exiting (issue #11).
+        runtime.start(require_adapters=False)
         logger.info("argusd started (PID %d).", me)
-        stop_event.wait()
+        # Wake periodically so ingest can begin by itself once ~/.claude shows
+        # up; try_activate() is a no-op once we're running.
+        while not stop_event.wait(adapter_poll_sec):
+            if runtime.try_activate():
+                logger.info("Agent data appeared — ingest started.")
     finally:
         runtime.stop()
         pidfile.remove(data_dir)

argus_code-0.5.1/tests/daemon/test_no_claude_dir.py

@@ -0,0 +1,162 @@
+"""argusd must survive a missing ``~/.claude`` — issue #11.
+
+``CoreRuntime.start()`` raises ``NoAdaptersError`` when no adapter reports
+``is_present()``, and ``ClaudeCodeAdapter.is_present()`` is just "does
+``~/.claude`` exist". In ``service.run_foreground`` that exception propagates
+straight out of ``runtime.start()``, so the ``finally`` tears down and removes
+the pidfile and the process exits — on a fresh machine, or one where Claude
+Code simply hasn't been launched yet, the daemon refuses to stay up.
+
+A long-running service should tolerate the directory being absent and start
+working once it appears. The *foreground* ``argus start`` raising immediately is
+useful feedback and is deliberately kept.
+"""
+from __future__ import annotations
+
+import sqlite3
+import threading
+from pathlib import Path
+
+import pytest
+
+from argus.adapters.claude_code import adapter as cc_adapter
+from argus.core.runtime import CoreRuntime, NoAdaptersError
+from argus.daemon import service
+
+
+@pytest.fixture
+def fake_home(tmp_path: Path, monkeypatch):
+    """Point the Claude Code adapter at a home that has no .claude/ yet."""
+    home = tmp_path / "home"
+    home.mkdir()
+    monkeypatch.setattr(cc_adapter, "_default_root", lambda: home / ".claude")
+    return home
+
+
+def test_foreground_start_still_raises(fake_home, tmp_path: Path):
+    """`argus start` keeps its immediate, friendly failure — that's useful."""
+    rt = CoreRuntime(tmp_path / "data")
+    try:
+        with pytest.raises(NoAdaptersError):
+            rt.start()
+    finally:
+        rt.stop()
+
+
+def test_daemon_start_does_not_raise_when_claude_is_missing(fake_home, tmp_path: Path):
+    rt = CoreRuntime(tmp_path / "data")
+    try:
+        rt.start(require_adapters=False)  # must not raise
+        assert rt.adapters == []
+        assert rt.repo is not None, "the DB should still be open and usable"
+    finally:
+        rt.stop()
+
+
+def test_daemon_activates_once_claude_appears(fake_home, tmp_path: Path):
+    """The whole point: come up idle, then start working by itself."""
+    rt = CoreRuntime(tmp_path / "data")
+    try:
+        rt.start(require_adapters=False)
+        assert rt.try_activate() is False, "nothing to activate yet"
+
+        proj = fake_home / ".claude" / "projects" / "p"
+        proj.mkdir(parents=True)
+        (proj / "s1.jsonl").write_text(
+            '{"type":"user","message":{"role":"user","content":"hi"}}\n',
+            encoding="utf-8",
+        )
+
+        assert rt.try_activate() is True, "should pick up the new ~/.claude"
+        assert [a.agent for a in rt.adapters] == ["claude_code"]
+        # Idempotent: a second call must not start a second watcher/scheduler.
+        assert rt.try_activate() is False
+    finally:
+        rt.stop()
+
+
+def test_run_foreground_stays_alive_without_claude(fake_home, tmp_path: Path):
+    """The daemon process must not exit; it must sit waiting for work."""
+    data_dir = tmp_path / "data"
+    stop = threading.Event()
+    error: list[BaseException] = []
+
+    def run() -> None:
+        try:
+            service.run_foreground(
+                data_dir, stop_event=stop, install_signals=False, adapter_poll_sec=0.05
+            )
+        except BaseException as e:  # noqa: BLE001
+            error.append(e)
+
+    t = threading.Thread(target=run, daemon=True)
+    t.start()
+    try:
+        # Give it long enough to have crashed if it were going to.
+        t.join(2.0)
+        assert t.is_alive(), f"daemon exited instead of waiting; error={error}"
+        assert not error, f"daemon raised: {error}"
+    finally:
+        stop.set()
+        t.join(10)
+    assert not error, f"daemon raised on shutdown: {error}"
+
+
+def test_run_foreground_picks_up_claude_created_while_running(
+    fake_home, tmp_path: Path
+):
+    data_dir = tmp_path / "data"
+    stop = threading.Event()
+    error: list[BaseException] = []
+
+    def run() -> None:
+        try:
+            service.run_foreground(
+                data_dir, stop_event=stop, install_signals=False, adapter_poll_sec=0.05
+            )
+        except BaseException as e:  # noqa: BLE001
+            error.append(e)
+
+    t = threading.Thread(target=run, daemon=True)
+    t.start()
+    try:
+        # Must be an *assistant* line: the pipeline deliberately creates no
+        # session row for a file with no turns, so a user-only line would
+        # ingest fine and still leave list_sessions() empty.
+        import json
+
+        from tests.conftest import assistant_line
+
+        proj = fake_home / ".claude" / "projects" / "p"
+        proj.mkdir(parents=True)
+        (proj / "s1.jsonl").write_text(
+            json.dumps(assistant_line("m1", 1)) + "\n", encoding="utf-8"
+        )
+        # Assert on the observable effect — data actually ingested — rather
+        # than on the daemon's internals.
+        from argus.store.db import open_db
+        from argus.store.repository import Repository
+
+        found = False
+        for _ in range(200):
+            # "The file exists" is not "the schema is ready" — SQLite creates
+            # the file the moment it is opened, before migrations run, so a
+            # fast probe queries a table-less DB. Treat every not-yet state
+            # (missing file, missing table, locked) as "keep waiting" rather
+            # than as a failure; the assert below is what decides the outcome.
+            try:
+                probe = open_db(data_dir / "argus.db", read_only=True)
+                try:
+                    found = bool(Repository(probe).list_sessions(limit=5))
+                finally:
+                    probe.close()
+            except (sqlite3.OperationalError, sqlite3.DatabaseError, OSError):
+                pass
+            if found:
+                break
+            threading.Event().wait(0.05)
+        assert found, "daemon never ingested the newly created ~/.claude"
+    finally:
+        stop.set()
+        t.join(10)
+    assert not error, f"daemon raised: {error}"

{argus_code-0.5.0 → argus_code-0.5.1}/tests/daemon/test_service.py

@@ -10,12 +10,22 @@ from argus.daemon import pidfile, service
 
 
 class _FakeRuntime:
+    """Stand-in for CoreRuntime — keep this signature-compatible with the real
+    one, or these tests pass while the daemon is broken."""
+
     def __init__(self, *a, **k):
         self.started = False
         self.stopped = False
+        self.require_adapters = None
+        self.activate_calls = 0
 
-    def start(self):
+    def start(self, *, require_adapters: bool = True):
         self.started = True
+        self.require_adapters = require_adapters
+
+    def try_activate(self) -> bool:
+        self.activate_calls += 1
+        return False
 
     def stop(self):
         self.stopped = True
@@ -41,6 +51,8 @@ def test_run_foreground_writes_pid_runs_and_cleans_up(tmp_path, monkeypatch):
         time.sleep(0.01)
     assert pidfile.read(tmp_path) is not None
     assert fake.started is True
+    # The daemon must tolerate a missing ~/.claude rather than exiting (issue #11).
+    assert fake.require_adapters is False
 
     stop.set()
     t.join(timeout=3)