PyPI - deja-cli - Versions diffs - 0.1.0__tar.gz → 0.1.3__tar.gz - Mend

deja-cli 0.1.0tar.gz → 0.1.3tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

{deja_cli-0.1.0 → deja_cli-0.1.3}/PKG-INFO RENAMED Viewed

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

{deja_cli-0.1.0 → deja_cli-0.1.3}/config/default.yaml RENAMED Viewed

@@ -60,3 +60,9 @@ watchers:
   codex_cli: false
   aider: false
   debounce_seconds: 30
+cloud:
+  enabled: false                    # set to true after deja login
+  endpoint: https://api.deja.sh
+  web_url: https://www.deja.sh      # browser login opens this — must be www, not apex (apex forwarding drops query params)
+  sync_on_save: false               # push to cloud on every deja save (async, non-blocking)

deja_cli-0.1.3/deja/cloud.py ADDED Viewed

@@ -0,0 +1,212 @@
+from __future__ import annotations
+import json
+import secrets
+import stat
+import threading
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from typing import Optional
+from urllib.parse import parse_qs, urlparse
+import httpx
+CLI_REDIRECT_PORT = 51234
+AUTH_FILE = Path.home() / ".deja" / "auth.json"
+SYNC_STATE_FILE = Path.home() / ".deja" / "sync_state.json"
+DEFAULT_ENDPOINT = "https://api.deja.sh"
+def _get_endpoint(config=None) -> str:
+    if config is None:
+        return DEFAULT_ENDPOINT
+    cloud = getattr(config, "cloud", None)
+    if cloud is None:
+        return DEFAULT_ENDPOINT
+    return getattr(cloud, "endpoint", DEFAULT_ENDPOINT).rstrip("/")
+# ── Token storage ─────────────────────────────────────────────────────
+def load_auth() -> Optional[dict]:
+    if not AUTH_FILE.exists():
+        return None
+    return json.loads(AUTH_FILE.read_text())
+def save_auth(data: dict) -> None:
+    AUTH_FILE.parent.mkdir(exist_ok=True)
+    AUTH_FILE.write_text(json.dumps(data, indent=2))
+    AUTH_FILE.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600
+def clear_auth() -> None:
+    if AUTH_FILE.exists():
+        AUTH_FILE.unlink()
+def get_token(config=None) -> Optional[str]:
+    """Return the stored PAT, or None if not logged in."""
+    auth = load_auth()
+    if not auth:
+        return None
+    return auth.get("access_token")
+# ── Browser login flow ────────────────────────────────────────────────
+def login_browser(config=None) -> str:
+    """Open deja.sh in the browser, wait for the CLI callback, exchange code for PAT."""
+    endpoint = _get_endpoint(config)
+    web_url = getattr(getattr(config, "cloud", None), "web_url", None) or endpoint.replace("api.", "www.", 1)
+    state = secrets.token_urlsafe(16)
+    code_holder: dict = {}
+    ready = threading.Event()
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            qs = parse_qs(urlparse(self.path).query)
+            code_holder["code"] = qs.get("code", [None])[0]
+            code_holder["error"] = qs.get("error", [None])[0]
+            self.send_response(200)
+            self.end_headers()
+            self.wfile.write(
+                b"<html><body style='font-family:sans-serif;background:#09090b;color:#fff;"
+                b"display:flex;align-items:center;justify-content:center;height:100vh;margin:0'>"
+                b"<p>CLI authorized. Return to your terminal.</p>"
+                b"<script>window.close()</script></body></html>"
+            )
+            ready.set()
+        def log_message(self, *args):
+            pass
+    server = HTTPServer(("localhost", CLI_REDIRECT_PORT), Handler)
+    auth_url = f"{web_url}/auth/cli?state={state}&port={CLI_REDIRECT_PORT}"
+    webbrowser.open(auth_url)
+    print(f"Opening deja.sh in your browser…")
+    print(f"If it doesn't open, visit: {auth_url}")
+    server.handle_request()
+    if code_holder.get("error"):
+        raise RuntimeError(f"Auth error: {code_holder['error']}")
+    if not code_holder.get("code"):
+        raise RuntimeError("No auth code received")
+    # Exchange one-time code for a PAT
+    resp = httpx.post(
+        f"{endpoint}/auth/cli/exchange",
+        json={"code": code_holder["code"]},
+        timeout=10,
+    )
+    resp.raise_for_status()
+    return resp.json()["token"]
+# ── Whoami ────────────────────────────────────────────────────────────
+def whoami(config=None) -> Optional[dict]:
+    token = get_token(config)
+    if not token:
+        return None
+    endpoint = _get_endpoint(config)
+    resp = httpx.get(
+        f"{endpoint}/auth/me",
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=10,
+    )
+    if not resp.is_success:
+        return None
+    return resp.json()
+# ── Save to cloud ─────────────────────────────────────────────────────
+_PUSH_FIELDS = {"content", "type", "project", "confidence", "triggerCmds", "category"}
+def push_memory(memory: dict, config=None) -> bool:
+    """Push a single memory to cloud. Returns True on success, False on failure (non-fatal)."""
+    token = get_token(config)
+    if not token:
+        return False
+    endpoint = _get_endpoint(config)
+    payload = _sanitize_for_push(memory)
+    try:
+        resp = httpx.post(
+            f"{endpoint}/v1/memories",
+            json=payload,
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+        return resp.is_success
+    except Exception:
+        return False
+# ── Sync ──────────────────────────────────────────────────────────────
+def load_sync_state() -> dict:
+    if not SYNC_STATE_FILE.exists():
+        return {}
+    return json.loads(SYNC_STATE_FILE.read_text())
+def save_sync_state(state: dict) -> None:
+    SYNC_STATE_FILE.parent.mkdir(exist_ok=True)
+    SYNC_STATE_FILE.write_text(json.dumps(state, indent=2))
+def _sanitize_for_push(memory: dict) -> dict:
+    """Convert a local memory dict to the shape the cloud API accepts."""
+    payload = {k: v for k, v in memory.items() if k in _PUSH_FIELDS}
+    if "id" in memory:
+        payload["localId"] = memory["id"]
+    # Local scope uses 'global' or 'project:xyz'; API uses 'local'|'global'.
+    payload["scope"] = "global"
+    if memory.get("last_confirmed"):
+        payload["lastConfirmed"] = memory["last_confirmed"]
+    return payload
+def sync_push(memories: list[dict], config=None) -> dict:
+    token = get_token(config)
+    if not token:
+        raise RuntimeError("Not logged in. Run `deja login`.")
+    endpoint = _get_endpoint(config)
+    sanitized = [_sanitize_for_push(m) for m in memories]
+    resp = httpx.post(
+        f"{endpoint}/v1/sync/push",
+        json={"memories": sanitized},
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=60,
+    )
+    if not resp.is_success:
+        raise RuntimeError(f"sync push failed ({resp.status_code}): {resp.text}")
+    return resp.json()
+def sync_pull(since: Optional[str] = None, config=None) -> dict:
+    token = get_token(config)
+    if not token:
+        raise RuntimeError("Not logged in. Run `deja login`.")
+    endpoint = _get_endpoint(config)
+    params = f"?since={since}" if since else ""
+    resp = httpx.get(
+        f"{endpoint}/v1/sync/pull{params}",
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=60,
+    )
+    resp.raise_for_status()
+    return resp.json()

{deja_cli-0.1.0 → deja_cli-0.1.3}/deja/config.py RENAMED Viewed

@@ -97,12 +97,20 @@ class EmbeddingConfig(BaseModel):
     base_url: str = "http://localhost:11434"
+class CloudConfig(BaseModel):
+    enabled: bool = False
+    endpoint: str = "https://api.deja.sh"
+    web_url: str = "https://www.deja.sh"
+    sync_on_save: bool = False
 class Config(BaseModel):
     llm: LLMConfig = LLMConfig()
     store: StoreConfig = StoreConfig()
     reflection: ReflectionConfig = ReflectionConfig()
     watchers: WatchersConfig = WatchersConfig()
     embedding: EmbeddingConfig = EmbeddingConfig()
+    cloud: CloudConfig = CloudConfig()
 def load_config(path: Optional[Path] = None) -> Config:
@@ -113,10 +121,6 @@ def load_config(path: Optional[Path] = None) -> Config:
         candidates.append(Path(path).expanduser())
     candidates.append(Path("~/.deja/config.yaml").expanduser())
-    # Bundled default
-    default_path = Path(__file__).parent.parent / "config" / "default.yaml"
-    candidates.append(default_path)
     for candidate in candidates:
         if candidate.exists():
             with open(candidate) as f:

{deja_cli-0.1.0 → deja_cli-0.1.3}/deja/core/reflection.py RENAMED Viewed

@@ -121,8 +121,7 @@ class ReflectionEngine:
     Two reflection modes
     --------------------
     LLM mode  — uses the configured ``reflection`` LLM (Ollama / Anthropic).
-                Triggered automatically by token-count thresholds or manually
-                via ``deja reflect``.
+                Invoked manually via ``deja reflect`` or on a cron schedule.
     Agent mode — no extra LLM call. The active coding agent (Claude Code,
                  Codex, Gemini CLI) reads the output of ``agent_mode_prompt()``
@@ -341,24 +340,3 @@ class ReflectionEngine:
         results["archive"] = await self.run_archive()
         return results
-    async def check_and_trigger(self, project: Optional[str] = None) -> None:
-        """Check token thresholds and auto-trigger observer/reflector if exceeded."""
-        if not self.adapter:
-            return
-        meta = await self.store.get_reflection_meta(project)
-        last_observer_at = meta.get("last_observer_at") if meta else None
-        memories = await self.store.list_for_reflection(project, since=last_observer_at)
-        token_count = sum(len(m["content"].split()) * 2 for m in memories)
-        if token_count >= self.config.observer_trigger_tokens:
-            n = await self.run_observer(project)
-            print(f"[deja] Auto-observer triggered: {n} observations created.", file=sys.stderr)
-        observations = await self.store.list_observations(project)
-        obs_tokens = sum(len(o["content"].split()) * 2 for o in observations)
-        if obs_tokens >= self.config.reflector_trigger_tokens:
-            n = await self.run_reflector(project)
-            print(f"[deja] Auto-reflector triggered: {n} observations reduced.", file=sys.stderr)

{deja_cli-0.1.0 → deja_cli-0.1.3}/deja/core/store.py RENAMED Viewed

@@ -5,7 +5,7 @@ import struct
 import sys
 from datetime import datetime, timezone, timedelta
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, NamedTuple, Optional
 import aiosqlite
 from ulid import ULID
@@ -138,6 +138,14 @@ def _parse_dt(dt_str: str) -> datetime:
 # ── store ──────────────────────────────────────────────────────────────────────
+class SaveResult(NamedTuple):
+    """Return type for MemoryStore.save()."""
+    id: str
+    is_new: bool
+    cloud_data: dict
 _GLOBAL_PROJECT_KEY = "__global__"
@@ -302,11 +310,16 @@ class MemoryStore:
                 pass  # column already exists
         await db.commit()
-    async def save(self, memory: dict, embedding: Optional[bytes] = None) -> str:
+    async def save(self, memory: dict, embedding: Optional[bytes] = None) -> SaveResult:
         """Save a memory, deduplicating if an existing memory is >80% similar.
         embedding: pre-computed embedding bytes (from EmbeddingAdapter.to_bytes()).
         Pass None if no embedding provider is configured.
+        Returns a SaveResult with:
+          .id        — the memory ID (new or existing dedup match)
+          .is_new    — True if a new record was inserted, False if deduplicated
+          .cloud_data — full current state of the saved/updated memory (no embedding blob)
         """
         db = await self._get_db()
         content = memory["content"]
@@ -346,7 +359,19 @@ class MemoryStore:
                         (new_confidence, new_reuse, now, now, merged_trigger, candidate["id"]),
                     )
                     await db.commit()
