shotgun-sh 0.1.12.dev3__py3-none-any.whl → 0.1.13.dev1__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -31,6 +31,7 @@ from pydantic_ai.messages import (
     SystemPromptPart,
     ToolCallPart,
     ToolCallPartDelta,
+    ToolReturnPart,
 )
 from textual.message import Message
 from textual.widget import Widget
@@ -44,7 +45,7 @@ from shotgun.utils.source_detection import detect_source
 from .export import create_export_agent
 from .history.compaction import apply_persistent_compaction
 from .messages import AgentSystemPrompt
-from .models import AgentDeps, AgentRuntimeOptions
+from .models import AgentDeps, AgentRuntimeOptions, UserAnswer
 from .plan import create_plan_agent
 from .research import create_research_agent
 from .specify import create_specify_agent
@@ -272,6 +273,8 @@ class AgentManager(Widget):
         # Use merged deps (shared state + agent-specific system prompt) if not provided
         if deps is None:
             deps = self._create_merged_deps(self._current_agent_type)
+        if not deferred_tool_results:
+            self.ensure_agent_canecelled_safely()
 
         # Ensure deps is not None
         if deps is None:
@@ -674,6 +677,32 @@ class AgentManager(Widget):
         self.ui_message_history.append(message)
         self._post_messages_updated()
 
+    def ensure_agent_canecelled_safely(self) -> None:
+        if not self.message_history:
+            return
+        self.last_response = self.message_history[-1]
+        ## we're searching for unanswered ask_user parts
+        found_tool = None
+        for part in self.message_history[-1].parts:
+            if isinstance(part, ToolCallPart) and part.tool_name == "ask_user":
+                found_tool = part
+                break
+        if not found_tool:
+            return
+        tool_result = ModelRequest(
+            parts=[
+                ToolReturnPart(
+                    tool_call_id=found_tool.tool_call_id,
+                    tool_name=found_tool.tool_name,
+                    content=UserAnswer(
+                        answer="⚠️ Operation cancelled by user",
+                        tool_call_id=found_tool.tool_call_id,
+                    ),
+                )
+            ]
+        )
+        self.message_history.append(tool_result)
+
 
 # Re-export AgentType for backward compatibility
 __all__ = [

shotgun/cli/codebase/commands.py

@@ -6,8 +6,21 @@ from pathlib import Path
 from typing import Annotated
 
 import typer
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+    TimeElapsedColumn,
+)
 
-from shotgun.codebase.models import CodebaseGraph, QueryType
+from shotgun.codebase.models import (
+    CodebaseGraph,
+    IndexProgress,
+    QueryType,
+)
 from shotgun.logging_config import get_logger
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
@@ -59,10 +72,66 @@ def index(
 ) -> None:
     """Index a new codebase."""
     sdk = CodebaseSDK()
+    console = Console()
+
+    # Create progress display
+    progress = Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+    # Track tasks by phase
+    tasks = {}
+
+    def progress_callback(progress_info: IndexProgress) -> None:
+        """Update progress display based on indexing phase."""
+        phase = progress_info.phase
+
+        # Create task if it doesn't exist
+        if phase not in tasks:
+            if progress_info.total is not None:
+                tasks[phase] = progress.add_task(
+                    progress_info.phase_name, total=progress_info.total
+                )
+            else:
+                # Indeterminate progress (spinner only)
+                tasks[phase] = progress.add_task(progress_info.phase_name, total=None)
+
+        task_id = tasks[phase]
+
+        # Update task
+        if progress_info.total is not None:
+            progress.update(
+                task_id,
+                completed=progress_info.current,
+                total=progress_info.total,
+                description=f"[bold blue]{progress_info.phase_name}",
+            )
+        else:
+            # Just update description for indeterminate tasks
+            progress.update(
+                task_id,
+                description=f"[bold blue]{progress_info.phase_name} ({progress_info.current} items)",
+            )
+
+        # Mark as complete if phase is done
+        if progress_info.phase_complete:
+            if progress_info.total is not None:
+                progress.update(task_id, completed=progress_info.total)
 
     try:
         repo_path = Path(path)
-        result = asyncio.run(sdk.index_codebase(repo_path, name))
+
+        # Run indexing with progress display
+        with progress:
+            result = asyncio.run(
+                sdk.index_codebase(repo_path, name, progress_callback=progress_callback)
+            )
+
         output_result(result, format_type)
     except InvalidPathError as e:
         error_result = ErrorResult(error_message=str(e))

shotgun/codebase/core/ingestor.py

@@ -535,6 +535,7 @@ class SimpleGraphBuilder:
         parsers: dict[str, Parser],
         queries: dict[str, Any],
         exclude_patterns: list[str] | None = None,
+        progress_callback: Any | None = None,
     ):
         self.ingestor = ingestor
         self.repo_path = repo_path
@@ -544,6 +545,7 @@ class SimpleGraphBuilder:
         self.ignore_dirs = IGNORE_PATTERNS
         if exclude_patterns:
             self.ignore_dirs = self.ignore_dirs.union(set(exclude_patterns))
+        self.progress_callback = progress_callback
 
         # Caches
         self.structural_elements: dict[Path, str | None] = {}
@@ -552,6 +554,34 @@ class SimpleGraphBuilder:
         self.simple_name_lookup: dict[str, set[str]] = defaultdict(set)
         self.class_inheritance: dict[str, list[str]] = {}  # class_qn -> [parent_qns]
 
+    def _report_progress(
+        self,
+        phase: str,
+        phase_name: str,
+        current: int,
+        total: int | None = None,
+        phase_complete: bool = False,
+    ) -> None:
+        """Report progress via callback if available."""
+        if not self.progress_callback:
+            return
+
+        try:
+            # Import here to avoid circular dependency
+            from shotgun.codebase.models import IndexProgress, ProgressPhase
+
+            progress = IndexProgress(
+                phase=ProgressPhase(phase),
+                phase_name=phase_name,
+                current=current,
+                total=total,
+                phase_complete=phase_complete,
+            )
+            self.progress_callback(progress)
+        except Exception as e:
+            # Don't let progress callback errors crash the build
+            logger.debug(f"Progress callback error: {e}")
+
     def run(self) -> None:
         """Run the three-pass graph building process."""
         logger.info(f"Building graph for project: {self.project_name}")
