deja-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{deja_cli-0.2.0 → deja_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deja-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: Local-first persistent memory CLI for coding agents
 Author-email: Mike <mike@bigtreeproduction.com>
 License: MIT

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/core/extractor.py

@@ -97,15 +97,25 @@ async def extract_memories(
 
     user_prompt = f"Session transcript/summary to extract memories from:\n\n{transcript}"
 
-    try:
-        result = await adapter.complete_structured(
-            system=EXTRACTION_SYSTEM,
-            user=user_prompt,
-            schema=EXTRACTION_SCHEMA,
-        )
-    except Exception as e:
-        logger.error("Extraction LLM error: %s", e)
-        return []
+    # Bug R2 (2026-04-22): let adapter / transport / JSON-parse errors
+    # propagate. The previous ``except Exception: return []`` made every
+    # LLM outage indistinguishable from "the model had nothing to
+    # extract." The watcher's ``_process`` then treated the empty list
+    # as a successful extraction and stamped ``_processed[path]`` —
+    # silently burning the transcript. Same bug class as H5 on the read
+    # side. Callers decide:
+    #
+    # - Watcher (``deja/ingest/watchers/base.py``) wraps this call in
+    #   its own try/except and routes to ``_schedule_extraction_retry``
+    #   (bounded N8/P2 backoff: 30s / 2min / 10min, then give up loudly).
+    # - CLI callers (``deja save-session``, ``deja ingest-skills``,
+    #   ``deja backfill``) catch and either exit cleanly or log + skip
+    #   the one file and continue.
+    result = await adapter.complete_structured(
+        system=EXTRACTION_SYSTEM,
+        user=user_prompt,
+        schema=EXTRACTION_SCHEMA,
+    )
 
     memories = result.get("memories", [])
     if not isinstance(memories, list):

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/core/reflection.py

@@ -336,6 +336,37 @@ class ReflectionEngine:
         await self.store.set_reflection_meta(None, last_archive_at=_now_iso())
         return count
 
+    async def run_dedup_fuzzy(self, project: Optional[str] = None) -> dict:
+        """Bug R4 (2026-04-22): wire fuzzy dedup into scheduled reflection.
+
+        ``MaintenanceService.dedup_fuzzy`` has shipped since the Phase 7
+        restructure but was never invoked from ``run_full`` — while
+        docstrings (MemoryStore, SaveService, MaintenanceService) and
+        user-facing docs (code-reading-guide, plan.md, AGENTS.md,
+        GEMINI.md, repo-strategic-assessment) all asserted it ran at
+        reflection time. Save-side dedup stayed exact-match only, so
+        two-character edits accumulated forever and the vault's
+        top-ranked results filled with near-duplicates over time.
+        Returns ``{"merged": N, "archived": N}``.
+
+        When ``project is None``, fan out per-project + globals (mirrors
+        ``run_reflector(None)``'s N2 pattern). The underlying service's
+        ``dedup_fuzzy(project=None)`` touches only the global bucket
+        because ``fetch_active(None)`` is global-only by convention —
+        so a single call would silently leave every project-scoped
+        near-duplicate unmerged. Fanning out keeps the scheduled pass
+        honest.
+        """
+        if project is not None:
+            return await self.store.dedup_fuzzy(project=project)
+        merged = 0
+        archived = 0
+        for p in await self.store.list_memory_projects():
+            result = await self.store.dedup_fuzzy(project=p)
+            merged += result.get("merged", 0)
+            archived += result.get("archived", 0)
+        return {"merged": merged, "archived": archived}
+
     # ── Agent mode ─────────────────────────────────────────────────────────
 
     async def agent_mode_prompt(self, project: Optional[str] = None) -> str:
@@ -354,26 +385,53 @@ class ReflectionEngine:
         lines = [
             f"You are acting as a memory reflector for project '{project_label}'.",
             "",
-            f"Review the {len(memories)} active memories below and identify any that should be:",
-            f"  1. Archived (stale, no longer relevant):",
-            f"       deja archive <id>",
-            f"  2. Invalidated (contradicted by newer information):",
-            f"       deja invalidate <id>",
-            f"  3. Consolidated (two memories express the same thing):",
-            f"       deja archive <id1>",
-            f"       deja archive <id2>",
+            f"PROCESS EVERY ONE of the {len(memories)} active memories below — not just",
+            "whatever topic the user happened to ask about in this session. The default",
+            "mode of `deja reflect --agent-mode` is a complete sweep: comb every row,",
+            "build a punch list of all obvious issues, then execute the punch list in",
+            "one pass.",
+            "",
+            "Scan for, in roughly this priority order:",
+            "  - Exact-content duplicates (same words across multiple IDs — pick the",
+            "    one with highest reuse_count, archive the rest)",
+            "  - Scope-leaks (same content saved at scope:global AND scope:project:X —",
+            "    keep the correctly-scoped one, archive the other)",
+            "  - Junk / save errors (single-word patterns, truncated content, malformed",
+            "    entries)",
+            "  - Stale stub TODO lists ('next items: 1. X, 2. Y') — typically archive",
+            "  - Untriggered gotchas tied to a specific command boundary (add --trigger)",
+            "  - Misclassified entries (pattern that is really a gotcha; gotcha that is",
+            "    really a preference)",
+            "  - Semantic duplicates (same rule, different wording — fuzzy threshold",
+            "    won't catch these, you must)",
+            "",
+            "Actions:",
+            "  1. Archive (stale, no longer relevant):",
+            "       deja archive <id>",
+            "  2. Invalidate (actively contradicted by newer information):",
+            "       deja invalidate <id>",
+            "  3. Consolidate (two or more memories express the same thing):",
+            "       deja archive <id1>",
+            "       deja archive <id2>",
             f'       deja save "<condensed content>" --type <type>{project_flag}',
-            f"  4. Trigger-tagged (gotcha clearly tied to a specific command but has no trigger):",
-            f'       deja update <id> --trigger "cmd1, cmd2"',
-            f"       Use this for gotchas about what to do right before/after a specific command.",
-            f"       Example triggers: 'kubectl apply', 'alembic upgrade', 'terraform apply'.",
-            f"       Only tag gotchas — not preferences, decisions, or progress.",
-            f"  5. Reclassified (saved as the wrong type — e.g. pattern that is really a gotcha):",
-            f"       deja update <id> --type gotcha",
+            "     (If one existing version is clearly better, just archive the lesser",
+            "     and keep the better as-is — no new save needed.)",
+            "  4. Trigger-tag (gotcha clearly tied to a specific command, no trigger yet):",
+            '       deja update <id> --trigger "cmd1, cmd2"',
+            "       Use this for gotchas about what to do right before/after a specific",
+            "       command. Example triggers: 'kubectl apply', 'alembic upgrade',",
+            "       'terraform apply'. Only tag gotchas — not preferences, decisions,",
+            "       or progress.",
+            "  5. Reclassify (saved as the wrong type — e.g. pattern that is really a",
+            "     gotcha):",
+            "       deja update <id> --type gotcha",
             "",
-            "Be conservative — only act on memories that clearly need attention.",
-            "For trigger tagging: if a gotcha is already tagged (shown as [trigger:...]), skip it.",
-            "If everything looks good, do nothing.",
+            "Be conservative on each ACTION (skip a memory when intent is unclear),",
+            "but exhaustive on COVERAGE (visit every memory, not just user-flagged ones).",
+            "For trigger tagging: if a gotcha is already tagged (shown as [trigger:...]),",
+            "skip it.",
+            f"If after sweeping all {len(memories)} you find nothing actionable, that's",
+            "fine — say so.",
             "",
             "--- MEMORIES ---",
             "",
@@ -395,7 +453,15 @@ class ReflectionEngine:
     # ── Full pass + auto-trigger ────────────────────────────────────────────
 
     async def run_full(self, project: Optional[str] = None) -> dict:
-        """Full reflection pass: observer → reflector → decay → promote → archive."""
+        """Full reflection pass: observer → reflector → decay → promote → dedup_fuzzy → archive.
+
+        Bug R4 (2026-04-22): ``dedup_fuzzy`` slots between ``promote``
+        and ``archive`` — after promotion (so promoted patterns are in
+        the active set for cross-project dedup) and before archival (so
+        archive sweeps low-confidence rows AFTER near-duplicates have
+        been merged, giving the survivor the full merged confidence/
+        reuse bump).
+        """
         results: dict = {}
         if self.adapter:
             results["observer"] = await self.run_observer(project)
@@ -405,6 +471,7 @@ class ReflectionEngine:
             results["reflector"] = 0
         results["decay"] = await self.run_decay()
         results["promote"] = await self.run_promote()
+        results["dedup_fuzzy"] = await self.run_dedup_fuzzy(project)
         results["archive"] = await self.run_archive()
         return results
 

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/core/store/__init__.py

@@ -267,6 +267,21 @@ class MemoryStore:
     async def archive_below_threshold(self, threshold: float) -> int:
         return await self._maint().archive_below_threshold(threshold)
 
+    async def dedup_fuzzy(
+        self, project: Optional[str] = None, threshold: Optional[float] = None
+    ) -> dict:
+        """Token-overlap dedup across active memories for the scope.
+
+        Merges near-duplicates (overlap > ``threshold``) into the older
+        row and archives the newer — preserves audit trail via archive,
+        never deletes. Returns ``{"merged": N, "archived": N}``.
+        Idempotent. See ``MaintenanceService.dedup_fuzzy``.
+        """
+        # Keep policy default in the service so the facade stays thin.
+        if threshold is None:
+            return await self._maint().dedup_fuzzy(project=project)
+        return await self._maint().dedup_fuzzy(project=project, threshold=threshold)
+
     async def increment_reuse_count(self, project: Optional[str] = None) -> int:
         return await self._maint().increment_reuse_count(project)
 
@@ -544,6 +559,17 @@ class MemoryStore:
         db = await self._connection.get()
         return await self._obs().list_distinct_projects(db)
 
+    async def list_memory_projects(self) -> list[Optional[str]]:
+        """Distinct project values with at least one active memory.
+
+        Used by ``ReflectionEngine.run_dedup_fuzzy(None)`` (Bug R4,
+        2026-04-22) to fan dedup out across every scope instead of
+        touching only globals (the historical ``dedup_fuzzy(None)``
+        semantics).
+        """
+        db = await self._connection.get()
+        return await self._mem().list_active_projects(db)
+
     async def replace_observations(
         self, project: Optional[str], new_texts: list[str],
         *,

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/core/store/policy.py

@@ -12,9 +12,12 @@ from __future__ import annotations
 
 # ── dedup ──────────────────────────────────────────────────────────────────────
 
-# On save, a candidate memory with token-overlap above this ratio against
-# an existing memory of the same type+scope is treated as a duplicate:
-# instead of inserting, we bump the existing row's confidence.
+# At reflection time (MaintenanceService.dedup_fuzzy → ReflectionEngine.run_full),
+# a candidate memory with token-overlap above this ratio against an existing
+# memory of the same type+scope+project is treated as a near-duplicate: the
+# survivor's confidence and reuse_count are bumped, the loser is archived.
+# Save-time dedup is exact-match only (idx_memories_dedup composite index)
+# to keep the hot path <1ms; fuzzy work batches into reflection (R4, 2026-04-22).
 DEDUP_OVERLAP_THRESHOLD: float = 0.8
 
 # How much to add to an existing memory's confidence when a dedup match

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/core/store/repos/memories.py

@@ -117,6 +117,23 @@ class MemoryRepository:
             rows = await cur.fetchall()
         return [Memory.from_row(r) for r in rows]
 
+    async def list_active_projects(
+        self, db: aiosqlite.Connection
+    ) -> list[Optional[str]]:
+        """Distinct ``project`` values with at least one active memory.
+
+        Includes ``None`` (global bucket) iff any active global rows
+        exist. Parallels ``ObservationRepository.list_distinct_projects``
+        and is used by ``ReflectionEngine.run_dedup_fuzzy(None)`` (Bug
+        R4, 2026-04-22) to fan out dedup across every scope instead of
+        operating only on globals.
+        """
+        async with db.execute(
+            f"SELECT DISTINCT project FROM memories WHERE {ACTIVE_FILTER}"
+        ) as cur:
+            rows = await cur.fetchall()
+        return [r["project"] for r in rows]
+
     async def fetch_for_sync(self, db: aiosqlite.Connection) -> list[Memory]:
         """Active + archived memories across every scope, for cloud sync push.
 

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/interfaces/cli/backfill.py

@@ -275,7 +275,15 @@ def register(app: typer.Typer) -> None:
                             typer.echo(f"  [dry-run] summary.md  ({len(content)} chars)")
                             continue
 
-                        memories = await extract_memories(content, proj_name, "backfill", adapter)
+                        try:
+                            memories = await extract_memories(content, proj_name, "backfill", adapter)
+                        except Exception as e:
+                            # Bug R2 (2026-04-22): extract_memories now raises on
+                            # adapter / transport failures. Log + skip this one
+                            # source so a transient LLM blip doesn't abort the
+                            # whole backfill run.
+                            typer.echo(f"  summary.md  (extraction failed: {e}, skipped)", err=True)
+                            continue
                         total_memories += await _embed_and_save(memories, store, embedding_adapter)
                         typer.echo(f"  summary.md  → {len(memories)} memories")
 
@@ -290,7 +298,13 @@ def register(app: typer.Typer) -> None:
                             typer.echo(f"  [dry-run] sessions-index.json  ({entry_count} sessions)")
                         else:
                             entry_count = len(json.loads(index_file.read_text()).get("entries", []))
-                            memories = await extract_memories(transcript, proj_name, "backfill", adapter)
+                            try:
+                                memories = await extract_memories(transcript, proj_name, "backfill", adapter)
+                            except Exception as e:
+                                # Bug R2 (2026-04-22): skip this source on
+                                # extraction failure instead of aborting.
+                                typer.echo(f"  sessions-index.json  (extraction failed: {e}, skipped)", err=True)
+                                continue
                             total_memories += await _embed_and_save(memories, store, embedding_adapter)
                             typer.echo(f"  sessions-index.json  ({entry_count} sessions) → {len(memories)} memories")
 
@@ -309,7 +323,13 @@ def register(app: typer.Typer) -> None:
                                 typer.echo(f"  [dry-run] {jsonl_file.name}  ({len(transcript)} chars)")
                                 continue
 
-                            memories = await extract_memories(transcript, proj_name, "backfill", adapter)
+                            try:
+                                memories = await extract_memories(transcript, proj_name, "backfill", adapter)
+                            except Exception as e:
+                                # Bug R2 (2026-04-22): skip this jsonl on
+                                # extraction failure; keep processing others.
+                                typer.echo(f"  {jsonl_file.name}  (extraction failed: {e}, skipped)", err=True)
+                                continue
                             total_memories += await _embed_and_save(memories, store, embedding_adapter)
                             typer.echo(f"  {jsonl_file.name}  → {len(memories)} memories")
 

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/interfaces/cli/maintenance.py

@@ -61,6 +61,12 @@ def register(app: typer.Typer) -> None:
                 lines.append(f"  Decay:     {results['decay']} memories decayed")
             if results.get("promote"):
                 lines.append(f"  Promote:   {results['promote']} patterns promoted to global")
+            dedup = results.get("dedup_fuzzy") or {}
+            if dedup.get("merged") or dedup.get("archived"):
+                lines.append(
+                    f"  Dedup:     {dedup.get('merged', 0)} merged, "
+                    f"{dedup.get('archived', 0)} near-duplicates archived"
+                )
             if results.get("archive"):
                 lines.append(f"  Archive:   {results['archive']} memories archived")
             if len(lines) == 1:

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/interfaces/cli/session.py

@@ -122,9 +122,17 @@ def register(app: typer.Typer) -> None:
             await store.init_db()
             try:
                 from deja.core.extractor import extract_memories
-                memories = await extract_memories(
-                    content, project or "unknown", "save-session", adapter
-                )
+                # Bug R2 (2026-04-22): extract_memories now raises on
+                # transport / adapter / JSON-parse failures instead of
+                # returning []. Catch and exit cleanly so the user sees
+                # the real cause instead of a bare traceback.
+                try:
+                    memories = await extract_memories(
+                        content, project or "unknown", "save-session", adapter
+                    )
+                except Exception as e:
+                    typer.echo(f"Extraction failed: {e}", err=True)
+                    raise typer.Exit(1)
                 embedding_adapter = await create_embedding_adapter(config)
                 saved = await _embed_and_save(memories, store, embedding_adapter)
                 return saved
@@ -186,7 +194,15 @@ def register(app: typer.Typer) -> None:
                 from deja.core.extractor import extract_memories
                 return await extract_memories(content, project or "unknown", "ingest-skills", adapter)
 
-            memories = asyncio.run(_extract())
+            # Bug R2 (2026-04-22): extract_memories propagates adapter
+            # errors; catch and exit cleanly with the error message.
+            try:
+                memories = asyncio.run(_extract())
+            except typer.Exit:
+                raise
+            except Exception as e:
+                typer.echo(f"Extraction failed: {e}", err=True)
+                raise typer.Exit(1)
             if not memories:
                 typer.echo("Extraction returned no memories. Try --no-llm or check the file format.", err=True)
                 raise typer.Exit(1)

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/interfaces/cli/setup.py

@@ -359,6 +359,31 @@ def _detect_deja_setup(target_path: Path, agent: str) -> list[str]:
 
 def _install_claude_hooks() -> None:
     """Write hook scripts and register them in ~/.claude/settings.json."""
+    # Bug R1 (2026-04-22): validate settings.json BEFORE any disk writes.
+    # Previously this function parsed settings.json with
+    # ``except json.JSONDecodeError: settings = {}`` then overwrote the
+    # file. A user with any syntax error (stray comma, unmatched
+    # bracket, half-finished hand edit) lost every other hook,
+    # permission rule, MCP server registration, env var, and status-line
+    # entry they had configured — replaced with just Deja's four hook
+    # entries, with zero log or prompt. Refuse loudly instead; the user
+    # fixes the syntax error and re-runs. The on-disk bytes stay
+    # untouched on the failure path.
+    settings_path = Path("~/.claude/settings.json").expanduser()
+    settings_text = settings_path.read_text(encoding="utf-8") if settings_path.exists() else ""
+    if settings_text.strip():
+        try:
+            settings = json.loads(settings_text)
+        except json.JSONDecodeError as e:
+            typer.echo(
+                f"deja: refusing to proceed — ~/.claude/settings.json is not valid "
+                f"JSON ({e}). Fix the syntax error and re-run `deja setup claude-code`.",
+                err=True,
+            )
+            raise typer.Exit(1)
+    else:
+        settings = {}
+
     hooks_dir = Path("~/.claude/hooks").expanduser()
     hooks_dir.mkdir(parents=True, exist_ok=True)
 
@@ -378,13 +403,6 @@ def _install_claude_hooks() -> None:
         display = str(path).replace(str(Path.home()), "~")
         typer.echo(f"deja: hooks installed → {display}")
 
-    settings_path = Path("~/.claude/settings.json").expanduser()
-    settings_text = settings_path.read_text(encoding="utf-8") if settings_path.exists() else ""
-    try:
-        settings = json.loads(settings_text) if settings_text.strip() else {}
-    except json.JSONDecodeError:
-        settings = {}
-
     hooks_obj = settings.setdefault("hooks", {})
     changed = False
 

{deja_cli-0.2.0 → deja_cli-0.2.1}/deja/interfaces/mcp_server.py

@@ -109,15 +109,32 @@ async def memory_save(
             "limit": e.limit,
         })
 
+    # Bug R3 (2026-04-22): surface the cloud-push outcome to the agent.
+    # Previously the ``(ok, msg)`` tuple returned by ``push_memory`` was
+    # discarded and the response was always ``{"status": "saved"}`` —
+    # so an agent with an expired PAT saw every save "succeed" while
+    # memories silently piled up local-only until the user ran
+    # ``deja sync`` by hand. The agent now sees ``cloud`` in
+    # {"ok", "skipped", "failed"} and can react (surface to user,
+    # prompt re-login) instead of trusting a misleading success.
+    cloud_status = "skipped"
+    cloud_reason: Optional[str] = None
     if config.cloud.sync_on_save:
         from deja.cloud import get_token, push_memory
         if get_token(config):
             # Bug N5 (2026-04-19): trigger → triggerCmds translation now lives
             # in ``_sanitize_for_push``; eager push delegates to the same path
             # as batch ``sync_push`` so the three codepaths can't drift again.
-            push_memory(result.cloud_data, config)
-
-    return json.dumps({"id": result.id, "status": "saved"})
+            ok, msg = push_memory(result.cloud_data, config)
+            cloud_status = "ok" if ok else "failed"
+            cloud_reason = None if ok else msg
+
+    return json.dumps({
+        "id": result.id,
+        "status": "saved",
+        "cloud": cloud_status,
+        "cloud_reason": cloud_reason,
+    })
 
 
 @mcp.tool()

{deja_cli-0.2.0 → deja_cli-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deja-cli"
-version = "0.2.0"
+version = "0.2.1"
 description = "Local-first persistent memory CLI for coding agents"
 readme = "README.pypi.md"
 license = { text = "MIT" }