kodit 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

kodit/infrastructure/snippet_extraction/languages/go.scm

@@ -1,26 +0,0 @@
-(function_declaration
-  name: (identifier) @function.name
-  body: (block) @function.body
-) @function.def
-
-(method_declaration
-  name: (field_identifier) @method.name
-  body: (block) @method.body
-) @method.def
-
-(import_declaration
-  (import_spec
-    path: (interpreted_string_literal) @import.name
-  )
-) @import.statement
-
-(identifier) @ident
-
-(parameter_declaration
-  name: (identifier) @param.name
-)
-
-(package_clause "package" (package_identifier) @name.definition.module)
-
-;; Exclude comments from being captured
-(comment) @comment

kodit/infrastructure/snippet_extraction/languages/java.scm

@@ -1,12 +0,0 @@
-(import_declaration
-  (scoped_identifier) @import.name
-)
-
-(method_declaration
-  name: (identifier) @function.name
-  body: (block) @function.body
-) @function.def
-
-(class_declaration
-  name: (identifier) @class.name
-) @class.def

kodit/infrastructure/snippet_extraction/languages/javascript.scm

@@ -1,24 +0,0 @@
-(import_statement
-  (import_clause
-    (named_imports
-      (import_specifier
-        name: (identifier) @import.name
-      )
-    )
-  )
-)
-
-(function_declaration
-  name: (identifier) @function.name
-  body: (statement_block) @function.body
-)
-
-(class_declaration
-  name: (identifier) @class.name
-  body: (class_body) @class.body
-) @class.def
-
-(method_definition
-  name: (property_identifier) @function.name
-  body: (statement_block) @function.body
-)

kodit/infrastructure/snippet_extraction/languages/python.scm

@@ -1,22 +0,0 @@
-(function_definition
-  name: (identifier) @function.name
-  body: (block) @function.body
-) @function.def
-
-(class_definition
-  name: (identifier) @class.name
-) @class.def
-
-(import_statement
-  name: (dotted_name (identifier) @import.name))
-
-(import_from_statement
-  module_name: (dotted_name (identifier) @import.from))
-
-(identifier) @ident
-
-(assignment
-  left: (identifier) @assignment.lhs)
-
-(parameters
-  (identifier) @param.name)

kodit/infrastructure/snippet_extraction/languages/typescript.scm

@@ -1,25 +0,0 @@
-(import_statement
-  (import_clause
-    (named_imports
-      (import_specifier
-        name: (identifier) @import.name
-      )
-    )
-  )
-)
-
-(variable_declarator
-  name: (identifier) @function.name
-  value: (arrow_function
-    body: (statement_block) @function.body
-  )
-)
-
-(class_declaration
-  name: (type_identifier) @class.name
-) @class.def
-
-(method_definition
-  name: (property_identifier) @function.name
-  body: (statement_block) @function.body
-)

kodit/infrastructure/snippet_extraction/snippet_extraction_factory.py

@@ -1,67 +0,0 @@
-"""Factory for creating snippet extraction services."""
-
-from pathlib import Path
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.enums import SnippetExtractionStrategy
-from kodit.domain.repositories import FileRepository, SnippetRepository
-from kodit.domain.services.snippet_extraction_service import (
-    SnippetExtractionDomainService,
-)
-from kodit.domain.value_objects import LanguageMapping
-from kodit.infrastructure.snippet_extraction.language_detection_service import (
-    FileSystemLanguageDetectionService,
-)
-from kodit.infrastructure.snippet_extraction.snippet_query_provider import (
-    FileSystemSnippetQueryProvider,
-)
-from kodit.infrastructure.snippet_extraction.tree_sitter_snippet_extractor import (
-    TreeSitterSnippetExtractor,
-)
-from kodit.infrastructure.sqlalchemy.file_repository import SqlAlchemyFileRepository
-from kodit.infrastructure.sqlalchemy.snippet_repository import (
-    SqlAlchemySnippetRepository,
-)
-
-
-def create_snippet_extraction_domain_service() -> SnippetExtractionDomainService:
-    """Create a snippet extraction domain service with all dependencies.
-
-    Returns:
-        Configured snippet extraction domain service
-
-    """
-    # Use the unified language mapping from the domain layer
-    language_map = LanguageMapping.get_extension_to_language_map()
-
-    # Create infrastructure services
-    language_detector = FileSystemLanguageDetectionService(language_map)
-    query_provider = FileSystemSnippetQueryProvider(Path(__file__).parent / "languages")
-
-    # Create snippet extractors
-    method_extractor = TreeSitterSnippetExtractor(query_provider)
-
-    snippet_extractors = {
-        SnippetExtractionStrategy.METHOD_BASED: method_extractor,
-    }
-
-    # Create domain service
-    return SnippetExtractionDomainService(language_detector, snippet_extractors)
-
-
-def create_snippet_repositories(
-    session: AsyncSession,
-) -> tuple[SnippetRepository, FileRepository]:
-    """Create snippet and file repositories.
-
-    Args:
-        session: SQLAlchemy session
-
-    Returns:
-        Tuple of (snippet_repository, file_repository)
-
-    """
-    snippet_repository = SqlAlchemySnippetRepository(session)
-    file_repository = SqlAlchemyFileRepository(session)
-    return snippet_repository, file_repository

