code2schema 0.1.1__py3-none-any.whl

code2schema/__init__.py

@@ -0,0 +1,10 @@
+"""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",
+]
+__version__ = "0.1.1"

code2schema/analyzer/__init__.py

@@ -0,0 +1 @@
+# code2schema.analyzer

code2schema/analyzer/cqrs.py

@@ -0,0 +1,166 @@
+"""
+code2schema.analyzer.cqrs
+~~~~~~~~~~~~~~~~~~~~~~~~~
+CQRS inference + call graph (NetworkX) + reguły jakości.
+"""
+from __future__ import annotations
+
+from typing import List
+
+import networkx as nx
+
+from code2schema.core.models import (
+    CQRSRole,
+    FunctionIR,
+    ModuleIR,
+    RuleIR,
+    SchemaIR,
+    SideEffect,
+    WorkflowIR,
+    WorkflowStep,
+)
+
+# ── Progi heurystyczne ───────────────────────────────────────────────────────
+
+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
+
+    if func.fan_out >= FAN_OUT_ORCHESTRATOR:
+        return CQRSRole.ORCHESTRATOR
+
+    if has_side_effects:
+        return CQRSRole.COMMAND
+
+    if func.fan_out == 0:
+        return CQRSRole.QUERY
+
+    # Małe funkcje bez side-effectów, ale z wywołaniami → query
+    return CQRSRole.QUERY
+
+
+# ── Call Graph ───────────────────────────────────────────────────────────────
+
+def build_call_graph(modules: List[ModuleIR]) -> nx.DiGraph:
+    """Buduje skierowany graf wywołań między funkcjami."""
+    G = nx.DiGraph()
+
+    all_names: set[str] = set()
+    for mod in modules:
+        for f in mod.functions:
+            all_names.add(f.name)
+            G.add_node(f.qualified_name, role=f.role, module=mod.name)
+
+    for mod in modules:
+        for f in mod.functions:
+            for callee in f.calls:
+                if callee in all_names:
+                    G.add_edge(f.qualified_name, callee)
+
+    return G
+
+
+def detect_cycles(G: nx.DiGraph) -> List[List[str]]:
+    """Zwraca listę cykli w grafie wywołań."""
+    return list(nx.simple_cycles(G))
+
+
+def centrality(G: nx.DiGraph) -> dict[str, float]:
+    """PageRank — im wyższy, tym bardziej 'centralny' w architekturze."""
+    return nx.pagerank(G) if G.number_of_edges() > 0 else {}
+
+
+# ── Workflow DAG ──────────────────────────────────────────────────────────────
+
+def build_workflows(modules: List[ModuleIR]) -> List[WorkflowIR]:
+    """Buduje DAG wykonania dla każdego orkiestratora."""
+    workflows: list[WorkflowIR] = []
+    for mod in modules:
+        for f in mod.functions:
+            if f.role == CQRSRole.ORCHESTRATOR and f.calls:
+                workflow = WorkflowIR(
+                    name=f"workflow_{f.name}",
+                    entry=f.qualified_name,
+                    steps=[
+                        WorkflowStep(callee=c, is_async=f.is_async)
+                        for c in f.calls
+                    ],
+                )
+                workflows.append(workflow)
+    return workflows
+
+
+# ── Rules ────────────────────────────────────────────────────────────────────
+
+def generate_rules(modules: List[ModuleIR]) -> List[RuleIR]:
+    """Generuje heurystyczne reguły jakości na podstawie IR."""
+    rules: 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",
+                ))
+            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",
+                ))
+
+    return rules
+
+
+# ── Main entry ────────────────────────────────────────────────────────────────
+
+def analyze(modules: List[ModuleIR]) -> SchemaIR:
+    """Pełna analiza: CQRS + graf + workflow + reguły → SchemaIR."""
+
+    # 1. Ustaw rolę CQRS dla każdej funkcji
+    for mod in modules:
+        for f in mod.functions:
+            f.role = _infer_role(f)
+
+    # 2. Graf wywołań
+    G = build_call_graph(modules)
+
+    # 3. Wzbogać fan-out danymi z grafu
+    out_degrees = dict(G.out_degree())
+    for mod in modules:
+        for f in mod.functions:
+            qn = f.qualified_name
+            if qn in out_degrees:
+                f.fan_out = max(f.fan_out, out_degrees[qn])
+            # Ponów rolę po uaktualnieniu fan-out
+            f.role = _infer_role(f)
+
+    # 4. Workflow DAG
+    workflows = build_workflows(modules)
+
+    # 5. Reguły
+    rules = generate_rules(modules)
+
+    return SchemaIR(modules=modules, workflows=workflows, rules=rules)

code2schema/analyzer/events.py

@@ -0,0 +1,162 @@
+"""
+code2schema.analyzer.events
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Inferencja modelu zdarzeń (DDD / Event Sourcing):
+  - wykrywa funkcje, które "emitują" zdarzenia
+  - 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
+
+
+# ── Heurystyki nazw ───────────────────────────────────────────────────────────
+
+_EVENT_EMIT_PATTERNS = re.compile(
+    r"(emit|publish|dispatch|fire|send|enqueue|produce|notify|trigger|broadcast)",
+    re.I,
+)
+_EVENT_HANDLER_PATTERNS = re.compile(
+    r"(on_|handle_|listener|subscriber|consumer|process_|receive_)",
+    re.I,
+)
+_AGGREGATE_PATTERNS = re.compile(
+    r"(create|update|delete|save|store|persist|commit|apply)",
+    re.I,
+)
+
+
+@dataclass
+class DomainEvent:
+    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"
+    emits: List[str] = field(default_factory=list)
+
+
+@dataclass
+class EventModel:
+    commands: List[CommandHandler] = field(default_factory=list)
+    events: List[DomainEvent] = field(default_factory=list)
+    aggregates: List[str] = field(default_factory=list)
+
+    def summary(self) -> str:
+        lines = [
+            f"Commands        : {len(self.commands)}",
+            f"Domain Events   : {len(self.events)}",
+            f"Aggregates      : {len(self.aggregates)}",
+        ]
+        if self.events:
+            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}]")
+        if self.commands:
+            lines.append("\nCommand Handlers (top 10):")
+            for cmd in self.commands[:10]:
+                emits = ", ".join(cmd.emits[:3]) or "—"
+                lines.append(f"  {cmd.name:30s} emits=[{emits}]")
+        return "\n".join(lines)
+
+
+# ── 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] = {}
+    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)
+
+    # Krok 2: znajdź handlerów
+    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:
+                    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
+    for mod in modules:
+        for f in mod.functions:
+            if f.role == CQRSRole.COMMAND or _AGGREGATE_PATTERNS.search(f.name):
+                emits = [
+                    _derive_event_name(c)
+                    for c in f.calls
+                    if _EVENT_EMIT_PATTERNS.search(c)
+                ]
+                if emits or f.role == CQRSRole.COMMAND:
+                    model.commands.append(
+                        CommandHandler(
+                            name=f.qualified_name,
+                            command=f.name,
+                            emits=emits,
+                        )
+                    )
+
+    # Krok 4: agregaty — moduły z operacjami CRUD
+    for mod in modules:
+        crud_score = sum(
+            1 for f in mod.functions
+            if _AGGREGATE_PATTERNS.search(f.name)
+        )
+        if crud_score >= 2:
+            model.aggregates.append(mod.name)
+
+    return model
+
+
+def _derive_event_name(func_name: str) -> str:
+    """save_user → UserSaved, create_order → OrderCreated."""
+    # Usuń prefiks czasownikowy
+    for prefix in ("on_", "handle_", "emit_", "publish_", "dispatch_", "fire_"):
+        if func_name.startswith(prefix):
+            func_name = func_name[len(prefix):]
+            break
+
+    parts = func_name.split("_")
+    if len(parts) >= 2:
+        verb = parts[-1]  # ostatni segment = czasownik → past tense
+        subject = "".join(p.capitalize() for p in parts[:-1])
+        past = _past_tense(verb)
+        return f"{subject}{past}"
+
+    return func_name.capitalize() + "Event"
+
+
+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",
+    }
+    return _map.get(verb.lower(), verb.capitalize() + "d")

