code2docs 0.1.2__tar.gz → 0.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2docs
-Version: 0.1.2
+Version: 0.1.3
 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.2-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.3-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.2 → code2docs-0.1.3}/README.md

@@ -1,6 +1,6 @@
 # code2docs
 
-![version](https://img.shields.io/badge/version-0.1.2-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.3-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.2 → code2docs-0.1.3}/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.2"
+__version__ = "0.1.3"
 __author__ = "Tom Sapletta"
 
 from .config import Code2DocsConfig

{code2docs-0.1.2 → code2docs-0.1.3}/code2docs/analyzers/docstring_extractor.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
-from code2llm.core.models import AnalysisResult, FunctionInfo, ClassInfo
+from code2llm.api import AnalysisResult, FunctionInfo, ClassInfo
 
 
 @dataclass
@@ -38,44 +38,53 @@ class DocstringExtractor:
         return docs
 
     def parse(self, docstring: str) -> DocstringInfo:
-        """Parse a docstring into structured sections."""
+        """Parse a docstring into structured sections (orchestrator)."""
         if not docstring:
             return DocstringInfo(raw="")
 
         lines = docstring.strip().splitlines()
         info = DocstringInfo(raw=docstring)
+        info.summary = self._extract_summary(lines)
+        self._parse_sections(lines[1:], info)
+        return info
 
-        if lines:
-            info.summary = lines[0].strip()
-
-        # Simple parser for Google/Numpy/Sphinx styles
+    @staticmethod
+    def _extract_summary(lines: List[str]) -> str:
+        """Extract the first-line summary."""
+        return lines[0].strip() if lines else ""
+
+    @staticmethod
+    def _classify_section(line: str) -> Optional[str]:
+        """Classify a line as a section header, or return None."""
+        lower = line.strip().lower()
+        if lower.startswith(("args:", "parameters:", "params:")):
+            return "params"
+        if lower.startswith(("returns:", "return:")):
+            return "returns"
+        if lower.startswith(("raises:", "raise:")):
+            return "raises"
+        if lower.startswith(("example:", "examples:", ">>>")):
+            return "examples"
+        return None
+
+    def _parse_sections(self, lines: List[str], info: DocstringInfo) -> None:
+        """Walk remaining lines, dispatching content to the right section."""
         current_section = "description"
         desc_lines: List[str] = []
-        param_lines: List[Tuple[str, str]] = []
 
-        for line in lines[1:]:
+        for line in lines:
             stripped = line.strip()
-            lower = stripped.lower()
 
-            if lower.startswith(("args:", "parameters:", "params:")):
-                current_section = "params"
-                continue
-            elif lower.startswith(("returns:", "return:")):
-                current_section = "returns"
-                continue
-            elif lower.startswith(("raises:", "raise:")):
-                current_section = "raises"
-                continue
-            elif lower.startswith(("example:", "examples:", ">>>")):
-                current_section = "examples"
-                if stripped.startswith(">>>"):
+            new_section = self._classify_section(stripped)
+            if new_section is not None:
+                current_section = new_section
+                if current_section == "examples" and stripped.startswith(">>>"):
                     info.examples.append(stripped)
                 continue
 
             if current_section == "description":
                 desc_lines.append(stripped)
             elif current_section == "params" and stripped:
-                # Parse "name: description" or "name (type): description"
                 if ":" in stripped:
                     pname, pdesc = stripped.split(":", 1)
                     info.params[pname.strip()] = pdesc.strip()
@@ -87,7 +96,6 @@ class DocstringExtractor:
                 info.examples.append(stripped)
 
         info.description = "\n".join(desc_lines).strip()
-        return info
 
     def coverage_report(self, result: AnalysisResult) -> Dict[str, float]:
         """Calculate docstring coverage statistics."""

{code2docs-0.1.2 → code2docs-0.1.3}/code2docs/analyzers/endpoint_detector.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from code2llm.core.models import AnalysisResult, FunctionInfo
+from code2llm.api import AnalysisResult, FunctionInfo
 
 
 @dataclass

{code2docs-0.1.2 → code2docs-0.1.3}/code2docs/analyzers/project_scanner.py

@@ -3,9 +3,7 @@
 from pathlib import Path
 from typing import Optional
 
-from code2llm import Config, FAST_CONFIG
-from code2llm.core.analyzer import ProjectAnalyzer
-from code2llm.core.models import AnalysisResult
+from code2llm.api import Config, FAST_CONFIG, AnalysisResult, analyze
 
 from ..config import Code2DocsConfig
 
@@ -35,8 +33,7 @@ class ProjectScanner:
 
     def analyze(self, project_path: str) -> AnalysisResult:
         """Analyze a project and return AnalysisResult for doc generation."""
-        analyzer = ProjectAnalyzer(self._llm_config)
-        return analyzer.analyze_project(project_path)
+        return analyze(project_path, self._llm_config)
 
 
 def analyze_and_document(project_path: str, config: Optional[Code2DocsConfig] = None) -> AnalysisResult:

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

@@ -9,7 +9,23 @@ import click
 from .config import Code2DocsConfig
 
 
-@click.group(invoke_without_command=True)
+class DefaultGroup(click.Group):
+    """Click Group that routes unknown subcommands to 'generate'."""
+
+    def parse_args(self, ctx, args):
+        if not args:
+            args = ["generate"]
+        elif args[0] not in self.commands and args[0] not in ("--help", "-h"):
+            args = ["generate"] + args
+        return super().parse_args(ctx, args)
+
+
+@click.group(cls=DefaultGroup)
+def main():
+    """code2docs — Auto-generate project documentation from source code."""
+
+
+@main.command()
 @click.argument("project_path", default=".", type=click.Path(exists=True))
 @click.option("--config", "-c", "config_path", default=None, help="Path to code2docs.yaml")
 @click.option("--readme-only", is_flag=True, help="Generate only README.md")
@@ -17,21 +33,8 @@ from .config import Code2DocsConfig
 @click.option("--output", "-o", default=None, help="Output directory for docs")
 @click.option("--verbose", "-v", is_flag=True, help="Verbose output")
 @click.option("--dry-run", is_flag=True, help="Show what would be generated without writing")
-@click.pass_context
-def main(ctx, project_path, config_path, readme_only, sections, output, verbose, dry_run):
-    """code2docs — Auto-generate project documentation from source code.
-
-    Analyzes PROJECT_PATH using code2llm and generates human-readable documentation.
-    """
-    if ctx.invoked_subcommand is not None:
-        ctx.ensure_object(dict)
-        ctx.obj["project_path"] = project_path
-        ctx.obj["config_path"] = config_path
-        ctx.obj["verbose"] = verbose
-        ctx.obj["dry_run"] = dry_run
-        return
-
-    # Default action: full generation
+def generate(project_path, config_path, readme_only, sections, output, verbose, dry_run):
+    """Generate documentation (default command)."""
     config = _load_config(project_path, config_path)
     if verbose:
         config.verbose = True

{code2docs-0.1.2 → code2docs-0.1.3}/code2docs/generators/api_reference_gen.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional
 
 from jinja2 import Environment, PackageLoader, select_autoescape
 
-from code2llm.core.models import AnalysisResult, FunctionInfo, ClassInfo, ModuleInfo
+from code2llm.api import AnalysisResult, FunctionInfo, ClassInfo, ModuleInfo
 
 from ..config import Code2DocsConfig
 
@@ -61,67 +61,79 @@ class ApiReferenceGenerator:
         return "\n".join(lines) + "\n"
 
     def _generate_module_api(self, mod_name: str, mod_info: ModuleInfo) -> str:
-        """Generate API reference for a single module."""
-        lines = [f"# `{mod_name}`\n"]
+        """Generate API reference for a single module (orchestrator)."""
+        parts: List[str] = [
+            self._render_api_header(mod_name, mod_info),
+            self._render_api_classes(mod_name),
+            self._render_api_functions(mod_name),
+            self._render_api_imports(mod_info),
+        ]
+        return "\n".join(p for p in parts if p)
 
-        # Source info
-        lines.append(f"> Source: `{mod_info.file}`\n")
+    def _render_api_header(self, mod_name: str, mod_info: ModuleInfo) -> str:
+        """Render module header with source info."""
+        return f"# `{mod_name}`\n\n> Source: `{mod_info.file}`\n"
 
-        # Classes in this module
+    def _render_api_classes(self, mod_name: str) -> str:
+        """Render classes with their method signatures."""
         module_classes = {
             k: v for k, v in self.result.classes.items()
             if v.module == mod_name or k.startswith(mod_name + ".")
         }
-        if module_classes:
-            lines.append("## Classes\n")
-            for cls_name, cls_info in sorted(module_classes.items()):
-                lines.append(f"### `{cls_info.name}`\n")
-                if cls_info.bases:
-                    lines.append(f"Inherits from: {', '.join(f'`{b}`' for b in cls_info.bases)}\n")
-                if cls_info.docstring:
-                    lines.append(f"{cls_info.docstring.strip()}\n")
-
-                # Methods of this class
-                methods = self._get_class_methods(cls_info)
-                if methods:
-                    lines.append("#### Methods\n")
-                    for method in methods:
-                        sig = self._format_signature(method)
-                        doc_line = ""
-                        if method.docstring:
-                            doc_line = f" — {method.docstring.splitlines()[0]}"
-                        cc = method.complexity.get("cyclomatic", 0)
-                        cc_badge = f" ⚠️ CC={cc}" if cc > 10 else ""
-                        lines.append(f"- `{sig}`{doc_line}{cc_badge}")
-                    lines.append("")
-
-        # Standalone functions in this module
+        if not module_classes:
+            return ""
+        lines = ["## Classes\n"]
+        for cls_name, cls_info in sorted(module_classes.items()):
+            lines.append(f"### `{cls_info.name}`\n")
+            if cls_info.bases:
+                lines.append(f"Inherits from: {', '.join(f'`{b}`' for b in cls_info.bases)}\n")
+            if cls_info.docstring:
+                lines.append(f"{cls_info.docstring.strip()}\n")
+            methods = self._get_class_methods(cls_info)
+            if methods:
+                lines.append("#### Methods\n")
+                for method in methods:
+                    sig = self._format_signature(method)
+                    doc_line = ""
+                    if method.docstring:
+                        doc_line = f" — {method.docstring.splitlines()[0]}"
+                    cc = method.complexity.get("cyclomatic", 0)
+                    cc_badge = f" ⚠️ CC={cc}" if cc > 10 else ""
+                    lines.append(f"- `{sig}`{doc_line}{cc_badge}")
+                lines.append("")
+        return "\n".join(lines)
+
+    def _render_api_functions(self, mod_name: str) -> str:
+        """Render standalone functions with signatures and complexity."""
         module_functions = {
             k: v for k, v in self.result.functions.items()
             if (v.module == mod_name or k.startswith(mod_name + "."))
             and not v.is_method
         }
-        if module_functions:
-            lines.append("## Functions\n")
-            for func_name, func_info in sorted(module_functions.items()):
-                sig = self._format_signature(func_info)
-                lines.append(f"### `{sig}`\n")
-                if func_info.docstring:
-                    lines.append(f"{func_info.docstring.strip()}\n")
-                cc = func_info.complexity.get("cyclomatic", 0)
-                if cc:
-                    lines.append(f"- Complexity: {cc}")
-                if func_info.calls:
-                    lines.append(f"- Calls: {', '.join(f'`{c}`' for c in func_info.calls[:10])}")
-                lines.append("")
-
-        # Imports
-        if mod_info.imports:
-            lines.append("## Imports\n")
-            for imp in sorted(mod_info.imports):
-                lines.append(f"- `{imp}`")
+        if not module_functions:
+            return ""
+        lines = ["## Functions\n"]
+        for func_name, func_info in sorted(module_functions.items()):
+            sig = self._format_signature(func_info)
+            lines.append(f"### `{sig}`\n")
+            if func_info.docstring:
+                lines.append(f"{func_info.docstring.strip()}\n")
+            cc = func_info.complexity.get("cyclomatic", 0)
+            if cc:
+                lines.append(f"- Complexity: {cc}")
+            if func_info.calls:
+                lines.append(f"- Calls: {', '.join(f'`{c}`' for c in func_info.calls[:10])}")
             lines.append("")
+        return "\n".join(lines)
 
+    def _render_api_imports(self, mod_info: ModuleInfo) -> str:
+        """Render module imports list."""
+        if not mod_info.imports:
+            return ""
+        lines = ["## Imports\n"]
+        for imp in sorted(mod_info.imports):
+            lines.append(f"- `{imp}`")
+        lines.append("")
         return "\n".join(lines)
 
     def _get_class_methods(self, cls_info: ClassInfo) -> List[FunctionInfo]:

{code2docs-0.1.2 → code2docs-0.1.3}/code2docs/generators/architecture_gen.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 from typing import Dict, List, Set
 
-from code2llm.core.models import AnalysisResult, ModuleInfo
+from code2llm.api import AnalysisResult, ModuleInfo
 
 from ..config import Code2DocsConfig
 

{code2docs-0.1.2 → code2docs-0.1.3}/code2docs/generators/changelog_gen.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from code2llm.core.models import AnalysisResult
+from code2llm.api import AnalysisResult
 
 from ..config import Code2DocsConfig
 

{code2docs-0.1.2 → code2docs-0.1.3}/code2docs/generators/examples_gen.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 from typing import Dict, List
 
-from code2llm.core.models import AnalysisResult, FunctionInfo, ClassInfo
+from code2llm.api import AnalysisResult, FunctionInfo, ClassInfo
 
 from ..config import Code2DocsConfig
 
@@ -34,70 +34,74 @@ class ExamplesGenerator:
         return files
 
     def _generate_basic_usage(self) -> str:
-        """Generate basic_usage.py example."""
+        """Generate basic_usage.py example (orchestrator)."""
         project_name = self.config.project_name or Path(self.result.project_path).name
-        lines: List[str] = [
-            f'"""Basic usage of {project_name}."""',
-            "",
-        ]
-
-        # Find importable public classes and functions
-        public_classes = [
-            c for c in self.result.classes.values()
-            if not c.name.startswith("_")
-        ]
+        public_classes = [c for c in self.result.classes.values() if not c.name.startswith("_")]
         public_functions = [
             f for f in self.result.functions.values()
             if not f.is_private and not f.is_method and not f.name.startswith("_")
         ]
 
-        # Generate import statements
+        sections = [
+            f'"""Basic usage of {project_name}."""',
+            "",
+            self._generate_import_section(project_name, public_classes, public_functions),
+            "",
+            self._generate_class_usage_section(public_classes),
+            self._generate_function_usage_section(public_functions),
+            "",
+        ]
+        return "\n".join(s for s in sections if s is not None)
+
+    def _generate_import_section(self, project_name: str,
+                                 public_classes: List[ClassInfo],
+                                 public_functions: List[FunctionInfo]) -> str:
+        """Generate import statements for the example."""
+        lines: List[str] = []
         imported = set()
         for cls in public_classes[:5]:
             mod = cls.module or project_name
             lines.append(f"from {mod} import {cls.name}")
             imported.add(cls.name)
-
         for func in public_functions[:5]:
             if func.name not in imported:
                 mod = func.module or project_name
                 lines.append(f"from {mod} import {func.name}")
                 imported.add(func.name)
-
         if not imported:
             lines.append(f"import {project_name}")
+        return "\n".join(lines)
 
+    def _generate_class_usage_section(self, public_classes: List[ClassInfo]) -> str:
+        """Generate class instantiation and method call examples."""
+        if not public_classes:
+            return ""
+        lines: List[str] = []
+        cls = public_classes[0]
+        lines.append(f"# Create {cls.name} instance")
+        init_args = self._get_init_args(cls)
+        if init_args:
+            args_str = ", ".join(f"{a}=..." for a in init_args[:3])
+            lines.append(f"obj = {cls.name}({args_str})")
+        else:
+            lines.append(f"obj = {cls.name}()")
         lines.append("")
-        lines.append("")
-
-        # Generate usage examples
-        if public_classes:
-            cls = public_classes[0]
-            lines.append(f"# Create {cls.name} instance")
-            init_args = self._get_init_args(cls)
-            if init_args:
-                args_str = ", ".join(f"{a}=..." for a in init_args[:3])
-                lines.append(f"obj = {cls.name}({args_str})")
-            else:
-                lines.append(f"obj = {cls.name}()")
-            lines.append("")
-
-            # Show method calls
-            methods = self._get_public_methods(cls)
-            for method in methods[:3]:
-                args_str = ", ".join(f"{a}=..." for a in method.args if a != "self")
-                ret_comment = f"  # → {method.returns}" if method.returns else ""
-                lines.append(f"result = obj.{method.name}({args_str}){ret_comment}")
-
-        if public_functions:
-            lines.append("")
-            lines.append("# Standalone functions")
-            for func in public_functions[:5]:
-                args_str = ", ".join(f"{a}=..." for a in func.args[:4])
-                ret_comment = f"  # → {func.returns}" if func.returns else ""
-                lines.append(f"result = {func.name}({args_str}){ret_comment}")
+        methods = self._get_public_methods(cls)
+        for method in methods[:3]:
+            args_str = ", ".join(f"{a}=..." for a in method.args if a != "self")
+            ret_comment = f"  # → {method.returns}" if method.returns else ""
+            lines.append(f"result = obj.{method.name}({args_str}){ret_comment}")
+        return "\n".join(lines)
 
-        lines.append("")
+    def _generate_function_usage_section(self, public_functions: List[FunctionInfo]) -> str:
+        """Generate standalone function call examples."""
+        if not public_functions:
+            return ""
+        lines = ["", "# Standalone functions"]
+        for func in public_functions[:5]:
+            args_str = ", ".join(f"{a}=..." for a in func.args[:4])
+            ret_comment = f"  # → {func.returns}" if func.returns else ""
+            lines.append(f"result = {func.name}({args_str}){ret_comment}")
         return "\n".join(lines)
 
     def _generate_entry_point_examples(self) -> str: