Add core context generator module

src/contextgen/context_generator.py

@@ -0,0 +1,99 @@
+"""Context generator that aggregates all analysis results."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from contextgen.analyzers.convention_extractor import ConventionExtractor
+from contextgen.analyzers.framework_detector import FrameworkDetector
+from contextgen.analyzers.language_detector import LanguageDetector
+from contextgen.analyzers.project_analyzer import ProjectAnalyzer
+from contextgen.analyzers.setup_generator import SetupInstructionGenerator
+from contextgen.formatters.json_formatter import JSONFormatter
+from contextgen.formatters.yaml_formatter import YAMLFormatter
+
+
+class ContextGenerator:
+    """Generates comprehensive context for a project."""
+
+    def __init__(self, project_path: Path):
+        self.project_path = Path(project_path).resolve()
+        self.project_name = self.project_path.name
+
+    def generate(self) -> dict[str, Any]:
+        """Run all analyzers and generate context."""
+        project_info = self._analyze_project()
+        conventions = self._analyze_conventions()
+        setup = self._analyze_setup()
+
+        context = {
+            "project": {
+                "name": self.project_name,
+                "description": f"Auto-generated context for {self.project_name}",
+                "path": str(self.project_path),
+                "timestamp": datetime.utcnow().isoformat() + "Z",
+            },
+            "analysis": project_info,
+            "structure": {
+                "file_tree": project_info.get("file_tree", {}),
+                "key_files": project_info.get("key_files", {}),
+                "total_files": project_info.get("total_files", 0),
+                "total_dirs": project_info.get("total_dirs", 0),
+            },
+            "conventions": conventions,
+            "setup": setup,
+        }
+
+        return context
+
+    def _analyze_project(self) -> dict[str, Any]:
+        """Analyze project structure and tech stack."""
+        results: dict[str, Any] = {}
+
+        project_analyzer = ProjectAnalyzer(self.project_path)
+        results.update(project_analyzer.analyze())
+
+        lang_detector = LanguageDetector(self.project_path)
+        results.update(lang_detector.analyze())
+
+        fw_detector = FrameworkDetector(self.project_path)
+        results.update(fw_detector.analyze())
+
+        return results
+
+    def _analyze_conventions(self) -> dict[str, Any]:
+        """Analyze coding conventions."""
+        extractor = ConventionExtractor(self.project_path)
+        return extractor.analyze()
+
+    def _analyze_setup(self) -> dict[str, Any]:
+        """Generate setup instructions."""
+        generator = SetupInstructionGenerator(self.project_path)
+        return generator.generate()
+
+    def save(
+        self, output_path: Path, format: str = "json"
+    ) -> None:
+        """Generate and save context to file."""
+        context = self.generate()
+
+        if format == "json":
+            formatter = JSONFormatter(output_path)
+        elif format == "yaml":
+            formatter = YAMLFormatter(output_path)
+        else:
+            raise ValueError(f"Unknown format: {format}")
+
+        formatter.save(context)
+
+    def generate_from_template(
+        self, template_name: str, template_path: Path | None = None
+    ) -> str:
+        """Generate context using a custom template."""
+        from contextgen.templates.engine import TemplateEngine
+
+        context = self.generate()
+        context["timestamp"] = datetime.utcnow().isoformat() + "Z"
+
+        engine = TemplateEngine(template_path)
+        return engine.render(template_name, context)