kodit 0.4.3__py3-none-any.whl → 0.5.1__py3-none-any.whl

kodit/domain/services/git_service.py

@@ -0,0 +1,300 @@
+"""Service for git operations."""
+
+import asyncio
+import hashlib
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import git
+import structlog
+from git import InvalidGitRepositoryError, Repo
+from pydantic import AnyUrl
+
+from kodit.application.factories.reporting_factory import create_noop_operation
+from kodit.application.services.reporting import ProgressTracker
+from kodit.domain.entities import WorkingCopy
+from kodit.domain.entities.git import (
+    GitBranch,
+    GitCommit,
+    GitFile,
+    GitRepo,
+    GitTag,
+)
+from kodit.domain.factories.git_repo_factory import GitRepoFactory
+
+if TYPE_CHECKING:
+    from git.objects import Commit
+
+
+class GitService:
+    """Service for git operations."""
+
+    def __init__(self, clone_dir: Path) -> None:
+        """Initialize the git service."""
+        self.clone_dir = clone_dir
+        self.log = structlog.get_logger(__name__)
+
+    def get_clone_path(self, uri: str) -> Path:
+        """Get the clone path for a Git working copy."""
+        sanitized_uri = WorkingCopy.sanitize_git_url(uri)
+        dir_hash = hashlib.sha256(str(sanitized_uri).encode("utf-8")).hexdigest()[:16]
+        dir_name = f"repo-{dir_hash}"
+        return self.clone_dir / dir_name
+
+    async def clone_and_extract_repo_info(
+        self, uri: str, step: ProgressTracker | None = None
+    ) -> GitRepo:
+        """Clone repository and extract complete git repository information."""
+        step = step or create_noop_operation()
+        # Verify the clone path doesn't already exist
+        clone_path = self.get_clone_path(uri)
+        if clone_path.exists():
+            raise ValueError(f"Clone path already exists: {clone_path}")
+        sanitized_uri = WorkingCopy.sanitize_git_url(uri)
+        clone_path.mkdir(parents=True, exist_ok=True)
+
+        step_record = []
+        await step.set_total(12)
+
+        def _clone_progress_callback(
+            a: int, _: str | float | None, __: str | float | None, _d: str
+        ) -> None:
+            if a not in step_record:
+                step_record.append(a)
+
+            # Git reports a really weird format. This is a quick hack to get some
+            # progress.
+            # Normally this would fail because the loop is already running,
+            # but in this case, this callback is called by some git sub-thread.
+            asyncio.run(
+                step.set_current(
+                    len(step_record), f"Cloning repository ({step_record[-1]})"
+                )
+            )
+
+        try:
+            self.log.info(
+                "Cloning repository", uri=sanitized_uri, clone_path=str(clone_path)
+            )
+            # Use the original URI for cloning (with credentials if present)
+            options = ["--depth=1", "--single-branch"]
+            git.Repo.clone_from(
+                uri,
+                clone_path,
+                progress=_clone_progress_callback,
+                multi_options=options,
+            )
+        except git.GitCommandError as e:
+            if "already exists and is not an empty directory" not in str(e):
+                msg = f"Failed to clone repository: {e}"
+                raise ValueError(msg) from e
+            self.log.info("Repository already exists, reusing...", uri=sanitized_uri)
+
+        # Extract git repository information from cloned path
+        # Convert original URI to AnyUrl for GitRepo
+        from pydantic import AnyUrl
+
+        original_uri = AnyUrl(uri)
+        return self.get_repo_info_from_path(clone_path, original_uri, sanitized_uri)
+
+    def get_repo_info_from_path(
+        self, repo_path: Path, remote_uri: AnyUrl, sanitized_remote_uri: AnyUrl
+    ) -> GitRepo:
+        """Extract complete git repository information from a local path."""
+        try:
+            repo = Repo(repo_path)
+        except InvalidGitRepositoryError as e:
+            raise ValueError(f"Path is not a git repository: {repo_path}") from e
+
+        # Get all branches with their commit histories
+        branches = self._get_all_branches(repo)
+
+        # Count commits for num_commits field (managed by GitCommitRepository)
+        all_commits = self._get_all_commits(repo)
+        num_commits = len(all_commits)
+
+        # Get all tags
+        all_tags = self._get_all_tags(repo)
+
+        # Get current branch as tracking branch
+        try:
+            current_branch = repo.active_branch
+            tracking_branch = next(
+                (b for b in branches if b.name == current_branch.name),
+                branches[0] if branches else None,
+            )
+        except (AttributeError, TypeError):
+            # Handle detached HEAD state or other branch access issues
+            tracking_branch = branches[0] if branches else None
+
+        if tracking_branch is None:
+            raise ValueError("No branches found in repository")
+
+        return GitRepoFactory.create_from_path_scan(
+            remote_uri=remote_uri,
+            sanitized_remote_uri=sanitized_remote_uri,
+            repo_path=repo_path,
+            tracking_branch=tracking_branch,
+            last_scanned_at=datetime.now(UTC),
+            num_commits=num_commits,
+            num_branches=len(branches),
+            num_tags=len(all_tags),
+        )
+
+    def get_commit_history(
+        self, repo_path: Path, branch_name: str, limit: int = 100
+    ) -> list[GitCommit]:
+        """Get commit history for a specific branch."""
+        try:
+            repo = Repo(repo_path)
+
+            # Get the branch reference
+            branch_ref = None
+            for branch in repo.branches:
+                if branch.name == branch_name:
+                    branch_ref = branch
+                    break
+
+            if branch_ref is None:
+                return []
+
+            # Get commit history for the branch
+            commits = []
+            for commit in repo.iter_commits(branch_ref, max_count=limit):
+                try:
+                    git_commit = self._convert_commit(repo, commit)
+                    commits.append(git_commit)
+                except Exception:  # noqa: BLE001, S112
+                    # Skip commits we can't process
+                    continue
+
+        except (InvalidGitRepositoryError, Exception):
+            return []
+        else:
+            return commits
+
+    def _get_all_branches(self, repo: Repo) -> list[GitBranch]:
+        """Get all branches with their commit histories."""
+        branches = []
+
+        for branch in repo.branches:
+            try:
+                # Get head commit for this branch
+                head_commit = self._convert_commit(repo, branch.commit)
+                branches.append(GitBranch(name=branch.name, head_commit=head_commit))
+            except Exception:  # noqa: BLE001, S112
+                # Skip branches that can't be accessed
+                continue
+
+        return branches
+
+    def _get_all_commits(self, repo: Repo) -> list[GitCommit]:
+        """Get all unique commits across all branches."""
+        commit_cache = {}  # Use SHA as key to avoid duplicates
+
+        # Get all commits from all branches
+        for branch in repo.branches:
+            try:
+                # Traverse the entire commit history for this branch
+                for commit in repo.iter_commits(branch):
+                    if commit.hexsha not in commit_cache:
+                        domain_commit = self._convert_commit(repo, commit)
+                        commit_cache[commit.hexsha] = domain_commit
+            except Exception:  # noqa: BLE001, S112
+                # Skip branches that can't be accessed
+                continue
+
+        return list(commit_cache.values())
+
+    def _get_all_tags(self, repo: Repo) -> list[GitTag]:
+        """Get all tags in the repository."""
+        all_commits = self._get_all_commits(repo)
+        all_commits_map = {commit.commit_sha: commit for commit in all_commits}
+        tags = []
+        try:
+            for tag_ref in repo.tags:
+                try:
+                    # Get the commit that the tag points to
+                    target_commit = tag_ref.commit
+
+                    tag = GitTag(
+                        created_at=datetime.now(UTC),
+                        name=tag_ref.name,
+                        target_commit=all_commits_map[target_commit.hexsha],
+                    )
+                    tags.append(tag)
+                except Exception:  # noqa: BLE001, S112
+                    # Skip tags that can't be processed
+                    continue
+        except Exception:  # noqa: BLE001
+            # If we can't get tags, return empty list
+            return []
+
+        return tags
+
+    def _convert_commit(self, repo: Repo, commit: "Commit") -> GitCommit:
+        """Convert a GitPython commit object to domain GitCommit."""
+        # Convert timestamp to datetime
+        commit_date = datetime.fromtimestamp(commit.committed_date, tz=UTC)
+
+        # Get parent commit SHA (first parent if merge commit)
+        parent_sha = commit.parents[0].hexsha if commit.parents else ""
+
+        # Get files changed in this commit
+        files = self._get_commit_files(repo, commit)
+
+        # Format author string from name and email
+        author_name = str(commit.author.name) if commit.author.name else ""
+        author_email = str(commit.author.email) if commit.author.email else ""
+        if author_name and author_email:
+            author = f"{author_name} <{author_email}>"
+        else:
+            author = author_name or "Unknown"
+
+        return GitCommit(
+            commit_sha=commit.hexsha,
+            date=commit_date,
+            message=str(commit.message).strip(),
+            parent_commit_sha=parent_sha,
+            files=files,
+            author=author,
+        )
+
+    def _get_commit_files(self, repo: Repo, commit: "Commit") -> list[GitFile]:
+        """Get files changed in a specific commit."""
+        try:
+            files = []
+
+            # Get files changed in this commit
+            if commit.parents:
+                # Compare with first parent to get changed files
+                changed_files = commit.parents[0].diff(commit)
+            else:
+                # Initial commit - get all files
+                changed_files = commit.diff(None)
+
+            for diff_item in changed_files:
+                # Handle both a_path and b_path (for renames/moves)
+                file_path = diff_item.b_path or diff_item.a_path
+                if file_path and diff_item.b_blob:
+                    try:
+                        blob = diff_item.b_blob
+                        file_entity = GitFile(
+                            created_at=datetime.now(UTC),
+                            blob_sha=blob.hexsha,
+                            path=str(Path(repo.working_dir) / file_path),
+                            mime_type="application/octet-stream",  # Default
+                            size=blob.size,
+                            extension=GitFile.extension_from_path(file_path),
+                        )
+                        files.append(file_entity)
+                    except Exception:  # noqa: BLE001, S112
+                        # Skip files we can't process
+                        continue
+
+        except Exception:  # noqa: BLE001
+            # If we can't get files for this commit, return empty list
+            return []
+        else:
+            return files

