marvisx-cli 0.3.8b4__tar.gz → 0.3.8b6__tar.gz

{marvisx_cli-0.3.8b4 → marvisx_cli-0.3.8b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marvisx-cli
-Version: 0.3.8b4
+Version: 0.3.8b6
 Summary: MarvisX OSS — agent-native company-brain CLI runtime (init, status, brief, triage)
 Author: MarvisX maintainers
 License: BSL-1.1

{marvisx_cli-0.3.8b4 → marvisx_cli-0.3.8b6}/core/api/config.py

@@ -492,6 +492,37 @@ class Settings(BaseSettings):
         default=False, alias="MARVIS_KG_CLAIMS"
     )
 
+    # Memory-freshness v2a Phase 1 (B-fix, DEFAULT OFF). The documents_fts
+    # INSERT/UPDATE triggers (migration 136) write file_path into the content
+    # column, so every doc written AFTER the one-time migration backfill has NO
+    # body in the lexical lane (prod 2026-06-09: 100% of recent docs degraded
+    # → the BM25 lane sees OLD bodies but never NEW ones — a direct stale-
+    # retrieval mechanism). When True, every documents upsert path additionally
+    # overwrites the trigger-degraded FTS row with the real title+body
+    # (refresh_documents_fts_row). When False the refresh helper is a no-op and
+    # behavior is byte-identical to today. The one-shot backfill script
+    # (scripts/backfill_documents_fts.py) repairs historical rows; in prod the
+    # flag must flip ON at backfill time and stay on, otherwise the next doc
+    # update re-degrades its row. See plan
+    # 2026-06-09-feat-memory-freshness-v2a-retrieval.
+    fts_bodies_enabled: bool = Field(
+        default=False, alias="MARVIS_FTS_BODIES"
+    )
+
+    # Memory-freshness v2a Phase 2 (A-span, DEFAULT OFF). When False the search
+    # read path never touches the chunks/vec_chunks sidecars and the response is
+    # byte-identical to today (no span_* fields populated). When True (and
+    # MARVIS_CHUNKING populated the sidecars), the semantic lane max-pools
+    # chunk-KNN hits into the doc ranking and each file-backed hit carries the
+    # winning chunk's span expanded to line boundaries ±12 lines (span_text /
+    # span_path / span_line_start / span_line_end) so the agent can answer FROM
+    # the search result without a follow-up Read. Write-side chunking stays
+    # gated by MARVIS_CHUNKING (env, read per-call). See plan
+    # 2026-06-09-feat-memory-freshness-v2a-retrieval.
+    search_spans_enabled: bool = Field(
+        default=False, alias="MARVIS_SEARCH_SPANS"
+    )
+
     # Track 2 #3c — community summaries in the brief (GraphRAG global-search,
     # DEFAULT OFF). When False the brief is byte-identical to today: the
     # communities/community_summary modules are a flag-gated library + seam,
@@ -534,6 +565,15 @@ class Settings(BaseSettings):
     brain_llm_polish_enabled: bool = Field(
         default=True, alias="BRAIN_LLM_POLISH_ENABLED"
     )
+    # P1: pick the Brain LLM backend. "gateway" (default, unchanged) = the HTTP
+    # Mac-gateway client (requires BRAIN_LLM_GATEWAY_API_KEY). "claude_cli" = run
+    # `claude -p` headless on the user's Claude Code subscription (NO API key) —
+    # see core/api/services/brain/llm/claude_cli.py.
+    brain_llm_provider: Literal["gateway", "claude_cli"] = Field(
+        default="gateway", alias="BRAIN_LLM_PROVIDER"
+    )
+    # Path/name of the `claude` binary for the claude_cli provider.
+    marvis_claude_bin: str = Field(default="claude", alias="MARVIS_CLAUDE_BIN")
     brain_llm_journal_polish_enabled: bool = Field(
         default=True, alias="BRAIN_LLM_JOURNAL_POLISH_ENABLED"
     )

{marvisx_cli-0.3.8b4 → marvisx_cli-0.3.8b6}/core/api/models/search.py

@@ -26,6 +26,14 @@ class SearchHit(BaseModel):
     edge_path: list[str] | None = None
     edge_path_summary: str | None = None
     rrf_score: float | None = None
+    # Memory-freshness v2a Phase 2 (A-span, MARVIS_SEARCH_SPANS): the winning
+    # chunk's text expanded to line boundaries ±12 lines, so the agent answers
+    # FROM the result without a follow-up Read. None when the flag is off, the
+    # hit is row-backed (task/learning/inbox), or the source file is gone.
+    span_text: str | None = None
+    span_path: str | None = None
+    span_line_start: int | None = None
+    span_line_end: int | None = None
 
 
 class SearchResponse(BaseModel):

