Merge pull request #3 from nickroci/chore/code-quanlity-2

Chore/code quanlity 2

Author: nickroci

.github/workflows/ci.yml

@@ -0,0 +1,50 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: ${{ matrix.package }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - package: daemon
+            python-version: "3.10"
+          - package: tools/search
+            python-version: "3.10"
+          - package: src
+            python-version: "3.12"
+    defaults:
+      run:
+        working-directory: ${{ matrix.package }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+          cache-dependency-glob: ${{ matrix.package }}/uv.lock
+
+      - name: Install dependencies
+        run: uv sync --locked
+
+      - name: Lint (ruff)
+        run: uv run ruff check .
+
+      - name: Format check (ruff)
+        run: uv run ruff format --check .
+
+      - name: Type check (pyright)
+        run: uv run pyright
+
+      - name: Tests (pytest)
+        run: uv run pytest

.gitignore

@@ -12,3 +12,4 @@ prior-art/
 # Per-machine Claude Code hook config; written by /ultan-install
 .claude/
 local/
+.coverage

.pre-commit-config.yaml

@@ -33,20 +33,23 @@ repos:
         entry: bash -c 'cd daemon && uv run --frozen pyright "${@#daemon/}"' --
         files: ^daemon/.*\.py$
         pass_filenames: true
+        stages: [pre-commit]
 
       - id: pyright-tools-search
         name: pyright (tools/search)
         language: system
         entry: bash -c 'cd tools/search && uv run --frozen pyright "${@#tools/search/}"' --
         files: ^tools/search/.*\.py$
         pass_filenames: true
+        stages: [pre-commit]
 
       - id: pyright-src
         name: pyright (src)
         language: system
         entry: bash -c 'cd src && uv run --frozen pyright "${@#src/}"' --
         files: ^src/.*\.py$
         pass_filenames: true
+        stages: [pre-commit]
 
       # Pytest per package — runs at pre-push, not pre-commit. Full suite,
       # only when something in that package changed since the last push.

daemon/agent_mem_daemon/__main__.py

@@ -23,11 +23,19 @@
 import sys
 import threading
 from pathlib import Path
+from types import FrameType
 
 from .buffer import DEFAULT_INACTIVITY_SECONDS, DEFAULT_MAX_TURNS, RollingBuffer
 from .ingest import DEFAULT_POLL_INTERVAL, JsonlTailer
 from .logging_setup import configure as configure_logging
-from .paths import ensure_home, events_path, log_path, offset_state_path, pid_path
+from .paths import (
+    ensure_home,
+    events_path,
+    knowledge_dir,
+    log_path,
+    offset_state_path,
+    pid_path,
+)
 from .priming_rpc import PrimingRpcThread
 from .scheduler import (
     DEFAULT_LIBRARIAN_CONCURRENCY,
@@ -240,35 +248,40 @@ def _build_parser() -> argparse.ArgumentParser:
 # ---- main loop ------------------------------------------------------
 
 
-def _prewarm_indexes(knowledge_dir: Path, log: logging.Logger) -> None:
+def _prewarm_indexes(knowledge_root: Path, log: logging.Logger) -> None:
     """Verify the BM25 and embedding indexes match the markdown source
     of truth at startup. Rebuild on drift; log either way.
 
     Run synchronously before worker threads start so first retrieval
     doesn't pay the rebuild cost. Failures fail-soft to lazy rebuild —
     a broken index never blocks daemon start.
+
+    Note: bm25 and embeddings live in a sibling ``tools/search`` package
+    not always on the daemon's ``sys.path``; the imports are kept local
+    to this function and wrapped in best-effort ``try/except`` so a
+    missing module degrades to lazy rebuild rather than blocking startup.
     """
-    if not knowledge_dir.exists():
-        log.info("startup: knowledge dir %s missing — skipping index prewarm", knowledge_dir)
+    if not knowledge_root.exists():
+        log.info("startup: knowledge dir %s missing — skipping index prewarm", knowledge_root)
         return
     try:
-        from bm25 import load_or_build as bm25_load
+        from bm25 import load_or_build as bm25_load  # noqa: PLC0415
 
-        idx = bm25_load(knowledge_dir)
+        idx = bm25_load(knowledge_root)
         log.info("startup: bm25 index ready (%d docs)", len(idx.docs))
     except Exception:
         log.exception("startup: bm25 prewarm failed (lazy rebuild on first use)")
     try:
-        from embeddings import load_or_build as emb_load
+        from embeddings import load_or_build as emb_load  # noqa: PLC0415
 
-        idx = emb_load(knowledge_dir)
+        idx = emb_load(knowledge_root)
         log.info("startup: embedding index ready (%d docs)", len(idx.docs))
     except Exception:
         log.exception("startup: embedding prewarm failed (lazy rebuild on first use)")
 
 
 def _install_signal_handlers(stop_event: threading.Event) -> None:
-    def handler(signum, _frame):
+    def handler(signum: int, _frame: FrameType | None) -> None:
         # signal.Signals(signum).name avoids hardcoding numbers in the
         # log line — clearer when reading post-mortem.
         try:
@@ -304,9 +317,7 @@ def run(args: argparse.Namespace) -> int:
     # Rebuilds on drift (manual edits, git pull from another machine,
     # restore from backup); logs "ready (N docs)" otherwise. Failures
     # fail-soft — first retrieval rebuilds.
-    from .paths import knowledge_dir as _knowledge_dir
-
-    _prewarm_indexes(_knowledge_dir(), log)
+    _prewarm_indexes(knowledge_dir(), log)
 
     stop_event = threading.Event()
     _install_signal_handlers(stop_event)

daemon/agent_mem_daemon/_response_parser.py

@@ -45,6 +45,72 @@ class ParseDiagnostic:
     error: Optional[str] = field(default=None)
 
 
+def _strip_code_fence(text: str) -> str:
+    """Peel a leading markdown code fence (```json ... ```) if present."""
+    if not text.startswith("```"):
+        return text
+    lines = text.splitlines()
+    inner = lines[1:]
+    if inner and inner[-1].lstrip().startswith("```"):
+        inner = inner[:-1]
+    return "\n".join(inner).strip()
+
+
+@dataclass
+class _BraceScanner:
+    """Mutable state for the balanced-brace walk. Separating it from
+    ``_collect_balanced_blocks`` keeps the loop body straight-line."""
+
+    depth: int = 0
+    in_string: bool = False
+    escape: bool = False
+    start: int = -1
+
+
+def _advance_scanner(state: _BraceScanner, i: int, ch: str) -> Optional[Tuple[int, int]]:
+    """Feed one character into the scanner. Returns a ``(start, end)``
+    slice (inclusive end) when a top-level balanced block just closed,
+    else ``None``."""
+    if state.escape:
+        state.escape = False
+        return None
+    if state.in_string:
+        if ch == "\\":
+            state.escape = True
+        elif ch == '"':
+            state.in_string = False
+        return None
+    if ch == '"':
+        state.in_string = True
+        return None
+    if ch == "{":
+        if state.depth == 0:
+            state.start = i
+        state.depth += 1
+        return None
+    if ch == "}":
+        state.depth -= 1
+        if state.depth == 0 and state.start >= 0:
+            block = (state.start, i)
+            state.start = -1
+            return block
+    return None
+
+
+def _collect_balanced_blocks(text: str) -> list[str]:
+    """Walk ``text`` left-to-right and return every top-level balanced
+    ``{...}`` substring. String-aware so braces inside JSON strings don't
+    confuse the depth counter."""
+    blocks: list[str] = []
+    state = _BraceScanner()
+    for i, ch in enumerate(text):
+        closed = _advance_scanner(state, i, ch)
+        if closed is not None:
+            s, e = closed
+            blocks.append(text[s : e + 1])
+    return blocks
+
+
 def extract_json_blob(text: str) -> Optional[str]:
     """Find the LAST top-level balanced ``{...}`` block in ``text``.
 
@@ -66,47 +132,8 @@ def extract_json_blob(text: str) -> Optional[str]:
     if not text or not text.strip():
         return None
 
-    stripped = text.strip()
-
-    # ── Step 1: strip a markdown fence if present ────────────────────
-    if stripped.startswith("```"):
-        # Drop the opening fence line (```json or ``` or ```anything).
-        lines = stripped.splitlines()
-        inner = lines[1:]
-        # Drop trailing closing fence if present.
-        if inner and inner[-1].lstrip().startswith("```"):
-            inner = inner[:-1]
-        stripped = "\n".join(inner).strip()
-
-    # ── Step 2: collect every top-level balanced { ... } ─────────────
-    blocks: list[str] = []
-    depth = 0
-    in_string = False
-    escape = False
-    start = -1
-
-    for i, ch in enumerate(stripped):
-        if escape:
-            escape = False
-            continue
-        if in_string:
-            if ch == "\\":
-                escape = True
-            elif ch == '"':
-                in_string = False
-            continue
-        if ch == '"':
-            in_string = True
-        elif ch == "{":
-            if depth == 0:
-                start = i
-            depth += 1
-        elif ch == "}":
-            depth -= 1
-            if depth == 0 and start >= 0:
-                blocks.append(stripped[start : i + 1])
-                start = -1
-
+    stripped = _strip_code_fence(text.strip())
+    blocks = _collect_balanced_blocks(stripped)
     if blocks:
         return blocks[-1]
 

daemon/agent_mem_daemon/_schemas.py

@@ -25,7 +25,7 @@
 from __future__ import annotations
 
 import json
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Dict, List, Literal, Mapping, Optional, Union, cast
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 from typing_extensions import Annotated
@@ -309,7 +309,7 @@ class LibrarianInterrupt(BaseModel):
         description="The exact applies-when phrase that matched the buffer.",
     )
     evidence: List[EvidenceItem] = Field(
-        default_factory=list,
+        default_factory=list[EvidenceItem],
         description=(
             "List of EvidenceItem dicts (NOT strings). Each item is "
             "{turn_id, role, quote}. Emit at least one verbatim turn quote."
@@ -326,7 +326,7 @@ class LibrarianInterrupt(BaseModel):
 
     @field_validator("evidence", mode="before")
     @classmethod
-    def _coerce_evidence(cls, v):
+    def _coerce_evidence(cls, v: object) -> object:
         """Tolerate LLM-shape drift on evidence.
 
         The schema asks for ``list[EvidenceItem]`` (dicts), but Sonnet /
@@ -343,11 +343,12 @@ def _coerce_evidence(cls, v):
             return []
         if isinstance(v, str):
             return [{"quote": v}]
-        if isinstance(v, dict):
-            return [v]
+        if isinstance(v, Mapping):
+            return [cast(Mapping[object, object], v)]
         if isinstance(v, list):
-            out = []
-            for item in v:
+            raw = cast(list[object], v)
+            out: list[object] = []
+            for item in raw:
                 if isinstance(item, str):
                     out.append({"quote": item})
                 else:
@@ -367,7 +368,7 @@ class LibrarianProposal(BaseModel):
     model_config = ConfigDict(extra="ignore")
 
     proposals: List[ProposedAction] = Field(
-        default_factory=list,
+        default_factory=list[ProposedAction],
         description=(
             "Ordered list of curator actions the Librarian wants the "
             "Scholar to execute. Each item is a typed action object "
@@ -377,7 +378,7 @@ class LibrarianProposal(BaseModel):
         ),
     )
     interrupts: List[LibrarianInterrupt] = Field(
-        default_factory=list,
+        default_factory=list[LibrarianInterrupt],
         description=(
             "Optional list of interrupt-nudge candidates: turns in the "
             "buffer that match an existing entry's applies-when phrases. "
@@ -479,7 +480,7 @@ class ScholarReview(BaseModel):
     model_config = ConfigDict(extra="ignore")
 
     decisions: List[ScholarDecision] = Field(
-        default_factory=list,
+        default_factory=list[ScholarDecision],
         description=(
             "One ScholarDecision per Librarian proposal, matched by "
             "`action_index`. Order need not mirror the proposals — the "
@@ -488,7 +489,7 @@ class ScholarReview(BaseModel):
         ),
     )
     interrupts_processed: List[ScholarInterruptDecision] = Field(
-        default_factory=list,
+        default_factory=list[ScholarInterruptDecision],
         description=(
             "One ScholarInterruptDecision per LibrarianInterrupt the "
             "Scholar reviewed. Approved decisions are written to "
@@ -513,10 +514,10 @@ class LibrarianResponse(BaseModel):
 
     model_config = ConfigDict(extra="ignore")
 
-    candidates: List[Dict[str, Any]] = Field(default_factory=list)
-    interrupt_candidates: List[Dict[str, Any]] = Field(default_factory=list)
-    proposals: List[Dict[str, Any]] = Field(default_factory=list)
-    interrupts: List[Dict[str, Any]] = Field(default_factory=list)
+    candidates: List[Dict[str, object]] = Field(default_factory=list[Dict[str, object]])
+    interrupt_candidates: List[Dict[str, object]] = Field(default_factory=list[Dict[str, object]])
+    proposals: List[Dict[str, object]] = Field(default_factory=list[Dict[str, object]])
+    interrupts: List[Dict[str, object]] = Field(default_factory=list[Dict[str, object]])
 
 
 class ScholarResponse(BaseModel):
@@ -527,8 +528,8 @@ class ScholarResponse(BaseModel):
 
     model_config = ConfigDict(extra="ignore")
 
-    candidates_processed: List[Dict[str, Any]] = Field(default_factory=list)
-    interrupts_processed: List[Dict[str, Any]] = Field(default_factory=list)
+    candidates_processed: List[Dict[str, object]] = Field(default_factory=list[Dict[str, object]])
+    interrupts_processed: List[Dict[str, object]] = Field(default_factory=list[Dict[str, object]])
 
 
 # ── Prompt-shape generators ──────────────────────────────────────────