klapcontext 0.2.0__tar.gz → 0.3.1__tar.gz

{klapcontext-0.2.0/src/klapcontext.egg-info → klapcontext-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: klapcontext
-Version: 0.2.0
+Version: 0.3.1
 Summary: Make your repository understandable to humans and AI.
 Author: Willy Cordon
 License-Expression: Apache-2.0
@@ -91,6 +91,7 @@ tu `.gitignore`.
 | `klap status [ruta]` | Indica si el contexto está actualizado respecto a Git. |
 | `klap open [ruta]` | Abre el portal humano estático. |
 | `klap agent [ruta]` | Muestra la configuración MCP local de Graphify. |
+| `klap context "tarea" [ruta]` | Compila un contexto focalizado reutilizando `.klap/context.json` si existe. |
 | `klap --version` | Muestra la versión instalada. |
 
 ## Salidas
@@ -121,6 +122,9 @@ El workflow de GitHub Actions publica tags `v*` mediante PyPI Trusted
 Publishing. Antes del primer tag, configurá el publisher de PyPI para este
 repositorio y workflow. No se necesitan tokens de PyPI en el repositorio.
 
+El repositorio ya incluye `.github/workflows/publish-pypi.yml`: al publicar un
+tag `vX.Y.Z`, GitHub construye el paquete y lo publica con ese publisher.
+
 ## Licencia
 
 Apache-2.0. Ver [LICENSE](LICENSE).

{klapcontext-0.2.0 → klapcontext-0.3.1}/README.md

@@ -57,6 +57,7 @@ tu `.gitignore`.
 | `klap status [ruta]` | Indica si el contexto está actualizado respecto a Git. |
 | `klap open [ruta]` | Abre el portal humano estático. |
 | `klap agent [ruta]` | Muestra la configuración MCP local de Graphify. |
+| `klap context "tarea" [ruta]` | Compila un contexto focalizado reutilizando `.klap/context.json` si existe. |
 | `klap --version` | Muestra la versión instalada. |
 
 ## Salidas
@@ -87,6 +88,9 @@ El workflow de GitHub Actions publica tags `v*` mediante PyPI Trusted
 Publishing. Antes del primer tag, configurá el publisher de PyPI para este
 repositorio y workflow. No se necesitan tokens de PyPI en el repositorio.
 
+El repositorio ya incluye `.github/workflows/publish-pypi.yml`: al publicar un
+tag `vX.Y.Z`, GitHub construye el paquete y lo publica con ese publisher.
+
 ## Licencia
 
 Apache-2.0. Ver [LICENSE](LICENSE).

{klapcontext-0.2.0 → klapcontext-0.3.1}/src/klapcontext/__init__.py

@@ -1,3 +1,3 @@
 """KlapContext local engineering-context generator."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.1"

{klapcontext-0.2.0 → klapcontext-0.3.1}/src/klapcontext/agent/compiler.py

@@ -27,14 +27,19 @@ def _rank(items: list[dict], terms: set[str], limit: int) -> list[dict]:
 
 def compile_context(root: Path, query: str, *, detail: str = "standard", max_tokens: int = 5000) -> dict:
     plan = ContextPlanner().plan(query, detail=detail, max_tokens=max_tokens)
-    context = build(root, {"nodes": []}); model = context["system_model"]; limit = min(DETAIL_LIMITS[detail], max(1, max_tokens // 350)); terms = _terms(query, plan.area)
+    cached = root / ".klap" / "context.json"
+    try:
+        context = json.loads(cached.read_text(encoding="utf-8")) if cached.exists() else build(root, {"nodes": []})
+    except (OSError, json.JSONDecodeError):
+        context = build(root, {"nodes": []})
+    model = context["system_model"]; limit = min(DETAIL_LIMITS[detail], max(1, max_tokens // 350)); terms = _terms(query, plan.area)
     entries = _rank(model["entry_points"], terms, limit); flows = _rank(model["main_flows"], terms, limit); files = _rank(model["important_files"], terms, limit)
     read_first = ([{"path": item.get("file"), "reason": "Punto de entrada relacionado", "relevance": item["relevance"]} for item in entries if item.get("file")] + files)[:limit]
     result = {"intent": plan.intent, "confidence": plan.confidence, "query": query, "area": plan.area, "detail": detail, "max_tokens": max_tokens, "entry_points": entries, "flows": flows, "symbols": _rank(model["semantic_model"]["components"], terms, limit), "files": files, "dependencies": _rank(model["dependencies"], terms, limit), "tests": _rank(context["tests"], terms, limit), "read_first": read_first, "evidence": [evidence for group in entries + flows for evidence in group.get("evidence", [])][:limit], "uncertainties": model["unknowns"], "strategy": plan.strategy}
     result["verification"] = reconcile(result["evidence"])
     result = sanitize(result)
     result["estimated_tokens"] = min(max_tokens, len(json.dumps(result, ensure_ascii=False)) // 4)
-    result["execution"] = {"capabilities": plan.capabilities, "providers": plan.providers, "files_selected": len(result["read_first"]), "sections_selected": len(plan.sections), "adaptive": True}
+    result["execution"] = {"capabilities": plan.capabilities, "providers": plan.providers, "files_selected": len(result["read_first"]), "sections_selected": len(plan.sections), "adaptive": True, "context_source": "cached" if cached.exists() else "generated"}
     return result
 
 

{klapcontext-0.2.0 → klapcontext-0.3.1}/src/klapcontext/context_builder.py

@@ -18,6 +18,21 @@ def _nodes(graph: dict) -> list[dict]:
     return graph.get("nodes", []) if isinstance(graph.get("nodes"), list) else graph.get("graph", {}).get("nodes", [])
 
 
+def _edges(graph: dict) -> list[dict]:
+    """Graphify has emitted both `edges` and `links` across supported versions."""
+    for key in ("edges", "links"):
+        value = graph.get(key)
+        if isinstance(value, list):
+            return value
+    nested = graph.get("graph", {})
+    if isinstance(nested, dict):
+        for key in ("edges", "links"):
+            value = nested.get(key)
+            if isinstance(value, list):
+                return value
+    return []
+
+
 def _modules(nodes: list[dict]) -> list[dict]:
     return [{"name": item.get("label") or item.get("name") or item.get("id"), "path": item.get("file") or item.get("path"), "kind": item.get("type", "module"), "description": None, "status": "CONFIRMED", "evidence": []} for item in nodes if (item.get("label") or item.get("name") or item.get("id")) and (item.get("file") or item.get("path"))][:100]
 
@@ -55,7 +70,14 @@ def _flows(model: dict) -> list[dict]:
         seen = {entry["name"], current}
         for _ in range(4):
             candidates = outgoing.get(current, []) or [item for source, values in outgoing.items() if source.endswith(current) for item in values]
-            edge = next((item for item in candidates if item["target"] not in seen), None)
+            candidates = [item for item in candidates if item["target"] not in seen]
+            current_class = current.rsplit("::", 1)[0].split("\\")[-1]
+            # A same-class call (for example a controller/service delegating to
+            # another method) is usually the main continuation of an HTTP flow.
+            # Preserve the other calls in the semantic model instead of guessing
+            # that they occur after it.
+            edge = next((item for item in candidates if item["target"].rsplit("::", 1)[0].split("\\")[-1] == current_class), None)
+            edge = edge or next(iter(candidates), None)
             if not edge: break
             target = edge["target"]; component = components.get(target, {})
             steps.append({"name": target, "kind": edge["type"].casefold(), "path": component.get("file") or edge.get("file"), "status": edge["status"]})
@@ -86,7 +108,7 @@ def _empty_raw() -> dict:
 
 
 def _semantic(root: Path, stack: dict) -> tuple[SemanticModel, dict]:
-    if "Laravel" in stack["frameworks"]:
+    if "Laravel" in stack["frameworks"] or "Lumen" in stack["frameworks"]:
         model = LaravelAdapter().analyze(root)
         return model, model.metadata["raw"]
     if "FastAPI" in stack["frameworks"]:
@@ -116,6 +138,6 @@ def build(root: Path, graph: dict) -> dict:
     tests = [{"path": item, "reason": "Tests detectados"} for item in ("tests", "test", "phpunit.xml", "pytest.ini") if (root / item).exists()]
     story = " ".join(item for item in (value["text"], runtime["description"], "La aplicación está contenerizada con Docker." if "Docker" in deploy["tools"] else None) if item)
     system = {"purpose": value, "project_story": {"text": story or None, "status": "CONFIRMED" if story else "UNKNOWN"}, "runtime": runtime, "framework": raw["framework"], "runtime_surfaces": raw["runtime_surfaces"], "routes": raw["routes"], "commands": raw["commands"], "scheduled_processes": raw["scheduled_processes"], "queue_jobs": raw["queue_jobs"], "events": raw["events"], "listeners": raw["listeners"], "components": raw["components"], "dependencies": raw["dependencies"], "semantic_model": model, "entry_points": points, "main_flows": flows, "system_interactions": _interactions(flows, systems, stores), "capabilities": _modules(_nodes(graph)), "inputs": inputs, "outputs": outputs, "external_systems": systems, "background_processes": background, "datastores": stores, "deployment": deploy, "observability": observability, "important_files": important, "start_here": [], "unknowns": [item for item, found in (("Propósito de negocio del proyecto", value["text"]), ("Plataforma de despliegue en producción", deploy["tools"])) if not found]}
-    technical = {"languages": stack["languages"], "frameworks": stack["frameworks"], "framework": raw["framework"], "dependencies": raw["dependencies"], "graph": {"nodes": len(_nodes(graph)), "edges": len(graph.get("edges", graph.get("graph", {}).get("edges", [])))}, "documents": [{"path": item["path"]} for item in docs], "tests": tests, "infrastructure": stack["infrastructure"]}
+    technical = {"languages": stack["languages"], "frameworks": stack["frameworks"], "framework": raw["framework"], "dependencies": raw["dependencies"], "graph": {"nodes": len(_nodes(graph)), "edges": len(_edges(graph))}, "documents": [{"path": item["path"]} for item in docs], "tests": tests, "infrastructure": stack["infrastructure"]}
     project = {"name": root.name, "type": stack["frameworks"][0] if stack["frameworks"] else None, "root": str(root.resolve()), "generated_at": datetime.now(timezone.utc).isoformat(), "git_commit": commit(root)}
     return {"schema_version": "0.5", "project": project, "technical_model": technical, "system_model": system, "semantic_model": model, "human_context": {"purpose": None, "users": None, "important_processes": [], "notes": []}, "stack": stack, "architecture": {"style": "MVC" if "Laravel" in stack["frameworks"] else None, "status": "INFERRED" if "Laravel" in stack["frameworks"] else "UNKNOWN", "confidence": None, "evidence": []}, "entry_points": points, "modules": system["capabilities"], "flows": flows, "api": raw["routes"], "jobs": background, "datastores": stores, "external_systems": systems, "deployment": deploy, "observability": observability, "tests": tests, "evidence": [item.as_dict() for item in detector_evidence] + value["evidence"] + _analysis_evidence(raw)}

{klapcontext-0.2.0 → klapcontext-0.3.1}/src/klapcontext/detector.py

@@ -1,41 +1,75 @@
 from __future__ import annotations
 
 import json
+import fnmatch
+import os
 from pathlib import Path
 
 from .evidence import Evidence
 
 
+EXCLUDED = {".git", ".klap", "graphify-out", "node_modules", "vendor", ".venv", "venv", ".test-venv", "build", "dist"}
+
+
+def _sources(root: Path, pattern: str):
+    for directory, children, names in os.walk(root):
+        children[:] = [child for child in children if child not in EXCLUDED]
+        for name in names:
+            if fnmatch.fnmatch(name, pattern):
+                yield Path(directory) / name
+
+
 def detect_project(root: Path) -> tuple[dict, list[Evidence]]:
     evidence: list[Evidence] = []
-    stack = {"languages": [], "frameworks": [], "databases": [], "runtime": [], "infrastructure": []}
+    stack = {"languages": [], "frameworks": [], "databases": [], "runtime": [], "infrastructure": [], "package_managers": [], "project_type": "unknown"}
     def add(bucket: str, value: str, path: str, reason: str) -> None:
         if value not in stack[bucket]: stack[bucket].append(value)
         evidence.append(Evidence("file", path, reason, "CONFIRMED", 1.0))
     composer = root / "composer.json"
     if composer.exists():
         add("languages", "PHP", "composer.json", "Composer manifest detected")
+        stack["runtime"].append("PHP"); stack["package_managers"].append("composer")
         try: deps = {**json.loads(composer.read_text(encoding="utf-8")).get("require", {}), **json.loads(composer.read_text(encoding="utf-8")).get("require-dev", {})}
         except json.JSONDecodeError: deps = {}
         if "laravel/framework" in deps: add("frameworks", "Laravel", "composer.json", "laravel/framework dependency detected")
-    elif any(root.rglob("*.php")):
+        if "laravel/lumen-framework" in deps:
+            add("frameworks", "Lumen", "composer.json", "laravel/lumen-framework dependency detected")
+            stack["project_type"] = "backend-api"
+    elif any(_sources(root, "*.php")):
         # A standalone PHP repository has no Composer manifest to identify it,
         # but language analysis can still provide a useful generic model.
-        first_php = next(root.rglob("*.php"))
+        first_php = next(_sources(root, "*.php"))
         add("languages", "PHP", str(first_php.relative_to(root)).replace("\\", "/"), "PHP source file detected")
     package = root / "package.json"
     if package.exists():
         add("languages", "JavaScript", "package.json", "npm manifest detected")
+        stack["runtime"].append("Node.js"); stack["package_managers"].append("npm")
         try: deps = {**json.loads(package.read_text(encoding="utf-8")).get("dependencies", {}), **json.loads(package.read_text(encoding="utf-8")).get("devDependencies", {})}
         except json.JSONDecodeError: deps = {}
         for name, label in (("next", "Next.js"), ("vue", "Vue"), ("react", "React"), ("express", "Express"), ("@nestjs/core", "NestJS")):
             if name in deps: add("frameworks", label, "package.json", f"{name} dependency detected")
+        if any(_sources(root, "*.ts")) or any(_sources(root, "*.tsx")): add("languages", "TypeScript", "package.json", "TypeScript source detected")
     if (root / "pyproject.toml").exists() or (root / "requirements.txt").exists():
         python_manifest = root / "pyproject.toml" if (root / "pyproject.toml").exists() else root / "requirements.txt"
         add("languages", "Python", python_manifest.name, "Python manifest detected")
+        stack["runtime"].append("Python"); stack["package_managers"].append("pip")
         if "fastapi" in python_manifest.read_text(encoding="utf-8", errors="ignore").casefold(): add("frameworks", "FastAPI", python_manifest.name, "FastAPI dependency detected")
     if (root / "manage.py").exists(): add("frameworks", "Django", "manage.py", "Django entry point detected")
-    if list(root.glob("*.csproj")): add("languages", "C#", next(root.glob("*.csproj")).name, ".NET project detected")
+    if list(root.glob("*.csproj")):
+        add("languages", "C#", next(root.glob("*.csproj")).name, ".NET project detected"); stack["runtime"].append(".NET"); stack["package_managers"].append("NuGet")
+        if (root / "Program.cs").exists(): add("frameworks", ".NET Web API", "Program.cs", "ASP.NET entry point detected")
+    if (root / "go.mod").exists():
+        add("languages", "Go", "go.mod", "Go module detected"); stack["runtime"].append("Go"); stack["package_managers"].append("go modules")
+    if (root / "Cargo.toml").exists():
+        add("languages", "Rust", "Cargo.toml", "Rust manifest detected"); stack["runtime"].append("Rust"); stack["package_managers"].append("cargo")
+    if (root / "pom.xml").exists() or (root / "build.gradle").exists() or (root / "build.gradle.kts").exists():
+        manifest = "pom.xml" if (root / "pom.xml").exists() else "build.gradle" if (root / "build.gradle").exists() else "build.gradle.kts"
+        add("languages", "Java", manifest, "Java build manifest detected"); stack["runtime"].append("JVM"); stack["package_managers"].append("maven" if manifest == "pom.xml" else "gradle")
+    # Keep generic analysis useful for small repositories without a manifest.
+    for suffix, language in (("*.py", "Python"), ("*.js", "JavaScript"), ("*.ts", "TypeScript"), ("*.java", "Java"), ("*.go", "Go"), ("*.rs", "Rust")):
+        if language not in stack["languages"] and any(_sources(root, suffix)):
+            first = next(_sources(root, suffix)); add("languages", language, first.relative_to(root).as_posix(), f"{language} source file detected")
+    if any(name in stack["frameworks"] for name in ("Laravel", "Lumen", "FastAPI", "Express", "NestJS", ".NET Web API")): stack["project_type"] = "backend-api"
     if (root / "Dockerfile").exists(): add("infrastructure", "Docker", "Dockerfile", "Dockerfile detected")
     if list(root.glob("docker-compose*")) or list(root.glob("compose*")): add("infrastructure", "Docker Compose", "docker-compose", "Compose configuration detected")
     if (root / ".github" / "workflows").exists(): add("infrastructure", "GitHub Actions", ".github/workflows", "GitHub Actions workflows detected")
@@ -45,8 +79,8 @@ def detect_project(root: Path) -> tuple[dict, list[Evidence]]:
 def detect_components(root: Path) -> list[dict]:
     """Find independent project boundaries without assuming a monorepo layout."""
     result = []
-    for manifest in [*root.rglob("composer.json"), *root.rglob("package.json"), *root.rglob("pyproject.toml"), *root.rglob("requirements.txt")]:
-        if any(part in {".git", ".klap", "node_modules", "vendor", ".venv", "venv"} for part in manifest.relative_to(root).parts): continue
+    manifests = [path for pattern in ("composer.json", "package.json", "pyproject.toml", "requirements.txt") for path in _sources(root, pattern)]
+    for manifest in manifests:
         directory = manifest.parent
         if directory == root: continue
         stack, _ = detect_project(directory)

{klapcontext-0.2.0 → klapcontext-0.3.1}/src/klapcontext/frameworks/laravel.py

@@ -28,7 +28,7 @@ def _e(root: Path, path: Path, offset: int, reason: str, *, symbol: str | None =
 
 def _category(package: str) -> str:
     package = package.lower()
-    if package == "laravel/framework": return "framework"
+    if package in {"laravel/framework", "laravel/lumen-framework"}: return "framework"
     if any(token in package for token in ("mysql", "postgres", "mongodb", "redis", "doctrine/dbal")): return "database"
     if any(token in package for token in ("queue", "horizon", "rabbit", "kafka")): return "queue"
     if any(token in package for token in ("jwt", "sanctum", "passport", "auth")): return "authentication"
@@ -42,18 +42,48 @@ def _category(package: str) -> str:
 def _composer(root: Path) -> tuple[list[dict], dict]:
     composer = root / "composer.json"
     if not composer.exists():
-        return [], {"laravel": None, "php": None}
+        return [], {"framework": None, "package": None, "version": None, "php": None}
     try:
         data = json.loads(_read(composer))
     except json.JSONDecodeError:
-        return [], {"laravel": None, "php": None}
+        return [], {"framework": None, "package": None, "version": None, "php": None}
     dependencies = []
     for scope, key in (("runtime", "require"), ("development", "require-dev")):
         for package, version in data.get(key, {}).items():
             evidence = Evidence("manifest", "composer.json", f"Dependencia Composer ({scope})", "CONFIRMED", 1.0, symbol=package).as_dict()
             dependencies.append({"package": package, "version": version, "scope": scope, "category": _category(package), "status": "CONFIRMED", "evidence": [evidence]})
     requirements = data.get("require", {})
-    return dependencies, {"laravel": requirements.get("laravel/framework"), "php": requirements.get("php")}
+    package = "laravel/lumen-framework" if "laravel/lumen-framework" in requirements else "laravel/framework" if "laravel/framework" in requirements else None
+    return dependencies, {"framework": "Lumen" if package == "laravel/lumen-framework" else "Laravel" if package else None, "package": package, "version": requirements.get(package) if package else None, "php": requirements.get("php")}
+
+
+def _group_spans(text: str) -> list[tuple[int, int, str, list[str]]]:
+    """Return Lumen/Laravel route-group bodies with their inherited metadata."""
+    pattern = re.compile(r"(?:\$router|\$app|Route)->group\s*\(\s*\[(.*?)\]\s*,\s*function\s*\([^)]*\)\s*(?:use\s*\([^)]*\)\s*)?\{", re.S)
+    groups = []
+    for match in pattern.finditer(text):
+        opening = match.end() - 1
+        depth, closing = 0, None
+        for index in range(opening, len(text)):
+            if text[index] == "{": depth += 1
+            elif text[index] == "}":
+                depth -= 1
+                if depth == 0:
+                    closing = index
+                    break
+        if closing is None:
+            continue
+        options = match.group(1)
+        prefix_match = re.search(r"['\"]prefix['\"]\s*=>\s*['\"]([^'\"]*)['\"]", options)
+        middleware_match = re.search(r"['\"]middleware['\"]\s*=>\s*(\[[^\]]*\]|['\"][^'\"]*['\"])", options, re.S)
+        middleware = re.findall(r"['\"]([^'\"]+)['\"]", middleware_match.group(1)) if middleware_match else []
+        groups.append((opening, closing, prefix_match.group(1) if prefix_match else "", middleware))
+    return groups
+
+
+def _comment_spans(text: str) -> list[tuple[int, int]]:
+    """Offsets covered by PHP line or block comments, preserving source lines."""
+    return [(match.start(), match.end()) for match in re.finditer(r"//[^\n]*|/\*.*?\*/", text, re.S)]
 
 
 def _routes(root: Path) -> tuple[list[dict], list[dict]]:
@@ -61,16 +91,28 @@ def _routes(root: Path) -> tuple[list[dict], list[dict]]:
     directory = root / "routes"
     if not directory.is_dir():
         return routes, scheduled
-    route_pattern = re.compile(r"Route::(get|post|put|patch|delete|options|any)\s*\(\s*['\"]([^'\"]+)['\"]\s*,\s*(.+?)\);", re.S | re.I)
+    route_pattern = re.compile(r"(?:Route|\$app|\$router)(?:::|->)(get|post|put|patch|delete|options|any)\s*\(\s*['\"]([^'\"]+)['\"]\s*,\s*(.+?)\);", re.S | re.I)
     resource_pattern = re.compile(r"Route::(?:api)?resource\s*\(\s*['\"]([^'\"]+)['\"]\s*,\s*([A-Za-z_]\w*(?:\\[A-Za-z_]\w*)*)::class", re.I)
     schedule_pattern = re.compile(r"Schedule::(?:command|job)\s*\(\s*['\"]([^'\"]+)['\"]\s*\).*?->([A-Za-z]\w*)\s*\(", re.S)
     for file in directory.glob("*.php"):
         text = _read(file)
+        groups = _group_spans(text)
+        comments = _comment_spans(text)
         for match in route_pattern.finditer(text):
+            if any(start <= match.start() < end for start, end in comments):
+                continue
             method, uri, target = match.groups()
             handler = _symbol(target)
-            name = f"{method.upper()} /{uri.lstrip('/')}"
-            routes.append({"type": "http", "method": method.upper(), "uri": "/" + uri.lstrip("/"), "name": name, "path": str(file.relative_to(root)), "source": str(file.relative_to(root)), "line": text.count("\n", 0, match.start()) + 1, "target": handler, "handler": handler, "middleware": [], "status": "CONFIRMED", "evidence": _e(root, file, match.start(), "Declaración de ruta Laravel", symbol=name)})
+            if not handler:
+                callback = re.search(r"['\"]([A-Za-z_]\w*)@([A-Za-z_]\w*)['\"]", target)
+                handler = f"{callback.group(1)}::{callback.group(2)}" if callback else None
+            active = [group for group in groups if group[0] < match.start() < group[1]]
+            prefix = "/".join(group[2].strip("/") for group in active if group[2])
+            middleware = [name for group in active for name in group[3]]
+            full_uri = "/" + "/".join(part for part in (prefix, uri.strip("/")) if part)
+            name = f"{method.upper()} {full_uri}"
+            framework = "Lumen" if "lumen-framework" in _read(root / "composer.json") else "Laravel"
+            routes.append({"type": "http", "method": method.upper(), "uri": full_uri, "name": name, "path": str(file.relative_to(root)), "source": str(file.relative_to(root)), "line": text.count("\n", 0, match.start()) + 1, "target": handler, "handler": handler, "middleware": middleware, "status": "CONFIRMED", "evidence": _e(root, file, match.start(), f"Declaración de ruta {framework}", symbol=name)})
         for match in resource_pattern.finditer(text):
             resource, controller = match.groups()
             name = f"RESOURCE /{resource.lstrip('/')}"
@@ -137,7 +179,9 @@ def analyze(root: Path) -> dict:
     for kind, label, values in (("http", "HTTP", routes), ("cli", "CLI", commands), ("scheduler", "Scheduler", scheduled), ("queue", "Queue", jobs), ("event", "Eventos", events), ("listener", "Listeners", listeners)):
         if values:
             surfaces.append({"type": kind, "label": label, "count": len(values), "items": values})
-    return {"framework": {"name": "Laravel", "version": versions["laravel"], "php_version": versions["php"], "status": "CONFIRMED", "evidence": [Evidence("manifest", "composer.json", "laravel/framework declarado", "CONFIRMED", 1.0, symbol="laravel/framework").as_dict()]}, "routes": routes, "commands": commands, "scheduled_processes": scheduled, "queue_jobs": jobs, "events": events, "listeners": listeners, "components": components, "dependencies": dependencies, "runtime_surfaces": surfaces, "important_files": important}
+    framework = versions["framework"] or "Laravel"
+    package = versions["package"] or "laravel/framework"
+    return {"framework": {"name": framework, "version": versions["version"], "php_version": versions["php"], "status": "CONFIRMED", "evidence": [Evidence("manifest", "composer.json", f"{package} declarado", "CONFIRMED", 1.0, symbol=package).as_dict()]}, "routes": routes, "commands": commands, "scheduled_processes": scheduled, "queue_jobs": jobs, "events": events, "listeners": listeners, "components": components, "dependencies": dependencies, "runtime_surfaces": surfaces, "important_files": important}
 
 
 class LaravelAdapter:
@@ -154,7 +198,7 @@ class LaravelAdapter:
         entries = []
         transitions = []
         for route in raw["routes"]:
-            entries.append(EntryPoint("HTTP", route["name"], route.get("target"), "HTTP", route.get("method"), route.get("uri"), route["path"], route["line"], "Laravel", route["status"], route["evidence"]))
+            entries.append(EntryPoint("HTTP", route["name"], route.get("target"), "HTTP", route.get("method"), route.get("uri"), route["path"], route["line"], raw["framework"]["name"], route["status"], route["evidence"]))
             if route.get("target"):
                 transitions.append(ExecutionTransition(route["name"], route["target"], "HTTP_ENTRY", route["path"], route["line"], route["status"], "laravel", route["evidence"]))
         for command in raw["commands"]:
@@ -184,4 +228,4 @@ class LaravelAdapter:
         events = [Event(item["name"], item["path"], item["status"], item["evidence"]) for item in raw["events"]]
         handlers = [EventHandler(item["name"], file=item["path"], status=item["status"], evidence=item["evidence"]) for item in raw["listeners"]]
         dependencies = [Dependency(item["package"], item["version"], item["category"], item["status"], item["evidence"]) for item in raw["dependencies"]]
-        return SemanticModel("PHP", "Laravel", "FRAMEWORK", components, entries, transitions, background_tasks=background, events=events, event_handlers=handlers, dependencies=dependencies, metadata={"raw": raw})
+        return SemanticModel("PHP", raw["framework"]["name"], "FRAMEWORK", components, entries, transitions, background_tasks=background, events=events, event_handlers=handlers, dependencies=dependencies, metadata={"raw": raw})

{klapcontext-0.2.0 → klapcontext-0.3.1}/src/klapcontext/providers/code_intelligence.py

@@ -3,12 +3,14 @@ from __future__ import annotations
 
 import hashlib
 import json
+import os
+import re
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
 
 
 EXCLUDED = {".git", ".klap", "vendor", "node_modules", "build", "dist", ".venv", "venv", ".test-venv"}
-INDEX_VERSION = 3
+INDEX_VERSION = 4
 
 
 @dataclass(frozen=True)
@@ -80,7 +82,11 @@ class PhpCodeIntelligenceProvider:
         self._index: dict | None = None
 
     def _files(self) -> list[Path]:
-        return sorted(path for path in self.root.rglob("*.php") if not any(part in EXCLUDED for part in path.relative_to(self.root).parts))
+        files = []
+        for directory, children, names in os.walk(self.root):
+            children[:] = [child for child in children if child not in EXCLUDED]
+            files.extend(Path(directory) / name for name in names if name.endswith(".php"))
+        return sorted(files)
 
     def _fingerprint(self, files: list[Path]) -> str:
         value = "|".join(f"{path.relative_to(self.root)}:{path.stat().st_mtime_ns}:{path.stat().st_size}" for path in files)
@@ -133,6 +139,7 @@ class PhpCodeIntelligenceProvider:
                     for target in [part.strip() for part in _text(child, source).replace("implements", "").split(",")]:
                         relations.append(asdict(CodeRelation(qualified, target, "IMPLEMENTS", relative, _line(source, child.start_byte), "CONFIRMED")))
             properties = self._properties(declaration, source)
+            properties.update(self._constructor_properties(declaration, source))
             for method in (node for node in _descendants(declaration) if node.type == "method_declaration"):
                 method_name = _field_text(method, "name", source)
                 if not method_name:
@@ -161,6 +168,28 @@ class PhpCodeIntelligenceProvider:
                 values[variable.lstrip("$")] = type_name.split("\\")[-1]
         return values
 
+    def _constructor_properties(self, declaration, source: bytes) -> dict[str, str]:
+        """Map classic constructor injection (``$this->x = $x``) to its type.
+
+        Lumen and older Laravel applications commonly use this form instead of
+        PHP 8 property promotion.  It is deliberately conservative: only a
+        typed constructor parameter assigned directly to a ``$this`` property
+        is resolved.
+        """
+        text = _text(declaration, source)
+        constructor = re.search(r"function\s+__construct\s*\((.*?)\)\s*\{(.*?)\}", text, re.S)
+        if not constructor:
+            return {}
+        parameters = {
+            variable: type_name.split("\\")[-1]
+            for type_name, variable in re.findall(r"(?:public|protected|private)?\s*([A-Za-z_]\w*(?:\\[A-Za-z_]\w*)*)\s+\$(\w+)", constructor.group(1))
+        }
+        return {
+            property_name: parameters[variable]
+            for property_name, variable in re.findall(r"\$this->(\w+)\s*=\s*\$(\w+)\s*;", constructor.group(2))
+            if variable in parameters
+        }
+
     def _calls(self, method, source: bytes, source_id: str, file: str, properties: dict[str, str]) -> list[dict]:
         relations = []
         for node in _descendants(method):
@@ -171,7 +200,9 @@ class PhpCodeIntelligenceProvider:
                 name = _field_text(node, "name", source)
                 object_node = node.child_by_field_name("object")
                 object_text = _text(object_node, source) if object_node else ""
-                if object_text.startswith("$this->"):
+                if object_text == "$this":
+                    target = f"{source_id.rsplit('::', 1)[0]}::{name}"
+                elif object_text.startswith("$this->"):
                     service = object_text.split("->", 1)[1]
                     target = f"{properties.get(service, service)}::{name}"
                 elif object_text.startswith("$"):

{klapcontext-0.2.0 → klapcontext-0.3.1}/src/klapcontext/system.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import os
 import re
 from pathlib import Path
 
@@ -9,6 +10,7 @@ from .evidence import Evidence
 
 
 TEXT_LIMIT = 180_000
+EXCLUDED = {".git", ".klap", "graphify-out", "node_modules", "vendor", ".venv", "venv", ".pytest_cache", ".test-venv", "build", "dist"}
 
 
 def _read(path: Path) -> str:
@@ -16,6 +18,16 @@ def _read(path: Path) -> str:
     except OSError: return ""
 
 
+def _source_files(root: Path, suffixes: set[str]):
+    """Walk source files without first descending into dependency trees."""
+    for directory, children, names in os.walk(root):
+        children[:] = [child for child in children if child not in EXCLUDED]
+        for name in names:
+            path = Path(directory) / name
+            if path.suffix.lower() in suffixes:
+                yield path
+
+
 def _ev(path: str, reason: str, status: str = "CONFIRMED", confidence: float = 1.0) -> dict:
     return Evidence("file", path, reason, status, confidence).as_dict()
 
@@ -74,16 +86,15 @@ def entry_points(root: Path) -> tuple[list[dict], list[dict]]:
             point=add("scheduled", command, rel, schedule=frequency, reason="Laravel scheduler declaration")
             background.append({"name":command,"type":"scheduled_command","schedule":frequency,"path":rel,"status":"CONFIRMED","evidence":point["evidence"]})
     # Python HTTP decorators and CLI bootstrap.
-    for path in root.rglob("*.py"):
-        if any(part in {".git", ".klap", "graphify-out", "venv", ".venv", ".test-venv", "build", "dist"} for part in path.parts) or path.name == "system.py": continue
+    for path in _source_files(root, {".py"}):
+        if path.name == "system.py": continue
         text=_read(path); rel=str(path.relative_to(root))
         for method, uri, function in re.findall(r"@\w+\.(get|post|put|patch|delete)\s*\(\s*['\"]([^'\"]+)['\"]\s*\)\s*\n\s*(?:async\s+)?def\s+(\w+)", text, re.I):
             add("http", f"{method.upper()} {uri}", rel, function, reason="Python web route decorator")
         if "if __name__ == \"__main__\"" in text or "if __name__ == '__main__'" in text:
             add("cli", path.stem, rel, reason="Python executable module")
     # Express route declarations.
-    for path in root.rglob("*.js"):
-        if any(part in {"node_modules", ".git", ".klap", "graphify-out", ".test-venv", "build", "dist"} for part in path.parts): continue
+    for path in _source_files(root, {".js"}):
         rel=str(path.relative_to(root)); text=_read(path)
         for method, uri in re.findall(r"\.(get|post|put|patch|delete)\s*\(\s*['\"]([^'\"]+)", text, re.I): add("http", f"{method.upper()} {uri}", rel, reason="JavaScript HTTP route declaration")
     return points[:50], background[:30]
@@ -93,9 +104,9 @@ def external_systems(root: Path) -> tuple[list[dict], list[dict]]:
     found, stores = [], []
     patterns = [(r"\bredis\b", "Redis", "redis"), (r"\brabbitmq\b|\bamqp\b", "RabbitMQ", "message broker"), (r"\bkafka\b", "Kafka", "message broker"), (r"\bsentry\b", "Sentry", "error tracking"), (r"\bsmtp\b|\bmailgun\b", "SMTP", "email"), (r"\bsftp\b", "SFTP", "sftp"), (r"\bftp\b", "FTP", "ftp")]
     store_patterns = [(r"\bmysql\b", "MySQL"), (r"\bpostgres(?:ql)?\b", "PostgreSQL"), (r"\bsqlsrv\b|sql server", "SQL Server"), (r"\bsqlite\b", "SQLite"), (r"\bmongodb\b", "MongoDB")]
-    candidates=[p for p in root.rglob("*") if p.is_file() and p.suffix.lower() in {".json", ".toml", ".yml", ".yaml", ".php", ".py", ".js", ".ts", ".env"}]
+    candidates = list(_source_files(root, {".json", ".toml", ".yml", ".yaml", ".php", ".py", ".js", ".ts", ".env"}))
     for path in candidates[:800]:
-        if any(part in {".git", ".klap", "graphify-out", "node_modules", "vendor", ".pytest_cache", "tests", ".test-venv", "build", "dist", "frameworks"} for part in path.parts) or path.name in {"system.py", "portal.py", "pyproject.toml"}: continue
+        if "tests" in path.relative_to(root).parts or "frameworks" in path.relative_to(root).parts or path.name in {"system.py", "portal.py", "pyproject.toml"}: continue
         text=_read(path); rel=str(path.relative_to(root))
         for pattern,name,kind in patterns:
             if re.search(pattern, text, re.I) and not any(x["name"] == name for x in found): found.append({"name":name,"type":kind,"purpose":None,"used_by":[],"configuration":[rel],"status":"CONFIRMED","evidence":[_ev(rel, f"{name} configuration or usage detected")]})
@@ -114,10 +125,9 @@ def deployment(root: Path) -> tuple[dict, dict, list[dict]]:
     for item in files:
         text=_read(root/item["path"]) if (root/item["path"]).is_file() else ""
         ports.extend(re.findall(r"(?:EXPOSE\s+|['\"]?)(\d{2,5})(?::\d{2,5})?", text))
-    for path in root.rglob("*"):
-        if path.is_file() and path.suffix.lower() in {".py", ".php", ".js", ".ts", ".json", ".yml", ".yaml"}:
-            if any(part in {".git", ".klap", "graphify-out", "node_modules", "vendor", ".pytest_cache", "tests", ".test-venv", "build", "dist"} for part in path.parts) or path.name in {"system.py", "laravel.py"}: continue
-            text=_read(path); rel=str(path.relative_to(root))
-            for term,name in (("prometheus","Prometheus"),("opentelemetry","OpenTelemetry"),("sentry","Sentry"),("/health","Health endpoint"),("/metrics","Metrics endpoint")):
-                if term in text.lower() and not any(x["name"]==name for x in observability): observability.append({"name":name,"path":rel,"status":"CONFIRMED","evidence":[_ev(rel, f"{name} reference detected")]})
+    for path in _source_files(root, {".py", ".php", ".js", ".ts", ".json", ".yml", ".yaml"}):
+        if "tests" in path.relative_to(root).parts or path.name in {"system.py", "laravel.py"}: continue
+        text=_read(path); rel=str(path.relative_to(root))
+        for term,name in (("prometheus","Prometheus"),("opentelemetry","OpenTelemetry"),("sentry","Sentry"),("/health","Health endpoint"),("/metrics","Metrics endpoint")):
+            if term in text.lower() and not any(x["name"]==name for x in observability): observability.append({"name":name,"path":rel,"status":"CONFIRMED","evidence":[_ev(rel, f"{name} reference detected")]})
     return {"tools":tools,"ports":sorted(set(ports)),"files":files,"status":"CONFIRMED" if files else "UNKNOWN"}, {"tools":observability,"status":"CONFIRMED" if observability else "UNKNOWN"}, files

{klapcontext-0.2.0 → klapcontext-0.3.1/src/klapcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: klapcontext
-Version: 0.2.0
+Version: 0.3.1
 Summary: Make your repository understandable to humans and AI.
 Author: Willy Cordon
 License-Expression: Apache-2.0
@@ -91,6 +91,7 @@ tu `.gitignore`.
 | `klap status [ruta]` | Indica si el contexto está actualizado respecto a Git. |
 | `klap open [ruta]` | Abre el portal humano estático. |
 | `klap agent [ruta]` | Muestra la configuración MCP local de Graphify. |
+| `klap context "tarea" [ruta]` | Compila un contexto focalizado reutilizando `.klap/context.json` si existe. |
 | `klap --version` | Muestra la versión instalada. |
 
 ## Salidas
@@ -121,6 +122,9 @@ El workflow de GitHub Actions publica tags `v*` mediante PyPI Trusted
 Publishing. Antes del primer tag, configurá el publisher de PyPI para este
 repositorio y workflow. No se necesitan tokens de PyPI en el repositorio.
 
+El repositorio ya incluye `.github/workflows/publish-pypi.yml`: al publicar un
+tag `vX.Y.Z`, GitHub construye el paquete y lo publica con ese publisher.
+
 ## Licencia
 
 Apache-2.0. Ver [LICENSE](LICENSE).

{klapcontext-0.2.0 → klapcontext-0.3.1}/tests/test_klapcontext.py

@@ -37,6 +37,32 @@ def test_detector_collects_confirmed_evidence(tmp_path):
     assert all(item.status == "CONFIRMED" for item in evidence)
 
 
+def test_detector_identifies_manifest_and_source_languages(tmp_path):
+    (tmp_path / "go.mod").write_text("module example")
+    (tmp_path / "src").mkdir(); (tmp_path / "src" / "main.ts").write_text("export {}")
+    stack, _ = detect_project(tmp_path)
+    assert {"Go", "TypeScript"} <= set(stack["languages"])
+    assert "go modules" in stack["package_managers"]
+
+
+def test_lumen_detection_and_route_adapter():
+    root = Path(__file__).parent / "fixtures" / "lumen_semantic"
+    stack, _ = detect_project(root)
+    assert "Lumen" in stack["frameworks"]
+    context = build(root, {"nodes": []})
+    route = context["system_model"]["routes"][0]
+    assert route["name"] == "POST /api/v1/call-vtex"
+    assert len(context["system_model"]["routes"]) == 1
+    assert route["middleware"] == ["apikey"]
+    assert context["system_model"]["framework"]["name"] == "Lumen"
+    flow = context["system_model"]["main_flows"][0]
+    assert [step["name"].split("\\")[-1] for step in flow["steps"]] == [
+        "POST /api/v1/call-vtex", "ProcessRequestController::callVtex",
+        "ProcessRequestService::validateRequest", "ProcessRequestService::callVtex",
+        "VtexService::searchOrderVtex", "VtexService::getOrderDetails",
+    ]
+
+
 def test_portal_has_dashboard_and_real_views(tmp_path):
     context = build(fixture_repo(tmp_path), {"nodes": [{"name": "UserController", "path": "app/Http/UserController.php", "type": "controller"}]})
     page = render_portal(context, render_agent(context), ["graph.html"])
@@ -207,6 +233,21 @@ def test_context_compiler_ranks_compact_task_context():
     assert minimal["execution"]["adaptive"] and minimal["execution"]["files_selected"] <= deep["execution"]["files_selected"]
 
 
+def test_context_compiler_reuses_generated_context(tmp_path, monkeypatch):
+    root = fixture_repo(tmp_path)
+    (root / ".klap").mkdir()
+    cached = build(root, {"nodes": []})
+    (root / ".klap" / "context.json").write_text(json.dumps(cached))
+    monkeypatch.setattr("klapcontext.agent.compiler.build", lambda *_: (_ for _ in ()).throw(AssertionError("should not rebuild")))
+    result = compile_context(root, "entender sistema")
+    assert result["execution"]["context_source"] == "cached"
+
+
+def test_graph_links_are_counted_like_edges(tmp_path):
+    context = build(fixture_repo(tmp_path), {"nodes": [], "links": [{"source": "a", "target": "b"}]})
+    assert context["technical_model"]["graph"]["edges"] == 1
+
+
 def test_specialized_contexts_keep_the_compact_compiler_contract():
     root = Path(__file__).parent / "fixtures" / "laravel_semantic"
     assert change_context(root, "modificar orders")["context_type"] == "CHANGE"