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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-coding
-Version: 0.14.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>

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

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "victor-coding"
-version = "0.14.0"
+version = "0.15.0"
 description = "Coding vertical for Victor AI - Software development, debugging, and code generation"
 readme = "README.md"
 requires-python = ">=3.12"

{victor_coding-0.14.0 → victor_coding-0.15.0}/victor_coding/languages/base.py

@@ -25,12 +25,16 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
+from types import MappingProxyType
 from typing import (
     TYPE_CHECKING,
+    AbstractSet,
     Any,
+    Callable,
     Dict,
     Iterable,
     List,
+    Mapping,
     Optional,
     Protocol,
     Tuple,
@@ -42,6 +46,67 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+#: ``(leaf_types, nested_types)`` arguments for :func:`last_named_child`.
+PathNameTypes = Tuple[AbstractSet[str], AbstractSet[str]]
+
+
+def last_named_child(
+    node: "Node",
+    leaf_types: AbstractSet[str],
+    nested_types: AbstractSet[str],
+    get_text: Callable[["Node"], Optional[str]],
+) -> Optional[str]:
+    """Name at the right end of a dotted / scoped path node.
+
+    Scans ``node``'s children right to left. The first ``leaf_types`` child
+    wins and its text is returned; a ``nested_types`` child (the same path
+    shape one level down) is searched recursively and its result returned
+    when non-empty. For ``obj.a.method`` / ``std::mem::drop`` this yields
+    ``method`` / ``drop``.
+
+    Args:
+        node: The path node (attribute, field/selector expression, ...).
+        leaf_types: Child node types holding a name segment.
+        nested_types: Child node types to recurse into; empty disables recursion.
+        get_text: Node-text accessor (typically ``BaseLanguagePlugin._get_node_text``).
+    """
+    for child in reversed(node.children):
+        if child.type in leaf_types:
+            return get_text(child)
+        if child.type in nested_types:
+            result = last_named_child(child, leaf_types, nested_types, get_text)
+            if result:
+                return result
+    return None
+
+
+def declarator_name(
+    node: "Node",
+    name_types: AbstractSet[str],
+    get_text: Callable[["Node"], Optional[str]],
+) -> Optional[str]:
+    """Function name of a C-family ``function_definition`` node.
+
+    Looks in the ``function_declarator`` child first (also one level inside a
+    child typed ``declarator``), then falls back to a direct child of the
+    definition. ``name_types`` are the node types accepted as the name.
+    """
+    for child in node.children:
+        if child.type == "function_declarator":
+            for grandchild in child.children:
+                if grandchild.type == "declarator":
+                    for ggchild in grandchild.children:
+                        if ggchild.type in name_types:
+                            return get_text(ggchild)
+                elif grandchild.type in name_types:
+                    return get_text(grandchild)
+
+    for child in node.children:
+        if child.type in name_types:
+            return get_text(child)
+
+    return None
+
 
 # ---------------------------------------------------------------------------
 # Tree-sitter Query Types
@@ -665,8 +730,34 @@ class BaseLanguagePlugin(ABC):
         """
         return ()
 
+    #: Child node types whose own text is the callee name (``foo()``).
+    _callee_name_types: AbstractSet[str] = frozenset()
+    #: Child node type -> ``(leaf_types, nested_types)``: the callee is the
+    #: :func:`last_named_child` of that child (``obj.method()``, ``a::b()``).
+    _callee_path_types: Mapping[str, PathNameTypes] = MappingProxyType({})
+    #: Child node types wrapping another callee expression (``(fn)()``):
+    #: :meth:`_extract_callee_name` is re-entered on that child.
+    _callee_wrapper_types: AbstractSet[str] = frozenset()
+
     def _extract_callee_name(self, call_node: "Node") -> Optional[str]:
-        """Return the called symbol's name for ``call_node``, or ``None``."""
+        """Return the called symbol's name for ``call_node``, or ``None``.
+
+        Default: the first child of ``call_node`` whose type appears in
+        :attr:`_callee_name_types`, :attr:`_callee_path_types` or
+        :attr:`_callee_wrapper_types` decides the result (which may be
+        ``None``); later children are not consulted. With the empty default
+        tables no callee is ever found.
+        """
+        for child in call_node.children:
+            child_type = child.type
+            if child_type in self._callee_name_types:
+                return self._get_node_text(child)
+            path_types = self._callee_path_types.get(child_type)
+            if path_types is not None:
+                leaf_types, nested_types = path_types
+                return last_named_child(child, leaf_types, nested_types, self._get_node_text)
+            if child_type in self._callee_wrapper_types:
+                return self._extract_callee_name(child)
         return None
 
 

victor_coding-0.15.0/victor_coding/languages/plugins/_ecmascript.py

@@ -0,0 +1,208 @@
+# Copyright 2025 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.
+
+"""Shared base for the ECMAScript-family (JavaScript/TypeScript) plugins.
+
+Holds the logic both plugins share verbatim -- capabilities, package.json test
+runner detection, prettier formatting, call-node traversal and callee/member
+name extraction. The genuine differences are expressed as class-attribute
+hooks that ``JavaScriptPlugin`` and ``TypeScriptPlugin`` override.
+"""
+
+from pathlib import Path
+from typing import ClassVar, List, Optional, Tuple, TYPE_CHECKING
+
+from victor_coding.languages.base import (
+    BaseLanguagePlugin,
+    ConfigurableASTTraverser,
+    Formatter,
+    LanguageCapabilities,
+    TestRunner,
+    TraversalConfig,
+)
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+
+class EcmaScriptPluginBase(BaseLanguagePlugin):
+    """Common behaviour of the JavaScript and TypeScript plugins.
+
+    Subclasses provide ``_create_config``/``_create_tree_sitter_queries`` and
+    may override the class-attribute hooks below.
+    """
+
+    # --- Hooks --------------------------------------------------------------
+    _supports_type_checking: ClassVar[bool] = False
+    _test_file_pattern: ClassVar[str] = "*.test.js"
+    _vitest_parallel_args: ClassVar[Tuple[str, ...]] = ()
+    _jest_parallel_args: ClassVar[Tuple[str, ...]] = ()
+    _detects_mocha: ClassVar[bool] = False
+    # Node types whose name is the first property_identifier/identifier child.
+    _method_node_types: ClassVar[Tuple[str, ...]] = ("method_definition",)
+    _extra_function_types: ClassVar[Tuple[str, ...]] = ()
+    _class_types: ClassVar[Tuple[str, ...]] = ("class_declaration",)
+    _scope_body_types: ClassVar[Tuple[str, ...]] = ("class_body",)
+
+    def _create_capabilities(self) -> LanguageCapabilities:
+        return LanguageCapabilities(
+            supports_syntax_analysis=True,
+            supports_semantic_analysis=True,
+            supports_type_checking=self._supports_type_checking,
+            supports_rename=True,
+            supports_extract_function=True,
+            supports_inline=True,
+            supports_organize_imports=True,
+            supports_test_discovery=True,
+            supports_test_execution=True,
+            supports_coverage=True,
+            supports_debugging=True,
+            supports_breakpoints=True,
+            supports_step_debugging=True,
+            supports_formatting=True,
+            supports_linting=True,
+            supports_completion=True,
+            supports_control_flow_graph=True,
+        )
+
+    def get_test_runner(self, project_root: Path) -> Optional[TestRunner]:
+        """Detect vitest, jest (or mocha, when enabled) from package.json; default jest."""
+        package_json = project_root / "package.json"
+        pattern = self._test_file_pattern
+
+        if package_json.exists():
+            content = package_json.read_text()
+
+            if '"vitest"' in content:
+                return TestRunner(
+                    name="vitest",
+                    command=["npx", "vitest"],
+                    file_pattern=pattern,
+                    run_args=["run"],
+                    coverage_args=["--coverage"],
+                    parallel_args=list(self._vitest_parallel_args),
+                    output_format="json",
+                    json_args=["--reporter=json"],
+                )
+
+            if '"jest"' in content:
+                return TestRunner(
+                    name="jest",
+                    command=["npx", "jest"],
+                    file_pattern=pattern,
+                    coverage_args=["--coverage"],
+                    parallel_args=list(self._jest_parallel_args),
+                    output_format="json",
+                    json_args=["--json"],
+                )
+
+            if self._detects_mocha and '"mocha"' in content:
+                return TestRunner(
+                    name="mocha",
+                    command=["npx", "mocha"],
+                    file_pattern=pattern,
+                    run_args=["--recursive"],
+                )
+
+        return TestRunner(
+            name="jest",
+            command=["npx", "jest"],
+            file_pattern=pattern,
+        )
+
+    def get_formatter(self, project_root: Path) -> Optional[Formatter]:
+        """Get prettier formatter."""
+        return Formatter(
+            name="prettier",
+            command=["npx", "prettier", "--write", "."],
+            check_args=["--check"],
+            config_file=".prettierrc",
+        )
+
+    def _find_call_nodes(
+        self,
+        root: "Node",
+    ) -> List[tuple["Node", str, Optional[int]]]:
+        """Find all call nodes with their enclosing function context."""
+        config = TraversalConfig(
+            function_types=[
+                "function_declaration",
+                "function_expression",
+                "method_definition",
+                "arrow_function",
+                *self._extra_function_types,
+            ],
+            class_types=list(self._class_types),
+            call_types=["call_expression", "new_expression"],
+            name_field="identifier",
+            scope_body_types=list(self._scope_body_types),
+        )
+        traverser = ConfigurableASTTraverser(config, self._get_node_text)
+        return traverser.find_call_nodes(root)
+
+    def _extract_function_name(self, node: "Node") -> Optional[str]:
+        """Extract function name from a function node."""
+        if node.type == "function_declaration":
+            for child in node.children:
+                if child.type == "identifier":
+                    return self._get_node_text(child)
+
+        if node.type in self._method_node_types:
+            for child in node.children:
+                if child.type in ("property_identifier", "identifier"):
+                    return self._get_node_text(child)
+
+        if node.type == "function_expression":
+            found_function = False
+            for child in node.children:
+                if child.type == "identifier":
+                    if found_function:
+                        return self._get_node_text(child)
+                elif child.type == "function":
+                    found_function = True
+
+        return None
+
+    def _extract_callee_name(self, call_node: "Node") -> Optional[str]:
+        """Extract the name of the called function from a call node."""
+        for child in call_node.children:
+            if child.type == "member_expression":
+                return self._extract_member_name(child)
+            elif child.type == "identifier":
+                return self._get_node_text(child)
+            elif child.type == "subscript_expression":
+                return self._extract_subscript_name(child)
+
+        return None
+
+    def _extract_member_name(self, member_node: "Node") -> Optional[str]:
+        """Extract member name from a member_expression node."""
+        for child in reversed(member_node.children):
+            if child.type == "property_identifier":
+                return self._get_node_text(child)
+            elif child.type == "member_expression":
+                result = self._extract_member_name(child)
+                if result:
+                    return result
+
+        return None
+
+    def _extract_subscript_name(self, subscript_node: "Node") -> Optional[str]:
+        """Extract method name from subscript expression."""
+        for child in subscript_node.children:
+            if child.type == "string":
+                text = self._get_node_text(child)
+                if text:
+                    return text.strip("\"'")
+        return None

{victor_coding-0.14.0 → victor_coding-0.15.0}/victor_coding/languages/plugins/additional.py

@@ -32,6 +32,7 @@ These plugins support embedding-based indexing for:
 - Markdown/reStructuredText
 """
 
+from types import MappingProxyType
 from typing import Any, List, Optional, TYPE_CHECKING
 
 from victor_coding.languages.base import (
@@ -41,6 +42,7 @@ from victor_coding.languages.base import (
     LanguageConfig,
     QueryPattern,
     TreeSitterQueries,
+    declarator_name,
 )
 
 if TYPE_CHECKING:
@@ -50,6 +52,14 @@ if TYPE_CHECKING:
 class CPlugin(BaseLanguagePlugin):
     """C language plugin."""
 
+    _function_name_types = frozenset({"identifier"})
+    # Callee hooks: foo() / ptr->method() (field_identifier of the outermost
+    # field_expression only; C does not recurse into nested field_expressions).
+    _callee_name_types = frozenset({"identifier"})
+    _callee_path_types = MappingProxyType(
+        {"field_expression": (frozenset({"field_identifier"}), frozenset())}
+    )
+
     def _create_config(self) -> LanguageConfig:
         return LanguageConfig(
             name="c",
@@ -176,80 +186,25 @@ class CPlugin(BaseLanguagePlugin):
         return results
 
     def _extract_function_name_c(self, node: "Node") -> Optional[str]:
-        """Extract function name from a function definition node.
-
-        Args:
-            node: Function definition node
-
-        Returns:
-            Function name or None
-        """
-        # Look for function_declarator
-        for child in node.children:
-            if child.type == "function_declarator":
-                # Get the declarator (identifier)
-                for grandchild in child.children:
-                    if grandchild.type == "declarator":
-                        for ggchild in grandchild.children:
-                            if ggchild.type == "identifier":
-                                return self._get_node_text(ggchild)
-                    elif grandchild.type == "identifier":
-                        return self._get_node_text(grandchild)
-
-        # Fallback: look for identifier directly
-        for child in node.children:
-            if child.type == "identifier":
-                return self._get_node_text(child)
-
-        return None
-
-    def _extract_callee_name(self, call_node: "Node") -> Optional[str]:
-        """Extract the name of the called function from a call node.
-
-        Handles:
-        - Simple calls: foo()
-        - Field expression calls: ptr->method()
-
-        Args:
-            call_node: Call expression node
-
-        Returns:
-            Callee name or None
-        """
-        # Get the function part of the call
-        for child in call_node.children:
-            if child.type == "field_expression":
-                # ptr->method() -> extract "method"
-                return self._extract_field_name_c(child)
-            elif child.type == "identifier":
-                # foo() -> extract "foo"
-                return self._get_node_text(child)
-
-        return None
-
-    def _extract_field_name_c(self, field_node: "Node") -> Optional[str]:
-        """Extract field name from a field_expression node.
-
-        For ptr->method, extracts "method".
-
-        Args:
-            field_node: Field expression node
-
-        Returns:
-            Field name or None
-        """
-        # field_expression: argument . field: (field_identifier)
-        # or for pointer access: argument -> field: (field_identifier)
-        for child in reversed(field_node.children):
-            if child.type == "field_identifier":
-                return self._get_node_text(child)
-
-        return None
+        """Extract function name from a function definition node."""
+        return declarator_name(node, self._function_name_types, self._get_node_text)
 
 
 class KotlinPlugin(BaseLanguagePlugin):
     """Kotlin language plugin."""
 
+    # Callee hooks: foo() / obj?.a.method() (last identifier of a
+    # navigation_expression chain).
+    _callee_name_types = frozenset({"identifier"})
+    _callee_path_types = MappingProxyType(
+        {
+            "navigation_expression": (
+                frozenset({"identifier"}),
+                frozenset({"navigation_expression"}),
+            )
+        }
+    )
+
     def _create_config(self) -> LanguageConfig:
         return LanguageConfig(
             name="kotlin",
@@ -412,54 +367,6 @@ class KotlinPlugin(BaseLanguagePlugin):
         traverse(root)
         return results
 
-    def _extract_callee_name(self, call_node: "Node") -> Optional[str]:
-        """Extract the name of the called function from a call node.
-
-        Handles:
-        - Simple calls: foo()
-        - Navigation expressions: obj.method()
-        - Safe navigation: obj?.method()
-
-        Args:
-            call_node: Call expression node
-
-        Returns:
-            Callee name or None
-        """
-        for child in call_node.children:
-            if child.type == "navigation_expression":
-                # obj.method() -> extract "method"
-                return self._extract_navigation_name(child)
-            elif child.type == "identifier":
-                # foo() -> extract "foo"
-                return self._get_node_text(child)
-
-        return None
-
-    def _extract_navigation_name(self, navigation_node: "Node") -> Optional[str]:
-        """Extract method name from a navigation_expression node.
-
-        For obj.method, extracts "method".
-        Handles safe navigation: obj?.method
-
-        Args:
-            navigation_node: Navigation expression node
-
-        Returns:
-            Method name or None
-        """
-        # navigation_expression can be nested: obj1.obj2.method
-        # We want the last identifier (not simple_identifier!)
-        for child in reversed(navigation_node.children):
-            if child.type == "identifier":
-                return self._get_node_text(child)
-            elif child.type == "navigation_expression":
-                result = self._extract_navigation_name(child)
-                if result:
-                    return result
-
-        return None
-
 
 class CSharpPlugin(BaseLanguagePlugin):
     """C# language plugin."""

{victor_coding-0.14.0 → victor_coding-0.15.0}/victor_coding/languages/plugins/cpp.py

@@ -15,6 +15,7 @@
 """C++ language plugin."""
 
 from pathlib import Path
+from types import MappingProxyType
 from typing import List, Optional, TYPE_CHECKING
 
 from victor_coding.languages.base import (
@@ -29,6 +30,7 @@ from victor_coding.languages.base import (
     QueryPattern,
     TestRunner,
     TreeSitterQueries,
+    declarator_name,
 )
 
 if TYPE_CHECKING:
@@ -45,6 +47,25 @@ class CppPlugin(BaseLanguagePlugin):
     - Building: CMake, Make
     """
 
+    _function_name_types = frozenset({"identifier", "field_identifier"})
+    # Callee hooks: foo() / obj.a.method() / ns::Klass::create() (last name
+    # segment of the path) / foo<T>() (template_function re-entered: its only
+    # name child is the template identifier).
+    _callee_name_types = frozenset({"identifier"})
+    _callee_path_types = MappingProxyType(
+        {
+            "field_expression": (
+                frozenset({"field_identifier"}),
+                frozenset({"field_expression"}),
+            ),
+            "qualified_identifier": (
+                frozenset({"identifier"}),
+                frozenset({"qualified_identifier"}),
+            ),
+        }
+    )
+    _callee_wrapper_types = frozenset({"template_function"})
+
     def _create_config(self) -> LanguageConfig:
         return LanguageConfig(
             name="cpp",
@@ -311,95 +332,4 @@ class CppPlugin(BaseLanguagePlugin):
 
         C++ functions can have complex declarators. This handles the common cases.
         """
-        # Look for function_declarator
-        for child in node.children:
-            if child.type == "function_declarator":
-                # Get the declarator (identifier or field_identifier)
-                for grandchild in child.children:
-                    if grandchild.type == "declarator":
-                        for ggchild in grandchild.children:
-                            if ggchild.type in ("identifier", "field_identifier"):
-                                return self._get_node_text(ggchild)
-                    elif grandchild.type in ("identifier", "field_identifier"):
-                        return self._get_node_text(grandchild)
-
-        # Fallback: look for identifier directly
-        for child in node.children:
-            if child.type in ("identifier", "field_identifier"):
-                return self._get_node_text(child)
-
-        return None
-
-    def _extract_callee_name(self, call_node: "Node") -> Optional[str]:
-        """Extract the name of the called function from a call node.
-
-        Handles:
-        - Simple calls: foo()
-        - Field access calls: obj.method()
-        - Template calls: foo<T>()
-        - Namespace-qualified calls: std::foo()
-        """
-        # Get the function part of the call
-        for child in call_node.children:
-            if child.type == "field_expression":
-                # obj.method() -> extract "method"
-                return self._extract_field_name(child)
-            elif child.type == "template_function":
-                # foo<T>() -> extract "foo"
-                return self._extract_template_name(child)
-            elif child.type == "identifier":
-                # foo() -> extract "foo"
-                return self._get_node_text(child)
-            elif child.type == "qualified_identifier":
-                # std::foo -> extract "foo"
-                return self._extract_qualified_name(child)
-
-        return None
-
-    def _extract_field_name(self, field_node: "Node") -> Optional[str]:
-        """Extract field name from a field_expression node.
-
-        For obj.method, extracts "method".
-        For obj.field1.field2, extracts "field2" (the final field).
-        """
-        # field_expression: object (identifier or field_expression) . field: (field_identifier)
-        for child in reversed(field_node.children):
-            if child.type == "field_identifier":
-                return self._get_node_text(child)
-            elif child.type == "field_expression":
-                result = self._extract_field_name(child)
-                if result:
-                    return result
-
-        return None
-
-    def _extract_template_name(self, template_node: "Node") -> Optional[str]:
-        """Extract the base name from a template function.
-
-        For foo<T>(), extracts "foo".
-        """
-        for child in template_node.children:
-            if child.type == "identifier":
-                return self._get_node_text(child)
-            elif child.type == "field_expression":
-                return self._extract_field_name(child)
-
-        return None
-
-    def _extract_qualified_name(self, qualified_node: "Node") -> Optional[str]:
-        """Extract the final identifier from a qualified identifier.
-
-        For std::foo, extracts "foo".
-        For ns::Class::method, extracts "method".
-        """
-        # qualified_identifier: identifier :: identifier (or nested)
-        # We want the last identifier
-        for child in reversed(qualified_node.children):
-            if child.type == "identifier":
-                return self._get_node_text(child)
-            elif child.type == "qualified_identifier":
-                result = self._extract_qualified_name(child)
-                if result:
-                    return result
-
-        return None
+        return declarator_name(node, self._function_name_types, self._get_node_text)