agentic-python-coder 2.2.0__tar.gz → 2.2.1__tar.gz

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/.gitignore

@@ -152,6 +152,7 @@ cython_debug/
 uv.lock
 
 # Project specific
+coder-examples/
 CLAUDE-archive.md
 PROCESS_NOTES.md
 conversation_log.json

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-python-coder
-Version: 2.2.0
+Version: 2.2.1
 Summary: A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions
 Author: Stefan Szeider
 License: Apache-2.0

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/coder/prompts/system.md

@@ -16,19 +16,12 @@ You have access to these specialized tools:
    - Call this ONCE when you have a complete, working solution
    - The code will be saved to {basename}_code.py
 
-3. **report_issue**: Provide feedback and summary
-   - Use at the end to summarize what was accomplished
-   - Report any issues, ambiguities, or difficulties encountered
-   - Also report if everything worked perfectly
-   - This feedback will be included in the log file
-
 ## Workflow
 
 1. **Understand the Task**: Read the problem in the <task> section carefully
 2. **Plan Your Approach**: Think through the problem and plan your solution strategy
 3. **Develop Solution**: Use python_exec iteratively to build and test
 4. **Save Final Code**: Call save_code with your complete solution
-5. **Provide Feedback**: Use report_issue to summarize and provide feedback
 
 ## Python Execution Best Practices
 
@@ -68,8 +61,7 @@ Build solutions incrementally:
 1. **Focus on the Task**: Complete what's requested, nothing more
 2. **Test Efficiently**: One or two test cases are usually sufficient
 3. **Save Once**: Call save_code only when you have the final code
-4. **Always Provide Feedback**: Use report_issue at the end to summarize your work
-5. **Stop When Done**: Don't add features not requested
+4. **Stop When Done**: Don't add features not requested
 
 ## Error Recovery
 
@@ -94,10 +86,6 @@ When finishing:
 1. Verify the solution works correctly
 2. Clean the code according to the **Code Cleaning Requirements** above
 3. Call save_code with the complete, cleaned code
-4. Call report_issue to provide your final summary and feedback:
-   - Summarize what was accomplished
-   - Report any issues, ambiguities, or difficulties encountered
-   - Even if everything worked perfectly, report: "All is fine - no issues encountered."
-5. STOP - do not continue unless asked
+4. STOP - do not continue unless asked
 
-Your goal is efficient, focused problem-solving.
+Your goal is efficient, focused problem-solving.

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/coder/prompts/system_todo.md

@@ -16,35 +16,28 @@ You have access to these specialized tools:
    - Call this ONCE when you have a complete, working solution
    - The code will be saved to {basename}_code.py
 
-3. **report_issue**: Provide feedback and summary
-   - Use at the end to summarize what was accomplished
-   - Report any issues, ambiguities, or difficulties encountered
-   - Also report if everything worked perfectly
-   - This feedback will be included in the log file
-
-4. **todo_write**: MANDATORY task management tool
+3. **todo_write**: MANDATORY task management tool
    - You MUST use this tool after understanding the problem
    - Create a todo list with items appropriate to the problem complexity
      (ranging from 3 simple items to over a dozen for complex problems)
    - Update todo item status as you progress (pending → in_progress → completed)
    - Only ONE todo item can be in_progress at a time
    - Add new todo items if you discover additional work needed
-   - Your last three todo items should always be: "Clean final code", "Save final code", and "Provide feedback"
+   - Your last two todo items should always be: "Clean final code" and "Save final code"
 
 ## Workflow
 
 1. **Understand the Task**: Read the problem in the <task> section carefully
-2. **Plan Your Approach** (MANDATORY): 
+2. **Plan Your Approach** (MANDATORY):
    - Use todo_write to create your todo list based on your understanding
    - The number of todo items should match problem complexity (3-12+ items)
-   - Include "Save final code" and "Provide feedback" as your last two items
+   - Include "Save final code" as your last item
    - This demonstrates planning and helps track progress
 3. **Develop Solution**: Use python_exec iteratively to build and test
    - Mark todo items as in_progress when starting them
    - Mark as completed when done
