intentgraph 0.1.0__py3-none-any.whl

intentgraph/__init__.py

@@ -0,0 +1,14 @@
+"""IntentGraph - A best-in-class repository dependency analyzer."""
+
+__version__ = "0.1.0"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"
+
+from .domain.models import AnalysisResult, FileInfo, Language, LanguageSummary
+
+__all__ = [
+    "AnalysisResult",
+    "FileInfo",
+    "Language",
+    "LanguageSummary",
+]

intentgraph/adapters/__init__.py

@@ -0,0 +1 @@
+"""Infrastructure adapters for IntentGraph."""

intentgraph/adapters/git.py

@@ -0,0 +1,124 @@
+"""Git integration and gitignore handling."""
+
+import logging
+from pathlib import Path
+
+import pathspec
+from git import Repo
+
+logger = logging.getLogger(__name__)
+
+
+class GitIgnoreHandler:
+    """Handles .gitignore file parsing and matching."""
+
+    def __init__(self) -> None:
+        self._spec: pathspec.PathSpec | None = None
+        self._repo_path: Path | None = None
+
+    def load_gitignore(self, repo_path: Path) -> None:
+        """Load .gitignore patterns from repository."""
+        self._repo_path = repo_path
+        patterns = []
+
+        try:
+            # Load .gitignore from root
+            gitignore_path = repo_path / ".gitignore"
+            if gitignore_path.exists():
+                patterns.extend(gitignore_path.read_text(encoding="utf-8").splitlines())
+
+            # Load nested .gitignore files
+            for gitignore_file in repo_path.rglob(".gitignore"):
+                if gitignore_file != gitignore_path:
+                    try:
+                        relative_dir = gitignore_file.parent.relative_to(repo_path)
+                        nested_patterns = gitignore_file.read_text(encoding="utf-8").splitlines()
+
+                        # Prefix patterns with relative directory
+                        for pattern in nested_patterns:
+                            if pattern.strip() and not pattern.startswith("#"):
+                                if pattern.startswith("/"):
+                                    # Absolute pattern within the nested directory
+                                    patterns.append(str(relative_dir / pattern[1:]))
+                                else:
+                                    # Relative pattern
+                                    patterns.append(str(relative_dir / pattern))
+                    except Exception as e:
+                        logger.warning(f"Failed to load {gitignore_file}: {e}")
+
+            # Add common patterns
+            patterns.extend([
+                ".git/",
+                ".git/**",
+                "__pycache__/",
+                "*.pyc",
+                "*.pyo",
+                "*.pyd",
+                ".Python",
+                "build/",
+                "develop-eggs/",
+                "dist/",
+                "downloads/",
+                "eggs/",
+                ".eggs/",
+                "lib/",
+                "lib64/",
+                "parts/",
+                "sdist/",
+                "var/",
+                "wheels/",
+                "*.egg-info/",
+                ".installed.cfg",
+                "*.egg",
+                "node_modules/",
+                ".env",
+                ".venv/",
+                "env/",
+                "venv/",
+                "ENV/",
+                "env.bak/",
+                "venv.bak/",
+            ])
+
+            # Create pathspec
+            self._spec = pathspec.PathSpec.from_lines("gitwildmatch", patterns)
+
+        except Exception as e:
+            logger.warning(f"Failed to load .gitignore: {e}")
+            self._spec = pathspec.PathSpec.from_lines("gitwildmatch", [])
+
+    def is_ignored(self, file_path: Path, repo_path: Path) -> bool:
+        """Check if file should be ignored according to .gitignore."""
+        if not self._spec or not self._repo_path:
+            return False
+
+        try:
+            # Get relative path from repository root
+            relative_path = file_path.relative_to(repo_path)
+
+            # Check if file matches any ignore pattern
+            return self._spec.match_file(str(relative_path))
+
+        except ValueError:
+            # File is outside repository
+            return True
+        except Exception as e:
+            logger.warning(f"Error checking ignore status for {file_path}: {e}")
+            return False
+
+    def get_tracked_files(self, repo_path: Path) -> list[Path]:
+        """Get list of files tracked by Git."""
+        try:
+            repo = Repo(repo_path)
+            tracked_files = []
+
+            for item in repo.index.entries:
+                file_path = repo_path / item[0]
+                if file_path.exists():
+                    tracked_files.append(file_path)
+
+            return tracked_files
+
+        except Exception as e:
+            logger.warning(f"Failed to get tracked files: {e}")
+            return []

intentgraph/adapters/output.py

