devagent-ai 0.8.1__tar.gz → 0.8.2__tar.gz

{devagent_ai-0.8.1/devagent_ai.egg-info → devagent_ai-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-ai
-Version: 0.8.1
+Version: 0.8.2
 Summary: Evidence-driven local autonomous software engineering agent
 Author: Tom Ha
 Maintainer: Tom Ha

{devagent_ai-0.8.1 → devagent_ai-0.8.2}/devagent/__init__.py

@@ -1,3 +1,3 @@
 """DevAgent: evidence-driven local software engineering automation."""
 
-__version__ = "0.8.1"
+__version__ = "0.8.2"

{devagent_ai-0.8.1 → devagent_ai-0.8.2}/devagent/tasking.py

@@ -63,6 +63,18 @@ _DIRECTIVE = re.compile(
     re.IGNORECASE,
 )
 
+# Bounded normalization for terse user intent. This is deliberately not a fuzzy
+# "guess what the user meant" layer: it corrects common engineering shorthand,
+# grammatical number, and operation wording while preserving identifiers,
+# quoted contracts, values, and explicit constraints. Task policy and repository
+# evidence still provide the verification/safety contract.
+_OPERATION_ALIASES: tuple[tuple[str, str], ...] = (
+    ("substraction", "subtraction"),
+    ("substract", "subtract"),
+    ("multipy", "multiply"),
+    ("mutiply", "multiply"),
+)
+
 
 def _classify(text: str) -> TaskType:
     lowered = text.lower()
@@ -98,6 +110,60 @@ def _dedupe(items: list[str]) -> list[str]:
     return result
 
 
+def _normalize_terse_requirement(requirement: str) -> str:
+    """Compile common rough one-line prompts into a clearer engineering request.
+
+    The compiler is intentionally bounded. It may repair shorthand/grammar and
+    make an operation explicit, but it must not add product behavior the user did
+    not request. Structured/multi-line requirements are left intact.
+    """
+
+    value = re.sub(r"\s+", " ", requirement).strip()
+    if not value or "\n" in requirement or _section_header(value) is not None:
+        return value
+    # An explicit callable name is already a precise user contract; never rename it.
+    if re.search(r"\b[A-Za-z_][A-Za-z0-9_]*\s*\(", value):
+        return value
+
+    for source, destination in _OPERATION_ALIASES:
+        value = re.sub(rf"\b{re.escape(source)}\b", destination, value, flags=re.IGNORECASE)
+
+    # Common shorthand from natural prompts such as "addition 2 matrix 2x2".
+    # Keep both "matrix" and "matrices" in the normalized contract so
+    # deterministic evidence can link either conventional symbol spelling.
+    matrix_match = re.search(
+        r"\b(add(?:ition)?|sum|subtract(?:ion)?|multiply|multiplication|divide|division)\b"
+        r"(?:\s+(?:of|for))?\s+(?:2|two)\s+matrix(?:es)?\s+(\d+x\d+)\b",
+        value,
+        flags=re.IGNORECASE,
+    )
+    if matrix_match:
+        operation = matrix_match.group(1).lower()
+        dimension = matrix_match.group(2).lower()
+        canonical_operation = {
+            "add": "addition",
+            "addition": "addition",
+            "sum": "addition",
+            "subtract": "subtraction",
+            "subtraction": "subtraction",
+            "multiply": "multiplication",
+            "multiplication": "multiplication",
+            "divide": "division",
+            "division": "division",
+        }[operation]
+        prefix = "Add" if re.search(r"\b(add|new|function|implement)\b", value, re.IGNORECASE) else "Implement"
+        return (
+            f"{prefix} a matrix {canonical_operation} function for two {dimension} matrices "
+            f"(matrix inputs)"
+        )
+
+    # Repair simple count+noun shorthand without inventing domain behavior.
+    value = re.sub(r"\b2\s+matrix\b", "two matrices", value, flags=re.IGNORECASE)
+    value = re.sub(r"\b2\s+file\b", "two files", value, flags=re.IGNORECASE)
+    value = re.sub(r"\b2\s+test\b", "two tests", value, flags=re.IGNORECASE)
+    return value
+
+
 def _section_header(line: str) -> tuple[str, str] | None:
     stripped = line.strip()
     markdown = re.match(r"^#{1,6}\s+(.+?)\s*$", stripped)
@@ -182,15 +248,21 @@ def _append_criterion(
 
 
 def compile_task(requirement: str) -> TaskSpec:
-    goal = re.sub(r"\s+", " ", requirement).strip()
-    if not goal:
+    raw_goal = re.sub(r"\s+", " ", requirement).strip()
+    if not raw_goal:
         raise ValueError("Engineering requirement cannot be empty")
+    goal = _normalize_terse_requirement(requirement)
     task_type = _classify(goal)
     code_change = task_type is not TaskType.UNIT_TEST or "only" not in goal.lower()
     requires_tests = task_type is not TaskType.BUILD_FAILURE
 
     criteria: list[AcceptanceCriterion] = []
-    for item in _user_acceptance_items(requirement):
+    # Structured user requirements remain authoritative. Only an unstructured,
+    # terse prompt is compiled into the clearer canonical request.
+    user_items = _user_acceptance_items(requirement)
+    if len(user_items) == 1 and user_items[0] == raw_goal and goal != raw_goal:
+        user_items = [goal]
+    for item in user_items:
         _append_criterion(criteria, item, source=AcceptanceSource.USER)
 
     if task_type in {TaskType.BUG_FIX, TaskType.RUNTIME_ERROR, TaskType.TEST_FAILURE}:
@@ -240,9 +312,61 @@ def compile_task(requirement: str) -> TaskSpec:
     )
 
 
+def _repository_language(repository: Any) -> str | None:
+    languages = [
+        language.lower()
+        for component in repository.components
+        for language in component.languages
+    ]
+    for preferred in ("python", "java", "csharp", "c#", "javascript", "typescript", "go", "rust"):
+        if preferred in languages:
+            return preferred
+    return languages[0] if languages else None
+
+
+def _matrix_operation_contract(task: TaskSpec, repository: Any) -> None:
+    """Turn the bounded matrix shorthand compiler output into a repo-style callable contract."""
+
+    match = re.fullmatch(
+        r"(?:Add|Implement) a matrix (addition|subtraction|multiplication|division) "
+        r"function for two (\d+x\d+) matrices \(matrix inputs\)",
+        task.goal,
+    )
+    if match is None:
+        return
+
+    operation, dimension = match.groups()
+    verb = {
+        "addition": "add",
+        "subtraction": "subtract",
+        "multiplication": "multiply",
+        "division": "divide",
+    }[operation]
+    compact_dimension = dimension.replace("x", "x")
+    language = _repository_language(repository)
+    if language in {"java", "javascript", "typescript"}:
+        symbol = f"{verb}Matrices{compact_dimension}"
+    elif language in {"csharp", "c#"}:
+        symbol = f"{verb.capitalize()}Matrices{compact_dimension}"
+    else:
+        symbol = f"{verb}_matrices_{compact_dimension}"
+
+    compiled = (
+        f"Add {symbol}(a, b) to perform element-wise matrix {operation} "
+        f"for two {dimension} matrices"
+    )
+    task.goal = compiled
+    user_criteria = [
+        criterion for criterion in task.acceptance_criteria if criterion.source is AcceptanceSource.USER
+    ]
+    if len(user_criteria) == 1:
+        user_criteria[0].description = compiled
+
+
 def enrich_acceptance_contract(task: TaskSpec, repository: Any) -> TaskSpec:
-    """Add checks derived from trusted repository capabilities without replacing user intent."""
+    """Compile safe repository-aware defaults, then add trusted repository checks."""
 
+    _matrix_operation_contract(task, repository)
     seen_commands: set[tuple[str, ...]] = set()
     for capability in repository.capabilities:
         if not capability.trusted:

{devagent_ai-0.8.1 → devagent_ai-0.8.2/devagent_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-ai
-Version: 0.8.1
+Version: 0.8.2
 Summary: Evidence-driven local autonomous software engineering agent
 Author: Tom Ha
 Maintainer: Tom Ha

{devagent_ai-0.8.1 → devagent_ai-0.8.2}/devagent_ai.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ tests/test_preservation_contradiction.py
 tests/test_production_hardening.py
 tests/test_production_v040.py
 tests/test_realworld_benchmark.py
+tests/test_requirement_compiler_v082.py
 tests/test_retrieval.py
 tests/test_runtime_sandbox.py
 tests/test_safety_workspace.py

{devagent_ai-0.8.1 → devagent_ai-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devagent-ai"
-version = "0.8.1"
+version = "0.8.2"
 description = "Evidence-driven local autonomous software engineering agent"
 readme = "README.md"
 requires-python = ">=3.10"

{devagent_ai-0.8.1 → devagent_ai-0.8.2}/tests/test_production_v040.py

@@ -62,7 +62,7 @@ def test_release_version_is_semver_and_consistent() -> None:
     version = match.group(1)
     assert re.fullmatch(r"\d+\.\d+\.\d+", version)
     assert version == __version__
-    assert version == "0.8.1"
+    assert version == "0.8.2"
 
 
 def test_release_workflow_requires_green_exact_main_revision() -> None:

devagent_ai-0.8.2/tests/test_requirement_compiler_v082.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from devagent.models import (
+    AcceptanceSource,
+    AcceptanceStatus,
+    Capability,
+    CapabilityProvenance,
+    ChangeMetrics,
+    CodeSymbol,
+    Component,
+    DeveloperReviewEvidence,
+    Evidence,
+    RepositoryModel,
+    ReviewDecision,
+    TaskType,
+    Understanding,
+    VerificationResult,
+)
+from devagent.orchestrator import _support_acceptance_criteria
+from devagent.tasking import compile_task, enrich_acceptance_contract
+
+
+def _repo(language: str = "python") -> RepositoryModel:
+    return RepositoryModel(
+        root="/repo",
+        kind="single-component",
+        components=[
+            Component(
+                path=".",
+                languages=[language],
+                capabilities=[
+                    Capability(
+                        kind="test",
+                        command=("python", "-m", "pytest", "-q"),
+                        source="pyproject.toml",
+                        provenance=CapabilityProvenance.EXPLICIT,
+                    )
+                ],
+            )
+        ],
+        facts=[],
+        git_head="abc",
+    )
+
+
+def _result(command: tuple[str, ...], *, tests: int | None = None) -> VerificationResult:
+    return VerificationResult(
+        command=command,
+        exit_code=0,
+        duration_seconds=0.1,
+        stdout="passed",
+        stderr="",
+        classification=None,
+        revision=2,
+        phase="final",
+        tests_run=tests,
+        tests_passed=tests,
+    )
+
+
+def test_rough_matrix_prompt_becomes_precise_python_contract() -> None:
+    task = compile_task("add new function addition 2 matrix 2x2")
+    assert task.task_type is TaskType.FEATURE
+    assert task.goal == "Add a matrix addition function for two 2x2 matrices (matrix inputs)"
+
+    enrich_acceptance_contract(task, _repo())
+    assert task.goal == (
+        "Add add_matrices_2x2(a, b) to perform element-wise matrix addition "
+        "for two 2x2 matrices"
+    )
+    user = [item for item in task.acceptance_criteria if item.source is AcceptanceSource.USER]
+    assert [item.description for item in user] == [task.goal]
+
+
+def test_requirement_compiler_preserves_explicit_user_callable() -> None:
+    requirement = "Add matrix_sum(a, b) for two 2x2 matrices"
+    task = compile_task(requirement)
+    enrich_acceptance_contract(task, _repo())
+    assert task.goal == requirement
+    user = [item for item in task.acceptance_criteria if item.source is AcceptanceSource.USER]
+    assert [item.description for item in user] == [requirement]
+
+
+def test_common_typo_is_compiled_without_inventing_behavior() -> None:
+    task = compile_task("add new function substraction 2 matrix 2x2")
+    enrich_acceptance_contract(task, _repo())
+    assert task.goal == (
+        "Add subtract_matrices_2x2(a, b) to perform element-wise matrix subtraction "
+        "for two 2x2 matrices"
+    )
+    assert "mutation" not in task.goal.lower()
+    assert "invalid" not in task.goal.lower()
+
+
+def test_repository_language_selects_conventional_java_callable() -> None:
+    task = compile_task("add new function addition 2 matrix 2x2")
+    enrich_acceptance_contract(task, _repo("java"))
+    assert "addMatrices2x2(a, b)" in task.goal
+
+
+def test_compiled_matrix_contract_links_to_exact_final_symbol_and_tests() -> None:
+    task = compile_task("add new function addition 2 matrix 2x2")
+    repository = _repo()
+    enrich_acceptance_contract(task, repository)
+
+    pytest_result = _result(("python", "-m", "pytest", "-q"), tests=3)
+    diff_check = _result(("git", "diff", "--check"))
+    understanding = Understanding(
+        problem="Matrix addition is missing.",
+        expected_behavior="Add two 2x2 matrices element by element.",
+        affected_paths=["calculator.py", "test_calculator.py"],
+        root_cause="No matrix addition function exists.",
+        evidence=[Evidence("calculator.py contains only existing calculator operations.", ("calculator.py",), 1.0)],
+        proposed_solution=["Add the compiled matrix function and regression tests."],
+        confidence=1.0,
+    )
+    review_evidence = DeveloperReviewEvidence(
+        changed_symbols=[CodeSymbol("calculator.py", "add_matrices_2x2", "function", 5, "ADDED")],
+        test_cases=[
+            CodeSymbol("test_calculator.py", "test_add_matrices_2x2", "function", 8, "ADDED"),
+            CodeSymbol("test_calculator.py", "test_add_matrices_2x2_negative", "function", 12, "ADDED"),
+        ],
+        test_files=["test_calculator.py"],
+    )
+    _support_acceptance_criteria(
+        task,
+        repository,
+        understanding,
+        ChangeMetrics(2, 20, 0, ["calculator.py", "test_calculator.py"]),
+        [pytest_result, diff_check],
+        [pytest_result, diff_check],
+        ReviewDecision(True, [], "approved"),
+        review_evidence,
+        ["Added the compiled 2x2 matrix addition function and tests"],
+        "+def add_matrices_2x2(a, b):\n+    return [[a[r][c] + b[r][c] for c in range(2)] for r in range(2)]\n",
+    )
+
+    required = [item for item in task.acceptance_criteria if item.required]
+    assert required
+    assert all(item.status is AcceptanceStatus.SATISFIED for item in required)
+    user = [item for item in required if item.source is AcceptanceSource.USER]
+    assert user[0].evidence
+    assert any("add_matrices_2x2" in item for item in user[0].evidence)
+
+
+def test_compiled_contract_does_not_accept_wrong_operation() -> None:
+    task = compile_task("add new function addition 2 matrix 2x2")
+    repository = _repo()
+    enrich_acceptance_contract(task, repository)
+
+    pytest_result = _result(("python", "-m", "pytest", "-q"), tests=3)
+    diff_check = _result(("git", "diff", "--check"))
+    understanding = Understanding(
+        problem="Matrix addition is missing.",
+        expected_behavior="Add two 2x2 matrices element by element.",
+        affected_paths=["calculator.py", "test_calculator.py"],
+        root_cause="No matrix addition function exists.",
+        evidence=[Evidence("calculator.py contains the current calculator implementation.", ("calculator.py",), 1.0)],
+        proposed_solution=["Add matrix behavior and tests."],
+        confidence=1.0,
+    )
+    wrong_review_evidence = DeveloperReviewEvidence(
+        changed_symbols=[CodeSymbol("calculator.py", "subtract_matrices_2x2", "function", 5, "ADDED")],
+        test_cases=[
+            CodeSymbol("test_calculator.py", "test_subtract_matrices_2x2", "function", 8, "ADDED"),
+        ],
+        test_files=["test_calculator.py"],
+    )
+    _support_acceptance_criteria(
+        task,
+        repository,
+        understanding,
+        ChangeMetrics(2, 12, 0, ["calculator.py", "test_calculator.py"]),
+        [pytest_result, diff_check],
+        [pytest_result, diff_check],
+        ReviewDecision(True, [], "approved"),
+        wrong_review_evidence,
+        ["Added a matrix function and tests"],
+        "+def subtract_matrices_2x2(a, b):\n+    return [[a[r][c] - b[r][c] for c in range(2)] for r in range(2)]\n",
+    )
+
+    user = [item for item in task.acceptance_criteria if item.source is AcceptanceSource.USER]
+    assert user[0].status is AcceptanceStatus.UNPROVEN
+    assert user[0].evidence == []
+    assert "semantically matches" in (user[0].reason or "")