kodit/infrastructure/snippet_extraction/snippet_query_provider.py

@@ -1,45 +0,0 @@
-"""Infrastructure implementation for loading snippet queries from files."""
-
-from abc import ABC, abstractmethod
-from pathlib import Path
-
-
-class SnippetQueryProvider(ABC):
-    """Abstract interface for providing snippet queries."""
-
-    @abstractmethod
-    async def get_query(self, language: str) -> str:
-        """Get the query for a specific language."""
-
-
-class FileSystemSnippetQueryProvider(SnippetQueryProvider):
-    """Infrastructure implementation for loading snippet queries from files."""
-
-    def __init__(self, query_directory: Path) -> None:
-        """Initialize the query provider.
-
-        Args:
-            query_directory: Directory containing query files
-
-        """
-        self.query_directory = query_directory
-
-    async def get_query(self, language: str) -> str:
-        """Load query from file system.
-
-        Args:
-            language: The programming language to get the query for
-
-        Returns:
-            The query string for the language
-
-        Raises:
-            FileNotFoundError: If the query file doesn't exist
-
-        """
-        query_path = self.query_directory / f"{language}.scm"
-
-        if not query_path.exists():
-            raise FileNotFoundError(f"Query file not found: {query_path}")
-
-        return query_path.read_text()

kodit/infrastructure/snippet_extraction/tree_sitter_snippet_extractor.py

