code2schema 0.1.4__tar.gz → 0.1.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2schema
-Version: 0.1.4
+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,11 +34,11 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.4-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.45-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.5h-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.4500 (3 commits)
-- 👤 **Human dev:** ~$350 (3.5h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $0.6000 (4 commits)
+- 👤 **Human dev:** ~$361 (3.6h @ $100/h, 30min dedup)
 
 Generated on 2026-05-07 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

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

@@ -3,11 +3,11 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.4-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.45-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.5h-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.4500 (3 commits)
-- 👤 **Human dev:** ~$350 (3.5h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $0.6000 (4 commits)
+- 👤 **Human dev:** ~$361 (3.6h @ $100/h, 30min dedup)
 
 Generated on 2026-05-07 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

{code2schema-0.1.4 → 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.4"
+__version__ = "0.1.6"

{code2schema-0.1.4 → 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.4 → 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,6 +75,7 @@ class EventModel:
 
 # ── Inference ─────────────────────────────────────────────────────────────────
 
+
 def _find_emitters(modules: List[ModuleIR]) -> List[DomainEvent]:
     """Krok 1: znajdź funkcje emitujące zdarzenia."""
     events: List[DomainEvent] = []
@@ -122,10 +126,7 @@ 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:
             aggregates.append(mod.name)
     return aggregates
@@ -145,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("_")
@@ -160,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.4 → 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.4 → code2schema-0.1.6}/code2schema/cli.py

@@ -3,6 +3,7 @@ code2schema.cli
 ~~~~~~~~~~~~~~~
 CLI v3 — pełny pipeline.
 """
+
 from __future__ import annotations
 
 import argparse
@@ -13,7 +14,11 @@ 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,
+    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
@@ -42,26 +47,53 @@ def _project_name_from_path(path: Path) -> str:
 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 = 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(
+        "-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(
+        "--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__}")
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
     return parser
 
 
@@ -89,11 +121,15 @@ def _resolve_optional_path(
     return None
 
 
-def _resolve_paths(
-    args: argparse.Namespace,
-) -> tuple[Path, Path, Path | None, Path | None, Path | None]:
-    """Resolve root, project name and output file paths from CLI args."""
-    root = Path(args.path)
+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)
 
@@ -101,6 +137,15 @@ def _resolve_paths(
     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
 
 

{code2schema-0.1.4 → code2schema-0.1.6}/code2schema/codegen/__init__.py

@@ -6,17 +6,18 @@ Generatory wyjściowe:
   - Proto (gRPC .proto)
   - Markdown summary
 """
+
 from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Literal
 
 from code2schema.core.models import CQRSRole, SchemaIR
 
 
 # ── JSON ──────────────────────────────────────────────────────────────────────
 
+
 def to_json(schema: SchemaIR, indent: int = 2) -> str:
     """Serializuje SchemaIR do JSON."""
     return json.dumps(schema.model_dump(), indent=indent, default=str)
@@ -28,12 +29,13 @@ def write_json(schema: SchemaIR, path: Path) -> None:
 
 # ── Proto ─────────────────────────────────────────────────────────────────────
 
+
 def to_proto(schema: SchemaIR) -> str:
     """Generuje .proto z modelu CQRS."""
     lines: list[str] = [
         'syntax = "proto3";',
         "",
-        f"// Generated by code2schema v0.1",
+        "// Generated by code2schema v0.1",
         f"// Modules: {len(schema.modules)}, "
         f"Commands: {len(schema.commands())}, "
         f"Queries: {len(schema.queries())}",
@@ -50,9 +52,7 @@ def to_proto(schema: SchemaIR) -> str:
         if func.role in (CQRSRole.QUERY, CQRSRole.COMMAND, CQRSRole.ORCHESTRATOR):
             suffix = func.role.value.capitalize()
             safe_name = _safe_proto_name(func.name)
-            lines.append(
-                f"  rpc {safe_name}{suffix} (Request) returns (Response);"
-            )
+            lines.append(f"  rpc {safe_name}{suffix} (Request) returns (Response);")
 
     lines += ["}", ""]
     return "\n".join(lines)
@@ -64,6 +64,7 @@ def write_proto(schema: SchemaIR, path: Path) -> None:
 
 # ── Markdown summary ──────────────────────────────────────────────────────────
 
+
 def to_markdown(schema: SchemaIR) -> str:
     """Zwraca czytelne Markdown podsumowanie."""
     funcs = schema.all_functions()
@@ -81,8 +82,8 @@ def to_markdown(schema: SchemaIR) -> str:
         "",
         "## CQRS Distribution",
         "",
-        f"| Role | Count |",
-        f"|------|-------|",
+        "| Role | Count |",
+        "|------|-------|",
         f"| Query | {queries} |",
         f"| Command | {commands} |",
         f"| Orchestrator | {orchestrators} |",
@@ -112,6 +113,7 @@ def write_markdown(schema: SchemaIR, path: Path) -> None:
 
 # ── helpers ───────────────────────────────────────────────────────────────────
 
+
 def _safe_proto_name(name: str) -> str:
     """CamelCase dla nazw proto RPC."""
     return "".join(part.capitalize() for part in name.split("_"))

{code2schema-0.1.4 → code2schema-0.1.6}/code2schema/codegen/visualizer.py

@@ -4,6 +4,7 @@ code2schema.codegen.visualizer
 Generuje interaktywny HTML z grafem CQRS (D3.js force layout).
 Bez zewnętrznych zależności poza stdlib — D3 ładowany z CDN.
 """
+
 from __future__ import annotations
 
 import json
@@ -14,66 +15,88 @@ from code2schema.core.models import CQRSRole, SchemaIR
 
 # ── Kolory ról ────────────────────────────────────────────────────────────────
 ROLE_COLOR: dict[str, str] = {
-    CQRSRole.QUERY:        "#4ade80",   # zielony
-    CQRSRole.COMMAND:      "#fb923c",   # pomarańczowy
-    CQRSRole.ORCHESTRATOR: "#a78bfa",   # fioletowy
-    CQRSRole.UNKNOWN:      "#94a3b8",   # szary
+    CQRSRole.QUERY: "#4ade80",  # zielony
+    CQRSRole.COMMAND: "#fb923c",  # pomarańczowy
+    CQRSRole.ORCHESTRATOR: "#a78bfa",  # fioletowy
+    CQRSRole.UNKNOWN: "#94a3b8",  # szary
 }
 
 ROLE_EMOJI: dict[str, str] = {
-    CQRSRole.QUERY:        "🔍",
-    CQRSRole.COMMAND:      "✏️",
+    CQRSRole.QUERY: "🔍",
+    CQRSRole.COMMAND: "✏️",
     CQRSRole.ORCHESTRATOR: "🔀",
-    CQRSRole.UNKNOWN:      "❓",
+    CQRSRole.UNKNOWN: "❓",
 }
 
 
-def _build_graph_data(schema: SchemaIR) -> dict[str, Any]:
-    """Buduje nodes/links dla D3 force graph."""
+def _build_nodes(schema: SchemaIR) -> tuple[list[dict], dict[str, int]]:
+    """Buduje listę node'ów i mapę nazwa → index dla D3."""
     nodes: list[dict] = []
-    links: list[dict] = []
     node_ids: dict[str, int] = {}
-
     for func in schema.all_functions():
         idx = len(nodes)
         node_ids[func.name] = idx
-        nodes.append({
-            "id": idx,
-            "name": func.name,
-            "module": func.module,
-            "role": func.role.value,
-            "color": ROLE_COLOR.get(func.role, "#94a3b8"),
-            "emoji": ROLE_EMOJI.get(func.role, "❓"),
-            "fan_out": func.fan_out,
-            "lines": func.lines,
-            "side_effects": [s.value for s in func.side_effects],
-            "is_async": func.is_async,
-        })
-
+        nodes.append(
+            {
+                "id": idx,
+                "name": func.name,
+                "module": func.module,
+                "role": func.role.value,
+                "color": ROLE_COLOR.get(func.role, "#94a3b8"),
+                "emoji": ROLE_EMOJI.get(func.role, "❓"),
+                "fan_out": func.fan_out,
+                "lines": func.lines,
+                "side_effects": [s.value for s in func.side_effects],
+                "is_async": func.is_async,
+            }
+        )
+    return nodes, node_ids
+
+
+def _build_links(schema: SchemaIR, node_ids: dict[str, int]) -> list[dict]:
+    """Buduje listę krawędzi (caller → callee) dla D3."""
+    links: list[dict] = []
     for func in schema.all_functions():
         src = node_ids.get(func.name)
+        if src is None:
+            continue
         for callee in func.calls:
             dst = node_ids.get(callee)
-            if src is not None and dst is not None and src != dst:
+            if dst is not None and src != dst:
                 links.append({"source": src, "target": dst})
+    return links
+
 
-    rules_by_target = {}
+def _group_rules_by_target(schema: SchemaIR) -> dict[str, list[str]]:
+    """Grupuje rule.id po krótkiej nazwie targetu."""
+    rules_by_target: dict[str, list[str]] = {}
     for r in schema.rules:
         rules_by_target.setdefault(r.target.split(".")[-1], []).append(r.id)
+    return rules_by_target
 
+
+def _build_stats(schema: SchemaIR, function_count: int) -> dict[str, int]:
+    """Buduje sekcję 'stats' wyświetlaną w pasku górnym."""
+    return {
+        "modules": len(schema.modules),
+        "functions": function_count,
+        "commands": len(schema.commands()),
+        "queries": len(schema.queries()),
+        "orchestrators": len(schema.orchestrators()),
+        "workflows": len(schema.workflows),
+        "rules": len(schema.rules),
+    }
+
+
+def _build_graph_data(schema: SchemaIR) -> dict[str, Any]:
+    """Buduje nodes/links/rules/stats dla D3 force graph."""
+    nodes, node_ids = _build_nodes(schema)
+    links = _build_links(schema, node_ids)
     return {
         "nodes": nodes,
         "links": links,
-        "rules": rules_by_target,
-        "stats": {
-            "modules": len(schema.modules),
-            "functions": len(nodes),
-            "commands": len(schema.commands()),
-            "queries": len(schema.queries()),
-            "orchestrators": len(schema.orchestrators()),
-            "workflows": len(schema.workflows),
-            "rules": len(schema.rules),
-        },
+        "rules": _group_rules_by_target(schema),
+        "stats": _build_stats(schema, len(nodes)),
     }
 
 

{code2schema-0.1.4 → code2schema-0.1.6}/code2schema/core/extractor.py

@@ -4,22 +4,54 @@ code2schema.core.extractor
 Ekstrakcja funkcji i importów z plików .py przy użyciu wbudowanego modułu `ast`.
 Bez zewnętrznych zależności — czyste stdlib.
 """
+
 from __future__ import annotations
 
 import ast
-import os
 from pathlib import Path
-from typing import List
 
 from code2schema.core.models import FunctionIR, ModuleIR
 
 
 # ── Wzorce side-effectów ─────────────────────────────────────────────────────
 
-_FILESYSTEM_CALLS: set[str] = {"open", "write", "read", "unlink", "mkdir", "rmdir", "rename"}
-_NETWORK_CALLS: set[str] = {"get", "post", "put", "delete", "patch", "request", "fetch", "connect"}
-_SYSTEM_CALLS: set[str] = {"system", "popen", "subprocess", "Popen", "run", "call", "check_output"}
-_DB_CALLS: set[str] = {"execute", "commit", "rollback", "query", "insert", "update", "delete"}
+_FILESYSTEM_CALLS: set[str] = {
+    "open",
+    "write",
+    "read",
+    "unlink",
+    "mkdir",
+    "rmdir",
+    "rename",
+}
+_NETWORK_CALLS: set[str] = {
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "request",
+    "fetch",
+    "connect",
+}
+_SYSTEM_CALLS: set[str] = {
+    "system",
+    "popen",
+    "subprocess",
+    "Popen",
+    "run",
+    "call",
+    "check_output",
+}
+_DB_CALLS: set[str] = {
+    "execute",
+    "commit",
+    "rollback",
+    "query",
+    "insert",
+    "update",
+    "delete",
+}
 
 _NETWORK_MODULES: set[str] = {"requests", "httpx", "aiohttp", "urllib", "http"}
 _SYSTEM_MODULES: set[str] = {"os", "subprocess", "shutil", "sys"}
@@ -55,7 +87,9 @@ class _FunctionVisitor(ast.NodeVisitor):
         self._process_func(node, is_async=True)
         self.generic_visit(node)
 
-    def _process_func(self, node: ast.FunctionDef | ast.AsyncFunctionDef, is_async: bool) -> None:
+    def _process_func(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef, is_async: bool
+    ) -> None:
         calls = self._collect_calls(node)
         side_effects = self._detect_side_effects(node, calls)
         docstring = ast.get_docstring(node)
@@ -66,7 +100,9 @@ class _FunctionVisitor(ast.NodeVisitor):
             calls=list(dict.fromkeys(calls)),  # deduplicate, preserve order
             fan_out=len(set(calls)),
             side_effects=side_effects,
-            lines=node.end_lineno - node.lineno + 1 if hasattr(node, "end_lineno") else 0,
+            lines=(
+                node.end_lineno - node.lineno + 1 if hasattr(node, "end_lineno") else 0
+            ),
             is_async=is_async,
             docstring=docstring,
         )
@@ -90,9 +126,7 @@ class _FunctionVisitor(ast.NodeVisitor):
             return func_node.attr
         return None
 
-    def _detect_side_effects(
-        self, node: ast.AST, calls: list[str]
-    ) -> list[str]:
+    def _detect_side_effects(self, node: ast.AST, calls: list[str]) -> list[str]:
         from code2schema.core.models import SideEffect
 
         effects: list[SideEffect] = []
@@ -112,6 +146,7 @@ class _FunctionVisitor(ast.NodeVisitor):
 
 # ── Public API ────────────────────────────────────────────────────────────────
 
+
 def extract_module(path: Path) -> ModuleIR | None:
     """Parsuje jeden plik .py i zwraca ModuleIR."""
     try:
@@ -127,7 +162,9 @@ def extract_module(path: Path) -> ModuleIR | None:
     imports = [
         alias.name
         for node in ast.walk(tree)
-        for alias in (node.names if isinstance(node, (ast.Import, ast.ImportFrom)) else [])
+        for alias in (
+            node.names if isinstance(node, (ast.Import, ast.ImportFrom)) else []
+        )
     ]
 
     return ModuleIR(

{code2schema-0.1.4 → code2schema-0.1.6}/code2schema/core/models.py

@@ -3,10 +3,11 @@ code2schema.core.models
 ~~~~~~~~~~~~~~~~~~~~~~~
 Intermediate Representation (IR) — język-most między kodem a schematem.
 """
+
 from __future__ import annotations
 
 from enum import Enum
-from typing import List, Optional, Set
+from typing import List, Optional
 
 from pydantic import BaseModel, Field
 
@@ -28,6 +29,7 @@ class SideEffect(str, Enum):
 
 class FunctionIR(BaseModel):
     """Pojedyncza funkcja w modelu semantycznym."""
+
     name: str
     module: str
     calls: List[str] = Field(default_factory=list)
@@ -45,7 +47,8 @@ class FunctionIR(BaseModel):
 
 class ModuleIR(BaseModel):
     """Moduł (plik .py) z wyekstrahowanymi funkcjami."""
-    name: str          # np. "backend.services.analyzer"
+
+    name: str  # np. "backend.services.analyzer"
     path: str
     functions: List[FunctionIR] = Field(default_factory=list)
     imports: List[str] = Field(default_factory=list)
@@ -59,6 +62,7 @@ class WorkflowStep(BaseModel):
 
 class WorkflowIR(BaseModel):
     """Graf wykonania (DAG) dla jednej funkcji-orkiestratora."""
+
     name: str
     entry: str
     steps: List[WorkflowStep] = Field(default_factory=list)
@@ -66,6 +70,7 @@ class WorkflowIR(BaseModel):
 
 class RuleIR(BaseModel):
     """Heurystyczna reguła jakości wygenerowana z analizy."""
+
     id: str
     target: str
     condition: str
@@ -75,7 +80,10 @@ class RuleIR(BaseModel):
 
 class SchemaIR(BaseModel):
     """Korzeń modelu semantycznego całego projektu."""
-    system: dict = Field(default_factory=lambda: {"type": "code2schema", "version": "0.1"})
+
+    system: dict = Field(
+        default_factory=lambda: {"type": "code2schema", "version": "0.1"}
+    )
     modules: List[ModuleIR] = Field(default_factory=list)
     workflows: List[WorkflowIR] = Field(default_factory=list)
     rules: List[RuleIR] = Field(default_factory=list)

{code2schema-0.1.4 → code2schema-0.1.6}/code2schema.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2schema
-Version: 0.1.4
+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,11 +34,11 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.4-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.45-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.5h-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.4500 (3 commits)
-- 👤 **Human dev:** ~$350 (3.5h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $0.6000 (4 commits)
+- 👤 **Human dev:** ~$361 (3.6h @ $100/h, 30min dedup)
 
 Generated on 2026-05-07 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

{code2schema-0.1.4 → code2schema-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code2schema"
-version = "0.1.4"
+version = "0.1.6"
 description = "Semantic compiler: Code → AST → CQRS Model → Workflow DAG → Proto/Schema"
 readme = "README.md"
 requires-python = ">=3.10"