marvisx_cli-0.3.8b6/core/api/services/brain/llm/claude_cli.py

@@ -0,0 +1,201 @@
+# v1.0.0 - 2026-06-09 - P1: claude -p (Claude Code headless) provider for the Brain.
+"""Brain LLM backend that runs `claude -p` (Claude Code headless) as a subprocess.
+
+The brain runs on the user's Claude Code **subscription** — zero API key. Selected
+with `BRAIN_LLM_PROVIDER=claude_cli`; the default `gateway` path is unchanged.
+
+Same `BrainLLMService` contract as `LocalGatewayBrainService` (call_polish / call_json
+/ aclose + model / grounding_strict). Only the transport differs: instead of an HTTP
+chat.completion, we exec `claude -p --output-format json`, write the user prompt to
+**stdin**, and read the single-result envelope. Verified flags/schema against the
+installed binary (2026-06-09): envelope `{result: str, is_error: bool, …}`.
+
+CRITICAL: `claude -p` is an AGENT by default (loads the Claude Code system prompt,
+may use tools). For pure generation we pass `--allowedTools ""` (no tools),
+`--system-prompt <brain>` (replace, not append) + `--exclude-dynamic-system-prompt-sections`
+(strip the agentic preamble). Everything fails SOFT: any error/timeout/non-zero
+exit/malformed JSON → PolishResult.failed (or None for call_json) → the brain
+degrades to its deterministic baseline, never a crash.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import shutil
+from contextlib import suppress
+from typing import Any
+
+from core.api.services.brain.llm.base import PolishPurpose, PolishResult
+from core.api.services.brain.llm.direction_alignment import (
+    classify_direction_alignment_impl,
+)
+from core.api.services.brain.llm.local_gateway import _project_polished_fields
+from core.api.services.brain.llm.parsers import ParseError, parse_json_or_raise
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeCliBrainService:
+    """Brain polish via `claude -p` headless on the local Claude Code subscription."""
+
+    def __init__(
+        self,
+        *,
+        model: str,
+        binary: str = "claude",
+        timeout_seconds: int = 60,
+        semaphore_size: int = 1,
+        grounding_strict: bool = False,
+    ) -> None:
+        self._model = model or ""
+        self._binary = binary or "claude"
+        self._timeout_seconds = max(5, int(timeout_seconds))
+        # Subprocess is heavy (CLI boot per call); keep concurrency low.
+        self._semaphore = asyncio.Semaphore(max(1, int(semaphore_size)))
+        self._grounding_strict = grounding_strict
+
+    @property
+    def model(self) -> str:
+        return self._model
+
+    @property
+    def grounding_strict(self) -> bool:
+        return self._grounding_strict
+
+    async def aclose(self) -> None:
+        # No persistent client/process to release.
+        return None
+
+    # ----------------------------------------------------------------- #
+    # subprocess transport                                              #
+    # ----------------------------------------------------------------- #
+
+    async def _run(self, *, system_prompt: str, user_prompt: str) -> tuple[str | None, str]:
+        """Run `claude -p` once. Returns (content, "") on success, (None, reason) on
+        any failure. `content` is the assistant text (the envelope's `result`)."""
+        if not os.path.isabs(self._binary) and shutil.which(self._binary) is None:
+            return (None, "claude_not_on_path")
+
+        argv = [
+            self._binary,
+            "-p",
+            "--output-format", "json",
+            "--allowedTools", "",  # no tools → pure generation, no agent loop
+            "--exclude-dynamic-system-prompt-sections",  # drop the Claude Code agentic preamble
+            "--system-prompt", system_prompt,
+        ]
+        if self._model:
+            argv += ["--model", self._model]
+
+        async with self._semaphore:
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    *argv,
+                    stdin=asyncio.subprocess.PIPE,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+            except Exception as exc:  # binary missing / exec error
+                return (None, f"spawn_failed:{exc}")
+            try:
+                out, err = await asyncio.wait_for(
+                    proc.communicate(user_prompt.encode("utf-8")),
+                    timeout=self._timeout_seconds,
+                )
+            except asyncio.TimeoutError:
+                proc.kill()
+                with suppress(Exception):
+                    await proc.wait()
+                return (None, "timeout")
+            except Exception as exc:
+                return (None, f"communicate_failed:{exc}")
+
+        if proc.returncode != 0:
+            tail = err.decode("utf-8", "replace")[:200] if err else ""
+            return (None, f"exit_{proc.returncode}:{tail}")
+
+        try:
+            env = json.loads(out.decode("utf-8"))
+        except Exception:
+            return (None, "envelope_not_json")
+        if not isinstance(env, dict):
+            return (None, "envelope_not_object")
+        if env.get("is_error"):
+            return (None, f"claude_error:{str(env.get('result'))[:200]}")
+
+        content = env.get("result")
+        if not isinstance(content, str) or not content.strip():
+            # Tolerant of schema drift: fall back to the first non-empty string field.
+            content = next(
+                (v for v in env.values() if isinstance(v, str) and v.strip()), ""
+            )
+        if not content:
+            return (None, "empty_result")
+        return (content, "")
+
+    # ----------------------------------------------------------------- #
+    # BrainLLMService contract                                          #
+    # ----------------------------------------------------------------- #
+
+    async def call_polish(
+        self,
+        *,
+        purpose: PolishPurpose,
+        system_prompt: str,
+        user_prompt: str,
+        max_tokens: int,
+        idempotency_key: str | None = None,
+    ) -> PolishResult:
+        """Issue the polish call. Never raises — returns PolishResult.failed on errors.
+        Shares the content→PolishResult projection with the gateway provider."""
+        content, reason = await self._run(system_prompt=system_prompt, user_prompt=user_prompt)
+        if content is None:
+            logger.warning("brain_claude_cli_polish_failed purpose=%s reason=%s", purpose, reason)
+            return PolishResult.failed(purpose=purpose, reason=reason, model=self._model)
+        try:
+            parsed = parse_json_or_raise(content)
+        except ParseError as exc:
+            return PolishResult.failed(
+                purpose=purpose, reason=f"json_parse_failed:{exc}", model=self._model
+            )
+        polished, cited = _project_polished_fields(purpose=purpose, parsed=parsed)
+        if not polished:
+            return PolishResult.failed(
+                purpose=purpose, reason="polished_fields_missing", model=self._model
+            )
+        return PolishResult(
+            success=True,
+            purpose=purpose,
+            polished=polished,
+            cited_evidence_refs=cited,
+            model=self._model,
+        )
+
+    async def call_json(
+        self,
+        *,
+        model: str,
+        system_prompt: str,
+        user_prompt: str,
+        max_tokens: int,
+        temperature: float,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any] | None:
+        """Generic JSON-object call (DR8 classifier). The per-call `model` is a
+        gateway model id with no Claude equivalent, so the configured Claude model
+        (`self._model`) is used. None on any failure — caller falls back."""
+        content, reason = await self._run(system_prompt=system_prompt, user_prompt=user_prompt)
+        if content is None:
+            logger.warning("brain_claude_cli_json_failed reason=%s", reason)
+            return None
+        try:
+            return parse_json_or_raise(content)
+        except ParseError as exc:
+            logger.warning("brain_claude_cli_json_parse_failed reason=%s", str(exc))
+            return None
+
+    async def classify_direction_alignment(self, payload: dict[str, Any]) -> dict[str, Any] | None:
+        """DR8 classifier surface — same impl the gateway provider uses."""
+        return await classify_direction_alignment_impl(llm_surface=self, payload=payload)

{marvisx_cli-0.3.8b4 → marvisx_cli-0.3.8b6}/core/api/services/brain/llm/factory.py

@@ -93,6 +93,19 @@ def get_brain_llm_service() -> BrainLLMService:
         _brain_llm_service = _NoOpBrainLLMService()
         return _brain_llm_service
 
+    # P1: claude -p provider runs on the Claude Code subscription — NO api key.
+    if getattr(settings, "brain_llm_provider", "gateway") == "claude_cli":
+        from core.api.services.brain.llm.claude_cli import ClaudeCliBrainService
+
+        _brain_llm_service = ClaudeCliBrainService(
+            binary=getattr(settings, "marvis_claude_bin", "claude") or "claude",
+            model=settings.brain_llm_model,
+            timeout_seconds=settings.brain_llm_polish_timeout_seconds,
+            semaphore_size=settings.brain_llm_semaphore_size,
+            grounding_strict=settings.brain_llm_grounding_strict,
+        )
+        return _brain_llm_service
+
     brain_key = _secret_text(settings.brain_llm_gateway_api_key)
     global_key = _secret_text(settings.llm_gateway_api_key)