-4. **Clean Final Code**: Clean the code according to Code Cleaning Requirements (third-to-last todo item)
-5. **Save Final Code**: Call save_code with your complete, cleaned solution (second-to-last todo item)
-6. **Provide Feedback**: Use report_issue to summarize and provide feedback (final todo item)
+4. **Clean Final Code**: Clean the code according to Code Cleaning Requirements (second-to-last todo item)
+5. **Save Final Code**: Call save_code with your complete, cleaned solution (final todo item)
 
 ## Python Execution Best Practices
 
@@ -85,8 +78,7 @@ Build solutions incrementally:
 2. **Focus on the Task**: Complete what's requested, nothing more
 3. **Test Efficiently**: One or two test cases are usually sufficient
 4. **Save Once**: Call save_code only when you have the final code
-5. **Always Provide Feedback**: Use report_issue at the end to summarize your work
-6. **Stop When Done**: Don't add features not requested
+5. **Stop When Done**: Don't add features not requested
 
 ## Error Recovery
 
@@ -111,13 +103,9 @@ When finishing (these should be your final todo items):
 1. Ensure all todo items are marked as completed
 2. Verify the solution works correctly
 3. Clean the code according to the **Code Cleaning Requirements** above
-4. Call save_code with the complete, cleaned code (second-to-last todo item)
-5. Call report_issue to provide your final summary and feedback (final todo item):
-   - Summarize what was accomplished
-   - Report any issues, ambiguities, or difficulties encountered
-   - Even if everything worked perfectly, report: "All is fine - no issues encountered."
-6. STOP - do not continue unless asked
+4. Call save_code with the complete, cleaned code (final todo item)
+5. STOP - do not continue unless asked
 
 Note: Your todo list should show a clear progression from planning through completion.
 
-Your goal is efficient, focused problem-solving.
+Your goal is efficient, focused problem-solving.

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/coder/src/agentic_python_coder/__init__.py

@@ -1,6 +1,6 @@
 """Python Coding Agent - A minimal coding assistant using LangGraph and OpenRouter."""
 
-__version__ = "2.1.0"
+__version__ = "2.2.1"
 
 # High-level API (recommended for most users)
 from agentic_python_coder.runner import solve_task

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/coder/src/agentic_python_coder/agent.py

