devcrew 0.1.0__py3-none-any.whl

devcrew/__init__.py

@@ -0,0 +1,3 @@
+"""DevCrew — an AI software team in a pipeline: plan -> code -> test -> review."""
+
+__version__ = "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/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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+devcrew/__init__.py,sha256=b5HYA_4lnPE-WrarBBTVBvw-VRH8lQ3U36JyUA87zM4,108
+devcrew/agents.py,sha256=EHXo2Lxdnv9DgLZrUpnE1-DerJeiRqrcUhuTnm16_3o,2743
+devcrew/cli.py,sha256=AuMCy-UEkMxu80XM5WD06hM3clpZovnOw5GH-ubRPDY,2234
+devcrew/crew.py,sha256=jb3mGyne-7yC0ZWeNRwTtt_741tND4QRAl-IjV_P5DY,1157
+devcrew/schemas.py,sha256=_XvI_wEi0vO6CJoeD24Lg9s8kxO1nLu-AiRAtSrQ8b4,2121
+devcrew/tasks.py,sha256=dJQh1C-P9ZtDdEGM3dnDEsfqEaBLiVMgcqe7yl0BcGE,2842
+devcrew-0.1.0.dist-info/METADATA,sha256=xbjFeofvbbxYeOh906hggmbDofhGZqOKDdTx2GDpMys,6429
+devcrew-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+devcrew-0.1.0.dist-info/entry_points.txt,sha256=ViCXHUuWsN5mGfaDO7sRvYnD_nOH3faEAHNlg-k8-ko,45
+devcrew-0.1.0.dist-info/licenses/LICENSE,sha256=fc3Um9yZj96IwCbnwNCmkWs6ZvlGDqz3YUfacpaxios,1069
+devcrew-0.1.0.dist-info/RECORD,,

devcrew-0.1.0.dist-info/WHEEL

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

devcrew-0.1.0.dist-info/entry_points.txt

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

devcrew-0.1.0.dist-info/licenses/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.