-                    return candidate["id"]
+                    cloud_data = {
+                        "id": candidate["id"],
+                        "content": content,
+                        "type": mem_type,
+                        "category": candidate.get("category", "agent"),
+                        "scope": scope,
+                        "project": project,
+                        "confidence": new_confidence,
+                        "trigger": merged_trigger,
+                        "last_confirmed": now,
+                        "updated_at": now,
+                    }
+                    return SaveResult(candidate["id"], False, cloud_data)
         # Insert new memory
         now = _now_iso()
@@ -379,7 +404,33 @@ class MemoryStore:
             ),
         )
         await db.commit()
-        return mem_id
+        cloud_data = {
+            "id": mem_id,
+            "content": content,
+            "type": mem_type,
+            "category": memory.get("category", "agent"),
+            "scope": scope,
+            "project": project,
+            "confidence": memory.get("confidence", 1.0),
+            "trigger": memory.get("trigger"),
+            "created_at": now,
+            "updated_at": now,
+            "last_confirmed": now,
+        }
+        return SaveResult(mem_id, True, cloud_data)
+    async def confirm_memories(self, ids: list[str]) -> None:
+        """Stamp last_confirmed = now on a list of memory IDs. Called after load."""
+        if not ids:
+            return
+        db = await self._get_db()
+        now = _now_iso()
+        placeholders = ",".join("?" * len(ids))
+        await db.execute(
+            f"UPDATE memories SET last_confirmed = ?, updated_at = ? WHERE id IN ({placeholders})",
+            [now, now, *ids],
+        )
+        await db.commit()
     async def save_embedding(self, memory_id: str, embedding: bytes) -> None:
         """Store an embedding for an existing memory (used for backfill)."""
