higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/application/commit_reporter.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+
+from higpertext.kernel.domain.commit_reporter import Commit, FileChange, CommitReport, CommitType, Layer
+from higpertext.kernel.app_config import LOG_SEP as _LOG_SEP
+from higpertext.kernel.infrastructure.presentation.html_renderer import HtmlReportRenderer
+from higpertext.kernel.infrastructure.presentation.markdown_report_renderer import MarkdownReportRenderer
+
+def parse_git_stat_line(line: str) -> tuple[str, str] | None:
+    """Parsea una línea de `git --stat` en tiempo lineal, sin regex con cuantificadores."""
+    path_part, separator, rest = line.strip().partition("|")
+    if not separator:
+        return None
+    path = path_part.strip()
+    if not path:
+        return None
+    fields = rest.strip().split(maxsplit=1)
+    if not fields or not fields[0].isdigit():
+        return None
+    markers = fields[1].strip() if len(fields) > 1 else ""
+    if any(char not in "+-" for char in markers):
+        return None
+    return path, markers
+
+
+def parse_git_header(line: str) -> tuple[str, str] | None:
+    commit_hash, separator, message = line.strip().partition(" ")
+    if not separator or len(commit_hash) < 6:
+        return None
+    if any(char not in "0123456789abcdef" for char in commit_hash.lower()):
+        return None
+    return commit_hash, message.strip()
+
+
+def first_prefixed_value(lines: list[str], prefix: str) -> str:
+    for line in lines:
+        if line.startswith(prefix):
+            return line.removeprefix(prefix).strip()
+    return "unknown"
+
+class CommitParser:
+    """Parsea salida de git show/log en objetos de dominio."""
+
+    def parse_show(self, output: str) -> CommitReport | None:
+        if not output.strip():
+            return None
+        lines = output.strip().splitlines()
+        header = parse_git_header(lines[0])
+        if not header:
+            return None
+
+        commit_hash, message = header
+
+        commit = Commit(
+            hash=commit_hash,
+            message=message,
+            author=first_prefixed_value(lines, "Author:"),
+            date=first_prefixed_value(lines, "Date:"),
+        )
+        changes = self._parse_stat_lines(lines)
+        return CommitReport(commit=commit, changes=changes)
+
+    def parse_log(self, output: str) -> list[Commit]:
+        commits = []
+        for line in output.strip().splitlines():
+            if _LOG_SEP not in line:
+                continue
+            parts = line.split(_LOG_SEP)
+            if len(parts) < 4:
+                continue
+            commits.append(
+                Commit(
+                    hash=parts[0].strip(),
+                    message=parts[1].strip(),
+                    author=parts[2].strip(),
+                    date=parts[3].strip(),
+                )
+            )
+        return commits
+
+    def _parse_stat_lines(self, lines: list[str]) -> list[FileChange]:
+        changes = []
+        for line in lines:
+            parsed = parse_git_stat_line(line)
+            if not parsed:
+                continue
+            path, markers = parsed
+            additions = markers.count("+")
+            deletions = markers.count("-")
+            changes.append(FileChange(path=path, additions=additions, deletions=deletions))
+        return changes
+
+
+_TYPE_LABELS = {
+    CommitType.FEAT: "new feature",
+    CommitType.FIX: "bug fix",
+    CommitType.DOCS: "documentation update",
+    CommitType.REFACTOR: "refactor",
+    CommitType.TEST: "test improvement",
+    CommitType.CHORE: "chore/maintenance",
+    CommitType.PERF: "performance improvement",
+    CommitType.CI: "CI/CD change",
+    CommitType.OTHER: "change",
+}
+
+
+@dataclass
+class CommitAnalysis:
+    summary: str
+    has_new_tests: bool
+    has_new_capabilities: bool
+    impact_tags: list[str] = field(default_factory=list)
+
+
+class ImpactAnalyzer:
+    """Analiza un CommitReport y produce un resumen explicativo."""
+
+    def analyze(self, report: CommitReport) -> CommitAnalysis:
+        commit = report.commit
+        type_label = _TYPE_LABELS.get(commit.commit_type, "change")
+        scope_part = f" in `{commit.scope}`" if commit.scope else ""
+        summary = f"This commit introduces a {type_label}{scope_part}: {commit.subject}."
+
+        tags = self._build_tags(report)
+        return CommitAnalysis(
+            summary=summary,
+            has_new_tests=report.has_new_tests,
+            has_new_capabilities=report.has_new_capabilities,
+            impact_tags=tags,
+        )
+
+    def _build_tags(self, report: CommitReport) -> list[str]:
+        tags = [report.commit.commit_type.value]
+        by_layer = report.files_by_layer()
+        if Layer.TEST in by_layer:
+            tags.append("tested")
+        if Layer.CAPABILITY in by_layer:
+            tags.append("new-capability")
+        if Layer.DOMAIN in by_layer:
+            tags.append("domain-change")
+        if Layer.INFRASTRUCTURE in by_layer:
+            tags.append("infra-change")
+        return tags
+
+
+_LAYER_ORDER = [
+    Layer.DOMAIN,
+    Layer.APPLICATION,
+    Layer.INFRASTRUCTURE,
+    Layer.CAPABILITY,
+    Layer.TEST,
+    Layer.OTHER,
+]
+
+_TYPE_COLOR = {
+    CommitType.FEAT: "#3fb950",
+    CommitType.FIX: "#f85149",
+    CommitType.DOCS: "#79c0ff",
+    CommitType.REFACTOR: "#d2a8ff",
+    CommitType.TEST: "#e3b341",
+    CommitType.CHORE: "#8b949e",
+    CommitType.PERF: "#ffa657",
+    CommitType.CI: "#bc8cff",
+    CommitType.OTHER: "#8b949e",
+}
+
+
+class ReportBuilder:
+    """Genera reportes Markdown y HTML a partir de CommitReport + CommitAnalysis."""
+
+    def to_markdown(
+        self, report: CommitReport, analysis: CommitAnalysis, diff: str | None = None
+    ) -> str:
+        c = report.commit
+        renderer = MarkdownReportRenderer()
+        tags = " ".join(f"`{t}`" for t in analysis.impact_tags)
+        layers_md = self._build_layers_md(report)
+        diff_section = "\n---\n\n## Diff completo\n```diff\n" + diff + "\n```" if diff else ""
+        return renderer.render_commit_report(
+            short_hash=c.short_hash,
+            date=c.date,
+            author=c.author,
+            summary=analysis.summary,
+            tags=tags,
+            changed_files_count=report.changed_files_count,
+            total_additions=report.total_additions,
+            total_deletions=report.total_deletions,
+            layers_md=layers_md,
+            diff_section=diff_section,
+        )
+
+    @staticmethod
+    def _build_layers_md(report: CommitReport) -> str:
+        by_layer = report.files_by_layer()
+        sections: list[str] = []
+        for layer in _LAYER_ORDER:
+            files = by_layer.get(layer, [])
+            if not files:
+                continue
+            sections.append(f"\n### {layer.value.capitalize()}")
+            for f in files:
+                sections.append(f"- `{f.path}` — +{f.additions} / -{f.deletions}")
+        return "\n".join(sections)
+
+    def to_html(
+        self, report: CommitReport, analysis: CommitAnalysis, diff: str | None = None
+    ) -> str:
+        c = report.commit
+        renderer = HtmlReportRenderer()
+        color = _TYPE_COLOR.get(c.commit_type, "#8b949e")
+        tags_html = " ".join(
+            f'<span class="tag">{t}</span>' for t in analysis.impact_tags
+        )
+        layers_html = self._build_layers_html(report, renderer)
+        diff_section = renderer.render_diff(renderer.build_diff_lines(diff)) if diff else ""
+        body = renderer.render_body(
+            commit_type=c.commit_type.value,
+            subject=c.subject,
+            short_hash=c.short_hash,
+            date=c.date,
+            author=c.author,
+            summary=analysis.summary,
+            tags_html=tags_html,
+            changed_files_count=report.changed_files_count,
+            total_additions=report.total_additions,
+            total_deletions=report.total_deletions,
+            layers_html=layers_html,
+            diff_section=diff_section,
+        )
+        return renderer.render_shell(c.short_hash, color, body)
+
+    @staticmethod
+    def _build_layers_html(report: CommitReport, renderer: HtmlReportRenderer) -> str:
+        by_layer = report.files_by_layer()
+        sections: list[str] = []
+        for layer in _LAYER_ORDER:
+            files = by_layer.get(layer, [])
+            if not files:
+                continue
+            rows = "".join(
+                f"<tr><td><code>{f.path}</code></td>"
+                f'<td class="add">+{f.additions}</td>'
+                f'<td class="del">-{f.deletions}</td></tr>'
+                for f in files
+            )
+            sections.append(renderer.render_layer(layer.value.capitalize(), rows))
+        return "\n".join(sections)