@@ -575,6 +605,7 @@ class SimpleGraphBuilder:
 
     def _identify_structure(self) -> None:
         """First pass: Walk directory to find packages and folders."""
+        dir_count = 0
         for root_str, dirs, _ in os.walk(self.repo_path, topdown=True):
             dirs[:] = [d for d in dirs if d not in self.ignore_dirs]
             root = Path(root_str)
@@ -584,6 +615,13 @@ class SimpleGraphBuilder:
             if root == self.repo_path:
                 continue
 
+            dir_count += 1
+            # Report progress every 10 directories
+            if dir_count % 10 == 0:
+                self._report_progress(
+                    "structure", "Identifying packages and folders", dir_count
+                )
+
             parent_rel_path = relative_root.parent
             parent_container_qn = self.structural_elements.get(parent_rel_path)
 
@@ -686,8 +724,34 @@ class SimpleGraphBuilder:
 
                 self.structural_elements[relative_root] = None
 
+        # Report phase completion
+        self._report_progress(
+            "structure",
+            "Identifying packages and folders",
+            dir_count,
+            phase_complete=True,
+        )
+
     def _process_files(self) -> None:
         """Second pass: Process files and extract definitions."""
+        # First pass: Count total files
+        total_files = 0
+        for root_str, _, files in os.walk(self.repo_path):
+            root = Path(root_str)
+
+            # Skip ignored directories
+            if any(part in self.ignore_dirs for part in root.parts):
+                continue
+
+            for filename in files:
+                filepath = root / filename
+                ext = filepath.suffix
+                lang_config = get_language_config(ext)
+
+                if lang_config and lang_config.name in self.parsers:
+                    total_files += 1
+
+        # Second pass: Process files with progress reporting
         file_count = 0
         for root_str, _, files in os.walk(self.repo_path):
             root = Path(root_str)
@@ -707,10 +771,27 @@ class SimpleGraphBuilder:
                     self._process_single_file(filepath, lang_config.name)
                     file_count += 1
 
+                    # Report progress after each file
+                    self._report_progress(
+                        "definitions",
+                        "Processing files and extracting definitions",
+                        file_count,
+                        total_files,
+                    )
+
                     if file_count % 100 == 0:
-                        logger.info(f"  Processed {file_count} files...")
+                        logger.info(f"  Processed {file_count}/{total_files} files...")
+
+        logger.info(f"  Total files processed: {file_count}/{total_files}")
 
-        logger.info(f"  Total files processed: {file_count}")
+        # Report phase completion
+        self._report_progress(
+            "definitions",
+            "Processing files and extracting definitions",
+            file_count,
+            total_files,
+            phase_complete=True,
+        )
 
     def _process_single_file(self, filepath: Path, language: str) -> None:
         """Process a single file."""
@@ -1143,7 +1224,8 @@ class SimpleGraphBuilder:
         self._process_inheritance()
 
         # Then process function calls
-        logger.info(f"Processing function calls for {len(self.ast_cache)} files...")
+        total_files = len(self.ast_cache)
+        logger.info(f"Processing function calls for {total_files} files...")
         logger.info(f"Function registry has {len(self.function_registry)} entries")
         logger.info(
             f"Simple name lookup has {len(self.simple_name_lookup)} unique names"
@@ -1157,10 +1239,29 @@ class SimpleGraphBuilder:
                     f"  Example: '{name}' -> {list(self.simple_name_lookup[name])[:3]}"
                 )
 
+        file_count = 0
         for filepath, (root_node, language) in self.ast_cache.items():
             self._process_calls(filepath, root_node, language)
             # NOTE: Add import processing. wtf does this mean?
 
+            file_count += 1
+            # Report progress after each file
+            self._report_progress(
+                "relationships",
+                "Processing relationships (calls, imports)",
+                file_count,
+                total_files,
+            )
+
+        # Report phase completion
+        self._report_progress(
+            "relationships",
+            "Processing relationships (calls, imports)",
+            file_count,
+            total_files,
+            phase_complete=True,
+        )
+
     def _process_inheritance(self) -> None:
         """Process inheritance relationships between classes."""
         logger.info("Processing inheritance relationships...")
@@ -1444,6 +1545,7 @@ class CodebaseIngestor:
         db_path: str,
         project_name: str | None = None,
         exclude_patterns: list[str] | None = None,
+        progress_callback: Any | None = None,
     ):
         """Initialize the ingestor.
 
@@ -1451,10 +1553,12 @@ class CodebaseIngestor:
             db_path: Path to Kuzu database
             project_name: Optional project name
             exclude_patterns: Patterns to exclude from processing
+            progress_callback: Optional callback for progress reporting
         """
         self.db_path = Path(db_path)
         self.project_name = project_name
         self.exclude_patterns = exclude_patterns or []
+        self.progress_callback = progress_callback
 
     def build_graph_from_directory(self, repo_path: str) -> None:
         """Build a code knowledge graph from a directory.
@@ -1484,7 +1588,12 @@ class CodebaseIngestor:
 
             # Build graph
             builder = SimpleGraphBuilder(
-                ingestor, repo_path_obj, parsers, queries, self.exclude_patterns
+                ingestor,
+                repo_path_obj,
+                parsers,
+                queries,
+                self.exclude_patterns,
+                self.progress_callback,
             )
             if self.project_name:
                 builder.project_name = self.project_name

shotgun/codebase/core/manager.py

@@ -329,6 +329,7 @@ class CodebaseGraphManager:
         languages: list[str] | None = None,
         exclude_patterns: list[str] | None = None,
         indexed_from_cwd: str | None = None,
+        progress_callback: Any | None = None,
     ) -> CodebaseGraph:
         """Build a new code knowledge graph.
 
@@ -337,6 +338,7 @@ class CodebaseGraphManager:
             name: Optional human-readable name
             languages: Languages to parse (default: all supported)
             exclude_patterns: Patterns to exclude
+            progress_callback: Optional callback for progress reporting
 
         Returns:
             Created graph metadata
@@ -353,7 +355,19 @@ class CodebaseGraphManager:
 
         # Check if graph already exists
         if graph_path.exists():
