@agxnte/reidx 2.0.2 → 2.0.3

package/README.md

@@ -65,7 +65,7 @@ reid doctor
 Expected output:
 
 ```
-reid 2.0.2
+reid 2.0.3
 settings  <path> (found|missing)
 python    <path> (3.13.x)
 workspace <cwd>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agxnte/reidx",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Terminal-native personal intelligence and coding CLI (agent-first runtime)",
   "bin": {
     "reid": "bin/reidx.js"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reidx"
-version = "2.0.1"
+version = "2.0.3"
 description = "Terminal-native personal intelligence and coding CLI (agent-first runtime)"
 readme = "README.md"
 requires-python = ">=3.12"

package/src/reidx/__init__.py

@@ -1,3 +1,3 @@
 """ReidX: terminal-native agent-first CLI runtime."""
 
-__version__ = "2.0.2"
+__version__ = "2.0.3"

package/src/reidx/app/commands.py

@@ -16,9 +16,11 @@ from reidx import __version__
 from reidx.automation.exec import exec_run
 from reidx.config.loader import ConfigLoader
 from reidx.config.models import Config
+from reidx.config.storage import storage_root
 from reidx.deepreid import format_markdown, run_deepreid, save_deepreid_result
 from reidx.diagnostics.logger import get_logger
 from reidx.provider.registry import default_registry
+from reidx.provider.store import load_from_database
 from reidx.provider.store import load_into as load_stored_providers
 from reidx.runtime.orchestrator import Orchestrator
 from reidx.tools import default_registry as tools_registry
@@ -97,11 +99,9 @@ def _main(
 def build_orchestrator(config: Config | None = None) -> Orchestrator:
     cfg = config or ConfigLoader().load()
     providers = default_registry(cfg)
-    load_stored_providers(providers, cfg.storage_root or (Path.home() / ".reidx"))
-    # `/connect` may have persisted a provider that isn't yet `cfg.default_provider`.
-    # We never auto-promote — stub stays default unless the user did `/use` last
-    # session (that's a session setting, not a config change). Fall back to stub
-    # if the configured default isn't registered.
+    root = cfg.storage_root or storage_root()
+    load_stored_providers(providers, root)
+    load_from_database(providers, root)
     default_name = cfg.default_provider if providers.has(cfg.default_provider) else "stub"
     provider = providers.get(default_name)
     return Orchestrator(cfg, provider, tools_registry(), providers=providers)

package/src/reidx/config/__init__.py

@@ -1,10 +1,13 @@
 from reidx.config.loader import ConfigLoader
 from reidx.config.models import Config, PolicyConfig, ProviderConfig, default_config
+from reidx.config.storage import app_data_dir, storage_root
 
 __all__ = [
     "Config",
     "ConfigLoader",
     "PolicyConfig",
     "ProviderConfig",
+    "app_data_dir",
     "default_config",
+    "storage_root",
 ]

package/src/reidx/config/loader.py

@@ -11,11 +11,12 @@ from pathlib import Path
 
 from reidx.config.models import Config, default_config
 from reidx.config.settings import apply_settings_env, read_reidx_block
+from reidx.config.storage import storage_root
 from reidx.diagnostics.logger import get_logger
 
 log = get_logger("reidx.config")
 
-GLOBAL_DIR = Path.home() / ".reidx"
+GLOBAL_DIR = storage_root()
 PROJECT_DIR = Path(".reidx")
 CONFIG_FILENAME = "config.json"
 

package/src/reidx/config/settings.py

@@ -24,12 +24,13 @@ import json
 import os
 from pathlib import Path
 
+from reidx.config.storage import app_data_dir
 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"
+GLOBAL_SETTINGS_PATH = app_data_dir() / "settings.json"
 PROJECT_SETTINGS_FILENAME = "settings.json"
 
 

package/src/reidx/config/storage.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+
+def app_data_dir() -> Path:
+    if sys.platform == "win32":
+        base = os.environ.get("APPDATA")
+        if base:
+            return Path(base) / "Reid"
+    return Path.home() / ".reidx"
+
+
+def storage_root() -> Path:
+    return app_data_dir()
+
+
+def settings_file() -> Path:
+    return app_data_dir() / "settings.json"

package/src/reidx/provider/_http.py

@@ -27,3 +27,16 @@ def post_json(url: str, payload: dict, headers: dict[str, str], timeout: int = T
     except urllib.error.URLError as exc:
         raise RuntimeError(f"connection error: {exc}") from exc
     return json.loads(raw)
+
+
+def get_json(url: str, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
+    req = urllib.request.Request(url, headers=headers, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        err_body = exc.read().decode("utf-8", errors="replace")[:500]
+        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"connection error: {exc}") from exc
+    return json.loads(raw)

package/src/reidx/provider/base.py

@@ -48,3 +48,6 @@ class BaseProvider(ABC):
         model: str | None = None,
     ) -> ProviderResponse:
         """Run one model turn. Returns text and/or tool calls."""
+
+    def fetch_models(self) -> list[str]:
+        return []

package/src/reidx/provider/ollama.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 from typing import Any
 
 from reidx.diagnostics.logger import get_logger
-from reidx.provider._http import post_json
+from reidx.provider._http import get_json, post_json
 from reidx.provider.base import BaseProvider, Message, ProviderResponse, ToolCall, Usage
 
 log = get_logger("reidx.provider.ollama")
@@ -107,3 +107,16 @@ class OllamaProvider(BaseProvider):
             ),
             stop_reason=body.get("done_reason", "stop"),
         )
+
+    def fetch_models(self) -> list[str]:
+        try:
+            body = get_json(f"{self.base_url}/api/tags", {})
+        except RuntimeError:
+            log.debug("failed to fetch models from ollama")
+            return []
+        models: list[str] = []
+        for item in body.get("models", []):
+            name = item.get("name", "")
+            if name:
+                models.append(name)
+        return sorted(models)

package/src/reidx/provider/openai.py

@@ -14,7 +14,7 @@ import os
 from typing import Any
 
 from reidx.diagnostics.logger import get_logger
-from reidx.provider._http import post_json
+from reidx.provider._http import get_json, post_json
 from reidx.provider.base import BaseProvider, Message, ProviderResponse, ToolCall, Usage
 
 log = get_logger("reidx.provider.openai")
@@ -125,6 +125,20 @@ class OpenAIProvider(BaseProvider):
             raise
         return self._parse(body, model)
 
+    def fetch_models(self) -> list[str]:
+        url = f"{self.base_url}/v1/models"
+        try:
+            body = get_json(url, self._headers())
+        except RuntimeError:
+            log.debug("failed to fetch models from %s", url)
+            return []
+        models: list[str] = []
+        for item in body.get("data", []):
+            mid = item.get("id", "")
+            if mid:
+                models.append(mid)
+        return sorted(models)
+
 
 class OpenAICompatibleProvider(OpenAIProvider):
     """OpenAI-compatible endpoints (llama.cpp server, LM Studio, vLLM, etc.).

package/src/reidx/provider/store.py

@@ -125,11 +125,25 @@ class ProviderStore:
         return True
 
 
+def validate_provider(record: ProviderRecord) -> tuple[bool, str]:
+    try:
+        provider = build_provider(record)
+    except (ValueError, TypeError) as exc:
+        return False, str(exc)
+    if not record.api_key and record.kind != "ollama":
+        return True, "no key required"
+    try:
+        models = provider.fetch_models()
+    except Exception:
+        return False, "could not connect to provider"
+    if models:
+        return True, f"ok ({len(models)} models available)"
+    if record.kind == "ollama":
+        return True, "connected"
+    return False, "key rejected or no models returned"
+
+
 def load_into(registry: ProviderRegistry, storage_root: Path) -> list[str]:
-    """Register every persisted provider into `registry`. Returns the list of
-    names successfully registered. Skips (with a warning) any record whose
-    kind is unknown or fails to construct — the app must not crash on a
-    single bad entry."""
     added: list[str] = []
     store = ProviderStore(storage_root)
     for record in store.list():
@@ -139,3 +153,39 @@ def load_into(registry: ProviderRegistry, storage_root: Path) -> list[str]:
         except (ValueError, TypeError):
             log.exception("skipping provider %s (kind=%s): failed to build", record.name, record.kind)
     return added
+
+
+def load_from_database(registry: ProviderRegistry, storage_root: Path) -> list[str]:
+    from reidx.provider_manager.database import ProviderDatabase
+
+    added: list[str] = []
+    db = ProviderDatabase(storage_root)
+    for sp in db.list_providers():
+        if registry.has(sp.name):
+            continue
+        api_key = sp.decrypted_api_key()
+        record = ProviderRecord(
+            name=sp.name,
+            kind=sp.kind,
+            base_url=sp.base_url,
+            api_key=api_key,
+            default_model=sp.default_model,
+        )
+        try:
+            provider = build_provider(record)
+        except (ValueError, TypeError):
+            log.warning("skipping provider %s (kind=%s): failed to build", sp.name, sp.kind)
+            continue
+        if not record.default_model:
+            try:
+                models = provider.fetch_models()
+            except Exception:
+                models = []
+            if models:
+                provider.default_model = models[0]
+                sp.default_model = models[0]
+                db.save_provider(sp)
+                log.info("auto-fetched model for %s: %s", sp.name, models[0])
+        registry.register(sp.name, provider)
+        added.append(sp.name)
+    return added

package/src/reidx/provider_manager/palette.py

@@ -9,7 +9,7 @@ from typing import Any
 from prompt_toolkit.buffer import Buffer
 
 from reidx.diagnostics.logger import get_logger
-from reidx.provider.store import ProviderRecord, build_provider
+from reidx.provider.store import ProviderRecord, build_provider, validate_provider
 from reidx.provider_manager.catalog import (
     ProviderDefinition,
     all_providers,
@@ -602,6 +602,25 @@ class ProviderPalette:
         auth = d.get("auth_method", "bearer")
         api_key = d.get("api_key", "").strip()
 
+        if api_key:
+            record = ProviderRecord(
+                name=name, kind=kind, base_url=base_url,
+                api_key=api_key, default_model=model,
+            )
+            ok, msg = validate_provider(record)
+            if not ok:
+                self._show_message(f"Key validation failed: {msg}", self.WIZARD)
+                self.wizard_step_idx = len(WIZARD_STEPS) - 1
+                return
+            if not model:
+                try:
+                    provider = build_provider(record)
+                    models = provider.fetch_models()
+                except Exception:
+                    models = []
+                if models:
+                    model = models[0]
+
         existing = self.db.get_provider(name)
         if existing:
             existing.kind = kind
@@ -647,10 +666,19 @@ class ProviderPalette:
         if not self.current_provider:
             return
         name = self.current_provider.name
+        sp = self.current_provider
+        record = ProviderRecord(
+            name=name, kind=sp.kind, base_url=sp.base_url,
+            api_key=api_key, default_model=sp.default_model,
+        )
+        ok, msg = validate_provider(record)
+        if not ok:
+            self._show_message(f"Key validation failed: {msg}", self.MANAGE)
+            return
         self.db.add_key(name, label, api_key)
         self.current_provider = self.db.get_provider(name)
         self._register_current()
-        self._show_message(f"Added key '{label}'", self.MANAGE)
+        self._show_message(f"Added key '{label}' ({msg})", self.MANAGE)
 
     def _do_delete_key(self, key_id: str, label: str) -> str:
         if not self.current_provider:
@@ -682,6 +710,15 @@ class ProviderPalette:
                 api_key=api_key, default_model=sp.default_model,
             )
             provider = build_provider(record)
+            if not sp.default_model:
+                try:
+                    models = provider.fetch_models()
+                except Exception:
+                    models = []
+                if models:
+                    provider.default_model = models[0]
+                    sp.default_model = models[0]
+                    self.db.save_provider(sp)
             self.orchestrator.providers.register(sp.name, provider)
         except (ValueError, TypeError):
             log.exception("failed to register provider %s", sp.name)

package/src/reidx/ui/app.py

@@ -458,8 +458,10 @@ class ChatApp:
         if self._palette is not None:
             return
         from pathlib import Path
-        storage_root = self.orchestrator.config.storage_root or (Path.home() / ".reidx")
-        db = ProviderDatabase(Path(storage_root))
+
+        from reidx.config.storage import storage_root as get_storage_root
+        root = self.orchestrator.config.storage_root or get_storage_root()
+        db = ProviderDatabase(Path(root))
         self._palette = ProviderPalette(
             db=db,
             orchestrator=self.orchestrator,

package/src/reidx/ui/commands.py

@@ -10,15 +10,22 @@ from, so they can't drift out of sync.
 """
 from __future__ import annotations
 
-from pathlib import Path
+import uuid
 
 from rich.console import Group
 from rich.panel import Panel
 from rich.text import Text
 
+from reidx.config.storage import storage_root
 from reidx.goals.models import Goal, GoalNodeKind, GoalStatus
 from reidx.policy.models import PermissionMode
-from reidx.provider.store import SUPPORTED_KINDS, ProviderRecord, ProviderStore, build_provider
+from reidx.provider.store import (
+    SUPPORTED_KINDS,
+    ProviderRecord,
+    ProviderStore,
+    build_provider,
+    validate_provider,
+)
 from reidx.runtime.orchestrator import Orchestrator
 from reidx.ui import render
 from reidx.ui.theme import APP_NAME, BOX, PRIMARY
@@ -472,10 +479,48 @@ _BUILTIN_PROVIDER_NAMES = ("stub", "anthropic")
 
 
 def _providers_store(orchestrator: Orchestrator) -> ProviderStore:
-    root = orchestrator.config.storage_root or (Path.home() / ".reidx")
+    root = orchestrator.config.storage_root or storage_root()
     return ProviderStore(root)
 
 
+def _save_to_database(orchestrator: Orchestrator, record: ProviderRecord) -> None:
+    from reidx.provider_manager import keychain
+    from reidx.provider_manager.database import ProviderDatabase, StoredKey, StoredProvider
+
+    root = orchestrator.config.storage_root or storage_root()
+    db = ProviderDatabase(root)
+    existing = db.get_provider(record.name)
+    if existing:
+        if record.api_key:
+            k = StoredKey(
+                id=uuid.uuid4().hex[:12],
+                label="Default",
+                encrypted_key=keychain.encrypt(record.api_key),
+            )
+            existing.keys.append(k)
+            if existing.active_key_id is None:
+                existing.active_key_id = k.id
+        existing.kind = record.kind
+        existing.base_url = record.base_url
+        if record.default_model:
+            existing.default_model = record.default_model
+        db.save_provider(existing)
+    else:
+        sp = StoredProvider(
+            name=record.name, kind=record.kind, base_url=record.base_url,
+            default_model=record.default_model,
+        )
+        if record.api_key:
+            k = StoredKey(
+                id=uuid.uuid4().hex[:12],
+                label="Default",
+                encrypted_key=keychain.encrypt(record.api_key),
+            )
+            sp.keys.append(k)
+            sp.active_key_id = k.id
+        db.save_provider(sp)
+
+
 def _handle_providers(orchestrator: Orchestrator) -> None:
     store = _providers_store(orchestrator)
     persisted = store.list()
@@ -507,12 +552,28 @@ def _handle_connect(orchestrator: Orchestrator, arg: str) -> None:
     api_key = parts[3] if len(parts) > 3 else ""
     model = parts[4] if len(parts) > 4 else ""
     record = ProviderRecord(name=name, kind=kind, base_url=base_url, api_key=api_key, default_model=model)
+    if api_key:
+        ok, msg = validate_provider(record)
+        if not ok:
+            render.print_error(f"key validation failed: {msg}")
+            return
+        render.print_info(f"key validated: {msg}")
     try:
         provider = build_provider(record)
     except ValueError as exc:
         render.print_error(f"failed to build provider: {exc}")
         return
+    if not model and api_key:
+        try:
+            models = provider.fetch_models()
+        except Exception:
+            models = []
+        if models:
+            provider.default_model = models[0]
+            record.default_model = models[0]
+            render.print_info(f"auto-detected model: {models[0]}")
     _providers_store(orchestrator).save(record)
+    _save_to_database(orchestrator, record)
     if orchestrator.providers is not None:
         orchestrator.providers.register(name, provider)
     render.print_info(f"connected provider '{name}' ({kind}) → {base_url or '(default)'}")