higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/infrastructure/parser/language/python_parser.py

@@ -0,0 +1,98 @@
+"""Python language parser — AST-based extraction."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from .base import LanguageParser, ParseResult
+
+_STDLIB_NOISE = frozenset(
+    {
+        "sys", "re", "json", "ast", "abc", "io", "copy", "math", "time", "enum",
+        "uuid", "glob", "shutil", "fnmatch", "hashlib", "logging", "argparse",
+        "pathlib", "datetime", "textwrap", "itertools", "functools", "operator",
+        "contextlib", "traceback", "subprocess", "threading", "multiprocessing",
+        "tempfile", "collections", "dataclasses", "typing", "types", "inspect",
+        "importlib", "warnings", "unittest", "os.path", "pathlib.Path",
+        "datetime.datetime", "collections.defaultdict", "typing.Optional",
+        "typing.List", "typing.Dict", "typing.Any",
+    }
+)
+
+
+class _ASTVisitor(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.classes: list[dict] = []
+        self.functions: list[dict] = []
+        self.imports: list[str] = []
+
+    def visit_Import(self, node: ast.Import) -> None:
+        for alias in node.names:
+            self.imports.append(alias.name)
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        module = node.module or ""
+        for alias in node.names:
+            full = f"{module}.{alias.name}" if module else alias.name
+            self.imports.append(full)
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        methods = [
+            {
+                "name": n.name,
+                "parameters": [a.arg for a in n.args.args],
+                "docstring": ast.get_docstring(n) or "",
+            }
+            for n in node.body
+            if isinstance(n, ast.FunctionDef)
+        ]
+        self.classes.append(
+            {
+                "name": node.name,
+                "docstring": ast.get_docstring(node) or "",
+                "methods": methods,
+            }
+        )
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        self.functions.append(
+            {
+                "name": node.name,
+                "parameters": [a.arg for a in node.args.args],
+                "docstring": ast.get_docstring(node) or "",
+            }
+        )
+        self.generic_visit(node)
+
+
+def _filter_imports(imports: list[str]) -> list[str]:
+    return sorted(
+        {imp for imp in imports if imp.split(".")[0] not in _STDLIB_NOISE and imp not in _STDLIB_NOISE}
+    )
+
+
+class PythonParser(LanguageParser):
+    """Parses Python files via the stdlib AST."""
+
+    def parse_file(self, file_path: Path) -> ParseResult:
+        try:
+            code = file_path.read_text(encoding="utf-8", errors="replace")
+            tree = ast.parse(code)
+        except (OSError, SyntaxError, ValueError) as exc:
+            return self.empty(note=f"Parser warning: {exc}", lang_type="python")
+
+        visitor = _ASTVisitor()
+        visitor.visit(tree)
+        is_entry = '__name__ == "__main__"' in code or "__name__ == '__main__'" in code
+
+        return ParseResult(
+            imports=_filter_imports(visitor.imports),
+            classes=visitor.classes,
+            functions=visitor.functions,
+            summary=ast.get_docstring(tree) or "",
+            type="python",
+            is_entry_point=is_entry,
+        )

higpertext/kernel/infrastructure/parser/language/typescript_parser.py

@@ -0,0 +1,91 @@
+"""TypeScript / JavaScript language parser."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .base import LanguageParser, ParseResult
+
+_RE_IMPORT_FROM = re.compile(
+    r"""import\s+(?:type\s+)?(?:\{[^}]*\}|[\w*]+)\s+from\s+['"]([^'"]+)['"]"""
+)
+_RE_REQUIRE = re.compile(
+    r"""(?:const|let|var)\s+([\w]+)\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)"""
+)
+_RE_CLASS = re.compile(r"""(?:export\s+(?:default\s+)?)?class\s+([\w]+)""")
+_RE_FUNC_DECL = re.compile(r"""(?:export\s+)?(?:async\s+)?function\s+([\w]+)\s*\(""")
+_RE_ARROW = re.compile(r"""(?:export\s+)?(?:const|let|var)\s+([\w]+)\s*=\s*(?:async\s*)?\(""")
+
+
+class TypeScriptParser(LanguageParser):
+    """Parses TypeScript/JavaScript files via regex."""
+
+    def parse_file(self, file_path: Path) -> ParseResult:
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return self.empty(lang_type="javascript")
+
+        imports = list(
+            {m.group(1) for m in _RE_IMPORT_FROM.finditer(content)}
+            | {m.group(2) for m in _RE_REQUIRE.finditer(content)}
+        )
+        classes = [
+            {"name": m.group(1), "docstring": "", "methods": []}
+            for m in _RE_CLASS.finditer(content)
+        ]
+        functions = [
+            {"name": m.group(1), "parameters": [], "docstring": ""}
+            for pattern in (_RE_FUNC_DECL, _RE_ARROW)
+            for m in pattern.finditer(content)
+        ]
+        return ParseResult(
+            imports=imports,
+            classes=classes,
+            functions=functions,
+            type="javascript",
+        )
+
+    def parse_source(self, source: str, file: str) -> tuple[list, list]:
+        """Secondary interface used by semantic_engine Symbol/Relation extraction."""
+        from higpertext.kernel.domain.semantic_engine import (
+            Relation, RelationType, Symbol, SymbolType,
+        )
+
+        if not source.strip():
+            return [], []
+
+        symbols: list = []
+        relations: list = []
+        file_sym = Symbol(name=file, type=SymbolType.MODULE, file=file, line=0)
+
+        for m in _RE_IMPORT_FROM.finditer(source):
+            mod = Symbol(name=m.group(1), type=SymbolType.MODULE, file=file,
+                         line=source[: m.start()].count("\n") + 1)
+            if mod not in symbols:
+                symbols.append(mod)
+            relations.append(Relation(source=file_sym, target=mod, type=RelationType.IMPORTS))
+
+        for m in _RE_REQUIRE.finditer(source):
+            var = m.group(1)
+            line = source[: m.start()].count("\n") + 1
+            mod = Symbol(name=var, type=SymbolType.MODULE, file=file, line=line)
+            if mod not in symbols:
+                symbols.append(mod)
+            relations.append(Relation(source=file_sym, target=mod, type=RelationType.IMPORTS))
+
+        for m in _RE_CLASS.finditer(source):
+            sym = Symbol(name=m.group(1), type=SymbolType.CLASS, file=file,
+                         line=source[: m.start()].count("\n") + 1)
+            if sym not in symbols:
+                symbols.append(sym)
+
+        for pattern in (_RE_FUNC_DECL, _RE_ARROW):
+            for m in pattern.finditer(source):
+                sym = Symbol(name=m.group(1), type=SymbolType.FUNCTION, file=file,
+                             line=source[: m.start()].count("\n") + 1)
+                if sym not in symbols:
+                    symbols.append(sym)
+
+        return symbols, relations

