@agxnte/reidx 2.0.2

package/src/reidx/config/settings.py

@@ -0,0 +1,127 @@
+"""Claude-Code-style settings file support.
+
+A settings.json holds an `env` block (applied to os.environ before any provider
+reads credentials) and an optional `reidx` block (project-baked ReidX
+configuration — default_provider, policy, providers, etc.). Same file shape as
+Claude Code's settings.json so existing files work as-is; ReidX-specific
+config lives under `reidx` so unknown keys (`theme`, `effortLevel`, ...) are
+ignored harmlessly.
+
+Path resolution (first hit wins):
+  1. $REIDCHAT_SETTINGS                (explicit override)
+  2. ./settings.json                   (project-local, when it exists)
+  3. E:/leech/Reidchat.json            (legacy default — the shared Reidchat file)
+
+Project-local wins over the shared Reidchat file so a project can bake in a
+different backend, permission mode, or provider set without editing the
+global file. The env block is authoritative for the process (overrides any
+ambient env) — this is how ReidX picks up the Reidchat proxy credentials
+even when the shell's ANTHROPIC_* vars point somewhere else.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from reidx.diagnostics.logger import get_logger
+
+log = get_logger("reidx.config.settings")
+
+LEGACY_SETTINGS_PATH = Path("E:/leech/Reidchat.json")
+GLOBAL_SETTINGS_PATH = Path.home() / ".reidx" / "settings.json"
+PROJECT_SETTINGS_FILENAME = "settings.json"
+
+
+def _walk_upward_for_project_settings(start: Path) -> Path | None:
+    """Walk from `start` toward the filesystem root looking for settings.json.
+
+    Mirrors how git finds `.git` — so launching `reid` from any
+    subdirectory of a project still finds that project's baked-in
+    settings.json. Stops at the root (path.parent == path).
+    """
+    seen: set[Path] = set()
+    current = start.resolve()
+    while current not in seen:
+        seen.add(current)
+        candidate = current / PROJECT_SETTINGS_FILENAME
+        if candidate.exists():
+            return candidate
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def settings_path() -> Path:
+    """Resolve the settings file path (first hit wins).
+
+    Order:
+      1. $REIDCHAT_SETTINGS                    (explicit override)
+      2. project settings.json (walk upward from CWD)
+      3. ~/.reidx/settings.json              (global default)
+      4. E:/leech/Reidchat.json                (legacy shared file)
+
+    Returns the last fallback even if it doesn't exist, so `doctor` can
+    report it as "missing" rather than crashing on a None.
+    """
+    override = os.environ.get("REIDCHAT_SETTINGS", "").strip()
+    if override:
+        return Path(override)
+    project = _walk_upward_for_project_settings(Path.cwd())
+    if project is not None:
+        return project
+    if GLOBAL_SETTINGS_PATH.exists():
+        return GLOBAL_SETTINGS_PATH
+    return LEGACY_SETTINGS_PATH
+
+
+def _read_settings(path: Path | None = None) -> dict:
+    path = path or settings_path()
+    if not path.exists():
+        log.debug("settings file not found: %s", path)
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as exc:
+        log.warning("failed to read settings %s: %s", path, exc)
+        return {}
+
+
+def apply_settings_env(path: Path | None = None) -> dict[str, str]:
+    """Apply a settings file's `env` block to os.environ.
+
+    Returns the mapping of env vars that were actually applied. Missing or
+    invalid files are a no-op.
+    """
+    data = _read_settings(path)
+    env = data.get("env")
+    if not isinstance(env, dict):
+        return {}
+
+    applied: dict[str, str] = {}
+    for key, value in env.items():
+        if value is None:
+            continue
+        new = str(value)
+        if os.environ.get(key) not in (None, new):
+            log.debug("settings override %s (ambient env replaced)", key)
+        os.environ[key] = new  # the settings file is authoritative
+        applied[key] = new
+
+    if applied:
+        log.debug("applied %d env var(s) from settings: %s", len(applied), ", ".join(applied))
+    return applied
+
+
+def read_reidx_block(path: Path | None = None) -> dict:
+    """Return the settings file's `reidx` block, or {} if absent.
+
+    Loader merges this into Config below the env-var overrides but above the
+    on-disk .reidx/config.json, so `settings.json` is the project's baked-in
+    source of truth for anything that isn't an env credential.
+    """
+    data = _read_settings(path)
+    block = data.get("reidx")
+    return block if isinstance(block, dict) else {}

package/src/reidx/deepreid/__init__.py

@@ -0,0 +1,8 @@
+from reidx.deepreid.pipeline import (
+    DeepReidResult,
+    format_markdown,
+    run_deepreid,
+    save_deepreid_result,
+)
+
+__all__ = ["DeepReidResult", "format_markdown", "run_deepreid", "save_deepreid_result"]

package/src/reidx/deepreid/pipeline.py

@@ -0,0 +1,221 @@
+"""DeepReid: Researcher -> Planner -> Critic planning-and-review pipeline.
+
+See deepreid-spec.md (repo root, one level above ReidX/) for the full
+design. DeepReid never writes files or runs commands — it produces a
+Markdown plan + critique. Building is a separate step.
+
+Each role is a fresh, independent Agent + RuntimeState + Session +
+PolicyEngine — not turns on one shared conversation, so each role's context
+window stays clean and the "Planner/Critic have no tools" constraint is real
+(a shared agent could otherwise still see prior tool results). All three
+subagent PolicyEngines run in AUTONOMOUS mode regardless of the caller's
+configured mode: Planner/Critic have zero tools registered (nothing to ever
+approve), and the Researcher's tools are all read-only/search — the
+restricted ToolRegistry is the actual safety boundary, so auto-approving
+inside it is safe and avoids the pipeline hanging on an unattended prompt.
+"""
+from __future__ import annotations
+
+import re
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from reidx.config.models import Config
+from reidx.policy.engine import PolicyEngine
+from reidx.policy.models import PermissionMode
+from reidx.provider.base import BaseProvider
+from reidx.runtime.agent import Agent
+from reidx.runtime.state import RuntimeState
+from reidx.session.models import Session
+from reidx.tools.file_tools import FindFilesTool, GrepFilesTool, ListDirTool, ReadFileTool
+from reidx.tools.registry import ToolRegistry
+from reidx.tools.web_tools import WebSearchTool
+
+MAX_REVISION_ROUNDS = 2
+# The Researcher is the only role that calls tools, so it's the only one that
+# can run out of Agent.run_turn's step budget mid-exploration — observed in
+# practice: a broad task ("read the dir") led it to keep calling list_dir/
+# read_file for all of the default 8 steps and never stop to write up
+# Findings, producing "[agent] step budget exhausted" instead of any usable
+# output. Give it real headroom; Planner/Critic have zero tools so they
+# always finish in exactly 1 step regardless of this number.
+RESEARCHER_MAX_STEPS = 20
+
+_RESEARCHER_PROMPT = (
+    "You are the Researcher in a DeepReid planning pipeline. Investigate the "
+    "codebase (read_file/grep_files/find_files/list_dir) and, if useful, the "
+    "web (web_search) to gather everything needed to plan the given task. You "
+    "cannot write files or run commands — you only look and report.\n\n"
+    "You have a limited number of tool calls. Investigate efficiently: prefer "
+    "list_dir/find_files/grep_files to survey before read_file-ing whole "
+    "files, and stop once you have enough to plan from — you do not need to "
+    "read every file. Always end with your Findings list as plain text (no "
+    "further tool calls) well before you run out of turns; a partial Findings "
+    "list from what you've seen so far is far more useful than none at all.\n\n"
+    "Produce a Findings list: one bullet per finding, each citing a "
+    "`file:line` reference or a web_search source. Be specific, not vague. Do "
+    "not propose a plan yourself; that is the Planner's job."
+)
+
+_PLANNER_PROMPT = (
+    "You are the Planner in a DeepReid planning pipeline. You have no tools — "
+    "reason only over the task and the Researcher's Findings given to you. "
+    "Produce: numbered implementation steps (each naming the file(s) it "
+    "touches and what changes), explicit risks or things you're unsure about, "
+    "and open questions for a human. Do not invent findings the Researcher "
+    "didn't report."
+)
+
+_PLANNER_REVISION_PROMPT = (
+    "You are the Planner, revising your plan after Critic feedback. You have "
+    "no tools. Given the original task, the Researcher's Findings, your prior "
+    "Plan, and the Critic's Critique below, produce a revised Plan in the "
+    "same format (numbered steps, risks, open questions) that addresses the "
+    "critique."
+)
+
+_CRITIC_PROMPT = (
+    "You are the Critic in a DeepReid planning pipeline. You have no tools — "
+    "reason only over the task, the Researcher's Findings, and the Planner's "
+    "Plan given to you. Find: claims in the Plan the Findings don't actually "
+    "support, missing edge cases or files the Researcher didn't look at, and "
+    "any internal contradictions. Write your Critique, then end your reply "
+    "with a literal final line in exactly one of these forms:\n"
+    "Verdict: ready to build\n"
+    "Verdict: needs revision\n"
+    "Verdict: blocked on: <what it's blocked on>"
+)
+
+_VERDICT_RE = re.compile(r"^\s*Verdict:\s*(.+?)\s*$", re.IGNORECASE | re.MULTILINE)
+
+
+@dataclass
+class DeepReidResult:
+    task: str
+    findings: str
+    plan: str
+    critique: str
+    verdict: str
+    rounds: int
+
+
+def _researcher_registry() -> ToolRegistry:
+    reg = ToolRegistry()
+    for tool in (ReadFileTool(), GrepFilesTool(), FindFilesTool(), ListDirTool(), WebSearchTool()):
+        reg.register(tool)
+    return reg  # write_file/patch_file/run_command are never registered at all
+
+
+def _make_subagent(
+    config: Config, provider: BaseProvider, workspace: Path, registry: ToolRegistry, base_prompt: str
+) -> tuple[Agent, RuntimeState]:
+    policy = PolicyEngine(config)
+    policy.set_mode(PermissionMode.AUTONOMOUS)
+    session = Session(title="deepreid", workspace=workspace)
+    agent = Agent(provider, registry, policy, base_system_prompt=base_prompt)
+    return agent, RuntimeState(session=session)
+
+
+def _run_role(
+    config: Config,
+    provider: BaseProvider,
+    workspace: Path,
+    registry: ToolRegistry,
+    base_prompt: str,
+    user_input: str,
+    *,
+    max_steps: int | None = None,
+) -> str:
+    agent, state = _make_subagent(config, provider, workspace, registry, base_prompt)
+    kwargs = {"max_steps": max_steps} if max_steps is not None else {}
+    text, _tools = agent.run_turn(state, user_input, approver=lambda _prompt: True, **kwargs)
+    return text
+
+
+def _report(on_progress: Callable[[str], None] | None, stage: str) -> None:
+    if on_progress is not None:
+        on_progress(stage)
+
+
+def _split_verdict(critic_text: str) -> tuple[str, str]:
+    """Split the Critic's reply into (critique_body, verdict_line).
+
+    Falls back to treating the whole reply as critique with an empty verdict
+    (never crashes on a Critic that ignores the requested format — same
+    "never hide the answer" philosophy as split_reasoning)."""
+    match = _VERDICT_RE.search(critic_text)
+    if match is None:
+        return critic_text.strip(), ""
+    verdict = match.group(1).strip()
+    critique = (critic_text[: match.start()] + critic_text[match.end() :]).strip()
+    return critique, verdict
+
+
+def run_deepreid(
+    config: Config,
+    provider: BaseProvider,
+    workspace: Path,
+    task: str,
+    on_progress: Callable[[str], None] | None = None,
+) -> DeepReidResult:
+    researcher_registry = _researcher_registry()
+    no_tools_registry = ToolRegistry()
+
+    _report(on_progress, "researching")
+    findings = _run_role(
+        config, provider, workspace, researcher_registry, _RESEARCHER_PROMPT, task,
+        max_steps=RESEARCHER_MAX_STEPS,
+    )
+
+    _report(on_progress, "planning")
+    plan = _run_role(
+        config, provider, workspace, no_tools_registry, _PLANNER_PROMPT,
+        f"Task: {task}\n\nFindings:\n{findings}",
+    )
+
+    _report(on_progress, "reviewing")
+    critic_text = _run_role(
+        config, provider, workspace, no_tools_registry, _CRITIC_PROMPT,
+        f"Task: {task}\n\nFindings:\n{findings}\n\nPlan:\n{plan}",
+    )
+    critique, verdict = _split_verdict(critic_text)
+
+    rounds = 1
+    while "revision" in verdict.lower() and rounds < MAX_REVISION_ROUNDS:
+        _report(on_progress, "revising plan")
+        plan = _run_role(
+            config, provider, workspace, no_tools_registry, _PLANNER_REVISION_PROMPT,
+            f"Task: {task}\n\nFindings:\n{findings}\n\nPrior Plan:\n{plan}\n\nCritique:\n{critique}",
+        )
+        _report(on_progress, "reviewing revision")
+        critic_text = _run_role(
+            config, provider, workspace, no_tools_registry, _CRITIC_PROMPT,
+            f"Task: {task}\n\nFindings:\n{findings}\n\nPlan:\n{plan}",
+        )
+        critique, verdict = _split_verdict(critic_text)
+        rounds += 1
+
+    return DeepReidResult(task=task, findings=findings, plan=plan, critique=critique, verdict=verdict, rounds=rounds)
+
+
+def format_markdown(result: DeepReidResult) -> str:
+    return (
+        f"# DeepReid: {result.task}\n\n"
+        f"## Findings\n{result.findings}\n\n"
+        f"## Plan\n{result.plan}\n\n"
+        f"## Critique\n{result.critique or '(none)'}\n\n"
+        f"## Verdict\n{result.verdict or '(not provided)'} "
+        f"({result.rounds} round{'s' if result.rounds != 1 else ''})\n"
+    )
+
+
+def save_deepreid_result(config: Config, result: DeepReidResult) -> Path:
+    storage_root = config.storage_root or (Path.home() / ".reidx")
+    out_dir = storage_root / "deepreid"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    run_id = time.strftime("%Y%m%d-%H%M%S")
+    path = out_dir / f"{run_id}.md"
+    path.write_text(format_markdown(result), encoding="utf-8")
+    return path

package/src/reidx/diagnostics/logger.py

@@ -0,0 +1,56 @@
+"""Diagnostics: logging + structured event log.
+
+Foundation is intentionally simple — a tagged logger and a JSONL event writer for
+runtime actions. Designed to grow into trace mode and token/usage reporting.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+
+def get_logger(name: str = "reidx") -> logging.Logger:
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s"))
+        logger.addHandler(handler)
+        # Default to WARNING so INFO logs don't pollute the interactive UI.
+        # Set REIDX_LOG_LEVEL=INFO (or DEBUG) to see verbose logs.
+        import os
+
+        level = os.environ.get("REIDX_LOG_LEVEL", "WARNING").upper()
+        logger.setLevel(getattr(logging, level, logging.WARNING))
+    return logger
+
+
+class EventLog:
+    """Append-only JSONL event log for runtime actions (tool calls, decisions, runs)."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def write(self, kind: str, data: dict[str, Any] | None = None) -> None:
+        record = {
+            "ts": datetime.now(UTC).isoformat(),
+            "kind": kind,
+            "data": data or {},
+        }
+        with self.path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(record, default=str) + "\n")
+
+    def tail(self, n: int = 50) -> list[dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        lines = self.path.read_text(encoding="utf-8").splitlines()
+        out: list[dict[str, Any]] = []
+        for line in lines[-n:]:
+            try:
+                out.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+        return out

package/src/reidx/goals/__init__.py

@@ -0,0 +1,21 @@
+from reidx.goals.models import (
+    Goal,
+    GoalConstraint,
+    GoalEvidence,
+    GoalNode,
+    GoalNodeKind,
+    GoalRevision,
+    GoalStatus,
+)
+from reidx.goals.store import GoalStore
+
+__all__ = [
+    "Goal",
+    "GoalConstraint",
+    "GoalEvidence",
+    "GoalNode",
+    "GoalNodeKind",
+    "GoalRevision",
+    "GoalStatus",
+    "GoalStore",
+]

package/src/reidx/goals/models.py

@@ -0,0 +1,101 @@
+"""Goal models.
+
+Goals are durable outcome structures for long-horizon work. They are separate
+from Tasks: a task is one execution record, while a goal captures the desired
+end state, evidence, decomposition, dependencies, and revision trail.
+"""
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+def _new_id() -> str:
+    import uuid
+
+    return uuid.uuid4().hex[:10]
+
+
+class GoalStatus(StrEnum):
+    DRAFT = "draft"
+    ACTIVE = "active"
+    BLOCKED = "blocked"
+    COMPLETED = "completed"
+    ABANDONED = "abandoned"
+
+
+class GoalNodeKind(StrEnum):
+    GOAL = "goal"
+    SUBGOAL = "subgoal"
+    MILESTONE = "milestone"
+    HABIT = "habit"
+    TASK_REF = "task_ref"
+
+
+class GoalEvidence(BaseModel):
+    description: str
+    satisfied: bool = False
+    note: str = ""
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    satisfied_at: datetime | None = None
+
+    def satisfy(self, note: str = "") -> None:
+        self.satisfied = True
+        if note:
+            self.note = note
+        self.satisfied_at = datetime.now(UTC)
+
+
+class GoalConstraint(BaseModel):
+    description: str
+    kind: str = "general"
+
+
+class GoalRevision(BaseModel):
+    at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    note: str
+
+
+class GoalNode(BaseModel):
+    id: str = Field(default_factory=_new_id)
+    title: str
+    kind: GoalNodeKind = GoalNodeKind.SUBGOAL
+    status: GoalStatus = GoalStatus.DRAFT
+    parent_id: str | None = None
+    depends_on: list[str] = Field(default_factory=list)
+    evidence: list[GoalEvidence] = Field(default_factory=list)
+    constraints: list[GoalConstraint] = Field(default_factory=list)
+    owner: str = "user"
+    notes: list[str] = Field(default_factory=list)
+    task_ids: list[str] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+    def touch(self) -> None:
+        self.updated_at = datetime.now(UTC)
+
+
+class Goal(BaseModel):
+    id: str = Field(default_factory=_new_id)
+    session_id: str
+    title: str
+    status: GoalStatus = GoalStatus.DRAFT
+    outcome: str = ""
+    evidence: list[GoalEvidence] = Field(default_factory=list)
+    constraints: list[GoalConstraint] = Field(default_factory=list)
+    nodes: list[GoalNode] = Field(default_factory=list)
+    active_node_id: str | None = None
+    task_ids: list[str] = Field(default_factory=list)
+    revisions: list[GoalRevision] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+    def touch(self) -> None:
+        self.updated_at = datetime.now(UTC)
+
+    def add_revision(self, note: str) -> None:
+        if note:
+            self.revisions.append(GoalRevision(note=note))
+            self.touch()