@@ -0,0 +1,122 @@
+"""Output formatting and validation."""
+
+import json
+import logging
+from pathlib import Path
+from types import MappingProxyType
+from typing import Any
+from uuid import UUID
+
+import orjson
+
+from ..domain.models import AnalysisResult
+
+logger = logging.getLogger(__name__)
+
+
+class OutputFormatter:
+    """Formats and validates analysis results for output."""
+
+    def __init__(self, schema_path: Path | None = None):
+        self.schema_path = schema_path
+        self._schema: dict[str, Any] | None = None
+
+        if schema_path and schema_path.exists():
+            try:
+                self._schema = json.loads(schema_path.read_text())
+            except Exception as e:
+                logger.warning(f"Failed to load schema from {schema_path}: {e}")
+
+    def format_json(self, result: AnalysisResult, pretty: bool = True) -> str:
+        """Format analysis result as JSON."""
+        try:
+            # Validate with pydantic
+            result_dict = result.dict()
+
+            # Convert paths and UUIDs to strings
+            converted_dict = self._convert_types(result_dict)
+
+            # Format with orjson
+            if pretty:
+                return orjson.dumps(
+                    converted_dict,
+                    option=orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS
+                ).decode('utf-8')
+            else:
+                return orjson.dumps(converted_dict).decode('utf-8')
+
+        except Exception as e:
+            logger.error(f"Failed to format JSON output: {e}")
+            raise
+
+    def _convert_types(self, obj: Any, seen: set = None) -> Any:
+        """Convert complex types to JSON-serializable formats."""
+        if seen is None:
+            seen = set()
+
+        # Prevent recursion by tracking object ids
+        obj_id = id(obj)
+        if obj_id in seen:
+            return str(obj)  # Fallback to string representation
+
+        if isinstance(obj, (dict, MappingProxyType)):
+            seen.add(obj_id)
+            try:
+                return {str(key): self._convert_types(value, seen) for key, value in obj.items()}
+            finally:
+                seen.remove(obj_id)
+        elif isinstance(obj, list):
+            return [self._convert_types(item, seen) for item in obj]
+        elif isinstance(obj, Path) or isinstance(obj, UUID):
+            return str(obj)
+        elif hasattr(obj, '__dict__') and not isinstance(obj, type(lambda: None)):
+            # Skip function types and Mock objects
+            if 'Mock' in str(type(obj)):
+                return str(obj)
+            seen.add(obj_id)
+            try:
+                return self._convert_types(obj.__dict__, seen)
+            finally:
+                seen.remove(obj_id)
+        else:
+            # Handle any other complex types by converting to string
+            try:
+                # Test if it's JSON serializable
+                json.dumps(obj)
+                return obj
+            except (TypeError, ValueError):
+                return str(obj)
+
+    def validate_against_schema(self, result: AnalysisResult) -> bool:
+        """Validate result against JSON schema."""
+        if not self._schema:
+            logger.warning("No schema available for validation")
+            return True
+
+        try:
+            import jsonschema
+
+            result_dict = result.dict()
+            converted_dict = self._convert_types(result_dict)
+
+            jsonschema.validate(converted_dict, self._schema)
+            return True
+
+        except ImportError:
+            logger.warning("jsonschema not available, skipping validation")
+            return True
+        except jsonschema.ValidationError as e:
+            logger.error(f"Schema validation failed: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Validation error: {e}")
+            return False
+
+    def export_to_file(self, result: AnalysisResult, output_path: Path, pretty: bool = True) -> None:
+        """Export result to file."""
+        try:
+            json_output = self.format_json(result, pretty)
+            output_path.write_text(json_output, encoding='utf-8')
+        except Exception as e:
+            logger.error(f"Failed to export to {output_path}: {e}")
+            raise

intentgraph/adapters/parsers/__init__.py

@@ -0,0 +1,39 @@
+"""Language parsers for dependency extraction."""
+
+from typing import Optional
+
+from ...domain.models import Language
+from .base import LanguageParser
+from .go_parser import GoParser
+from .javascript_parser import JavaScriptParser
+from .python_parser import PythonParser
+from .typescript_parser import TypeScriptParser
+
+
+class _ParserRegistry:
+    def __init__(self):
+        self._parsers = {
+            Language.PYTHON: PythonParser(),
+            Language.JAVASCRIPT: JavaScriptParser(),
+            Language.TYPESCRIPT: TypeScriptParser(),
+            Language.GO: GoParser(),
+        }
+
+    def get_parser(self, language: Language) -> LanguageParser | None:
+        return self._parsers.get(language)
+
+_registry = _ParserRegistry()
+
+def get_parser_for_language(language: Language) -> LanguageParser | None:
+    """Get appropriate parser for a language."""
+    return _registry.get_parser(language)
+
+
+__all__ = [
+    "GoParser",
+    "JavaScriptParser",
+    "LanguageParser",
+    "PythonParser",
+    "TypeScriptParser",
+    "get_parser_for_language",
+]

