turma 0.1.2__tar.gz

turma-0.1.2/LICENSE

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

turma-0.1.2/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: turma
+Version: 0.1.2
+Summary: Provider-pool-aware multi-agent coding orchestration.
+Author: Turma contributors
+License: MIT
+Project-URL: Homepage, https://turma.sh
+Project-URL: Repository, https://github.com/turma-dev/turma
+Project-URL: Documentation, https://turma.sh
+Project-URL: Issues, https://github.com/turma-dev/turma/issues
+Keywords: ai,agents,cli,coding,orchestration,python
+Classifier: Development Status :: 3 - Alpha
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Turma
+
+Provider-pool-aware multi-agent coding orchestration with spec-driven planning,
+Beads task tracking, and resumable swarm execution.
+
+## Status
+
+Early scaffold. This repo now has the initial Python package layout, corrected
+design docs, baseline CLI entry point, and project configuration. The full
+orchestrator described in the architecture docs is not implemented yet.
+
+## What It Is
+
+Turma is designed as a two-phase workflow:
+
+1. Planning: generate and refine OpenSpec artifacts through an author/critic
+   loop with explicit human approval.
+2. Execution: translate approved tasks into a Beads DAG and route work across
+   multiple agent runtimes while tracking task and integration state.
+
+The main design goal is to treat provider rate-limit pools as a routing input
+without overstating that pool independence alone solves throughput.
+
+## Repository Layout
+
+```text
+.
+├── .agents/                    # role guidance for author / critic / implementer / reviewer
+├── .claude/commands/           # slash commands used in project context
+├── docs/
+│   ├── architecture.md         # detailed system design
+│   └── commercial-roadmap.md   # freemium and hosted-tier roadmap
+├── src/turma/                 # Python package scaffold
+├── tests/                      # initial test scaffold
+├── CHANGELOG.md
+├── LICENSE
+├── README.md
+├── turma.example.toml         # committed config template
+└── pyproject.toml
+```
+
+## CLI Scaffold
+
+Default development workflow:
+
+```bash
+uv sync
+cp turma.example.toml turma.toml
+uv run turma --help
+uv run turma init
+uv run turma plan --feature oauth-auth
+uv run turma run --feature oauth-auth
+uv run turma status
+```
+
+These commands are scaffolds today. They provide the initial package and entry
+point structure that the orchestrator can grow into.
+
+Validation commands:
+
+```bash
+uv run turma --help
+uv run python -m turma --help
+uv run pytest
+```
+
+## Core Docs
+
+- [Architecture](docs/architecture.md)
+- [Commercial roadmap](docs/commercial-roadmap.md)
+- [Changelog](CHANGELOG.md)
+
+## Next Implementation Steps
+
+- wire `turma plan` to the planning graph
+- wire `turma run` to Beads plus worktree orchestration
+- persist reconciliation metadata for resumable task recovery
+- replace placeholder status output with task, PR, and CI state
+
+## License
+
+MIT

turma-0.1.2/README.md

@@ -0,0 +1,82 @@
+# Turma
+
+Provider-pool-aware multi-agent coding orchestration with spec-driven planning,
+Beads task tracking, and resumable swarm execution.
+
+## Status
+
+Early scaffold. This repo now has the initial Python package layout, corrected
+design docs, baseline CLI entry point, and project configuration. The full
+orchestrator described in the architecture docs is not implemented yet.
+
+## What It Is
+
+Turma is designed as a two-phase workflow:
+
+1. Planning: generate and refine OpenSpec artifacts through an author/critic
+   loop with explicit human approval.
+2. Execution: translate approved tasks into a Beads DAG and route work across
+   multiple agent runtimes while tracking task and integration state.
+
+The main design goal is to treat provider rate-limit pools as a routing input
+without overstating that pool independence alone solves throughput.
+
+## Repository Layout
+
+```text
+.
+├── .agents/                    # role guidance for author / critic / implementer / reviewer
+├── .claude/commands/           # slash commands used in project context
+├── docs/
+│   ├── architecture.md         # detailed system design
+│   └── commercial-roadmap.md   # freemium and hosted-tier roadmap
+├── src/turma/                 # Python package scaffold
+├── tests/                      # initial test scaffold
+├── CHANGELOG.md
+├── LICENSE
+├── README.md
+├── turma.example.toml         # committed config template
+└── pyproject.toml
+```
+
+## CLI Scaffold
+
+Default development workflow:
+
+```bash
+uv sync
+cp turma.example.toml turma.toml
+uv run turma --help
+uv run turma init
+uv run turma plan --feature oauth-auth
+uv run turma run --feature oauth-auth
+uv run turma status
+```
+
+These commands are scaffolds today. They provide the initial package and entry
+point structure that the orchestrator can grow into.
+
+Validation commands:
+
+```bash
+uv run turma --help
+uv run python -m turma --help
+uv run pytest
+```
+
+## Core Docs
+
+- [Architecture](docs/architecture.md)
+- [Commercial roadmap](docs/commercial-roadmap.md)
+- [Changelog](CHANGELOG.md)
+
+## Next Implementation Steps
+
+- wire `turma plan` to the planning graph
+- wire `turma run` to Beads plus worktree orchestration
+- persist reconciliation metadata for resumable task recovery
+- replace placeholder status output with task, PR, and CI state
+
+## License
+
+MIT

