shotgun-sh 0.1.0.dev1__py3-none-any.whl

shotgun/cli/tasks.py

@@ -0,0 +1,71 @@
+"""Tasks command for shotgun CLI."""
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+from shotgun.agents.config import ProviderType
+from shotgun.agents.models import AgentRuntimeOptions
+from shotgun.agents.tasks import (
+    create_tasks_agent,
+    get_tasks_history,
+    run_tasks_agent,
+)
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(name="tasks", help="Generate task lists with agentic approach")
+logger = get_logger(__name__)
+
+
+@app.callback(invoke_without_command=True)
+def tasks(
+    instruction: Annotated[
+        str, typer.Argument(help="Task creation instruction or project description")
+    ],
+    non_interactive: Annotated[
+        bool,
+        typer.Option(
+            "--non-interactive", "-n", help="Disable user interaction (for CI/CD)"
+        ),
+    ] = False,
+    provider: Annotated[
+        ProviderType | None,
+        typer.Option("--provider", "-p", help="AI provider to use (overrides default)"),
+    ] = None,
+) -> None:
+    """Generate actionable task lists based on existing research and plans.
+
+    This command creates detailed task breakdowns using AI agents that analyze
+    your research and plans to generate prioritized, actionable tasks with
+    acceptance criteria and effort estimates.
+    """
+
+    logger.info("📋 Task Creation Instruction: %s", instruction)
+
+    try:
+        # Create agent dependencies
+        agent_runtime_options = AgentRuntimeOptions(
+            interactive_mode=not non_interactive
+        )
+
+        # Create the tasks agent with deps and provider
+        agent, deps = create_tasks_agent(agent_runtime_options, provider)
+
+        # Start task creation process
+        logger.info("🎯 Starting task creation...")
+        result = asyncio.run(run_tasks_agent(agent, instruction, deps))
+
+        # Display results
+        logger.info("✅ Task Creation Complete!")
+        logger.info("📋 Results:")
+        logger.info("%s", result.output)
+        logger.info("📄 Tasks saved to: .shotgun/tasks.md")
+        logger.debug("📚 Current tasks:")
+        logger.debug("%s", get_tasks_history())
+
+    except Exception as e:
+        logger.error("❌ Error during task creation: %s", str(e))
+        import traceback
+
+        logger.debug("Full traceback:\n%s", traceback.format_exc())

shotgun/cli/utils.py

@@ -0,0 +1,25 @@
+"""Common utilities for CLI commands."""
+
+import json
+from typing import Any
+
+from pydantic import BaseModel
+
+from .models import OutputFormat
+
+
+def format_result_json(result: Any) -> str:
+    """Format result object as JSON using Pydantic serialization."""
+    if isinstance(result, BaseModel):
+        return result.model_dump_json(indent=2)
+    else:
+        # Fallback for non-Pydantic objects
+        return json.dumps({"result": str(result)}, indent=2)
+
+
+def output_result(result: Any, format_type: OutputFormat = OutputFormat.TEXT) -> None:
+    """Output result in specified format."""
+    if format_type == OutputFormat.JSON:
+        print(format_result_json(result))
+    else:  # Default to text
+        print(str(result))

shotgun/codebase/__init__.py

@@ -0,0 +1,12 @@
+"""Shotgun codebase analysis and graph management."""
+
+from shotgun.codebase.models import CodebaseGraph, GraphStatus, QueryResult, QueryType
+from shotgun.codebase.service import CodebaseService
+
+__all__ = [
+    "CodebaseService",
+    "CodebaseGraph",
+    "GraphStatus",
+    "QueryResult",
+    "QueryType",
+]

shotgun/codebase/core/__init__.py

