code2docs 3.0.4__tar.gz → 3.0.6__tar.gz

{code2docs-3.0.4 → code2docs-3.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2docs
-Version: 3.0.4
+Version: 3.0.6
 Summary: Auto-generate and sync project documentation from source code analysis
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -50,7 +50,7 @@ Dynamic: license-file
 
 # code2docs
 
-![version](https://img.shields.io/badge/version-3.0.4-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-3.0.6-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.
 
@@ -190,7 +190,7 @@ code2docs can update only specific sections of an existing README using markers:
 ```markdown
 <!-- code2docs:start --># code2docs
 
-![version](https://img.shields.io/badge/version-3.0.4-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![coverage](https://img.shields.io/badge/coverage-unknown-lightgrey) ![functions](https://img.shields.io/badge/functions-276-green)
+![version](https://img.shields.io/badge/version-3.0.6-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![coverage](https://img.shields.io/badge/coverage-unknown-lightgrey) ![functions](https://img.shields.io/badge/functions-276-green)
 > **276** functions | **57** classes | **51** files | CC̄ = 3.8
 
 > Auto-generated project documentation from source code analysis.

{code2docs-3.0.4 → code2docs-3.0.6}/README.md

@@ -1,6 +1,6 @@
 # code2docs
 
-![version](https://img.shields.io/badge/version-3.0.4-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-3.0.6-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.
 
@@ -140,7 +140,7 @@ code2docs can update only specific sections of an existing README using markers:
 ```markdown
 <!-- code2docs:start --># code2docs
 
-![version](https://img.shields.io/badge/version-3.0.4-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![coverage](https://img.shields.io/badge/coverage-unknown-lightgrey) ![functions](https://img.shields.io/badge/functions-276-green)
+![version](https://img.shields.io/badge/version-3.0.6-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![coverage](https://img.shields.io/badge/coverage-unknown-lightgrey) ![functions](https://img.shields.io/badge/functions-276-green)
 > **276** functions | **57** classes | **51** files | CC̄ = 3.8
 
 > Auto-generated project documentation from source code analysis.

{code2docs-3.0.4 → code2docs-3.0.6}/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__ = "3.0.4"
+__version__ = "3.0.6"
 __author__ = "Tom Sapletta"
 
 from .config import Code2DocsConfig

{code2docs-3.0.4 → code2docs-3.0.6}/code2docs/cli.py

@@ -40,8 +40,9 @@ def main():
 @click.option("--dry-run", is_flag=True, help="Show what would be generated without writing")
 @click.option("--llm", "llm_model", default=None,
               help="Enable LLM-assisted generation (e.g. openai/gpt-4o-mini, ollama/llama3)")
+@click.option("--org-name", default=None, help="Organization name for org-mode README generation")
 def generate(project_path, config_path, readme_only, sections, output, verbose, dry_run,
-             llm_model):
+             llm_model, org_name):
     """Generate documentation (default command)."""
     config = _load_config(project_path, config_path)
     if verbose:
@@ -53,6 +54,8 @@ def generate(project_path, config_path, readme_only, sections, output, verbose,
     if llm_model:
         config.llm.enabled = True
         config.llm.model = llm_model
+    if org_name:
+        config.org_name = org_name
 
     _run_generate(project_path, config, readme_only=readme_only, dry_run=dry_run)
 

{code2docs-3.0.4 → code2docs-3.0.6}/code2docs/config.py

@@ -108,6 +108,7 @@ class Code2DocsConfig:
     output: str = "./docs/"
     readme_output: str = "./README.md"
     repo_url: str = ""  # GitHub/GitLab URL for source links (auto-detected from git)
+    org_name: str = ""  # Organization name for org-mode README generation
 
     readme: ReadmeConfig = field(default_factory=ReadmeConfig)
     docs: DocsConfig = field(default_factory=DocsConfig)

{code2docs-3.0.4 → code2docs-3.0.6}/code2docs/generators/_registry_adapters.py

@@ -240,6 +240,35 @@ class Code2LlmAdapter(BaseGenerator):
         return "⚠️ project/ (no files generated)"
 
 
+class OrgReadmeAdapter(BaseGenerator):
+    """Adapter for organization README generation."""
+    name = "org_readme"
+
+    def should_run(self, *, readme_only: bool = False) -> bool:
+        # Only run if org_name is set in config
+        return hasattr(self.config, 'org_name') and bool(self.config.org_name)
+
+    def run(self, ctx: GenerateContext) -> Optional[str]:
+        from .org_readme_gen import OrgReadmeGenerator
+        
+        org_name = getattr(self.config, 'org_name', '')
+        if not org_name:
+            return None
+            
+        gen = OrgReadmeGenerator(self.config, str(ctx.project), org_name)
+        content = gen.generate()
+        
+        if ctx.dry_run:
+            click.echo(f"\n--- {org_name} README ({len(content)} chars) ---")
+            preview = content[:500] + "..." if len(content) > 500 else content
+            click.echo(preview)
+            return None
+        
+        readme_path = ctx.docs_dir / "README.md"
+        gen.write(str(readme_path), content)
+        return f"✅ {readme_path.relative_to(ctx.project)}"
+
+
 ALL_ADAPTERS = [
     ReadmeGeneratorAdapter,
     ApiReferenceAdapter,
@@ -254,4 +283,5 @@ ALL_ADAPTERS = [
     ContributingAdapter,
     MkDocsAdapter,
     Code2LlmAdapter,
+    OrgReadmeAdapter,
 ]

code2docs-3.0.6/code2docs/generators/org_readme_gen.py

@@ -0,0 +1,227 @@
+"""Organization README generator - generates overview of multiple projects."""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from code2llm.api import AnalysisResult
+
+from ..config import Code2DocsConfig
+from ..analyzers.project_scanner import ProjectScanner
+
+
+class OrgReadmeGenerator:
+    """Generate organization README with list of projects and brief descriptions."""
+
+    def __init__(self, config: Code2DocsConfig, org_path: str, org_name: str = ""):
+        self.config = config
+        self.org_path = Path(org_path).resolve()
+        self.org_name = org_name or self.org_path.name
+        self.scanner = ProjectScanner(config)
+
+    def generate(self) -> str:
+        """Generate organization README content."""
+        projects = self._discover_projects()
+        
+        lines = [
+            f"# {self.org_name}\n",
+            f"Projects in the {self.org_name} organization.\n",
+            f"**{len(projects)}** projects discovered.\n",
+            "## Projects\n",
+        ]
+        
+        for project_name, project_info in sorted(projects.items()):
+            lines.append(self._render_project_section(project_name, project_info))
+            lines.append("")
+        
+        return "\n".join(lines)
+
+    def _discover_projects(self) -> Dict[str, Dict]:
+        """Discover all projects in organization directory."""
+        projects = {}
+        
+        for item in self.org_path.iterdir():
+            if not item.is_dir():
+                continue
+            if item.name.startswith(".") or item.name.startswith("__"):
+                continue
+            
+            project_info = self._analyze_project(item)
+            if project_info:
+                projects[item.name] = project_info
+        
+        return projects
+
+    def _analyze_project(self, project_path: Path) -> Optional[Dict]:
+        """Analyze a single project and return summary info."""
+        try:
+            result = self.scanner.analyze(str(project_path))
+            
+            # Extract description from first module docstring or pyproject.toml
+            description = self._extract_description(project_path, result)
+            
+            # Count functions, classes, modules
+            func_count = len(result.functions)
+            class_count = len(result.classes)
+            module_count = len(result.modules)
+            
+            # Get version from pyproject.toml if available
+            version = self._get_version(project_path)
+            
+            # Get repo URL from git or config
+            repo_url = self._get_repo_url(project_path)
+            
+            return {
+                "name": project_path.name,
+                "description": description,
+                "version": version,
+                "stats": {
+                    "functions": func_count,
+                    "classes": class_count,
+                    "modules": module_count,
+                },
+                "repo_url": repo_url,
+                "path": str(project_path),
+            }
+        except Exception:
+            return None
+
+    def _extract_description(self, project_path: Path, result: AnalysisResult) -> str:
+        """Extract short description from project (max 5 lines)."""
+        # Try pyproject.toml first
+        try:
+            import tomllib
+            pyproject = project_path / "pyproject.toml"
+            if pyproject.exists():
+                with open(pyproject, "rb") as f:
+                    data = tomllib.load(f)
+                    desc = data.get("project", {}).get("description", "")
+                    if desc:
+                        # Limit to ~5 lines worth of content
+                        return self._truncate_description(desc)
+        except Exception:
+            pass
+        
+        # Try first package docstring
+        for mod in result.modules.values():
+            if mod.is_package and hasattr(mod, "docstring") and mod.docstring:
+                return self._truncate_description(mod.docstring)
+        
+        # Try README.md first paragraph
+        readme = project_path / "README.md"
+        if readme.exists():
+            try:
+                content = readme.read_text(encoding="utf-8")
+                # Find first paragraph after title
+                lines = content.split("\n")
+                for i, line in enumerate(lines):
+                    if line.startswith("# "):
+                        # Get next non-empty lines
+                        desc_lines = []
+                        for j in range(i + 1, min(i + 10, len(lines))):
+                            if lines[j].strip() and not lines[j].startswith("#"):
+                                desc_lines.append(lines[j].strip())
+                            if len(desc_lines) >= 5:
+                                break
+                        if desc_lines:
+                            return " ".join(desc_lines)
+            except Exception:
+                pass
+        
+        return "No description available."
+
+    def _truncate_description(self, desc: str, max_chars: int = 300) -> str:
+        """Truncate description to ~5 lines of content."""
+        lines = desc.strip().split("\n")
+        # Filter out empty lines and headers
+        content_lines = [l.strip() for l in lines if l.strip() and not l.startswith("#")]
+        
+        result = []
+        char_count = 0
+        for line in content_lines[:5]:
+            if char_count + len(line) > max_chars:
+                remaining = max_chars - char_count
+                if remaining > 20:
+                    result.append(line[:remaining] + "...")
+                break
+            result.append(line)
+            char_count += len(line)
+        
+        return " ".join(result) if result else "No description available."
+
+    def _get_version(self, project_path: Path) -> str:
+        """Get version from pyproject.toml or VERSION file."""
+        try:
+            import tomllib
+            pyproject = project_path / "pyproject.toml"
+            if pyproject.exists():
+                with open(pyproject, "rb") as f:
+                    data = tomllib.load(f)
+                    return data.get("project", {}).get("version", "")
+        except Exception:
+            pass
+        
+        version_file = project_path / "VERSION"
+        if version_file.exists():
+            return version_file.read_text(encoding="utf-8").strip()
+        
+        return ""
+
+    def _get_repo_url(self, project_path: Path) -> str:
+        """Get repository URL from git or pyproject.toml."""
+        # Try pyproject.toml
+        try:
+            import tomllib
+            pyproject = project_path / "pyproject.toml"
+            if pyproject.exists():
+                with open(pyproject, "rb") as f:
+                    data = tomllib.load(f)
+                    urls = data.get("project", {}).get("urls", {})
+                    if urls:
+                        return urls.get("Repository", urls.get("Homepage", ""))
+        except Exception:
+            pass
+        
+        # Try git remote
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["git", "remote", "get-url", "origin"],
+                cwd=str(project_path),
+                capture_output=True, text=True, timeout=5,
+            )
+            if result.returncode == 0:
+                url = result.stdout.strip()
+                # Convert SSH to HTTPS
+                if url.startswith("git@"):
+                    url = url.replace(":", "/", 1).replace("git@", "https://", 1)
+                return url.removesuffix(".git")
+        except Exception:
+            pass
+        
+        return ""
+
+    def _render_project_section(self, name: str, info: Dict) -> str:
+        """Render a single project section (5 lines max)."""
+        lines = [f"### {name}"]
+        
+        # Line 1: Description
+        lines.append(info["description"])
+        
+        # Line 2: Stats
+        stats = info["stats"]
+        stats_line = f"📊 {stats['functions']} functions | {stats['classes']} classes | {stats['modules']} modules"
+        if info["version"]:
+            stats_line += f" | v{info['version']}"
+        lines.append(stats_line)
+        
+        # Line 3: Repo link if available
+        if info["repo_url"]:
+            lines.append(f"🔗 [{info['repo_url']}]({info['repo_url']})")
+        
+        return "\n".join(lines)
+
+    def write(self, output_path: str, content: str) -> None:
+        """Write README to output path."""
+        out_path = Path(output_path)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(content, encoding="utf-8")

{code2docs-3.0.4 → code2docs-3.0.6}/code2docs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2docs
-Version: 3.0.4
+Version: 3.0.6
 Summary: Auto-generate and sync project documentation from source code analysis
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -50,7 +50,7 @@ Dynamic: license-file
 
 # code2docs
 
-![version](https://img.shields.io/badge/version-3.0.4-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-3.0.6-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.
 
@@ -190,7 +190,7 @@ code2docs can update only specific sections of an existing README using markers:
 ```markdown
 <!-- code2docs:start --># code2docs
 
-![version](https://img.shields.io/badge/version-3.0.4-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![coverage](https://img.shields.io/badge/coverage-unknown-lightgrey) ![functions](https://img.shields.io/badge/functions-276-green)
+![version](https://img.shields.io/badge/version-3.0.6-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![coverage](https://img.shields.io/badge/coverage-unknown-lightgrey) ![functions](https://img.shields.io/badge/functions-276-green)
 > **276** functions | **57** classes | **51** files | CC̄ = 3.8
 
 > Auto-generated project documentation from source code analysis.

{code2docs-3.0.4 → code2docs-3.0.6}/code2docs.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ code2docs/generators/examples_gen.py
 code2docs/generators/getting_started_gen.py
 code2docs/generators/mkdocs_gen.py
 code2docs/generators/module_docs_gen.py
+code2docs/generators/org_readme_gen.py
 code2docs/generators/readme_gen.py
 code2docs/sync/__init__.py
 code2docs/sync/differ.py

{code2docs-3.0.4 → code2docs-3.0.6}/pyproject.toml

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

code2docs-3.0.6/tests/test_cli.py

@@ -0,0 +1,287 @@
+"""CLI smoke tests using Click's CliRunner and subprocess e2e tests."""
+
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+from code2docs.cli import main
+
+
+class TestCLI:
+    """Unit tests using Click's CliRunner."""
+
+    def setup_method(self):
+        self.runner = CliRunner()
+
+    def test_help(self):
+        result = self.runner.invoke(main, ["--help"])
+        assert result.exit_code == 0
+        assert "code2docs" in result.output
+        assert "generate" in result.output
+        assert "sync" in result.output
+        assert "init" in result.output
+
+    def test_generate_help(self):
+        result = self.runner.invoke(main, ["generate", "--help"])
+        assert result.exit_code == 0
+        assert "--readme-only" in result.output
+        assert "--dry-run" in result.output
+        assert "--verbose" in result.output
+
+    def test_sync_help(self):
+        result = self.runner.invoke(main, ["sync", "--help"])
+        assert result.exit_code == 0
+        assert "Synchronize" in result.output
+
+    def test_init_creates_config(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            result = self.runner.invoke(main, ["init", tmpdir])
+            assert result.exit_code == 0
+            assert (Path(tmpdir) / "code2docs.yaml").exists()
+
+    def test_generate_dry_run(self):
+        result = self.runner.invoke(main, [".", "--dry-run"])
+        assert result.exit_code == 0
+        assert "code2docs" in result.output
+        assert "README.md" in result.output
+        assert "dry-run" in result.output
+        assert "Done!" in result.output
+
+    def test_readme_only_dry_run(self):
+        result = self.runner.invoke(main, [".", "--readme-only", "--dry-run"])
+        assert result.exit_code == 0
+        assert "README.md" in result.output
+        # Should NOT have docs/api since --readme-only
+        assert "docs/api" not in result.output
+
+    def test_default_group_routes_path(self):
+        """Ensure bare path argument is routed to generate."""
+        result = self.runner.invoke(main, [".", "--dry-run"])
+        assert result.exit_code == 0
+        assert "Done!" in result.output
+
+    def test_verbose(self):
+        result = self.runner.invoke(main, [".", "--verbose", "--dry-run"])
+        assert result.exit_code == 0
+        assert "Functions" in result.output
+        assert "Classes" in result.output
+        assert "Modules" in result.output
+
+    def test_check_help(self):
+        result = self.runner.invoke(main, ["check", "--help"])
+        assert result.exit_code == 0
+        assert "Health check" in result.output
+        assert "--target" in result.output
+
+    def test_check_runs(self):
+        result = self.runner.invoke(main, ["check", "."])
+        assert result.exit_code == 0
+        assert "check" in result.output
+        assert "Score:" in result.output
+
+    def test_diff_help(self):
+        result = self.runner.invoke(main, ["diff", "--help"])
+        assert result.exit_code == 0
+        assert "Preview" in result.output
+
+    def test_diff_runs(self):
+        result = self.runner.invoke(main, ["diff", "."])
+        assert result.exit_code == 0
+        assert "diff" in result.output
+        assert "dry-run" in result.output
+
+
+class TestCLIShellE2E:
+    """E2E tests using actual shell subprocess calls."""
+
+    @pytest.fixture
+    def temp_project(self):
+        """Create a temporary project with Python files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            project_dir = Path(tmpdir) / "test_project"
+            project_dir.mkdir()
+
+            # Create a simple Python package
+            pkg_dir = project_dir / "my_pkg"
+            pkg_dir.mkdir()
+            (pkg_dir / "__init__.py").write_text('"""My package."""\n')
+            (pkg_dir / "module.py").write_text(
+                '"""A module."""\n\ndef hello():\n    """Say hello."""\n    return "Hello"\n'
+            )
+
+            # Create pyproject.toml
+            (project_dir / "pyproject.toml").write_text(
+                '[project]\nname = "test-project"\nversion = "0.1.0"\n'
+            )
+
+            yield project_dir
+
+    def _run_shell(self, cmd: list, cwd: Path = None) -> subprocess.CompletedProcess:
+        """Run command in shell and return result."""
+        return subprocess.run(
+            cmd,
+            cwd=str(cwd) if cwd else None,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+    def test_shell_generate(self, temp_project):
+        """E2E: Generate docs via shell."""
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", str(temp_project), "--dry-run"],
+        )
+        assert result.returncode == 0
+        assert "code2docs" in result.stdout
+
+    def test_shell_generate_creates_files(self, temp_project):
+        """E2E: Generate actually creates output files."""
+        output_dir = temp_project / "docs_output"
+
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", str(temp_project),
+             "--output", str(output_dir)],
+            cwd=temp_project,
+        )
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        assert "Done!" in result.stdout
+
+        # Check files were created
+        assert (temp_project / "README.md").exists()
+
+    def test_shell_init(self, temp_project):
+        """E2E: Init command creates config file."""
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", "init", str(temp_project)],
+        )
+        assert result.returncode == 0
+        assert (temp_project / "code2docs.yaml").exists()
+
+    def test_shell_check(self, temp_project):
+        """E2E: Check command runs successfully."""
+        # First generate some docs
+        self._run_shell(
+            [sys.executable, "-m", "code2docs", str(temp_project)],
+            cwd=temp_project,
+        )
+
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", "check", str(temp_project)],
+        )
+        assert result.returncode == 0
+        assert "Health" in result.stdout or "check" in result.stdout
+        assert "Score:" in result.stdout
+
+    def test_shell_diff(self, temp_project):
+        """E2E: Diff command runs successfully."""
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", "diff", str(temp_project)],
+        )
+        assert result.returncode == 0
+        assert "diff" in result.stdout.lower()
+
+    def test_shell_help(self):
+        """E2E: Help command works."""
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", "--help"],
+        )
+        assert result.returncode == 0
+        assert "code2docs" in result.stdout
+        assert "generate" in result.stdout
+
+    def test_shell_generate_with_sections(self, temp_project):
+        """E2E: Generate with --sections option."""
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", str(temp_project),
+             "--sections", "overview,install", "--dry-run"],
+            cwd=temp_project,
+        )
+        assert result.returncode == 0
+
+    def test_shell_version(self):
+        """E2E: Check version output."""
+        result = self._run_shell(
+            [sys.executable, "-c", "import code2docs; print(code2docs.__version__)"],
+        )
+        assert result.returncode == 0
+        assert "." in result.stdout.strip()
+
+
+class TestCLINewFeaturesE2E:
+    """E2E tests for new CLI features (--org-name)."""
+
+    @pytest.fixture
+    def temp_org(self):
+        """Create a temporary organization with multiple projects."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            org_dir = Path(tmpdir) / "test_org"
+            org_dir.mkdir()
+
+            # Create project 1
+            proj1 = org_dir / "project1"
+            proj1.mkdir()
+            (proj1 / "pyproject.toml").write_text(
+                '[project]\nname = "project1"\nversion = "0.1.0"\n'
+                'description = "First project"\n'
+            )
+            pkg1 = proj1 / "pkg1"
+            pkg1.mkdir()
+            (pkg1 / "__init__.py").write_text('"""Package 1."""\n')
+
+            # Create project 2
+            proj2 = org_dir / "project2"
+            proj2.mkdir()
+            (proj2 / "pyproject.toml").write_text(
+                '[project]\nname = "project2"\nversion = "0.2.0"\n'
+                'description = "Second project"\n'
+            )
+            pkg2 = proj2 / "pkg2"
+            pkg2.mkdir()
+            (pkg2 / "__init__.py").write_text('"""Package 2."""\n')
+
+            yield org_dir
+
+    def _run_shell(self, cmd: list, cwd: Path = None) -> subprocess.CompletedProcess:
+        """Run command in shell and return result."""
+        return subprocess.run(
+            cmd,
+            cwd=str(cwd) if cwd else None,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+    def test_shell_org_mode(self, temp_org):
+        """E2E: Generate organization README with --org-name."""
+        output_dir = temp_org / "articles"
+
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", str(temp_org),
+             "--output", str(output_dir),
+             "--org-name", "TestOrg"],
+            cwd=temp_org,
+        )
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        assert "Done!" in result.stdout
+
+        # Check org README was created
+        org_readme = output_dir / "README.md"
+        assert org_readme.exists(), f"Files in {output_dir}: {list(output_dir.iterdir())}"
+
+        content = org_readme.read_text()
+        assert "TestOrg" in content
+        assert "project1" in content
+        assert "project2" in content
+
+    def test_shell_org_mode_dry_run(self, temp_org):
+        """E2E: Organization mode dry run."""
+        result = self._run_shell(
+            [sys.executable, "-m", "code2docs", str(temp_org),
+             "--org-name", "TestOrg", "--dry-run"],
+        )
+        assert result.returncode == 0
+        assert "TestOrg" in result.stdout or "dry-run" in result.stdout

code2docs-3.0.4/tests/test_cli.py

@@ -1,90 +0,0 @@
-"""CLI smoke tests using Click's CliRunner."""
-
-import tempfile
-from pathlib import Path
-
-from click.testing import CliRunner
-
-from code2docs.cli import main
-
-
-class TestCLI:
-    def setup_method(self):
-        self.runner = CliRunner()
-
-    def test_help(self):
-        result = self.runner.invoke(main, ["--help"])
-        assert result.exit_code == 0
-        assert "code2docs" in result.output
-        assert "generate" in result.output
-        assert "sync" in result.output
-        assert "init" in result.output
-
-    def test_generate_help(self):
-        result = self.runner.invoke(main, ["generate", "--help"])
-        assert result.exit_code == 0
-        assert "--readme-only" in result.output
-        assert "--dry-run" in result.output
-        assert "--verbose" in result.output
-
-    def test_sync_help(self):
-        result = self.runner.invoke(main, ["sync", "--help"])
-        assert result.exit_code == 0
-        assert "Synchronize" in result.output
-
-    def test_init_creates_config(self):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            result = self.runner.invoke(main, ["init", tmpdir])
-            assert result.exit_code == 0
-            assert (Path(tmpdir) / "code2docs.yaml").exists()
-
-    def test_generate_dry_run(self):
-        result = self.runner.invoke(main, [".", "--dry-run"])
-        assert result.exit_code == 0
-        assert "code2docs" in result.output
-        assert "README.md" in result.output
-        assert "dry-run" in result.output
-        assert "Done!" in result.output
-
-    def test_readme_only_dry_run(self):
-        result = self.runner.invoke(main, [".", "--readme-only", "--dry-run"])
-        assert result.exit_code == 0
-        assert "README.md" in result.output
-        # Should NOT have docs/api since --readme-only
-        assert "docs/api" not in result.output
-
-    def test_default_group_routes_path(self):
-        """Ensure bare path argument is routed to generate."""
-        result = self.runner.invoke(main, [".", "--dry-run"])
-        assert result.exit_code == 0
-        assert "Done!" in result.output
-
-    def test_verbose(self):
-        result = self.runner.invoke(main, [".", "--verbose", "--dry-run"])
-        assert result.exit_code == 0
-        assert "Functions" in result.output
-        assert "Classes" in result.output
-        assert "Modules" in result.output
-
-    def test_check_help(self):
-        result = self.runner.invoke(main, ["check", "--help"])
-        assert result.exit_code == 0
-        assert "Health check" in result.output
-        assert "--target" in result.output
-
-    def test_check_runs(self):
-        result = self.runner.invoke(main, ["check", "."])
-        assert result.exit_code == 0
-        assert "check" in result.output
-        assert "Score:" in result.output
-
-    def test_diff_help(self):
-        result = self.runner.invoke(main, ["diff", "--help"])
-        assert result.exit_code == 0
-        assert "Preview" in result.output
-
-    def test_diff_runs(self):
-        result = self.runner.invoke(main, ["diff", "."])
-        assert result.exit_code == 0
-        assert "diff" in result.output
-        assert "dry-run" in result.output