auto-coder 0.1.352__tar.gz → 0.1.353__tar.gz

{auto_coder-0.1.352 → auto_coder-0.1.353}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.352
+Version: 0.1.353
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.352 → auto_coder-0.1.353}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.352
+Version: 0.1.353
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.352 → auto_coder-0.1.353}/src/auto_coder.egg-info/SOURCES.txt

@@ -135,6 +135,7 @@ src/autocoder/common/v2/agent/agentic_edit_tools/plan_mode_respond_tool_resolver
 src/autocoder/common/v2/agent/agentic_edit_tools/read_file_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/replace_in_file_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/search_files_tool_resolver.py
+src/autocoder/common/v2/agent/agentic_edit_tools/test_search_files_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/use_mcp_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/write_to_file_tool_resolver.py
 src/autocoder/compilers/__init__.py

{auto_coder-0.1.352 → auto_coder-0.1.353}/src/autocoder/common/git_utils.py

@@ -64,7 +64,7 @@ def commit_changes(repo_path: str, message: str) -> CommitResult:
     try:
         repo.git.add(all=True)
         if repo.is_dirty():
-            commit = repo.index.commit(message)
+            commit = repo.index.commit(message,skip_hooks=True)
             result = CommitResult(
                 success=True,
                 commit_message=message,

{auto_coder-0.1.352 → auto_coder-0.1.353}/src/autocoder/common/v2/agent/agentic_edit.py

@@ -1177,6 +1177,8 @@ Below are some files the user is focused on, and the content is up to date. Thes
                 # If no event was processed in this iteration, break inner loop
                 if not found_event:
                     break
+        
+        yield TokenUsageEvent(usage=meta_holder.meta)        
 
         # After generator exhausted, yield any remaining content
         if in_thinking_block:
@@ -1440,6 +1442,37 @@ Below are some files the user is focused on, and the content is up to date. Thes
             self.apply_pre_changes()
             event_stream = self.analyze(request)
             for event in event_stream:
+                if isinstance(event, TokenUsageEvent):
+                    last_meta: SingleOutputMeta = event.usage
+                    # Get model info for pricing
+                    from autocoder.utils import llms as llm_utils
+                    model_name = ",".join(llm_utils.get_llm_names(self.llm))
+                    model_info = llm_utils.get_model_info(
+                        model_name, self.args.product_mode) or {}
+                    input_price = model_info.get(
+                        "input_price", 0.0) if model_info else 0.0
+                    output_price = model_info.get(
+                        "output_price", 0.0) if model_info else 0.0
+
+                    # Calculate costs
+                    input_cost = (last_meta.input_tokens_count *
+                                  input_price) / 1000000  # Convert to millions
+                    # Convert to millions
+                    output_cost = (
+                        last_meta.generated_tokens_count * output_price) / 1000000
+
+                    self.printer.print_in_terminal(
+                            "code_generation_complete",
+                            duration=0.0,
+                            input_tokens=last_meta.input_tokens_count,
+                            output_tokens=last_meta.generated_tokens_count,
+                            input_cost=input_cost,
+                            output_cost=output_cost,
+                            speed=0.0,
+                            model_names=model_name,
+                            sampling_count=1
+                        )
+                    
                 if isinstance(event, LLMThinkingEvent):
                     # Render thinking within a less prominent style, maybe grey?
                     console.print(f"[grey50]{event.text}[/grey50]", end="")

auto_coder-0.1.353/src/autocoder/common/v2/agent/agentic_edit_tools/test_search_files_tool_resolver.py

@@ -0,0 +1,163 @@
+import pytest
+import os
+import tempfile
+import shutil
+from unittest.mock import patch, MagicMock
+
+from autocoder.common.v2.agent.agentic_edit_tools.search_files_tool_resolver import SearchFilesToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import SearchFilesTool, ToolResult
+from autocoder.common import AutoCoderArgs
+
+# Helper function to create a directory structure with files for testing
+def create_test_files(base_dir, structure):
+    """
+    Creates a directory structure with files based on the provided dictionary.
+    Keys are filenames (relative to base_dir), values are file contents.
+    Directories are created automatically.
+    """
+    for path, content in structure.items():
+        full_path = os.path.join(base_dir, path)
+        os.makedirs(os.path.dirname(full_path), exist_ok=True)
+        with open(full_path, 'w') as f:
+            f.write(content)
+
+@pytest.fixture
+def search_tool_resolver(temp_search_dir):
+    """Fixture to provide an instance of SearchFilesToolResolver."""
+    # Create AutoCoderArgs with the temp directory as source_dir to allow the security check to pass
+    args = AutoCoderArgs()
+    args.source_dir = temp_search_dir  # Set the source_dir to our temp directory
+    return SearchFilesToolResolver(None, SearchFilesTool(path="", regex=""), args)
+
+@pytest.fixture(scope="function")
+def temp_search_dir():
+    """Fixture to create a temporary directory with test files for searching."""
+    temp_dir = tempfile.mkdtemp()
+    test_structure = {
+        "file1.txt": "Hello world\nThis is a test file.",
+        "subdir/file2.py": "import sys\n\ndef main():\n    print('Python script')\n",
+        "subdir/another.txt": "Another text file with world.",
+        ".hiddenfile": "This should be ignored by default",
+        "no_match.md": "Markdown file."
+    }
+    create_test_files(temp_dir, test_structure)
+    yield temp_dir # Provide the path to the test function
+    shutil.rmtree(temp_dir) # Cleanup after test
+
+# --- Test Cases ---
+
+def test_resolve_finds_matches(search_tool_resolver, temp_search_dir):
+    """Test that resolve finds matches correctly."""
+    # Set up the tool with the pattern we want to search for
+    tool = SearchFilesTool(
+        path="",  # Use empty path to search in the source_dir itself
+        regex="world",
+        file_pattern="*.txt"
+    )
+    search_tool_resolver.tool = tool
+
+    # Call the resolve method directly
+    response = search_tool_resolver.resolve()
+
+    # Check the response
+    assert isinstance(response, ToolResult)
+    assert response.success
+    assert "Search completed. Found 2 matches" in response.message
+    
+    # Check that the correct files were found
+    assert len(response.content) == 2
+    paths = [result["path"] for result in response.content]
+    assert any("file1.txt" in path for path in paths)
+    assert any("another.txt" in path for path in paths)
+    
+    # Check that the match lines contain our search pattern
+    for result in response.content:
+        assert "world" in result["match_line"]
+
+def test_resolve_no_matches(search_tool_resolver, temp_search_dir):
+    """Test that resolve handles no matches correctly."""
+    tool = SearchFilesTool(
+        path="",  # Use empty path to search in the source_dir itself
+        regex="nonexistent_pattern",
+        file_pattern="*"
+    )
+    search_tool_resolver.tool = tool
+
+    response = search_tool_resolver.resolve()
+
+    assert isinstance(response, ToolResult)
+    assert response.success  # Still success, just no results
+    assert "Search completed. Found 0 matches" in response.message
+    assert len(response.content) == 0
+
+def test_resolve_file_pattern(search_tool_resolver, temp_search_dir):
+    """Test that the file_pattern is correctly applied."""
+    # Test .txt pattern
+    tool_txt = SearchFilesTool(
+        path="",  # Use empty path to search in the source_dir itself
+        regex="world",
+        file_pattern="*.txt"  # Only search .txt files
+    )
+    search_tool_resolver.tool = tool_txt
+    
+    response_txt = search_tool_resolver.resolve()
+    
+    assert isinstance(response_txt, ToolResult)
+    assert response_txt.success
+    assert "Search completed. Found 2 matches" in response_txt.message
+    # Ensure only .txt files were matched
+    for result in response_txt.content:
+        assert result["path"].endswith(".txt")
+    
+    # Test .py pattern
+    tool_py = SearchFilesTool(
+        path="",  # Use empty path to search in the source_dir itself
+        regex="print",
+        file_pattern="*.py"  # Only search .py files
+    )
+    search_tool_resolver.tool = tool_py
+    
+    response_py = search_tool_resolver.resolve()
+    
+    assert isinstance(response_py, ToolResult)
+    assert response_py.success
+    assert "Search completed. Found 1 matches" in response_py.message
+    # Ensure only .py files were matched
+    for result in response_py.content:
+        assert result["path"].endswith(".py")
+
+def test_invalid_regex(search_tool_resolver, temp_search_dir):
+    """Test that an invalid regex pattern is properly handled."""
+    tool = SearchFilesTool(
+        path="",  # Use empty path to search in the source_dir itself
+        regex="[invalid regex",  # Invalid regex pattern
+        file_pattern="*"
+    )
+    search_tool_resolver.tool = tool
+
+    response = search_tool_resolver.resolve()
+
+    assert isinstance(response, ToolResult)
+    assert not response.success
+    assert "Invalid regex pattern" in response.message
+
+def test_nonexistent_path(search_tool_resolver, temp_search_dir):
+    """Test that a nonexistent path is properly handled."""
+    # Create a path that we know doesn't exist under temp_search_dir
+    nonexistent_path = "nonexistent_subdirectory"
+    
+    tool = SearchFilesTool(
+        path=nonexistent_path,  # This path doesn't exist in our temp directory
+        regex="pattern",
+        file_pattern="*"
+    )
+    search_tool_resolver.tool = tool
+
+    response = search_tool_resolver.resolve()
+
+    assert isinstance(response, ToolResult)
+    assert not response.success
+    assert "Error: Search path not found" in response.message
+
+# Add more tests as needed
+

auto_coder-0.1.353/src/autocoder/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.353"

auto_coder-0.1.352/src/autocoder/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.352"