-            raise CodebaseAlreadyIndexedError(repo_path)
+            # Verify it's not corrupted by checking if we can load the Project node
+            existing_graph = await self.get_graph(graph_id)
+            if existing_graph:
+                # Valid existing graph
+                raise CodebaseAlreadyIndexedError(repo_path)
+            else:
+                # Corrupted database - remove and re-index
+                logger.warning(
+                    f"Found corrupted database at {graph_path}, removing for re-indexing..."
+                )
+                import shutil
+
+                shutil.rmtree(graph_path)
 
         # Import the builder from local core module
         from shotgun.codebase.core import CodebaseIngestor
@@ -379,6 +393,7 @@ class CodebaseGraphManager:
             db_path=str(graph_path),
             project_name=name,
             exclude_patterns=exclude_patterns or [],
+            progress_callback=progress_callback,
         )
 
         # Run build in thread pool
@@ -1193,6 +1208,136 @@ class CodebaseGraphManager:
             )
             return None
 
+    async def cleanup_corrupted_databases(self) -> list[str]:
+        """Detect and remove corrupted Kuzu databases.
+
+        This method iterates through all .kuzu files in the storage directory,
+        attempts to open them, and removes any that are corrupted or unreadable.
+
+        Returns:
+            List of graph_ids that were removed due to corruption
+        """
+        import shutil
+
+        removed_graphs = []
+
+        # Find all .kuzu files (can be files or directories)
+        for path in self.storage_dir.glob("*.kuzu"):
+            graph_id = path.stem
+
+            # If it's a plain file (not a directory), it's corrupted
+            # Valid Kuzu databases are always directories
+            if path.is_file():
+                logger.warning(
+                    f"Detected corrupted database file (should be directory) at {path}, removing it"
+                )
+                try:
+                    await anyio.to_thread.run_sync(path.unlink)
+                    removed_graphs.append(graph_id)
+                    logger.info(f"Removed corrupted database file: {graph_id}")
+                except Exception as e:
+                    logger.error(
+                        f"Failed to remove corrupted database file {graph_id}: {e}"
+                    )
+                continue
+
+            try:
+                # Try to open the database with a timeout to prevent hanging
+                async def try_open_database(
+                    gid: str = graph_id, db_path: Path = path
+                ) -> bool:
+                    lock = await self._get_lock()
+                    async with lock:
+                        # Close existing connections if any
+                        if gid in self._connections:
+                            try:
+                                self._connections[gid].close()
+                            except Exception as e:
+                                logger.debug(
+                                    f"Failed to close connection for {gid}: {e}"
+                                )
+                            del self._connections[gid]
+                        if gid in self._databases:
+                            try:
+                                self._databases[gid].close()
+                            except Exception as e:
+                                logger.debug(f"Failed to close database for {gid}: {e}")
+                            del self._databases[gid]
+
+                        # Try to open the database
+                        def _open_and_query(g: str = gid, p: Path = db_path) -> bool:
+                            db = kuzu.Database(str(p))
+                            conn = kuzu.Connection(db)
+                            try:
+                                result = conn.execute(
+                                    "MATCH (p:Project {graph_id: $graph_id}) RETURN p",
+                                    {"graph_id": g},
+                                )
+                                has_results = (
+                                    result.has_next()
+                                    if hasattr(result, "has_next")
+                                    else False
+                                )
+                                return has_results
+                            finally:
+                                conn.close()
+                                db.close()
+
+                        return await anyio.to_thread.run_sync(_open_and_query)
+
+                # Try to open with 5 second timeout
+                has_project = await asyncio.wait_for(try_open_database(), timeout=5.0)
+
+                if not has_project:
+                    # Database exists but has no Project node - consider it corrupted
+                    raise ValueError("No Project node found in database")
+
+            except (Exception, asyncio.TimeoutError) as e:
+                # Database is corrupted or timed out - remove it
+                error_type = (
+                    "timed out" if isinstance(e, asyncio.TimeoutError) else "corrupted"
+                )
+                logger.warning(
+                    f"Detected {error_type} database at {path}, removing it. "
+                    f"Error: {str(e) if not isinstance(e, asyncio.TimeoutError) else 'Operation timed out after 5 seconds'}"
+                )
+
+                try:
+                    # Clean up any open connections
+                    lock = await self._get_lock()
+                    async with lock:
+                        if graph_id in self._connections:
+                            try:
+                                self._connections[graph_id].close()
+                            except Exception as e:
+                                logger.debug(
+                                    f"Failed to close connection during cleanup for {graph_id}: {e}"
+                                )
+                            del self._connections[graph_id]
+                        if graph_id in self._databases:
+                            try:
+                                self._databases[graph_id].close()
+                            except Exception as e:
+                                logger.debug(
+                                    f"Failed to close database during cleanup for {graph_id}: {e}"
+                                )
+                            del self._databases[graph_id]
+
+                    # Remove the database (could be file or directory)
+                    if path.is_dir():
+                        await anyio.to_thread.run_sync(shutil.rmtree, path)
+                    else:
+                        await anyio.to_thread.run_sync(path.unlink)
+                    removed_graphs.append(graph_id)
+                    logger.info(f"Removed {error_type} database: {graph_id}")
+
+                except Exception as cleanup_error:
+                    logger.error(
+                        f"Failed to remove corrupted database {graph_id}: {cleanup_error}"
+                    )
+
+        return removed_graphs
+
     async def list_graphs(self) -> list[CodebaseGraph]:
         """List all available graphs.
 
@@ -1464,6 +1609,7 @@ class CodebaseGraphManager:
         languages: list[str] | None,
         exclude_patterns: list[str] | None,
         indexed_from_cwd: str | None = None,
+        progress_callback: Any | None = None,
     ) -> CodebaseGraph:
         """Internal implementation of graph building (runs in background)."""
         operation_id = str(uuid.uuid4())
@@ -1487,7 +1633,13 @@ class CodebaseGraphManager:
 
             # Do the actual build work
             graph = await self._do_build_graph(
-                graph_id, repo_path, name, languages, exclude_patterns, indexed_from_cwd
+                graph_id,
+                repo_path,
+                name,
+                languages,
+                exclude_patterns,
+                indexed_from_cwd,
+                progress_callback,
             )
 
             # Update operation stats
@@ -1536,6 +1688,7 @@ class CodebaseGraphManager:
         languages: list[str] | None,
         exclude_patterns: list[str] | None,
         indexed_from_cwd: str | None = None,
+        progress_callback: Any | None = None,
     ) -> CodebaseGraph:
         """Execute the actual graph building logic (extracted from original build_graph)."""
         # The database and Project node already exist from _initialize_graph_metadata
@@ -1591,6 +1744,7 @@ class CodebaseGraphManager:
                 parsers=parsers,
                 queries=queries,
                 exclude_patterns=exclude_patterns,
+                progress_callback=progress_callback,
             )
 
             # Build the graph
@@ -1616,6 +1770,7 @@ class CodebaseGraphManager:
         languages: list[str] | None = None,
         exclude_patterns: list[str] | None = None,
         indexed_from_cwd: str | None = None,
+        progress_callback: Any | None = None,
     ) -> str:
         """Start building a new code knowledge graph asynchronously.
 
