forgex-cli 0.1.0__py3-none-any.whl

forgex/tools/verification.py

@@ -0,0 +1,174 @@
+"""Deterministic verification harness (spec sections 11, 56)."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from forgex.orchestration.events import EventRecorder
+from forgex.project import detect_project
+from forgex.sandbox.executor import CommandExecutor
+from forgex.schemas.error import CommandDeniedError
+from forgex.schemas.event import EventType
+from forgex.schemas.result import (
+    BuildResults,
+    CommandOutcome,
+    TestResults,
+    VerificationOutcome,
+)
+from forgex.tools.testing import detect_test_command
+
+
+def detect_build_command(root: Path) -> list[str] | None:
+    det = detect_project(root)
+    langs = det.languages
+
+    if (root / "package.json").is_file():
+        try:
+            data = json.loads((root / "package.json").read_text(encoding="utf-8"))
+            if (data.get("scripts") or {}).get("build"):
+                return ["npm", "run", "build"]
+        except (OSError, json.JSONDecodeError):
+            pass
+
+    if "Rust" in langs or (root / "Cargo.toml").is_file():
+        return ["cargo", "build"]
+
+    if "Go" in langs or (root / "go.mod").is_file():
+        return ["go", "build", "./..."]
+
+    if "Python" in langs:
+        src_dir = root / "src"
+        if src_dir.is_dir():
+            return ["python", "-m", "compileall", "-q", "src"]
+        if list(root.glob("*.py")):
+            return ["python", "-m", "compileall", "-q", "."]
+
+    return None
+
+
+def detect_lint_command(root: Path) -> list[str] | None:
+    pyproject = root / "pyproject.toml"
+    if pyproject.is_file():
+        try:
+            content = pyproject.read_text(encoding="utf-8", errors="replace")
+            if "[tool.ruff]" in content:
+                return ["python", "-m", "ruff", "check", "."]
+        except OSError:
+            pass
+
+    pkg = root / "package.json"
+    if pkg.is_file():
+        try:
+            data = json.loads(pkg.read_text(encoding="utf-8"))
+            if (data.get("scripts") or {}).get("lint"):
+                return ["npm", "run", "lint"]
+        except (OSError, json.JSONDecodeError):
+            pass
+
+    return None
+
+
+def parse_pytest_summary(output: str) -> tuple[int | None, int | None, int | None]:
+    """Parse passed, failed, errors counts from pytest output summary."""
+    passed = None
+    failed = None
+    errors = None
+
+    p_match = re.search(r"(\d+)\s+passed", output)
+    if p_match:
+        passed = int(p_match.group(1))
+
+    f_match = re.search(r"(\d+)\s+failed", output)
+    if f_match:
+        failed = int(f_match.group(1))
+
+    e_match = re.search(r"(\d+)\s+error", output)
+    if e_match:
+        errors = int(e_match.group(1))
+
+    if passed is not None and failed is None:
+        failed = 0
+    if failed is not None and passed is None:
+        passed = 0
+
+    return passed, failed, errors
+
+
+async def _step(command: list[str], executor: CommandExecutor) -> CommandOutcome:
+    try:
+        res = await executor.run(command, cwd=".")
+        tail = (res.stdout + "\n" + res.stderr)[-4000:].strip()
+        return CommandOutcome(
+            command=command,
+            exit_code=res.exit_code,
+            timed_out=res.timed_out,
+            duration_ms=round(res.duration_ms, 1),
+            output_tail=tail,
+        )
+    except CommandDeniedError as exc:
+        return CommandOutcome(
+            command=command,
+            exit_code=None,
+            timed_out=False,
+            output_tail=f"not run (command denied by policy: {exc})",
+        )
+
+
+async def run_verification(
+    root: Path,
+    executor: CommandExecutor,
+    events: EventRecorder | None = None,
+    run_id: str | None = None,
+    include_build: bool = True,
+    include_lint: bool = True,
+) -> VerificationOutcome:
+    outcome = VerificationOutcome()
+
+    test_cmd = detect_test_command(root)
+    if test_cmd:
+        if events is not None:
+            events.record(EventType.TEST_STARTED, {"command": test_cmd}, run_id=run_id)
+        base = await _step(test_cmd, executor)
+        passed, failed, errors = parse_pytest_summary(base.output_tail)
+        outcome.tests = TestResults(
+            command=base.command,
+            exit_code=base.exit_code,
+            timed_out=base.timed_out,
+            duration_ms=base.duration_ms,
+            output_tail=base.output_tail,
+            passed=passed,
+            failed=failed,
+            errors=errors,
+        )
+        if events is not None:
+            events.record(
+                EventType.TEST_COMPLETED,
+                {
+                    "exit_code": base.exit_code,
+                    "passed": passed,
+                    "failed": failed,
+                    "timed_out": base.timed_out,
+                },
+                run_id=run_id,
+            )
+
+    if include_build:
+        build_cmd = detect_build_command(root)
+        if build_cmd:
+            base_build = await _step(build_cmd, executor)
+            outcome.build = BuildResults(
+                command=base_build.command,
+                exit_code=base_build.exit_code,
+                timed_out=base_build.timed_out,
+                duration_ms=base_build.duration_ms,
+                output_tail=base_build.output_tail,
+            )
+
+    if include_lint:
+        lint_cmd = detect_lint_command(root)
+        if lint_cmd:
+            outcome.lint = await _step(lint_cmd, executor)
+
+    return outcome

forgex/utils/__init__.py

@@ -0,0 +1,15 @@
+"""Shared utilities."""
+
+from forgex.utils.logging import configure_logging
+from forgex.utils.paths import PathViolationError, find_project_root, resolve_in_workspace
+from forgex.utils.redact import MASK, redact, redact_patterns
+
+__all__ = [
+    "MASK",
+    "PathViolationError",
+    "configure_logging",
+    "find_project_root",
+    "redact",
+    "redact_patterns",
+    "resolve_in_workspace",
+]

forgex/utils/logging.py

@@ -0,0 +1,28 @@
+"""Internal logging for FORGEX.
+
+Diagnostics go to stderr so stdout stays clean for --json and piped
+output. Human-facing rendering lives in :mod:`forgex.cli.ui`.
+"""
+
+from __future__ import annotations
+
+import logging
+
+_LEVELS = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+}
+
+
+def configure_logging(level: str = "warning") -> None:
+    """Configure the root ``forgex`` logger with a stderr handler."""
+    logger = logging.getLogger("forgex")
+    handler = logging.StreamHandler()
+    handler.setFormatter(
+        logging.Formatter("%(asctime)s %(levelname)-7s %(name)s: %(message)s", "%H:%M:%S")
+    )
+    logger.handlers.clear()
+    logger.addHandler(handler)
+    logger.setLevel(_LEVELS.get(level.lower(), logging.WARNING))

forgex/utils/paths.py

@@ -0,0 +1,48 @@
+"""Workspace-safe path resolution.
+
+Every filesystem operation performed by FORGEX tools must obtain its
+target path through :func:`resolve_in_workspace`. This is a core security
+boundary: agents must never touch paths outside the authorized workspace.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from forgex.schemas.error import PathViolationError
+
+FORGEX_DIR_NAME = ".forgex"
+
+__all__ = ["PathViolationError", "find_project_root", "resolve_in_workspace"]
+
+
+def resolve_in_workspace(workspace: str | Path, target: str | Path) -> Path:
+    """Resolve *target* inside *workspace* and refuse any escape.
+
+    Rules enforced:
+      * Relative targets are joined to the workspace.
+      * Absolute targets must already be inside the workspace.
+      * ``..`` traversal that would leave the workspace is rejected.
+      * Symlinks are resolved; links pointing outside the workspace are
+        rejected (containment is checked on the final real path).
+      * The workspace root itself is allowed (needed for listing).
+    """
+    workspace = Path(workspace).resolve()
+    candidate = Path(target)
+
+    resolved = candidate.resolve() if candidate.is_absolute() else (workspace / candidate).resolve()
+
+    if resolved != workspace and workspace not in resolved.parents:
+        msg = f"path escapes workspace: {target!r} -> {resolved}"
+        raise PathViolationError(msg)
+
+    return resolved
+
+
+def find_project_root(start: str | Path | None = None) -> Path | None:
+    """Walk upward from *start* (default: cwd) looking for a .forgex directory."""
+    current = (Path(start) if start else Path.cwd()).resolve()
+    for candidate in (current, *current.parents):
+        if (candidate / FORGEX_DIR_NAME).is_dir():
+            return candidate
+    return None