@@ -0,0 +1,46 @@
+"""Core components for codebase understanding."""
+
+from shotgun.codebase.core.code_retrieval import (
+    CodeSnippet,
+    retrieve_code_by_cypher,
+    retrieve_code_by_qualified_name,
+)
+from shotgun.codebase.core.ingestor import (
+    CodebaseIngestor,
+    Ingestor,
+    SimpleGraphBuilder,
+)
+from shotgun.codebase.core.language_config import (
+    LANGUAGE_CONFIGS,
+    LanguageConfig,
+    get_language_config,
+)
+from shotgun.codebase.core.manager import CodebaseGraphManager
+from shotgun.codebase.core.nl_query import (
+    clean_cypher_response,
+    generate_cypher,
+    generate_cypher_openai_async,
+)
+from shotgun.codebase.core.parser_loader import load_parsers
+
+__all__ = [
+    # Ingestor classes
+    "CodebaseIngestor",
+    "Ingestor",
+    "SimpleGraphBuilder",
+    "CodebaseGraphManager",
+    # Language configuration
+    "LanguageConfig",
+    "LANGUAGE_CONFIGS",
+    "get_language_config",
+    # Parser loading
+    "load_parsers",
+    # Natural language query
+    "generate_cypher",
+    "generate_cypher_openai_async",
+    "clean_cypher_response",
+    # Code retrieval
+    "CodeSnippet",
+    "retrieve_code_by_qualified_name",
+    "retrieve_code_by_cypher",
+]

shotgun/codebase/core/change_detector.py