@@ -1654,7 +1809,13 @@ class CodebaseGraphManager:
         # Start the build operation in background
         task = asyncio.create_task(
             self._build_graph_impl(
-                graph_id, repo_path, name, languages, exclude_patterns, indexed_from_cwd
+                graph_id,
+                repo_path,
+                name,
+                languages,
+                exclude_patterns,
+                indexed_from_cwd,
+                progress_callback,
             )
         )
         self._operations[graph_id] = task

shotgun/codebase/models.py

@@ -1,5 +1,6 @@
 """Data models for codebase service."""
 
+from collections.abc import Callable
 from enum import Enum
 from typing import Any
 
@@ -22,6 +23,30 @@ class QueryType(str, Enum):
     CYPHER = "cypher"
 
 
+class ProgressPhase(str, Enum):
+    """Phase of codebase indexing progress."""
+
+    STRUCTURE = "structure"  # Identifying packages and folders
+    DEFINITIONS = "definitions"  # Processing files and extracting definitions
+    RELATIONSHIPS = "relationships"  # Processing relationships (calls, imports)
+
+
+class IndexProgress(BaseModel):
+    """Progress information for codebase indexing."""
+
+    phase: ProgressPhase = Field(..., description="Current indexing phase")
+    phase_name: str = Field(..., description="Human-readable phase name")
+    current: int = Field(..., description="Current item count")
+    total: int | None = Field(None, description="Total items (None if unknown)")
+    phase_complete: bool = Field(
+        default=False, description="Whether this phase is complete"
+    )
+
+
+# Type alias for progress callback function
+ProgressCallback = Callable[[IndexProgress], None]
+
+
 class OperationStats(BaseModel):
     """Statistics for a graph operation (build/update)."""
 

shotgun/codebase/service.py

@@ -69,11 +69,19 @@ class CodebaseService:
             # Otherwise, check if current directory is in the allowed list
             elif target_path in graph.indexed_from_cwds:
                 filtered_graphs.append(graph)
+            # Also allow access if current directory IS the repository itself
+            # Use Path.resolve() for robust comparison (handles symlinks, etc.)
+            elif Path(target_path).resolve() == Path(graph.repo_path).resolve():
+                filtered_graphs.append(graph)
 
         return filtered_graphs
 
     async def create_graph(
-        self, repo_path: str | Path, name: str, indexed_from_cwd: str | None = None
+        self,
+        repo_path: str | Path,
+        name: str,
+        indexed_from_cwd: str | None = None,
+        progress_callback: Any | None = None,
     ) -> CodebaseGraph:
         """Create and index a new graph from a repository.
 
@@ -81,12 +89,16 @@ class CodebaseService:
             repo_path: Path to the repository to index
             name: Human-readable name for the graph
             indexed_from_cwd: Working directory from which indexing was initiated
+            progress_callback: Optional callback for progress reporting
 
         Returns:
             The created CodebaseGraph
         """
         return await self.manager.build_graph(
-            str(repo_path), name, indexed_from_cwd=indexed_from_cwd
+            str(repo_path),
+            name,
+            indexed_from_cwd=indexed_from_cwd,
+            progress_callback=progress_callback,
         )
 
     async def get_graph(self, graph_id: str) -> CodebaseGraph | None:

shotgun/prompts/codebase/partials/cypher_rules.j2

@@ -21,4 +21,17 @@
   MATCH (f:Function) RETURN f.name AS name, f.qualified_name AS qname
   UNION ALL
   MATCH (m:Method) RETURN m.name AS name, m.qualified_name AS qname, m.path AS path  // ERROR: Extra column!
