docforge-gen 0.1.0__tar.gz

docforge_gen-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+dist/
+*.egg-info/
+.eggs/
+.env
+.venv
+venv/
+env/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+htmlcov/
+.coverage
+*.log
+docs/
+.docforge_tmp/

docforge_gen-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DocForge Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

docforge_gen-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: docforge-gen
+Version: 0.1.0
+Summary: Automatically generate documentation for any GitHub repository using LLMs
+Project-URL: Homepage, https://github.com/your-org/docforge
+Project-URL: Repository, https://github.com/your-org/docforge
+Project-URL: Issues, https://github.com/your-org/docforge/issues
+License: MIT License
+        
+        Copyright (c) 2026 DocForge Contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: cli,code-analysis,documentation,llm,tree-sitter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.11
+Requires-Dist: gitpython>=3.1.40
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: litellm>=1.52.0
+Requires-Dist: pydantic>=2.8.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: tenacity>=9.0.0
+Requires-Dist: tiktoken>=0.7.0
+Requires-Dist: tree-sitter-go>=0.23.0
+Requires-Dist: tree-sitter-java>=0.23.0
+Requires-Dist: tree-sitter-javascript>=0.23.0
+Requires-Dist: tree-sitter-python>=0.23.0
+Requires-Dist: tree-sitter-rust>=0.23.0
+Requires-Dist: tree-sitter-typescript>=0.23.0
+Requires-Dist: tree-sitter>=0.23.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: coverage>=7.5.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.14.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: mkdocs
+Requires-Dist: mkdocs-material>=9.5.0; extra == 'mkdocs'
+Requires-Dist: mkdocs>=1.6.0; extra == 'mkdocs'
+Description-Content-Type: text/markdown
+
+# DocForge
+
+AI-powered documentation generator for any GitHub repository or local project.
+
+## Quick Start
+
+```bash
+pip install docforge
+
+# From GitHub URL
+docforge generate https://github.com/user/repo
+
+# From local path
+docforge generate ./my-project
+
+# With Ollama (local, free)
+docforge generate ./my-project --model ollama/llama3 --api-base http://localhost:11434
+```
+
+## What it generates
+
+- `README.md` — Comprehensive project overview
+- `INSTALLATION.md` — Setup and installation guide
+- `ARCHITECTURE.md` — System architecture with Mermaid diagrams
+- `CHANGELOG.md` — Formatted changelog from git history
+- `api/*.md` — Per-module API reference docs
+- `mkdocs.yml` — Optional MkDocs site config (`--mkdocs`)
+- `.github/workflows/auto-docs.yml` — Optional GitHub Action (`--github-action`)
+
+## Supported Languages
+
+Python, JavaScript, TypeScript, Go, Rust, Java
+
+## Supported LLM Providers
+
+- **OpenAI** (default): `--model gpt-4o`
+- **Anthropic Claude**: `--model claude-sonnet-4-6`
+- **Ollama (local)**: `--model ollama/llama3 --api-base http://localhost:11434`
+- Any provider supported by [LiteLLM](https://docs.litellm.ai)
+
+## License
+
+MIT

docforge_gen-0.1.0/README.md

@@ -0,0 +1,43 @@
+# DocForge
+
+AI-powered documentation generator for any GitHub repository or local project.
+
+## Quick Start
+
+```bash
+pip install docforge
+
+# From GitHub URL
+docforge generate https://github.com/user/repo
+
+# From local path
+docforge generate ./my-project
+
+# With Ollama (local, free)
+docforge generate ./my-project --model ollama/llama3 --api-base http://localhost:11434
+```
+
+## What it generates
+
+- `README.md` — Comprehensive project overview
+- `INSTALLATION.md` — Setup and installation guide
+- `ARCHITECTURE.md` — System architecture with Mermaid diagrams
+- `CHANGELOG.md` — Formatted changelog from git history
+- `api/*.md` — Per-module API reference docs
+- `mkdocs.yml` — Optional MkDocs site config (`--mkdocs`)
+- `.github/workflows/auto-docs.yml` — Optional GitHub Action (`--github-action`)
+
+## Supported Languages
+
+Python, JavaScript, TypeScript, Go, Rust, Java
+
+## Supported LLM Providers
+
+- **OpenAI** (default): `--model gpt-4o`
+- **Anthropic Claude**: `--model claude-sonnet-4-6`
+- **Ollama (local)**: `--model ollama/llama3 --api-base http://localhost:11434`
+- Any provider supported by [LiteLLM](https://docs.litellm.ai)
+
+## License
+
+MIT

docforge_gen-0.1.0/docforge/__init__.py

@@ -0,0 +1,3 @@
+"""DocForge - Automatically generate documentation for any GitHub repository using LLMs."""
+
+__version__ = "0.1.0"

docforge_gen-0.1.0/docforge/analysis/__init__.py

@@ -0,0 +1,5 @@
+from .context_builder import RepoContext, CommitGroup, build_context
+from .repo_analyzer import analyze_repo
+from .dependency_detector import detect_dependencies
+
+__all__ = ["RepoContext", "CommitGroup", "build_context", "analyze_repo", "detect_dependencies"]

docforge_gen-0.1.0/docforge/analysis/context_builder.py

@@ -0,0 +1,131 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from ..parsing.base_parser import ParsedFile
+
+
+@dataclass
+class CommitGroup:
+    tag: str  # "v1.2.0" or "Unreleased"
+    date: str
+    commits: list[dict] = field(default_factory=list)
+
+
+@dataclass
+class RepoContext:
+    name: str
+    description: str
+    primary_language: str
+    languages: list[str]
+    file_tree: list[str]
+    parsed_files: list[ParsedFile]
+    dependencies: dict[str, list[str]]
+    commit_groups: list[CommitGroup]
+    github_url: str | None = None
+    topics: list[str] = field(default_factory=list)
+    license: str | None = None
+    has_tests: bool = False
+    has_ci: bool = False
+    entry_points: list[str] = field(default_factory=list)
+
+
+def build_context(
+    repo_path: Path,
+    parsed_files: list[ParsedFile],
+    dependencies: dict[str, list[str]],
+    commit_groups: list[CommitGroup],
+    gh_metadata: dict | None = None,
+) -> RepoContext:
+    gh = gh_metadata or {}
+
+    name = gh.get("name") or repo_path.name
+    description = gh.get("description") or _infer_description(parsed_files, repo_path)
+    languages = _detect_languages(parsed_files)
+    primary_language = languages[0] if languages else "unknown"
+    file_tree = _build_file_tree(repo_path, parsed_files)
+    has_tests = _has_tests(repo_path)
+    has_ci = _has_ci(repo_path)
+    entry_points = _find_entry_points(repo_path, parsed_files)
+
+    return RepoContext(
+        name=name,
+        description=description,
+        primary_language=primary_language,
+        languages=languages,
+        file_tree=file_tree,
+        parsed_files=parsed_files,
+        dependencies=dependencies,
+        commit_groups=commit_groups,
+        github_url=gh.get("html_url"),
+        topics=gh.get("topics", []),
+        license=gh.get("license", {}).get("name") if gh.get("license") else None,
+        has_tests=has_tests,
+        has_ci=has_ci,
+        entry_points=entry_points,
+    )
+
+
+def _detect_languages(parsed_files: list[ParsedFile]) -> list[str]:
+    counts: dict[str, int] = {}
+    for f in parsed_files:
+        counts[f.language] = counts.get(f.language, 0) + 1
+    return sorted(counts, key=lambda k: counts[k], reverse=True)
+
+
+def _build_file_tree(repo_path: Path, parsed_files: list[ParsedFile]) -> list[str]:
+    paths = []
+    for f in parsed_files:
+        try:
+            rel = Path(f.path).relative_to(repo_path)
+            paths.append(str(rel))
+        except ValueError:
+            paths.append(f.path)
+    return sorted(paths)
+
+
+def _infer_description(parsed_files: list[ParsedFile], repo_path: Path) -> str:
+    # Try to read existing README for description
+    for readme_name in ["README.md", "README.rst", "README.txt", "README"]:
+        readme = repo_path / readme_name
+        if readme.exists():
+            try:
+                content = readme.read_text(errors="replace")
+                lines = [l.strip() for l in content.splitlines() if l.strip()]
+                # Find first non-heading line
+                for line in lines:
+                    if not line.startswith("#") and len(line) > 20:
+                        return line[:200]
+            except Exception:
+                pass
+    return "A software project"
+
+
+def _has_tests(repo_path: Path) -> bool:
+    test_indicators = ["tests/", "test/", "spec/", "__tests__/", "test_*.py", "*_test.go"]
+    for indicator in test_indicators:
+        if list(repo_path.glob(f"**/{indicator}")):
+            return True
+    return False
+
+
+def _has_ci(repo_path: Path) -> bool:
+    ci_paths = [
+        ".github/workflows",
+        ".gitlab-ci.yml",
+        ".circleci/config.yml",
+        "Jenkinsfile",
+        ".travis.yml",
+    ]
+    for ci_path in ci_paths:
+        if (repo_path / ci_path).exists():
+            return True
+    return False
+
+
+def _find_entry_points(repo_path: Path, parsed_files: list[ParsedFile]) -> list[str]:
+    entry_points = []
+    candidates = ["main.py", "app.py", "cli.py", "main.go", "main.rs", "index.js", "index.ts"]
+    for candidate in candidates:
+        if (repo_path / candidate).exists():
+            entry_points.append(candidate)
+    return entry_points

docforge_gen-0.1.0/docforge/analysis/dependency_detector.py

@@ -0,0 +1,120 @@
+import json
+import tomllib
+from pathlib import Path
+
+
+def detect_dependencies(repo_path: Path) -> dict[str, list[str]]:
+    """Read manifest files and return dependencies per language/ecosystem."""
+    deps: dict[str, list[str]] = {}
+
+    # Python
+    py_deps = _detect_python(repo_path)
+    if py_deps:
+        deps["python"] = py_deps
+
+    # JavaScript/TypeScript
+    js_deps = _detect_javascript(repo_path)
+    if js_deps:
+        deps["javascript"] = js_deps
+
+    # Go
+    go_deps = _detect_go(repo_path)
+    if go_deps:
+        deps["go"] = go_deps
+
+    # Rust
+    rust_deps = _detect_rust(repo_path)
+    if rust_deps:
+        deps["rust"] = rust_deps
+
+    # Java
+    java_deps = _detect_java(repo_path)
+    if java_deps:
+        deps["java"] = java_deps
+
+    return deps
+
+
+def _detect_python(repo_path: Path) -> list[str]:
+    deps = []
+
+    pyproject = repo_path / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            with open(pyproject, "rb") as f:
+                data = tomllib.load(f)
+            deps += data.get("project", {}).get("dependencies", [])
+        except Exception:
+            pass
+
+    requirements = repo_path / "requirements.txt"
+    if requirements.exists():
+        try:
+            lines = requirements.read_text().splitlines()
+            deps += [l.strip() for l in lines if l.strip() and not l.startswith("#")]
+        except Exception:
+            pass
+
+    return deps
+
+
+def _detect_javascript(repo_path: Path) -> list[str]:
+    package_json = repo_path / "package.json"
+    if not package_json.exists():
+        return []
+    try:
+        data = json.loads(package_json.read_text())
+        deps = list(data.get("dependencies", {}).keys())
+        deps += list(data.get("devDependencies", {}).keys())
+        return deps
+    except Exception:
+        return []
+
+
+def _detect_go(repo_path: Path) -> list[str]:
+    go_mod = repo_path / "go.mod"
+    if not go_mod.exists():
+        return []
+    deps = []
+    try:
+        for line in go_mod.read_text().splitlines():
+            line = line.strip()
+            if line.startswith("require ") or (line and not line.startswith("//") and " v" in line):
+                parts = line.split()
+                if len(parts) >= 2 and "/" in parts[0]:
+                    deps.append(parts[0])
+    except Exception:
+        pass
+    return deps
+
+
+def _detect_rust(repo_path: Path) -> list[str]:
+    cargo_toml = repo_path / "Cargo.toml"
+    if not cargo_toml.exists():
+        return []
+    try:
+        with open(cargo_toml, "rb") as f:
+            data = tomllib.load(f)
+        deps = list(data.get("dependencies", {}).keys())
+        deps += list(data.get("dev-dependencies", {}).keys())
+        return deps
+    except Exception:
+        return []
+
+
+def _detect_java(repo_path: Path) -> list[str]:
+    # Basic pom.xml detection
+    pom = repo_path / "pom.xml"
+    if pom.exists():
+        try:
+            content = pom.read_text()
+            # Very basic extraction - just flag that Maven is used
+            return ["[Maven - see pom.xml]"]
+        except Exception:
+            pass
+
+    build_gradle = repo_path / "build.gradle"
+    if build_gradle.exists():
+        return ["[Gradle - see build.gradle]"]
+
+    return []

docforge_gen-0.1.0/docforge/analysis/file_walker.py

@@ -0,0 +1,63 @@
+import fnmatch
+from pathlib import Path
+
+
+BINARY_EXTENSIONS = {
+    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".svg",
+    ".pdf", ".zip", ".tar", ".gz", ".bz2", ".xz", ".rar",
+    ".exe", ".dll", ".so", ".dylib", ".a", ".o",
+    ".woff", ".woff2", ".ttf", ".eot",
+    ".mp3", ".mp4", ".wav", ".avi", ".mov",
+    ".db", ".sqlite", ".lock",
+}
+
+
+def walk_repo(
+    repo_path: Path,
+    exclude_patterns: list[str],
+    max_file_size_kb: int = 512,
+    supported_extensions: list[str] | None = None,
+):
+    """
+    Yield (file_path, extension) for all code files in repo_path.
+    Respects exclude patterns and size limits.
+    """
+    max_bytes = max_file_size_kb * 1024
+
+    for file_path in sorted(repo_path.rglob("*")):
+        if not file_path.is_file():
+            continue
+
+        # Check binary extension
+        if file_path.suffix.lower() in BINARY_EXTENSIONS:
+            continue
+
+        # Check exclude patterns
+        relative = str(file_path.relative_to(repo_path))
+        if _is_excluded(relative, exclude_patterns):
+            continue
+
+        # Check supported extension
+        ext = file_path.suffix.lower()
+        if supported_extensions and ext not in supported_extensions:
+            continue
+
+        # Check file size
+        try:
+            if file_path.stat().st_size > max_bytes:
+                continue
+        except OSError:
+            continue
+
+        yield file_path, ext
+
+
+def _is_excluded(relative_path: str, patterns: list[str]) -> bool:
+    for pattern in patterns:
+        if fnmatch.fnmatch(relative_path, pattern):
+            return True
+        # Also match path components
+        parts = relative_path.replace("\\", "/")
+        if fnmatch.fnmatch(parts, pattern):
+            return True
+    return False

docforge_gen-0.1.0/docforge/analysis/repo_analyzer.py

@@ -0,0 +1,53 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+
+from ..config.schema import DocForgeConfig
+from ..parsing.base_parser import ParsedFile
+from ..parsing.registry import get_parser, supported_extensions
+from .file_walker import walk_repo
+
+
+def analyze_repo(repo_path: Path, config: DocForgeConfig) -> list[ParsedFile]:
+    """Parse all code files in repo_path and return ParsedFile list."""
+    exts = supported_extensions()
+    files_to_parse = list(walk_repo(
+        repo_path,
+        exclude_patterns=config.exclude_patterns,
+        max_file_size_kb=config.max_file_size_kb,
+        supported_extensions=exts,
+    ))
+
+    parsed: list[ParsedFile] = []
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]Parsing files..."),
+        BarColumn(),
+        TaskProgressColumn(),
+        transient=True,
+    ) as progress:
+        task = progress.add_task("parsing", total=len(files_to_parse))
+
+        def parse_file(args):
+            file_path, ext = args
+            parser = get_parser(ext)
+            if parser is None:
+                return None
+            try:
+                source = file_path.read_bytes()
+                return parser.parse(file_path, source)
+            except Exception:
+                return None
+            finally:
+                progress.advance(task)
+
+        with ThreadPoolExecutor(max_workers=8) as executor:
+            futures = {executor.submit(parse_file, item): item for item in files_to_parse}
+            for future in as_completed(futures):
+                result = future.result()
+                if result is not None:
+                    parsed.append(result)
+
+    return parsed

docforge_gen-0.1.0/docforge/cli/__init__.py

@@ -0,0 +1,3 @@
+from docforge import __version__
+
+__all__ = ["__version__"]

docforge_gen-0.1.0/docforge/cli/app.py

@@ -0,0 +1,29 @@
+import typer
+from . import __version__
+from .commands.generate import generate
+
+app = typer.Typer(
+    name="docforge",
+    help="AI-powered documentation generator for any GitHub repository.",
+    add_completion=False,
+    rich_markup_mode="rich",
+)
+
+app.command(name="generate", help="Generate documentation for a repo.")(generate)
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(f"DocForge v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main_callback(
+    version: bool = typer.Option(None, "--version", "-v", callback=version_callback, is_eager=True),
+):
+    pass
+
+
+def main():
+    app()