arborescent 0.2.0__tar.gz

arborescent-0.2.0/LICENSE

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

arborescent-0.2.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: arborescent
+Version: 0.2.0
+Summary: One architecture policy that generates import-linter, tach and type-checker configs, then enforces more.
+Author: Brian Powers
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/112345brian/arborescent
+Project-URL: Repository, https://github.com/112345brian/arborescent
+Project-URL: Changelog, https://github.com/112345brian/arborescent/blob/main/CHANGELOG.md
+Keywords: architecture,import-linter,tach,pyright,clean-architecture,lint
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: importlinter
+Requires-Dist: import-linter>=2.0; extra == "importlinter"
+Provides-Extra: tach
+Requires-Dist: tach>=0.30; extra == "tach"
+Provides-Extra: pyright
+Requires-Dist: pyright>=1.1.400; extra == "pyright"
+Provides-Extra: ruff
+Requires-Dist: ruff>=0.16.3; extra == "ruff"
+Provides-Extra: basedpyright
+Requires-Dist: basedpyright>=1.30; extra == "basedpyright"
+Provides-Extra: ty
+Requires-Dist: ty>=0.0.50; extra == "ty"
+Provides-Extra: pyrefly
+Requires-Dist: pyrefly>=0.40; extra == "pyrefly"
+Provides-Extra: all
+Requires-Dist: import-linter>=2.0; extra == "all"
+Requires-Dist: tach>=0.30; extra == "all"
+Requires-Dist: pyright>=1.1.400; extra == "all"
+Requires-Dist: ruff>=0.16.3; extra == "all"
+Requires-Dist: ty>=0.0.50; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: import-linter>=2.0; extra == "dev"
+Requires-Dist: tach>=0.30; extra == "dev"
+Requires-Dist: pyright>=1.1.400; extra == "dev"
+Requires-Dist: ruff>=0.16.3; extra == "dev"
+Requires-Dist: basedpyright>=1.30; extra == "dev"
+Requires-Dist: ty>=0.0.50; extra == "dev"
+Requires-Dist: pyrefly>=0.40; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+# Arborescent
+
+One architecture policy. It enforces architecture rules itself and runs [import-linter](https://import-linter.readthedocs.io),
+[tach](https://docs.gauge.sh), [Ruff](https://docs.astral.sh/ruff/) and a type checker ([ty](https://github.com/astral-sh/ty) by default, with pyright and basedpyright
+or [pyrefly](https://pyrefly.org)) using their native project configuration. `arborescent generate` can scaffold optional preset files and never overwrites an existing file.
+Arborescent also enforces: every module must be classified, each ring
+has an allow-list of external packages, OS branching is limited to named rings, lazy imports count, entry scripts must
+declare what the code imports, and a set of repository-hygiene practices that each come from a bug that really happened.
+
+Arborescent's core has no runtime dependencies; the engines are optional extras run as subprocesses.
+
+Install the checks you use with the package, or install every engine for development:
+
+```sh
+python -m pip install '.[all]'
+python -m pip install '.[dev]'  # tests and all checker adapters
+```
+
+Ruff is included in `all` and `dev`, and is also available as the `ruff` extra. Ty is the default type checker; list
+`type_checkers = ["ty", "pyright"]` to keep both configs generated and use `--type-checker pyright` when needed.
+
+## Quickstart
+
+```toml
+# pyproject.toml
+[tool.arborescent]
+sources = ["src/app"]
+source_roots = ["src"]
+rings = ["domain", "ports", "adapters", "composition"]      # innermost first
+type_checkers = ["ty", "pyright"]                          # first is the default; --type-checker pyright selects strict Pyright
+
+[tool.arborescent.groups]
+pure = ["__future__", "dataclasses", "typing"]
+
+[tool.arborescent.ring.domain]
+external = ["@pure"]
+[tool.arborescent.ring.ports]
+may_import = ["domain"]
+external = ["@pure"]
+[tool.arborescent.ring.adapters]
+may_import = ["domain", "ports"]
+external = ["@pure", "os", "psutil"]
+os_branching = true                                         # only these rings may read os.name / sys.platform
+[tool.arborescent.ring.composition]
+may_import = ["*"]
+external = ["@pure", "sys"]
+
+[tool.arborescent.classify]                                    # first matching glob wins; every module needs one
+"app" = "domain"
+"app.domain" = "domain"
+"app.ports" = "ports"
+"app.adapters" = "adapters"
+"app.main" = "composition"
+```
+
+```
+arborescent generate     # optionally create missing recommended config files; existing files stay untouched
+arborescent check        # engines in parallel, own checks, baseline ratchet; generated-preset drift is advisory
+arborescent check --install-tools # prompt to install missing tools, then run the checks
+arborescent install-tools # prompt to install missing tools without running checks
+arborescent check --install-tools --yes # install without prompting, then check
+arborescent check --require-tools --require-profile  # require profile v1 and its verified tool versions/rules
+arborescent check --changed origin/main      # only files changed since a git ref
+arborescent discover     # list Python files that still need ring classification
+arborescent baseline     # record existing violations; future checks fail on new findings
+arborescent selftest     # mutation-test native rules and fail if a rule stops firing
+arborescent bench DIR…   # cold/warm timings of every engine on prepared codebases
+```
+
+Documentation: [CLI commands, configuration and rules](docs/configuration.md) and
+[Arborescent's own architecture](docs/architecture.md).
+
+`check` never installs packages unless you pass `--install-tools`. By default, missing selected tools produce an exact
+install command and the usual skip/fail behavior. `check --install-tools` prints the command, prompts with No as the
+default, installs on confirmation, then runs checks; `--yes` skips the prompt. `arborescent install-tools` uses the same
+setup flow without running checks. Installation targets the active Python environment (or uv targeting that
+interpreter when pip is unavailable). In Poetry projects it uses `poetry add` to place checkers in an `arborescent` group
+included by `dev`, then verifies the lock. Set `disabled_tools = ["import-linter", "tach", "ruff"]` in
+`[tool.arborescent]` (or the top-level `arborescent.toml`) to deliberately omit those tools from checks and setup hints;
+minimum-profile certification still requires Ruff and Tach.
+
+## Presets
+
+`preset = "strict"` is the default. A preset only changes how much of the external-import and OS rules applies; ring
+layering, classification (every module needs a ring) and lazy-import detection are the same in all of them.
+
+| preset | imports that need a ring `external` entry | OS branching limited to named rings |
+|---|---|---|
+| `strict` (default) | every external import, stdlib included | yes |
+| `standard` | third-party packages and the I/O stdlib set; other stdlib is free | yes |
+| `relaxed` | third-party packages only | no |
+
+The I/O stdlib set (`os`, `subprocess`, `socket`, `sqlite3`, `pathlib`, ...: see `arborescent.presets.IO_MODULES`) also drives
+the generated import-linter bans. Replace it per project with `io_modules = ["os", "subprocess", ...]` (an empty list means
+no stdlib module counts as I/O).
+
+## Ports
+
+- `ToolRunner` (`available`, `run`) -- how engines and git are executed; `arborescent.testing.FakeToolRunner` fakes it.
+- `TypeChecker` (`render_config`, `command`, `passed`) -- pyright, basedpyright, ty and pyrefly adapters in
+  `arborescent.typecheckers`. Every strict-mode setting was verified by running the tool (see the module docstring).
+- `FileSystem` -- every file read, write, listing, copy and temporary folder the use cases need; `LocalFileSystem` is the
+  real one and `arborescent.testing.FakeFileSystem` an in-memory twin (both run the same contract tests).
+- `ModuleScanner` -- finds modules and parses each file once; `FsScanner` adds a content-hash cache.
+
+## What the policy compiles to
+
+| engine | optional generated preset | what it cannot say (Arborescent's own check says it) |
+|---|---|---|
+| import-linter | one `forbidden` contract per ring for the rings it may not import, one per ring banning I/O stdlib and declared third-party packages the ring does not list, one global `forbid_everywhere` | an external allow-list (it only has deny-lists); single-file entry scripts (not packages) |
+| tach | `layers` (outermost first), one `[[modules]]` per module; `layers_explicit_depends_on` + per-module `depends_on` when a ring skips an inner ring | tach's circular-dependency check is switched off in that mode; Arborescent independently enforces circular-import checks across all first-party modules |
+| Ruff | recommended `ruff.toml`; violations join the baseline, and suppression comments are ignored | ring-dependent effects (Arborescent's native rules) |
+| pyright / basedpyright / ty / pyrefly | strict config, `# type: ignore` ignored, `match` exhaustiveness, no Unknown | -- |
+
+## Practices (`[tool.arborescent.practices]`)
+
+`gitignore-shadow` (an unanchored `local_voice/` ignored a real package: empty wheel), `sibling-versions` (a meta-package
+pinned `==0.1.1` while the component was `0.2.0`), `secrets-guard` (tests need an autouse conftest fixture that scrubs
+the environment), `docs-sync` (the architecture doc's `| module | ring |` table must equal the policy), `crlf`
+(scripts with CRLF), `undeclared-imports` (third-party import absent from the manifest). Each has a reproduction test in
+`tests/test_practices.py` that builds the broken repository in a temp directory.
+
+## Speed
+
+Engines run concurrently; Arborescent parses each file once (AST), caches facts by content hash in `.arborescent/`, and
+`--changed` limits Arborescent, Ruff, and the type checker to changed files. import-linter, `tach check`, and `tach check-external`
+are graph-wide, so Arborescent skips them and reports that reason in the engine results. See the repository CHANGELOG for measured numbers; `arborescent bench` reproduces them.
+
+## Limits (honest)
+
+Effect checks detect direct imports, aliases and attribute chains. They intentionally do not catch calls routed through
+`getattr`, variables or wrapper functions. `module_forbid_imports` can add finer-grained internal-import restrictions
+for selected modules without changing their ring. CI is configured for Windows, macOS and Linux; the account's
+GitHub billing block has prevented hosted runs so far.

arborescent-0.2.0/README.md

@@ -0,0 +1,134 @@
+# Arborescent
+
+One architecture policy. It enforces architecture rules itself and runs [import-linter](https://import-linter.readthedocs.io),
+[tach](https://docs.gauge.sh), [Ruff](https://docs.astral.sh/ruff/) and a type checker ([ty](https://github.com/astral-sh/ty) by default, with pyright and basedpyright
+or [pyrefly](https://pyrefly.org)) using their native project configuration. `arborescent generate` can scaffold optional preset files and never overwrites an existing file.
+Arborescent also enforces: every module must be classified, each ring
+has an allow-list of external packages, OS branching is limited to named rings, lazy imports count, entry scripts must
+declare what the code imports, and a set of repository-hygiene practices that each come from a bug that really happened.
+
+Arborescent's core has no runtime dependencies; the engines are optional extras run as subprocesses.
+
+Install the checks you use with the package, or install every engine for development:
+
+```sh
+python -m pip install '.[all]'
+python -m pip install '.[dev]'  # tests and all checker adapters
+```
+
+Ruff is included in `all` and `dev`, and is also available as the `ruff` extra. Ty is the default type checker; list
+`type_checkers = ["ty", "pyright"]` to keep both configs generated and use `--type-checker pyright` when needed.
+
+## Quickstart
+
+```toml
+# pyproject.toml
+[tool.arborescent]
+sources = ["src/app"]
+source_roots = ["src"]
+rings = ["domain", "ports", "adapters", "composition"]      # innermost first
+type_checkers = ["ty", "pyright"]                          # first is the default; --type-checker pyright selects strict Pyright
+
+[tool.arborescent.groups]
+pure = ["__future__", "dataclasses", "typing"]
+
+[tool.arborescent.ring.domain]
+external = ["@pure"]
+[tool.arborescent.ring.ports]
+may_import = ["domain"]
+external = ["@pure"]
+[tool.arborescent.ring.adapters]
+may_import = ["domain", "ports"]
+external = ["@pure", "os", "psutil"]
+os_branching = true                                         # only these rings may read os.name / sys.platform
+[tool.arborescent.ring.composition]
+may_import = ["*"]
+external = ["@pure", "sys"]
+
+[tool.arborescent.classify]                                    # first matching glob wins; every module needs one
+"app" = "domain"
+"app.domain" = "domain"
+"app.ports" = "ports"
+"app.adapters" = "adapters"
+"app.main" = "composition"
+```
+
+```
+arborescent generate     # optionally create missing recommended config files; existing files stay untouched
+arborescent check        # engines in parallel, own checks, baseline ratchet; generated-preset drift is advisory
+arborescent check --install-tools # prompt to install missing tools, then run the checks
+arborescent install-tools # prompt to install missing tools without running checks
+arborescent check --install-tools --yes # install without prompting, then check
+arborescent check --require-tools --require-profile  # require profile v1 and its verified tool versions/rules
+arborescent check --changed origin/main      # only files changed since a git ref
+arborescent discover     # list Python files that still need ring classification
+arborescent baseline     # record existing violations; future checks fail on new findings
+arborescent selftest     # mutation-test native rules and fail if a rule stops firing
+arborescent bench DIR…   # cold/warm timings of every engine on prepared codebases
+```
+
+Documentation: [CLI commands, configuration and rules](docs/configuration.md) and
+[Arborescent's own architecture](docs/architecture.md).
+
+`check` never installs packages unless you pass `--install-tools`. By default, missing selected tools produce an exact
+install command and the usual skip/fail behavior. `check --install-tools` prints the command, prompts with No as the
+default, installs on confirmation, then runs checks; `--yes` skips the prompt. `arborescent install-tools` uses the same
+setup flow without running checks. Installation targets the active Python environment (or uv targeting that
+interpreter when pip is unavailable). In Poetry projects it uses `poetry add` to place checkers in an `arborescent` group
+included by `dev`, then verifies the lock. Set `disabled_tools = ["import-linter", "tach", "ruff"]` in
+`[tool.arborescent]` (or the top-level `arborescent.toml`) to deliberately omit those tools from checks and setup hints;
+minimum-profile certification still requires Ruff and Tach.
+
+## Presets
+
+`preset = "strict"` is the default. A preset only changes how much of the external-import and OS rules applies; ring
+layering, classification (every module needs a ring) and lazy-import detection are the same in all of them.
+
+| preset | imports that need a ring `external` entry | OS branching limited to named rings |
+|---|---|---|
+| `strict` (default) | every external import, stdlib included | yes |
+| `standard` | third-party packages and the I/O stdlib set; other stdlib is free | yes |
+| `relaxed` | third-party packages only | no |
+
+The I/O stdlib set (`os`, `subprocess`, `socket`, `sqlite3`, `pathlib`, ...: see `arborescent.presets.IO_MODULES`) also drives
+the generated import-linter bans. Replace it per project with `io_modules = ["os", "subprocess", ...]` (an empty list means
+no stdlib module counts as I/O).
+
+## Ports
+
+- `ToolRunner` (`available`, `run`) -- how engines and git are executed; `arborescent.testing.FakeToolRunner` fakes it.
+- `TypeChecker` (`render_config`, `command`, `passed`) -- pyright, basedpyright, ty and pyrefly adapters in
+  `arborescent.typecheckers`. Every strict-mode setting was verified by running the tool (see the module docstring).
+- `FileSystem` -- every file read, write, listing, copy and temporary folder the use cases need; `LocalFileSystem` is the
+  real one and `arborescent.testing.FakeFileSystem` an in-memory twin (both run the same contract tests).
+- `ModuleScanner` -- finds modules and parses each file once; `FsScanner` adds a content-hash cache.
+
+## What the policy compiles to
+
+| engine | optional generated preset | what it cannot say (Arborescent's own check says it) |
+|---|---|---|
+| import-linter | one `forbidden` contract per ring for the rings it may not import, one per ring banning I/O stdlib and declared third-party packages the ring does not list, one global `forbid_everywhere` | an external allow-list (it only has deny-lists); single-file entry scripts (not packages) |
+| tach | `layers` (outermost first), one `[[modules]]` per module; `layers_explicit_depends_on` + per-module `depends_on` when a ring skips an inner ring | tach's circular-dependency check is switched off in that mode; Arborescent independently enforces circular-import checks across all first-party modules |
+| Ruff | recommended `ruff.toml`; violations join the baseline, and suppression comments are ignored | ring-dependent effects (Arborescent's native rules) |
+| pyright / basedpyright / ty / pyrefly | strict config, `# type: ignore` ignored, `match` exhaustiveness, no Unknown | -- |
+
+## Practices (`[tool.arborescent.practices]`)
+
+`gitignore-shadow` (an unanchored `local_voice/` ignored a real package: empty wheel), `sibling-versions` (a meta-package
+pinned `==0.1.1` while the component was `0.2.0`), `secrets-guard` (tests need an autouse conftest fixture that scrubs
+the environment), `docs-sync` (the architecture doc's `| module | ring |` table must equal the policy), `crlf`
+(scripts with CRLF), `undeclared-imports` (third-party import absent from the manifest). Each has a reproduction test in
+`tests/test_practices.py` that builds the broken repository in a temp directory.
+
+## Speed
+
+Engines run concurrently; Arborescent parses each file once (AST), caches facts by content hash in `.arborescent/`, and
+`--changed` limits Arborescent, Ruff, and the type checker to changed files. import-linter, `tach check`, and `tach check-external`
+are graph-wide, so Arborescent skips them and reports that reason in the engine results. See the repository CHANGELOG for measured numbers; `arborescent bench` reproduces them.
+
+## Limits (honest)
+
+Effect checks detect direct imports, aliases and attribute chains. They intentionally do not catch calls routed through
+`getattr`, variables or wrapper functions. `module_forbid_imports` can add finer-grained internal-import restrictions
+for selected modules without changing their ring. CI is configured for Windows, macOS and Linux; the account's
+GitHub billing block has prevented hosted runs so far.

arborescent-0.2.0/pyproject.toml

@@ -0,0 +1,161 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "arborescent"
+version = "0.2.0"
+description = "One architecture policy that generates import-linter, tach and type-checker configs, then enforces more."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Brian Powers" }]
+keywords = ["architecture", "import-linter", "tach", "pyright", "clean-architecture", "lint"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Quality Assurance",
+    "Typing :: Typed",
+]
+dependencies = []
+
+# The engines are extras: Arborescent runs them as subprocesses and skips (or, with --require-tools, fails) when absent.
+[project.optional-dependencies]
+importlinter = ["import-linter>=2.0"]
+tach = ["tach>=0.30"]
+pyright = ["pyright>=1.1.400"]
+ruff = ["ruff>=0.16.3"]
+basedpyright = ["basedpyright>=1.30"]
+ty = ["ty>=0.0.50"]
+pyrefly = ["pyrefly>=0.40"]
+all = ["import-linter>=2.0", "tach>=0.30", "pyright>=1.1.400", "ruff>=0.16.3", "ty>=0.0.50"]
+dev = ["pytest>=8", "import-linter>=2.0", "tach>=0.30", "pyright>=1.1.400", "ruff>=0.16.3", "basedpyright>=1.30", "ty>=0.0.50", "pyrefly>=0.40", "build"]
+
+[project.urls]
+Homepage = "https://github.com/112345brian/arborescent"
+Repository = "https://github.com/112345brian/arborescent"
+Changelog = "https://github.com/112345brian/arborescent/blob/main/CHANGELOG.md"
+
+[project.scripts]
+arborescent = "arborescent.cli:main"
+
+[tool.setuptools]
+packages = ["arborescent"]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.package-data]
+arborescent = ["py.typed"]
+
+# Arborescent's own architecture, checked by Arborescent (`arborescent check` in this folder).
+[tool.arborescent]
+python = "3.11"
+sources = ["src/arborescent"]
+source_roots = ["src"]
+exclude = ["__pycache__", "tests", "tools"]
+forbid_circular_imports = true
+rings = ["domain", "ports", "application", "adapters", "composition"]
+type_checkers = ["ty", "pyright"]
+
+[tool.arborescent.groups]
+pure = ["__future__", "collections", "dataclasses", "enum", "fnmatch", "re", "typing", "ast", "sys", "tomllib", "io", "tokenize", "posixpath", "json"]
+
+[tool.arborescent.ring.domain]
+external = ["@pure", "arborescent"]
+
+[tool.arborescent.ring.ports]
+may_import = ["domain"]
+external = ["@pure", "pathlib", "contextlib", "arborescent"]
+
+[tool.arborescent.ring.application]
+may_import = ["domain", "ports"]
+# pathlib: Path values only (join, relative_to); every disk access goes through FileSystem (tests/test_filesystem.py)
+external = ["@pure", "pathlib", "concurrent", "arborescent"]
+# The application coordinates parallel engines; all other effect categories keep the strict default.
+forbid = ["clock", "dynamic-import", "env", "identity", "patch", "process", "randomness", "sleep"]
+
+[tool.arborescent.ring.adapters]
+may_import = ["domain", "ports"]
+external = ["@pure", "pathlib", "contextlib", "json", "hashlib", "os", "shutil", "subprocess", "tempfile", "time", "sysconfig", "tomllib", "arborescent"]
+os_branching = true
+forbid = ["clock", "dynamic-import", "env", "identity", "patch", "randomness", "sleep", "threads"]
+
+[tool.arborescent.ring.composition]
+may_import = ["*"]
+external = ["@pure", "argparse", "pathlib", "os", "shlex", "arborescent"]
+
+[tool.arborescent.classify]
+"arborescent" = "domain"
+"arborescent.domain" = "domain"
+"arborescent.facts" = "domain"
+"arborescent.rules" = "domain"
+"arborescent.presets" = "domain"
+"arborescent.stdlib" = "domain"
+"arborescent.ports" = "ports"
+"arborescent.generate" = "application"
+"arborescent.baseline" = "application"
+"arborescent.config" = "application"
+"arborescent.engine" = "application"
+"arborescent.certification" = "application"
+"arborescent.install_tools" = "application"
+"arborescent.practices" = "application"
+"arborescent.selftest" = "application"
+"arborescent.suggestions" = "application"
+"arborescent.bench" = "application"
+"arborescent.adapters" = "adapters"
+"arborescent.installer_adapter" = "adapters"
+"arborescent.clock_adapter" = "adapters"
+"arborescent.filesystem_adapter" = "adapters"
+"arborescent.scanner" = "adapters"
+"arborescent.tool_runner" = "adapters"
+"arborescent.typecheckers" = "adapters"
+"arborescent.engines" = "adapters"
+"arborescent.testing" = "adapters"
+"arborescent.cli" = "composition"
+"arborescent.cli_install" = "composition"
+"arborescent.cli_report" = "composition"
+"arborescent.__main__" = "composition"
+
+[tool.arborescent.practices]
+crlf = ["*.sh", "*.bash"]
+undeclared-imports = true
+secrets-guard = "tests"
+docs-sync = "docs/architecture.md"
+
+[tool.arborescent.ruff]
+# The subprocess adapter deliberately owns process execution and passes argument vectors with shell disabled.
+
+[tool.arborescent.ruff.per-file-ignores]
+"src/arborescent/tool_runner.py" = ["S404", "S603"]
+"src/arborescent/cli_install.py" = ["T20"]
+"src/arborescent/cli_report.py" = ["T20"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "tests"]
+addopts = "-q"
+
+# Contract that lived in the launch-runner root pyproject: the core and the ports stay free of process/file/network modules.
+# (`lint-imports` reads this table; the generated arborescent-importlinter.toml is checked by `arborescent check`.)
+[tool.importlinter]
+root_packages = ["arborescent"]
+include_external_packages = true
+
+[[tool.importlinter.contracts]]
+name = "arborescent core and ports must not import adapters, the engines or process/file/network modules"
+type = "forbidden"
+source_modules = ["arborescent.domain", "arborescent.facts", "arborescent.presets", "arborescent.stdlib", "arborescent.rules", "arborescent.ports"]
+forbidden_modules = [
+    "arborescent.adapters", "arborescent.tool_runner", "arborescent.typecheckers", "arborescent.engines", "arborescent.engine", "arborescent.cli", "subprocess", "shutil", "tempfile",
+    "socket", "urllib",
+]
+allow_indirect_imports = true
+
+[tool.ruff.lint]
+# PIE807 asks for container factories, but Pyright strict reports the field type as
+# partially unknown; explicit lambdas keep its inferred type fully concrete.
+extend-ignore = ["PIE807"]

arborescent-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

arborescent-0.2.0/src/arborescent/__init__.py

@@ -0,0 +1,13 @@
+"""Arborescent: one architecture policy that compiles to import-linter, tach and a type checker, and enforces more.
+
+- ``domain`` / ``facts`` / ``rules`` -- the policy, one-pass AST facts, and the pure checks (no I/O).
+- ``ports`` -- ``ToolRunner``, ``TypeChecker``, ``ModuleScanner``.
+- ``generate`` / ``engine`` / ``baseline`` / ``selftest`` / ``practices`` / ``bench`` -- the use cases.
+- ``adapters`` / ``typecheckers`` -- subprocesses, the file system + content-hash cache, pyright/basedpyright/ty/pyrefly.
+- ``testing`` -- fakes. ``cli`` -- the composition root.
+"""
+
+from .domain import Policy, PolicyError, Violation
+
+__all__ = ["Policy", "PolicyError", "Violation"]
+__version__ = "0.1.0"

arborescent-0.2.0/src/arborescent/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

arborescent-0.2.0/src/arborescent/adapters.py

@@ -0,0 +1,11 @@
+"""Compatibility exports for Arborescent's runtime adapters.
+
+New code should import adapters from their responsibility-specific modules.
+"""
+
+from .clock_adapter import SystemClock
+from .filesystem_adapter import LocalFileSystem
+from .scanner import FsScanner, ScanData
+from .tool_runner import SubprocessToolRunner, resolve_executable
+
+__all__ = ["FsScanner", "LocalFileSystem", "ScanData", "SubprocessToolRunner", "SystemClock", "resolve_executable"]