turma-0.1.2/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "turma"
+version = "0.1.2"
+description = "Provider-pool-aware multi-agent coding orchestration."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [
+  { name = "Turma contributors" }
+]
+keywords = ["ai", "agents", "cli", "coding", "orchestration", "python"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development",
+  "Topic :: Software Development :: Build Tools",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://turma.sh"
+Repository = "https://github.com/turma-dev/turma"
+Documentation = "https://turma.sh"
+Issues = "https://github.com/turma-dev/turma/issues"
+
+[project.scripts]
+turma = "turma.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+]

turma-0.1.2/setup.cfg

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

turma-0.1.2/src/turma/__init__.py

@@ -0,0 +1,5 @@
+"""Turma package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.2"

turma-0.1.2/src/turma/__main__.py

@@ -0,0 +1,6 @@
+from turma.cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

turma-0.1.2/src/turma/cli.py

@@ -0,0 +1,66 @@
+"""CLI entry point for the Turma project."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from turma import __version__
+from turma.planning import run_planning
+from turma.swarm import run_swarm, status_summary
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="turma",
+        description="Provider-pool-aware multi-agent coding orchestration.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    init_parser = subparsers.add_parser("init", help="Initialize local project scaffolding.")
+    init_parser.add_argument(
+        "--path",
+        default=".",
+        help="Project directory to initialize. Defaults to the current directory.",
+    )
+
+    plan_parser = subparsers.add_parser("plan", help="Run the planning workflow scaffold.")
+    plan_parser.add_argument("--feature", required=True, help="Feature name to plan.")
+
+    run_parser = subparsers.add_parser("run", help="Run the implementation swarm scaffold.")
+    run_parser.add_argument("--feature", help="Feature name to run.")
+
+    subparsers.add_parser("status", help="Show current swarm status scaffold.")
+
+    return parser
+
+
+def cmd_init(path: str) -> int:
+    project_path = Path(path).resolve()
+    print(
+        f"Initialization scaffold for {project_path}. "
+        "This repo already contains the baseline layout, config, and docs."
+    )
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "init":
+        return cmd_init(args.path)
+    if args.command == "plan":
+        print(run_planning(args.feature))
+        return 0
+    if args.command == "run":
+        print(run_swarm(args.feature))
+        return 0
+    if args.command == "status":
+        print(status_summary())
+        return 0
+
+    parser.error("unknown command")
+    return 2

turma-0.1.2/src/turma/planning.py

@@ -0,0 +1,10 @@
+"""Planning scaffolding for the Turma CLI."""
+
+
+def run_planning(feature: str) -> str:
+    """Return a placeholder planning message for the requested feature."""
+    return (
+        f"Planning scaffold for feature '{feature}'. "
+        "Connect this command to the LangGraph planning loop in docs/architecture.md."
+    )
+

turma-0.1.2/src/turma/swarm.py

@@ -0,0 +1,20 @@
+"""Implementation swarm scaffolding for the Turma CLI."""
+
+
+def run_swarm(feature: str | None) -> str:
+    """Return a placeholder swarm message for the requested feature."""
+    if feature:
+        return (
+            f"Swarm scaffold for feature '{feature}'. "
+            "Connect this command to the orchestrator described in docs/architecture.md."
+        )
+    return (
+        "Swarm scaffold. Connect this command to the orchestrator described in "
+        "docs/architecture.md."
+    )
+
+
+def status_summary() -> str:
+    """Return a placeholder status message."""
+    return "Status scaffold. Integrate Beads, PR state, and reconciliation metadata."
+

turma-0.1.2/src/turma.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: turma
+Version: 0.1.2
+Summary: Provider-pool-aware multi-agent coding orchestration.
+Author: Turma contributors
+License: MIT
+Project-URL: Homepage, https://turma.sh
+Project-URL: Repository, https://github.com/turma-dev/turma
+Project-URL: Documentation, https://turma.sh
+Project-URL: Issues, https://github.com/turma-dev/turma/issues
+Keywords: ai,agents,cli,coding,orchestration,python
+Classifier: Development Status :: 3 - Alpha
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Turma
+
+Provider-pool-aware multi-agent coding orchestration with spec-driven planning,
+Beads task tracking, and resumable swarm execution.
+
+## Status
+
+Early scaffold. This repo now has the initial Python package layout, corrected
+design docs, baseline CLI entry point, and project configuration. The full
+orchestrator described in the architecture docs is not implemented yet.
+
+## What It Is
+
+Turma is designed as a two-phase workflow:
+
+1. Planning: generate and refine OpenSpec artifacts through an author/critic
+   loop with explicit human approval.
+2. Execution: translate approved tasks into a Beads DAG and route work across
+   multiple agent runtimes while tracking task and integration state.
+
+The main design goal is to treat provider rate-limit pools as a routing input
+without overstating that pool independence alone solves throughput.
+
+## Repository Layout
+
+```text
+.
+├── .agents/                    # role guidance for author / critic / implementer / reviewer
+├── .claude/commands/           # slash commands used in project context
+├── docs/
+│   ├── architecture.md         # detailed system design
+│   └── commercial-roadmap.md   # freemium and hosted-tier roadmap
+├── src/turma/                 # Python package scaffold
+├── tests/                      # initial test scaffold
+├── CHANGELOG.md
+├── LICENSE
+├── README.md
+├── turma.example.toml         # committed config template
+└── pyproject.toml
+```
+
+## CLI Scaffold
+
+Default development workflow:
+
+```bash
+uv sync
+cp turma.example.toml turma.toml
+uv run turma --help
+uv run turma init
+uv run turma plan --feature oauth-auth
+uv run turma run --feature oauth-auth
+uv run turma status
+```
+
+These commands are scaffolds today. They provide the initial package and entry
+point structure that the orchestrator can grow into.
+
+Validation commands:
+
+```bash
+uv run turma --help
+uv run python -m turma --help
+uv run pytest
+```
+
+## Core Docs
+
+- [Architecture](docs/architecture.md)
+- [Commercial roadmap](docs/commercial-roadmap.md)
+- [Changelog](CHANGELOG.md)
+
+## Next Implementation Steps
+
+- wire `turma plan` to the planning graph
+- wire `turma run` to Beads plus worktree orchestration
+- persist reconciliation metadata for resumable task recovery
+- replace placeholder status output with task, PR, and CI state
+
+## License
+
+MIT

turma-0.1.2/src/turma.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/turma/__init__.py
+src/turma/__main__.py
+src/turma/cli.py
+src/turma/planning.py
+src/turma/swarm.py
+src/turma.egg-info/PKG-INFO
+src/turma.egg-info/SOURCES.txt
+src/turma.egg-info/dependency_links.txt
+src/turma.egg-info/entry_points.txt
+src/turma.egg-info/top_level.txt
+tests/test_cli.py

turma-0.1.2/src/turma.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

turma-0.1.2/src/turma.egg-info/entry_points.txt

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

turma-0.1.2/src/turma.egg-info/top_level.txt

@@ -0,0 +1 @@
+turma

turma-0.1.2/tests/test_cli.py

@@ -0,0 +1,6 @@
+from turma.cli import build_parser
+
+
+def test_parser_builds() -> None:
+    parser = build_parser()
+    assert parser.prog == "turma"