devcrew 0.1.0__tar.gz

devcrew-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+.env
+__pycache__/
+*.pyc
+output/
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/

devcrew-0.1.0/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project are documented here.
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project uses
+[Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-21
+
+### Added
+- Installable package with a `devcrew` command (`pip install -e .`).
+- `--output-dir` and `--model` options, plus `--version`.
+- Unit tests that check pipeline wiring and validate `sample_output/` against the schemas,
+  without calling an LLM.
+- CI on Python 3.10–3.13 (lint, tests, package build) and a PyPI release workflow.
+- MIT license, contributing guide, security policy, issue and PR templates.
+
+### Changed
+- Schemas now constrain QA verdicts, review severities, review verdicts and 1–10 scores, so
+  malformed agent output is rejected instead of passed downstream.
+
+### Fixed
+- `--output-dir` refuses absolute paths and `..`. CrewAI only writes to relative paths and would
+  otherwise silently turn `/tmp/out` into `./tmp/out`.
+
+## 0.0.1 - 2026-08-18
+
+- First version: Project Manager → Developer → QA Tester → Code Reviewer pipeline on CrewAI.
+
+[Unreleased]: https://github.com/agrvasu05/DevCrew/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/agrvasu05/DevCrew/releases/tag/v0.1.0

devcrew-0.1.0/LICENSE

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

devcrew-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.5
+Name: devcrew
+Version: 0.1.0
+Summary: An AI software team in a pipeline: four agents plan, code, test and review a project from a one-line idea.
+Project-URL: Homepage, https://github.com/agrvasu05/DevCrew
+Project-URL: Issues, https://github.com/agrvasu05/DevCrew/issues
+Project-URL: Changelog, https://github.com/agrvasu05/DevCrew/blob/main/CHANGELOG.md
+Author: Vasu Agrawal
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,code-generation,code-review,crewai,llm,multi-agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: <3.14,>=3.10
+Requires-Dist: crewai>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# DevCrew — Multi-Agent AI Orchestration System
+
+[![CI](https://github.com/agrvasu05/DevCrew/actions/workflows/ci.yml/badge.svg)](https://github.com/agrvasu05/DevCrew/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Python 3.10–3.13](https://img.shields.io/badge/python-3.10%E2%80%933.13-blue.svg)
+
+An AI software team in a pipeline. You give it a one-line project idea; four specialised LLM agents plan it, code it, test it, and review it — each handing structured output to the next.
+
+Built with **CrewAI** on the OpenAI API.
+
+## How it works
+
+```
+ idea ─→ ┌─────────────────┐      ┌─────────────────┐
+         │ Project Manager │ ───→ │    Developer    │
+         │  plan.json      │      │    code.py      │
+         └─────────────────┘      └───────┬─────────┘
+                                          │
+                                          ▼
+         ┌─────────────────┐      ┌─────────────────┐
+         │  Code Reviewer  │ ←─── │    QA Tester    │
+         │  review.json    │      │ test_report.json│
+         └─────────────────┘      └─────────────────┘
+          (sees code + QA report)
+```
+
+1. **Project Manager** turns the idea into a 3–6 task plan (JSON).
+2. **Developer** implements the plan as one runnable Python file.
+3. **QA Tester** designs edge-case tests against the code and honestly marks which would fail (JSON).
+4. **Code Reviewer** reads the code *and* the QA report, scores it, and gives a verdict (JSON).
+
+## Design decisions
+
+- **Role-scoped context, not one giant prompt.** Each agent only receives what it needs (the developer sees the plan, not the user's raw message). Narrow prompts hallucinate less and stay on task.
+- **Structured JSON outputs via Pydantic.** Every non-code output is bound to a schema (`devcrew/schemas.py`), so one agent's output is machine-parseable input for the next — no regex, no parsing failures.
+- **Sequential process.** A software pipeline has a natural order; sequential orchestration keeps the run deterministic and debuggable. Every stage is written to `output/` so you can inspect exactly where a run went wrong.
+- **Adversarial QA.** The tester is prompted to be sceptical and mark failures honestly, and the reviewer sees the QA report — so the review verdict is grounded in found bugs, not vibes.
+
+## Run it
+
+```bash
+git clone https://github.com/agrvasu05/DevCrew && cd DevCrew
+pip install -e .
+cp .env.example .env   # add your OPENAI_API_KEY
+
+devcrew "Build a CLI expense tracker with categories and monthly totals"
+```
+
+`python main.py "..."` still works if you'd rather not install the package.
+
+| Option | Default | What it does |
+|---|---|---|
+| `-o`, `--output-dir` | `output` | Where results go (a path relative to the current directory) |
+| `-m`, `--model` | `$MODEL` or `gpt-4o-mini` | Which LLM the agents use |
+| `--version` | | Print the version |
+
+Outputs land in the output directory:
+
+| File | Agent | Contents |
+|---|---|---|
+| `01_plan.json` | Project Manager | Task breakdown |
+| `02_code.py` | Developer | Runnable Python file |
+| `03_test_report.json` | QA Tester | Test cases + bugs found |
+| `04_review.json` | Code Reviewer | Scores, comments, verdict |
+
+A full example run is committed in [`sample_output/`](sample_output/).
+
+> DevCrew never runs the code it generates. Read `02_code.py` before you execute it.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest          # no API key or network needed
+ruff check .
+```
+
+The tests check how the pipeline is wired (which agent sees which output) and validate
+`sample_output/` against the schemas, without calling an LLM. CI runs them on Python 3.10–3.13.
+
+## Roadmap
+
+- Feed the reviewer's verdict back to the Developer for a fix-up round when changes are requested
+- Actually run the generated code against the QA test cases in a sandbox
+- Support projects that span more than one file
+- A small eval set of project ideas to catch prompt regressions in CI
+
+Ideas and PRs are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Stack
+
+Python · CrewAI · OpenAI API · Pydantic
+
+## Project structure
+
+```
+devcrew/
+├── main.py              # thin wrapper around devcrew.cli
+├── devcrew/
+│   ├── cli.py           # `devcrew` command-line entry point
+│   ├── agents.py        # 4 agents with role-scoped prompts
+│   ├── tasks.py         # pipeline tasks + context hand-offs
+│   ├── schemas.py       # Pydantic schemas for structured JSON
+│   └── crew.py          # crew assembly (sequential process)
+├── sample_output/       # committed example run
+├── tests/               # offline unit tests
+├── pyproject.toml
+├── requirements.txt
+└── .env.example
+```
+
+## License
+
+[MIT](LICENSE) © Vasu Agrawal

devcrew-0.1.0/README.md

@@ -0,0 +1,114 @@
+# DevCrew — Multi-Agent AI Orchestration System
+
+[![CI](https://github.com/agrvasu05/DevCrew/actions/workflows/ci.yml/badge.svg)](https://github.com/agrvasu05/DevCrew/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Python 3.10–3.13](https://img.shields.io/badge/python-3.10%E2%80%933.13-blue.svg)
+
+An AI software team in a pipeline. You give it a one-line project idea; four specialised LLM agents plan it, code it, test it, and review it — each handing structured output to the next.
+
+Built with **CrewAI** on the OpenAI API.
+
+## How it works
+
+```
+ idea ─→ ┌─────────────────┐      ┌─────────────────┐
+         │ Project Manager │ ───→ │    Developer    │
+         │  plan.json      │      │    code.py      │
+         └─────────────────┘      └───────┬─────────┘
+                                          │
+                                          ▼
+         ┌─────────────────┐      ┌─────────────────┐
+         │  Code Reviewer  │ ←─── │    QA Tester    │
+         │  review.json    │      │ test_report.json│
+         └─────────────────┘      └─────────────────┘
+          (sees code + QA report)
+```
+
+1. **Project Manager** turns the idea into a 3–6 task plan (JSON).
+2. **Developer** implements the plan as one runnable Python file.
+3. **QA Tester** designs edge-case tests against the code and honestly marks which would fail (JSON).
+4. **Code Reviewer** reads the code *and* the QA report, scores it, and gives a verdict (JSON).
+
+## Design decisions
+
+- **Role-scoped context, not one giant prompt.** Each agent only receives what it needs (the developer sees the plan, not the user's raw message). Narrow prompts hallucinate less and stay on task.
+- **Structured JSON outputs via Pydantic.** Every non-code output is bound to a schema (`devcrew/schemas.py`), so one agent's output is machine-parseable input for the next — no regex, no parsing failures.
+- **Sequential process.** A software pipeline has a natural order; sequential orchestration keeps the run deterministic and debuggable. Every stage is written to `output/` so you can inspect exactly where a run went wrong.
+- **Adversarial QA.** The tester is prompted to be sceptical and mark failures honestly, and the reviewer sees the QA report — so the review verdict is grounded in found bugs, not vibes.
+
+## Run it
+
+```bash
+git clone https://github.com/agrvasu05/DevCrew && cd DevCrew
+pip install -e .
+cp .env.example .env   # add your OPENAI_API_KEY
+
+devcrew "Build a CLI expense tracker with categories and monthly totals"
+```
+
+`python main.py "..."` still works if you'd rather not install the package.
+
+| Option | Default | What it does |
+|---|---|---|
+| `-o`, `--output-dir` | `output` | Where results go (a path relative to the current directory) |
+| `-m`, `--model` | `$MODEL` or `gpt-4o-mini` | Which LLM the agents use |
+| `--version` | | Print the version |
+
+Outputs land in the output directory:
+
+| File | Agent | Contents |
+|---|---|---|
+| `01_plan.json` | Project Manager | Task breakdown |
+| `02_code.py` | Developer | Runnable Python file |
+| `03_test_report.json` | QA Tester | Test cases + bugs found |
+| `04_review.json` | Code Reviewer | Scores, comments, verdict |
+
+A full example run is committed in [`sample_output/`](sample_output/).
+
+> DevCrew never runs the code it generates. Read `02_code.py` before you execute it.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest          # no API key or network needed
+ruff check .
+```
+
+The tests check how the pipeline is wired (which agent sees which output) and validate
+`sample_output/` against the schemas, without calling an LLM. CI runs them on Python 3.10–3.13.
+
+## Roadmap
+
+- Feed the reviewer's verdict back to the Developer for a fix-up round when changes are requested
+- Actually run the generated code against the QA test cases in a sandbox
+- Support projects that span more than one file
+- A small eval set of project ideas to catch prompt regressions in CI
+
+Ideas and PRs are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Stack
+
+Python · CrewAI · OpenAI API · Pydantic
+
+## Project structure
+
+```
+devcrew/
+├── main.py              # thin wrapper around devcrew.cli
+├── devcrew/
+│   ├── cli.py           # `devcrew` command-line entry point
+│   ├── agents.py        # 4 agents with role-scoped prompts
+│   ├── tasks.py         # pipeline tasks + context hand-offs
+│   ├── schemas.py       # Pydantic schemas for structured JSON
+│   └── crew.py          # crew assembly (sequential process)
+├── sample_output/       # committed example run
+├── tests/               # offline unit tests
+├── pyproject.toml
+├── requirements.txt
+└── .env.example
+```
+
+## License
+
+[MIT](LICENSE) © Vasu Agrawal

devcrew-0.1.0/devcrew/__init__.py

@@ -0,0 +1,3 @@
+"""DevCrew — an AI software team in a pipeline: plan -> code -> test -> review."""
+
+__version__ = "0.1.0"

devcrew-0.1.0/devcrew/agents.py

@@ -0,0 +1,80 @@
+"""The four specialised agents.
+
+Each agent gets a narrow role, goal and backstory ("role-scoped context").
+This is deliberate: a focused prompt hallucinates less than one giant
+prompt asking a single LLM to plan, code, test and review all at once.
+"""
+
+import os
+
+from crewai import LLM, Agent
+
+DEFAULT_MODEL = "gpt-4o-mini"
+
+
+def get_llm(model: str | None = None) -> LLM:
+    """One shared LLM config. Model comes from the argument, then the MODEL env var."""
+    return LLM(
+        model=model or os.getenv("MODEL", DEFAULT_MODEL),
+        temperature=0.3,  # low temp = more deterministic, parseable output
+    )
+
+
+def project_manager(llm: LLM) -> Agent:
+    return Agent(
+        role="Project Manager",
+        goal="Break the user's idea into a small, concrete development plan.",
+        backstory=(
+            "You are a pragmatic software project manager. You take vague "
+            "one-line ideas and turn them into 3-6 unambiguous tasks a "
+            "developer can implement in a single Python file. You never "
+            "invent features the user did not ask for."
+        ),
+        llm=llm,
+        verbose=True,
+    )
+
+
+def developer(llm: LLM) -> Agent:
+    return Agent(
+        role="Python Developer",
+        goal="Implement the project plan as clean, working Python code.",
+        backstory=(
+            "You are a senior Python developer. You write a single, "
+            "self-contained, runnable Python file with functions, docstrings "
+            "and a __main__ demo block. You implement exactly the tasks in "
+            "the plan — nothing more. You only use the standard library."
+        ),
+        llm=llm,
+        verbose=True,
+    )
+
+
+def qa_tester(llm: LLM) -> Agent:
+    return Agent(
+        role="QA Tester",
+        goal="Find bugs and untested edge cases in the developer's code.",
+        backstory=(
+            "You are a sceptical QA engineer. You read code line by line "
+            "looking for edge cases: empty inputs, wrong types, negative "
+            "numbers, duplicates. You design test cases and honestly mark "
+            "which ones the current code would fail."
+        ),
+        llm=llm,
+        verbose=True,
+    )
+
+
+def code_reviewer(llm: LLM) -> Agent:
+    return Agent(
+        role="Code Reviewer",
+        goal="Judge the code on readability and correctness, using the QA report.",
+        backstory=(
+            "You are a strict but fair code reviewer. You consider both the "
+            "code and the QA report, score readability and correctness out "
+            "of 10, and give a final verdict: approved or changes_requested. "
+            "You point at specific functions, never vague advice."
+        ),
+        llm=llm,
+        verbose=True,
+    )

devcrew-0.1.0/devcrew/cli.py

@@ -0,0 +1,71 @@
+"""Command-line entry point: `devcrew "your project idea"`."""
+
+import argparse
+import os
+import sys
+
+from dotenv import load_dotenv
+
+from . import __version__
+from .agents import DEFAULT_MODEL
+
+OUTPUT_FILES = (
+    ("01_plan.json", "Project Manager's plan"),
+    ("02_code.py", "Developer's code"),
+    ("03_test_report.json", "QA Tester's report"),
+    ("04_review.json", "Code Reviewer's verdict"),
+)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="devcrew",
+        description="Run an AI software team (plan -> code -> test -> review) on a one-line idea.",
+    )
+    parser.add_argument("idea", help='what to build, e.g. "a CLI expense tracker"')
+    parser.add_argument(
+        "-o",
+        "--output-dir",
+        default="output",
+        help="folder for results, relative to the current directory (default: output)",
+    )
+    parser.add_argument(
+        "-m", "--model", default=None, help=f"LLM to use (default: $MODEL or {DEFAULT_MODEL})"
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    # CrewAI only writes task output to relative paths: it rejects ".." and "~",
+    # and silently drops the leading "/" of an absolute path.
+    if (
+        os.path.isabs(args.output_dir)
+        or ".." in args.output_dir.split(os.sep)
+        or (args.output_dir.startswith(("~", "$")))
+    ):
+        parser.error("--output-dir must be a relative path inside the current directory")
+
+    load_dotenv()
+
+    if not os.getenv("OPENAI_API_KEY"):
+        sys.exit("Missing OPENAI_API_KEY. Copy .env.example to .env and add your key.")
+
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    # Imported here so `--help` and `--version` stay fast.
+    from .crew import run
+
+    print(f"\n🚀 DevCrew starting on: {args.idea}\n")
+    run(args.idea, output_dir=args.output_dir, model=args.model)
+    print(f"\n✅ Done. Check the {args.output_dir}/ folder:")
+    for name, what in OUTPUT_FILES:
+        print(f"   {name:<20}— {what}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

devcrew-0.1.0/devcrew/crew.py

@@ -0,0 +1,33 @@
+"""Assemble the crew and run the pipeline end-to-end."""
+
+from crewai import Crew, Process
+
+from . import agents, tasks
+
+
+def build_crew(output_dir: str = "output", model: str | None = None) -> Crew:
+    llm = agents.get_llm(model)
+
+    pm = agents.project_manager(llm)
+    dev = agents.developer(llm)
+    qa = agents.qa_tester(llm)
+    reviewer = agents.code_reviewer(llm)
+
+    t_plan = tasks.plan_task(pm, output_dir=output_dir)
+    t_code = tasks.code_task(dev, plan=t_plan, output_dir=output_dir)
+    t_test = tasks.test_task(qa, code=t_code, output_dir=output_dir)
+    t_review = tasks.review_task(reviewer, code=t_code, tests=t_test, output_dir=output_dir)
+
+    return Crew(
+        agents=[pm, dev, qa, reviewer],
+        tasks=[t_plan, t_code, t_test, t_review],
+        process=Process.sequential,  # strict order: plan -> code -> test -> review
+        verbose=True,
+    )
+
+
+def run(idea: str, output_dir: str = "output", model: str | None = None) -> str:
+    """Run the full pipeline for a one-line project idea."""
+    crew = build_crew(output_dir=output_dir, model=model)
+    result = crew.kickoff(inputs={"idea": idea})
+    return str(result)

devcrew-0.1.0/devcrew/schemas.py

@@ -0,0 +1,66 @@
+"""Pydantic schemas that force each agent to return structured JSON.
+
+Why this matters: LLM agents tend to ramble. By binding each task to a
+schema, the output of one agent becomes machine-parseable input for the
+next agent in the pipeline — no regex, no guessing.
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+# ---------- Project Manager output ----------
+
+
+class PlanItem(BaseModel):
+    id: int = Field(description="Sequential task id, starting at 1")
+    title: str = Field(description="Short task title")
+    description: str = Field(description="What exactly needs to be built")
+
+
+class ProjectPlan(BaseModel):
+    project_name: str
+    summary: str = Field(description="One-paragraph summary of the project")
+    tasks: list[PlanItem] = Field(description="3-6 concrete development tasks")
+
+
+# ---------- QA Tester output ----------
+
+
+class TestCase(BaseModel):
+    name: str
+    scenario: str = Field(description="What is being tested")
+    expected: str = Field(description="Expected behaviour")
+    verdict: Literal["pass", "fail"] = Field(
+        description="'pass' or 'fail' based on reading the code"
+    )
+    notes: str = Field(default="", description="Why it passes/fails")
+
+
+class TestReport(BaseModel):
+    total_cases: int
+    passed: int
+    failed: int
+    test_cases: list[TestCase]
+    bugs_found: list[str] = Field(description="Concrete bugs or edge cases the code misses")
+
+
+# ---------- Code Reviewer output ----------
+
+
+class ReviewComment(BaseModel):
+    severity: Literal["critical", "major", "minor"] = Field(
+        description="'critical', 'major' or 'minor'"
+    )
+    location: str = Field(description="Function or section of code")
+    comment: str
+
+
+class ReviewReport(BaseModel):
+    verdict: Literal["approved", "changes_requested"] = Field(
+        description="'approved' or 'changes_requested'"
+    )
+    readability_score: int = Field(ge=1, le=10, description="1-10")
+    correctness_score: int = Field(ge=1, le=10, description="1-10")
+    comments: list[ReviewComment]
+    summary: str = Field(description="Final review summary in 2-3 sentences")

devcrew-0.1.0/devcrew/tasks.py

@@ -0,0 +1,74 @@
+"""The pipeline: Plan -> Code -> Test -> Review.
+
+The hand-off between agents happens through CrewAI's `context` parameter:
+each task receives the *output* of the previous task(s) as input. That is
+the "orchestrated hand-off" — no agent sees the whole conversation, only
+what it needs.
+"""
+
+import os
+
+from crewai import Agent, Task
+
+from .schemas import ProjectPlan, ReviewReport, TestReport
+
+
+def plan_task(agent: Agent, output_dir: str = "output") -> Task:
+    return Task(
+        description=(
+            "The user wants to build: '{idea}'.\n"
+            "Create a development plan with 3-6 concrete tasks. The whole "
+            "project must fit in ONE Python file using only the standard "
+            "library."
+        ),
+        expected_output="A structured project plan as JSON.",
+        agent=agent,
+        output_json=ProjectPlan,
+        output_file=os.path.join(output_dir, "01_plan.json"),
+    )
+
+
+def code_task(agent: Agent, plan: Task, output_dir: str = "output") -> Task:
+    return Task(
+        description=(
+            "Implement the project plan you received as ONE self-contained "
+            "Python file. Include docstrings and a small demo under "
+            "`if __name__ == '__main__':`. Output ONLY the raw Python code, "
+            "no markdown fences, no explanations."
+        ),
+        expected_output="A single runnable Python file.",
+        agent=agent,
+        context=[plan],  # hand-off: developer only sees the plan
+        output_file=os.path.join(output_dir, "02_code.py"),
+    )
+
+
+def test_task(agent: Agent, code: Task, output_dir: str = "output") -> Task:
+    return Task(
+        description=(
+            "Read the Python code you received and design 5-8 test cases "
+            "covering normal use and edge cases (empty input, invalid input, "
+            "duplicates, boundaries). For each, decide honestly whether the "
+            "CURRENT code would pass or fail, and list concrete bugs."
+        ),
+        expected_output="A structured QA test report as JSON.",
+        agent=agent,
+        context=[code],  # hand-off: tester only sees the code
+        output_json=TestReport,
+        output_file=os.path.join(output_dir, "03_test_report.json"),
+    )
+
+
+def review_task(agent: Agent, code: Task, tests: Task, output_dir: str = "output") -> Task:
+    return Task(
+        description=(
+            "Review the code, taking the QA report into account. Score "
+            "readability and correctness out of 10, leave specific comments "
+            "with severity levels, and give a final verdict."
+        ),
+        expected_output="A structured code review as JSON.",
+        agent=agent,
+        context=[code, tests],  # hand-off: reviewer sees code + QA report
+        output_json=ReviewReport,
+        output_file=os.path.join(output_dir, "04_review.json"),
+    )

devcrew-0.1.0/main.py

@@ -0,0 +1,14 @@
+"""DevCrew — run an AI software team on a one-line project idea.
+
+Usage:
+    python main.py "Build a CLI expense tracker"
+
+Once installed (`pip install -e .`), the same thing is available as `devcrew "..."`.
+"""
+
+import sys
+
+from devcrew.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

devcrew-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "devcrew"
+dynamic = ["version"]
+description = "An AI software team in a pipeline: four agents plan, code, test and review a project from a one-line idea."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Vasu Agrawal" }]
+requires-python = ">=3.10,<3.14"
+dependencies = [
+    "crewai>=1.0.0",
+    "python-dotenv>=1.0.0",
+]
+keywords = ["ai", "agents", "multi-agent", "crewai", "llm", "code-generation", "code-review"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Code Generators",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "ruff>=0.6"]
+
+[project.scripts]
+devcrew = "devcrew.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/agrvasu05/DevCrew"
+Issues = "https://github.com/agrvasu05/DevCrew/issues"
+Changelog = "https://github.com/agrvasu05/DevCrew/blob/main/CHANGELOG.md"
+
+[tool.hatch.version]
+path = "devcrew/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["devcrew", "tests", "sample_output", "main.py", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+extend-exclude = ["sample_output"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

devcrew-0.1.0/sample_output/01_plan.json

@@ -0,0 +1,31 @@
+{
+  "project_name": "CLI Expense Tracker",
+  "summary": "A command-line interface (CLI) application that allows users to track their expenses by categories and calculate monthly totals, all implemented in a single Python file using only the standard library.",
+  "tasks": [
+    {
+      "id": 1,
+      "title": "Define Expense Data Structure",
+      "description": "Create a data structure to hold expense entries, including fields for amount, category, and date."
+    },
+    {
+      "id": 2,
+      "title": "Implement Expense Entry Functionality",
+      "description": "Write a function to allow users to input new expenses, specifying the amount, category, and date, and store these in the defined data structure."
+    },
+    {
+      "id": 3,
+      "title": "Create Category Management",
+      "description": "Implement functionality to define and manage expense categories, allowing users to view and add categories."
+    },
+    {
+      "id": 4,
+      "title": "Calculate Monthly Totals",
+      "description": "Develop a function to calculate and display the total expenses for each category on a monthly basis."
+    },
+    {
+      "id": 5,
+      "title": "Build CLI Interface",
+      "description": "Create a command-line interface that allows users to interact with the expense tracker, including options to add expenses, view totals, and manage categories."
+    }
+  ]
+}

devcrew-0.1.0/sample_output/02_code.py

@@ -0,0 +1,64 @@
+import json
+from datetime import datetime
+
+class Expense:
+    """Class to represent an expense entry."""
+    def __init__(self, amount, category, date):
+        self.amount = amount
+        self.category = category
+        self.date = datetime.strptime(date, '%Y-%m-%d')
+
+class ExpenseTracker:
+    """Class to manage expenses and categories."""
+    def __init__(self):
+        self.expenses = []
+        self.categories = set()
+
+    def add_expense(self, amount, category, date):
+        """Add a new expense to the tracker."""
+        if category not in self.categories:
+            print(f"Category '{category}' not found. Please add it first.")
+            return
+        expense = Expense(amount, category, date)
+        self.expenses.append(expense)
+
+    def add_category(self, category):
+        """Add a new category to the tracker."""
+        self.categories.add(category)
+
+    def calculate_monthly_totals(self, year, month):
+        """Calculate total expenses for each category for a given month."""
+        monthly_totals = {}
+        for expense in self.expenses:
+            if expense.date.year == year and expense.date.month == month:
+                if expense.category not in monthly_totals:
+                    monthly_totals[expense.category] = 0
+                monthly_totals[expense.category] += expense.amount
+        return monthly_totals
+
+    def view_categories(self):
+        """View all expense categories."""
+        return list(self.categories)
+
+def main():
+    tracker = ExpenseTracker()
+    
+    # Add categories
+    tracker.add_category("Food")
+    tracker.add_category("Transport")
+    tracker.add_category("Utilities")
+    
+    # Add expenses
+    tracker.add_expense(50, "Food", "2023-10-01")
+    tracker.add_expense(20, "Transport", "2023-10-02")
+    tracker.add_expense(100, "Utilities", "2023-10-03")
+    tracker.add_expense(30, "Food", "2023-10-04")
+    
+    # Calculate monthly totals
+    totals = tracker.calculate_monthly_totals(2023, 10)
+    print("Monthly Totals for October 2023:")
+    for category, total in totals.items():
+        print(f"{category}: ${total}")
+
+if __name__ == '__main__':
+    main()

devcrew-0.1.0/sample_output/03_test_report.json

@@ -0,0 +1,54 @@
+{
+  "total_cases": 6,
+  "passed": 3,
+  "failed": 3,
+  "test_cases": [
+    {
+      "name": "Valid Expense Addition",
+      "scenario": "Adding an expense with a valid category and date.",
+      "expected": "Expense is added successfully.",
+      "verdict": "pass",
+      "notes": "The expense is added correctly when the category exists."
+    },
+    {
+      "name": "Invalid Category Expense Addition",
+      "scenario": "Adding an expense with a non-existent category.",
+      "expected": "Error message is printed, and expense is not added.",
+      "verdict": "fail",
+      "notes": "The code prints an error but does not prevent adding the expense if the category is invalid."
+    },
+    {
+      "name": "Empty Category Addition",
+      "scenario": "Adding an empty category.",
+      "expected": "Category is added as an empty string.",
+      "verdict": "pass",
+      "notes": "The code allows adding an empty string as a category."
+    },
+    {
+      "name": "Duplicate Category Addition",
+      "scenario": "Adding a category that already exists.",
+      "expected": "Category remains unchanged, no error.",
+      "verdict": "pass",
+      "notes": "The set data structure prevents duplicates, which is expected behavior."
+    },
+    {
+      "name": "Calculate Monthly Totals with No Expenses",
+      "scenario": "Calculating totals for a month with no expenses.",
+      "expected": "Returns an empty dictionary.",
+      "verdict": "pass",
+      "notes": "The method correctly returns an empty dictionary when there are no expenses."
+    },
+    {
+      "name": "Invalid Date Format",
+      "scenario": "Adding an expense with an invalid date format.",
+      "expected": "Error raised due to invalid date format.",
+      "verdict": "fail",
+      "notes": "The code does not handle invalid date formats and will raise a ValueError."
+    }
+  ],
+  "bugs_found": [
+    "The add_expense method does not prevent adding an expense if the category is invalid.",
+    "The code does not handle invalid date formats, which can cause runtime errors.",
+    "Adding an empty string as a category is allowed, which may not be intended."
+  ]
+}

devcrew-0.1.0/sample_output/04_review.json

@@ -0,0 +1,23 @@
+{
+  "verdict": "changes_requested",
+  "readability_score": 7,
+  "correctness_score": 5,
+  "comments": [
+    {
+      "severity": "major",
+      "location": "add_expense",
+      "comment": "The method does not prevent adding an expense if the category is invalid, which can lead to incorrect data being stored."
+    },
+    {
+      "severity": "critical",
+      "location": "Expense.__init__",
+      "comment": "The code does not handle invalid date formats, which can cause runtime errors when an invalid date is provided."
+    },
+    {
+      "severity": "minor",
+      "location": "add_category",
+      "comment": "Allowing an empty string as a category may not be intended behavior and could lead to confusion."
+    }
+  ],
+  "summary": "The code has good readability but contains critical issues that affect correctness. Specifically, it does not handle invalid categories or date formats properly, which must be addressed before approval."
+}

devcrew-0.1.0/tests/conftest.py

@@ -0,0 +1,7 @@
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def fake_api_key(monkeypatch):
+    """Building agents needs a key to be set; no test ever calls the API."""
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-test-not-a-real-key")

devcrew-0.1.0/tests/test_cli.py

@@ -0,0 +1,45 @@
+import pytest
+
+from devcrew import __version__, cli
+
+
+def test_version(capsys):
+    with pytest.raises(SystemExit) as exc:
+        cli.main(["--version"])
+    assert exc.value.code == 0
+    assert __version__ in capsys.readouterr().out
+
+
+def test_idea_is_required():
+    with pytest.raises(SystemExit) as exc:
+        cli.main([])
+    assert exc.value.code == 2
+
+
+def test_missing_api_key_exits_with_hint(monkeypatch):
+    monkeypatch.delenv("OPENAI_API_KEY")
+    monkeypatch.setattr(cli, "load_dotenv", lambda: None)
+    with pytest.raises(SystemExit) as exc:
+        cli.main(["a todo app"])
+    assert "OPENAI_API_KEY" in str(exc.value.code)
+
+
+@pytest.mark.parametrize("bad", ["/tmp/out", "../out", "~/out"])
+def test_output_dir_must_be_relative(bad):
+    with pytest.raises(SystemExit) as exc:
+        cli.main(["a todo app", "-o", bad])
+    assert exc.value.code == 2
+
+
+def test_runs_pipeline_with_options(monkeypatch, tmp_path):
+    calls = {}
+
+    def fake_run(idea, output_dir, model):
+        calls.update(idea=idea, output_dir=output_dir, model=model)
+        return "ok"
+
+    monkeypatch.setattr("devcrew.crew.run", fake_run)
+    monkeypatch.chdir(tmp_path)
+    assert cli.main(["a todo app", "-o", "runs/todo", "-m", "gpt-4o"]) == 0
+    assert calls == {"idea": "a todo app", "output_dir": "runs/todo", "model": "gpt-4o"}
+    assert (tmp_path / "runs" / "todo").is_dir()

devcrew-0.1.0/tests/test_crew.py

@@ -0,0 +1,53 @@
+"""The pipeline is wired as plan -> code -> test -> review, without calling an LLM."""
+
+import os
+
+from crewai import Process
+
+from devcrew import schemas
+from devcrew.crew import build_crew
+
+
+def test_crew_has_four_agents_in_order():
+    crew = build_crew()
+    assert [a.role for a in crew.agents] == [
+        "Project Manager",
+        "Python Developer",
+        "QA Tester",
+        "Code Reviewer",
+    ]
+    assert crew.process == Process.sequential
+
+
+def test_each_task_only_sees_what_it_needs():
+    plan, code, test, review = build_crew().tasks
+    assert not isinstance(plan.context, list)  # no upstream task
+    assert code.context == [plan]
+    assert test.context == [code]
+    assert review.context == [code, test]
+
+
+def test_structured_outputs_are_bound_to_schemas():
+    plan, code, test, review = build_crew().tasks
+    assert plan.output_json is schemas.ProjectPlan
+    assert code.output_json is None
+    assert test.output_json is schemas.TestReport
+    assert review.output_json is schemas.ReviewReport
+
+
+def test_output_dir_is_configurable():
+    out = os.path.join("runs", "todo-app")
+    tasks = build_crew(output_dir=out).tasks
+    assert [os.path.basename(t.output_file) for t in tasks] == [
+        "01_plan.json",
+        "02_code.py",
+        "03_test_report.json",
+        "04_review.json",
+    ]
+    assert {os.path.dirname(t.output_file) for t in tasks} == {out}
+
+
+def test_model_can_be_overridden(monkeypatch):
+    monkeypatch.setenv("MODEL", "gpt-4o")
+    assert build_crew().agents[0].llm.model == "gpt-4o"
+    assert build_crew(model="gpt-4.1-mini").agents[0].llm.model == "gpt-4.1-mini"

devcrew-0.1.0/tests/test_schemas.py

@@ -0,0 +1,55 @@
+"""The committed sample run must match the schemas agents are bound to."""
+
+import json
+from pathlib import Path
+
+import pytest
+from pydantic import ValidationError
+
+from devcrew import schemas
+
+SAMPLE = Path(__file__).resolve().parent.parent / "sample_output"
+
+
+def load(name: str) -> dict:
+    return json.loads((SAMPLE / name).read_text())
+
+
+def test_sample_plan_is_valid():
+    plan = schemas.ProjectPlan.model_validate(load("01_plan.json"))
+    assert 3 <= len(plan.tasks) <= 6
+    assert [t.id for t in plan.tasks] == list(range(1, len(plan.tasks) + 1))
+
+
+def test_sample_test_report_is_valid():
+    report = schemas.TestReport.model_validate(load("03_test_report.json"))
+    assert report.total_cases == len(report.test_cases)
+    assert report.passed + report.failed == report.total_cases
+
+
+def test_sample_review_is_valid():
+    schemas.ReviewReport.model_validate(load("04_review.json"))
+
+
+def test_sample_code_compiles():
+    compile((SAMPLE / "02_code.py").read_text(), "02_code.py", "exec")
+
+
+@pytest.mark.parametrize("score", [0, 11])
+def test_review_scores_are_bounded(score):
+    review = load("04_review.json") | {"readability_score": score}
+    with pytest.raises(ValidationError):
+        schemas.ReviewReport.model_validate(review)
+
+
+def test_unknown_verdict_is_rejected():
+    review = load("04_review.json") | {"verdict": "looks fine"}
+    with pytest.raises(ValidationError):
+        schemas.ReviewReport.model_validate(review)
+
+
+def test_unknown_severity_is_rejected():
+    review = load("04_review.json")
+    review["comments"][0]["severity"] = "blocker"
+    with pytest.raises(ValidationError):
+        schemas.ReviewReport.model_validate(review)