codepilot-00 0.0.0__tar.gz

codepilot_00-0.0.0/LICENSE

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

codepilot_00-0.0.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: codepilot-00
+Version: 0.0.0
+Summary: A command-line AI assistant for generating and testing Python code.
+Keywords: ai,code-generation,command-line
+Author: Prit_kanani
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Dist: openai>=3.31.0
+Requires-Dist: prompt-toolkit>=3.0.53
+Requires-Dist: python-dotenv>=1.2.4
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.27.3
+Requires-Python: >=3.14
+Project-URL: Repository, https://github.com/kevit-prit-kanani/Agents
+Project-URL: Issues, https://github.com/kevit-prit-kanani/Agents/issues
+Description-Content-Type: text/markdown
+
+# CodePilot
+
+CodePilot is a command-line Python assistant that can answer questions and
+generate, test, and repair small Python programs.
+
+## Project structure
+
+- `src/codepilot/agent.py` talks to the language model.
+- `src/codepilot/workflow.py` coordinates code generation, testing, and retries.
+- `src/codepilot/runner.py` runs generated code and tests in a temporary folder.
+- `src/codepilot/cli.py` handles terminal input, output, and saving solutions.
+- `tests/` contains the project's own automated checks.
+
+Generated test code is used only during the temporary test run. CodePilot saves
+the generated implementation under `generated/`; it does not save generated
+test scripts.
+
+During interactive work, CodePilot shows each active stage and marks completed
+stages before moving on to the next one.
+
+The chat prompt suggests matching slash commands as you type. Use `/help` to
+list commands, and `/exit` or `/quit` to end the chat.
+
+## Run
+
+Install the package, save your OpenAI API key, and start the interactive
+session:
+
+```console
+pipx install codepilot-00
+codepilot setup
+codepilot chat
+```
+
+The PyPI distribution is named `codepilot-00`; the installed terminal command
+is `codepilot`.
+
+If you prefer not to use `pipx`, install the distribution in a virtual
+environment and ensure its scripts directory is on your `PATH`:
+
+```console
+python -m pip install codepilot-00
+```
+
+Generate code directly without the interactive session:
+
+```console
+uv run codepilot generate "Write a function that checks whether text is a palindrome"
+```
+
+See the [installation and publishing guide](https://github.com/kevit-prit-kanani/Agents/blob/master/SETUP.md)
+for detailed instructions.

codepilot_00-0.0.0/README.md

@@ -0,0 +1,52 @@
+# CodePilot
+
+CodePilot is a command-line Python assistant that can answer questions and
+generate, test, and repair small Python programs.
+
+## Project structure
+
+- `src/codepilot/agent.py` talks to the language model.
+- `src/codepilot/workflow.py` coordinates code generation, testing, and retries.
+- `src/codepilot/runner.py` runs generated code and tests in a temporary folder.
+- `src/codepilot/cli.py` handles terminal input, output, and saving solutions.
+- `tests/` contains the project's own automated checks.
+
+Generated test code is used only during the temporary test run. CodePilot saves
+the generated implementation under `generated/`; it does not save generated
+test scripts.
+
+During interactive work, CodePilot shows each active stage and marks completed
+stages before moving on to the next one.
+
+The chat prompt suggests matching slash commands as you type. Use `/help` to
+list commands, and `/exit` or `/quit` to end the chat.
+
+## Run
+
+Install the package, save your OpenAI API key, and start the interactive
+session:
+
+```console
+pipx install codepilot-00
+codepilot setup
+codepilot chat
+```
+
+The PyPI distribution is named `codepilot-00`; the installed terminal command
+is `codepilot`.
+
+If you prefer not to use `pipx`, install the distribution in a virtual
+environment and ensure its scripts directory is on your `PATH`:
+
+```console
+python -m pip install codepilot-00
+```
+
+Generate code directly without the interactive session:
+
+```console
+uv run codepilot generate "Write a function that checks whether text is a palindrome"
+```
+
+See the [installation and publishing guide](https://github.com/kevit-prit-kanani/Agents/blob/master/SETUP.md)
+for detailed instructions.

codepilot_00-0.0.0/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "codepilot-00"
+version = "0.0.0"
+description = "A command-line AI assistant for generating and testing Python code."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+keywords = [
+    "ai",
+    "code-generation",
+    "command-line",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Code Generators",
+]
+dependencies = [
+    "openai>=3.31.0",
+    "prompt-toolkit>=3.0.53",
+    "python-dotenv>=1.2.4",
+    "rich>=15.0.0",
+    "typer>=0.27.3",
+]
+
+[[project.authors]]
+name = "Prit_kanani"
+
+[project.scripts]
+codepilot = "codepilot.cli:app"
+
+[project.urls]
+Repository = "https://github.com/kevit-prit-kanani/Agents"
+Issues = "https://github.com/kevit-prit-kanani/Agents/issues"
+
+[build-system]
+requires = ["uv_build>=0.12.9,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv]
+package = true
+
+[tool.uv.build-backend]
+module-name = "codepilot"
+
+[dependency-groups]
+dev = ["pytest>=9.1.1"]

codepilot_00-0.0.0/pyproject.toml.orig

@@ -0,0 +1,50 @@
+[project]
+name = "codepilot-00"
+version = "0.0.0"
+description = "A command-line AI assistant for generating and testing Python code."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Prit_kanani" }
+]
+requires-python = ">=3.14"
+keywords = ["ai", "code-generation", "command-line"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Code Generators",
+]
+dependencies = [
+    "openai>=3.31.0",
+    "prompt-toolkit>=3.0.53",
+    "python-dotenv>=1.2.4",
+    "rich>=15.0.0",
+    "typer>=0.27.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.12.9,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv]
+package = true
+
+[tool.uv.build-backend]
+module-name = "codepilot"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]
+
+[project.scripts]
+codepilot = "codepilot.cli:app"
+
+[project.urls]
+Repository = "https://github.com/kevit-prit-kanani/Agents"
+Issues = "https://github.com/kevit-prit-kanani/Agents/issues"

codepilot_00-0.0.0/src/codepilot/agent.py

@@ -0,0 +1,151 @@
+import json
+import os
+import re
+
+from openai import OpenAI
+
+from codepilot.settings import load_configuration
+
+
+def clean_code(text: str) -> str:
+    """Remove optional Markdown fences from generated code."""
+    text = text.strip()
+    text = re.sub(
+        r"\A```(?:python|py)?[ \t]*\r?\n?",
+        "",
+        text,
+        flags=re.IGNORECASE,
+    )
+    text = re.sub(r"\r?\n?```[ \t]*\Z", "", text)
+    return text.strip()
+
+
+class CodeAgent:
+    """Generate Python implementations and their tests."""
+
+    def __init__(self) -> None:
+        load_configuration()
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "OPENAI_API_KEY is missing. Run `codepilot setup` to save it, "
+                "or set the OPENAI_API_KEY environment variable."
+            )
+
+        self.model = os.getenv("OPENAI_MODEL", "gpt-5.5")
+        self.client = OpenAI(api_key=api_key)
+
+    def _request(self, instructions: str, prompt: str) -> str:
+        response = self.client.responses.create(
+            model=self.model,
+            instructions=instructions,
+            input=prompt,
+        )
+        code = clean_code(response.output_text or "")
+        if not code:
+            raise RuntimeError("The model returned empty code.")
+        return code
+
+    def generate(
+        self,
+        task: str,
+        feedback: str | None = None,
+    ) -> str:
+        """Generate or repair a Python implementation."""
+        instructions = """
+            You are a Python code generation agent.
+
+            Requirements:
+            - Return Python implementation code only.
+            - Do not include Markdown fences or explanations.
+            - Prefer simple, readable, maintainable code.
+            - Do not include tests in the implementation.
+            - Correct the implementation using any provided test feedback.
+            - Do not claim that the code passed tests unless it was tested.
+        """
+        
+        prompt = f"Programming task:\n{task}"
+
+        if feedback:
+            prompt += (
+                "\n\nThe previous implementation failed its tests."
+                "\nFix the implementation using this feedback."
+                f"\n\nTest feedback:\n{feedback}"
+            )
+
+        return self._request(instructions, prompt)
+
+    def generate_tests(self, task: str, code: str) -> str:
+        """Generate unittest tests for the candidate implementation."""
+        instructions = """
+                You are a Python test engineer.
+
+                Requirements:
+                - Return Python unittest test code only.
+                - Do not include Markdown fences or explanations.
+                - Do not repeat or redefine the candidate implementation.
+                - The candidate implementation will appear before your test code
+                in the same Python file.
+                - Use unittest.TestCase and test methods beginning with test_.
+                - Test normal behavior, boundary cases, and relevant invalid inputs.
+                - Derive expected results from the user's task, not from assumptions
+                that merely make the candidate implementation pass.
+                - Do not modify files, access the network, or run shell commands.
+                """
+        prompt = (
+            f"User's programming task:\n{task}\n\n"
+            f"Candidate implementation:\n{code}\n\n"
+            "Write a unittest test suite for this implementation."
+        )
+
+        return self._request(instructions, prompt)
+
+    def route_message(self, message: str) -> dict[str, str]:
+        """Decide whether to answer conversationally or start coding."""
+        instructions = """
+                You are CodePilot's message router and conversational assistant.
+
+                Return a JSON object with exactly these keys:
+                - "intent": either "chat" or "code"
+                - "response": a string
+
+                Choose "chat" for:
+                - Greetings and small talk.
+                - Questions about CodePilot or how you can help.
+                - General knowledge and conceptual explanations.
+                - Programming questions that ask for an explanation rather than implementation.
+                - Follow-up questions that do not request code creation, modification,
+                debugging, or execution.
+
+                For chat, answer the user directly and helpfully in the response field.
+                Do not generate a Python implementation for ordinary conversation.
+
+                Choose "code" when the user asks to create, write, implement, modify,
+                debug, repair, or test a program or code artifact.
+
+                For code, make the response field a concise, faithful description of the
+                requested coding task. Do not generate the implementation here.
+                Do not treat every mention of programming as a coding task.
+        """
+
+        result = self.client.responses.create(
+            model=self.model,
+            instructions=instructions + "\nReturn your decision as valid JSON.",
+            input=f"Classify this user message and respond in JSON:\n{message}",
+            text={"format": {"type": "json_object"}},
+        )
+
+        try:
+            decision = json.loads(result.output_text)
+        except (json.JSONDecodeError, TypeError) as exc:
+            raise RuntimeError(
+                "Could not interpret the message-routing response."
+            ) from exc
+
+        intent = decision.get("intent")
+        response = decision.get("response")
+
+        if intent not in {"chat", "code"} or not isinstance(response, str):
+            raise RuntimeError("The model returned an invalid routing decision.")
+
+        return {"intent": intent, "response": response}

codepilot_00-0.0.0/src/codepilot/cli.py

@@ -0,0 +1,273 @@
+import re
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+
+import typer
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from codepilot.agent import CodeAgent
+from codepilot.settings import save_api_key
+from codepilot.workflow import CodeWorkflow
+
+app = typer.Typer(
+    name="CodePilot",
+    help="Generate, test, and repair Python code.",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+SLASH_COMMANDS = {
+    "/help": "Show available commands",
+    "/exit": "Exit CodePilot",
+    "/quit": "Exit CodePilot",
+}
+
+
+class SlashCommandCompleter(Completer):
+    """Suggest available slash commands while the user types."""
+
+    def get_completions(
+        self,
+        document: Document,
+        complete_event: CompleteEvent,
+    ) -> Generator[Completion]:
+        prefix = document.text_before_cursor
+        if not prefix.startswith("/") or any(char.isspace() for char in prefix):
+            return
+
+        for command, description in SLASH_COMMANDS.items():
+            if command.startswith(prefix.lower()):
+                yield Completion(
+                    command,
+                    start_position=-len(prefix),
+                    display_meta=description,
+                )
+
+
+def save_code(task: str, code: str) -> Path:
+    """Save the generated implementation."""
+    output_dir = Path("generated")
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    slug = re.sub(r"[^a-zA-Z0-9_-]+", "_", task.lower()).strip("_")
+    slug = slug[:40] or "solution"
+
+    code_path = output_dir / f"{slug}.py"
+    code_path.write_text(code.rstrip() + "\n", encoding="utf-8")
+    return code_path
+
+
+@contextmanager
+def show_progress_step(label: str) -> Generator[None]:
+    """Show one active step, then keep its completion visible."""
+    with console.status(f"[cyan]{label}...", spinner="dots"):
+        yield
+    console.print(f"[bold green]✓ {label}[/bold green]")
+
+
+def run_coding_task(
+    agent: CodeAgent,
+    task: str,
+    max_attempts: int,
+) -> None:
+    """Generate, test, and display one coding task."""
+    workflow = CodeWorkflow(
+        agent=agent,
+        max_attempts=max_attempts,
+        show_progress=show_progress_step,
+    )
+    result = workflow.run(task=task)
+
+    console.print(
+        Panel(
+            Syntax(
+                result.code,
+                "python",
+                theme="monokai",
+                line_numbers=True,
+            ),
+            title="Final Python Implementation",
+            border_style="green" if result.passed else "red",
+        )
+    )
+
+    code_path = save_code(task, result.code)
+
+    if result.passed:
+        console.print(
+            f"[bold green]Tests passed[/bold green] "
+            f"on attempt {result.attempts}/{max_attempts}."
+        )
+    else:
+        console.print(
+            f"[bold red]Tests did not pass[/bold red] "
+            f"after {result.attempts} attempt(s)."
+        )
+        console.print(
+            Panel(
+                result.test_result.feedback,
+                title="Final Test Feedback",
+                border_style="red",
+            )
+        )
+
+    console.print(f"Implementation saved to: [cyan]{code_path}[/cyan]")
+
+
+def handle_message(
+    agent: CodeAgent,
+    message: str,
+    max_attempts: int,
+) -> None:
+    """Route a message to a direct answer or the coding workflow."""
+    with show_progress_step("Understanding your request"):
+        decision = agent.route_message(message)
+
+    if decision["intent"] == "chat":
+        console.print(
+            Panel(
+                Markdown(decision["response"]),
+                title="[bold cyan]CodePilot[/bold cyan]",
+                border_style="cyan",
+            )
+        )
+        return
+
+    run_coding_task(agent, decision["response"], max_attempts)
+
+
+def handle_slash_command(message: str) -> bool | None:
+    """Run a slash command; return whether the chat should exit."""
+    command = message.strip().lower()
+
+    if command in {"/exit", "/quit"}:
+        return True
+    if command == "/help":
+        console.print(
+            Panel(
+                "\n".join(
+                    f"[cyan]{name}[/cyan] — {description}"
+                    for name, description in SLASH_COMMANDS.items()
+                ),
+                title="Available commands",
+            )
+        )
+        return False
+    if command.startswith("/"):
+        console.print(
+            f"[yellow]Unknown command:[/yellow] {command}. "
+            "Type /help to see available commands."
+        )
+        return False
+    return None
+
+
+@app.command()
+def setup() -> None:
+    """Save or replace the OpenAI API key for this user."""
+    api_key = typer.prompt(
+        "OpenAI API key",
+        hide_input=True,
+        confirmation_prompt=True,
+    )
+    try:
+        config_file = save_api_key(api_key)
+    except (OSError, ValueError) as exc:
+        console.print(f"[bold red]Could not save API key:[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    console.print(
+        "[bold green]API key saved.[/bold green] "
+        f"Configuration file: [cyan]{config_file}[/cyan]"
+    )
+
+
+@app.command()
+def generate(
+    task: str = typer.Argument(..., help="Describe the Python program."),
+) -> None:
+    """Generate code without testing it."""
+    try:
+        agent = CodeAgent()
+        with console.status("[cyan]Generating code...", spinner="dots"):
+            code = agent.generate(task=task)
+
+        console.print(
+            Panel(
+                Syntax(code, "python", theme="monokai", line_numbers=True),
+                title="Generated Python Code",
+                border_style="green",
+            )
+        )
+    except Exception as exc:
+        console.print(f"[bold red]Error:[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+
+@app.command()
+def chat(
+    max_attempts: int = typer.Option(
+        3,
+        "--max-attempts",
+        min=1,
+        help="Maximum implementation attempts.",
+    ),
+) -> None:
+    """Start an interactive conversational coding session."""
+    console.print(
+        Panel(
+            "Ask questions or give me a coding task.\n"
+            "Coding tasks are generated, tested, and repaired automatically.\n"
+            "Type /help for commands. Use /exit or /quit to stop.",
+            title="[bold cyan]CodePilot[/bold cyan]",
+        )
+    )
+
+    agent = None
+    prompt_session = PromptSession(
+        completer=SlashCommandCompleter(),
+        complete_while_typing=True,
+    )
+
+    while True:
+        try:
+            message = prompt_session.prompt("you > ").strip()
+        except KeyboardInterrupt:
+            console.print(
+                "\n[yellow]Input cancelled. Use /exit or /quit to end the chat.[/yellow]"
+            )
+            continue
+        except EOFError:
+            console.print("\n[yellow]Input stream closed.[/yellow]")
+            break
+
+        if not message:
+            continue
+
+        should_exit = handle_slash_command(message)
+        if should_exit is True:
+            console.print("[yellow]Goodbye.[/yellow]")
+            break
+        if should_exit is False:
+            continue
+
+        try:
+            if agent is None:
+                agent = CodeAgent()
+
+            handle_message(agent, message, max_attempts)
+
+        except Exception as exc:  # noqa: BLE001
+            console.print(f"[bold red]Error:[/bold red] {exc}")
+
+
+if __name__ == "__main__":
+    app()

codepilot_00-0.0.0/src/codepilot/runner.py

@@ -0,0 +1,97 @@
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class TestResult:
+    """Structured result returned by the test runner."""
+
+    __test__ = False
+
+    passed: bool
+    return_code: int | None
+    stdout: str
+    stderr: str
+    timed_out: bool = False
+
+    @property
+    def feedback(self) -> str:
+        """Format test output for display or LLM repair feedback."""
+        if self.passed:
+            return "All tests passed!"
+
+        if self.timed_out:
+            return "Execution timed out"
+
+        return (
+            f"Exit code: {self.return_code}\n"
+            f"STDOUT:\n{self.stdout}\n"
+            f"STDERR:\n{self.stderr}"
+        )
+
+
+class TestRunner:
+    """Execute candidate code and its generated tests in a child process."""
+
+    __test__ = False
+
+    def __init__(self, timeout: int = 5) -> None:
+        if timeout <= 0:
+            raise ValueError("timeout must be greater than zero")
+
+        self.timeout = timeout
+
+    def run(self, code: str, test_code: str) -> TestResult:
+        """
+        Run candidate code and its generated tests in a temporary child process.
+
+        The temporary test script is removed automatically after execution.
+        """
+
+        with tempfile.TemporaryDirectory(prefix="codepilot-") as tmp:
+            script_path = Path(tmp) / "candidate_test.py"
+            script_path.write_text(
+                code
+                + "\n\n"
+                + "import unittest\n"
+                + test_code
+                + "\n\n"
+                + 'if __name__ == "__main__":\n'
+                + "\tunittest.main(verbosity=2)\n",
+                encoding="utf-8",
+            )
+            try:
+                completed = subprocess.run(
+                    [sys.executable, "-I", str(script_path)],
+                    capture_output=True,
+                    text=True,
+                    timeout=self.timeout,
+                    check=False,
+                    cwd=tmp,
+                )
+                return TestResult(
+                    passed=completed.returncode == 0,
+                    return_code=completed.returncode,
+                    stdout=completed.stdout,
+                    stderr=completed.stderr,
+                )
+            except subprocess.TimeoutExpired as exc:
+                stdout = exc.stdout or ""
+                stderr = exc.stderr or ""
+
+                if isinstance(stdout, bytes):
+                    stdout = stdout.decode("utf-8", errors="replace")
+
+                if isinstance(stderr, bytes):
+                    stderr = stderr.decode("utf-8", errors="replace")
+
+                return TestResult(
+                    passed=False,
+                    return_code=None,
+                    stdout=stdout,
+                    stderr=stderr,
+                    timed_out=True,
+                )

codepilot_00-0.0.0/src/codepilot/settings.py

@@ -0,0 +1,38 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv, set_key
+
+
+def user_config_file() -> Path:
+    """Return the per-user .env file used by installed CodePilot commands."""
+    config_root = (
+        os.getenv("XDG_CONFIG_HOME")
+        or os.getenv("APPDATA")
+        or str(Path.home() / ".config")
+    )
+    return Path(config_root) / "codepilot" / ".env"
+
+
+def load_configuration() -> None:
+    """Load user settings first, then fall back to a project-local .env file."""
+    load_dotenv(user_config_file())
+    load_dotenv(Path.cwd() / ".env")
+
+
+def save_api_key(api_key: str) -> Path:
+    """Save the API key to the private per-user configuration file."""
+    api_key = api_key.strip()
+    if not api_key:
+        raise ValueError("The API key cannot be empty.")
+
+    config_file = user_config_file()
+    config_file.parent.mkdir(parents=True, exist_ok=True)
+    set_key(
+        str(config_file),
+        "OPENAI_API_KEY",
+        api_key,
+        quote_mode="always",
+    )
+    config_file.chmod(0o600)
+    return config_file

codepilot_00-0.0.0/src/codepilot/workflow.py

@@ -0,0 +1,84 @@
+
+from collections.abc import Callable
+from contextlib import AbstractContextManager, nullcontext
+from dataclasses import dataclass
+
+from codepilot.agent import CodeAgent
+from codepilot.runner import TestResult, TestRunner
+
+
+@dataclass
+class WorkflowResult:
+    """Outcome of a generate-test-repair run."""
+
+    code: str
+    test_code: str
+    attempts: int
+    test_result: TestResult
+
+    @property
+    def passed(self) -> bool:
+        return self.test_result.passed
+
+
+class CodeWorkflow:
+    """Generate code and tests, execute them, and retry on failure."""
+
+    def __init__(
+        self,
+        agent: CodeAgent | None = None,
+        runner: TestRunner | None = None,
+        max_attempts: int = 3,
+        show_progress: Callable[[str], AbstractContextManager[None]] | None = None,
+    ) -> None:
+        if max_attempts < 1:
+            raise ValueError("max_attempts must be at least 1")
+
+        self.agent = agent if agent is not None else CodeAgent()
+        self.runner = runner if runner is not None else TestRunner()
+        self.max_attempts = max_attempts
+        self.show_progress = show_progress
+
+    def run(self, task: str) -> WorkflowResult:
+        """Generate implementation and tests, then retry on failures."""
+        with self._progress_step("Writing the first implementation"):
+            code = self.agent.generate(task=task)
+
+        with self._progress_step("Preparing checks"):
+            test_code = self.agent.generate_tests(task=task, code=code)
+
+        for attempt in range(1, self.max_attempts + 1):
+            with self._progress_step(
+                f"Running checks (attempt {attempt}/{self.max_attempts})"
+            ):
+                result = self.runner.run(code=code, test_code=test_code)
+
+            if result.passed:
+                return WorkflowResult(
+                    code=code,
+                    test_code=test_code,
+                    attempts=attempt,
+                    test_result=result,
+                )
+
+            if attempt < self.max_attempts:
+                with self._progress_step(
+                    f"Improving the implementation (attempt "
+                    f"{attempt + 1}/{self.max_attempts})"
+                ):
+                    code = self.agent.generate(
+                        task=task,
+                        feedback=result.feedback,
+                    )
+
+        return WorkflowResult(
+            code=code,
+            test_code=test_code,
+            attempts=self.max_attempts,
+            test_result=result,
+        )
+
+    def _progress_step(self, label: str) -> AbstractContextManager[None]:
+        if self.show_progress is None:
+            return nullcontext()
+        return self.show_progress(label)