code-finder 0.1.0__py3-none-any.whl

claude_context/__init__.py

@@ -0,0 +1,33 @@
+"""
+Claude Context MCP Integration for Vibe2Doc
+
+This module provides semantic code search and understanding capabilities
+using Milvus Lite for vector storage and embeddings.
+
+Philosophy: Fail fast, log clearly, no silent fallbacks.
+"""
+
+from .config import ClaudeContextConfig, MilvusManager
+from .embeddings import LocalEmbeddings, create_embeddings
+from .indexer import RepositoryIndexer
+from .search import HybridSearcher, SearchResult, create_hybrid_searcher
+try:
+    # Expose synthesis module when available (Phase 3)
+    from .synthesis.llm_synthesizer import LLMSynthesizer  # type: ignore
+except Exception:
+    LLMSynthesizer = None  # Optional until Phase 3 is fully wired
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "ClaudeContextConfig",
+    "MilvusManager",
+    "LocalEmbeddings",
+    "create_embeddings",
+    "RepositoryIndexer",
+    "HybridSearcher",
+    "SearchResult",
+    "create_hybrid_searcher",
+    # Optional synthesis export
+    "LLMSynthesizer",
+]

claude_context/agentic_integration.py

@@ -0,0 +1,309 @@
+"""
+Integration module for Claude Context modes with agentic_client_langgraph.py
+
+This module bridges the new mode-based approach with the existing
+LangGraph agentic workflow.
+"""
+
+import logging
+import asyncio
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+
+from .mode_handler import (
+    DocumentationModeHandler,
+    DocumentationMode,
+    ModeContext,
+    run_documentation_mode
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AgenticModeIntegration:
+    """
+    Integrates Claude Context modes with the existing agentic workflow.
+    
+    This class provides methods that can be called from agentic_client_langgraph.py
+    to leverage the new mode-based documentation generation.
+    """
+    
+    def __init__(self):
+        """Initialize the integration"""
+        self.handler = DocumentationModeHandler()
+        self.current_mode = DocumentationMode.AUTO  # Default
+        self.current_context: Optional[ModeContext] = None
+    
+    async def analyze_repository_with_mode(
+        self,
+        repository_path: str,
+        mode: str = "auto",
+        context_files: Optional[List[str]] = None,
+        jira_config: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """
+        Analyze a repository using the specified mode.
+        
+        This method replaces the standard repository analysis with
+        mode-aware analysis that includes indexing and context.
+        
+        Args:
+            repository_path: Path to the repository
+            mode: Documentation mode (auto/interactive/hybrid)
+            context_files: External context files
+            jira_config: Jira configuration
+            
+        Returns:
+            Analysis results compatible with existing workflow
+        """
+        logger.info(f"Analyzing repository with {mode} mode")
+        
+        # Parse mode
+        try:
+            doc_mode = DocumentationMode(mode.lower())
+        except ValueError:
+            logger.warning(f"Invalid mode {mode}, defaulting to AUTO")
+            doc_mode = DocumentationMode.AUTO
+        
+        # Initialize the mode
+        self.current_context = await self.handler.initialize_mode(
+            mode=doc_mode,
+            repository_path=repository_path,
+            context_files=context_files,
+            jira_config=jira_config
+        )
+        
+        # Build analysis result compatible with existing workflow
+        analysis = {
+            "repository_path": repository_path,
+            "mode": doc_mode.value,
+            "indexed": True,
+            "stats": {
+                "files_indexed": self.current_context.indexer.stats.get("files_indexed", 0)
+                if self.current_context.indexer else 0,
+                "total_chunks": self.current_context.indexer.stats.get("total_chunks", 0)
+                if self.current_context.indexer else 0,
+                "context_items": self.current_context.context_manager.total_items
+                if self.current_context.context_manager else 0
+            },
+            "has_context": doc_mode != DocumentationMode.AUTO,
+            "requires_interaction": doc_mode == DocumentationMode.INTERACTIVE
+        }
+        
+        # For INTERACTIVE mode, we need to run the Q&A session
+        if doc_mode == DocumentationMode.INTERACTIVE:
+            logger.info("INTERACTIVE mode requires Q&A session")
+            analysis["interaction_required"] = True
+            analysis["explorer_ready"] = self.current_context.explorer is not None
+        
+        return analysis
+    
+    async def run_interactive_exploration(self) -> Dict[str, Any]:
+        """
+        Run the interactive Q&A exploration session.
+        
+        Returns:
+            Exploration results including Q&A history
+        """
+        if not self.current_context:
+            raise RuntimeError("No context initialized")
+        
+        if self.current_context.mode != DocumentationMode.INTERACTIVE:
+            raise RuntimeError("Interactive exploration only available in INTERACTIVE mode")
+        
+        # Run the interactive session
+        await self.handler._run_interactive_session(self.current_context)
+        
+        # Return exploration results
+        return {
+            "exploration_complete": self.current_context.exploration_complete,
+            "qa_count": len(self.current_context.qa_history),
+            "qa_history": self.current_context.qa_history,
+            "context_used": self.current_context.context_manager.total_items
+            if self.current_context.context_manager else 0
+        }
+    
+    async def generate_documentation_with_mode(
+        self,
+        analysis_data: Dict[str, Any],
+        doc_type: str = "overview"
+    ) -> str:
+        """
+        Generate documentation using the current mode.
+        
+        This method is called by the existing workflow to generate
+        individual documentation sections.
+        
+        Args:
+            analysis_data: Analysis data from the workflow
+            doc_type: Type of documentation to generate
+            
+        Returns:
+            Generated documentation content
+        """
+        if not self.current_context:
+            logger.warning("No mode context, falling back to standard generation")
+            return f"# {doc_type.title()}\n\nNo mode context available."
+        
+        # Generate based on mode
+        if self.current_context.mode == DocumentationMode.AUTO:
+            docs = await self.handler.run_auto_mode(self.current_context)
+        elif self.current_context.mode == DocumentationMode.HYBRID:
+            docs = await self.handler.run_hybrid_mode(self.current_context)
+        elif self.current_context.mode == DocumentationMode.INTERACTIVE:
+            docs = await self.handler.run_interactive_mode(self.current_context)
+        else:
+            return f"# {doc_type.title()}\n\nUnsupported mode."
+        
+        # Map doc_type to our generated files
+        type_mapping = {
+            "overview": "README.md",
+            "architecture": "ARCHITECTURE.md",
+            "api": "API.md",
+            "setup": "README.md",  # Part of README
+            "requirements": "REQUIREMENTS_TRACING.md",
+            "insights": "EXPLORATION_INSIGHTS.md"
+        }
+        
+        filename = type_mapping.get(doc_type, "README.md")
+        return docs.get(filename, f"# {doc_type.title()}\n\nContent not available.")
+    
+    async def search_code_with_context(
+        self,
+        query: str,
+        include_context: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Search code and optionally external context.
+        
+        This can be used by the existing workflow to find relevant
+        code and context for specific documentation sections.
+        
+        Args:
+            query: Search query
+            include_context: Whether to search external context too
+            
+        Returns:
+            Search results from code and context
+        """
+        if not self.current_context or not self.current_context.searcher:
+            return {"code_results": [], "context_results": []}
+        
+        # Search code
+        code_results = self.current_context.searcher.search(query, limit=5)
+        
+        # Search context if available and requested
+        context_results = []
+        if include_context and self.current_context.context_manager:
+            context_items = self.current_context.context_manager.search_context(query, limit=3)
+            context_results = [
+                {
+                    "type": item.type,
+                    "summary": item.get_summary(),
+                    "source": item.source,
+                    "relevance": score
+                }
+                for item, score in context_items
+            ]
+        
+        return {
+            "code_results": [
+                {
+                    "file": r.file_path,
+                    "lines": f"{r.start_line}-{r.end_line}",
+                    "content": r.content[:200],
+                    "score": r.combined_score
+                }
+                for r in code_results
+            ],
+            "context_results": context_results
+        }
+    
+    def get_mode_status(self) -> Dict[str, Any]:
+        """
+        Get the current status of the mode handler.
+        
+        Returns:
+            Status information
+        """
+        if not self.current_context:
+            return {
+                "initialized": False,
+                "mode": None
+            }
+        
+        return {
+            "initialized": True,
+            "mode": self.current_context.mode.value,
+            "repository": self.current_context.repository_path,
+            "has_context": self.current_context.context_manager is not None,
+            "context_items": self.current_context.context_manager.total_items
+            if self.current_context.context_manager else 0,
+            "qa_count": len(self.current_context.qa_history),
+            "exploration_complete": self.current_context.exploration_complete,
+            "docs_generated": len(self.current_context.generated_docs)
+        }
+
+
+# Global instance for use by agentic_client_langgraph.py
+_mode_integration = None
+
+
+def get_mode_integration() -> AgenticModeIntegration:
+    """
+    Get or create the global mode integration instance.
+    
+    Returns:
+        The mode integration instance
+    """
+    global _mode_integration
+    if _mode_integration is None:
+        _mode_integration = AgenticModeIntegration()
+    return _mode_integration
+
+
+async def analyze_with_mode(
+    repository_path: str,
+    mode: str = "auto",
+    **kwargs
+) -> Dict[str, Any]:
+    """
+    Convenience function for analyzing with a specific mode.
+    
+    This can be called directly from agentic_client_langgraph.py.
+    
+    Args:
+        repository_path: Path to repository
+        mode: Documentation mode
+        **kwargs: Additional arguments (context_files, jira_config)
+        
+    Returns:
+        Analysis results
+    """
+    integration = get_mode_integration()
+    return await integration.analyze_repository_with_mode(
+        repository_path=repository_path,
+        mode=mode,
+        **kwargs
+    )
+
+
+async def generate_with_mode(
+    analysis_data: Dict[str, Any],
+    doc_type: str = "overview"
+) -> str:
+    """
+    Convenience function for generating documentation with current mode.
+    
+    Args:
+        analysis_data: Analysis data
+        doc_type: Documentation type
+        
+    Returns:
+        Generated documentation
+    """
+    integration = get_mode_integration()
+    return await integration.generate_documentation_with_mode(
+        analysis_data=analysis_data,
+        doc_type=doc_type
+    )