@agxnte/reidx 2.0.2

package/bin/reidx.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+const { findPython } = require("../scripts/find-python");
+
+function main() {
+  const python = findPython();
+  if (!python) {
+    console.error(
+      "reidx: no Python 3.12+ interpreter found on PATH.\n" +
+        "Install Python (https://www.python.org/downloads/) and re-run `npm install -g reidx`."
+    );
+    process.exit(1);
+  }
+
+  const result = spawnSync(
+    python.cmd,
+    [...python.args, "-m", "reidx", ...process.argv.slice(2)],
+    { stdio: "inherit" }
+  );
+
+  if (result.error) {
+    console.error(
+      `reidx: failed to launch Python (${python.cmd}): ${result.error.message}`
+    );
+    process.exit(1);
+  }
+
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+main();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@agxnte/reidx",
+  "version": "2.0.2",
+  "description": "Terminal-native personal intelligence and coding CLI (agent-first runtime)",
+  "bin": {
+    "reid": "bin/reidx.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "src",
+    "pyproject.toml",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "os": [
+    "win32",
+    "darwin",
+    "linux"
+  ],
+  "preferGlobal": true,
+  "license": "MIT",
+  "author": "Reid",
+  "keywords": [
+    "cli",
+    "agent",
+    "ai",
+    "reidx",
+    "terminal"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ryyReid/ReidX.git"
+  }
+}

package/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "reidx"
+version = "2.0.1"
+description = "Terminal-native personal intelligence and coding CLI (agent-first runtime)"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [{ name = "Reid" }]
+dependencies = [
+    "typer>=0.12.0",
+    "pydantic>=2.7.0",
+    "rich>=13.7.0",
+    "prompt-toolkit>=3.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff>=0.6.0",
+    "pytest>=8.0.0",
+]
+
+[project.scripts]
+reid = "reidx.app.commands:app"
+
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/reidx"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = ["E501"]
+
+[tool.ruff.lint.flake8-bugbear]
+extend-immutable-calls = ["typer.Option"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]

package/scripts/find-python.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+
+const CANDIDATES =
+  process.platform === "win32"
+    ? [["py", ["-3"]], ["python", []], ["python3", []]]
+    : [["python3", []], ["python", []]];
+
+function commandWorks(cmd, args) {
+  const result = spawnSync(cmd, [...args, "--version"], { stdio: "ignore" });
+  return !result.error && result.status === 0;
+}
+
+function findPython() {
+  for (const [cmd, args] of CANDIDATES) {
+    if (commandWorks(cmd, args)) {
+      return { cmd, args };
+    }
+  }
+  return null;
+}
+
+module.exports = { findPython };

package/scripts/postinstall.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { findPython } = require("./find-python");
+
+const PACKAGE_ROOT = path.join(__dirname, "..");
+
+function pipInstall(python) {
+  const args = [...python.args, "-m", "pip", "install", "--user", "--quiet", PACKAGE_ROOT];
+  const result = spawnSync(python.cmd, args, { stdio: "inherit" });
+  return !result.error && result.status === 0;
+}
+
+function main() {
+  const python = findPython();
+  if (!python) {
+    console.warn(
+      "reidx: no Python 3.12+ interpreter found on PATH — skipping automatic setup.\n" +
+        "Install Python, then run: pip install --user " + JSON.stringify(PACKAGE_ROOT)
+    );
+    return;
+  }
+
+  console.log("reidx: installing Python package (reidx) via pip...");
+  if (!pipInstall(python)) {
+    console.warn(
+      "reidx: automatic `pip install` failed.\n" +
+        "Run it manually: " +
+        `${python.cmd} ${python.args.join(" ")} -m pip install --user ${JSON.stringify(PACKAGE_ROOT)}`
+    );
+  }
+}
+
+main();

package/src/reidx/__init__.py

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

package/src/reidx/__main__.py

@@ -0,0 +1,9 @@
+from reidx.app.commands import app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

package/src/reidx/app/__init__.py

@@ -0,0 +1,3 @@
+from reidx.app.commands import app, build_orchestrator
+
+__all__ = ["app", "build_orchestrator"]

package/src/reidx/app/commands.py

@@ -0,0 +1,221 @@
+"""App layer: Typer command surface and dependency wiring.
+
+This is the only place that composes ConfigLoader + ProviderRegistry + ToolRegistry
+into an Orchestrator. Commands stay thin — they build an orchestrator and delegate
+to runtime/ui/automation layers.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+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.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_into as load_stored_providers
+from reidx.runtime.orchestrator import Orchestrator
+from reidx.tools import default_registry as tools_registry
+from reidx.ui import render
+from reidx.ui.repl import repl
+
+log = get_logger("reidx.app")
+console = Console()
+
+app = typer.Typer(
+    name="reid",
+    help="Terminal-native agent-first CLI runtime.",
+    no_args_is_help=False,
+    add_completion=False,
+)
+
+_PROMPT_ARG_HELP = (
+    "Inject this as the first prompt right after launch — same as typing it into the "
+    "box and pressing Enter, except the session stays interactive afterward (unlike "
+    "`reid exec`, which runs once and exits). If omitted and stdin isn't a "
+    "terminal (piped input), stdin is read as the prompt instead."
+)
+_PROMPT_FILE_HELP = "Read the prompt from a text file instead of the command line (e.g. a long or multi-line prompt)."
+_NYX_HELP = "Launch in Nyx mode: a redteam/offensive-security assistant persona for authorized pentesting and CTF work."
+
+
+def _stdin_prompt() -> str | None:
+    if sys.stdin.isatty():
+        return None
+    data = sys.stdin.read().strip()
+    return data or None
+
+
+def _resolve_prompt(prompt: str | None, prompt_file: Path | None, *, fall_back_to_stdin: bool) -> str | None:
+    if prompt and prompt_file:
+        render.print_error("pass either a prompt argument or --file, not both")
+        raise typer.Exit(code=1)
+    if prompt_file:
+        try:
+            text = prompt_file.read_text(encoding="utf-8").strip()
+        except OSError as exc:
+            render.print_error(f"failed to read prompt file {prompt_file}: {exc}")
+            raise typer.Exit(code=1) from exc
+        if not text:
+            render.print_error(f"prompt file is empty: {prompt_file}")
+            raise typer.Exit(code=1)
+        return text
+    if prompt:
+        return prompt
+    return _stdin_prompt() if fall_back_to_stdin else None
+
+
+@app.callback(invoke_without_command=True)
+def _main(
+    ctx: typer.Context,
+    prompt_file: Path | None = typer.Option(None, "--file", "-f", help=_PROMPT_FILE_HELP),
+    nyx: bool = typer.Option(False, "--nyx", help=_NYX_HELP),
+) -> None:
+    """With no subcommand, launch interactive mode."""
+    # No positional prompt argument here on purpose: a Typer/Click group with
+    # both subcommands and its own positional argument resolves ambiguously —
+    # tested and confirmed it swallows subcommand names ("reid version",
+    # "reid sessions", ...) as the argument instead of dispatching to
+    # them. `--file`/`-f` is a named option, not positional, so it doesn't
+    # have that problem. `reid interactive "<prompt>"` is the unambiguous
+    # way to inject literal prompt text; bare `reid` still just launches
+    # empty (or reads piped stdin), as before.
+    if ctx.invoked_subcommand is None:
+        initial = _resolve_prompt(None, prompt_file, fall_back_to_stdin=True)
+        orch = build_orchestrator()
+        if nyx:
+            orch.set_nyx(True)
+        repl(orch, initial_prompt=initial)
+
+
+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.
+    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)
+
+
+@app.command()
+def interactive(
+    prompt: str | None = typer.Argument(None, help=_PROMPT_ARG_HELP),
+    prompt_file: Path | None = typer.Option(None, "--file", "-f", help=_PROMPT_FILE_HELP),
+    nyx: bool = typer.Option(False, "--nyx", help=_NYX_HELP),
+) -> None:
+    """Launch interactive mode (default)."""
+    initial = _resolve_prompt(prompt, prompt_file, fall_back_to_stdin=True)
+    orch = build_orchestrator()
+    if nyx:
+        orch.set_nyx(True)
+    repl(orch, initial_prompt=initial)
+
+
+@app.command(name="exec")
+def exec_(
+    prompt: str | None = typer.Argument(None, help="Prompt to run non-interactively."),
+    prompt_file: Path | None = typer.Option(None, "--file", "-f", help=_PROMPT_FILE_HELP),
+    nyx: bool = typer.Option(False, "--nyx", help=_NYX_HELP),
+) -> None:
+    """Run a single prompt non-interactively (headless)."""
+    resolved = _resolve_prompt(prompt, prompt_file, fall_back_to_stdin=False)
+    if not resolved:
+        render.print_error("usage: reid exec \"<prompt>\" (or --file <path>)")
+        raise typer.Exit(code=1)
+    orch = build_orchestrator()
+    if nyx:
+        orch.set_nyx(True)
+    raise typer.Exit(code=exec_run(orch, resolved))
+
+
+@app.command()
+def deepreid(
+    task: str | None = typer.Argument(None, help=_PROMPT_ARG_HELP),
+    prompt_file: Path | None = typer.Option(None, "--file", "-f", help=_PROMPT_FILE_HELP),
+) -> None:
+    """Plan + review a task via Researcher/Planner/Critic subagents (no code changes)."""
+    resolved = _resolve_prompt(task, prompt_file, fall_back_to_stdin=True)
+    if not resolved:
+        render.print_error('usage: reid deepreid "<task>" (or --file <path>)')
+        raise typer.Exit(code=1)
+    cfg = ConfigLoader().load()
+    provider = default_registry(cfg).get(cfg.default_provider)
+    result = run_deepreid(cfg, provider, Path.cwd(), resolved, on_progress=render.print_info)
+    path = save_deepreid_result(cfg, result)
+    console.print(format_markdown(result))
+    render.print_info(f"saved to {path}")
+
+
+@app.command()
+def resume(session_id: str = typer.Argument(..., help="Session id to resume.")) -> None:
+    """Resume a prior session, then enter interactive mode."""
+    orch = build_orchestrator()
+    try:
+        orch.resume_session(session_id)
+    except KeyError as exc:
+        render.print_error(str(exc))
+        raise typer.Exit(code=1) from exc
+    render.print_info(f"resumed {session_id}")
+    repl(orch)
+
+
+@app.command()
+def sessions() -> None:
+    """List sessions."""
+    orch = build_orchestrator()
+    render.print_sessions(orch.session_store.list())
+
+
+@app.command()
+def config_show() -> None:
+    """Show the effective (merged) configuration."""
+    cfg = ConfigLoader().load()
+    console.print(cfg.model_dump_json(indent=2, exclude={"providers": {"__all__": {"api_key"}}}))
+
+
+@app.command()
+def tools() -> None:
+    """List registered tools."""
+    orch = build_orchestrator()
+    from reidx.ui.render import print_tools
+
+    print_tools(orch.tools.definitions())
+
+
+@app.command()
+def doctor() -> None:
+    """Run environment diagnostics."""
+    cfg = ConfigLoader().load()
+    orch = build_orchestrator(cfg)
+    from reidx.config.settings import settings_path
+
+    sp = settings_path()
+    console.print(f"[bold]reid[/] {__version__}")
+    console.print(f"settings  {sp} ({'found' if sp.exists() else 'missing'})")
+    console.print(f"python    {sys.executable} ({sys.version.split()[0]})")
+    console.print(f"workspace {cfg.workspace_root}")
+    console.print(f"storage   {cfg.storage_root}")
+    console.print(f"provider  {cfg.default_provider}")
+    console.print(f"mode      {cfg.policy.default_mode.value}")
+    console.print(f"providers {orch.provider.name} (active), {orch.tools.definitions().__len__()} tools")
+    import os
+
+    has_key = bool(os.environ.get("ANTHROPIC_API_KEY", "").strip())
+    console.print(f"anthropic {'configured' if has_key else 'not configured'} (env: ANTHROPIC_API_KEY)")
+    console.print("[green]ok[/] runtime importable; provider available")
+
+
+@app.command()
+def version() -> None:
+    """Show version and runtime info."""
+    console.print(f"reid {__version__}")

package/src/reidx/automation/__init__.py

@@ -0,0 +1,3 @@
+from reidx.automation.exec import exec_run
+
+__all__ = ["exec_run"]

package/src/reidx/automation/exec.py

@@ -0,0 +1,35 @@
+"""Automation layer: non-interactive execution.
+
+`exec_run` runs a single user prompt against a fresh session without entering the
+REPL, prints the result, and exits with a meaningful code. Scheduled/background
+work is TODO (roadmap Phase 7).
+"""
+from __future__ import annotations
+
+import sys
+
+from reidx.runtime.orchestrator import Orchestrator
+from reidx.tools.base import Approver
+
+
+def _auto_approve(prompt: str) -> bool:
+    """Headless approver: auto-allows in autonomous mode, denies otherwise.
+
+    For exec mode the operator should pre-set permission mode via config/env.
+    Prompts in strict/balanced modes are denied to avoid hanging on stdin.
+    """
+
+    # The orchestrator's policy mode is the source of truth; here we just allow
+    # because exec is expected to run with AUTONOMOUS configured. Denial would
+    # block every tool call silently, which is worse for a headless run.
+    del prompt
+    return True
+
+
+def exec_run(orchestrator: Orchestrator, prompt: str, approver: Approver | None = None) -> int:
+    orchestrator.start_session(title=f"exec: {prompt[:40]}")
+    result = orchestrator.submit_task(prompt, approver=approver or _auto_approve)
+    print(result["text"])
+    if result["tools"]:
+        print(f"\n[{len(result['tools'])} tool call(s)]", file=sys.stderr)
+    return 0 if result["text"] else 1

package/src/reidx/config/__init__.py

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

package/src/reidx/config/loader.py

@@ -0,0 +1,104 @@
+"""Config loader: merge global + project + env into a validated Config.
+
+Precedence (low -> high): defaults < global (~/.reidx/config.json)
+< project (./.reidx/config.json) < environment overrides.
+"""
+from __future__ import annotations
+
+import json
+import os
+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.diagnostics.logger import get_logger
+
+log = get_logger("reidx.config")
+
+GLOBAL_DIR = Path.home() / ".reidx"
+PROJECT_DIR = Path(".reidx")
+CONFIG_FILENAME = "config.json"
+
+
+def _read_json(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as exc:
+        log.warning("failed to read config %s: %s", path, exc)
+        return {}
+
+
+def _env_overrides() -> dict:
+    overrides: dict = {}
+    provider = os.environ.get("REIDX_PROVIDER")
+    if provider:
+        overrides["default_provider"] = provider
+    workspace = os.environ.get("REIDX_WORKSPACE")
+    if workspace:
+        overrides["workspace_root"] = workspace
+    storage = os.environ.get("REIDX_STORAGE")
+    if storage:
+        overrides["storage_root"] = storage
+    mode = os.environ.get("REIDX_PERMISSION_MODE")
+    if mode:
+        overrides.setdefault("policy", {})["default_mode"] = mode
+    log_level = os.environ.get("REIDX_LOG_LEVEL")
+    if log_level:
+        overrides["log_level"] = log_level
+    return overrides
+
+
+def _deep_merge(base: dict, over: dict) -> dict:
+    out = dict(base)
+    for key, value in over.items():
+        if isinstance(value, dict) and isinstance(out.get(key), dict):
+            out[key] = _deep_merge(out[key], value)
+        else:
+            out[key] = value
+    return out
+
+
+class ConfigLoader:
+    """Loads and persists config across global + project scopes."""
+
+    def __init__(self, global_dir: Path = GLOBAL_DIR, project_dir: Path = PROJECT_DIR) -> None:
+        self.global_dir = global_dir
+        self.project_dir = project_dir
+
+    def load(self) -> Config:
+        # Apply the Reidchat settings file's env block (ANTHROPIC_* creds) before
+        # anything reads the environment, so the provider routes through Reidchat.
+        apply_settings_env()
+        data = default_config().model_dump(mode="json")
+        data = _deep_merge(data, _read_json(self.global_dir / CONFIG_FILENAME))
+        data = _deep_merge(data, _read_json(self.project_dir / CONFIG_FILENAME))
+        # Claude-Code-shaped settings.json (`reidx` block) — sits above
+        # .reidx/config.json so the project's baked-in settings file wins
+        # over an older on-disk config; env vars still win over both.
+        data = _deep_merge(data, read_reidx_block())
+        data = _deep_merge(data, _env_overrides())
+
+        cfg = Config.model_validate(data)
+        if cfg.storage_root is None:
+            cfg.storage_root = self.global_dir
+        if cfg.workspace_root is None:
+            cfg.workspace_root = Path.cwd().resolve()
+        return cfg
+
+    def save_global(self, cfg: Config) -> None:
+        self.global_dir.mkdir(parents=True, exist_ok=True)
+        path = self.global_dir / CONFIG_FILENAME
+        path.write_text(
+            cfg.model_dump_json(indent=2, exclude_none=True, mode="json"),
+            encoding="utf-8",
+        )
+
+    def save_project(self, cfg: Config) -> None:
+        self.project_dir.mkdir(parents=True, exist_ok=True)
+        path = self.project_dir / CONFIG_FILENAME
+        path.write_text(
+            cfg.model_dump_json(indent=2, exclude_none=True, mode="json"),
+            encoding="utf-8",
+        )

package/src/reidx/config/models.py

@@ -0,0 +1,49 @@
+"""Config models: provider, policy, and top-level Config schemas.
+
+Pydantic v2 models. `Config` is the merged, validated runtime configuration.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field, SecretStr
+
+from reidx.policy.models import PermissionMode
+
+
+class ProviderConfig(BaseModel):
+    name: str
+    # Which client to build (anthropic/openai/openai-compatible/ollama). Empty
+    # means "same as name" — fine for the built-in kinds whose name matches.
+    kind: str = ""
+    base_url: str | None = None
+    api_key: SecretStr | None = None
+    default_model: str = ""
+
+
+class PolicyConfig(BaseModel):
+    default_mode: PermissionMode = PermissionMode.BALANCED
+    allowed_commands: list[str] = Field(default_factory=list)
+    blocked_commands: list[str] = Field(default_factory=list)
+    additional_writable_roots: list[Path] = Field(default_factory=list)
+    read_only_paths: list[Path] = Field(default_factory=list)
+    shell_timeout_seconds: int = 30
+
+
+class Config(BaseModel):
+    providers: dict[str, ProviderConfig] = Field(default_factory=dict)
+    default_provider: str = "stub"
+    policy: PolicyConfig = Field(default_factory=PolicyConfig)
+    workspace_root: Path | None = None
+    storage_root: Path | None = None  # defaults to ~/.reidx when loaded
+    log_level: str = "INFO"
+
+
+def default_config() -> Config:
+    """Baseline config with a stub provider so the runtime is exercisable without API keys."""
+    return Config(
+        providers={
+            "stub": ProviderConfig(name="stub", default_model="stub-v0"),
+        },
+        default_provider="stub",
+    )