intentgraph/adapters/parsers/base.py

@@ -0,0 +1,135 @@
+"""Base class for language parsers."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Optional
+
+from ...domain.models import CodeSymbol, APIExport, FunctionDependency
+
+
+class LanguageParser(ABC):
+    """Abstract base class for language-specific parsers."""
+
+    @abstractmethod
+    def extract_dependencies(self, file_path: Path, repo_path: Path) -> list[str]:
+        """Extract dependencies from a source file.
+        
+        Args:
+            file_path: Path to the source file
+            repo_path: Path to the repository root
+            
+        Returns:
+            List of relative paths to dependencies within the repository
+        """
+        pass
+
+    def extract_code_structure(self, file_path: Path, repo_path: Path) -> tuple[
+        list[CodeSymbol], 
+        list[APIExport], 
+        list[FunctionDependency],
+        list[str],  # imports
+        dict[str, any]  # metadata (complexity, etc.)
+    ]:
+        """Extract detailed code structure information.
+        
+        Args:
+            file_path: Path to the source file
+            repo_path: Path to the repository root
+            
+        Returns:
+            Tuple of (symbols, exports, function_deps, imports, metadata)
+        """
+        # Default implementation returns empty data
+        return [], [], [], [], {}
+
+    def _resolve_import_path(self, import_path: str, file_path: Path, repo_path: Path) -> list[str]:
+        """Resolve import path to actual file paths with security validation."""
+        resolved_paths = []
+
+        # Validate import_path format
+        if not self._is_valid_import_path(import_path):
+            return []
+
+        # Handle relative imports
+        if import_path.startswith('.'):
+            base_dir = file_path.parent
+            relative_path = import_path.lstrip('.')
+            if relative_path:
+                target_path = base_dir / relative_path.replace('.', '/')
+            else:
+                target_path = base_dir
+        else:
+            # Handle absolute imports from repo root
+            target_path = repo_path / import_path.replace('.', '/')
+
+        # Resolve and validate the path
+        try:
+            resolved_target = target_path.resolve()
+            repo_resolved = repo_path.resolve()
+
+            # Ensure target is within repository boundaries
+            resolved_target.relative_to(repo_resolved)
+
+            # Continue with existing logic...
+            extensions = self._get_file_extensions()
+            for ext in extensions:
+                candidate = resolved_target.with_suffix(ext)
+                if candidate.exists() and candidate.is_file():
+                    try:
+                        rel_path = candidate.relative_to(repo_resolved)
+                        resolved_paths.append(str(rel_path))
+                    except ValueError:
+                        # File is outside repository - skip
+                        continue
+
+        except (ValueError, OSError):
+            # Path traversal attempt or invalid path
+            return []
+
+        # Try directory with __init__ file
+        try:
+            if resolved_target.is_dir():
+                for init_name in self._get_init_files():
+                    init_file = resolved_target / init_name
+                    if init_file.exists():
+                        try:
+                            rel_path = init_file.relative_to(repo_resolved)
+                            resolved_paths.append(str(rel_path))
+                        except ValueError:
+                            # File is outside repository - skip
+                            continue
+        except (ValueError, OSError):
+            # Path traversal attempt or invalid path
+            pass
+
+        return resolved_paths
+
+    def _is_valid_import_path(self, import_path: str) -> bool:
+        """Validate import path format to prevent injection."""
+        # Check for null bytes and control characters
+        if '\x00' in import_path or any(ord(c) < 32 for c in import_path if c not in '\t\n'):
+            return False
+
+        # Check length limits
+        if len(import_path) > 1000:  # Reasonable limit
+            return False
+
+        # Check for excessive relative traversal
+        if import_path.count('..') > 10:  # Reasonable limit
+            return False
+
+        # Must not be empty or whitespace only
+        if not import_path.strip():
+            return False
+
+        return True
+
+    @abstractmethod
+    def _get_file_extensions(self) -> list[str]:
+        """Get file extensions for this language."""
+        pass
+
+    @abstractmethod
+    def _get_init_files(self) -> list[str]:
+        """Get initialization file names for this language."""
+        pass