kodit/domain/services/physical_architecture_service.py

@@ -0,0 +1,182 @@
+"""Core service for discovering physical architecture and generating narrative observations."""  # noqa: E501
+
+from datetime import UTC, datetime
+from pathlib import Path
+
+from kodit.domain.enrichments.architecture.physical.discovery_notes import (
+    ArchitectureDiscoveryNotes,
+)
+from kodit.domain.enrichments.architecture.physical.formatter import (
+    PhysicalArchitectureFormatter,
+)
+from kodit.infrastructure.physical_architecture.detectors import docker_compose_detector
+
+ARCHITECTURE_ENRICHMENT_SYSTEM_PROMPT = """You are an expert software architect.
+Deliver the user's request succinctly.
+"""
+
+ARCHITECTURE_ENRICHMENT_TASK_PROMPT = """Convert the raw architecture discovery logs
+into a clean, structured summary written in markdown.
+
+<architecture_narrative>
+{architecture_narrative}
+</architecture_narrative>
+
+**Return the following information**
+
+## Services List
+
+For each service, write one line:
+- **[Service Name]**: [what it does] | Tech: [technology] | Ports: [ports]
+
+## Service Dependencies
+
+List the important connections:
+- [Service A] → [Service B]: [why they connect]
+
+## Mermaid Diagram
+
+Output a Mermaid diagram depicting the architecture using the names of the services and
+the ports that they expose.
+
+## Key Information
+
+Answer these questions in 1-2 sentences each:
+1. What databases are used and for what?
+2. What are the critical services that everything else depends on?
+3. Are there any unusual communication patterns between services that people should be
+aware of? (e.g. a different direction to what you'd expect)
+
+## Rules:
+- Skip duplicate services (keep only one instance)
+- Don't list environment variables
+- Don't describe Docker volumes in detail
+- Focus on WHAT each service does, not HOW it's configured
+- If a service name is unclear, make your best guess based on the information
+- Keep descriptions to 10 words or less per service
+"""
+
+
+class PhysicalArchitectureService:
+    """Core service for discovering physical architecture and generating narrative observations."""  # noqa: E501
+
+    def __init__(self, formatter: PhysicalArchitectureFormatter) -> None:
+        """Initialize the service with detectors and formatter."""
+        self.docker_detector = docker_compose_detector.DockerComposeDetector()
+        self.formatter = formatter
+
+    async def discover_architecture(self, repo_path: Path) -> str:
+        """Discover physical architecture and generate rich narrative observations."""
+        # Generate repository context overview
+        repo_context = await self._analyze_repository_context(repo_path)
+
+        # Collect observations from all detectors
+        component_notes = []
+        connection_notes = []
+        infrastructure_notes = []
+
+        # Run detectors and collect narrative observations
+        (
+            docker_component_notes,
+            docker_connection_notes,
+            docker_infrastructure_notes,
+        ) = await self.docker_detector.analyze(repo_path)
+        component_notes.extend(docker_component_notes)
+        connection_notes.extend(docker_connection_notes)
+        infrastructure_notes.extend(docker_infrastructure_notes)
+
+        # Future: Add Kubernetes and code structure detectors when available
+
+        # Generate discovery metadata
+        discovery_metadata = self._generate_discovery_metadata(repo_path)
+
+        # Create comprehensive notes
+        notes = ArchitectureDiscoveryNotes(
+            repository_context=repo_context,
+            component_observations=component_notes,
+            connection_observations=connection_notes,
+            infrastructure_observations=infrastructure_notes,
+            discovery_metadata=discovery_metadata,
+        )
+
+        return self.formatter.format_for_llm(notes)
+
+    async def _analyze_repository_context(self, repo_path: Path) -> str:
+        """Generate high-level repository context and scope."""
+        context_observations = []
+
+        # Check for basic repository structure
+        context_observations.append(f"Analyzing repository at {repo_path}")
+
+        # Check for common project indicators
+        has_docker_compose = bool(
+            list(repo_path.glob("docker-compose*.yml"))
+            + list(repo_path.glob("docker-compose*.yaml"))
+        )
+        has_dockerfile = bool(list(repo_path.glob("Dockerfile*")))
+        has_k8s = bool(
+            list(repo_path.glob("**/k8s/**/*.yaml"))
+            + list(repo_path.glob("**/kubernetes/**/*.yaml"))
+        )
+        has_package_json = (repo_path / "package.json").exists()
+        has_requirements_txt = (repo_path / "requirements.txt").exists()
+        has_go_mod = (repo_path / "go.mod").exists()
+
+        # Determine likely project type
+        project_indicators = []
+        if has_docker_compose:
+            project_indicators.append("Docker Compose orchestration")
+        if has_dockerfile:
+            project_indicators.append("containerized deployment")
+        if has_k8s:
+            project_indicators.append("Kubernetes deployment")
+        if has_package_json:
+            project_indicators.append("Node.js/JavaScript components")
+        if has_requirements_txt:
+            project_indicators.append("Python components")
+        if has_go_mod:
+            project_indicators.append("Go components")
+
+        if project_indicators:
+            context_observations.append(
+                f"Repository shows evidence of {', '.join(project_indicators)}, "
+                "suggesting a modern containerized application architecture."
+            )
+        else:
+            context_observations.append(
+                "Repository structure analysis shows limited infrastructure configuration. "  # noqa: E501
+                "This may be a simple application or library without complex deployment requirements."  # noqa: E501
+            )
+
+        return " ".join(context_observations)
+
+    def _generate_discovery_metadata(self, _repo_path: Path) -> str:
+        """Document discovery methodology, confidence, and limitations."""
+        timestamp = datetime.now(UTC).isoformat()
+
+        metadata_parts = [
+            f"Analysis completed on {timestamp} using physical architecture discovery system version 1.0.",  # noqa: E501
+            "Discovery methodology: Docker Compose parsing and infrastructure configuration analysis.",  # noqa: E501
+        ]
+
+        # Document detection sources used
+        sources_used = ["Docker Compose file analysis"]
+        # Future: Add Kubernetes manifest and code analysis sources
+
+        metadata_parts.append(f"Detection sources: {', '.join(sources_used)}.")
+
+        # Document confidence levels
+        metadata_parts.append(
+            "Confidence levels: High confidence for infrastructure-defined components, "
+            "medium confidence for inferred roles based on naming and configuration patterns."  # noqa: E501
+        )
+
+        # Document limitations
+        limitations = [
+            "analysis limited to Docker Compose configurations",
+            "code-level analysis not yet implemented",
+            "runtime behavior patterns not captured",
+        ]
+        metadata_parts.append(f"Current limitations: {', '.join(limitations)}.")
+
+        return " ".join(metadata_parts)

kodit/domain/services/task_status_query_service.py

@@ -12,8 +12,8 @@ class TaskStatusQueryService:
         """Initialize the task status query service."""
         self._repository = repository
 
-    async def get_index_status(self, index_id: int) -> list[TaskStatus]:
+    async def get_index_status(self, repo_id: int) -> list[TaskStatus]:
         """Get the status of tasks for a specific index."""
         return await self._repository.load_with_hierarchy(
-            trackable_type=TrackableType.INDEX.value, trackable_id=index_id
+            trackable_type=TrackableType.KODIT_REPOSITORY.value, trackable_id=repo_id
         )