higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/application/profile_use_cases.py

@@ -0,0 +1,93 @@
+"""Casos de uso de perfiles y contexto de agente."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from pathlib import Path
+
+from higpertext.kernel.app_config import GLOBAL_PROFILE_NAMES
+from higpertext.kernel.application.ports import (
+    ICapabilityRepository,
+    IProfileRepository,
+    IWorkflowRepository,
+)
+from higpertext.kernel.application.profile_service import ProfileService
+
+
+class GetAgentContextUseCase:
+    """Construye el contexto activo para un perfil de agente."""
+
+    def __init__(
+        self,
+        profiles_repo: IProfileRepository,
+        caps_repo: ICapabilityRepository,
+        workflows_repo: IWorkflowRepository,
+        base_dir: Path,
+    ) -> None:
+        self.profiles_repo = profiles_repo
+        self.caps_repo = caps_repo
+        self.workflows_repo = workflows_repo
+        self.base_dir = base_dir
+
+    def execute(self, profile_name: str, env_data: dict | None = None) -> dict:
+        service = ProfileService(self.profiles_repo, self.caps_repo, self.base_dir)
+        profile = service.resolve_hierarchy(profile_name)
+        cap_ids = self._capability_ids_with_global_defaults(service, profile_name, profile.capabilities)
+
+        return {
+            "profile": asdict(profile),
+            "active_capabilities": self._load_capabilities(cap_ids),
+            "active_workflows": self._load_workflows(profile_name),
+            "environment": env_data or {},
+        }
+
+    def _capability_ids_with_global_defaults(
+        self, service: ProfileService, profile_name: str, capabilities: list[str]
+    ) -> list[str]:
+        cap_ids = list(capabilities)
+        if profile_name.lower() == "global":
+            return cap_ids
+
+        try:
+            global_profile = service.resolve_hierarchy("global")
+            for cap_id in global_profile.capabilities:
+                if cap_id not in cap_ids:
+                    cap_ids.append(cap_id)
+        except (FileNotFoundError, ValueError):  # nosec B110
+            pass
+        return cap_ids
+
+    def _load_capabilities(self, cap_ids: list[str]) -> list[dict]:
+        loaded_caps = []
+        for cap_id in cap_ids:
+            try:
+                loaded_caps.append(asdict(self.caps_repo.load(cap_id)))
+            except FileNotFoundError:  # nosec B110
+                pass
+        return loaded_caps
+
+    def _load_workflows(self, profile_name: str) -> list[dict]:
+        profile_lower = profile_name.lower()
+        return [
+            asdict(workflow)
+            for workflow in self.workflows_repo.list_all()
+            if workflow.required_profile.lower() in GLOBAL_PROFILE_NAMES | {profile_lower}
+        ]
+
+
+class ValidateProfileUseCase:
+    """Valida un perfil y sus dependencias declaradas."""
+
+    def __init__(
+        self,
+        profiles_repo: IProfileRepository,
+        caps_repo: ICapabilityRepository,
+        base_dir: Path,
+    ) -> None:
+        self.profiles_repo = profiles_repo
+        self.caps_repo = caps_repo
+        self.base_dir = base_dir
+
+    def execute(self, profile_name: str) -> tuple[bool, list[str], list[str]]:
+        service = ProfileService(self.profiles_repo, self.caps_repo, self.base_dir)
+        return service.validate_profile(profile_name)

higpertext/kernel/application/rag_service.py

@@ -0,0 +1,75 @@
+"""RAG Application Service - coordina la indexación y búsqueda semántica."""
+
+from __future__ import annotations
+from pathlib import Path
+from higpertext.kernel.domain.rag import IEmbeddingProvider, IVectorStore, VectorEntry
+from higpertext.kernel.infrastructure.parser.code_chunker import CodeChunker
+
+
+class RAGService:
+    """Caso de uso orquestador de indexación y queries semánticas de RAG."""
+
+    def __init__(self, embedder: IEmbeddingProvider, store: IVectorStore) -> None:
+        self.embedder = embedder
+        self.store = store
+
+    def index_project(self, project_root: Path, file_globs: list[str] | None = None) -> int:
+        """Divide e indexa todos los archivos del proyecto que coincidan con los globs."""
+        if file_globs is None:
+            file_globs = ["src/**/*.py", "src/**/*.md", "tests/**/*.py"]
+
+        self.store.clear()
+        all_chunks = []
+
+        # Encontrar y parsear archivos
+        for glob_pattern in file_globs:
+            for file_path in project_root.glob(glob_pattern):
+                # Ignorar archivos en __pycache__ y .venv
+                if "__pycache__" in file_path.parts or ".venv" in file_path.parts or ".git" in file_path.parts:
+                    continue
+                if file_path.is_file():
+                    chunks = CodeChunker.chunk_file(file_path)
+                    all_chunks.extend(chunks)
+
+        if not all_chunks:
+            return 0
+
+        # Generar embeddings e indexar
+        entries: list[VectorEntry] = []
+        for chunk in all_chunks:
+            try:
+                embedding = self.embedder.get_embedding(chunk.content)
+                entries.append(VectorEntry(chunk=chunk, embedding=embedding))
+            except Exception as e:
+                # Silenciar errores individuales de chunks de API para no romper la indexación global
+                print(f"[RAG WARNING] Falló generación de embedding para chunk en {chunk.file}: {e}")
+                continue
+
+        if entries:
+            self.store.add_entries(entries)
+            self.store.save()
+
+        return len(entries)
+
+    def search_context(self, query: str, limit: int = 5) -> list[dict]:
+        """Busca fragmentos semánticamente cercanos y los devuelve formateados."""
+        self.store.load()
+        try:
+            query_vector = self.embedder.get_embedding(query)
+        except Exception as e:
+            raise RuntimeError(f"Error al calcular embedding del query: {e}")
+
+        hits = self.store.search(query_vector, limit=limit)
+        
+        serialized_hits = []
+        for chunk, score in hits:
+            serialized_hits.append({
+                "file": chunk.file,
+                "content": chunk.content,
+                "chunk_type": chunk.chunk_type,
+                "start_line": chunk.start_line,
+                "end_line": chunk.end_line,
+                "metadata": chunk.metadata,
+                "score": score
+            })
+        return serialized_hits

higpertext/kernel/application/roadmap_reporter.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+import json
+from pathlib import Path
+
+from higpertext.kernel.domain.roadmap_reporter import Phase, PhaseStatus, Roadmap, RoadmapReport
+from higpertext.kernel.infrastructure.presentation.html_renderer import HtmlReportRenderer
+from higpertext.kernel.infrastructure.presentation.markdown_report_renderer import MarkdownReportRenderer
+
+_STATUS_ICON = {
+    PhaseStatus.DONE: "✅",
+    PhaseStatus.ACTIVE: "🔄",
+    PhaseStatus.PENDING: "⏳",
+}
+_STATUS_COLOR = {
+    PhaseStatus.DONE: "#3fb950",
+    PhaseStatus.ACTIVE: "#e3b341",
+    PhaseStatus.PENDING: "#8b949e",
+}
+
+
+@dataclass
+class RoadmapAnalysis:
+    summary: str
+    completion_pct: float
+    impact_tags: list[str] = field(default_factory=list)
+    phase_insights: list[str] = field(default_factory=list)
+
+
+class ProgressAnalyzer:
+    """Analiza un RoadmapReport y produce un resumen explicativo."""
+
+    def analyze(self, report: RoadmapReport) -> RoadmapAnalysis:
+        pct = report.completion_pct
+        active = report.active_phase
+        summary = self._build_summary(report, pct, active)
+        tags = self._build_tags(report, pct)
+        insights = self._build_insights(report)
+        return RoadmapAnalysis(
+            summary=summary,
+            completion_pct=pct,
+            impact_tags=tags,
+            phase_insights=insights,
+        )
+
+    def _build_summary(self, report, pct, active) -> str:
+        name = report.roadmap.name
+        done = report.done_phases
+        total = report.total_phases
+        if pct == 100.0:
+            return f'Roadmap "{name}" completed: all {total} phases done.'
+        active_part = f' Currently working on: "{active.name}".' if active else ""
+        return f'Roadmap "{name}" is {pct:.0f}% complete ({done}/{total} phases done).{active_part}'
+
+    def _build_tags(self, report, pct) -> list[str]:
+        tags = []
+        if pct == 100.0:
+            tags.append("completed")
+        elif report.active_phase:
+            tags.append("in-progress")
+        else:
+            tags.append("not-started")
+        if report.all_skills_used:
+            tags.append("skills-tracked")
+        if report.all_subagents_used:
+            tags.append("subagents-used")
+        return tags
+
+    def _build_insights(self, report) -> list[str]:
+        insights = []
+        for phase in report.roadmap.phases:
+            icon = _STATUS_ICON[phase.status]
+            skills_part = f", skills: {', '.join(phase.skills)}" if phase.skills else ""
+            insights.append(f"{icon} [{phase.status.value}] {phase.name}{skills_part}")
+        return insights
+
+
+class RoadmapParser:
+    """Deserializa roadmap JSON en objetos de dominio."""
+
+    def parse(self, raw: str) -> RoadmapReport:
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Invalid roadmap JSON: {exc}") from exc
+        return self._build_report(data)
+
+    def parse_file(self, path: Path) -> RoadmapReport:
+        return self.parse(path.read_text(encoding="utf-8"))
+
+    def _build_report(self, data: dict) -> RoadmapReport:
+        phases = [self._build_phase(p) for p in data.get("phases", [])]
+        roadmap = Roadmap(
+            id=data["id"],
+            name=data["name"],
+            description=data.get("description", ""),
+            phases=phases,
+        )
+        return RoadmapReport(roadmap=roadmap)
+
+    def _build_phase(self, data: dict) -> Phase:
+        return Phase(
+            id=data["id"],
+            name=data["name"],
+            description=data.get("description", ""),
+            status=PhaseStatus(data.get("status", "pending")),
+            skills=list(data.get("skills", [])),
+            subagents=list(data.get("subagents", [])),
+        )
+
+
+class RoadmapReportBuilder:
+    """Genera reportes Markdown y HTML para un RoadmapReport."""
+
+    def to_markdown(self, report: RoadmapReport, analysis: RoadmapAnalysis) -> str:
+        r = report.roadmap
+        renderer = MarkdownReportRenderer()
+        tags = " ".join(f"`{t}`" for t in analysis.impact_tags)
+        phases_rows = "\n".join(
+            f"| {i} | {phase.name} | {_STATUS_ICON[phase.status]} {phase.status.value}"
+            f" | {", ".join(phase.skills) or '—'} | {", ".join(phase.subagents) or '—'} |"
+            for i, phase in enumerate(r.phases, 1)
+        )
+        insights = "\n".join(f"- {ins}" for ins in analysis.phase_insights)
+        return renderer.render_roadmap_report(
+            name=r.name,
+            summary=analysis.summary,
+            completion_pct=f"{analysis.completion_pct:.0f}",
+            done_phases=report.done_phases,
+            total_phases=report.total_phases,
+            tags=tags,
+            phases_rows=phases_rows,
+            insights=insights,
+            skills_all=", ".join(report.all_skills_used) or "—",
+            subs_all=", ".join(report.all_subagents_used) or "—",
+        )
+
+    def to_html(self, report: RoadmapReport, analysis: RoadmapAnalysis) -> str:
+        renderer = HtmlReportRenderer()
+        r = report.roadmap
+        pct = f"{analysis.completion_pct:.0f}"
+        tags_html = " ".join(
+            f'<span class="tag">{t}</span>' for t in analysis.impact_tags
+        )
+        phases_html = "\n".join(
+            renderer.render_roadmap_phase(
+                css=f"phase-{p.status.value}",
+                icon=_STATUS_ICON[p.status],
+                name=p.name,
+                status=p.status.value,
+                description=p.description or "",
+                skills_html=" ".join(
+                    f'<span class="skill-tag">{s}</span>' for s in p.skills
+                ),
+                subs_html=" ".join(
+                    f'<span class="sub-tag">{a}</span>' for a in p.subagents
+                ),
+            )
+            for p in r.phases
+        )
+        skills_html = " ".join(
+            f'<span class="skill-tag">{s}</span>' for s in report.all_skills_used
+        ) or "—"
+        subs_html = " ".join(
+            f'<span class="sub-tag">{a}</span>' for a in report.all_subagents_used
+        ) or "—"
+        body = renderer.render_roadmap_body(
+            name=r.name,
+            done_phases=report.done_phases,
+            total_phases=report.total_phases,
+            summary=analysis.summary,
+            tags_html=tags_html,
+            pct=pct,
+            phases_html=phases_html,
+            skills_html=skills_html,
+            subs_html=subs_html,
+        )
+        return renderer.render_roadmap_shell(title=r.name, body=body)

higpertext/kernel/application/semantic_engine.py

@@ -0,0 +1,258 @@
+"""Semantic Engine Application layer — ClusterService, ContextRanker, and GraphBuilder."""
+
+from __future__ import annotations
+import json
+from collections import defaultdict, deque
+from pathlib import Path
+from higpertext.kernel.domain.semantic_engine import Cluster, SemanticGraph, Symbol, Relation
+from higpertext.kernel.config_paths import PROJECT_ROOT
+
+_SG_CONFIG_PATH = PROJECT_ROOT / "src" / "config" / "semantic_graph.json"
+_SG: dict = json.loads(_SG_CONFIG_PATH.read_text(encoding="utf-8"))
+_SCORES: dict = _SG["ranking"]["scores"]
+_BASE_TOKENS_PER_SYMBOL: int = _SG["ranking"]["base_tokens_per_symbol"]
+_IGNORE_FOLDERS: frozenset[str] = frozenset(_SG["ignore_folders"])
+
+
+class ClusterService:
+    """Detecta comunidades usando Louvain phase-1 (modularity gain greedy)."""
+
+    def detect(self, graph: SemanticGraph, max_passes: int = 20) -> list[Cluster]:
+        symbols = graph.all_symbols()
+        if not symbols:
+            return []
+
+        fqns = [s.fqn for s in symbols]
+        sym_by_fqn: dict[str, Symbol] = {s.fqn: s for s in symbols}
+
+        # Adyacencia ponderada (peso = número de aristas entre par)
+        adj: dict[str, dict[str, float]] = defaultdict(lambda: defaultdict(float))
+        total_weight = 0.0
+        for rel in graph.all_relations():
+            adj[rel.source.fqn][rel.target.fqn] += 1.0
+            adj[rel.target.fqn][rel.source.fqn] += 1.0
+            total_weight += 1.0
+        m = total_weight or 1.0
+
+        # Grado de cada nodo
+        degree: dict[str, float] = {fqn: sum(adj[fqn].values()) for fqn in fqns}
+
+        # Comunidad inicial: cada nodo es su propia comunidad
+        community: dict[str, int] = {fqn: i for i, fqn in enumerate(fqns)}
+
+        def _modularity_gain(fqn: str, target_comm: int) -> float:
+            k_i = degree[fqn]
+            k_i_in = sum(w for nb, w in adj[fqn].items() if community[nb] == target_comm)
+            sigma_tot = sum(degree[f] for f in fqns if community[f] == target_comm)
+            return (k_i_in / m) - (sigma_tot * k_i) / (2 * m * m)
+
+        for _ in range(max_passes):
+            moved = False
+            for fqn in fqns:
+                current = community[fqn]
+                best_comm = current
+                best_gain = 0.0
+
+                neighbors_comms = {community[nb] for nb in adj[fqn]}
+                neighbors_comms.discard(current)
+
+                for candidate in neighbors_comms:
+                    gain = _modularity_gain(fqn, candidate) - _modularity_gain(fqn, current)
+                    if gain > best_gain:
+                        best_gain = gain
+                        best_comm = candidate
+
+                if best_comm != current:
+                    community[fqn] = best_comm
+                    moved = True
+
+            if not moved:
+                break
+
+        # Renumera comunidades de forma compacta
+        label_map: dict[int, int] = {}
+        counter = 0
+        for old in community.values():
+            if old not in label_map:
+                label_map[old] = counter
+                counter += 1
+
+        groups: dict[int, list[Symbol]] = defaultdict(list)
+        for fqn, comm in community.items():
+            groups[label_map[comm]].append(sym_by_fqn[fqn])
+
+        return [
+            Cluster(id=f"cluster-{cid}", members=members) for cid, members in sorted(groups.items())
+        ]
+
+
+class ContextRanker:
+    """Rankea símbolos del grafo por relevancia a un conjunto de keywords."""
+
+    def __init__(self, graph: SemanticGraph) -> None:
+        self._graph = graph
+        self._in_degree = self._build_in_degree()
+
+    def _build_in_degree(self) -> dict[str, int]:
+        degree: dict[str, int] = {}
+        for rel in self._graph.all_relations():
+            degree[rel.target.fqn] = degree.get(rel.target.fqn, 0) + 1
+        return degree
+
+    @staticmethod
+    def _symbol_text(symbol: Symbol) -> str:
+        return " ".join((symbol.name, symbol.fqn, symbol.file, symbol.type.value)).lower()
+
+    def _match_score(self, symbol: Symbol, keywords: list[str]) -> int:
+        score = 0
+        name = symbol.name.lower()
+        file = symbol.file.lower()
+        fqn = symbol.fqn.lower()
+        symbol_type = symbol.type.value.lower()
+        for kw in keywords:
+            structural_query = any(mark in kw for mark in ("/", ".", "::"))
+            if kw == name:
+                score += _SCORES["exact_name"]
+            elif name.startswith(kw):
+                score += _SCORES["name_starts_with"]
+            elif kw in name:
+                score += _SCORES["name_contains"]
+            if structural_query and kw in fqn:
+                score += _SCORES["structural_fqn"]
+            if structural_query and kw in file:
+                score += _SCORES["structural_file"]
+            if kw == symbol_type:
+                score += _SCORES["type_match"]
+        return score
+
+    @staticmethod
+    def _token_cost(symbol: Symbol) -> int:
+        return _BASE_TOKENS_PER_SYMBOL + max(1, (len(symbol.fqn) + len(symbol.type.value)) // 4)
+
+    def rank(
+        self,
+        keywords: list[str],
+        budget: int,
+        depth: int = 2,
+    ) -> list[Symbol]:
+        if not keywords or budget <= 0:
+            return []
+
+        lower_kws = [kw.lower() for kw in keywords]
+        all_symbols = self._graph.all_symbols()
+
+        seeds = [s for s in all_symbols if self._match_score(s, lower_kws) > 0]
+        if not seeds:
+            return []
+
+        seeds.sort(
+            key=lambda s: (
+                -self._match_score(s, lower_kws),
+                -self._in_degree.get(s.fqn, 0),
+                s.file,
+                s.name,
+            ),
+        )
+
+        visited: dict[str, Symbol] = {}
+        queue: deque[tuple[Symbol, int]] = deque()
+
+        for seed in seeds:
+            if seed.fqn not in visited:
+                visited[seed.fqn] = seed
+                queue.append((seed, 0))
+
+        while queue:
+            sym, current_depth = queue.popleft()
+            if current_depth >= depth:
+                continue
+            for neighbor in self._graph.neighbors(sym):
+                if neighbor.fqn not in visited:
+                    visited[neighbor.fqn] = neighbor
+                    queue.append((neighbor, current_depth + 1))
+
+        seed_fqns = {s.fqn for s in seeds}
+        ordered = sorted(
+            visited.values(),
+            key=lambda s: (
+                0 if s.fqn in seed_fqns else 1,
+                -self._match_score(s, lower_kws),
+                -self._in_degree.get(s.fqn, 0),
+                s.file,
+                s.name,
+            ),
+        )
+
+        result: list[Symbol] = []
+        tokens_used = 0
+        for sym in ordered:
+            cost = self._token_cost(sym)
+            if tokens_used + cost > budget:
+                break
+            result.append(sym)
+            tokens_used += cost
+
+        return result
+
+
+class GraphBuilder:
+    """Orquesta parsers multi-lenguaje y construye el SemanticGraph con caché incremental."""
+
+    def build(self, root: Path, incremental: bool = True) -> SemanticGraph:
+        return self.build_with_stats(root, incremental)["graph"]
+
+    def build_with_stats(self, root: Path, incremental: bool = True) -> dict:
+        from higpertext.kernel.infrastructure.semantic_engine import (
+            FileCache,
+            PythonParser,
+            TypeScriptParser,
+            LanguageParser,
+        )
+        from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+        _ignore = _IGNORE_FOLDERS | {WORKSPACE_DIR_NAME}
+
+        parsers: dict[str, LanguageParser] = {
+            ext: _PARSER_CLASS()
+            for ext, _PARSER_CLASS in (
+                (".py",  PythonParser),
+                (".ts",  TypeScriptParser),
+                (".tsx", TypeScriptParser),
+                (".js",  TypeScriptParser),
+                (".jsx", TypeScriptParser),
+            )
+        }
+
+        cache = FileCache(root)
+        cached_hashes = cache.load() if incremental else {}
+        new_hashes: dict[str, str] = dict(cached_hashes)
+        graph = SemanticGraph()
+        parsed = 0
+        skipped = 0
+
+        # Iterar archivos
+        for file_path in root.rglob("*"):
+            if file_path.suffix not in parsers:
+                continue
+            if any(part in _ignore for part in file_path.parts):
+                continue
+
+            rel = file_path.relative_to(root).as_posix()
+            cached = cached_hashes.get(rel)
+            if incremental and not cache.is_changed(rel, file_path, cached):
+                skipped += 1
+                continue
+
+            parser = parsers[file_path.suffix]
+            source = file_path.read_text(encoding="utf-8", errors="ignore")
+            symbols, relations = parser.parse(source=source, file=rel)
+            for sym in symbols:
+                graph.add_symbol(sym)
+            for rel_obj in relations:
+                graph.add_relation(rel_obj)
+            new_hashes[rel] = cache.compute(file_path)
+            parsed += 1
+
+        if incremental:
+            cache.save(new_hashes)
+        return {"graph": graph, "parsed": parsed, "skipped": skipped}

higpertext/kernel/application/session_services.py

@@ -0,0 +1,33 @@
+"""Lógica pura de aplicación para gestión de ciclo de vida de Sesión."""
+
+from __future__ import annotations
+import datetime
+import secrets
+from higpertext.kernel.domain.entities import Session
+from higpertext.kernel.application.ports import ISessionRepository, IProfileRepository
+
+
+class SessionApplicationService:
+    def __init__(self, session_repo: ISessionRepository, profile_repo: IProfileRepository):
+        self.session_repo = session_repo
+        self.profile_repo = profile_repo
+
+    def create_session(
+        self, profile_name: str, assistant: str, skills: list[str], subagents: list[str]
+    ) -> Session:
+        session_id = f"sess_{int(datetime.datetime.now().timestamp())}_{secrets.token_hex(2)}"
+        new_session = Session(
+            session_id=session_id,
+            profile=profile_name,
+            assistant=assistant,
+            status="active",
+            created_at=datetime.datetime.now().isoformat(),
+            active_skills=skills,
+            active_subagents=subagents,
+            tasks=[],
+        )
+        self.session_repo.save(new_session)
+        return new_session
+
+    def clean_session(self) -> None:
+        self.session_repo.delete()