code2schema 0.1.2__tar.gz → 0.1.6__tar.gz

{code2schema-0.1.2 → code2schema-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2schema
-Version: 0.1.2
+Version: 0.1.6
 Summary: Semantic compiler: Code → AST → CQRS Model → Workflow DAG → Proto/Schema
 License: Apache-2.0
 Keywords: ast,cqrs,static-analysis,code-quality,schema
@@ -34,13 +34,13 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.2-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.15-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-2.0h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.6-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.60-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.6h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $0.1500 (1 commits)
-- 👤 **Human dev:** ~$200 (2.0h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $0.6000 (4 commits)
+- 👤 **Human dev:** ~$361 (3.6h @ $100/h, 30min dedup)
 
-Generated on 2026-05-04 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-05-07 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 

{code2schema-0.1.2 → code2schema-0.1.6}/README.md

@@ -3,13 +3,13 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.2-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.15-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-2.0h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.6-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.60-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.6h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $0.1500 (1 commits)
-- 👤 **Human dev:** ~$200 (2.0h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $0.6000 (4 commits)
+- 👤 **Human dev:** ~$361 (3.6h @ $100/h, 30min dedup)
 
-Generated on 2026-05-04 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-05-07 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 

{code2schema-0.1.2 → code2schema-0.1.6}/code2schema/__init__.py

@@ -1,10 +1,16 @@
 """code2schema — Semantic Compiler for Software Systems."""
+
 from code2schema.core.models import SchemaIR, CQRSRole, FunctionIR, ModuleIR
 from code2schema.core.extractor import extract_project, extract_module
 from code2schema.analyzer.cqrs import analyze
 
 __all__ = [
-    "SchemaIR", "CQRSRole", "FunctionIR", "ModuleIR",
-    "extract_project", "extract_module", "analyze",
+    "SchemaIR",
+    "CQRSRole",
+    "FunctionIR",
+    "ModuleIR",
+    "extract_project",
+    "extract_module",
+    "analyze",
 ]
-__version__ = "0.1.2"
+__version__ = "0.1.6"

{code2schema-0.1.2 → code2schema-0.1.6}/code2schema/analyzer/cqrs.py

@@ -3,6 +3,7 @@ code2schema.analyzer.cqrs
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 CQRS inference + call graph (NetworkX) + reguły jakości.
 """
+
 from __future__ import annotations
 
 from typing import List
@@ -22,13 +23,14 @@ from code2schema.core.models import (
 
 # ── Progi heurystyczne ───────────────────────────────────────────────────────
 
-FAN_OUT_ORCHESTRATOR = 5   # >= N wywołań → orchestrator
-FAN_OUT_HIGH = 10          # alert reguły
-CC_LIMIT = 15              # (placeholder, liczony zewnętrznie)
+FAN_OUT_ORCHESTRATOR = 5  # >= N wywołań → orchestrator
+FAN_OUT_HIGH = 10  # alert reguły
+CC_LIMIT = 15  # (placeholder, liczony zewnętrznie)
 
 
 # ── CQRS Inference ───────────────────────────────────────────────────────────
 
+
 def _infer_role(func: FunctionIR) -> CQRSRole:
     """Klasyfikuje funkcję na podstawie side-effectów i fan-outu."""
     has_side_effects = SideEffect.NONE not in func.side_effects
@@ -48,6 +50,7 @@ def _infer_role(func: FunctionIR) -> CQRSRole:
 
 # ── Call Graph ───────────────────────────────────────────────────────────────
 
+
 def build_call_graph(modules: List[ModuleIR]) -> nx.DiGraph:
     """Buduje skierowany graf wywołań między funkcjami."""
     G = nx.DiGraph()
@@ -79,6 +82,7 @@ def centrality(G: nx.DiGraph) -> dict[str, float]:
 
 # ── Workflow DAG ──────────────────────────────────────────────────────────────
 
+
 def build_workflows(modules: List[ModuleIR]) -> List[WorkflowIR]:
     """Buduje DAG wykonania dla każdego orkiestratora."""
     workflows: list[WorkflowIR] = []
@@ -89,8 +93,7 @@ def build_workflows(modules: List[ModuleIR]) -> List[WorkflowIR]:
                     name=f"workflow_{f.name}",
                     entry=f.qualified_name,
                     steps=[
-                        WorkflowStep(callee=c, is_async=f.is_async)
-                        for c in f.calls
+                        WorkflowStep(callee=c, is_async=f.is_async) for c in f.calls
                     ],
                 )
                 workflows.append(workflow)
@@ -99,6 +102,7 @@ def build_workflows(modules: List[ModuleIR]) -> List[WorkflowIR]:
 
 # ── Rules ────────────────────────────────────────────────────────────────────
 
+
 def generate_rules(modules: List[ModuleIR]) -> List[RuleIR]:
     """Generuje heurystyczne reguły jakości na podstawie IR."""
     rules: list[RuleIR] = []
@@ -106,36 +110,42 @@ def generate_rules(modules: List[ModuleIR]) -> List[RuleIR]:
     for mod in modules:
         for f in mod.functions:
             if f.fan_out >= FAN_OUT_HIGH:
-                rules.append(RuleIR(
-                    id="HIGH_FAN_OUT",
-                    target=f.qualified_name,
-                    condition=f"fan_out={f.fan_out} >= {FAN_OUT_HIGH}",
-                    action="refactor_to_service",
-                    severity="error",
-                ))
+                rules.append(
+                    RuleIR(
+                        id="HIGH_FAN_OUT",
+                        target=f.qualified_name,
+                        condition=f"fan_out={f.fan_out} >= {FAN_OUT_HIGH}",
+                        action="refactor_to_service",
+                        severity="error",
+                    )
+                )
             if f.lines > 100:
-                rules.append(RuleIR(
-                    id="LONG_FUNCTION",
-                    target=f.qualified_name,
-                    condition=f"lines={f.lines} > 100",
-                    action="split_function",
-                    severity="warning",
-                ))
-            if (f.role == CQRSRole.QUERY
-                    and SideEffect.NONE not in f.side_effects):
-                rules.append(RuleIR(
-                    id="QUERY_WITH_SIDE_EFFECTS",
-                    target=f.qualified_name,
-                    condition="role=query but has side effects",
-                    action="separate_command_from_query",
-                    severity="warning",
-                ))
+                rules.append(
+                    RuleIR(
+                        id="LONG_FUNCTION",
+                        target=f.qualified_name,
+                        condition=f"lines={f.lines} > 100",
+                        action="split_function",
+                        severity="warning",
+                    )
+                )
+            if f.role == CQRSRole.QUERY and SideEffect.NONE not in f.side_effects:
+                rules.append(
+                    RuleIR(
+                        id="QUERY_WITH_SIDE_EFFECTS",
+                        target=f.qualified_name,
+                        condition="role=query but has side effects",
+                        action="separate_command_from_query",
+                        severity="warning",
+                    )
+                )
 
     return rules
 
 
 # ── Main entry ────────────────────────────────────────────────────────────────
 
+
 def analyze(modules: List[ModuleIR]) -> SchemaIR:
     """Pełna analiza: CQRS + graf + workflow + reguły → SchemaIR."""
 

{code2schema-0.1.2 → code2schema-0.1.6}/code2schema/analyzer/events.py

@@ -6,13 +6,14 @@ Inferencja modelu zdarzeń (DDD / Event Sourcing):
   - klasyfikuje: Command Handler → Event → Event Handler
   - buduje Event Flow Map
 """
+
 from __future__ import annotations
 
 import re
 from dataclasses import dataclass, field
 from typing import List
 
-from code2schema.core.models import CQRSRole, FunctionIR, ModuleIR
+from code2schema.core.models import CQRSRole, ModuleIR
 
 
 # ── Heurystyki nazw ───────────────────────────────────────────────────────────
@@ -33,15 +34,15 @@ _AGGREGATE_PATTERNS = re.compile(
 
 @dataclass
 class DomainEvent:
-    name: str              # np. "UserCreated"
-    emitted_by: str        # qualified_name funkcji emitującej
+    name: str  # np. "UserCreated"
+    emitted_by: str  # qualified_name funkcji emitującej
     handled_by: List[str] = field(default_factory=list)
 
 
 @dataclass
 class CommandHandler:
     name: str
-    command: str           # nazwa wywołania, które traktujemy jako "command"
+    command: str  # nazwa wywołania, które traktujemy jako "command"
     emits: List[str] = field(default_factory=list)
 
 
@@ -61,7 +62,9 @@ class EventModel:
             lines.append("\nDomain Events:")
             for ev in self.events[:15]:
                 handlers = ", ".join(ev.handled_by[:3]) or "—"
-                lines.append(f"  {ev.name:30s} ← {ev.emitted_by.split('.')[-1]:25s} → [{handlers}]")
+                lines.append(
+                    f"  {ev.name:30s} ← {ev.emitted_by.split('.')[-1]:25s} → [{handlers}]"
+                )
         if self.commands:
             lines.append("\nCommand Handlers (top 10):")
             for cmd in self.commands[:10]:
@@ -72,39 +75,34 @@ class EventModel:
 
 # ── Inference ─────────────────────────────────────────────────────────────────
 
-def infer_event_model(modules: List[ModuleIR]) -> EventModel:
-    """Przechodzi po IR i buduje model zdarzeń."""
-    model = EventModel()
-
-    all_funcs: dict[str, FunctionIR] = {}
-    for mod in modules:
-        for f in mod.functions:
-            all_funcs[f.qualified_name] = f
-            all_funcs[f.name] = f  # short alias
 
-    # Krok 1: znajdź emiterów
-    emitters: dict[str, DomainEvent] = {}
+def _find_emitters(modules: List[ModuleIR]) -> List[DomainEvent]:
+    """Krok 1: znajdź funkcje emitujące zdarzenia."""
+    events: List[DomainEvent] = []
     for mod in modules:
         for f in mod.functions:
             if _EVENT_EMIT_PATTERNS.search(f.name) or any(
                 _EVENT_EMIT_PATTERNS.search(c) for c in f.calls
             ):
                 event_name = _derive_event_name(f.name)
-                ev = DomainEvent(name=event_name, emitted_by=f.qualified_name)
-                emitters[f.name] = ev
-                model.events.append(ev)
+                events.append(DomainEvent(name=event_name, emitted_by=f.qualified_name))
+    return events
 
-    # Krok 2: znajdź handlerów
+
+def _find_handlers(events: List[DomainEvent], modules: List[ModuleIR]) -> None:
+    """Krok 2: dopasuj handlery do zdarzeń (mutuje events in-place)."""
     for mod in modules:
         for f in mod.functions:
             if _EVENT_HANDLER_PATTERNS.search(f.name):
-                # sprawdź, czy handler pasuje do jakiegoś zdarzenia
-                for ev in model.events:
+                for ev in events:
                     keyword = ev.name.lower().replace("event", "").strip()
                     if keyword and keyword in f.name.lower():
                         ev.handled_by.append(f.qualified_name)
 
-    # Krok 3: command handlers
+
+def _find_command_handlers(modules: List[ModuleIR]) -> List[CommandHandler]:
+    """Krok 3: znajdź command handlery i ich emitowane zdarzenia."""
+    commands: List[CommandHandler] = []
     for mod in modules:
         for f in mod.functions:
             if f.role == CQRSRole.COMMAND or _AGGREGATE_PATTERNS.search(f.name):
@@ -114,24 +112,33 @@ def infer_event_model(modules: List[ModuleIR]) -> EventModel:
                     if _EVENT_EMIT_PATTERNS.search(c)
                 ]
                 if emits or f.role == CQRSRole.COMMAND:
-                    model.commands.append(
+                    commands.append(
                         CommandHandler(
                             name=f.qualified_name,
                             command=f.name,
                             emits=emits,
                         )
                     )
+    return commands
+
 
-    # Krok 4: agregaty — moduły z operacjami CRUD
+def _find_aggregates(modules: List[ModuleIR]) -> List[str]:
+    """Krok 4: znajdź moduły będące agregatami (CRUD score >= 2)."""
+    aggregates: List[str] = []
     for mod in modules:
-        crud_score = sum(
-            1 for f in mod.functions
-            if _AGGREGATE_PATTERNS.search(f.name)
-        )
+        crud_score = sum(1 for f in mod.functions if _AGGREGATE_PATTERNS.search(f.name))
         if crud_score >= 2:
-            model.aggregates.append(mod.name)
+            aggregates.append(mod.name)
+    return aggregates
 
-    return model
+
+def infer_event_model(modules: List[ModuleIR]) -> EventModel:
+    """Przechodzi po IR i buduje model zdarzeń."""
+    events = _find_emitters(modules)
+    _find_handlers(events, modules)
+    commands = _find_command_handlers(modules)
+    aggregates = _find_aggregates(modules)
+    return EventModel(commands=commands, events=events, aggregates=aggregates)
 
 
 def _derive_event_name(func_name: str) -> str:
@@ -139,7 +146,7 @@ def _derive_event_name(func_name: str) -> str:
     # Usuń prefiks czasownikowy
     for prefix in ("on_", "handle_", "emit_", "publish_", "dispatch_", "fire_"):
         if func_name.startswith(prefix):
-            func_name = func_name[len(prefix):]
+            func_name = func_name[len(prefix) :]
             break
 
     parts = func_name.split("_")
@@ -154,9 +161,15 @@ def _derive_event_name(func_name: str) -> str:
 
 def _past_tense(verb: str) -> str:
     _map = {
-        "create": "Created", "update": "Updated", "delete": "Deleted",
-        "save": "Saved", "send": "Sent", "emit": "Emitted",
-        "publish": "Published", "register": "Registered",
-        "process": "Processed", "notify": "Notified",
+        "create": "Created",
+        "update": "Updated",
+        "delete": "Deleted",
+        "save": "Saved",
+        "send": "Sent",
+        "emit": "Emitted",
+        "publish": "Published",
+        "register": "Registered",
+        "process": "Processed",
+        "notify": "Notified",
     }
     return _map.get(verb.lower(), verb.capitalize() + "d")

{code2schema-0.1.2 → code2schema-0.1.6}/code2schema/analyzer/graph.py

@@ -7,18 +7,20 @@ Zaawansowana analiza grafu wywołań:
   - detekcja hubów i cykli
   - metryki warstw (layered architecture check)
 """
+
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 
 import networkx as nx
 
-from code2schema.core.models import CQRSRole, ModuleIR, SchemaIR
+from code2schema.core.models import CQRSRole, SchemaIR
 
 
 # ── Builder ───────────────────────────────────────────────────────────────────
 
+
 def build_rich_graph(schema: SchemaIR) -> nx.DiGraph:
     """Buduje pełny graf z atrybutami węzłów (rola, moduł, fan-out)."""
     G = nx.DiGraph()
@@ -50,6 +52,7 @@ def build_rich_graph(schema: SchemaIR) -> nx.DiGraph:
 
 # ── Metrics ───────────────────────────────────────────────────────────────────
 
+
 def centrality_report(G: nx.DiGraph, top_n: int = 10) -> List[Tuple[str, float]]:
     """PageRank — funkcje najważniejsze architektonicznie."""
     if G.number_of_edges() == 0:
@@ -91,6 +94,7 @@ def layer_violations(schema: SchemaIR) -> List[str]:
 
 # ── Export ────────────────────────────────────────────────────────────────────
 
+
 def write_graphml(G: nx.DiGraph, path: Path) -> None:
     """Eksport do GraphML — kompatybilny z Gephi / yEd / Neo4j importer."""
     nx.write_graphml(G, str(path))
@@ -98,7 +102,7 @@ def write_graphml(G: nx.DiGraph, path: Path) -> None:
 
 def write_dot(G: nx.DiGraph, path: Path) -> None:
     """Eksport do DOT — renderowany przez Graphviz."""
-    lines = ["digraph CallGraph {", '  rankdir=LR;', '  node [shape=box];', ""]
+    lines = ["digraph CallGraph {", "  rankdir=LR;", "  node [shape=box];", ""]
     for n, data in G.nodes(data=True):
         role = data.get("role", "unknown")
         color = {

code2schema-0.1.6/code2schema/cli.py

@@ -0,0 +1,252 @@
+"""
+code2schema.cli
+~~~~~~~~~~~~~~~
+CLI v3 — pełny pipeline.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import time
+from pathlib import Path
+
+from code2schema.analyzer.cqrs import analyze
+from code2schema.analyzer.events import infer_event_model
+from code2schema.analyzer.graph import (
+    build_rich_graph,
+    detect_cycles,
+    graph_summary,
+    write_dot,
+    write_graphml,
+)
+from code2schema.codegen import write_json, write_markdown, write_proto
+from code2schema.codegen.visualizer import write_html
+from code2schema.core.extractor import extract_project
+
+
+_SPECIAL_PROJECT_DIRS = {"backend", "frontend", "src", "app", "api"}
+_GENERIC_PATH_PARTS = {"home", "github", "workspace", "projects", "src"}
+
+
+def _project_name_from_path(path: Path) -> str:
+    """Extract project name from path (e.g., /path/to/c2004/backend -> c2004)."""
+    # Try to find a meaningful name from the path
+    parts = path.parts
+    for i, part in enumerate(reversed(parts)):
+        if part in _SPECIAL_PROJECT_DIRS:
+            # Use parent directory name
+            if i < len(parts) - 1:
+                return parts[-(i + 2)]
+        # Skip common generic names
+        if part not in _GENERIC_PATH_PARTS:
+            return part
+    return path.name or "project"
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Build CLI argument parser."""
+    from code2schema import __version__
+
+    parser = argparse.ArgumentParser(
+        prog="code2schema",
+        description="Semantic Compiler: Code → CQRS → Schema / Proto / Graph",
+    )
+    parser.add_argument("path")
+    parser.add_argument(
+        "-o",
+        "--out",
+        metavar="FILE",
+        help="Output JSON schema (default: <project>_schema.json)",
+    )
+    parser.add_argument(
+        "--proto",
+        metavar="FILE",
+        nargs="?",
+        const=True,
+        default=None,
+        help="Output .proto file (default: <project>_api.proto if flag present)",
+    )
+    parser.add_argument(
+        "--md",
+        metavar="FILE",
+        nargs="?",
+        const=True,
+        default=None,
+        help="Output Markdown report (default: <project>_report.md if flag present)",
+    )
+    parser.add_argument("--graphml", metavar="FILE")
+    parser.add_argument("--dot", metavar="FILE")
+    parser.add_argument(
+        "--html",
+        metavar="FILE",
+        nargs="?",
+        const=True,
+        default=None,
+        help="Interactive HTML visualization (default: <project>_viz.html if flag present)",
+    )
+    parser.add_argument("--events", action="store_true")
+    parser.add_argument("--cycles", action="store_true")
+    parser.add_argument("--graph-summary", action="store_true")
+    parser.add_argument("--no-rules", action="store_true")
+    parser.add_argument("--exclude", nargs="*", default=[])
+    parser.add_argument("-q", "--quiet", action="store_true")
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    return parser
+
+
+def _resolve_output_dir(root: Path) -> Path:
+    if not root.is_dir():
+        return root.parent
+    if root.name in _SPECIAL_PROJECT_DIRS:
+        return root.parent
+    return root
+
+
+def _resolve_required_path(out_dir: Path, value: str | None, default_name: str) -> Path:
+    return out_dir / (value or default_name)
+
+
+def _resolve_optional_path(
+    out_dir: Path,
+    value: str | bool | None,
+    default_name: str,
+) -> Path | None:
+    if isinstance(value, str):
+        return out_dir / value
+    if value is True:
+        return out_dir / default_name
+    return None
+
+
+def _validate_root(args: argparse.Namespace) -> Path:
+    """Return ``Path`` for the analysis root from CLI args."""
+    return Path(args.path)
+
+
+def _build_output_paths(
+    root: Path, args: argparse.Namespace
+) -> tuple[Path, Path | None, Path | None, Path | None]:
+    """Build output file paths (JSON / proto / md / html) for the resolved root."""
+    proj_name = _project_name_from_path(root)
+    out_dir = _resolve_output_dir(root)
+
+    out_path = _resolve_required_path(out_dir, args.out, f"{proj_name}_schema.json")
+    proto_path = _resolve_optional_path(out_dir, args.proto, f"{proj_name}_api.proto")
+    md_path = _resolve_optional_path(out_dir, args.md, f"{proj_name}_report.md")
+    html_path = _resolve_optional_path(out_dir, args.html, f"{proj_name}_viz.html")
+    return out_path, proto_path, md_path, html_path
+
+
+def _resolve_paths(
+    args: argparse.Namespace,
+) -> tuple[Path, Path, Path | None, Path | None, Path | None]:
+    """Resolve root and all output file paths from CLI args."""
+    root = _validate_root(args)
+    out_path, proto_path, md_path, html_path = _build_output_paths(root, args)
+    return root, out_path, proto_path, md_path, html_path
+
+
+def _run_extraction(args, root):
+    """Parse project and run CQRS analysis. Returns (modules, schema, G) or None on failure."""
+    modules = extract_project(root, exclude=args.exclude or None)
+    if not modules:
+        print("ERROR: Brak plików .py.", file=sys.stderr)
+        return None
+    schema = analyze(modules)
+    if args.no_rules:
+        schema.rules = []
+    G = build_rich_graph(schema)
+    return modules, schema, G
+
+
+def _run_reports(args, modules, schema, G):
+    """Print optional reports: cycles, graph summary, events."""
+    if args.cycles:
+        cycles = detect_cycles(G)
+        if cycles:
+            print(f"\n⚠️  Cykle ({len(cycles)}):")
+            for c in cycles[:5]:
+                print(f"  {' → '.join(c[:5])}")
+        else:
+            print("✅ Brak cykli.")
+
+    if args.graph_summary:
+        print("\n── Graph Summary ──────────────────────")
+        print(graph_summary(G, schema))
+
+    if args.events:
+        em = infer_event_model(modules)
+        print("\n── Event Model ────────────────────────")
+        print(em.summary())
+
+
+def _write_outputs(args, schema, G, out_path, proto_path, md_path, html_path):
+    """Write all output files (JSON, proto, md, html, graphml, dot)."""
+    write_json(schema, out_path)
+    if proto_path:
+        write_proto(schema, proto_path)
+    if md_path:
+        write_markdown(schema, md_path)
+    if html_path:
+        write_html(schema, html_path)
+    if args.graphml:
+        write_graphml(G, Path(args.graphml))
+    if args.dot:
+        write_dot(G, Path(args.dot))
+
+
+def _print_summary(modules, schema, G, t0, out_path, proto_path, md_path, html_path):
+    """Print final summary with metrics and output file names."""
+    funcs = schema.all_functions()
+    outputs = [f"   → {out_path.name}"]
+    if proto_path:
+        outputs.append(f"   → {proto_path.name}")
+    if md_path:
+        outputs.append(f"   → {md_path.name}")
+    if html_path:
+        outputs.append(f"   → {html_path.name}")
+    print(
+        f"\n✅ Gotowe ({time.perf_counter()-t0:.2f}s)\n"
+        f"   Modules  : {len(modules)}\n"
+        f"   Functions: {len(funcs)}\n"
+        f"   Queries  : {len(schema.queries())}\n"
+        f"   Commands : {len(schema.commands())}\n"
+        f"   Orchest. : {len(schema.orchestrators())}\n"
+        f"   Workflows: {len(schema.workflows)}\n"
+        f"   Rules    : {len(schema.rules)}\n"
+        f"   Graph    : {G.number_of_nodes()}N / {G.number_of_edges()}E\n"
+        + "\n".join(outputs)
+    )
+
+
+def main(argv=None):
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    root, out_path, proto_path, md_path, html_path = _resolve_paths(args)
+    if not root.exists():
+        print(f"ERROR: {root}", file=sys.stderr)
+        return 1
+
+    t0 = time.perf_counter()
+    if not args.quiet:
+        print(f"⏳ Parsing: {root}")
+
+    result = _run_extraction(args, root)
+    if result is None:
+        return 1
+    modules, schema, G = result
+
+    _run_reports(args, modules, schema, G)
+    _write_outputs(args, schema, G, out_path, proto_path, md_path, html_path)
+
+    if not args.quiet:
+        _print_summary(modules, schema, G, t0, out_path, proto_path, md_path, html_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())