@@ -986,6 +1037,25 @@ class MemoryStore:
         db = await self._get_db()
         mem_id = memory["id"]
+        _KNOWN_COLUMNS = {
+            "id", "type", "category", "content", "scope", "project", "source",
+            "confidence", "reuse_count", "domain", "entity_graph", "trigger",
+            "embedding", "created_at", "updated_at", "last_confirmed",
+            "archived_at", "invalidated_at",
+        }
+        memory = {k: v for k, v in memory.items() if k in _KNOWN_COLUMNS}
+        # Fill NOT NULL defaults the cloud may omit
+        now = _now_iso()
+        memory.setdefault("created_at", now)
+        memory.setdefault("updated_at", now)
+        memory.setdefault("type", "semantic")
+        memory.setdefault("category", "agent")
+        memory.setdefault("content", "")
+        memory.setdefault("scope", "global")
+        memory.setdefault("confidence", 1.0)
+        memory.setdefault("reuse_count", 0)
         existing = await self.get(mem_id)
         if not existing:
             # New record, just insert

deja_cli-0.1.3/deja/interfaces/cli/__init__.py ADDED Viewed

@@ -0,0 +1,20 @@
+from __future__ import annotations
+import typer
+from . import memory, session, transfer, maintenance, backfill, watch, cloud
+from . import setup as setup_mod
+from ._helpers import _embed_and_save, _format_load_result  # re-exported for backwards compat
+app = typer.Typer(name="deja", help="Deja — persistent coding memory CLI")
+memory.register(app)
+session.register(app)
+transfer.register(app)
+maintenance.register(app)
+backfill.register(app)
+watch.register(app)
+setup_mod.register(app)
+cloud.register(app)
+__all__ = ["app", "_embed_and_save", "_format_load_result"]