@@ -1,182 +0,0 @@
-"""Infrastructure implementation using tree-sitter for method extraction."""
-
-from pathlib import Path
-from typing import cast
-
-from tree_sitter import Node, Query
-from tree_sitter_language_pack import SupportedLanguage, get_language, get_parser
-
-from kodit.domain.services.snippet_extraction_service import SnippetExtractor
-from kodit.infrastructure.snippet_extraction.snippet_query_provider import (
-    SnippetQueryProvider,
-)
-
-
-class TreeSitterSnippetExtractor(SnippetExtractor):
-    """Infrastructure implementation using tree-sitter for method extraction."""
-
-    def __init__(self, query_provider: SnippetQueryProvider) -> None:
-        """Initialize the tree-sitter snippet extractor.
-
-        Args:
-            query_provider: Provider for snippet queries
-
-        """
-        self.query_provider = query_provider
-
-    async def extract(self, file_path: Path, language: str) -> list[str]:
-        """Extract snippets using tree-sitter parsing.
-
-        Args:
-            file_path: Path to the file to extract snippets from
-            language: The programming language of the file
-
-        Returns:
-            List of extracted code snippets
-
-        Raises:
-            ValueError: If the file cannot be read or language is not supported
-
-        """
-        try:
-            # Get the query for the language
-            query = await self.query_provider.get_query(language)
-        except FileNotFoundError as e:
-            raise ValueError(f"Unsupported language: {file_path}") from e
-
-        # Get parser and language for tree-sitter
-        try:
-            tree_sitter_language = get_language(cast("SupportedLanguage", language))
-            parser = get_parser(cast("SupportedLanguage", language))
-        except Exception as e:
-            raise ValueError(f"Unsupported language: {file_path}") from e
-
-        # Create query object
-        query_obj = Query(tree_sitter_language, query)
-
-        # Read file content
-        try:
-            file_bytes = file_path.read_bytes()
-        except Exception as e:
-            raise ValueError(f"Failed to read file: {file_path}") from e
-
-        # Parse and extract snippets
-        tree = parser.parse(file_bytes)
-        captures_by_name = query_obj.captures(tree.root_node)
-        lines = file_bytes.decode().splitlines()
-
-        # Extract snippets using the existing logic
-        snippets = self._extract_snippets_from_captures(captures_by_name, lines)
-
-        # If there are no results, return the entire file
-        if not snippets:
-            return [file_bytes.decode()]
-
-        return snippets
-
-    def _extract_snippets_from_captures(
-        self, captures_by_name: dict[str, list[Node]], lines: list[str]
-    ) -> list[str]:
-        """Extract snippets from tree-sitter captures.
-
-        Args:
-            captures_by_name: Captures organized by name
-            lines: Lines of the source file
-
-        Returns:
-            List of extracted code snippets
-
-        """
-        # Find all leaf functions
-        leaf_functions = self._get_leaf_functions(captures_by_name)
-
-        # Find all imports
-        imports = self._get_imports(captures_by_name)
-
-        results = []
-
-        # For each leaf function, find all lines this function is dependent on
-        for func_node in leaf_functions:
-            all_lines_to_keep = set()
-
-            ancestors = self._get_ancestors(captures_by_name, func_node)
-
-            # Add self to keep
-            all_lines_to_keep.update(
-                range(func_node.start_point[0], func_node.end_point[0] + 1)
-            )
-
-            # Add imports to keep
-            for import_node in imports:
-                all_lines_to_keep.update(
-                    range(import_node.start_point[0], import_node.end_point[0] + 1)
-                )
-
-            # Add ancestors to keep
-            for node in ancestors:
-                # Get the first line of the node for now
-                start = node.start_point[0]
-                end = node.start_point[0]
-                all_lines_to_keep.update(range(start, end + 1))
-
-            pseudo_code = []
-            for i, line in enumerate(lines):
-                if i in all_lines_to_keep:
-                    pseudo_code.append(line)
-
-            results.append("\n".join(pseudo_code))
-
-        return results
-
-    def _get_leaf_functions(
-        self, captures_by_name: dict[str, list[Node]]
-    ) -> list[Node]:
-        """Return all leaf functions in the AST."""
-        return [
-            node
-            for node in captures_by_name.get("function.body", [])
-            if self._is_leaf_function(captures_by_name, node)
-        ]
-
-    def _is_leaf_function(
-        self, captures_by_name: dict[str, list[Node]], node: Node
-    ) -> bool:
-        """Return True if the node is a leaf function."""
-        for other in captures_by_name.get("function.body", []):
-            if other == node:  # Skip self
-                continue
-            # if other is inside node, it's not a leaf function
-            if other.start_byte >= node.start_byte and other.end_byte <= node.end_byte:
-                return False
-        return True
-
-    def _get_imports(self, captures_by_name: dict[str, list[Node]]) -> list[Node]:
-        """Return all imports in the AST."""
-        return captures_by_name.get("import.name", []) + captures_by_name.get(
-            "import.from", []
-        )
-
-    def _classes_and_functions(
-        self, captures_by_name: dict[str, list[Node]]
-    ) -> list[int]:
-        """Return all classes and functions in the AST."""
-        return [
-            node.id
-            for node in {
-                *captures_by_name.get("function.def", []),
-                *captures_by_name.get("class.def", []),
-            }
-        ]
-
-    def _get_ancestors(
-        self, captures_by_name: dict[str, list[Node]], node: Node
-    ) -> list[Node]:
-        """Return all ancestors of the node."""
-        valid_ancestors = self._classes_and_functions(captures_by_name)
-        ancestors = []
-        parent = node.parent
-        while parent:
-            if parent.id in valid_ancestors:
-                ancestors.append(parent)
-            parent = parent.parent
-        return ancestors

kodit/infrastructure/sqlalchemy/file_repository.py

@@ -1,78 +0,0 @@
-"""SQLAlchemy implementation of file repository."""
-
-from collections.abc import Sequence
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.entities import File, Index
-from kodit.domain.repositories import FileRepository
-
-
-class SqlAlchemyFileRepository(FileRepository):
-    """SQLAlchemy implementation of file repository."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize the SQLAlchemy file repository.
-
-        Args:
-            session: The SQLAlchemy async session to use for database operations
-
-        """
-        self.session = session
-
-    async def get(self, id: int) -> File | None:  # noqa: A002
-        """Get a file by ID."""
-        return await self.session.get(File, id)
-
-    async def save(self, entity: File) -> File:
-        """Save entity."""
-        self.session.add(entity)
-        return entity
-
-    async def delete(self, id: int) -> None:  # noqa: A002
-        """Delete entity by ID."""
-        file = await self.get(id)
-        if file:
-            await self.session.delete(file)
-
-    async def list(self) -> Sequence[File]:
-        """List all entities."""
-        return (await self.session.scalars(select(File))).all()
-
-    async def get_files_for_index(self, index_id: int) -> Sequence[File]:
-        """Get all files for an index.
-
-        Args:
-            index_id: The ID of the index to get files for
-
-        Returns:
-            A list of File instances
-
-        """
-        # Get the index first to find its source_id
-        index_query = select(Index).where(Index.id == index_id)
-        index_result = await self.session.execute(index_query)
-        index = index_result.scalar_one_or_none()
-
-        if not index:
-            return []
-
-        # Get all files for the source
-        query = select(File).where(File.source_id == index.source_id)
-        result = await self.session.execute(query)
-        return list(result.scalars())
-
-    async def get_by_id(self, file_id: int) -> File | None:
-        """Get a file by ID.
-
-        Args:
-            file_id: The ID of the file to retrieve
-
-        Returns:
-            The File instance if found, None otherwise
-
-        """
-        query = select(File).where(File.id == file_id)
-        result = await self.session.execute(query)
-        return result.scalar_one_or_none()

