reactifact 0.6.0__tar.gz

reactifact-0.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bzdv
+
+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.

reactifact-0.6.0/PKG-INFO

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: reactifact
+Version: 0.6.0
+Summary: Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context
+Project-URL: Homepage, https://github.com/bzdvdn/reactifact
+Project-URL: Repository, https://github.com/bzdvdn/reactifact
+Project-URL: Documentation, https://github.com/bzdvdn/reactifact/tree/master/docs
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: httpx>=0.27
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: dev
+Requires-Dist: ruff>=0.8; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: pytest>=9.1.1; extra == "dev"
+Requires-Dist: pytest-cov>=7.1.0; extra == "dev"
+Provides-Extra: web
+Requires-Dist: fastapi>=0.115; extra == "web"
+Requires-Dist: uvicorn[standard]>=0.30; extra == "web"
+Provides-Extra: pg
+Requires-Dist: psycopg[binary]>=3.2; extra == "pg"
+Dynamic: license-file
+
+# reactifact
+
+**Stop drawing the graph. Build agents as reactions to versioned, provable artifacts.**
+
+[![CI](https://github.com/bzdvdn/reactifact/actions/workflows/ci.yml/badge.svg)](https://github.com/bzdvdn/reactifact/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)](https://github.com/bzdvdn/reactifact)
+[![PyPI version](https://img.shields.io/pypi/v/reactifact)](https://pypi.org/project/reactifact/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Most agent frameworks make you **draw the graph**: connect nodes, wire memory,
+declare control flow. But a knowledge question — *"why did infra costs jump in
+Q2?"* — needs Confluence + GitLab + CSV + calculations + verification, and the
+*next* question needs a different path. There is no universal graph to draw.
+
+reactifact flips the model. You describe **what artifacts exist and what agents can
+do with them**; the runtime derives what runs next from **state changes**. Agents
+react to events — there is no graph, no node pipeline.
+
+```bash
+pip install reactifact
+```
+
+Runs offline, no API key needed — paste this straight into a `.py` file. Two
+agents, no graph edge declared between them — the second reacts because the
+first one's output exists, and the answer carries *proof* of where it came
+from:
+
+```python
+from pydantic import BaseModel
+
+from reactifact import Budget, Consume, Context, Runtime, RuntimeResources, create_agent, produce
+
+
+class Question(BaseModel):
+    text: str
+
+
+class Evidence(BaseModel):
+    text: str
+
+
+class Answer(BaseModel):
+    text: str
+
+
+DOCS = {
+    "refund": "Refunds are available within 14 days of purchase.",
+    "pricing": "The Pro plan is $49/month, billed annually.",
+}
+
+
+@produce(Evidence)
+async def find_evidence(context, inputs, event, effects):
+    question = next((a for a in inputs if isinstance(a.data, Question)), None)
+    if question is None:
+        return None
+    hit = next((v for k, v in DOCS.items() if k in question.data.text.lower()), None)
+    if hit is not None:
+        effects.create(Evidence(text=hit))
+
+
+@produce(Answer)
+async def answer_from_evidence(context, inputs, event, effects):
+    evidence = next((a for a in inputs if isinstance(a.data, Evidence)), None)
+    if evidence is None:
+        return None
+    effects.create(Answer(text=evidence.data.text)).link("supported_by", evidence)
+
+
+search_agent = create_agent("search", consumes=[Consume(Question)], produces=[find_evidence])
+answer_agent = create_agent("answer", consumes=[Consume(Evidence)], produces=[answer_from_evidence])
+
+ctx = Context(resources=RuntimeResources())
+runtime = Runtime(ctx, agents=[search_agent, answer_agent], budget=Budget(max_runs=10))
+
+ctx.create(Question(text="what's your refund policy?"))
+runtime.run()  # search_agent and answer_agent both react — nobody wired them together
+
+answer = ctx.latest(Answer)
+evidence = ctx.related(answer.id, "supported_by")[0]
+print(answer.data.text)                     # "Refunds are available within 14 days of purchase."
+print("supported_by:", evidence.data.text)  # provenance you can trace, not just a string in a log
+```
+
+## How it works
+
+```text
+ARTIFACT CREATED / UPDATED
+       │
+       ▼
+     AGENTS REACT ──self.effects──► Effects ──compile──► Patch
+       ▲                                                      │
+       └──────────────────────────────────────────────────────┘
+                                                        Context v+1
+```
+
+A produce writes what should change (`self.effects.create/update/link/ask`) and
+returns `None`; the runtime compiles the effect set into one **atomic** `Patch`
+and moves the context to the next version. The `event` that wakes an agent is
+*derived* from that same change — the causal chain can never drift from the
+actual state.
+
+## What makes it different
+
+| Traditional agent (LangGraph / CrewAI / LangChain) | reactifact |
+| --- | --- |
+| A program follows a graph / plan | Agents **react** to state changes |
+| Messages are strings | **Typed, versioned artifacts** (`Claim`, `Evidence`, `Answer`) |
+| Orchestration is explicit wiring | Orchestration **falls out of the state** |
+| A unit of work *returns* a change | An agent **writes effects**; the runtime compiles them |
+| Retries/rollback are manual | Context is **git-like versioned** (diff, rollback, branch, merge) |
+| "Who produced this?" is lost | **Provenance** links every derived artifact to its inputs |
+| The model guesses the numbers | **Calculations are calculated** — the LLM is a reasoning component, not the source of truth |
+
+Reactive. Deterministic. Accountable.
+
+Full breakdown, including where reactifact is *not* the right choice:
+[docs/en/comparison.md](docs/en/comparison.md).
+
+## Core primitives
+
+- **Context** — versioned working state, git-like commits, `diff`/`rollback`/`merge`.
+- **Artifact** — a first-class typed object (`Claim`, `Evidence`, `Answer`), not a string blob.
+- **Effects** — an agent states its change via `self.effects.create/update/link/ask`; the runtime compiles it.
+- **Patch** — the compiled, validated change-set applied as one atomic commit.
+- **Agent** — a thin container declaring `consumes`/`produces`; logic lives in a `Produce`.
+- **Source** — retrieval is a capability: vector search is *one* strategy; direct API, keyword, SQL, filesystem are equally first-class.
+- **Provenance** — every derived artifact links to what produced it
+  (`Answer —supported_by→ Claim —derived_from→ Evidence —extracted_from→ Doc`).
+- **HITL** — humans as `effects.ask(...)` → `PendingQuestion`, answered via `effects.resume(...)` like any agent.
+
+## In the box
+
+- **Deterministic by design** — calculations over structured data, honest `None`
+  fallbacks instead of hallucinated answers; the model reasons, never "knows".
+- **Observability** — every run traces agent spans, reads/writes, LLM calls,
+  tokens: SQLite store + web dashboard, exportable to Langfuse/Postgres (async sinks).
+- **Budgets & replanning** — cap by runs/time/iterations/tool-calls, replan on decline.
+- **Branching & replay** — `context.branch()`, three-way `merge()`, deterministic
+  `ReplayLLM`, all for audit and safe alternative states.
+- **Sessions** — `SessionStore` over `FileKVBackend`/`SQLiteKVBackend`
+  (and `PostgreSQLKVBackend`) for durable chat memory.
+- **Web layer** — `ChatAssistant` + `create_chat_router` mount a canonical SSE
+  chat on *your* FastAPI app; errors degrade to a logged fallback, never a 500.
+- **Recipes** — `find`/`find_all` (typed lookup in `inputs`), `fan_out_sources`,
+  `materialize_doc`, `StatusMachine`, `WindowSummarizer`/`WindowPruner`
+  (bounded conversation memory), change→rebuild rollback helpers,
+  `Skill`/`match_skills` (Claude-Skills-shaped instructions, keyword-triggered)
+  — pure and LLM-free, except the summarizer, which takes your callback.
+- **Viz & CLI** — Mermaid `blueprint`/`context_to_mermaid`/`trace_to_mermaid`;
+  `reactifact` with `graph`/`context`/`trace`/`replay`/`branch`.
+
+## Run a demo
+
+Offline-capable, no API keys required (deterministic fallbacks):
+
+```bash
+uv run python ./examples/llm_ladder/level1.py  # the simplest LLM turn (offline too)
+uv run python ./examples/repair/web.py         # room renovation: plan, estimate, CSV export
+uv run python ./examples/devops/web.py         # HITL ops assistant + trace dashboard
+```
+
+Classic-pattern ports run as one-liners too:
+`python -m examples.{reflection,map_reduce,supervisor,summarize,time_travel,adaptive,ledger}.main`.
+
+## Examples (in-repo, not shipped)
+
+- `knowledge` — multi-source chat: search → evidence → claim verification → answer, with CSV calculation.
+- `research` — goes to the web (`WebSource`): lazy page fetch → evidence → verified claims → answer with URL provenance.
+- `medic-lab` — hypothesis laboratory: competing hypotheses scored, HITL steering, honest report.
+- `devops` — HITL tool agents + LLM tool router + trace dashboard.
+- `repair` — budget-aware replanning (chat/data in Russian by design).
+- `forklab` — deterministic branch & merge: two strategies on their own forks, three-way merge.
+- `ledger` — offline proof of reactive recompute: edit one fact, only its real `Consume`rs re-run.
+- `llm_ladder` — the workflow from one LLM call to state-changing patches (3 levels).
+- `adaptive` — hybrid scheduler: rule filters + deterministic rank + LLM tie-break + `rank_limit`.
+- `{reflection,map_reduce,supervisor,summarize,time_travel}` — canonical ports (see [port-matrix](docs/en/port-matrix.md)).
+
+## Documentation
+
+- [English](docs/en/index.md) · [Русский](docs/ru/index.md) — concepts, sources,
+  providers, recipes, patterns, observability, eval, branching, replay, viz/CLI, API.
+- [Quickstart](docs/en/quickstart.md) — three runnable snippets: tool-calling
+  agent, retrieval over your docs, session-persisted chat bot.
+- [Why reactifact](docs/en/why-reactifact.md) — the *design argument*: why effects, why no graph, why determinism.
+- [Comparison](docs/en/comparison.md) — reactifact vs LangGraph/CrewAI, feature by feature, and when *not* to use reactifact.
+- [Tutorial · llm-ladder](docs/en/examples.md#tutorial-ladder) — learn the workflow.
+- [docs/constitution.md](docs/constitution.md) — the full design rationale and invariants.
+
+## Development
+
+```bash
+uv sync --extra dev --extra web
+.venv/bin/python -m pytest
+.venv/bin/mypy
+.venv/bin/ruff check
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

reactifact-0.6.0/README.md

@@ -0,0 +1,201 @@
+# reactifact
+
+**Stop drawing the graph. Build agents as reactions to versioned, provable artifacts.**
+
+[![CI](https://github.com/bzdvdn/reactifact/actions/workflows/ci.yml/badge.svg)](https://github.com/bzdvdn/reactifact/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)](https://github.com/bzdvdn/reactifact)
+[![PyPI version](https://img.shields.io/pypi/v/reactifact)](https://pypi.org/project/reactifact/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Most agent frameworks make you **draw the graph**: connect nodes, wire memory,
+declare control flow. But a knowledge question — *"why did infra costs jump in
+Q2?"* — needs Confluence + GitLab + CSV + calculations + verification, and the
+*next* question needs a different path. There is no universal graph to draw.
+
+reactifact flips the model. You describe **what artifacts exist and what agents can
+do with them**; the runtime derives what runs next from **state changes**. Agents
+react to events — there is no graph, no node pipeline.
+
+```bash
+pip install reactifact
+```
+
+Runs offline, no API key needed — paste this straight into a `.py` file. Two
+agents, no graph edge declared between them — the second reacts because the
+first one's output exists, and the answer carries *proof* of where it came
+from:
+
+```python
+from pydantic import BaseModel
+
+from reactifact import Budget, Consume, Context, Runtime, RuntimeResources, create_agent, produce
+
+
+class Question(BaseModel):
+    text: str
+
+
+class Evidence(BaseModel):
+    text: str
+
+
+class Answer(BaseModel):
+    text: str
+
+
+DOCS = {
+    "refund": "Refunds are available within 14 days of purchase.",
+    "pricing": "The Pro plan is $49/month, billed annually.",
+}
+
+
+@produce(Evidence)
+async def find_evidence(context, inputs, event, effects):
+    question = next((a for a in inputs if isinstance(a.data, Question)), None)
+    if question is None:
+        return None
+    hit = next((v for k, v in DOCS.items() if k in question.data.text.lower()), None)
+    if hit is not None:
+        effects.create(Evidence(text=hit))
+
+
+@produce(Answer)
+async def answer_from_evidence(context, inputs, event, effects):
+    evidence = next((a for a in inputs if isinstance(a.data, Evidence)), None)
+    if evidence is None:
+        return None
+    effects.create(Answer(text=evidence.data.text)).link("supported_by", evidence)
+
+
+search_agent = create_agent("search", consumes=[Consume(Question)], produces=[find_evidence])
+answer_agent = create_agent("answer", consumes=[Consume(Evidence)], produces=[answer_from_evidence])
+
+ctx = Context(resources=RuntimeResources())
+runtime = Runtime(ctx, agents=[search_agent, answer_agent], budget=Budget(max_runs=10))
+
+ctx.create(Question(text="what's your refund policy?"))
+runtime.run()  # search_agent and answer_agent both react — nobody wired them together
+
+answer = ctx.latest(Answer)
+evidence = ctx.related(answer.id, "supported_by")[0]
+print(answer.data.text)                     # "Refunds are available within 14 days of purchase."
+print("supported_by:", evidence.data.text)  # provenance you can trace, not just a string in a log
+```
+
+## How it works
+
+```text
+ARTIFACT CREATED / UPDATED
+       │
+       ▼
+     AGENTS REACT ──self.effects──► Effects ──compile──► Patch
+       ▲                                                      │
+       └──────────────────────────────────────────────────────┘
+                                                        Context v+1
+```
+
+A produce writes what should change (`self.effects.create/update/link/ask`) and
+returns `None`; the runtime compiles the effect set into one **atomic** `Patch`
+and moves the context to the next version. The `event` that wakes an agent is
+*derived* from that same change — the causal chain can never drift from the
+actual state.
+
+## What makes it different
+
+| Traditional agent (LangGraph / CrewAI / LangChain) | reactifact |
+| --- | --- |
+| A program follows a graph / plan | Agents **react** to state changes |
+| Messages are strings | **Typed, versioned artifacts** (`Claim`, `Evidence`, `Answer`) |
+| Orchestration is explicit wiring | Orchestration **falls out of the state** |
+| A unit of work *returns* a change | An agent **writes effects**; the runtime compiles them |
+| Retries/rollback are manual | Context is **git-like versioned** (diff, rollback, branch, merge) |
+| "Who produced this?" is lost | **Provenance** links every derived artifact to its inputs |
+| The model guesses the numbers | **Calculations are calculated** — the LLM is a reasoning component, not the source of truth |
+
+Reactive. Deterministic. Accountable.
+
+Full breakdown, including where reactifact is *not* the right choice:
+[docs/en/comparison.md](docs/en/comparison.md).
+
+## Core primitives
+
+- **Context** — versioned working state, git-like commits, `diff`/`rollback`/`merge`.
+- **Artifact** — a first-class typed object (`Claim`, `Evidence`, `Answer`), not a string blob.
+- **Effects** — an agent states its change via `self.effects.create/update/link/ask`; the runtime compiles it.
+- **Patch** — the compiled, validated change-set applied as one atomic commit.
+- **Agent** — a thin container declaring `consumes`/`produces`; logic lives in a `Produce`.
+- **Source** — retrieval is a capability: vector search is *one* strategy; direct API, keyword, SQL, filesystem are equally first-class.
+- **Provenance** — every derived artifact links to what produced it
+  (`Answer —supported_by→ Claim —derived_from→ Evidence —extracted_from→ Doc`).
+- **HITL** — humans as `effects.ask(...)` → `PendingQuestion`, answered via `effects.resume(...)` like any agent.
+
+## In the box
+
+- **Deterministic by design** — calculations over structured data, honest `None`
+  fallbacks instead of hallucinated answers; the model reasons, never "knows".
+- **Observability** — every run traces agent spans, reads/writes, LLM calls,
+  tokens: SQLite store + web dashboard, exportable to Langfuse/Postgres (async sinks).
+- **Budgets & replanning** — cap by runs/time/iterations/tool-calls, replan on decline.
+- **Branching & replay** — `context.branch()`, three-way `merge()`, deterministic
+  `ReplayLLM`, all for audit and safe alternative states.
+- **Sessions** — `SessionStore` over `FileKVBackend`/`SQLiteKVBackend`
+  (and `PostgreSQLKVBackend`) for durable chat memory.
+- **Web layer** — `ChatAssistant` + `create_chat_router` mount a canonical SSE
+  chat on *your* FastAPI app; errors degrade to a logged fallback, never a 500.
+- **Recipes** — `find`/`find_all` (typed lookup in `inputs`), `fan_out_sources`,
+  `materialize_doc`, `StatusMachine`, `WindowSummarizer`/`WindowPruner`
+  (bounded conversation memory), change→rebuild rollback helpers,
+  `Skill`/`match_skills` (Claude-Skills-shaped instructions, keyword-triggered)
+  — pure and LLM-free, except the summarizer, which takes your callback.
+- **Viz & CLI** — Mermaid `blueprint`/`context_to_mermaid`/`trace_to_mermaid`;
+  `reactifact` with `graph`/`context`/`trace`/`replay`/`branch`.
+
+## Run a demo
+
+Offline-capable, no API keys required (deterministic fallbacks):
+
+```bash
+uv run python ./examples/llm_ladder/level1.py  # the simplest LLM turn (offline too)
+uv run python ./examples/repair/web.py         # room renovation: plan, estimate, CSV export
+uv run python ./examples/devops/web.py         # HITL ops assistant + trace dashboard
+```
+
+Classic-pattern ports run as one-liners too:
+`python -m examples.{reflection,map_reduce,supervisor,summarize,time_travel,adaptive,ledger}.main`.
+
+## Examples (in-repo, not shipped)
+
+- `knowledge` — multi-source chat: search → evidence → claim verification → answer, with CSV calculation.
+- `research` — goes to the web (`WebSource`): lazy page fetch → evidence → verified claims → answer with URL provenance.
+- `medic-lab` — hypothesis laboratory: competing hypotheses scored, HITL steering, honest report.
+- `devops` — HITL tool agents + LLM tool router + trace dashboard.
+- `repair` — budget-aware replanning (chat/data in Russian by design).
+- `forklab` — deterministic branch & merge: two strategies on their own forks, three-way merge.
+- `ledger` — offline proof of reactive recompute: edit one fact, only its real `Consume`rs re-run.
+- `llm_ladder` — the workflow from one LLM call to state-changing patches (3 levels).
+- `adaptive` — hybrid scheduler: rule filters + deterministic rank + LLM tie-break + `rank_limit`.
+- `{reflection,map_reduce,supervisor,summarize,time_travel}` — canonical ports (see [port-matrix](docs/en/port-matrix.md)).
+
+## Documentation
+
+- [English](docs/en/index.md) · [Русский](docs/ru/index.md) — concepts, sources,
+  providers, recipes, patterns, observability, eval, branching, replay, viz/CLI, API.
+- [Quickstart](docs/en/quickstart.md) — three runnable snippets: tool-calling
+  agent, retrieval over your docs, session-persisted chat bot.
+- [Why reactifact](docs/en/why-reactifact.md) — the *design argument*: why effects, why no graph, why determinism.
+- [Comparison](docs/en/comparison.md) — reactifact vs LangGraph/CrewAI, feature by feature, and when *not* to use reactifact.
+- [Tutorial · llm-ladder](docs/en/examples.md#tutorial-ladder) — learn the workflow.
+- [docs/constitution.md](docs/constitution.md) — the full design rationale and invariants.
+
+## Development
+
+```bash
+uv sync --extra dev --extra web
+.venv/bin/python -m pytest
+.venv/bin/mypy
+.venv/bin/ruff check
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

reactifact-0.6.0/pyproject.toml

@@ -0,0 +1,107 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reactifact"
+version = "0.6.0"
+description = "Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "pydantic>=2.13.4",
+    "httpx>=0.27",
+    "python-dotenv>=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/bzdvdn/reactifact"
+Repository = "https://github.com/bzdvdn/reactifact"
+Documentation = "https://github.com/bzdvdn/reactifact/tree/master/docs"
+
+[project.optional-dependencies]
+dev = [
+    "ruff>=0.8",
+    "mypy>=1.11",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+]
+web = [
+    "fastapi>=0.115",
+    "uvicorn[standard]>=0.30",
+]
+pg = [
+    "psycopg[binary]>=3.2",
+]
+
+# uv-native groups mirror the extras so `uv run`/`uv sync` installs the web demo
+# deps by default (no `--extra` flag needed to boot the examples). Extras stay
+# for PyPI (`pip install reactifact[web]`).
+[dependency-groups]
+dev = [
+    "ruff>=0.8",
+    "mypy>=1.11",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+]
+web = [
+    "fastapi>=0.115",
+    "uvicorn[standard]>=0.30",
+]
+pg = [
+    "psycopg[binary]>=3.2",
+]
+
+[tool.uv]
+default-groups = ["dev", "web"]
+
+# Публикация: в wheel едет только пакет `reactifact`; examples/tests остаются
+# в репозитории для демо и разработки, но не попадают в дистрибутив.
+[project.scripts]
+reactifact = "reactifact.__main__:main"
+
+[tool.setuptools]
+packages = { find = { where = ["."], include = ["reactifact*"], exclude = ["examples*", "tests*"] } }
+
+[tool.setuptools.package-data]
+reactifact = ["py.typed"]
+"reactifact.tracing" = ["templates/*.html"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 88
+src = ["reactifact", "examples"]
+
+[tool.ruff.lint]
+select = [
+    "E",  # pycodestyle errors
+    "F",  # pyflakes
+    "I",  # isort
+    "B",  # bugbear
+    "UP", # pyupgrade
+    "SIM",# simplify
+]
+ignore = [
+    "E501", # line length handled by formatter; long prompts allowed
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+# entry-скрипты: bootstrap sys.path перед импортом пакета src
+"web.py" = ["E402"]
+"repair/chat.py" = ["E402"]
+"assistant_chat.py" = ["E402"]
+"run_example.py" = ["E402"] # пакет-реэксорт: импорты — публичный API
+
+[tool.ruff.format]
+# Документы (docs/constitution.md и пр.) не трогаем форматером
+exclude = ["*.md"]
+
+[tool.mypy]
+python_version = "3.11"
+packages = ["reactifact", "examples"]
+strict = true
+warn_unused_ignores = true

reactifact-0.6.0/reactifact/__init__.py

@@ -0,0 +1,96 @@
+"""reactifact's core public API.
+
+Deliberately small: the primitives from the README's "Core primitives"
+section, plus the everyday building blocks (tool calling, sessions, the LLM
+provider protocol) most agents need regardless of what else they use.
+
+Everything else — eval, tracing, checkpoint/branch backends beyond the
+in-memory default, the chat/web layer, the adaptive scheduler, replay,
+structured-LLM helpers, viz, prompts — is one level down, in its own
+submodule (`reactifact.eval`, `reactifact.tracing`, `reactifact.chat`, ...). Import it
+from there:
+
+    from reactifact.structured import structured_llm
+    from reactifact.tracing import TraceStore
+    from reactifact.chat import ChatAssistant
+
+This keeps `dir(reactifact)` / editor autocomplete to what you need to build a
+first agent, and keeps optional-dependency features (Postgres, FastAPI) out
+of the names you see by default even though they were always cheap to import
+(the driver itself is still lazily imported inside the class, see
+`reactifact._extras`).
+"""
+
+from .agents import Agent, create_agent
+from .artifacts import Artifact
+from .branching import MergeConflict
+from .budget import Budget, RunOutcome, RunStats
+from .consume import Consume, consume
+from .context import Context, View
+from .effects import Effects, Handle
+from .events import Event, EventType
+from .interrupt import PendingQuestion
+from .patches import Create, Delete, Link, Patch, Relation, Unlink, Update
+from .produce import Produce, produce
+from .providers import (
+    EmbeddingProvider,
+    FakeEmbedder,
+    FakeLLM,
+    LLMProvider,
+    LLMRequest,
+    LLMResponse,
+    LLMResponseChunk,
+    Message,
+)
+from .resources import RuntimeResources
+from .runtime import Runtime
+from .session import Session, SessionStore
+from .tools import FunctionTool, Tool, ToolOutput, tool
+from .triggers import Trigger
+
+__version__ = "0.6.0"
+
+__all__ = [
+    "Agent",
+    "Artifact",
+    "Budget",
+    "Consume",
+    "Context",
+    "Create",
+    "Delete",
+    "EmbeddingProvider",
+    "Effects",
+    "Event",
+    "EventType",
+    "FakeEmbedder",
+    "FakeLLM",
+    "FunctionTool",
+    "Handle",
+    "Link",
+    "Message",
+    "MergeConflict",
+    "Patch",
+    "PendingQuestion",
+    "Produce",
+    "Relation",
+    "RunOutcome",
+    "RunStats",
+    "Runtime",
+    "RuntimeResources",
+    "LLMProvider",
+    "LLMRequest",
+    "LLMResponse",
+    "LLMResponseChunk",
+    "Session",
+    "SessionStore",
+    "Tool",
+    "ToolOutput",
+    "Trigger",
+    "Unlink",
+    "Update",
+    "View",
+    "consume",
+    "create_agent",
+    "produce",
+    "tool",
+]

reactifact-0.6.0/reactifact/__main__.py

@@ -0,0 +1,10 @@
+"""Console-script / `python -m reactifact` entry point — see `reactifact.cli`."""
+
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())