higpertext/kernel/application/context_builder.py

@@ -0,0 +1,166 @@
+"""SessionContextBuilder — resuelve skills y subagentes para una sesión (Aplicación)."""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+import json
+from pathlib import Path
+
+from higpertext.kernel.infrastructure.logger import get_logger
+from higpertext.kernel.app_config import UNIVERSAL_SKILLS as _UNIVERSAL_SKILLS
+_log = get_logger()
+
+_UNIVERSAL_SUBAGENTS = []
+
+
+class SessionContextBuilder:
+    """Responsabilidad única: determinar qué skills/subagentes montar en sesión."""
+
+    def __init__(self, project_root: Path, root_dir: Path) -> None:
+        self.project_root = project_root
+        self.root_dir = root_dir
+
+    def resolve_resources(
+        self,
+        profile_name: str,
+        skills: list | None,
+        subagents: list | None,
+    ) -> tuple[list, list]:
+        if not skills and not subagents:
+            skills, subagents, loaded = self.load_resources_from_roadmap(profile_name)
+            if not loaded:
+                skills, subagents = self.load_resources_from_profile(profile_name)
+        return skills or [], subagents or []
+
+    def load_resources_from_roadmap(self, profile_name: str = "") -> tuple[list, list, bool]:
+        roadmaps_dir = self.project_root / WORKSPACE_DIR_NAME / "config" / "roadmaps"
+        active_index = roadmaps_dir / "active.json"
+        if active_index.exists():
+            return self._load_from_roadmaps_dir(roadmaps_dir, active_index, profile_name)
+        return self._load_from_single_roadmap(profile_name)
+
+    def _load_from_roadmaps_dir(
+        self, roadmaps_dir: Path, active_index: Path, profile_name: str
+    ) -> tuple[list, list, bool]:
+        try:
+            active_ids: list[str] = json.loads(active_index.read_text(encoding="utf-8")).get(
+                "active", []
+            )
+        except (OSError, json.JSONDecodeError):
+            return [], [], False
+
+        if not active_ids:
+            return [], [], False
+
+        merged_skills: list[str] = []
+        merged_subagents: list[str] = []
+        loaded: list[str] = []
+
+        for rid in active_ids:
+            roadmap_file = roadmaps_dir / f"{rid}.json"
+            if not roadmap_file.exists():
+                _log.warning(f"[!] Roadmap '{rid}' no encontrado en roadmaps/ — omitiendo.")
+                continue
+            try:
+                self._process_roadmap_file(
+                    roadmap_file, rid, profile_name, merged_skills, merged_subagents, loaded
+                )
+            except (OSError, json.JSONDecodeError):
+                continue
+
+        if not loaded:
+            return [], [], False
+
+        projects_str = ", ".join(f"'{p}'" for p in loaded)
+        _log.info(
+            f"[*] Roadmaps activos: {projects_str} — montando {len(merged_skills)} "
+            f"skill(s) y {len(merged_subagents)} subagente(s)."
+        )
+        return merged_skills, merged_subagents, True
+
+    def _process_roadmap_file(
+        self,
+        roadmap_file: Path,
+        rid: str,
+        profile_name: str,
+        merged_skills: list[str],
+        merged_subagents: list[str],
+        loaded: list[str],
+    ) -> None:
+        data = json.loads(roadmap_file.read_text(encoding="utf-8"))
+        roadmap_profile = data.get("profile", "")
+        if roadmap_profile and profile_name and roadmap_profile != profile_name:
+            _log.warning(
+                f"[!] Roadmap '{rid}' es de perfil '{roadmap_profile}'"
+                f" (activo: '{profile_name}') — omitiendo."
+            )
+            return
+        res = data.get("session_resources", {})
+        for s in res.get("skills", []):
+            if s not in merged_skills:
+                merged_skills.append(s)
+        for sa in res.get("subagents", []):
+            if sa not in merged_subagents:
+                merged_subagents.append(sa)
+        loaded.append(data.get("project", rid))
+
+    def _load_from_single_roadmap(self, profile_name: str) -> tuple[list, list, bool]:
+        roadmap_file = self.project_root / WORKSPACE_DIR_NAME / "config" / "roadmap.json"
+        if not roadmap_file.exists():
+            return [], [], False
+        try:
+            data = json.loads(roadmap_file.read_text(encoding="utf-8"))
+            roadmap_profile = data.get("profile", "")
+            if roadmap_profile and profile_name and roadmap_profile != profile_name:
+                _log.warning(
+                    f"[!] Roadmap '{data.get('project', '')}' es de perfil"
+                    f" '{roadmap_profile}' (activo: '{profile_name}') — ignorando roadmap."
+                )
+                return [], [], False
+            res = data.get("session_resources", {})
+            skills = res.get("skills", [])
+            subagents = res.get("subagents", [])
+            if skills or subagents:
+                _log.info(f"[*] Roadmap detectado: '{
+                        data.get(
+                            'project',
+                            '')}' — montando {
+                        len(skills)} skill(s) y {
+                        len(subagents)} subagente(s).")
+                return skills, subagents, True
+        except (OSError, json.JSONDecodeError):  # nosec B110
+            pass
+        return [], [], False
+
+    def load_resources_from_profile(self, profile_name: str) -> tuple[list, list]:
+        skills, subagents = self._resolve_profile_resources(profile_name)
+        if not skills and not subagents:
+            skills, subagents = _UNIVERSAL_SKILLS[:], _UNIVERSAL_SUBAGENTS[:]
+            _log.info(
+                f"[*] Sin roadmap ni recursos en perfil '{profile_name}'"
+                f" — montando Set Universal de Desarrollo."
+            )
+        else:
+            _log.info(f"[*] Sin roadmap activo — usando recursos del perfil '{profile_name}'.")
+        return skills, subagents
+
+    def _resolve_profile_resources(self, profile_name: str) -> tuple[list, list]:
+        """Delega en ProfileService para resolver la jerarquía de perfiles."""
+        try:
+            from higpertext.kernel.infrastructure.file_repositories import (
+                FileProfileRepository,
+                FileCapabilityRepository,
+            )
+            from higpertext.kernel.application.profile_service import ProfileService
+            from higpertext.kernel.pkg_resources import resolve_resource
+
+            profiles_repo = FileProfileRepository(
+                resolve_resource(self.root_dir, "src", "config", "profiles")
+            )
+            caps_repo = FileCapabilityRepository(
+                resolve_resource(self.root_dir, "src", "higpertext", "capabilities")
+            )
+            service = ProfileService(profiles_repo, caps_repo, self.root_dir)
+            profile = service.resolve_hierarchy(profile_name)
+            return list(profile.session_skills), list(profile.session_subagents)
+        except (FileNotFoundError, ValueError):
+            return [], []