code2schema/analyzer/graph.py

@@ -0,0 +1,146 @@
+"""
+code2schema.analyzer.graph
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+Zaawansowana analiza grafu wywołań:
+  - eksport GraphML (do Gephi / yEd / Neo4j)
+  - PageRank centrality (kto jest "centrum" architektury)
+  - detekcja hubów i cykli
+  - metryki warstw (layered architecture check)
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import networkx as nx
+
+from code2schema.core.models import CQRSRole, ModuleIR, 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()
+
+    func_map: dict[str, str] = {}  # short_name → qualified_name (last wins)
+    for mod in schema.modules:
+        for f in mod.functions:
+            G.add_node(
+                f.qualified_name,
+                label=f.name,
+                role=f.role.value,
+                module=mod.name,
+                fan_out=f.fan_out,
+                lines=f.lines,
+                is_async=int(f.is_async),
+            )
+            func_map[f.name] = f.qualified_name
+
+    for mod in schema.modules:
+        for f in mod.functions:
+            src = f.qualified_name
+            for callee in f.calls:
+                dst = func_map.get(callee)
+                if dst and dst != src:
+                    G.add_edge(src, dst)
+
+    return G
+
+
+# ── 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:
+        return []
+    pr = nx.pagerank(G, alpha=0.85)
+    return sorted(pr.items(), key=lambda x: x[1], reverse=True)[:top_n]
+
+
+def hub_nodes(G: nx.DiGraph, threshold: int = 5) -> List[str]:
+    """Węzły z fan-in >= threshold — potencjalne hub-moduły."""
+    return [n for n, d in G.in_degree() if d >= threshold]
+
+
+def detect_cycles(G: nx.DiGraph) -> List[List[str]]:
+    return list(nx.simple_cycles(G))
+
+
+def layer_violations(schema: SchemaIR) -> List[str]:
+    """
+    Prosta heurystyka: query nie powinno wołać command.
+    Zwraca listę naruszeń.
+    """
+    func_roles: dict[str, CQRSRole] = {}
+    for mod in schema.modules:
+        for f in mod.functions:
+            func_roles[f.name] = f.role
+
+    violations: list[str] = []
+    for mod in schema.modules:
+        for f in mod.functions:
+            if f.role == CQRSRole.QUERY:
+                for callee in f.calls:
+                    if func_roles.get(callee) == CQRSRole.COMMAND:
+                        violations.append(
+                            f"LAYER_VIOLATION: {f.qualified_name} (query) → {callee} (command)"
+                        )
+    return violations
+
+
+# ── 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))
+
+
+def write_dot(G: nx.DiGraph, path: Path) -> None:
+    """Eksport do DOT — renderowany przez Graphviz."""
+    lines = ["digraph CallGraph {", '  rankdir=LR;', '  node [shape=box];', ""]
+    for n, data in G.nodes(data=True):
+        role = data.get("role", "unknown")
+        color = {
+            "query": "lightblue",
+            "command": "lightsalmon",
+            "orchestrator": "lightgreen",
+        }.get(role, "white")
+        label = data.get("label", n.split(".")[-1])
+        lines.append(f'  "{n}" [label="{label}" style=filled fillcolor="{color}"];')
+    lines.append("")
+    for src, dst in G.edges():
+        lines.append(f'  "{src}" -> "{dst}";')
+    lines += ["}", ""]
+    path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def graph_summary(G: nx.DiGraph, schema: SchemaIR) -> str:
+    """Tekstowe podsumowanie grafu."""
+    cycles = detect_cycles(G)
+    hubs = hub_nodes(G)
+    top = centrality_report(G, top_n=5)
+    violations = layer_violations(schema)
+
+    lines = [
+        f"Nodes     : {G.number_of_nodes()}",
+        f"Edges     : {G.number_of_edges()}",
+        f"Cycles    : {len(cycles)}",
+        f"Hubs      : {len(hubs)}",
+        f"Violations: {len(violations)}",
+        "",
+    ]
+    if top:
+        lines.append("Top-5 PageRank (architektoniczne centra):")
+        for name, score in top:
+            short = name.split(".")[-1]
+            lines.append(f"  {score:.4f}  {short}")
+    if violations:
+        lines.append("\nLayer violations:")
+        for v in violations[:10]:
+            lines.append(f"  {v}")
+    if cycles:
+        lines.append(f"\nCycles (pierwsze {min(5, len(cycles))}):")
+        for c in cycles[:5]:
+            lines.append(f"  {' → '.join(c[:4])}{'...' if len(c) > 4 else ''}")
+    return "\n".join(lines)

code2schema/cli.py

@@ -0,0 +1,105 @@
+"""
+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.core.extractor import extract_project
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="code2schema",
+        description="Semantic Compiler: Code → CQRS → Schema / Proto / Graph")
+    parser.add_argument("path")
+    parser.add_argument("-o", "--out", default="schema.json")
+    parser.add_argument("--proto", metavar="FILE")
+    parser.add_argument("--md", metavar="FILE")
+    parser.add_argument("--graphml", metavar="FILE")
+    parser.add_argument("--dot", metavar="FILE")
+    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")
+    args = parser.parse_args(argv)
+
+    root = Path(args.path)
+    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}")
+
+    modules = extract_project(root, exclude=args.exclude or None)
+    if not modules:
+        print("ERROR: Brak plików .py.", file=sys.stderr)
+        return 1
+
+    schema = analyze(modules)
+    if args.no_rules:
+        schema.rules = []
+
+    G = build_rich_graph(schema)
+
+    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())
+
+    write_json(schema, Path(args.out))
+    if args.proto:
+        write_proto(schema, Path(args.proto))
+    if args.md:
+        write_markdown(schema, Path(args.md))
+    if args.graphml:
+        write_graphml(G, Path(args.graphml))
+    if args.dot:
+        write_dot(G, Path(args.dot))
+
+    if not args.quiet:
+        funcs = schema.all_functions()
+        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"
+            f"   → {args.out}"
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())