shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.3.3.dev1__py3-none-any.whl

shotgun/cli/update.py

@@ -45,7 +45,7 @@ def update(
 
     This command will:
     - Check PyPI for the latest version
-    - Detect your installation method (pipx, pip, or venv)
+    - Detect your installation method (uvx, uv-tool, pipx, pip, or venv)
     - Perform the appropriate upgrade command
 
     Examples:
@@ -93,6 +93,8 @@ def update(
         )
         console.print(
             "Use --force to update anyway, or install the stable version with:\n"
+            "  uv tool install shotgun-sh\n"
+            "  or\n"
             "  pipx install shotgun-sh\n"
             "  or\n"
             "  pip install shotgun-sh",
@@ -134,7 +136,19 @@ def update(
             console.print(f"\n[red]✗[/red] {message}", style="bold red")
 
             # Provide manual update instructions
-            if method == "pipx":
+            if method == "uvx":
+                console.print(
+                    "\n[yellow]Run uvx again to use the latest version:[/yellow]\n"
+                    "  uvx shotgun-sh\n"
+                    "\n[yellow]Or install permanently:[/yellow]\n"
+                    "  uv tool install shotgun-sh"
+                )
+            elif method == "uv-tool":
+                console.print(
+                    "\n[yellow]Try updating manually:[/yellow]\n"
+                    "  uv tool upgrade shotgun-sh"
+                )
+            elif method == "pipx":
                 console.print(
                     "\n[yellow]Try updating manually:[/yellow]\n"
                     "  pipx upgrade shotgun-sh"

shotgun/codebase/core/change_detector.py

@@ -6,6 +6,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, cast
 
+import aiofiles
 import kuzu
 
 from shotgun.logging_config import get_logger
@@ -301,7 +302,7 @@ class ChangeDetector:
             # Direct substring match
             return pattern in filepath
 
-    def _calculate_file_hash(self, filepath: Path) -> str:
+    async def _calculate_file_hash(self, filepath: Path) -> str:
         """Calculate hash of file contents.
 
         Args:
@@ -311,8 +312,9 @@ class ChangeDetector:
             SHA256 hash of file contents
         """
         try:
-            with open(filepath, "rb") as f:
-                return hashlib.sha256(f.read()).hexdigest()
+            async with aiofiles.open(filepath, "rb") as f:
+                content = await f.read()
+                return hashlib.sha256(content).hexdigest()
         except Exception as e:
             logger.error(f"Failed to calculate hash for {filepath}: {e}")
             return ""

shotgun/codebase/core/code_retrieval.py

@@ -3,6 +3,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+import aiofiles
 from pydantic import BaseModel
 
 from shotgun.logging_config import get_logger
@@ -141,8 +142,9 @@ async def retrieve_code_by_qualified_name(
 
         # Read the file and extract the snippet
         try:
-            with full_path.open("r", encoding="utf-8") as f:
-                all_lines = f.readlines()
+            async with aiofiles.open(full_path, encoding="utf-8") as f:
+                content = await f.read()
+                all_lines = content.splitlines(keepends=True)
 
             # Extract the relevant lines (1-indexed to 0-indexed)
             snippet_lines = all_lines[start_line - 1 : end_line]

shotgun/codebase/core/ingestor.py

@@ -1,13 +1,16 @@
 """Kuzu graph ingestor for building code knowledge graphs."""
 
+import asyncio
 import hashlib
 import os
 import time
 import uuid
 from collections import defaultdict
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
+import aiofiles
 import kuzu
 from tree_sitter import Node, Parser, QueryCursor
 
@@ -196,11 +199,21 @@ class Ingestor:
                     return True
         return False
 
-    def flush_nodes(self) -> None:
-        """Flush pending node insertions to the database."""
+    def flush_nodes(
+        self,
+        progress_callback: Callable[[int, int], None] | None = None,
+    ) -> None:
+        """Flush pending node insertions to the database.
+
+        Args:
+            progress_callback: Optional callback(current, total) for progress reporting
+        """
         if not self.node_buffer:
             return
 
+        total_nodes = len(self.node_buffer)
+        processed = 0
+
         # Group nodes by label
         nodes_by_label: dict[str, list[dict[str, Any]]] = defaultdict(list)
         for label, properties in self.node_buffer:
@@ -237,9 +250,18 @@ class Ingestor:
                     params = dict(zip(prop_names, prop_values, strict=False))
                     self.conn.execute(query, params)
 
+                    # Report progress
+                    processed += 1
+                    if progress_callback and processed % 10 == 0:
+                        progress_callback(processed, total_nodes)
+
             except Exception as e:
                 logger.error(f"Failed to insert {label} nodes: {e}")
 
+        # Final progress report
+        if progress_callback:
+            progress_callback(total_nodes, total_nodes)
+
         # Log node counts by type
         node_type_counts: dict[str, int] = {}
         for label, _ in self.node_buffer:
@@ -278,11 +300,21 @@ class Ingestor:
 
         # Don't auto-flush relationships - wait for explicit flush_all() to ensure nodes exist first
 
-    def flush_relationships(self) -> None:
-        """Flush pending relationship insertions to the database."""
+    def flush_relationships(
+        self,
+        progress_callback: Callable[[int, int], None] | None = None,
+    ) -> None:
+        """Flush pending relationship insertions to the database.
+
+        Args:
+            progress_callback: Optional callback(current, total) for progress reporting
+        """
         if not self.relationship_buffer:
             return
 
+        total_rels = len(self.relationship_buffer)
+        processed = 0
+
         # Group relationships by type
         rels_by_type: dict[
             str, list[tuple[str, str, Any, str, str, str, Any, dict[str, Any] | None]]
@@ -297,7 +329,7 @@ class Ingestor:
                 to_label,
                 to_key,
                 to_value,
-                properties,
+                _properties,
             ) = rel_data
 
             # Determine actual table name
@@ -321,7 +353,7 @@ class Ingestor:
                         to_label,
                         to_key,
                         to_value,
-                        properties,
+                        _properties,
                     ) = rel_data
 
                     # Build MATCH and MERGE query (use MERGE to avoid duplicate relationships)
@@ -335,6 +367,11 @@ class Ingestor:
                     try:
                         self.conn.execute(query, params)
                         success_count += 1
+
+                        # Report progress
+                        processed += 1
+                        if progress_callback and processed % 10 == 0:
+                            progress_callback(processed, total_rels)
                     except Exception as e:
                         logger.error(
                             f"Failed to create single relationship {table_name}: {from_label}({from_value}) -> {to_label}({to_value})"
@@ -358,6 +395,10 @@ class Ingestor:
                 # Don't swallow the exception - let it propagate
                 raise
 
+        # Final progress report
+        if progress_callback:
+            progress_callback(total_rels, total_rels)
+
         # Log summary of flushed relationships
         logger.info(
             f"Flushed {len(self.relationship_buffer)} relationships: {relationship_counts}"
@@ -584,6 +625,9 @@ class SimpleGraphBuilder:
             self.ignore_dirs = self.ignore_dirs.union(set(exclude_patterns))
         self.progress_callback = progress_callback
 
+        # Generate unique session ID for correlating timing events in PostHog
+        self._index_session_id = str(uuid.uuid4())[:8]
+
         # Caches
         self.structural_elements: dict[Path, str | None] = {}
         self.ast_cache: dict[Path, tuple[Node, str]] = {}
@@ -619,25 +663,129 @@ class SimpleGraphBuilder:
             # Don't let progress callback errors crash the build
             logger.debug(f"Progress callback error: {e}")
 
-    def run(self) -> None:
+    def _log_timing(
+        self,
+        phase: str,
+        duration: float,
+        items: int,
+        extra_props: dict[str, Any] | None = None,
+    ) -> None:
+        """Log timing data to PostHog for analysis."""
+        from shotgun.posthog_telemetry import track_event
+
+        properties: dict[str, Any] = {
+            "session_id": self._index_session_id,
+            "phase": phase,
+            "duration_seconds": round(duration, 3),
+            "item_count": items,
+        }
+        if extra_props:
+            properties.update(extra_props)
+
+        track_event("codebase_index_phase_completed", properties)
+
+    def _log_summary(
+        self,
+        total_duration: float,
+        total_files: int,
+        total_nodes: int,
+        total_relationships: int,
+    ) -> None:
+        """Log indexing summary event to PostHog."""
+        from shotgun.posthog_telemetry import track_event
+
+        track_event(
+            "codebase_index_completed",
+            {
+                "session_id": self._index_session_id,
+                "total_duration_seconds": round(total_duration, 3),
+                "total_files": total_files,
+                "total_nodes": total_nodes,
+                "total_relationships": total_relationships,
+            },
+        )
+
+    async def run(self) -> None:
         """Run the three-pass graph building process."""
         logger.info(f"Building graph for project: {self.project_name}")
 
         # Pass 1: Structure
         logger.info("Pass 1: Identifying packages and folders...")
+        t0 = time.time()
         self._identify_structure()
+        t1 = time.time()
+        self._log_timing("structure", t1 - t0, len(self.structural_elements))
 
         # Pass 2: Definitions
         logger.info("Pass 2: Processing files and extracting definitions...")
-        self._process_files()
+        t2 = time.time()
+        await self._process_files()
+        t3 = time.time()
+        self._log_timing(
+            "definitions",
+            t3 - t2,
+            len(self.ast_cache),
+            {"file_count": len(self.ast_cache)},
+        )
 
         # Pass 3: Relationships
         logger.info("Pass 3: Processing relationships (calls, imports)...")
+        t4 = time.time()
         self._process_relationships()
+        t5 = time.time()
+        self._log_timing("relationships", t5 - t4, len(self.ast_cache))
 
         # Flush all pending operations
         logger.info("Flushing all data to database...")
-        self.ingestor.flush_all()
+        t6 = time.time()
+        node_count = len(self.ingestor.node_buffer)
+
+        # Create progress callback for flush_nodes
+        def node_progress(current: int, total: int) -> None:
+            self._report_progress(
+                "flush_nodes", "Flushing nodes to database", current, total
+            )
+
+        self.ingestor.flush_nodes(progress_callback=node_progress)
+        self._report_progress(
+            "flush_nodes", "Flushing nodes to database", node_count, node_count, True
+        )
+        t7 = time.time()
+        self._log_timing("flush_nodes", t7 - t6, node_count, {"node_count": node_count})
+
+        rel_count = len(self.ingestor.relationship_buffer)
+
+        # Create progress callback for flush_relationships
+        def rel_progress(current: int, total: int) -> None:
+            self._report_progress(
+                "flush_relationships",
+                "Flushing relationships to database",
+                current,
+                total,
+            )
+
+        self.ingestor.flush_relationships(progress_callback=rel_progress)
+        self._report_progress(
+            "flush_relationships",
+            "Flushing relationships to database",
+            rel_count,
+            rel_count,
+            True,
+        )
+        t8 = time.time()
+        self._log_timing(
+            "flush_relationships", t8 - t7, rel_count, {"relationship_count": rel_count}
+        )
+
+        # Track summary event with totals (no PII - only numeric metadata)
+        total_duration = t8 - t0
+        self._log_summary(
+            total_duration=total_duration,
+            total_files=len(self.ast_cache),
+            total_nodes=node_count,
+            total_relationships=rel_count,
+        )
+
         logger.info("Graph building complete!")
 
     def _identify_structure(self) -> None:
@@ -771,7 +919,7 @@ class SimpleGraphBuilder:
             phase_complete=True,
         )
 
-    def _process_files(self) -> None:
+    async def _process_files(self) -> None:
         """Second pass: Process files and extract definitions."""
         # First pass: Count total files
         total_files = 0
@@ -807,7 +955,7 @@ class SimpleGraphBuilder:
                 lang_config = get_language_config(ext)
 
                 if lang_config and lang_config.name in self.parsers:
-                    self._process_single_file(filepath, lang_config.name)
+                    await self._process_single_file(filepath, lang_config.name)
                     file_count += 1
 
                     # Report progress after each file
@@ -832,7 +980,7 @@ class SimpleGraphBuilder:
             phase_complete=True,
         )
 
-    def _process_single_file(self, filepath: Path, language: str) -> None:
+    async def _process_single_file(self, filepath: Path, language: str) -> None:
         """Process a single file."""
         relative_path = filepath.relative_to(self.repo_path)
         relative_path_str = str(relative_path).replace(os.sep, "/")
@@ -873,8 +1021,8 @@ class SimpleGraphBuilder:
 
         # Parse file
         try:
-            with open(filepath, "rb") as f:
-                content = f.read()
+            async with aiofiles.open(filepath, "rb") as f:
+                content = await f.read()
 
             parser = self.parsers[language]
             tree = parser.parse(content)
@@ -1636,7 +1784,7 @@ class CodebaseIngestor:
             )
             if self.project_name:
                 builder.project_name = self.project_name
-            builder.run()
+            asyncio.run(builder.run())
 
             logger.info(f"Graph successfully created at: {self.db_path}")
 

shotgun/codebase/core/manager.py

@@ -371,7 +371,16 @@ class CodebaseGraphManager:
                 )
                 import shutil
 
-                shutil.rmtree(graph_path)
+                # Handle both files and directories (kuzu v0.11.2+ uses files)
+                if graph_path.is_file():
+                    graph_path.unlink()  # Delete file
+                    # Also delete WAL file if it exists
+                    wal_path = graph_path.with_suffix(graph_path.suffix + ".wal")
+                    if wal_path.exists():
+                        wal_path.unlink()
+                        logger.debug(f"Deleted WAL file: {wal_path}")
+                else:
+                    shutil.rmtree(graph_path)  # Delete directory
 
         # Import the builder from local core module
         from shotgun.codebase.core import CodebaseIngestor
@@ -760,7 +769,7 @@ class CodebaseGraphManager:
 
                     lang_config = get_language_config(full_path.suffix)
                     if lang_config and lang_config.name in parsers:
-                        builder._process_single_file(full_path, lang_config.name)
+                        await builder._process_single_file(full_path, lang_config.name)
                         stats["nodes_modified"] += 1  # Approximate
 
             # Process additions
@@ -775,7 +784,7 @@ class CodebaseGraphManager:
 
                     lang_config = get_language_config(full_path.suffix)
                     if lang_config and lang_config.name in parsers:
-                        builder._process_single_file(full_path, lang_config.name)
+                        await builder._process_single_file(full_path, lang_config.name)
                         stats["nodes_added"] += 1  # Approximate
 
             # Flush all pending operations
@@ -1742,7 +1751,7 @@ class CodebaseGraphManager:
             )
 
             # Build the graph
-            builder.run()
+            asyncio.run(builder.run())
 
         # Run build in thread pool
         await anyio.to_thread.run_sync(_build_graph)

shotgun/codebase/core/nl_query.py

@@ -34,7 +34,7 @@ async def llm_cypher_prompt(
     Returns:
         CypherGenerationResponse with cypher_query, can_generate flag, and reason if not
     """
-    model_config = get_provider_model()
+    model_config = await get_provider_model()
 
     # Create an agent with structured output for Cypher generation
     cypher_agent = Agent(

shotgun/codebase/models.py

@@ -29,6 +29,8 @@ class ProgressPhase(StrEnum):
     STRUCTURE = "structure"  # Identifying packages and folders
     DEFINITIONS = "definitions"  # Processing files and extracting definitions
     RELATIONSHIPS = "relationships"  # Processing relationships (calls, imports)
+    FLUSH_NODES = "flush_nodes"  # Flushing nodes to database
+    FLUSH_RELATIONSHIPS = "flush_relationships"  # Flushing relationships to database
 
 
 class IndexProgress(BaseModel):