@@ -0,0 +1,358 @@
+"""Change detection for incremental graph updates."""
+
+import hashlib
+import os
+from enum import Enum
+from pathlib import Path
+from typing import Any, cast
+
+import kuzu
+
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class ChangeType(Enum):
+    """Types of file changes."""
+
+    ADDED = "added"
+    MODIFIED = "modified"
+    DELETED = "deleted"
+
+
+class ChangeDetector:
+    """Detects changes in the codebase by comparing with FileMetadata nodes."""
+
+    def __init__(self, connection: kuzu.Connection, repo_path: Path):
+        """Initialize change detector.
+
+        Args:
+            connection: Kuzu database connection
+            repo_path: Root path of the repository
+        """
+        self.conn = connection
+        self.repo_path = Path(repo_path).resolve()
+
+        # Validate that repo path exists
+        if not self.repo_path.exists():
+            raise ValueError(f"Repository path does not exist: {self.repo_path}")
+        if not self.repo_path.is_dir():
+            raise ValueError(f"Repository path is not a directory: {self.repo_path}")
+
+        logger.info(f"ChangeDetector initialized with repo_path: {self.repo_path}")
+
+    def detect_changes(
+        self,
+        languages: list[str] | None = None,
+        exclude_patterns: list[str] | None = None,
+    ) -> dict[str, ChangeType]:
+        """Detect all changes since last update.
+
+        Args:
+            languages: Optional list of languages to include
+            exclude_patterns: Optional patterns to exclude
+
+        Returns:
+            Dictionary mapping file paths to change types
+        """
+        changes = {}
+        current_files = set()
+
+        # Get supported file extensions
+        from shotgun.codebase.core.language_config import get_language_config
+
+        supported_extensions = set()
+        if languages:
+            # Map language names to their primary extensions
+            lang_to_ext = {
+                "python": ".py",
+                "javascript": ".js",
+                "typescript": ".ts",
+                "java": ".java",
+                "cpp": ".cpp",
+                "c": ".c",
+                "csharp": ".cs",
+                "go": ".go",
+                "rust": ".rs",
+                "ruby": ".rb",
+                "php": ".php",
+            }
+
+            for lang in languages:
+                # Try to get config using the language's primary extension
+                primary_ext = lang_to_ext.get(lang.lower())
+                if primary_ext:
+                    config = get_language_config(primary_ext)
+                    if config:
+                        supported_extensions.update(config.file_extensions)
+        else:
+            # Get all supported extensions
+            for ext in [
+                ".py",
+                ".js",
+                ".ts",
+                ".tsx",
+                ".jsx",
+                ".java",
+                ".cpp",
+                ".c",
+                ".hpp",
+                ".h",
+                ".cs",
+                ".go",
+                ".rs",
+                ".rb",
+                ".php",
+            ]:
+                if get_language_config(ext):
+                    supported_extensions.add(ext)
+
+        # Walk through all source files
+        logger.debug(
+            f"Walking source files in {self.repo_path} with extensions {supported_extensions}"
+        )
+        for filepath in self._walk_source_files(supported_extensions, exclude_patterns):
+            # Normalize the relative path to use forward slashes consistently
+            relative_path = str(filepath.relative_to(self.repo_path)).replace(
+                os.sep, "/"
+            )
+            current_files.add(relative_path)
+
+            file_info = self._get_file_info(relative_path)
+            if not file_info:
+                # New file
+                changes[relative_path] = ChangeType.ADDED
+                logger.debug(f"Detected new file: {relative_path}")
+            else:
+                # Check if modified
+                mtime = int(filepath.stat().st_mtime)
+                if mtime > file_info["mtime"]:
+                    # Check hash to confirm actual change
+                    current_hash = self._calculate_file_hash(filepath)
+                    if current_hash != file_info.get("hash", ""):
+                        changes[relative_path] = ChangeType.MODIFIED
+                        logger.debug(f"Detected modified file: {relative_path}")
+
+        # Check for deleted files
+        tracked_files = self._get_tracked_files()
+        logger.debug(
+            f"Found {len(tracked_files)} tracked files, {len(current_files)} current files"
+        )
+
+        # Log sample of files for debugging
+        if tracked_files and current_files:
+            logger.debug(f"Sample tracked files: {list(tracked_files)[:5]}")
+            logger.debug(f"Sample current files: {list(current_files)[:5]}")
+
+        for tracked_file in tracked_files:
+            if tracked_file not in current_files:
+                changes[tracked_file] = ChangeType.DELETED
+                logger.debug(f"Detected deleted file: {tracked_file}")
+
+        # Warn if detecting large number of deletions
+        deleted_count = sum(1 for c in changes.values() if c == ChangeType.DELETED)
+        if deleted_count > 100:
+            logger.warning(
+                f"Detected {deleted_count} file deletions - this may indicate a path resolution issue"
+            )
+
+        logger.info(
+            f"Detected {len(changes)} file changes: "
+            f"{sum(1 for c in changes.values() if c == ChangeType.ADDED)} added, "
+            f"{sum(1 for c in changes.values() if c == ChangeType.MODIFIED)} modified, "
+            f"{sum(1 for c in changes.values() if c == ChangeType.DELETED)} deleted"
+        )
+
+        return changes
+
+    def _get_file_info(self, filepath: str) -> dict[str, Any] | None:
+        """Get FileMetadata info for a file.
+
+        Args:
+            filepath: Relative file path
+
+        Returns:
+            Dictionary with file metadata or None if not found
+        """
+        try:
+            result = self.conn.execute(
+                "MATCH (f:FileMetadata {filepath: $path}) RETURN f.mtime, f.hash",
+                {"path": filepath},
+            )
+
+            # Handle the QueryResult properly - cast to proper type
+            if hasattr(result, "has_next"):
+                query_result = cast(Any, result)
+                if query_result.has_next():
+                    row = query_result.get_next()
+                    if isinstance(row, list | tuple) and len(row) >= 2:
+                        return {"mtime": row[0], "hash": row[1]}
+        except Exception as e:
+            logger.error(f"Failed to get file info for {filepath}: {e}")
+
+        return None
+
+    def _get_tracked_files(self) -> list[str]:
+        """Get all tracked file paths from database.
+
+        Returns:
+            List of relative file paths
+        """
+        files = []
+        try:
+            result = self.conn.execute("MATCH (f:FileMetadata) RETURN f.filepath")
+            # Handle the QueryResult properly - cast to proper type
+            if hasattr(result, "has_next"):
+                query_result = cast(Any, result)
+                while query_result.has_next():
+                    # Normalize path separators to forward slashes
+                    row = query_result.get_next()
+                    if isinstance(row, list | tuple) and len(row) > 0:
+                        filepath = row[0]
+                        if filepath:
+                            normalized_path = filepath.replace(os.sep, "/")
+                            files.append(normalized_path)
+        except Exception as e:
+            logger.error(f"Failed to get tracked files: {e}")
+        return files
+
+    def _walk_source_files(
+        self, supported_extensions: set[str], exclude_patterns: list[str] | None = None
+    ) -> list[Path]:
+        """Walk repository and find all source files.
+
+        Args:
+            supported_extensions: Set of file extensions to include
+            exclude_patterns: Optional patterns to exclude
+
+        Returns:
+            List of absolute file paths
+        """
+        source_files = []
+        ignore_dirs = {
+            ".git",
+            "__pycache__",
+            "node_modules",
+            ".venv",
+            "venv",
+            ".env",
+            "dist",
+            "build",
+            ".pytest_cache",
+            ".mypy_cache",
+            ".tox",
+        }
+
+        logger.debug(f"Walking files from: {self.repo_path}")
+        logger.debug(f"Current working directory: {Path.cwd()}")
+
+        # Add custom exclude patterns
+        if exclude_patterns:
+            for pattern in exclude_patterns:
+                if pattern.startswith("*/"):
+                    ignore_dirs.add(pattern[2:])
+
+        for root, dirs, files in os.walk(self.repo_path):
+            root_path = Path(root)
+
+            # Filter out ignored directories
+            dirs[:] = [d for d in dirs if d not in ignore_dirs]
+
+            # Skip if any parent directory should be ignored
+            if any(part in ignore_dirs for part in root_path.parts):
+                continue
+
+            for file in files:
+                filepath = root_path / file
+
+                # Check if it's a supported source file
+                if filepath.suffix in supported_extensions:
+                    # Check exclude patterns
+                    if exclude_patterns:
+                        relative_path = str(filepath.relative_to(self.repo_path))
+                        if any(
+                            self._matches_pattern(relative_path, pattern)
+                            for pattern in exclude_patterns
+                        ):
+                            continue
+
+                    source_files.append(filepath)
+
+        return source_files
+
+    def _matches_pattern(self, filepath: str, pattern: str) -> bool:
+        """Check if filepath matches an exclude pattern.
+
+        Args:
+            filepath: File path to check
+            pattern: Pattern to match against
+
+        Returns:
+            True if matches
+        """
+        # Simple pattern matching
+        if "*" in pattern:
+            # Convert simple glob to regex-like matching
+            import fnmatch
+
+            return fnmatch.fnmatch(filepath, pattern)
+        else:
+            # Direct substring match
+            return pattern in filepath
+
+    def _calculate_file_hash(self, filepath: Path) -> str:
+        """Calculate hash of file contents.
+
+        Args:
+            filepath: Path to file
+
+        Returns:
+            SHA256 hash of file contents
+        """
+        try:
+            with open(filepath, "rb") as f:
+                return hashlib.sha256(f.read()).hexdigest()
+        except Exception as e:
+            logger.error(f"Failed to calculate hash for {filepath}: {e}")
+            return ""
+
+    def get_file_nodes(self, filepath: str) -> set[str]:
+        """Get all nodes tracked by a FileMetadata.
+
+        Args:
+            filepath: Relative file path
+
+        Returns:
+            Set of qualified names of nodes in the file
+        """
+        nodes = set()
+
+        # Query each TRACKS relationship type
+        for node_type, rel_type in [
+            ("Module", "TRACKS_Module"),
+            ("Class", "TRACKS_Class"),
+            ("Function", "TRACKS_Function"),
+            ("Method", "TRACKS_Method"),
+        ]:
+            try:
+                result = self.conn.execute(
+                    f"""
+                    MATCH (f:FileMetadata {{filepath: $path}})-[:{rel_type}]->(n:{node_type})
+                    RETURN n.qualified_name
+                """,
+                    {"path": filepath},
+                )
+
+                # Handle the QueryResult properly - cast to proper type
+                if hasattr(result, "has_next"):
+                    query_result = cast(Any, result)
+                    while query_result.has_next():
+                        row = query_result.get_next()
+                        if isinstance(row, list | tuple) and len(row) > 0:
+                            nodes.add(row[0])
+            except Exception as e:
+                # Ignore if relationship doesn't exist - this is expected when tables aren't created yet
+                logger.debug(f"No {rel_type} relationship found for {filepath}: {e}")
+
+        return nodes