higpertext/kernel/infrastructure/parser/semantic_graph.py

@@ -0,0 +1,409 @@
+"""higpertext Semantic Graph — indexa símbolos y dependencias del proyecto (Infraestructura)."""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME, PROJECT_ROOT
+import os
+import json
+import re
+import fnmatch
+from collections import defaultdict
+from pathlib import Path
+from higpertext.kernel.infrastructure.parser.language import (
+    PythonParser,
+    TypeScriptParser,
+    PowerShellParser,
+    ParseResult,
+)
+
+# ── Config ────────────────────────────────────────────────────────────────────
+_SG_CONFIG_PATH = PROJECT_ROOT / "src" / "config" / "semantic_graph.json"
+_SG: dict = json.loads(_SG_CONFIG_PATH.read_text(encoding="utf-8"))
+_MD: dict = _SG["markdown"]
+
+_IGNORE_FOLDERS = frozenset(_SG["ignore_folders"]) | {WORKSPACE_DIR_NAME}
+_IGNORE_SUFFIXES = frozenset(_SG["ignore_suffixes"])
+_SUPPORTED_SUFFIXES = frozenset(_SG["supported_suffixes"])
+
+
+class IgnoreChecker:
+    """Determina si una ruta debe ser excluida del análisis."""
+
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+        self.patterns: list[str] = list(_SG["ignore_patterns"])
+        for ignore_file in _SG["ignore_files"]:
+            self._load_ignore_file(project_root / ignore_file)
+
+    def _load_ignore_file(self, path: Path) -> None:
+        if not path.exists():
+            return
+        try:
+            text = path.read_text(encoding="utf-8", errors="ignore")
+            for line in text.splitlines():
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if line.endswith("/"):
+                    self.patterns += [line[:-1], line + "*"]
+                else:
+                    self.patterns += [line, line + "/*"]
+        except OSError:  # nosec B110
+            pass
+
+    def _has_ignored_folder(self, relative_path: str) -> bool:
+        return any(part in _IGNORE_FOLDERS for part in Path(relative_path).parts)
+
+    def _has_ignored_suffix(self, relative_path: str) -> bool:
+        name = Path(relative_path).name.lower()
+        return any(name.endswith(s) for s in _IGNORE_SUFFIXES)
+
+    def _has_unsupported_suffix(self, relative_path: str) -> bool:
+        suffix = Path(relative_path).suffix.lower()
+        return bool(suffix) and suffix not in _SUPPORTED_SUFFIXES
+
+    def _matches_pattern(self, relative_path: str) -> bool:
+        name = Path(relative_path).name
+        return any(
+            fnmatch.fnmatch(relative_path, p) or fnmatch.fnmatch(name, p) for p in self.patterns
+        )
+
+    def is_ignored(self, relative_path: str) -> bool:
+        return (
+            self._has_ignored_folder(relative_path)
+            or self._has_ignored_suffix(relative_path)
+            or self._has_unsupported_suffix(relative_path)
+            or self._matches_pattern(relative_path)
+        )
+
+
+_PARSER_CLASSES = {
+    "python":     PythonParser,
+    "powershell":  PowerShellParser,
+    "typescript": TypeScriptParser,
+}
+_PARSERS: dict[str, object] = {
+    ext: _PARSER_CLASSES[name]()
+    for ext, name in _SG["parser_map"].items()
+}
+
+
+class SemanticGraphGenerator:
+    """Genera el grafo semántico del proyecto (JSON + Markdown)."""
+
+    @staticmethod
+    def _parse_file(full_path: Path, suffix: str) -> dict:
+        parser = _PARSERS.get(suffix)
+        if parser is not None:
+            result: ParseResult = parser.parse_file(full_path)  # type: ignore[union-attr]
+        else:
+            result = ParseResult(type=suffix.lstrip(".") or "unknown")
+        result.size = full_path.stat().st_size
+        return result.to_dict()
+
+    # --- Compatibility shims (delegated to shared parsers) ---
+
+    @staticmethod
+    def parse_python(file_path: Path) -> dict:
+        return _PARSERS[".py"].parse_file(file_path).to_dict()  # type: ignore[union-attr]
+
+    @staticmethod
+    def parse_powershell(file_path: Path) -> dict:
+        return _PARSERS[".ps1"].parse_file(file_path).to_dict()  # type: ignore[union-attr]
+
+    @staticmethod
+    def parse_javascript(file_path: Path) -> dict:
+        return _PARSERS[".js"].parse_file(file_path).to_dict()  # type: ignore[union-attr]
+
+    @staticmethod
+    def resolve_dependencies(files_data: dict) -> list[dict]:
+        all_paths = list(files_data.keys())
+        deps = []
+        for rel_path, data in files_data.items():
+            for imp in data.get("imports", []):
+                parts = imp.split(".")
+                resolved = next(
+                    (
+                        f
+                        for f in all_paths
+                        if list(Path(f).with_suffix("").parts[-len(parts) :]) == parts
+                        and f != rel_path
+                    ),
+                    None,
+                )
+                if resolved:
+                    deps.append({"from": rel_path, "to": resolved})
+        return deps
+
+    @classmethod
+    def generate(cls, project_root: Path) -> None:
+        project_root = project_root.resolve()
+        checker = IgnoreChecker(project_root)
+        files_data: dict = {}
+
+        for root, dirs, files in os.walk(project_root):
+            dirs[:] = [d for d in dirs if not checker.is_ignored(str(Path(root) / d))]
+            for file in files:
+                full_path = Path(root) / file
+                rel_path = str(full_path.relative_to(project_root))
+                if checker.is_ignored(rel_path):
+                    continue
+                files_data[rel_path] = cls._parse_file(full_path, full_path.suffix.lower())
+
+        dependencies = cls.resolve_dependencies(files_data)
+
+        higpertext_dir = project_root / WORKSPACE_DIR_NAME / "state"
+        higpertext_dir.mkdir(parents=True, exist_ok=True)
+
+        json_path = higpertext_dir / "semantic_graph.json"
+        graph_data = {
+            "generated_at": (json_path.stat().st_mtime if json_path.exists() else None),
+            "files": files_data,
+            "dependencies": dependencies,
+        }
+        json_path.write_text(json.dumps(graph_data, indent=4, ensure_ascii=False), encoding="utf-8")
+
+        cls._write_markdown_graph(higpertext_dir / "semantic_graph.md", files_data, dependencies)
+
+    # --- Markdown generation helpers ---
+
+    @staticmethod
+    def _layer_map_lines(files_data: dict) -> list[str]:
+        layer_counts: dict[str, int] = defaultdict(int)
+        for fp, data in files_data.items():
+            has_content = data.get("classes") or data.get("functions")
+            if not has_content:
+                continue
+            parts = Path(fp).parts
+            layer = parts[0] if len(parts) == 1 else "/".join(parts[:2])
+            layer_counts[layer] += 1
+
+        if not layer_counts:
+            return []
+
+        lines = [_MD["section_layer_map"], ""]
+        lines += [_MD["layer_table_header"], _MD["layer_table_sep"]]
+        for layer, count in sorted(layer_counts.items(), key=lambda x: -x[1]):
+            lines.append(f"| `{layer}` | {count} |")
+        lines += ["", "---", ""]
+        return lines
+
+    @staticmethod
+    def _entry_points_lines(files_data: dict) -> list[str]:
+        entries = [fp for fp, data in sorted(files_data.items()) if data.get("is_entry_point")]
+        if not entries:
+            return []
+        lines = [_MD["section_entry_points"], ""]
+        for fp in entries:
+            lines.append(f"- [`{fp}`](file:///{fp})")
+        lines += ["", "---", ""]
+        return lines
+
+    @staticmethod
+    def _mermaid_block(files_data: dict, dependencies: list) -> list[str]:
+        layer_deps: set[tuple[str, str]] = set()
+        for dep in dependencies:
+            from_layer = Path(dep["from"]).parts[0]
+            to_layer = Path(dep["to"]).parts[0]
+            if from_layer != to_layer:
+                layer_deps.add((from_layer, to_layer))
+
+        if not layer_deps:
+            return []
+
+        lines = [_MD["section_dep_graph"], "```mermaid", "graph TD"]
+        seen_nodes: set[str] = set()
+        for src, dst in sorted(layer_deps):
+            src_id = re.sub(r"\W", "_", src)
+            dst_id = re.sub(r"\W", "_", dst)
+            if src_id not in seen_nodes:
+                lines.append(f'  {src_id}["{src}"]')
+                seen_nodes.add(src_id)
+            if dst_id not in seen_nodes:
+                lines.append(f'  {dst_id}["{dst}"]')
+                seen_nodes.add(dst_id)
+            lines.append(f"  {src_id} --> {dst_id}")
+        lines += ["```", "", "---", ""]
+        return lines
+
+    @staticmethod
+    def _render_classes(classes: list) -> list[str]:
+        lines = ["#### Classes"]
+        for cls in classes:
+            doc = f" — *{cls['docstring'].strip()}*" if cls.get("docstring") else ""
+            lines.append(f"- **`class {cls['name']}`**{doc}")
+            for method in cls.get("methods", []):
+                params_str = ", ".join(method["parameters"])
+                mdoc = f" — *{method['docstring'].strip()}*" if method.get("docstring") else ""
+                lines.append(f"  - `def {method['name']}({params_str})`{mdoc}")
+        lines.append("")
+        return lines
+
+    @staticmethod
+    def _render_functions(functions: list) -> list[str]:
+        lines = ["#### Functions"]
+        for func in functions:
+            params_str = ", ".join(func.get("parameters", []))
+            fdoc = f" — *{func['docstring'].strip()}*" if func.get("docstring") else ""
+            lines.append(f"- `def {func['name']}({params_str})`{fdoc}")
+        lines.append("")
+        return lines
+
+    @staticmethod
+    def _file_section(filepath: str, data: dict) -> list[str]:
+        has_content = data.get("classes") or data.get("functions") or data.get("summary")
+        if not has_content:
+            return []
+        ftype = data.get("type", "unknown").upper()
+        header = f"### 📂 [{filepath}](file:///{filepath}) ({ftype})"
+        lines: list[str] = [header]
+        if data.get("summary"):
+            lines += [f"*{data['summary'].strip()}*", ""]
+        if data.get("classes"):
+            lines += SemanticGraphGenerator._render_classes(data["classes"])
+        if data.get("functions"):
+            lines += SemanticGraphGenerator._render_functions(data["functions"])
+        if data.get("imports"):
+            imports_str = ", ".join(f"`{imp}`" for imp in sorted(data["imports"]))
+            lines += [f"**Imports**: {imports_str}", ""]
+        lines += ["---", ""]
+        return lines
+
+    @staticmethod
+    def _has_symbols(data: dict) -> bool:
+        return bool(data.get("classes") or data.get("functions"))
+
+    @classmethod
+    def _write_markdown_graph(cls, md_path: Path, files_data: dict, dependencies: list) -> None:
+        symbol_files = {fp: d for fp, d in files_data.items() if cls._has_symbols(d)}
+        total = len(files_data)
+        with_symbols = len(symbol_files)
+
+        lines: list[str] = [
+            _MD["graph_title"],
+            "",
+            _MD["graph_description"],
+            "",
+            _MD["section_overview"],
+            f"- **Total indexed files**: {total}",
+            f"- **Files with symbols**: {with_symbols}",
+            "",
+            "---",
+            "",
+        ]
+
+        lines += cls._layer_map_lines(files_data)
+        lines += cls._entry_points_lines(files_data)
+        if dependencies:
+            lines += cls._mermaid_block(files_data, dependencies)
+
+        lines += [_MD["section_files_dir"], ""]
+        groups: dict[str, list[str]] = defaultdict(list)
+        for fp in sorted(symbol_files):
+            parts = Path(fp).parts
+            group = "/".join(parts[:2]) if len(parts) > 2 else parts[0]
+            groups[group].append(fp)
+
+        for group in sorted(groups):
+            lines += [f"### 📁 `{group}/`", ""]
+            is_test_group = any(p in group.lower() for p in _SG["test_group_markers"])
+            if is_test_group:
+                for filepath in groups[group]:
+                    lines.append(f"- [`{Path(filepath).name}`](file:///{filepath})")
+                lines.append("")
+            else:
+                for filepath in groups[group]:
+                    lines += cls._file_section(filepath, symbol_files[filepath])
+
+        project_root = md_path.parent.parent
+        lines += cls._capabilities_index_lines(project_root)
+        lines += cls._profiles_index_lines(project_root)
+
+        md_path.write_text("\n".join(lines), encoding="utf-8")
+
+    @staticmethod
+    def _capabilities_index_lines(project_root: Path) -> list[str]:
+        _desc_max = _SG["description_max_length"]
+        caps_root = PROJECT_ROOT / _SG["paths"]["capabilities_root"]
+        if not caps_root.exists():
+            return []
+
+        rows: list[tuple[str, str, str, str]] = []
+        for json_file in sorted(caps_root.rglob("*.json")):
+            try:
+                data = json.loads(json_file.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                continue
+            cap_id = data.get("id", "")
+            if not cap_id:
+                continue
+            description = data.get("description", "")[:_desc_max]
+            hook = data.get("hook_task_id", "—")
+            entrypoint = data.get("entrypoint", "")
+            rows.append((cap_id, description, hook, entrypoint))
+
+        if not rows:
+            return []
+
+        lines = [
+            _MD["section_caps_index"],
+            "",
+            _MD["caps_description"],
+            "",
+            _MD["caps_table_header"],
+            _MD["caps_table_sep"],
+        ]
+        for cap_id, desc, hook, entry in rows:
+            lines.append(f"| `{cap_id}` | {desc} | `{hook}` | `{entry}` |")
+        lines += ["", "---", ""]
+        return lines
+
+    @staticmethod
+    def _profiles_index_lines(project_root: Path) -> list[str]:
+        profiles_root = PROJECT_ROOT / _SG["paths"]["profiles_root"]
+        caps_root = PROJECT_ROOT / _SG["paths"]["capabilities_root"]
+        if not profiles_root.exists():
+            return []
+
+        hook_map: dict[str, str] = {}
+        for json_file in caps_root.rglob("*.json"):
+            try:
+                data = json.loads(json_file.read_text(encoding="utf-8"))
+                cap_id = data.get("id", "")
+                hook = data.get("hook_task_id", "")
+                if cap_id and hook:
+                    hook_map[cap_id] = hook
+            except (OSError, json.JSONDecodeError):
+                continue
+
+        lines = [
+            _MD["section_profiles"],
+            "",
+            _MD["profiles_description"],
+            "",
+        ]
+
+        for profile_file in sorted(profiles_root.glob("*.json")):
+            try:
+                profile = json.loads(profile_file.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                continue
+
+            name = profile.get("name", profile_file.stem)
+            desc = profile.get("description", "")
+            capabilities = profile.get("capabilities", [])
+            active_hooks = sorted({hook_map[c] for c in capabilities if c in hook_map})
+
+            lines += [
+                f"### `{name}`",
+                f"*{desc}*",
+                "",
+                f"**Capabilities** ({len(capabilities)}): "
+                + ", ".join(f"`{c}`" for c in capabilities),
+                "",
+                "**Hooks activos**: "
+                + (", ".join(f"`{h}`" for h in active_hooks) if active_hooks else "—"),
+                "",
+            ]
+
+        lines += ["---", ""]
+        return lines

higpertext/kernel/infrastructure/presentation/__init__.py

@@ -0,0 +1 @@
+# Infrastructure presentation init