+  ```
+- **NULL Type Casting in UNION ALL**: When a property doesn't exist on a node type, you MUST use a typed placeholder instead of bare NULL. Bare NULL has type ANY which causes "qualified_name has data type ANY but STRING was expected" errors.
+  CORRECT usage (use empty string or explicit cast):
+  ```
+  MATCH (f:Function) RETURN f.name AS name, f.qualified_name AS qname, 'Function' AS type
+  UNION ALL
+  MATCH (fi:File) RETURN fi.name AS name, '' AS qname, 'File' AS type  // Empty string for missing STRING property
+  ```
+  INCORRECT usage (bare NULL causes type mismatch):
+  ```
+  MATCH (f:Function) RETURN f.name AS name, f.qualified_name AS qname, 'Function' AS type
+  UNION ALL
+  MATCH (fi:File) RETURN fi.name AS name, NULL AS qname, 'File' AS type  // ERROR: NULL is type ANY, not STRING!
   ```

shotgun/sdk/codebase.py

@@ -3,6 +3,7 @@
 import asyncio
 from collections.abc import Awaitable, Callable
 from pathlib import Path
+from typing import Any
 
 from shotgun.codebase.models import CodebaseGraph, QueryType
 from shotgun.logging_config import get_logger
@@ -63,7 +64,11 @@ class CodebaseSDK:
         return ListResult(graphs=graphs)
 
     async def index_codebase(
-        self, path: Path, name: str, indexed_from_cwd: str | None = None
+        self,
+        path: Path,
+        name: str,
+        indexed_from_cwd: str | None = None,
+        progress_callback: Any | None = None,
     ) -> IndexResult:
         """Index a new codebase.
 
@@ -72,6 +77,7 @@ class CodebaseSDK:
             name: Human-readable name for the codebase
             indexed_from_cwd: Working directory from which indexing was initiated.
                             If None, uses current working directory.
+            progress_callback: Optional callback for progress reporting
 
         Returns:
             IndexResult with indexing details
@@ -88,7 +94,10 @@ class CodebaseSDK:
             indexed_from_cwd = str(Path.cwd().resolve())
 
         graph = await self.service.create_graph(
-            resolved_path, name, indexed_from_cwd=indexed_from_cwd
+            resolved_path,
+            name,
+            indexed_from_cwd=indexed_from_cwd,
+            progress_callback=progress_callback,
         )
         file_count = sum(graph.language_stats.values()) if graph.language_stats else 0
 

shotgun/tui/app.py

@@ -100,6 +100,26 @@ def run(no_update_check: bool = False, continue_session: bool = False) -> None:
         no_update_check: If True, disable automatic update checks.
         continue_session: If True, continue from previous conversation.
     """
+    # Clean up any corrupted databases BEFORE starting the TUI
+    # This prevents crashes from corrupted databases during initialization
+    import asyncio
+
+    from shotgun.codebase.core.manager import CodebaseGraphManager
+    from shotgun.utils import get_shotgun_home
+
+    storage_dir = get_shotgun_home() / "codebases"
+    manager = CodebaseGraphManager(storage_dir)
+
+    try:
+        removed = asyncio.run(manager.cleanup_corrupted_databases())
+        if removed:
+            logger.info(
+                f"Cleaned up {len(removed)} corrupted database(s) before TUI startup"
+            )
+    except Exception as e:
+        logger.error(f"Failed to cleanup corrupted databases: {e}")
+        # Continue anyway - the TUI can still function
+
     app = ShotgunApp(no_update_check=no_update_check, continue_session=continue_session)
     app.run(inline_no_clear=True)
 

shotgun/tui/screens/chat.py

@@ -41,6 +41,7 @@ from shotgun.agents.models import (
     UserQuestion,
 )
 from shotgun.codebase.core.manager import CodebaseAlreadyIndexedError
+from shotgun.codebase.models import IndexProgress, ProgressPhase
 from shotgun.posthog_telemetry import track_event
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
@@ -592,6 +593,68 @@ class ChatScreen(Screen[None]):
             f"[$foreground-muted]Indexing [bold $text-accent]{selection.name}[/]...[/]"
         )
         label.refresh()
+
+        def create_progress_bar(percentage: float, width: int = 20) -> str:
+            """Create a visual progress bar using Unicode block characters."""
+            filled = int((percentage / 100) * width)
+            empty = width - filled
+            return "▓" * filled + "░" * empty
+
+        # Spinner animation state (shared between timer and progress callback)
+        spinner_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        spinner_state: dict[str, int | str | float] = {
+            "frame_index": 0,
+            "phase_name": "Starting...",
+            "percentage": 0.0,
+        }
+
+        def update_spinner_display() -> None:
+            """Update spinner frame on timer - runs every 100ms."""
+            # Advance spinner frame
+            frame_idx = int(spinner_state["frame_index"])
+            spinner_state["frame_index"] = (frame_idx + 1) % len(spinner_frames)
+            spinner = spinner_frames[frame_idx]
+
+            # Get current state
+            phase = str(spinner_state["phase_name"])
+            pct = float(spinner_state["percentage"])
+            bar = create_progress_bar(pct)
+
+            # Update label
+            label.update(
+                f"[$foreground-muted]Indexing codebase: {spinner} {phase}... {bar} {pct:.0f}%[/]"
+            )
+
+        def progress_callback(progress_info: IndexProgress) -> None:
+            """Update progress state (spinner animates independently on timer)."""
+            # Calculate overall percentage (0-95%, reserve 95-100% for finalization)
+            if progress_info.phase == ProgressPhase.STRUCTURE:
+                # Phase 1: 0-10%, always show 5% while running, 10% when complete
+                overall_pct = 10.0 if progress_info.phase_complete else 5.0
+            elif progress_info.phase == ProgressPhase.DEFINITIONS:
+                # Phase 2: 10-80% based on files processed
+                if progress_info.total and progress_info.total > 0:
+                    phase_pct = (progress_info.current / progress_info.total) * 70.0
+                    overall_pct = 10.0 + phase_pct
+                else:
+                    overall_pct = 10.0
+            elif progress_info.phase == ProgressPhase.RELATIONSHIPS:
+                # Phase 3: 80-95% based on relationships processed (cap at 95%)
+                if progress_info.total and progress_info.total > 0:
+                    phase_pct = (progress_info.current / progress_info.total) * 15.0
+                    overall_pct = 80.0 + phase_pct
+                else:
+                    overall_pct = 80.0
+            else:
+                overall_pct = 0.0
+
+            # Update shared state (timer will render it)
+            spinner_state["phase_name"] = progress_info.phase_name
+            spinner_state["percentage"] = overall_pct
+
+        # Start spinner animation timer (10 fps = 100ms interval)
+        spinner_timer = self.set_interval(0.1, update_spinner_display)
+
         try:
             # Pass the current working directory as the indexed_from_cwd
             logger.debug(
@@ -602,7 +665,19 @@ class ChatScreen(Screen[None]):
                 selection.repo_path,
                 selection.name,
                 indexed_from_cwd=str(Path.cwd().resolve()),
+                progress_callback=progress_callback,
             )
+
+            # Stop spinner animation
+            spinner_timer.stop()
+
+            # Show 100% completion after indexing finishes
+            final_bar = create_progress_bar(100.0)
+            label.update(
+                f"[$foreground-muted]Indexing codebase: ✓ Complete {final_bar} 100%[/]"
+            )
+            label.refresh()
+
             logger.info(
                 f"Successfully indexed codebase '{result.name}' (ID: {result.graph_id})"
             )
@@ -613,10 +688,12 @@ class ChatScreen(Screen[None]):
             )
 
         except CodebaseAlreadyIndexedError as exc:
+            spinner_timer.stop()
             logger.warning(f"Codebase already indexed: {exc}")
             self.notify(str(exc), severity="warning")
             return
         except InvalidPathError as exc:
+            spinner_timer.stop()
             logger.error(f"Invalid path error: {exc}")
             self.notify(str(exc), severity="error")
 
@@ -628,6 +705,8 @@ class ChatScreen(Screen[None]):
             )
             self.notify(f"Failed to index codebase: {exc}", severity="error")
         finally:
+            # Always stop the spinner timer
+            spinner_timer.stop()
             label.update("")
             label.refresh()
 
@@ -667,6 +746,7 @@ class ChatScreen(Screen[None]):
         except asyncio.CancelledError:
             # Handle cancellation gracefully - DO NOT re-raise
             self.mount_hint("⚠️ Operation cancelled by user")
+            self.agent_manager.ensure_agent_canecelled_safely()
         finally:
             self.working = False
             self._current_worker = None

shotgun/tui/screens/chat_screen/history.py

@@ -238,25 +238,97 @@ class AgentResponseWidget(Widget):
                     continue
         return acc.strip()
 
+    def _truncate(self, text: str, max_length: int = 100) -> str:
+        """Truncate text to max_length characters, adding ellipsis if needed."""
+        if len(text) <= max_length:
+            return text
+        return text[: max_length - 3] + "..."
+
+    def _parse_args(self, args: dict[str, object] | str | None) -> dict[str, object]:
+        """Parse tool call arguments, handling both dict and JSON string formats."""
+        if args is None:
+            return {}
+        if isinstance(args, str):
+            try:
+                return json.loads(args) if args.strip() else {}
+            except json.JSONDecodeError:
+                return {}
+        return args if isinstance(args, dict) else {}
+
     def _format_tool_call_part(self, part: ToolCallPart) -> str:
         if part.tool_name == "ask_user":
             return self._format_ask_user_part(part)
+
+        # Parse args once (handles both JSON string and dict)
+        args = self._parse_args(part.args)
+
+        # Codebase tools - show friendly names
+        if part.tool_name == "query_graph":
+            if "query" in args:
+                query = self._truncate(str(args["query"]))
+                return f'Querying code: "{query}"'
+            return "Querying code"
+
+        if part.tool_name == "retrieve_code":
+            if "qualified_name" in args:
+                return f'Retrieving code: "{args["qualified_name"]}"'
+            return "Retrieving code"
+
+        if part.tool_name == "file_read":
+            if "file_path" in args:
+                return f'Reading file: "{args["file_path"]}"'
+            return "Reading file"
+
+        if part.tool_name == "directory_lister":
+            if "directory" in args:
+                return f'Listing directory: "{args["directory"]}"'
+            return "Listing directory"
+
+        if part.tool_name == "codebase_shell":
+            command = args.get("command", "")
+            cmd_args = args.get("args", [])
+            # Handle cmd_args as list of strings
+            if isinstance(cmd_args, list):
+                args_str = " ".join(str(arg) for arg in cmd_args)
+            else:
+                args_str = ""
+            full_cmd = f"{command} {args_str}".strip()
+            if full_cmd:
+                return f'Running shell: "{self._truncate(full_cmd)}"'
+            return "Running shell"
+
+        # File management tools
+        if part.tool_name == "read_file":
+            if "filename" in args:
+                return f'Reading file: "{args["filename"]}"'
+            return "Reading file"
+
+        # Web search tools
+        if part.tool_name in [
+            "openai_web_search_tool",
+            "anthropic_web_search_tool",
+            "gemini_web_search_tool",
+        ]:
+            if "query" in args:
+                query = self._truncate(str(args["query"]))
+                return f'Searching web: "{query}"'
+            return "Searching web"
+
         # write_file
         if part.tool_name == "write_file" or part.tool_name == "append_file":
-            if isinstance(part.args, dict) and "filename" in part.args:
-                return f"{part.tool_name}({part.args['filename']})"
-            else:
-                return f"{part.tool_name}()"
+            if "filename" in args:
+                return f"{part.tool_name}({args['filename']})"
+            return f"{part.tool_name}()"
+
         if part.tool_name == "write_artifact_section":
-            if isinstance(part.args, dict) and "section_title" in part.args:
-                return f"{part.tool_name}({part.args['section_title']})"
-            else:
-                return f"{part.tool_name}()"
+            if "section_title" in args:
+                return f"{part.tool_name}({args['section_title']})"
+            return f"{part.tool_name}()"
+
         if part.tool_name == "create_artifact":
-            if isinstance(part.args, dict) and "name" in part.args:
-                return f"{part.tool_name}({part.args['name']})"
-            else:
-                return f"▪ {part.tool_name}()"
+            if "name" in args:
+                return f"{part.tool_name}({args['name']})"
+            return f"▪ {part.tool_name}()"
 
         return f"{part.tool_name}({part.args})"
 

{shotgun_sh-0.1.12.dev3.dist-info → shotgun_sh-0.1.13.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.12.dev3
+Version: 0.1.13.dev1
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun

{shotgun_sh-0.1.12.dev3.dist-info → shotgun_sh-0.1.13.dev1.dist-info}/RECORD

@@ -7,7 +7,7 @@ shotgun/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/sentry_telemetry.py,sha256=L7jFMNAnDIENWVeQYSLpyul2nmIm2w3wnOp2kDP_cic,2902
 shotgun/telemetry.py,sha256=Ves6Ih3hshpKVNVAUUmwRdtW8NkTjFPg8hEqvFKZ0t0,3208
 shotgun/agents/__init__.py,sha256=8Jzv1YsDuLyNPFJyckSr_qI4ehTVeDyIMDW4omsfPGc,25
-shotgun/agents/agent_manager.py,sha256=01MafRjUDFre00mZUWIyOImdBkylpEG75mLNuQ0cJv4,25308
+shotgun/agents/agent_manager.py,sha256=hmJlcOX98vLn5hYuzjC_cDGpDc89DMjCpQupK-Gq2WU,26393
 shotgun/agents/common.py,sha256=vt7ECq1rT6GR5Rt63t0whH0R0cydrk7Mty2KyPL8mEg,19045
 shotgun/agents/conversation_history.py,sha256=5J8_1yxdZiiWTq22aDio88DkBDZ4_Lh_p5Iy5_ENszc,3898
 shotgun/agents/conversation_manager.py,sha256=fxAvXbEl3Cl2ugJ4N9aWXaqZtkrnfj3QzwjWC4LFXwI,3514
@@ -58,18 +58,18 @@ shotgun/cli/tasks.py,sha256=17qWoGCVYpNIxa2vaoIH1P-xz2RcGLaK8SF4JlPsOWI,2420
 shotgun/cli/update.py,sha256=Dn_No7jPmdZ-7qYlhzI0BtmlufetVdw1BN-xRi_UE5A,4718
 shotgun/cli/utils.py,sha256=umVWXDx8pelovMk-nT8B7m0c39AKY9hHsuAMnbw_Hcg,732
 shotgun/cli/codebase/__init__.py,sha256=rKdvx33p0i_BYbNkz5_4DCFgEMwzOOqLi9f5p7XTLKM,73
-shotgun/cli/codebase/commands.py,sha256=zvcM9gjHHO6styhXojb_1bnpq-Cozh2c77ZOIjw4B8s,6683
+shotgun/cli/codebase/commands.py,sha256=1N2yOGmok0ZarqXPIpWGcsQrwm_ZJcyWiMxy6tm0j70,8711
 shotgun/cli/codebase/models.py,sha256=B9vs-d-Bq0aS6FZKebhHT-9tw90Y5f6k_t71VlZpL8k,374
 shotgun/codebase/__init__.py,sha256=QBgFE2Abd5Vl7_NdYOglF9S6d-vIjkb3C0cpIYoHZEU,309
-shotgun/codebase/models.py,sha256=hxjbfDUka8loTApXq9KTvkXKt272fzdjr5u2ImYrNtk,4367
-shotgun/codebase/service.py,sha256=CZR5f1vZyUS3gVXuDiZj0cIuuxiR7fbkHK65PTPAovI,7504
+shotgun/codebase/models.py,sha256=1AAipm6KrGOHmYBBavugnyeOsVkzX-YXAD6dDsSVRWg,5299
+shotgun/codebase/service.py,sha256=nyggapfHKdwkKXyuT9oA0tJ9qf4RNVsOxfY8lC5pHro,8006
 shotgun/codebase/core/__init__.py,sha256=GWWhJEqChiDXAF4omYCgzgoZmJjwsAf6P1aZ5Bl8OE0,1170
 shotgun/codebase/core/change_detector.py,sha256=kWCYLWzRzb3IGGOj71KBn7UOCOKMpINJbOBDf98aMxE,12409
 shotgun/codebase/core/code_retrieval.py,sha256=_JVyyQKHDFm3dxOOua1mw9eIIOHIVz3-I8aZtEsEj1E,7927
 shotgun/codebase/core/cypher_models.py,sha256=Yfysfa9lLguILftkmtuJCN3kLBFIo7WW7NigM-Zr-W4,1735
-shotgun/codebase/core/ingestor.py,sha256=H_kVCqdOKmnQpjcXvUdPFpep8OC2AbOhhE-9HKr_XZM,59836
+shotgun/codebase/core/ingestor.py,sha256=yh6BEIuUUfXU3dVpP0Llk19SrxA-uo3pdGnfcQsDsSo,63368
 shotgun/codebase/core/language_config.py,sha256=vsqHyuFnumRPRBV1lMOxWKNOIiClO6FyfKQR0fGrtl4,8934
-shotgun/codebase/core/manager.py,sha256=6gyjfACbC5n1Hdy-JQIEDH2aNAlesUS9plQP_FHoJ94,59277
+shotgun/codebase/core/manager.py,sha256=nwyDv6bnyZRIerra8LSC41fJasmfSs7mGpVYbbKGeYs,66378
 shotgun/codebase/core/nl_query.py,sha256=kPoSJXBlm5rLhzOofZhqPVMJ_Lj3rV2H6sld6BwtMdg,16115
 shotgun/codebase/core/parser_loader.py,sha256=LZRrDS8Sp518jIu3tQW-BxdwJ86lnsTteI478ER9Td8,4278
 shotgun/prompts/__init__.py,sha256=RswUm0HMdfm2m2YKUwUsEdRIwoczdbI7zlucoEvHYRo,132
@@ -90,19 +90,19 @@ shotgun/prompts/codebase/__init__.py,sha256=NYuPMtmYM2ptuwf3YxVuotNlJOUq0hnjmwlz
 shotgun/prompts/codebase/cypher_query_patterns.j2,sha256=ufTx_xT3VoS76KcVUbIgGQx-bJoJHx3bBE3dagAXv18,8913
 shotgun/prompts/codebase/cypher_system.j2,sha256=jo8d_AIoyAd0zKCvPXSmYGBxvtulMsCfeaOTdOfeC5g,2620
 shotgun/prompts/codebase/enhanced_query_context.j2,sha256=WzGnFaBLZO-mOdkZ_u_PewSu9niKy87DKNL4uzQq1Jg,724
-shotgun/prompts/codebase/partials/cypher_rules.j2,sha256=vtc5OqTp-z5Rq_ti-_RG31bVOIA_iNe80_x3CdxO6bs,2397
+shotgun/prompts/codebase/partials/cypher_rules.j2,sha256=yhptyyZNzFNJWFGmOkxpF5PzZtUAXWDF4xl9ADu7yDw,3200
 shotgun/prompts/codebase/partials/graph_schema.j2,sha256=fUsD1ZgU1pIWUzrs97jHq3TatKeGSvZgG8XP5gCQUJc,1939
 shotgun/prompts/codebase/partials/temporal_context.j2,sha256=yYHQHBQ4EeSs6TtKPm9fflGW3y6H0-yAANcTdsApkk4,1388
 shotgun/prompts/history/__init__.py,sha256=wbMLQ8yWmYz1sfXXigEAUlNkFcM50KdQv0kp4VU_P58,43
 shotgun/prompts/history/incremental_summarization.j2,sha256=GmnNh0pWTjaEaI1sPwKNsGCys5fK8xrzWqalAs_LhJw,2447
 shotgun/prompts/history/summarization.j2,sha256=OYNVHg65zbuWB6_pXzTOs2T2k5qFD2gyfbmr6NP01rs,2268
 shotgun/sdk/__init__.py,sha256=ESV0WM9MigjXG30g9qVjcCMI40GQv-P-MSMGVuOisK4,380
-shotgun/sdk/codebase.py,sha256=3FzSI9eCg7idps_cD-cnRwMIsJVAVhZQWBR0bU4hdA8,8602
+shotgun/sdk/codebase.py,sha256=7doUvwwl27RDJZIbP56LQsAx26GANtAKEBptTUhLT6w,8842
 shotgun/sdk/exceptions.py,sha256=qBcQv0v7ZTwP7CMcxZST4GqCsfOWtOUjSzGBo0-heqo,412
 shotgun/sdk/models.py,sha256=X9nOTUHH0cdkQW1NfnMEDu-QgK9oUsEISh1Jtwr5Am4,5496
 shotgun/sdk/services.py,sha256=J4PJFSxCQ6--u7rb3Ta-9eYtlYcxcbnzrMP6ThyCnw4,705
 shotgun/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shotgun/tui/app.py,sha256=3_g11ZyhJ0avcnX0vundJ9dF2EkkcZnHBBSYzg-P_54,3583
+shotgun/tui/app.py,sha256=xosEcdzWzRv0Aa0ZLJ04DYlYPpJ6dk2BITEPNLyFxms,4330
 shotgun/tui/filtered_codebase_service.py,sha256=lJ8gTMhIveTatmvmGLP299msWWTkVYKwvY_2FhuL2s4,1687
 shotgun/tui/styles.tcss,sha256=ETyyw1bpMBOqTi5RLcAJUScdPWTvAWEqE9YcT0kVs_E,121
 shotgun/tui/commands/__init__.py,sha256=8D5lvtpqMW5-fF7Bg3oJtUzU75cKOv6aUaHYYszydU8,2518
@@ -110,7 +110,7 @@ shotgun/tui/components/prompt_input.py,sha256=Ss-htqraHZAPaehGE4x86ij0veMjc4Ugad
 shotgun/tui/components/spinner.py,sha256=ovTDeaJ6FD6chZx_Aepia6R3UkPOVJ77EKHfRmn39MY,2427
 shotgun/tui/components/splash.py,sha256=vppy9vEIEvywuUKRXn2y11HwXSRkQZHLYoVjhDVdJeU,1267
 shotgun/tui/components/vertical_tail.py,sha256=kROwTaRjUwVB7H35dtmNcUVPQqNYvvfq7K2tXBKEb6c,638
-shotgun/tui/screens/chat.py,sha256=HYHiHpvek465tOX2YBs_O1en29O524qaDlB3R_8Z9s4,27304
+shotgun/tui/screens/chat.py,sha256=1XpiST6yIiFFGDN8VEQis9m4dWPvPdl7Bk_7avSsGUg,30928
 shotgun/tui/screens/chat.tcss,sha256=2Yq3E23jxsySYsgZf4G1AYrYVcpX0UDW6kNNI0tDmtM,437
 shotgun/tui/screens/directory_setup.py,sha256=lIZ1J4A6g5Q2ZBX8epW7BhR96Dmdcg22CyiM5S-I5WU,3237
 shotgun/tui/screens/provider_config.py,sha256=A_tvDHF5KLP5PV60LjMJ_aoOdT3TjI6_g04UIUqGPqM,7126
@@ -118,7 +118,7 @@ shotgun/tui/screens/splash.py,sha256=E2MsJihi3c9NY1L28o_MstDxGwrCnnV7zdq00MrGAsw
 shotgun/tui/screens/chat_screen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/tui/screens/chat_screen/command_providers.py,sha256=55JIH9T8QnyHRsMoXhOi87FiVM-d6o7OKpCe82uDP9I,7840
 shotgun/tui/screens/chat_screen/hint_message.py,sha256=WOpbk8q7qt7eOHTyyHvh_IQIaublVDeJGaLpsxEk9FA,933
-shotgun/tui/screens/chat_screen/history.py,sha256=BncDlwXks5wKosPlU4_TioYVMWeep8gDxtpAQsgiB9k,9717
+shotgun/tui/screens/chat_screen/history.py,sha256=NVLA3_tERTyB4vkH71w8ef_M5CszfkwbQOuMb100Fzc,12272
 shotgun/tui/utils/__init__.py,sha256=cFjDfoXTRBq29wgP7TGRWUu1eFfiIG-LLOzjIGfadgI,150
 shotgun/tui/utils/mode_progress.py,sha256=lseRRo7kMWLkBzI3cU5vqJmS2ZcCjyRYf9Zwtvc-v58,10931
 shotgun/utils/__init__.py,sha256=WinIEp9oL2iMrWaDkXz2QX4nYVPAm8C9aBSKTeEwLtE,198
@@ -126,8 +126,8 @@ shotgun/utils/env_utils.py,sha256=8QK5aw_f_V2AVTleQQlcL0RnD4sPJWXlDG46fsHu0d8,10
 shotgun/utils/file_system_utils.py,sha256=l-0p1bEHF34OU19MahnRFdClHufThfGAjQ431teAIp0,1004
 shotgun/utils/source_detection.py,sha256=Co6Q03R3fT771TF3RzB-70stfjNP2S4F_ArZKibwzm8,454
 shotgun/utils/update_checker.py,sha256=IgzPHRhS1ETH7PnJR_dIx6lxgr1qHpCkMTgzUxvGjhI,7586
-shotgun_sh-0.1.12.dev3.dist-info/METADATA,sha256=DVBz9JPoN3t6ypYy6oit9oEExatPN8WDvVlcvA1bFp4,11197
-shotgun_sh-0.1.12.dev3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-shotgun_sh-0.1.12.dev3.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
-shotgun_sh-0.1.12.dev3.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
-shotgun_sh-0.1.12.dev3.dist-info/RECORD,,
+shotgun_sh-0.1.13.dev1.dist-info/METADATA,sha256=ghoaqJH6WWZee1-qvat2Ac1RV9Ky6zvQkxJffBLvf_A,11197
+shotgun_sh-0.1.13.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+shotgun_sh-0.1.13.dev1.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
+shotgun_sh-0.1.13.dev1.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
+shotgun_sh-0.1.13.dev1.dist-info/RECORD,,