deja_cli-0.1.3/deja/interfaces/cli/_helpers.py ADDED Viewed

@@ -0,0 +1,166 @@
+from __future__ import annotations
+import asyncio
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+from deja.config import load_config
+from deja.core.store import MemoryStore
+from deja.llm.embedding import EmbeddingAdapter
+def _get_config():
+    return load_config()
+def _get_store(config=None) -> MemoryStore:
+    if config is None:
+        config = _get_config()
+    return MemoryStore(config)
+async def _init_store(store: MemoryStore) -> None:
+    await store.init_db()
+async def _embed_and_save(
+    memories: list[dict],
+    store: MemoryStore,
+    embedding_adapter,  # Optional[EmbeddingAdapter]
+) -> int:
+    """Embed each memory (if adapter available) and save. Returns count saved."""
+    saved = 0
+    for memory in memories:
+        emb_bytes = None
+        if embedding_adapter is not None:
+            try:
+                emb = await embedding_adapter.embed(memory["content"])
+                emb_bytes = EmbeddingAdapter.to_bytes(emb)
+            except Exception as e:
+                print(f"[deja] Embedding failed: {e}", file=sys.stderr)
+        await store.save(memory, emb_bytes)
+        saved += 1
+    return saved
+def _format_memory_text(mem: dict) -> str:
+    scope = mem["scope"]
+    scope_label = "global" if scope == "global" else mem.get("project", scope)
+    domain = mem.get("domain")
+    domain_tag = f" [domain:{domain}]" if domain else ""
+    return (
+        f"[{mem['type']}]{domain_tag} [{scope_label}] {mem['content']} "
+        f"(confidence: {mem['confidence']:.1f})"
+    )
+def _format_load_result(result: dict) -> str:
+    """Render a load_budgeted() result as compact, agent-readable text."""
+    memories = result["memories"]
+    total = result["total"]
+    overflow = result["overflow"]
+    project = result["project"]
+    overflow_hints = result.get("overflow_hints", [])
+    if not memories and total == 0:
+        return "No memories found."
+    header = f"=== deja: {len(memories)}/{total} memories"
+    if project != "global":
+        header += f" (project: {project})"
+    header += " ==="
+    lines = [header]
+    by_type: dict[str, list[dict]] = {}
+    for mem in memories:
+        t = mem.get("type", "pattern")
+        by_type.setdefault(t, []).append(mem)
+    type_order = ["preference", "gotcha", "decision", "pattern", "procedure", "progress"]
+    for mem_type in type_order:
+        mems = by_type.get(mem_type, [])
+        if not mems:
+            continue
+        lines.append("")
+        for mem in mems:
+            label = f"[{mem_type}]"
+            if mem.get("domain"):
+                label += f"[{mem['domain']}]"
+            if mem_type == "procedure" and mem.get("reuse_count", 0):
+                label += f"(reuse:{mem['reuse_count']})"
+            if mem.get("scope") != "global":
+                label += f"({mem.get('project', '')})"
+            lines.append(f"{label} {mem['content']}")
+    if overflow > 0:
+        lines.append("")
+        search_cmd = 'deja search "<topic>"'
+        if project != "global":
+            search_cmd += f" --project {project}"
+        hints_str = ", ".join(f"{h['type']} +{h['overflow']}" for h in overflow_hints)
+        lines.append(f"--- {overflow} more memories available. Run: {search_cmd} ---")
+        if hints_str:
+            lines.append(f"Overflow: {hints_str}")
+    return "\n".join(lines)
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+def _prepare_import_memory(raw: object, project: Optional[str]) -> tuple[Optional[dict], Optional[str]]:
+    """Validate and normalize one imported memory record."""
+    if not isinstance(raw, dict):
+        return None, "record is not a JSON object"
+    required_fields = ("id", "type", "content")
+    for field in required_fields:
+        value = raw.get(field)
+        if not isinstance(value, str) or not value.strip():
+            return None, f"missing required field: {field}"
+    scope = f"project:{project}" if project else raw.get("scope")
+    if not isinstance(scope, str) or not scope.strip():
+        return None, "missing required field: scope"
+    project_name = project if project else raw.get("project")
+    created_at = raw.get("created_at") or _now_iso()
+    updated_at = raw.get("updated_at") or created_at
+    last_confirmed = raw.get("last_confirmed") or updated_at
+    confidence = raw.get("confidence", 1.0)
+    try:
+        confidence = float(confidence)
+    except (TypeError, ValueError):
+        return None, "invalid confidence value"
+    confidence = max(0.0, min(1.0, confidence))
+    reuse_count = raw.get("reuse_count", 0)
+    try:
+        reuse_count = int(reuse_count)
+    except (TypeError, ValueError):
+        reuse_count = 0
+    normalized = {
+        "id": raw["id"],
+        "type": raw["type"],
+        "category": raw.get("category", "agent"),
+        "content": raw["content"],
+        "scope": scope,
+        "project": project_name,
+        "source": raw.get("source"),
+        "confidence": confidence,
+        "reuse_count": reuse_count,
+        "domain": raw.get("domain"),
+        "entity_graph": raw.get("entity_graph"),
+        "created_at": created_at,
+        "updated_at": updated_at,
+        "last_confirmed": last_confirmed,
+        "archived_at": raw.get("archived_at"),
+        "invalidated_at": raw.get("invalidated_at"),
+    }
+    return normalized, None

deja-cli 0.1.0__tar.gz → 0.1.3__tar.gz

deja-cli 0.1.0tar.gz → 0.1.3tar.gz