forgex/utils/redact.py

@@ -0,0 +1,44 @@
+"""Secret redaction (spec sections 46, 75).
+
+Secrets must never leak into logs, events, errors, or the database. Any
+code formatting external text passes through redact() or redact_patterns()
+with known secrets.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+
+MASK = "***REDACTED***"
+
+_SECRET_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"gsk_[A-Za-z0-9]{20,}"),
+    re.compile(r"sk-[A-Za-z0-9_-]{20,}"),
+    re.compile(r"AKIA[0-9A-Z]{16}"),
+    re.compile(r"ghp_[A-Za-z0-9]{30,}"),
+    re.compile(r"github_pat_[A-Za-z0-9_]{20,}"),
+    re.compile(r"glpat-[A-Za-z0-9_-]{20,}"),
+    re.compile(r"xox[baprs]-[A-Za-z0-9-]{10,}"),
+    re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----"),
+    re.compile(
+        r"(?i)\b(api[_-]?key|secret|token|password|passwd)\b['\"]?\s*[:=]\s*['\"][^'\"\n]{8,}['\"]"
+    ),
+)
+
+
+def redact(text: str, secrets: Iterable[str | None]) -> str:
+    """Replace every occurrence of each secret with the mask."""
+    result = text
+    for secret in secrets:
+        if secret and len(secret) >= 4:
+            result = result.replace(secret, MASK)
+    return result
+
+
+def redact_patterns(text: str) -> str:
+    """Scrub secret-looking content before it enters model context (§46).
+    Applied at every content-on-ramp: read_file, search, prefetch, context."""
+    for pattern in _SECRET_PATTERNS:
+        text = pattern.sub(MASK, text)
+    return text

forgex_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.5
+Name: forgex-cli
+Version: 0.1.0
+Summary: FORGEX — multi-agent AI software engineering. Plan. Build. Refine. Verify.
+Project-URL: Homepage, https://github.com/B-max12/Forgex
+Project-URL: Repository, https://github.com/B-max12/Forgex
+Project-URL: Issues, https://github.com/B-max12/Forgex/issues
+Project-URL: Changelog, https://github.com/B-max12/Forgex/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/B-max12/Forgex/tree/main/docs
+Author: FORGEX Contributors
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,automation,cli,groq,llm,openai,software-engineering
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.12
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: pydantic>=2.7
+Requires-Dist: rich>=13.7
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.2; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# FORGEX
+
+**Plan. Build. Refine. Verify.**
+
+FORGEX is a CLI-first autonomous AI software engineering system. Specialized
+agents — **Architect**, **Builder**, **Expert Coder**, **Supervisor** —
+collaborate on a real repository through permission-gated tools, Git
+checkpoints, a deterministic verification harness, and a bounded self-healing
+repair loop.
+
+> FORGEX is not a chatbot and not a code generator: it is an AI software
+> engineering *runtime* — with the safety rails that implies.
+
+```
+request → Architect → research → plan → [ Builder → Expert Coder →
+tests → Supervisor → PASS? done : repair ↺ ] (bounded by max_iterations)
+```
+
+**Status: v0.1.0 alpha** — the full pipeline works end-to-end with any
+OpenAI-compatible provider (Groq, OpenAI, local servers). Multi-model
+ensemble review, Docker sandboxing, and a context-intelligence layer are
+built in.
+
+## Installation
+
+### One-Line Install (Zero Environment Activation)
+
+```bash
+curl -sSL https://raw.githubusercontent.com/B-max12/Forgex/main/install.sh | bash
+```
+*(Or clone and run `./install.sh`)*
+
+### Via `pipx` or `uv tool`
+
+```bash
+pipx install forgex-cli          # once published to PyPI
+# or directly from GitHub:
+pipx install "git+https://github.com/B-max12/Forgex.git"
+```
+
+### From source (Developers):
+
+```bash
+git clone https://github.com/B-max12/Forgex.git && cd Forgex
+pip install -e ".[dev]"
+```
+
+Python 3.12+. Optional: Git (checkpoints — strongly recommended),
+Docker (sandboxing), ripgrep (faster search).
+
+## Quickstart
+
+### The Universal Way (Zero Learning Curve)
+
+Simply run `forgex` and describe what you want in plain English:
+
+```bash
+forgex
+```
+
+```text
+forgex ❯ Build me a FastAPI Todo API with SQLite and pytest
+```
+
+FORGEX handles the complete lifecycle automatically:
+1. **Auto-initializes** the project workspace and git repository if needed
+2. **Plans** architecture and task breakdown (Architect agent)
+3. **Implements** code and tests across tasks (Builder + Expert Coder)
+4. **Verifies** deterministically (tests, lint, typecheck)
+5. **Self-heals** and auto-repairs if any verification gates fail
+6. **Snapshots** a clean, reversible Git checkpoint on success!
+
+Follow up naturally with conversational context:
+```text
+forgex ❯ now add rate limiting to those endpoints
+forgex ❯ fix the failing tests in users.py
+```
+
+### One-Shot CLI / CI/CD Mode
+
+Run tasks directly from your shell without opening the REPL:
+
+```bash
+forgex "Create a FastAPI Todo API with SQLite and pytest"
+# Or:
+forgex do "Add JWT authentication with refresh tokens"
+```
+
+### Granular Power User Commands
+
+For granular manual control, individual pipeline stages remain available:
+
+```bash
+forgex plan "Add caching layer"     # run architect planning only
+forgex build                         # execute existing plan tasks
+forgex verify                        # run tests and lint deterministically
+forgex fix                           # verify + repair loop without replanning
+forgex checkpoint "Stable release"   # snapshot Git state
+forgex rollback                      # undo to previous checkpoint
+```
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `forgex init [DIR]` | initialize a project (state, events, SQLite index) |
+| `forgex plan [REQUEST] [--dry-run]` | Architect: analysis → registry research → implementation plan |
+| `forgex build [REQUEST] [--file F] [--resume] [--dry-run]` | full pipeline with the repair loop |
+| `forgex fix` | verify + supervise + repair until green — no rebuild |
+| `forgex run [-- CMD]` | run the project's start command (policy-gated) |
+| `forgex task list / run ID` | inspect / execute single tasks (Builder + review) |
+| `forgex review [TASK] [--base C]` | Expert Coder review — single model or ensemble |
+| `forgex verify` | deterministic tests/build/lint — no LLM |
+| `forgex supervise` | verification + LLM audit + quality gates → verdict |
+| `forgex status / logs / diff` | project state, event stream, git diff |
+| `forgex checkpoint / rollback` | Git checkpoints; reversible rollback |
+| `forgex models [catalog\|health]` | bindings, capability catalog, live provider ping |
+| `forgex context stats\|search` | context index and relevance retrieval |
+| `forgex tools list\|run` | inspect / manually run agent tools |
+| `forgex config show\|get\|set\|setup` | layered configuration |
+| `forgex doctor [--ping]` | environment and provider health |
+
+Every command supports `--json` and `--plain` (CI/SSH friendly).
+
+## Providers
+
+| Type | Target | Notes |
+|---|---|---|
+| `groq` | Groq API | default binding: llama-3.3-70b-versatile |
+| `openai_compatible` | OpenAI & any compatible endpoint | set base_url |
+| `local` | Ollama, llama.cpp, vLLM, LM Studio | base_url required, keyless |
+
+Provider-independent by design: per-agent model bindings, capability-aware
+routing, retry with backoff, fallback chains, and multi-model ensemble
+review (`[ensemble] enabled = true` — e.g. Groq + OpenAI reviewing the same
+diff in parallel, findings corroborated before fixes are applied).
+
+## Security
+
+- Agents act only through permission-gated tools; every path is workspace-confined; `.forgex/`, `.git/` and secret files are untouchable.
+- Commands are argv-only (no shells), policy-filtered (deny list, optional allowlist, network approval), and — with `[sandbox] enabled = true` — run in hardened Docker containers (no network by default, host FS invisible).
+- Secrets never enter prompts: env-only storage, sanitized child environments, pattern-based content scrubbing.
+- Deterministic quality gates: no model verdict can pass a red test suite or an incomplete build.
+
+Full model + residual risks: `docs/security.md`.
+
+## License
+
+MIT

forgex_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,115 @@
+forgex/__init__.py,sha256=8Hu38mXfDi41oplmNAMNnTJlGm1gGGFBsqjIUItWP-Y,69
+forgex/__main__.py,sha256=epF6ct9aMmoavj1WUyibBInERIleJKLpCyySZp2SCd8,104
+forgex/project.py,sha256=6xRu_lEhlIqcCypeGBOQeTwnR46JlFW_FuTrllrRNos,7620
+forgex/agents/__init__.py,sha256=VGgsL4k6C2g3H6Dj3ZHFIDJe1jhwzJxyVNFjC-jwXKM,1021
+forgex/agents/architect.py,sha256=m7pzK4mGRdZS1j_EK7sFSXWGbdhULizFgSoScScHk7E,8249
+forgex/agents/base.py,sha256=1tRtdirmo5U4WUxFKI-wZTqOmTUPKQHgYkK4nvkkkms,15187
+forgex/agents/builder.py,sha256=nZZr3732XNRnx9OTb-Sd6X9Es0zHK7PgEQ0tNFs4Lnc,8854
+forgex/agents/ensemble.py,sha256=2r1f3KU_sWNchwYppyIx77TDTGksZvUlHDCyL2c2uW0,10930
+forgex/agents/expert_coder.py,sha256=aFme4fFDGPN7W5Ylp-domG9TAC5FXObSkgh0JPQRQpA,9149
+forgex/agents/supervisor.py,sha256=7sWMeKIEmQZu8n2ZUkaR7rP8_Rw58F4kGe7JviFVb3Q,10238
+forgex/cli/__init__.py,sha256=C63yWifzpA0IV7YWDatpAdrhoV8zjqxAKv0xMf09VdM,19
+forgex/cli/app.py,sha256=iUVc0oIHqLxhnggUZGecxlTOJ4LcMoq7OfjnayAdS7w,8534
+forgex/cli/build_views.py,sha256=a6REKszTvK5x41wuHRRrwFrQ8VG1RxL7frNNB3jwTEc,3855
+forgex/cli/context_memory.py,sha256=Ql4EjzjnsO6pHDqJ6EIVKxn3F0llvP1xgCGAaBKZ-0g,2170
+forgex/cli/intent.py,sha256=wcXs8WBxIEr5cK8eC-WqomRwtkejgAwBsiLwYvoVdLA,6388
+forgex/cli/progress.py,sha256=c-MbILnDOD2fQWCDTK2goH_fz7dx4nDrmf0M6IC0ocM,3709
+forgex/cli/repl.py,sha256=Xq-9kGHnLA5hnVj93pJfT_5ohcEBrEtmZJcIRbhq4cg,15601
+forgex/cli/runtime.py,sha256=wCaw_lU9EPE-zA1TTyjXTe6WYbnxea9FuY7-5kuAgsk,7980
+forgex/cli/session.py,sha256=Bs0Cu8le20JN0hhXLuBPPR_8L5Ev1chAJQlykqQqe-A,3335
+forgex/cli/ui.py,sha256=fKf7SyA-h6WE7Dz-AxZCMFEhPNAaVAWodYRGXbtwhWo,3196
+forgex/cli/commands/__init__.py,sha256=gQ6tnU0Rvm0-ESWFUBU-KDl5dpNOpUTG509hXOQQjwY,27
+forgex/cli/commands/build.py,sha256=a5GgzFWnRnXRY06XAJbCCyyNlCRToONpxHnBowF-93U,2600
+forgex/cli/commands/checkpoint.py,sha256=h8-nmQqtl1n3LzBVpuxE2QH-fTv80piTIuUy6v_pIIc,1528
+forgex/cli/commands/config.py,sha256=g4cftES94Gxk6WzgiyyMEOr7jmgUVdHBPljp1ThU3wQ,8788
+forgex/cli/commands/context.py,sha256=LMnR8y26LkyoFct7-h5AYIVF4DQZzk6oPt9Wjcuxxww,3532
+forgex/cli/commands/diff.py,sha256=eS0RX5DZFS1ywT9LxxaP-B9ESrCouMrjWYeE-q3Bid4,1019
+forgex/cli/commands/do_cmd.py,sha256=1fvmuRXKpFJYXOan3BFaHGD_-ZEB3Si7yhdwJKUP08w,1923
+forgex/cli/commands/doctor.py,sha256=PkzrfOFvDhAPVvAbryYJeS8-CujEfAirRQO25MhmfRs,5994
+forgex/cli/commands/fix.py,sha256=x0Q9MlNWQX3UWFkx0UI__2GoSjofVUCRMjZqWGsXqsc,1584
+forgex/cli/commands/init.py,sha256=C9sAq_wo-e5npOTidSLO0u-NvzASL-DpGj-IXSN0iuI,1366
+forgex/cli/commands/logs.py,sha256=gPzVb8qoXk2x9bXUGRmiXMXdEujoWUcuM8MSZFmabWA,3568
+forgex/cli/commands/models.py,sha256=6UEZl9mShSHaenSfe8OZCiaslck09DJ0GuGIY6FaORI,5172
+forgex/cli/commands/plan.py,sha256=pC6kKn_nZN8QVVQVF7FYHcnkJyhKzFYRHHyaV8IySPY,3704
+forgex/cli/commands/review.py,sha256=pPy5wK2ajwFeUur7qzjMro4-2qab3RmN0doFoSN3h9A,2690
+forgex/cli/commands/rollback.py,sha256=mVyJ_V_jhdCe1iGPSIYXGnRQ4z8VDVJIZgJzxUSXhbM,2791
+forgex/cli/commands/run.py,sha256=MyNuyyUi-gPiHoztgvdKxjU1kbyRHFoSESJ3qpwaQ7A,2580
+forgex/cli/commands/status.py,sha256=pliHRhCtwNS9U_hEMBqEEynENDGTvsrEvxrmXxLke-M,5484
+forgex/cli/commands/supervise.py,sha256=xUH4DqMybNrH9iA4LA2WX2EfqibWQCvLtMiYewRwvPo,2162
+forgex/cli/commands/task.py,sha256=A83c782eEc6tJ1XhCmX9ybBuLDWACJlW88OPfsn_140,4551
+forgex/cli/commands/tools.py,sha256=QD64A2MvRzFGtyYARV1AWnZ8_k93-QtKphfDbROimbk,4357
+forgex/cli/commands/verify.py,sha256=T3CurElaSVOMhvbxAwzc5RkEuoZGX-VwKDVnm1fOu-s,2355
+forgex/config/__init__.py,sha256=yfn7mP0l54Ndqh2wEDdJahmt_jCpci8zPYB1LLLpY44,1097
+forgex/config/loader.py,sha256=F28e5HSJFEUlJ_cnzuMiNVjMUBktvZ7vrRHjNqaaoEc,6213
+forgex/config/schema.py,sha256=b11natC9BEHwkxBJWZYlrMXgJKzT2TGWdGM81arL4M8,4490
+forgex/context/__init__.py,sha256=tYuaRQihCCL8YQiNkWwFvZIeOZYZTCAQAKfTcu0CrPc,254
+forgex/context/chunker.py,sha256=Jt7OS2I2mtdg2dm7aLBdA_FqREyS23Dwl9s2yTHUNFk,3364
+forgex/context/dependency_graph.py,sha256=cbRab1rFy7seijsMfwLCcLLzBXP0RxYVyR0oS_vF6iU,3957
+forgex/context/indexer.py,sha256=H0lwwMv6_TkRNxN4paqGO5Qjn6DHE40z5jv5WyP19_A,5126
+forgex/context/manager.py,sha256=Bkwd8WrHU2X-WtzGsZupL95bC1ktkhkAMbumHt0jWPw,5695
+forgex/context/retriever.py,sha256=XGbTDGiU6DK0piFeO25tkiDxuMpgSgDrgvFTSNIYIfo,3348
+forgex/models/__init__.py,sha256=ED7YeMCP9jFdoXfspP7zXWjLTX2OZtRy6BcKSzb3UPY,517
+forgex/models/base.py,sha256=QGQrnUwPfIwsOlSOmTvJP_iPj0XsDUS1FML3ugyoFKk,2832
+forgex/models/capabilities.py,sha256=avCWmlZy4nxreKoF8RfBSqIgORQihh1SyCQP0g7SEnw,681
+forgex/models/factory.py,sha256=e-Vd7IHuk8Ga_kvDw3hWgUJ8amtuRnbmKbShvMAdc8k,2322
+forgex/models/groq.py,sha256=HNv5VF_k_3uJQsoJMzL3t5RC5UyoGy3vHVT6RkkbDIE,526
+forgex/models/local.py,sha256=naRfjGVrfpK_urNqnsfZUX8xwicvygiC-ZeANQ_K9sE,390
+forgex/models/openai_compatible.py,sha256=jy_ao19M2Kh9tusr2dv8xWUxUf2QBg3nkm_RKIRXZwA,8747
+forgex/models/registry.py,sha256=KRCdfcI8IvEQ8BIhCReYDneVHulpFkXcnoeWesj-Cgk,2406
+forgex/models/router.py,sha256=fH6Xki4FjvMpFGpG3XK_mrZQZLYTx0a5bgJkCMRDZNc,12735
+forgex/orchestration/__init__.py,sha256=-dTdrZXYL2dY3HED18GF2Oyaqt7qleqy610IgbbiStk,1039
+forgex/orchestration/checkpoints.py,sha256=V-beUwx0AS26xSmL1tAuilMpJPbJwA8GnWiwcq3XnBE,3484
+forgex/orchestration/engine.py,sha256=O2i6heSxL8M_0XWecyMBlPOzqY-wW7Lmk2S8ztLT1AQ,21065
+forgex/orchestration/events.py,sha256=6EKqJYfYoInD5yhs9IAp2TGQ9wXulI4RptO42x-IMoI,3075
+forgex/orchestration/lockfile.py,sha256=X_9ADh_dKLPMhUxdzKsG26eaWgD0BnwEq1Cd3n0Xz4g,2597
+forgex/orchestration/retry.py,sha256=OPN8dQd47987ttZ-5mkIsHvBQgtdD8cep8ATgzY9mCU,2141
+forgex/orchestration/state.py,sha256=lO24dJtBWEF8x7eDYpikA5Apl1EWqmBstkl9tVRPgXU,3101
+forgex/orchestration/stores.py,sha256=vURGuGkmrJIyISBHfHx2G--s2apRlHaBvYcyOrIfgws,3212
+forgex/orchestration/workflow.py,sha256=HINieGFQbHzl5pzlkFSut1k4cUu6nNfjrDjdNeTI2IQ,3149
+forgex/prompts/__init__.py,sha256=NuAsFK03L8fgUbHmvVBjp32nU3ZHC9uqbZ3BlLAhZkE,713
+forgex/prompts/architect.md,sha256=0imykrysITgy5W1BimhLqTTkvEXA5XjAixKAKqzBx8Q,1657
+forgex/prompts/builder.md,sha256=1eA-3QMbQwCBjqitsZwcH33CegeGxhj0qC13YJAe7OA,1386
+forgex/prompts/expert_coder.md,sha256=xqPtNj3swKX8F-SUvo-59YLXh-YaO4QwkMFRVw8Kmag,1447
+forgex/prompts/reviewer.md,sha256=ao0Fz5sDYMIB55FwOw_vIN53tW_OiMGdFY4YSxMNlGc,999
+forgex/prompts/supervisor.md,sha256=T_0w2pzcE5K6cmrqV5moDIY5ZTOelq7w7rFYyz2SLec,1729
+forgex/research/__init__.py,sha256=wKx-9Nr-3XcyFIqJjaZOpOubG3CohLnFK1pUGz1sbIc,417
+forgex/research/citations.py,sha256=fd99Xroppx69ZEfX5XKJpHrZvIHZ8PrE8Cg6-_fZHMU,613
+forgex/research/engine.py,sha256=toak42FGXM4VUWb73pk_288FbGx6LQTm_qnZdViJWVc,2794
+forgex/research/sources.py,sha256=8dqfRqcc-UbzaYnwIwmRfKXFBypCuRffk0_2BDkcYJc,4732
+forgex/sandbox/__init__.py,sha256=RMlzPnnuT96vCAAveq9-JyQGFsCdaOEl9xCr-3X8zxI,870
+forgex/sandbox/executor.py,sha256=zwUsu518Zc0QpUGuBsn3Wq8bxmNB7yBbT_eSAoM5UHU,12697
+forgex/sandbox/permissions.py,sha256=7IvHZuqDnbcBoH7ptIAwMY5sQ1v9zEmr0fVpdd0NyoY,1931
+forgex/sandbox/policies.py,sha256=MKhrwbZIBEi0OfELxfh68pG4FM4dov11WZZ_J_MTt5I,4276
+forgex/schemas/__init__.py,sha256=OB-OpLibsph-OmR6mBMBqdDqUSdSx30yVE6C5DYxO-g,2191
+forgex/schemas/agent.py,sha256=0ru2j0PbDuJrjJ5DiO35hQgxkkSNggeutG5rlcll7jU,3387
+forgex/schemas/checkpoint.py,sha256=UrqisYGT24FdOwqa9tDlRN2YoNzp7YxhYXKn-28mCpE,474
+forgex/schemas/error.py,sha256=wdUUnfz-h6fXlGYEJB-AqGGf7s-5YFLegFDo2VYNuK8,2779
+forgex/schemas/event.py,sha256=vrKJX2BNT8H_UkQU-tXvHDHmN5uEk2LyvHX64iR1vhI,2340
+forgex/schemas/plan.py,sha256=W2HFAAg8wyxtqxM8c65-BTnA4Lbp51tIa_PwKjSWv4E,2805
+forgex/schemas/project.py,sha256=tWSFDALJmQ981Qbg9yppElf7JGAeFQqhzV8ea6S6Zos,2941
+forgex/schemas/research.py,sha256=TGtnK6RFkhdl58HLLNYvlwKd2oYI3g-gs6WTvoWa4UE,770
+forgex/schemas/result.py,sha256=6QXoMT9y0av2JOS5YN7Yv1Gk8L_53c9qYRgewrQ1eZs,1985
+forgex/schemas/task.py,sha256=h3f2_QHMq2cyLtUybtd9wXGoZIbygDOSrkaJ85uyoCY,3651
+forgex/storage/__init__.py,sha256=t886ETE2mAmmF2tf4q76ZP74LxV2WfNuOqAgNtJlByI,592
+forgex/storage/database.py,sha256=WrutIrKtb3I80fjOE-OyIlLGXjlbJLCFXY-lF1NYhmg,1249
+forgex/storage/migrations.py,sha256=hu47LK1sBUW8z-Tdj5OtB0QdvgPYoU1sUbRN7dB4K0Y,3961
+forgex/storage/repositories.py,sha256=PsEhRS3tvohrIl0K9TmXigl59ZAG47XL2XbB2chxqOY,18503
+forgex/tools/__init__.py,sha256=grhMS_lbiS2nMLXIDGUdgNK4rIF5qrjlM2yku1PpB7U,1996
+forgex/tools/base.py,sha256=0EjtI3UMrLTfxn5z6lAFPDg5GkPI40FxGj0zJMLttng,6764
+forgex/tools/dependencies.py,sha256=nmqWFGoB2nWc9ic60yIDwnMF4UoU2C9N-nyEAYgVyLU,5180
+forgex/tools/filesystem.py,sha256=rWCZTQo-Raapr48KK1y1_Q3ADAtLKAWKDMv89Fv8rm0,10690
+forgex/tools/git.py,sha256=mXI8AyYbGmhS-bqtXvFOtt2Q0jKp74Jo2NrzR6IPBFM,8169
+forgex/tools/project.py,sha256=HqJeecfxh0Cml3vaxJpyKBox_sFANSHZG26F-3BCVXI,1387
+forgex/tools/search.py,sha256=7HJNVTnACvmT4nqEAZTZ4RJWlgj_AY8mmHRG3rKmRbM,6980
+forgex/tools/terminal.py,sha256=2hiQVchkZLPr_uO8gVIu8F3UY3UsGN7V_EZrnK0OQeo,2921
+forgex/tools/testing.py,sha256=EHPW9IqOHubOkjv0kEwpry3-raTYRj2UogIZUB7cxak,3144
+forgex/tools/verification.py,sha256=HgK5mlrffJuJpIyeRo73tdtClsa3Svn6lzhi6M1ECCs,5352
+forgex/utils/__init__.py,sha256=TMSkuQnwBk254xYtqQvIpJLQlWjcYsaSvgTzPLZfz2M,397
+forgex/utils/logging.py,sha256=vxSKfmQtdyQQcamqesLr1hlCaYP6zX-qPfj3s7vj3yM,801
+forgex/utils/paths.py,sha256=BpGE8gxk4qZll-g6iiMJu_OWM6OFwAFXMuiFQNY3LcU,1777
+forgex/utils/redact.py,sha256=13_AbyPz8wDyB_VPY6C5GFgSvzUesWO2zKgis4gije0,1468
+forgex_cli-0.1.0.dist-info/METADATA,sha256=dtw77XXAx8Zss-33T_O_YiiCw8oaeWSrOI1akxb_6lY,7336
+forgex_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+forgex_cli-0.1.0.dist-info/entry_points.txt,sha256=iQeCcJqidt0rKckzw2pQEmXQkMb_ekLR7u6hloppViI,47
+forgex_cli-0.1.0.dist-info/licenses/LICENSE,sha256=UE8dNWDqILNshGTpijfZLH3rabYi4cEHfdJ3Py3pLiQ,1081
+forgex_cli-0.1.0.dist-info/RECORD,,

forgex_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

forgex_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+forgex = forgex.cli.app:main

forgex_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 FORGEX Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.