victor-coding 0.13.0__tar.gz → 0.15.0__tar.gz

{victor_coding-0.13.0 → victor_coding-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-coding
-Version: 0.13.0
+Version: 0.15.0
 Summary: Coding vertical for Victor AI - Software development, debugging, and code generation
 Author-email: Vijaykumar Singh <vijay@anvaiops.com>
 Maintainer-email: Vijaykumar Singh <vijay@anvaiops.com>
@@ -18,7 +18,7 @@ Classifier: Topic :: Software Development
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: victor-contracts[yaml]<1.0,>=0.6.0
+Requires-Dist: victor-contracts[yaml]<1.0,>=0.11.0
 Requires-Dist: victor-codegraph[treesitter]>=0.1.0
 Requires-Dist: defusedxml<1.0,>=0.7
 Provides-Extra: runtime
@@ -30,12 +30,12 @@ Provides-Extra: codegraph
 Requires-Dist: victor-codegraph<1.0,>=0.1.0; extra == "codegraph"
 Provides-Extra: dev
 Requires-Dist: numpy<2.6,>=1.24; extra == "dev"
-Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest<9.2,>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
 Requires-Dist: pytest-cov>=4.1; extra == "dev"
 Requires-Dist: pytest-xdist>=3.0; extra == "dev"
 Requires-Dist: pytest-benchmark>=5.0; extra == "dev"
-Requires-Dist: black==26.10.0; extra == "dev"
+Requires-Dist: black==26.10.1; extra == "dev"
 Requires-Dist: ruff>=0.5; extra == "dev"
 Requires-Dist: mypy==2.4.0; extra == "dev"
 Provides-Extra: native-dev

{victor_coding-0.13.0 → victor_coding-0.15.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "victor-coding"
-version = "0.13.0"
+version = "0.15.0"
 description = "Coding vertical for Victor AI - Software development, debugging, and code generation"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -34,7 +34,7 @@ classifiers = [
     "Topic :: Software Development",
 ]
 dependencies = [
-    "victor-contracts[yaml]>=0.6.0,<1.0",  # Definition-layer contract for external verticals
+    "victor-contracts[yaml]>=0.11.0,<1.0",  # Definition-layer contract for external verticals
     "victor-codegraph[treesitter]>=0.1.0",  # Shared code->CPG chunker (ADR-014); [treesitter] supplies the grammars the delegation parses JS/Go/TS/Rust with
     "defusedxml>=0.7,<1.0",  # XXE-hardened XML parsing for coverage reports
 ]
@@ -47,10 +47,10 @@ native = [
     # Compatibility extra. Build the separate distribution from ./native;
     # see native/README.md. Installing this empty extra does not build Rust.
 ]
-# ProximaDB embedding provider (optional backend).
-# Imported lazily with graceful ImportError fallback in
-# victor_coding/codebase/embeddings/proximadb_provider.py. Pin kept identical
-# to victor-ai's proximadb extra so the backend version stays aligned.
+# ProximaDB embedding backend (optional). The provider lives in victor-ai
+# (victor/storage/vector_stores/proximadb_provider.py) and is resolved through
+# victor_contracts.embeddings_runtime; this pass-through extra keeps the pin
+# identical to victor-ai's proximadb extra.
 proximadb = [
     "proximadb>=0.4.1,<0.5",
 ]
@@ -62,12 +62,12 @@ codegraph = [
 ]
 dev = [
     "numpy>=1.24,<2.6",  # Synthetic embeddings in indexer tests
-    "pytest>=8.0",
+    "pytest>=8.0,<9.2",  # pytest 9.2 (2026-10-27) removed Function._nodeid, which pytest-benchmark reads in fixture setup (verticals CI _nodeid AttributeErrors)
     "pytest-asyncio>=0.23",
     "pytest-cov>=4.1",
     "pytest-xdist>=3.0",
     "pytest-benchmark>=5.0",
-    "black==26.10.0",
+    "black==26.10.1",
     "ruff>=0.5",
     "mypy==2.4.0",
 ]
@@ -143,7 +143,7 @@ coding-compaction = "victor_coding.protocols:CodingCompactionProvider"
 [tool.setuptools.packages.find]
 # Auto-discover all `victor_coding*` subpackages. An explicit `packages` list
 # here previously omitted nested subpackages (languages.plugins,
-# codebase.embeddings, codebase.graph, compat, completion.providers,
+# codebase.embeddings, codebase.graph, compat,
 # coverage.parsers, native, performance, refactor.transforms), which silently
 # broke the published wheel (ModuleNotFoundError) while editable installs
 # worked — because the whole source tree is on sys.path under `-e`.
@@ -158,6 +158,11 @@ target-version = [
 ]
 
 [tool.ruff]
+extend-exclude = [
+    # Parser input corpus for the golden tests: data, not code. Editing it
+    # shifts the pinned line numbers.
+    "tests/codebase/goldens/samples",
+]
 line-length = 100
 target-version = "py312"
 
@@ -166,7 +171,6 @@ select = ["E", "W", "F", "B", "C4"]
 ignore = [
     "E501",  # line too long (handled by formatter)
     "E402",  # module level import not at top of file (sometimes necessary)
-    "F401",  # unused imports (often intentional re-exports)
     "F811",  # redefined while unused (type imports shadowing runtime)
     "B007",  # loop control variable not used within loop body
     "B008",  # do not perform function calls in argument defaults

victor_coding-0.15.0/tests/test_coding_handlers.py

@@ -0,0 +1,147 @@
+# Copyright 2026 Vijaykumar Singh <vijay@anvaiops.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pre-move characterization for victor-coding compute handlers (dedup F5).
+
+Pins the observable contract before the envelope is extracted to the shared
+kernel: command construction, output-key handling, the two handlers' DIFFERENT
+failure policies (code_validation always COMPLETED with all_passed inside the
+output; test_runner FAILED when the suite fails), and registration semantics.
+"""
+
+from typing import Any, Dict
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from victor_contracts.testing import MockComputeNode, MockToolResult, MockWorkflowContext
+from victor_coding.handlers import HANDLERS, CodeValidationHandler, TestRunnerHandler
+
+
+def registry(result: MockToolResult) -> MagicMock:
+    r = MagicMock()
+    r.execute = AsyncMock(return_value=result)
+    return r
+
+
+class TestCodeValidationHandler:
+    @pytest.mark.asyncio
+    async def test_lint_check_passes_through_shell_command(self):
+        reg = registry(MockToolResult(success=True, output="clean"))
+        ctx = MockWorkflowContext()
+        node = MockComputeNode(
+            node_id="v1",
+            input_mapping={"files": ["a.py"], "checks": ["lint"]},
+            output_key="validation",
+        )
+        result = await CodeValidationHandler()(node, ctx, reg)
+        cmd = reg.execute.call_args.kwargs["command"]
+        assert cmd == "ruff check a.py"
+        assert result.status.value == "completed"
+        assert ctx.get("validation")["all_passed"] is True
+        assert ctx.get("validation")["checks"]["lint"]["passed"] is True
+
+    @pytest.mark.asyncio
+    async def test_failed_check_still_completes_with_all_passed_false(self):
+        """code_validation's fail policy: COMPLETED status, failure in output."""
+        reg = registry(MockToolResult(success=False, error="E501"))
+        ctx = MockWorkflowContext()
+        node = MockComputeNode(node_id="v2", input_mapping={"files": ["b.py"], "checks": ["lint"]})
+        result = await CodeValidationHandler()(node, ctx, reg)
+        assert result.status.value == "completed"
+        assert ctx.get("v2")["all_passed"] is False
+
+    @pytest.mark.asyncio
+    async def test_unknown_check_passes_with_message(self):
+        reg = registry(MockToolResult(success=True))
+        node = MockComputeNode(
+            node_id="v3", input_mapping={"files": ["x.py"], "checks": ["nonexistent"]}
+        )
+        ctx = MockWorkflowContext()
+        result = await CodeValidationHandler()(node, ctx, reg)
+        assert result.status.value == "completed"
+        assert ctx.get("v3")["checks"]["nonexistent"]["passed"] is True
+
+    @pytest.mark.asyncio
+    async def test_exception_is_contained_per_check(self):
+        """Actual behavior: _run_check catches exceptions and reports them as
+        failed checks — the node still COMPLETES (no outer try/except)."""
+        reg = MagicMock()
+        reg.execute = AsyncMock(side_effect=RuntimeError("boom"))
+        node = MockComputeNode(node_id="v4", input_mapping={"files": ["c.py"]})
+        ctx = MockWorkflowContext()
+        result = await CodeValidationHandler()(node, ctx, reg)
+        assert result.status.value == "completed"
+        assert ctx.get("v4")["all_passed"] is False
+        assert "boom" in ctx.get("v4")["checks"]["lint"]["error"]
+
+
+class TestTestRunnerHandler:
+    @pytest.mark.asyncio
+    async def test_pytest_command_with_coverage(self):
+        reg = registry(MockToolResult(success=True, output="3 passed"))
+        node = MockComputeNode(
+            node_id="t1",
+            input_mapping={"test_path": "tests/", "framework": "pytest", "coverage": True},
+            output_key="test_results",
+        )
+        ctx = MockWorkflowContext()
+        result = await TestRunnerHandler()(node, ctx, reg)
+        cmd = reg.execute.call_args.kwargs["command"]
+        assert cmd == "pytest tests/ -v --cov --cov-report=json"
+        assert result.status.value == "completed"
+        assert ctx.get("test_results")["passed"] is True
+
+    @pytest.mark.asyncio
+    async def test_failed_suite_fails_the_node(self):
+        """test_runner's fail policy: FAILED status on suite failure (unlike
+        code_validation — the kernel must parameterize this)."""
+        reg = registry(MockToolResult(success=False, output="1 failed"))
+        node = MockComputeNode(node_id="t2", input_mapping={"framework": "pytest"})
+        ctx = MockWorkflowContext()
+        result = await TestRunnerHandler()(node, ctx, reg)
+        assert result.status.value == "failed"
+
+    @pytest.mark.asyncio
+    async def test_unittest_framework_command(self):
+        reg = registry(MockToolResult(success=True))
+        node = MockComputeNode(node_id="t3", input_mapping={"framework": "unittest"})
+        ctx = MockWorkflowContext()
+        await TestRunnerHandler()(node, ctx, reg)
+        cmd = reg.execute.call_args.kwargs["command"]
+        assert cmd.startswith("python -m unittest discover")
+
+
+class TestRegistration:
+    def test_handlers_table_and_registrar_signature(self):
+        assert set(HANDLERS) == {"code_validation", "test_runner"}
+        # The UI introspects this signature; the kernel must keep it.
+        import inspect
+
+        from victor_coding.handlers import register_handlers
+
+        params = inspect.signature(register_handlers).parameters
+        assert "registrar" in params
+
+    def test_register_via_explicit_registrar(self):
+        entries: Dict[str, Any] = {}
+
+        class Registrar:
+            def __call__(self, name: str, handler: Any) -> None:
+                entries[name] = handler
+
+        from victor_coding.handlers import register_handlers
+
+        register_handlers(Registrar())
+        assert set(entries) == set(HANDLERS)

{victor_coding-0.13.0 → victor_coding-0.15.0}/tests/test_coding_vertical_workflows.py

@@ -285,3 +285,41 @@ class TestWorkflowIntegration:
                     # Most agent nodes should have allowed_tools
                     # (not all require it, but most do)
                     pass  # Just ensure no crashes
+
+
+class TestSharedEscapeHatches:
+    """Generic hatches come from the framework registry, not a local copy."""
+
+    SHARED = {
+        "complexity_check": "condition",
+        "complexity_assessment": "condition",
+        "format_implementation_plan": "transform",
+    }
+
+    def test_provider_resolves_the_shared_hatches(self):
+        config = CodingWorkflowProvider()._get_config()
+        for name, kind in self.SHARED.items():
+            registry = (
+                config.condition_registry if kind == "condition" else config.transform_registry
+            )
+            assert name in registry, f"{name} missing from the coding workflow {kind}s"
+            assert callable(registry[name])
+
+    def test_refactor_workflow_still_routes_on_complexity(self):
+        """refactor.yaml branches on complexity_assessment."""
+        config = CodingWorkflowProvider()._get_config()
+        assess = config.condition_registry["complexity_assessment"]
+        assert assess({"files_affected": list(range(30))}) in {
+            "high",
+            "complex",
+            "medium",
+            "low",
+            "simple",
+        }
+
+    def test_not_redefined_locally(self):
+        import victor_coding.escape_hatches as local
+
+        for name in self.SHARED:
+            assert not hasattr(local, name), f"{name} copied back into victor_coding.escape_hatches"
+        assert not set(self.SHARED) & (set(local.CONDITIONS) | set(local.TRANSFORMS))

{victor_coding-0.13.0 → victor_coding-0.15.0}/tests/test_enhanced_integration.py

@@ -300,7 +300,7 @@ class TestEnhancedCodingConversationManager:
         manager = EnhancedCodingConversationManager()
 
         assert manager._conversation_coordinator is not None
-        assert isinstance(manager._coding_context, CodingContext)
+        assert isinstance(manager.get_coding_context(), CodingContext)
 
     def test_add_message(self):
         """Test adding a message."""

victor_coding-0.15.0/tests/test_personas.py

@@ -0,0 +1,143 @@
+# Copyright 2026 Vijaykumar Singh <vijay@anvaiops.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pre-move characterization for victor-coding personas (dedup F6).
+
+Coding was the only personas vertical with NO test file. These pin the
+observable contract before the kernel extraction: inventory, trait
+normalization, prompt hints, backstory shape, helper semantics, and explicit-provider
+registration (registration tuples included). Import-time registration was
+removed by FEP-0042.
+"""
+
+from victor_contracts.testing.personas import (
+    assert_explicit_persona_registration,
+    assert_import_registers_no_personas,
+)
+from victor_coding.teams.personas import (
+    CODING_PERSONAS,
+    CodingPersonaTraits,
+    CommunicationStyle,
+    DecisionStyle,
+    apply_persona_to_spec,
+    get_persona,
+    get_persona_by_expertise,
+    get_personas_for_role,
+    list_personas,
+)
+
+
+class TestInventory:
+    def test_eight_personas_with_expected_ids(self):
+        assert set(CODING_PERSONAS) == {
+            "code_archaeologist",
+            "security_auditor",
+            "architect",
+            "refactoring_strategist",
+            "craftsman",
+            "debugger",
+            "quality_guardian",
+            "test_specialist",
+        }
+
+    def test_every_persona_complete(self):
+        for pid, persona in CODING_PERSONAS.items():
+            assert persona.name, pid
+            assert persona.role in ("researcher", "planner", "executor", "reviewer"), pid
+            assert persona.expertise, pid
+            assert persona.strengths, pid
+            assert persona.approach, pid
+
+
+class TestTraits:
+    def test_trait_scales_normalized(self):
+        traits = CodingPersonaTraits(attention_to_detail=2.0, risk_tolerance=-1.0, verbosity=0.5)
+        # values are stored as given (no clamping in the dataclass)
+        assert traits.attention_to_detail == 2.0
+        assert traits.risk_tolerance == -1.0
+
+    def test_prompt_hints_composition(self):
+        traits = CodingPersonaTraits(
+            communication_style=CommunicationStyle.CONCISE,
+            decision_style=DecisionStyle.CONSERVATIVE,
+            attention_to_detail=0.9,
+            risk_tolerance=0.1,
+        )
+        hints = traits.to_prompt_hints()
+        assert "brief" in hints.lower()
+        assert "proven" in hints.lower()
+        assert "edge cases" in hints.lower()
+        assert "thorough testing" in hints.lower()
+
+    def test_framework_traits_mapping(self):
+        traits = CodingPersonaTraits(attention_to_detail=0.8, risk_tolerance=0.4, verbosity=0.6)
+        fw = traits.to_framework_traits(name="X", role="executor", description="d", strengths=["s"])
+        assert fw.risk_tolerance == 0.4
+        assert fw.verbosity == 0.6
+        # coding's mapping: creativity = 1 - attention_to_detail
+        assert abs(fw.creativity - 0.2) < 1e-9
+        assert fw.custom_traits["decision_style"]
+        assert fw.custom_traits["attention_to_detail"] == 0.8
+
+
+class TestPersonaSemantics:
+    def test_get_expertise_list_merges_primary_and_secondary(self):
+        p = get_persona("architect")
+        lst = p.get_expertise_list()
+        assert lst
+        assert all(isinstance(e, str) for e in lst)
+
+    def test_generate_backstory_shape(self):
+        story = get_persona("debugger").generate_backstory()
+        assert story.startswith("You are ")
+        assert "Bug Hunter" in story
+        assert story.endswith(".")
+
+    def test_helpers(self):
+        assert set(list_personas()) == set(CODING_PERSONAS)
+        planners = get_personas_for_role("planner")
+        assert planners
+        assert all(p.role == "planner" for p in planners)
+        found = get_persona_by_expertise(CODING_PERSONAS["architect"].expertise[0])
+        assert found
+
+    def test_apply_persona_to_spec_merges(self):
+        from victor_contracts import TeamMemberSpec
+
+        spec = TeamMemberSpec(role="planner", goal="ship", name="a1")
+        out = apply_persona_to_spec(spec, "architect")
+        # documented contract: same object, enhanced in place
+        assert out is spec
+        assert getattr(spec, "expertise", None) or getattr(spec, "backstory", None)
+        # unknown persona: unchanged spec returned
+        spec2 = TeamMemberSpec(role="planner", goal="ship", name="a2")
+        assert apply_persona_to_spec(spec2, "no_such_persona") is spec2
+
+
+class TestPersonaRegistration:
+    """FEP-0042: personas reach the host through ``get_personas()`` on activation;
+    nothing registers at import, and the explicit-provider helper still works."""
+
+    def test_teams_import_registers_nothing_and_emits_no_deprecation(self):
+        assert_import_registers_no_personas("victor_coding.teams", "victor_coding.teams.personas")
+
+    def test_explicit_provider_helper_registers_every_persona_without_warning(self):
+        from victor_coding.teams.personas import _register_personas_with_framework
+
+        calls = assert_explicit_persona_registration(
+            _register_personas_with_framework, CODING_PERSONAS, "coding"
+        )
+        debugger = next(c for c in calls if c["name"] == "debugger")
+        assert debugger["category"] == "execution"
+        assert debugger["tags"] == ["debugging", "troubleshooting", "root-cause"]

victor_coding-0.15.0/tests/test_protocol_providers.py

@@ -0,0 +1,68 @@
+# Copyright 2026 Vijaykumar Singh <vijay@anvaiops.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pre-move characterization for victor-coding protocol providers (dedup F3)."""
+
+from victor_coding.protocols import (
+    CodingPromptProvider,
+    CodingSafetyProvider,
+    CodingToolProvider,
+    CodingToolSelectionStrategy,
+    CodingWorkflowProvider,
+)
+
+
+class TestCodingToolProvider:
+    def test_tool_list_contract(self):
+        tools = CodingToolProvider().get_tools()
+        assert len(tools) == len(set(tools)), "duplicate tools"
+        for expected in ("read", "write", "shell", "grep", "code_search"):
+            assert expected in tools
+
+    def test_selection_strategy_stage_and_fallback(self):
+        strategy = CodingToolSelectionStrategy()
+        assert "grep" in strategy.get_tools_for_stage("understand", "coding")
+        # stage map membership (order is nondeterministic — set-built)
+        assert set(strategy.get_tools_for_stage("implement", "coding")) == {
+            "write", "shell", "edit",
+        }
+        # coding's fallback is [] (plus any task-type enhancements) — NOT the
+        # devops [read, shell]; per-vertical fallback is kernel data.
+        assert strategy.get_tools_for_stage("unknown_stage", "any") == []
+
+
+class TestCodingSafetyProvider:
+    def test_extension_backed_surface(self):
+        provider = CodingSafetyProvider()
+        # coding's provider is extension-backed (not the devops pattern shape)
+        assert isinstance(provider.get_extensions(), list)
+        assert isinstance(provider.get_bash_patterns(), list)
+        assert isinstance(provider.get_file_patterns(), list)
+        assert isinstance(provider.get_tool_restrictions(), dict)
+
+
+class TestCodingPromptAndWorkflowProviders:
+    def test_prompt_sections(self):
+        sections = CodingPromptProvider().get_system_prompt_sections()
+        assert isinstance(sections, dict) and sections
+        assert isinstance(CodingPromptProvider().get_prompt_contributors(), list)
+
+    def test_workflow_registry(self):
+        provider = CodingWorkflowProvider()
+        names = provider.list_workflows()
+        assert names == list(provider.get_workflows().keys())
+        assert sorted(names) == sorted(set(names)), "duplicate workflow names"
+        for name in names:
+            assert provider.get_workflow(name) is not None
+        assert provider.get_workflow("no_such_workflow") is None

{victor_coding-0.13.0 → victor_coding-0.15.0}/victor_coding/assistant.py

@@ -498,7 +498,7 @@ You have access to 45+ tools. Use them efficiently to accomplish tasks."""
             def _load_editor():
                 import importlib
 
-                mod = importlib.import_module("victor_coding.editing.editor")
+                mod = importlib.import_module("victor_coding.editing")
                 return mod.FileEditor()
 
             registrations.append((EditorProtocol, create_lazy_capability_proxy(_load_editor)))