victor-coding 0.7.1__tar.gz → 0.7.2__tar.gz

{victor_coding-0.7.1 → victor_coding-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-coding
-Version: 0.7.1
+Version: 0.7.2
 Summary: Coding vertical for Victor AI - Software development, debugging, and code generation
 Author-email: Vijaykumar Singh <singhvjd@gmail.com>
 Maintainer-email: Vijaykumar Singh <singhvjd@gmail.com>
@@ -24,7 +24,7 @@ Requires-Dist: numpy<2.3,>=1.24
 Requires-Dist: victor-codegraph[treesitter]>=0.1.0
 Requires-Dist: defusedxml<1.0,>=0.7
 Provides-Extra: runtime
-Requires-Dist: victor-ai<1.0,>=0.6.0; extra == "runtime"
+Requires-Dist: victor-ai<1.0,>=0.7.6; extra == "runtime"
 Provides-Extra: native
 Provides-Extra: proximadb
 Requires-Dist: proximadb<0.3,>=0.2; extra == "proximadb"
@@ -106,4 +106,4 @@ Apache License 2.0 - see [LICENSE](LICENSE) for details.
 
 - **Victor AI**: https://github.com/vijay-singh/codingagent
 - **Documentation**: https://docs.victor.dev/verticals/coding
-- **Victor Registry**: https://github.com/vjsingh1984/victor-registry
+- **Victor Registry**: https://github.com/anvai-labs/victor-registry

{victor_coding-0.7.1 → victor_coding-0.7.2}/README.md

@@ -61,4 +61,4 @@ Apache License 2.0 - see [LICENSE](LICENSE) for details.
 
 - **Victor AI**: https://github.com/vijay-singh/codingagent
 - **Documentation**: https://docs.victor.dev/verticals/coding
-- **Victor Registry**: https://github.com/vjsingh1984/victor-registry
+- **Victor Registry**: https://github.com/anvai-labs/victor-registry

{victor_coding-0.7.1 → victor_coding-0.7.2}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "victor-coding"
-version = "0.7.1"
+version = "0.7.2"
 description = "Coding vertical for Victor AI - Software development, debugging, and code generation"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -43,7 +43,7 @@ dependencies = [
 
 [project.optional-dependencies]
 runtime = [
-    "victor-ai>=0.6.0,<1.0",  # Runtime support - optional, contract-first architecture
+    "victor-ai>=0.7.6,<1.0",  # Runtime support - optional, contract-first architecture
 ]
 native = [
     # Native extensions are handled by maturin
@@ -142,25 +142,16 @@ coding-hooks = "victor_coding.protocols:CodingHookProvider"
 [project.entry-points."victor.compaction.providers"]
 coding-compaction = "victor_coding.protocols:CodingCompactionProvider"
 
-[tool.setuptools]
-packages = [
-    "victor_coding",
-    "victor_coding.api",
-    "victor_coding.codebase",
-    "victor_coding.completion",
-    "victor_coding.coverage",
-    "victor_coding.docgen",
-    "victor_coding.editing",
-    "victor_coding.languages",
-    "victor_coding.lsp",
-    "victor_coding.refactor",
-    "victor_coding.review",
-    "victor_coding.rl",
-    "victor_coding.teams",
-    "victor_coding.testgen",
-    "victor_coding.tools",
-    "victor_coding.workflows",
-]
+[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,
+# 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`.
+# Discovery makes the wheel match the source tree by construction.
+include = ["victor_coding*"]
+exclude = ["tests*", "docs*", "native*"]
 
 [tool.black]
 line-length = 100

{victor_coding-0.7.1 → victor_coding-0.7.2}/tests/test_api_router_provider.py

@@ -22,7 +22,8 @@ else:
     get_fastapi_router_provider = None
 
 pytestmark = pytest.mark.skipif(
-    not FASTAPI_AVAILABLE, reason="FastAPI not installed. Install with: pip install fastapi"
+    not FASTAPI_AVAILABLE,
+    reason="FastAPI not installed. Install with: pip install fastapi",
 )
 
 

{victor_coding-0.7.1 → victor_coding-0.7.2}/tests/test_extension_cache.py

@@ -655,7 +655,9 @@ class TestVerticalLoaderObservabilityEvents:
         assert "stats" in data
 
     @pytest.mark.asyncio
-    async def test_discover_verticals_async_concurrent_cache_hit_telemetry_is_correct(self):
+    async def test_discover_verticals_async_concurrent_cache_hit_telemetry_is_correct(
+        self,
+    ):
         """Concurrent async discovery should report one miss and one cache hit."""
         loader = VerticalLoader()
         emitted = []

victor_coding-0.7.2/tests/test_framework_lsp_adapter.py

@@ -0,0 +1,198 @@
+# Copyright 2026 Vijaykumar Singh <singhvjd@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+
+"""Tests for the framework LSP adapter (victor-coding → FEP-0019 activation).
+
+The adapter bridges victor-coding's ``LSPConnectionPool`` (display dicts +
+``victor_contracts`` types) to the LSP shape the FEP-0019 framework runtime
+duck-types, so the diagnostic middleware + symbol context provider activate.
+Uses a mock pool (no live language server).
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import List
+
+import pytest
+
+from victor_contracts.lsp_runtime import (
+    Diagnostic,
+    DiagnosticSeverity,
+    DocumentSymbol,
+    Position,
+    Range,
+    SymbolKind,
+)
+
+
+def _ds(name: str, kind: SymbolKind, children=None, detail=None) -> DocumentSymbol:
+    r = Range(start=Position(line=1, character=0), end=Position(line=9, character=0))
+    sel = Range(start=Position(line=1, character=6), end=Position(line=1, character=6))
+    return DocumentSymbol(
+        name=name,
+        kind=kind,
+        range=r,
+        selection_range=sel,
+        detail=detail,
+        children=children or [],
+    )
+
+
+class _MockPool:
+    """Stand-in for LSPConnectionPool returning controlled data."""
+
+    def __init__(self, symbols=None):
+        self._symbols = symbols or []
+        self.calls: List[tuple] = []
+
+    async def open_document(self, file_path: str, text=None) -> bool:
+        self.calls.append(("open_document", file_path))
+        return True
+
+    async def update_document(self, file_path: str, text: str) -> bool:
+        self.calls.append(("update_document", file_path))
+        return True
+
+    def close_document(self, file_path: str) -> None:
+        self.calls.append(("close_document", file_path))
+
+    def get_diagnostics(self, file_path: str):
+        # Match the pool's real shape: severity as STRING, line 1-indexed.
+        return [
+            {
+                "line": 41,
+                "character": 5,
+                "message": "undefined name 'foo'",
+                "severity": "error",
+                "source": "pyright",
+                "code": None,
+            },
+            {
+                "line": 8,
+                "character": 0,
+                "message": "unused import",
+                "severity": "warning",
+                "source": "ruff",
+                "code": "F401",
+            },
+        ]
+
+    async def get_document_symbols(self, file_path: str):
+        self.calls.append(("get_document_symbols", file_path))
+        return self._symbols
+
+
+def _adapter(pool=None):
+    from victor_coding.lsp.framework_adapter import FrameworkLSPAdapter
+
+    return FrameworkLSPAdapter(pool or _MockPool())
+
+
+class TestDiagnosticsConversion:
+    def test_severity_name_to_enum_and_line_zero_indexed(self):
+        adapter = _adapter()
+        diags = adapter.get_diagnostics("a.py")
+        assert len(diags) == 2
+        assert all(isinstance(d, Diagnostic) for d in diags)
+        # "error" -> ERROR(1), line 41 (1-indexed) -> 40
+        assert diags[0].severity == DiagnosticSeverity.ERROR
+        assert int(diags[0].severity) == 1
+        assert diags[0].range.start.line == 40
+        assert diags[0].range.start.character == 5
+        assert diags[0].message == "undefined name 'foo'"
+        assert diags[0].source == "pyright"
+        # "warning" -> WARNING(2)
+        assert diags[1].severity == DiagnosticSeverity.WARNING
+        assert int(diags[1].severity) == 2
+        assert diags[1].code == "F401"
+
+    def test_unknown_severity_defaults_to_error(self):
+        pool = _MockPool()
+        pool.get_diagnostics = lambda fp: [
+            {"line": 1, "character": 0, "message": "x", "severity": "bogus"}
+        ]
+        diags = _adapter(pool).get_diagnostics("a.py")
+        assert diags[0].severity == DiagnosticSeverity.ERROR
+
+
+class TestDocumentSymbols:
+    @pytest.mark.asyncio
+    async def test_symbols_returned_as_contracts_types(self):
+        pool = _MockPool(
+            symbols=[
+                _ds(
+                    "SessionManager",
+                    SymbolKind.CLASS,
+                    detail="(store)",
+                    children=[
+                        _ds("__init__", SymbolKind.CONSTRUCTOR),
+                        _ds("validate", SymbolKind.METHOD),
+                    ],
+                ),
+                _ds("TOP_LEVEL_CONST", SymbolKind.CONSTANT),
+            ]
+        )
+        symbols = await _adapter(pool).get_document_symbols("a.py")
+        assert len(symbols) == 2
+        assert all(isinstance(s, DocumentSymbol) for s in symbols)
+        # kind is an IntEnum — the framework reads it as int.
+        assert symbols[0].name == "SessionManager"
+        assert int(symbols[0].kind) == int(SymbolKind.CLASS)
+        assert symbols[0].detail == "(store)"
+        assert len(symbols[0].children) == 2
+        assert int(symbols[0].children[0].kind) == int(SymbolKind.CONSTRUCTOR)
+
+    @pytest.mark.asyncio
+    async def test_empty_symbols(self):
+        symbols = await _adapter().get_document_symbols("a.py")
+        assert symbols == []
+
+
+class TestPassthrough:
+    @pytest.mark.asyncio
+    async def test_open_and_update_delegate_to_pool(self):
+        pool = _MockPool()
+        adapter = _adapter(pool)
+        assert await adapter.open_document("a.py", "x = 1") is True
+        assert await adapter.update_document("a.py", "x = 2") is True
+        adapter.close_document("a.py")
+        names = [c[0] for c in pool.calls]
+        assert names == ["open_document", "update_document", "close_document"]
+
+
+class TestGetLspWiring:
+    def test_coding_assistant_get_lsp_returns_adapter(self):
+        from victor_coding.assistant import CodingAssistant
+        from victor_coding.lsp.framework_adapter import FrameworkLSPAdapter
+
+        cap = CodingAssistant.get_lsp()
+        assert isinstance(cap, FrameworkLSPAdapter)
+
+
+class TestEndToEndActivation:
+    """The real CodingAssistant flows through the framework's apply_lsp."""
+
+    def test_apply_lsp_wires_coding_assistant_capability(self):
+        from victor.framework.step_handlers import FrameworkStepHandler
+
+        from victor_coding.assistant import CodingAssistant
+        from victor_coding.lsp.framework_adapter import FrameworkLSPAdapter
+
+        class _Recorder:
+            def __init__(self) -> None:
+                self.set_calls: list = []
+
+            def set_lsp(self, capability) -> None:
+                self.set_calls.append(capability)
+
+        orch = _Recorder()
+        context = SimpleNamespace()
+        result = SimpleNamespace(add_info=lambda *a, **k: None, add_warning=lambda *a, **k: None)
+
+        FrameworkStepHandler().apply_lsp(orch, CodingAssistant, context, result)
+
+        assert len(orch.set_calls) == 1
+        assert isinstance(orch.set_calls[0], FrameworkLSPAdapter)

{victor_coding-0.7.1 → victor_coding-0.7.2}/victor_coding/__init__.py

@@ -74,7 +74,10 @@ _EXPORTS = {
     "CodingPlugin": ("victor_coding.plugin", "CodingPlugin"),
     "plugin": ("victor_coding.plugin", "plugin"),
     "CodingMiddleware": ("victor_coding.middleware", "CodingMiddleware"),
-    "CodeCorrectionMiddleware": ("victor_coding.middleware", "CodeCorrectionMiddleware"),
+    "CodeCorrectionMiddleware": (
+        "victor_coding.middleware",
+        "CodeCorrectionMiddleware",
+    ),
     "CodingSafetyExtension": ("victor_coding.safety", "CodingSafetyExtension"),
     "EnhancedCodingSafetyExtension": (
         "victor_coding.safety_enhanced",
@@ -87,10 +90,22 @@ _EXPORTS = {
     "CodingSafetyRules": ("victor_coding.safety_enhanced", "CodingSafetyRules"),
     "CodingContext": ("victor_coding.conversation_enhanced", "CodingContext"),
     "CodingPromptContributor": ("victor_coding.prompts", "CodingPromptContributor"),
-    "CodingModeConfigProvider": ("victor_coding.mode_config", "CodingModeConfigProvider"),
-    "CodingServiceProvider": ("victor_coding.service_provider", "CodingServiceProvider"),
-    "CodingCapabilityProvider": ("victor_coding.capabilities", "CodingCapabilityProvider"),
-    "get_coding_capabilities": ("victor_coding.capabilities", "get_coding_capabilities"),
+    "CodingModeConfigProvider": (
+        "victor_coding.mode_config",
+        "CodingModeConfigProvider",
+    ),
+    "CodingServiceProvider": (
+        "victor_coding.service_provider",
+        "CodingServiceProvider",
+    ),
+    "CodingCapabilityProvider": (
+        "victor_coding.capabilities",
+        "CodingCapabilityProvider",
+    ),
+    "get_coding_capabilities": (
+        "victor_coding.capabilities",
+        "get_coding_capabilities",
+    ),
     "create_coding_capability_loader": (
         "victor_coding.capabilities",
         "create_coding_capability_loader",

{victor_coding-0.7.1 → victor_coding-0.7.2}/victor_coding/assistant.py

@@ -109,6 +109,31 @@ class CodingAssistant(VerticalBase):
 
         return list(CODING_SKILLS)
 
+    @classmethod
+    def get_lsp(cls):
+        """Expose victor-coding's LSP capability to the framework (FEP-0019).
+
+        Returns a ``FrameworkLSPAdapter`` over the shared ``LSPConnectionPool``.
+        The framework duck-types ``orchestrator.lsp``, and
+        ``FrameworkStepHandler.apply_lsp`` routes this object to
+        ``orchestrator.set_lsp`` during integration, activating the diagnostic
+        middleware (Phases 1+2) and the symbol-context provider (Phase 3).
+        Returns ``None`` if the pool/adapter cannot be built.
+        """
+        try:
+            from victor_coding.lsp.framework_adapter import FrameworkLSPAdapter
+            from victor_coding.lsp.manager import get_lsp_manager
+
+            return FrameworkLSPAdapter(get_lsp_manager())
+        except Exception:
+            import logging
+
+            logging.getLogger(__name__).debug(
+                "victor-coding LSP capability unavailable; FEP-0019 chain stays dormant",
+                exc_info=True,
+            )
+            return None
+
     # =========================================================================
     # Phase 3: Framework Capabilities
     # =========================================================================
@@ -224,14 +249,24 @@ You have access to 45+ tools. Use them efficiently to accomplish tasks."""
             "INITIAL": StageDefinition(
                 name="INITIAL",
                 description="Understanding the coding request",
-                tools={ToolNames.READ, ToolNames.LS, ToolNames.OVERVIEW, ToolNames.GREP},
+                tools={
+                    ToolNames.READ,
+                    ToolNames.LS,
+                    ToolNames.OVERVIEW,
+                    ToolNames.GREP,
+                },
                 keywords=["what", "how", "explain", "where", "show me"],
                 next_stages={"PLANNING", "READING"},
             ),
             "PLANNING": StageDefinition(
                 name="PLANNING",
                 description="Planning the implementation approach",
-                tools={ToolNames.GREP, ToolNames.PLAN, ToolNames.OVERVIEW, ToolNames.READ},
+                tools={
+                    ToolNames.GREP,
+                    ToolNames.PLAN,
+                    ToolNames.OVERVIEW,
+                    ToolNames.READ,
+                },
                 keywords=["plan", "approach", "design", "architecture", "strategy"],
                 next_stages={"READING", "EXECUTION"},
             ),
@@ -252,7 +287,12 @@ You have access to 45+ tools. Use them efficiently to accomplish tasks."""
             "ANALYSIS": StageDefinition(
                 name="ANALYSIS",
                 description="Analyzing code structure and dependencies",
-                tools={ToolNames.LSP, ToolNames.SYMBOL, ToolNames.REFS, ToolNames.OVERVIEW},
+                tools={
+                    ToolNames.LSP,
+                    ToolNames.SYMBOL,
+                    ToolNames.REFS,
+                    ToolNames.OVERVIEW,
+                },
                 keywords=["analyze", "review", "understand", "why", "how does"],
                 next_stages={"EXECUTION", "PLANNING"},
             ),

{victor_coding-0.7.1 → victor_coding-0.7.2}/victor_coding/codebase/architecture_analyzer.py

@@ -167,7 +167,10 @@ class ArchitectureAnalyzer:
     def find_config_files(self) -> None:
         """Find important configuration files."""
         config_patterns = [
-            ("pyproject.toml", "Project configuration, dependencies, and build settings"),
+            (
+                "pyproject.toml",
+                "Project configuration, dependencies, and build settings",
+            ),
             ("setup.py", "Legacy Python package setup"),
             ("setup.cfg", "Package configuration"),
             (".env.example", "Environment variable template"),

victor_coding-0.7.2/victor_coding/codebase/embeddings/__init__.py

@@ -0,0 +1,56 @@
+# Copyright 2025 Vijaykumar Singh <singhvjd@gmail.com>
+# SPDX-License-Identifier: Apache-2.0
+
+"""Embedding system for Victor codebase intelligence.
+
+This module combines:
+1. Generic vector storage infrastructure from victor-core (victor.storage.vector_stores)
+2. Code-specific AST-aware chunking (local to victor-coding)
+
+For new code, prefer importing directly from victor.storage.vector_stores for
+the generic embedding infrastructure:
+    from victor.storage.vector_stores import EmbeddingConfig, EmbeddingRegistry
+
+The code-specific ASTAwareChunker remains in this module:
+    from victor_coding.codebase.embeddings.chunker import ASTAwareChunker
+"""
+
+# Re-export from victor-core for backward compatibility
+from victor.storage.vector_stores import (
+    # Base classes
+    BaseEmbeddingProvider,
+    BaseEmbeddingModel,
+    EmbeddingConfig,
+    EmbeddingModelConfig,
+    EmbeddingSearchResult,
+    # Embedding models
+    SentenceTransformerModel,
+    OllamaEmbeddingModel,
+    OpenAIEmbeddingModel,
+    CohereEmbeddingModel,
+    create_embedding_model,
+    # Registry
+    EmbeddingRegistry,
+)
+
+# Code-specific: AST-aware chunking (stays in victor-coding)
+from victor_coding.codebase.embeddings.chunker import ASTAwareChunker
+
+__all__ = [
+    # Base classes (from victor-core)
+    "BaseEmbeddingProvider",
+    "BaseEmbeddingModel",
+    "EmbeddingConfig",
+    "EmbeddingModelConfig",
+    "EmbeddingSearchResult",
+    # Embedding models (from victor-core)
+    "SentenceTransformerModel",
+    "OllamaEmbeddingModel",
+    "OpenAIEmbeddingModel",
+    "CohereEmbeddingModel",
+    "create_embedding_model",
+    # Registry (from victor-core)
+    "EmbeddingRegistry",
+    # Code-specific (local)
+    "ASTAwareChunker",
+]