@@ -10,7 +10,6 @@ from agentic_python_coder.tools import (
     todo_write,
     python_exec,
     save_code,
-    report_issue,
     working_dir,
     set_task_basename,
     reset_global_state,
@@ -80,9 +79,9 @@ def create_coding_agent(
 
     # Minimal tool set
     if todo:
-        tools = [python_exec, save_code, report_issue, todo_write]
+        tools = [python_exec, save_code, todo_write]
     else:
-        tools = [python_exec, save_code, report_issue]
+        tools = [python_exec, save_code]
 
     # Build combined prompt
     prompts = []

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/coder/src/agentic_python_coder/runner.py

@@ -5,7 +5,6 @@ from pathlib import Path
 from typing import Optional, List, Any, Dict
 
 from agentic_python_coder.agent import create_coding_agent, run_agent
-from agentic_python_coder.tools import get_reported_issues
 
 
 def get_system_prompt_path(todo: bool = False) -> Path:
@@ -113,16 +112,6 @@ def save_conversation_log(
                             )
                             + "\n"
                         )
-                    elif tool_name == "report_issue":
-                        f.write(
-                            json.dumps(
-                                {
-                                    "event": "report_issue",
-                                    "issue": tool_args.get("text", "")[:200],
-                                }
-                            )
-                            + "\n"
-                        )
                     else:
                         f.write(
                             json.dumps({"event": "tool_call", "tool": tool_name}) + "\n"
@@ -162,28 +151,12 @@ def save_conversation_log(
                 + "\n"
             )
 
-        # Agent feedback
-        reported_issues = get_reported_issues()
-        if reported_issues:
-            for issue in reported_issues:
-                f.write(
-                    json.dumps(
-                        {
-                            "event": "agent_feedback",
-                            "content": issue.get("content", ""),
-                        }
-                    )
-                    + "\n"
-                )
-
         # Complete event
         f.write(
             json.dumps(
                 {
                     "event": "complete",
-                    "status": "success"
-                    if not reported_issues
-                    else "success_with_issues",
+                    "status": "success",
                 }
             )
             + "\n"

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/coder/src/agentic_python_coder/tools.py

@@ -221,54 +221,11 @@ def save_code(code: str) -> str:
         return error_response(f"Error saving code: {str(e)}")
 
 
-_reported_issues = []
-
-
-@tool
-def report_issue(text: str) -> str:
-    """Report an environment or specification issue (fileless mode).
-
-    Use this ONLY for:
-    - Missing packages or import errors
-    - Unclear task specifications
-    - Environment setup problems
-
-    Do NOT use for:
-    - Logic errors in your code
-    - Failed test cases
-    - Debugging information
-
-    Args:
-        text: Description of the issue
-
-    Returns:
-        JSON with success status
-    """
-    try:
-        global _reported_issues
-
-        # Store the issue in memory to be included when log is saved
-        _reported_issues.append({"type": "agent_feedback", "content": text})
-
-        return success_response(
-            "Issue reported and will be included in the log", reported=True
-        )
-    except Exception as e:
-        return error_response(f"Error reporting issue: {str(e)}")
-
-
-def get_reported_issues():
-    """Get all reported issues for inclusion in the log."""
-    global _reported_issues
-    return _reported_issues
-
-
 def reset_global_state():
     """Reset all global state to avoid accumulation across runs.
 
     Called by create_coding_agent() to ensure clean state for each new agent.
     """
-    global _todos, _task_basename, _reported_issues
+    global _todos, _task_basename
     _todos = []
     _task_basename = None
-    _reported_issues = []

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/coder/tests/test_library_api.py

@@ -15,27 +15,28 @@ def test_imports_from_package():
         run_agent,
         get_final_response,
         get_openrouter_llm,
-        MODEL_REGISTRY,
-        MODEL_STRING,
+        list_available_models,
+        DEFAULT_MODEL,
     )
 
-    assert __version__ == "2.0.0"
+    assert __version__ == "2.2.1"
     assert callable(solve_task)
     assert callable(create_coding_agent)
     assert callable(run_agent)
     assert callable(get_final_response)
     assert callable(get_openrouter_llm)
-    assert isinstance(MODEL_REGISTRY, dict)
-    assert isinstance(MODEL_STRING, str)
+    assert callable(list_available_models)
+    assert isinstance(DEFAULT_MODEL, str)
 
 
 def test_model_registry():
-    """Test that MODEL_REGISTRY contains expected models."""
-    from agentic_python_coder import MODEL_REGISTRY
+    """Test that list_available_models returns expected models."""
+    from agentic_python_coder import list_available_models
 
-    expected_models = ["sonnet", "opus", "deepseek", "grok", "qwen", "gemini", "gpt", "default"]
+    models = list_available_models()
+    expected_models = ["sonnet45", "opus45", "deepseek31", "grok41", "qwen3", "gemini25", "gpt5"]
     for model in expected_models:
-        assert model in MODEL_REGISTRY, f"Missing model: {model}"
+        assert model in models, f"Missing model: {model}"
 
 
 def test_create_agent_with_string_prompt():
@@ -46,7 +47,7 @@ def test_create_agent_with_string_prompt():
         agent = create_coding_agent(
             working_directory=tmpdir,
             system_prompt="You are a helpful coding assistant.",
-            model="sonnet",
+            model="sonnet45",
         )
         assert agent is not None
         assert agent._coder_metadata["working_directory"] == tmpdir
@@ -60,6 +61,7 @@ def test_create_agent_metadata():
         agent = create_coding_agent(
             working_directory=tmpdir,
             system_prompt="Test",
+            model="sonnet45",
             with_packages=["numpy", "pandas"],
             task_basename="test_task",
         )
@@ -104,7 +106,7 @@ def test_verbose_false_suppresses_output():
             agent = create_coding_agent(
                 working_directory=tmpdir,
                 system_prompt="Test",
-                model="sonnet",
+                model="sonnet45",
                 verbose=False,  # Should suppress output
             )
             output = sys.stdout.getvalue()
@@ -118,13 +120,14 @@ def test_verbose_false_suppresses_output():
 def test_global_state_reset():
     """Test that global state is reset between agent creations."""
     from agentic_python_coder import create_coding_agent
-    from agentic_python_coder.tools import _todos, _reported_issues, _task_basename
+    from agentic_python_coder.tools import _todos, _task_basename
 
     with tempfile.TemporaryDirectory() as tmpdir:
         # Create first agent
         agent1 = create_coding_agent(
             working_directory=tmpdir,
             system_prompt="Test",
+            model="sonnet45",
             task_basename="task1",
         )
 
@@ -132,6 +135,7 @@ def test_global_state_reset():
         agent2 = create_coding_agent(
             working_directory=tmpdir,
             system_prompt="Test",
+            model="sonnet45",
             task_basename="task2",
         )
 

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/coder/tests/test_todo_tool_availability.py

@@ -12,6 +12,7 @@ def test_agent_tools_without_todo():
         agent = create_coding_agent(
             working_directory=tmpdir,
             system_prompt="Test prompt",
+            model="sonnet45",
             todo=False,
         )
         assert agent is not None
@@ -24,6 +25,7 @@ def test_agent_tools_with_todo():
         agent = create_coding_agent(
             working_directory=tmpdir,
             system_prompt="Test prompt",
+            model="sonnet45",
             todo=True,
         )
         assert agent is not None

{agentic_python_coder-2.2.0 → agentic_python_coder-2.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentic-python-coder"
-version = "2.2.0"
+version = "2.2.1"
 description = "A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

agentic_python_coder-2.2.0/examples/cpmpy/README.md

@@ -1,69 +0,0 @@
-# CPMpy Examples
-
-Constraint programming examples using CPMpy for solving combinatorial problems.
-
-## Quick Start
-
-```bash
-# Recommended: Use --with flag (no installation needed)
-coder --with cpmpy --project cpmpy.md n_queens.md
-
-# Alternative: Install CPMpy manually first
-uv pip install cpmpy
-
-# Then solve N-Queens problem
-cd sample_problems
-coder --project ../cpmpy.md n_queens.md
-
-# Solve Magic Square
-coder --project ../cpmpy.md magic_square.md
-```
-
-## What's Included
-
-The `cpmpy.md` project template provides:
-- CPMpy constraint modeling patterns
-- Common constraint types (AllDifferent, Sum, etc.)
-- Solving strategies and optimization techniques
-
-## Sample Problems
-
-- **n_queens.md** - Place N queens on a chessboard
-- **magic_square.md** - Create a magic square with equal sums
-
-## Create Your Own
-
-Write a markdown file with:
-1. Problem description
-2. Input format
-3. Constraints to satisfy
-4. Expected output format
-
-Example:
-```
-# Sudoku Solver
-
-## Problem
-Fill a 9x9 grid with digits 1-9 following standard Sudoku rules.
-
-## Input
-Partial grid with 0 for empty cells
-
-## Constraints
-- Each row contains 1-9
-- Each column contains 1-9
-- Each 3x3 box contains 1-9
-
-## Output
-Completed grid
-```
-
-Then run:
-```bash
-coder --project cpmpy.md your_problem.md
-```
-
-## Resources
-
-- [CPMpy Documentation](https://cpmpy.readthedocs.io/)
-- [CP-Bench Dataset](https://zenodo.org/records/15592407)

agentic_python_coder-2.2.0/examples/cpmpy/cpmpy.md

@@ -1,46 +0,0 @@
-# CPMPY project prompt
-
-You are solving constraint programming problems using CPMpy.
-
-## Core Rules
-
-1. Use CPMpy's constraint modeling - never write search algorithms
-2. Output ONLY valid JSON using `json.dumps()` - no other text
-3. Always `import json` if outputting JSON
-4. Check the exact output format required
-5. Test your solution manually to verify it satisfies the problem
-
-## Basic Template
-```python
-from cpmpy import *
-import json
-
-# Variables
-# Constraints  
-# Solve
-if model.solve():
-    # Build result dict as specified
-    result = {...}
-    # Verify solution satisfies problem requirements
-    print(json.dumps(result))
-else:
-    print(json.dumps({"error": "No solution"}))
-```
-
-## Essential Constraints
-- `AllDifferent(vars)` - all different values
-- `sum(vars) == total` - sum constraint
-- `Circuit(x)` - variables x form a Hamiltonian circuit (for routing/tour problems)
-
-## Optimization
-- Use `model.minimize(objective)` or `model.maximize(objective)`
-- CPMpy automatically finds the OPTIMAL solution, not just first valid
-- The solver continues searching until it proves optimality
-- Always verify the objective value matches your expectation
-- Example:
-  ```python
-  profit = sum(price[i] * x[i] for i in range(n))
-  model.maximize(profit)
-  ```
-
-That's it. Read the problem carefully, model it declaratively, and let CPMpy find the optimal solution.

agentic_python_coder-2.2.0/examples/cpmpy/sample_problems/magic_square.md

@@ -1,46 +0,0 @@
-# Magic Square Problem
-
-## Problem Description
-Fill an n×n grid with distinct integers from 1 to n² such that the sum of numbers in each row, column, and both main diagonals equals the same "magic constant".
-
-## Input Format
-```python
-n = 3  # Size of the square
-```
-
-## Magic Constant
-For an n×n magic square using numbers 1 to n², the magic constant is:
-```
-magic_constant = n * (n² + 1) / 2
-```
-
-## Output Format
-Return a 2D array representing the magic square.
-
-## Example
-For n=3, one solution is:
-```
-2 7 6
-9 5 1
-4 3 8
-```
-Each row, column, and diagonal sums to 15.
-
-## Constraints
-- Use CPMPy for constraint modeling
-- All numbers from 1 to n² must be used exactly once
-- All rows must sum to the magic constant
-- All columns must sum to the magic constant
-- Both diagonals must sum to the magic constant
-
-## Test Cases
-```python
-# n=3: Magic constant = 15
-# n=4: Magic constant = 34
-# n=5: Magic constant = 65
-```
-
-## Implementation Notes
-- Use AllDifferent constraint for uniqueness
-- Consider symmetry breaking to reduce search space
-- For odd n, there are known construction methods, but use constraint solving

agentic_python_coder-2.2.0/examples/cpmpy/sample_problems/n_queens.md

@@ -1,36 +0,0 @@
-# N-Queens Problem
-
-## Problem Description
-Place N queens on an N×N chessboard such that no two queens threaten each other. A queen can attack any piece in the same row, column, or diagonal.
-
-## Input Format
-```python
-n = 8  # Board size
-```
-
-## Output Format
-Return a list of queen positions where position[i] represents the column of the queen in row i.
-
-## Example
-For n=4, one solution is:
-```
-. Q . .
-. . . Q
-Q . . .
-. . Q .
-```
-Represented as: [1, 3, 0, 2]
-
-## Constraints
-- Use CPMPy for constraint modeling
-- All queens must be placed
-- No two queens can be on the same row (automatic from representation)
-- No two queens can be on the same column
-- No two queens can be on the same diagonal
-
-## Test Cases
-```python
-# n=4: Should find solution like [1, 3, 0, 2]
-# n=8: Should find one of 92 possible solutions
-# n=1: Should return [0]
-```