kodit/infrastructure/sqlalchemy/repository.py

@@ -1,133 +0,0 @@
-"""SQLAlchemy repository."""
-
-from collections.abc import Sequence
-from typing import cast
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.entities import Author, AuthorFileMapping, File, Source, SourceType
-from kodit.domain.repositories import AuthorRepository, SourceRepository
-
-
-class SqlAlchemySourceRepository(SourceRepository):
-    """SQLAlchemy source repository."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize the repository."""
-        self._session = session
-
-    async def get(self, id: int) -> Source | None:  # noqa: A002
-        """Get a source by ID."""
-        return await self._session.get(Source, id)
-
-    async def save(self, entity: Source) -> Source:
-        """Save entity."""
-        self._session.add(entity)
-        return entity
-
-    async def delete(self, id: int) -> None:  # noqa: A002
-        """Delete entity by ID."""
-        source = await self.get(id)
-        if source:
-            await self._session.delete(source)
-
-    async def list(self) -> Sequence[Source]:
-        """List all entities."""
-        stmt = select(Source)
-        return (await self._session.scalars(stmt)).all()
-
-    async def get_by_uri(self, uri: str) -> Source | None:
-        """Get a source by URI."""
-        stmt = select(Source).where(Source.uri == uri)
-        return cast("Source | None", await self._session.scalar(stmt))
-
-    async def list_by_type(
-        self, source_type: SourceType | None = None
-    ) -> Sequence[Source]:
-        """List sources by type."""
-        stmt = select(Source)
-        if source_type is not None:
-            stmt = stmt.where(Source.type == source_type)
-        return (await self._session.scalars(stmt)).all()
-
-    async def create_file(self, file: File) -> File:
-        """Create a new file record."""
-        self._session.add(file)
-        return file
-
-    async def upsert_author(self, author: Author) -> Author:
-        """Create a new author or return existing one if email already exists."""
-        # First check if author already exists with same name and email
-        stmt = select(Author).where(
-            Author.name == author.name, Author.email == author.email
-        )
-        existing_author = cast("Author | None", await self._session.scalar(stmt))
-
-        if existing_author:
-            return existing_author
-
-        # Author doesn't exist, create new one
-        self._session.add(author)
-        return author
-
-    async def upsert_author_file_mapping(
-        self, mapping: AuthorFileMapping
-    ) -> AuthorFileMapping:
-        """Create a new author file mapping or return existing one if already exists."""
-        # First check if mapping already exists with same author_id and file_id
-        stmt = select(AuthorFileMapping).where(
-            AuthorFileMapping.author_id == mapping.author_id,
-            AuthorFileMapping.file_id == mapping.file_id,
-        )
-        existing_mapping = cast(
-            "AuthorFileMapping | None", await self._session.scalar(stmt)
-        )
-
-        if existing_mapping:
-            return existing_mapping
-
-        # Mapping doesn't exist, create new one
-        self._session.add(mapping)
-        return mapping
-
-
-class SqlAlchemyAuthorRepository(AuthorRepository):
-    """SQLAlchemy author repository."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize the repository."""
-        self._session = session
-
-    async def get(self, id: int) -> Author | None:  # noqa: A002
-        """Get an author by ID."""
-        return await self._session.get(Author, id)
-
-    async def save(self, entity: Author) -> Author:
-        """Save entity."""
-        self._session.add(entity)
-        return entity
-
-    async def delete(self, id: int) -> None:  # noqa: A002
-        """Delete entity by ID."""
-        author = await self.get(id)
-        if author:
-            await self._session.delete(author)
-
-    async def list(self) -> Sequence[Author]:
-        """List authors."""
-        return (await self._session.scalars(select(Author))).all()
-
-    async def get_by_name(self, name: str) -> Author | None:
-        """Get an author by name."""
-        return cast(
-            "Author | None",
-            await self._session.scalar(select(Author).where(Author.name == name)),
-        )
-
-    async def get_by_email(self, email: str) -> Author | None:
-        """Get an author by email."""
-        return cast(
-            "Author | None",
-            await self._session.scalar(select(Author).where(Author.email == email)),
-        )