code2docs 0.1.3__tar.gz → 0.1.5__tar.gz

{code2docs-0.1.3 → code2docs-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2docs
-Version: 0.1.3
+Version: 0.1.5
 Summary: Auto-generate and sync project documentation from source code analysis
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -40,7 +40,7 @@ Dynamic: license-file
 
 # code2docs
 
-![version](https://img.shields.io/badge/version-0.1.3-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![docs](https://img.shields.io/badge/docs-auto--generated-blueviolet)
+![version](https://img.shields.io/badge/version-0.1.5-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![docs](https://img.shields.io/badge/docs-auto--generated-blueviolet)
 
 > Auto-generate and sync project documentation from source code analysis.
 

{code2docs-0.1.3 → code2docs-0.1.5}/README.md

@@ -1,6 +1,6 @@
 # code2docs
 
-![version](https://img.shields.io/badge/version-0.1.3-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![docs](https://img.shields.io/badge/docs-auto--generated-blueviolet)
+![version](https://img.shields.io/badge/version-0.1.5-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![docs](https://img.shields.io/badge/docs-auto--generated-blueviolet)
 
 > Auto-generate and sync project documentation from source code analysis.
 

{code2docs-0.1.3 → code2docs-0.1.5}/code2docs/__init__.py

@@ -5,7 +5,7 @@ Uses code2llm's AnalysisResult to produce human-readable documentation:
 README.md, API references, module docs, examples, and architecture diagrams.
 """
 
-__version__ = "0.1.3"
+__version__ = "0.1.5"
 __author__ = "Tom Sapletta"
 
 from .config import Code2DocsConfig

{code2docs-0.1.3 → code2docs-0.1.5}/code2docs/cli.py

@@ -115,6 +115,10 @@ def _run_generate(project_path: str, config: Code2DocsConfig,
     from .generators.module_docs_gen import ModuleDocsGenerator
     from .generators.examples_gen import ExamplesGenerator
     from .generators.architecture_gen import ArchitectureGenerator
+    from .generators.depgraph_gen import DepGraphGenerator
+    from .generators.coverage_gen import CoverageGenerator
+    from .generators.mkdocs_gen import MkDocsGenerator
+    from .generators.api_changelog_gen import ApiChangelogGenerator
 
     project = Path(project_path).resolve()
     click.echo(f"📖 code2docs: analyzing {project.name}...")
@@ -169,13 +173,40 @@ def _run_generate(project_path: str, config: Code2DocsConfig,
         arch_gen = ArchitectureGenerator(config, result)
         content = arch_gen.generate()
         if not dry_run:
-            arch_path = docs_dir / "architecture.md"
-            arch_path.write_text(content, encoding="utf-8")
+            (docs_dir / "architecture.md").write_text(content, encoding="utf-8")
             click.echo(f"  ✅ docs/architecture.md")
         else:
             click.echo(f"  [dry-run] docs/architecture.md")
 
-    # Step 4: Generate examples/
+    # Step 4: Dependency graph
+    depgraph_gen = DepGraphGenerator(config, result)
+    content = depgraph_gen.generate()
+    if not dry_run:
+        (docs_dir / "dependency-graph.md").write_text(content, encoding="utf-8")
+        click.echo(f"  ✅ docs/dependency-graph.md")
+    else:
+        click.echo(f"  [dry-run] docs/dependency-graph.md")
+
+    # Step 5: Docstring coverage
+    cov_gen = CoverageGenerator(config, result)
+    content = cov_gen.generate()
+    if not dry_run:
+        (docs_dir / "coverage.md").write_text(content, encoding="utf-8")
+        click.echo(f"  ✅ docs/coverage.md")
+    else:
+        click.echo(f"  [dry-run] docs/coverage.md")
+
+    # Step 6: API changelog (diff with previous snapshot)
+    api_cl_gen = ApiChangelogGenerator(config, result)
+    content = api_cl_gen.generate(str(project))
+    if not dry_run:
+        (docs_dir / "api-changelog.md").write_text(content, encoding="utf-8")
+        api_cl_gen.save_snapshot(str(project))
+        click.echo(f"  ✅ docs/api-changelog.md")
+    else:
+        click.echo(f"  [dry-run] docs/api-changelog.md")
+
+    # Step 7: Generate examples/
     if config.examples.auto_generate:
         ex_gen = ExamplesGenerator(config, result)
         files = ex_gen.generate_all()
@@ -186,6 +217,15 @@ def _run_generate(project_path: str, config: Code2DocsConfig,
         else:
             click.echo(f"  [dry-run] examples/ ({len(files)} files)")
 
+    # Step 8: mkdocs.yml
+    mkdocs_gen = MkDocsGenerator(config, result)
+    content = mkdocs_gen.generate(str(docs_dir))
+    if not dry_run:
+        mkdocs_gen.write(str(project / "mkdocs.yml"), content)
+        click.echo(f"  ✅ mkdocs.yml")
+    else:
+        click.echo(f"  [dry-run] mkdocs.yml")
+
     click.echo("📖 Done!")
 
 

{code2docs-0.1.3 → code2docs-0.1.5}/code2docs/generators/__init__.py

@@ -6,6 +6,10 @@ from .module_docs_gen import ModuleDocsGenerator
 from .examples_gen import ExamplesGenerator
 from .architecture_gen import ArchitectureGenerator
 from .changelog_gen import ChangelogGenerator
+from .depgraph_gen import DepGraphGenerator
+from .coverage_gen import CoverageGenerator
+from .mkdocs_gen import MkDocsGenerator
+from .api_changelog_gen import ApiChangelogGenerator
 
 __all__ = [
     "ReadmeGenerator",
@@ -14,6 +18,10 @@ __all__ = [
     "ExamplesGenerator",
     "ArchitectureGenerator",
     "ChangelogGenerator",
+    "DepGraphGenerator",
+    "CoverageGenerator",
+    "MkDocsGenerator",
+    "ApiChangelogGenerator",
     "generate_docs",
 ]
 
@@ -39,4 +47,7 @@ def generate_docs(project_path: str, config=None):
     if config.docs.architecture:
         docs["architecture"] = ArchitectureGenerator(config, result).generate()
 
+    docs["dependency_graph"] = DepGraphGenerator(config, result).generate()
+    docs["coverage"] = CoverageGenerator(config, result).generate()
+
     return docs

code2docs-0.1.5/code2docs/generators/api_changelog_gen.py

@@ -0,0 +1,196 @@
+"""API changelog generator — diff function/class signatures between versions."""
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from code2llm.api import AnalysisResult
+
+from ..config import Code2DocsConfig
+
+SNAPSHOT_FILE = ".code2docs.api_snapshot.json"
+
+
+@dataclass
+class ApiChange:
+    """A single API change between two analysis snapshots."""
+    kind: str          # added, removed, changed
+    item_type: str     # function, class, method
+    name: str
+    old_signature: str = ""
+    new_signature: str = ""
+    detail: str = ""
+
+    @property
+    def emoji(self) -> str:
+        return {"added": "🆕", "removed": "🗑️", "changed": "✏️"}.get(self.kind, "•")
+
+
+class ApiChangelogGenerator:
+    """Generate API changelog by diffing current analysis with a saved snapshot."""
+
+    def __init__(self, config: Code2DocsConfig, result: AnalysisResult):
+        self.config = config
+        self.result = result
+
+    def generate(self, project_path: str) -> str:
+        """Generate api-changelog.md by comparing with previous snapshot."""
+        project = Path(project_path).resolve()
+        snapshot_path = project / SNAPSHOT_FILE
+
+        old_snapshot = self._load_snapshot(snapshot_path)
+        new_snapshot = self._build_snapshot()
+        changes = self._diff(old_snapshot, new_snapshot)
+
+        project_name = self.config.project_name or project.name
+        return self._render(project_name, changes, old_snapshot is not None)
+
+    def save_snapshot(self, project_path: str) -> None:
+        """Save current API state as snapshot for future diffs."""
+        project = Path(project_path).resolve()
+        snapshot = self._build_snapshot()
+        path = project / SNAPSHOT_FILE
+        path.write_text(json.dumps(snapshot, indent=2), encoding="utf-8")
+
+    def _build_snapshot(self) -> Dict:
+        """Build a JSON-serializable snapshot of current API."""
+        functions = {}
+        for name, func in self.result.functions.items():
+            if func.is_private:
+                continue
+            sig = f"{func.name}({', '.join(func.args)})"
+            if func.returns:
+                sig += f" → {func.returns}"
+            functions[name] = {
+                "signature": sig,
+                "is_method": func.is_method,
+                "module": func.module,
+                "docstring_hash": str(hash(func.docstring or ""))[:8],
+            }
+
+        classes = {}
+        for name, cls in self.result.classes.items():
+            classes[name] = {
+                "bases": cls.bases,
+                "methods": sorted(cls.methods),
+                "module": cls.module,
+            }
+
+        return {"functions": functions, "classes": classes}
+
+    @staticmethod
+    def _load_snapshot(path: Path) -> Optional[Dict]:
+        """Load previous snapshot, or None if not found."""
+        if not path.exists():
+            return None
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    def _diff(self, old: Optional[Dict], new: Dict) -> List[ApiChange]:
+        """Compute list of API changes between old and new snapshots."""
+        if old is None:
+            return []
+
+        changes: List[ApiChange] = []
+        self._diff_functions(old.get("functions", {}), new.get("functions", {}), changes)
+        self._diff_classes(old.get("classes", {}), new.get("classes", {}), changes)
+        return sorted(changes, key=lambda c: (c.kind, c.name))
+
+    @staticmethod
+    def _diff_functions(old: Dict, new: Dict, changes: List[ApiChange]) -> None:
+        """Diff function signatures."""
+        all_names = set(old.keys()) | set(new.keys())
+        for name in all_names:
+            old_fn = old.get(name)
+            new_fn = new.get(name)
+            item_type = "method" if (new_fn or old_fn or {}).get("is_method") else "function"
+
+            if old_fn and not new_fn:
+                changes.append(ApiChange(
+                    kind="removed", item_type=item_type, name=name,
+                    old_signature=old_fn["signature"],
+                ))
+            elif new_fn and not old_fn:
+                changes.append(ApiChange(
+                    kind="added", item_type=item_type, name=name,
+                    new_signature=new_fn["signature"],
+                ))
+            elif old_fn["signature"] != new_fn["signature"]:
+                changes.append(ApiChange(
+                    kind="changed", item_type=item_type, name=name,
+                    old_signature=old_fn["signature"],
+                    new_signature=new_fn["signature"],
+                    detail="signature changed",
+                ))
+
+    @staticmethod
+    def _diff_classes(old: Dict, new: Dict, changes: List[ApiChange]) -> None:
+        """Diff class definitions."""
+        all_names = set(old.keys()) | set(new.keys())
+        for name in all_names:
+            old_cls = old.get(name)
+            new_cls = new.get(name)
+
+            if old_cls and not new_cls:
+                changes.append(ApiChange(
+                    kind="removed", item_type="class", name=name,
+                ))
+            elif new_cls and not old_cls:
+                changes.append(ApiChange(
+                    kind="added", item_type="class", name=name,
+                ))
+            else:
+                diffs = []
+                if set(old_cls.get("bases", [])) != set(new_cls.get("bases", [])):
+                    diffs.append("bases changed")
+                old_methods = set(old_cls.get("methods", []))
+                new_methods = set(new_cls.get("methods", []))
+                added = new_methods - old_methods
+                removed = old_methods - new_methods
+                if added:
+                    diffs.append(f"added methods: {', '.join(sorted(added))}")
+                if removed:
+                    diffs.append(f"removed methods: {', '.join(sorted(removed))}")
+                if diffs:
+                    changes.append(ApiChange(
+                        kind="changed", item_type="class", name=name,
+                        detail="; ".join(diffs),
+                    ))
+
+    @staticmethod
+    def _render(project_name: str, changes: List[ApiChange], has_baseline: bool) -> str:
+        """Render changelog as Markdown."""
+        lines = [f"# {project_name} — API Changelog\n"]
+
+        if not has_baseline:
+            lines.append(
+                "> No previous API snapshot found. Run `code2docs generate` to create a baseline.\n"
+                "> Future runs will show changes here.\n"
+            )
+            return "\n".join(lines)
+
+        if not changes:
+            lines.append("✅ **No API changes detected since last snapshot.**\n")
+            return "\n".join(lines)
+
+        lines.append(f"> {len(changes)} change(s) detected\n")
+
+        # Group by kind
+        for kind_label, kind_key in [("Added", "added"), ("Changed", "changed"), ("Removed", "removed")]:
+            group = [c for c in changes if c.kind == kind_key]
+            if not group:
+                continue
+            lines.append(f"## {kind_label}\n")
+            for c in group:
+                sig = c.new_signature or c.old_signature or c.name
+                lines.append(f"- {c.emoji} **{c.item_type}** `{sig}`")
+                if c.detail:
+                    lines.append(f"  - {c.detail}")
+                if c.kind == "changed" and c.old_signature and c.new_signature:
+                    lines.append(f"  - was: `{c.old_signature}`")
+            lines.append("")
+
+        return "\n".join(lines)

code2docs-0.1.5/code2docs/generators/coverage_gen.py

@@ -0,0 +1,85 @@
+"""Docstring coverage report generator."""
+
+from typing import Dict, List
+
+from code2llm.api import AnalysisResult
+
+from ..config import Code2DocsConfig
+from ..analyzers.docstring_extractor import DocstringExtractor
+
+
+class CoverageGenerator:
+    """Generate docs/coverage.md — docstring coverage report."""
+
+    def __init__(self, config: Code2DocsConfig, result: AnalysisResult):
+        self.config = config
+        self.result = result
+        self._extractor = DocstringExtractor()
+
+    def generate(self) -> str:
+        """Generate coverage.md content."""
+        project_name = self.config.project_name or "Project"
+        report = self._extractor.coverage_report(self.result)
+
+        lines = [
+            f"# {project_name} — Docstring Coverage\n",
+            self._render_summary(report),
+            "",
+            "## Per-Module Breakdown\n",
+            self._render_per_module(),
+            "",
+            "## Undocumented Items\n",
+            self._render_undocumented(),
+            "",
+        ]
+        return "\n".join(lines)
+
+    @staticmethod
+    def _render_summary(report: Dict[str, float]) -> str:
+        """Render overall coverage summary."""
+        overall = report.get("overall_coverage", 0)
+        badge = "🟢" if overall >= 80 else "🟡" if overall >= 50 else "🔴"
+        lines = [
+            f"{badge} **Overall coverage: {overall:.1f}%**\n",
+            "| Category | Documented | Total | Coverage |",
+            "|----------|-----------|-------|----------|",
+            f"| Functions | {report['functions_documented']} | {report['functions_total']} | {report['functions_coverage']:.1f}% |",
+            f"| Classes | {report['classes_documented']} | {report['classes_total']} | {report['classes_coverage']:.1f}% |",
+        ]
+        return "\n".join(lines)
+
+    def _render_per_module(self) -> str:
+        """Render per-module coverage table."""
+        rows: List[str] = [
+            "| Module | Functions | Classes | Coverage |",
+            "|--------|-----------|---------|----------|",
+        ]
+        for mod_name in sorted(self.result.modules.keys()):
+            funcs = [f for f in self.result.functions.values()
+                     if f.module == mod_name and not f.is_method]
+            classes = [c for c in self.result.classes.values()
+                       if c.module == mod_name]
+            total = len(funcs) + len(classes)
+            documented = (sum(1 for f in funcs if f.docstring) +
+                          sum(1 for c in classes if c.docstring))
+            pct = (documented / total * 100) if total else 100.0
+            badge = "🟢" if pct >= 80 else "🟡" if pct >= 50 else "🔴"
+            rows.append(
+                f"| `{mod_name}` | {sum(1 for f in funcs if f.docstring)}/{len(funcs)} "
+                f"| {sum(1 for c in classes if c.docstring)}/{len(classes)} "
+                f"| {badge} {pct:.0f}% |"
+            )
+        return "\n".join(rows)
+
+    def _render_undocumented(self) -> str:
+        """List all undocumented public functions and classes."""
+        items: List[str] = []
+        for name, func in sorted(self.result.functions.items()):
+            if not func.docstring and not func.is_private and not func.is_method:
+                items.append(f"- `{name}` ({func.file}:{func.line})")
+        for name, cls in sorted(self.result.classes.items()):
+            if not cls.docstring:
+                items.append(f"- `{name}` ({cls.file}:{cls.line})")
+        if not items:
+            return "_All public items are documented._ ✅"
+        return "\n".join(items)

code2docs-0.1.5/code2docs/generators/depgraph_gen.py

@@ -0,0 +1,112 @@
+"""Dependency graph generator — Mermaid diagram from coupling matrix."""
+
+from typing import Dict, List, Set, Tuple
+
+from code2llm.api import AnalysisResult, ModuleInfo
+
+from ..config import Code2DocsConfig
+
+
+class DepGraphGenerator:
+    """Generate docs/dependency-graph.md with Mermaid diagrams."""
+
+    def __init__(self, config: Code2DocsConfig, result: AnalysisResult):
+        self.config = config
+        self.result = result
+
+    def generate(self) -> str:
+        """Generate dependency-graph.md content."""
+        project_name = self.config.project_name or "Project"
+        edges = self._collect_edges()
+        in_degree, out_degree = self._calc_degrees(edges)
+
+        lines = [
+            f"# {project_name} — Dependency Graph\n",
+            f"> {len(self.result.modules)} modules, "
+            f"{len(edges)} dependency edges\n",
+            "## Module Dependencies\n",
+            self._render_mermaid(edges),
+            "",
+            "## Coupling Matrix\n",
+            self._render_matrix(edges),
+            "",
+            "## Fan-in / Fan-out\n",
+            self._render_degree_table(in_degree, out_degree),
+            "",
+        ]
+        return "\n".join(lines)
+
+    def _collect_edges(self) -> List[Tuple[str, str]]:
+        """Build directed edges from module imports."""
+        edges: List[Tuple[str, str]] = []
+        module_names = set(self.result.modules.keys())
+
+        for mod_name, mod_info in self.result.modules.items():
+            for imp in mod_info.imports:
+                for other in module_names:
+                    if mod_name != other and self._import_matches(imp, other):
+                        edges.append((mod_name, other))
+        return sorted(set(edges))
+
+    @staticmethod
+    def _import_matches(imp: str, module: str) -> bool:
+        """Check if an import string refers to a known module."""
+        return imp == module or imp.startswith(module + ".")
+
+    def _render_mermaid(self, edges: List[Tuple[str, str]]) -> str:
+        """Render Mermaid graph from edges."""
+        lines = ["```mermaid", "graph LR"]
+        for src, tgt in edges:
+            s = src.split(".")[-1]
+            t = tgt.split(".")[-1]
+            lines.append(f"    {s} --> {t}")
+        if not edges:
+            lines.append("    note[No internal dependencies]")
+        lines.append("```")
+        return "\n".join(lines)
+
+    def _render_matrix(self, edges: List[Tuple[str, str]]) -> str:
+        """Render a coupling matrix as a Markdown table."""
+        mods = sorted(self.result.modules.keys())
+        if not mods:
+            return "_No modules._"
+        short = {m: m.split(".")[-1] for m in mods}
+        edge_set = set(edges)
+
+        header = "| | " + " | ".join(short[m] for m in mods) + " |"
+        sep = "| --- | " + " | ".join("---" for _ in mods) + " |"
+        rows = [header, sep]
+        for src in mods:
+            cells = []
+            for tgt in mods:
+                if src == tgt:
+                    cells.append("·")
+                elif (src, tgt) in edge_set:
+                    cells.append("→")
+                else:
+                    cells.append("")
+            rows.append(f"| **{short[src]}** | " + " | ".join(cells) + " |")
+        return "\n".join(rows)
+
+    @staticmethod
+    def _calc_degrees(edges: List[Tuple[str, str]]) -> Tuple[Dict[str, int], Dict[str, int]]:
+        """Calculate in-degree and out-degree per module."""
+        in_deg: Dict[str, int] = {}
+        out_deg: Dict[str, int] = {}
+        for src, tgt in edges:
+            out_deg[src] = out_deg.get(src, 0) + 1
+            in_deg[tgt] = in_deg.get(tgt, 0) + 1
+        return in_deg, out_deg
+
+    def _render_degree_table(self, in_deg: Dict[str, int], out_deg: Dict[str, int]) -> str:
+        """Render fan-in/fan-out table."""
+        mods = sorted(self.result.modules.keys())
+        lines = [
+            "| Module | Fan-in | Fan-out |",
+            "|--------|--------|---------|",
+        ]
+        for m in mods:
+            fi = in_deg.get(m, 0)
+            fo = out_deg.get(m, 0)
+            lines.append(f"| `{m}` | {fi} | {fo} |")
+        return "\n".join(lines)

code2docs-0.1.5/code2docs/generators/mkdocs_gen.py

@@ -0,0 +1,79 @@
+"""MkDocs configuration generator — auto-generate mkdocs.yml from docs tree."""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import yaml
+
+from code2llm.api import AnalysisResult
+
+from ..config import Code2DocsConfig
+
+
+class MkDocsGenerator:
+    """Generate mkdocs.yml from the docs/ directory structure."""
+
+    def __init__(self, config: Code2DocsConfig, result: AnalysisResult):
+        self.config = config
+        self.result = result
+
+    def generate(self, docs_dir: Optional[str] = None) -> str:
+        """Generate mkdocs.yml content."""
+        project_name = self.config.project_name or "Project"
+        nav = self._build_nav(docs_dir)
+
+        data = {
+            "site_name": f"{project_name} Documentation",
+            "theme": {"name": "material"},
+            "nav": nav,
+            "markdown_extensions": [
+                "admonition",
+                "pymdownx.highlight",
+                "pymdownx.superfences",
+                {"pymdownx.superfences": {
+                    "custom_fences": [{
+                        "name": "mermaid",
+                        "class": "mermaid",
+                        "format": "!!python/name:pymdownx.superfences.fence_code_format",
+                    }]
+                }},
+            ],
+        }
+        return yaml.dump(data, default_flow_style=False, sort_keys=False)
+
+    def _build_nav(self, docs_dir: Optional[str] = None) -> List:
+        """Build navigation structure from docs tree and analysis."""
+        nav: List = [{"Home": "index.md"}]
+
+        if self.config.docs.architecture:
+            nav.append({"Architecture": "architecture.md"})
+
+        # API reference
+        if self.config.docs.api_reference:
+            api_items = [{"Overview": "api/index.md"}]
+            for mod_name in sorted(self.result.modules.keys()):
+                safe = mod_name.replace(".", "_").replace("/", "_")
+                api_items.append({mod_name: f"api/module_{safe}.md"})
+            nav.append({"API Reference": api_items})
+
+        # Module docs
+        if self.config.docs.module_docs:
+            mod_items = []
+            for mod_name in sorted(self.result.modules.keys()):
+                safe = mod_name.replace(".", "_").replace("/", "_")
+                mod_items.append({mod_name: f"modules/{safe}.md"})
+            if mod_items:
+                nav.append({"Modules": mod_items})
+
+        # Extra pages
+        nav.append({"Dependency Graph": "dependency-graph.md"})
+        nav.append({"Coverage": "coverage.md"})
+
+        if self.config.docs.changelog:
+            nav.append({"Changelog": "changelog.md"})
+
+        return nav
+
+    def write(self, output_path: str, content: str) -> None:
+        """Write mkdocs.yml file."""
+        Path(output_path).write_text(content, encoding="utf-8")

code2docs-0.1.5/code2docs/templates/module_doc.md.j2

@@ -0,0 +1,86 @@
+# {{ module_name }}
+
+> Source: `{{ module_info.file }}`{% if file_lines %} | {{ file_lines }} lines{% endif %}{% if avg_cc %} | CC avg: {{ avg_cc }}{% endif %}
+
+{% if module_docstring %}
+## Overview
+
+{{ module_docstring }}
+{% endif %}
+
+{% if classes %}
+## Classes
+
+{% for cls_name, cls_info in classes.items() %}
+### {{ cls_info.name }}
+
+{% if cls_info.bases %}
+*Bases:* {% for b in cls_info.bases %}`{{ b }}`{% if not loop.last %}, {% endif %}{% endfor %}
+
+{% endif %}
+{% if cls_info.docstring %}
+{{ cls_info.docstring }}
+
+{% endif %}
+{% if methods[cls_name] %}
+#### Methods
+
+| Method | Args | Returns | CC |
+|--------|------|---------|----|
+{% for m in methods[cls_name] %}
+{% set args = m.args[:4]|join(', ') %}
+{% set ret = m.returns or '—' %}
+{% set cc = m.complexity.get('cyclomatic', '—') %}
+| `{{ m.name }}` | `{{ args }}` | `{{ ret }}` | {{ cc }} |
+{% endfor %}
+
+{% endif %}
+{% endfor %}
+{% endif %}
+
+{% if functions %}
+## Functions
+
+{% for func_name, func_info in functions.items() %}
+{% set args = func_info.args|join(', ') %}
+{% set ret = ' → ' ~ func_info.returns if func_info.returns else '' %}
+### `{{ func_info.name }}({{ args }}){{ ret }}`
+
+{% if func_info.docstring %}
+{{ func_info.docstring }}
+
+{% endif %}
+{% if func_info.calls %}
+**Calls:** {% for c in func_info.calls[:10] %}`{{ c }}`{% if not loop.last %}, {% endif %}{% endfor %}
+
+{% endif %}
+{% endfor %}
+{% endif %}
+
+{% if imports %}
+## Dependencies
+
+{% if internal_imports %}
+**Internal imports:**
+{% for imp in internal_imports %}
+- `{{ imp }}`
+{% endfor %}
+{% endif %}
+
+{% if stdlib_imports %}
+**Standard library:**
+{% for imp in stdlib_imports %}
+- `{{ imp }}`
+{% endfor %}
+{% endif %}
+{% endif %}
+
+{% if metrics %}
+## Metrics
+
+| Metric | Value |
+|--------|-------|
+{% for k, v in metrics.items() %}
+| {{ k }} | {{ v }} |
+{% endfor %}
+{% endif %}

{code2docs-0.1.3 → code2docs-0.1.5}/code2docs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2docs
-Version: 0.1.3
+Version: 0.1.5
 Summary: Auto-generate and sync project documentation from source code analysis
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -40,7 +40,7 @@ Dynamic: license-file
 
 # code2docs
 
-![version](https://img.shields.io/badge/version-0.1.3-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![docs](https://img.shields.io/badge/docs-auto--generated-blueviolet)
+![version](https://img.shields.io/badge/version-0.1.5-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![docs](https://img.shields.io/badge/docs-auto--generated-blueviolet)
 
 > Auto-generate and sync project documentation from source code analysis.
 

{code2docs-0.1.3 → code2docs-0.1.5}/code2docs.egg-info/SOURCES.txt

@@ -21,10 +21,14 @@ code2docs/formatters/badges.py
 code2docs/formatters/markdown.py
 code2docs/formatters/toc.py
 code2docs/generators/__init__.py
+code2docs/generators/api_changelog_gen.py
 code2docs/generators/api_reference_gen.py
 code2docs/generators/architecture_gen.py
 code2docs/generators/changelog_gen.py
+code2docs/generators/coverage_gen.py
+code2docs/generators/depgraph_gen.py
 code2docs/generators/examples_gen.py
+code2docs/generators/mkdocs_gen.py
 code2docs/generators/module_docs_gen.py
 code2docs/generators/readme_gen.py
 code2docs/sync/__init__.py
@@ -35,6 +39,7 @@ code2docs/templates/api_module.md.j2
 code2docs/templates/architecture.md.j2
 code2docs/templates/example_usage.py.j2
 code2docs/templates/index.md.j2
+code2docs/templates/module_doc.md.j2
 code2docs/templates/readme.md.j2
 tests/test_analyzers.py
 tests/test_code2docs.py

{code2docs-0.1.3 → code2docs-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code2docs"
-version = "0.1.3"
+version = "0.1.5"
 description = "Auto-generate and sync project documentation from source code analysis"
 readme = "README.md"
 requires-python = ">=3.9"