toolbelt-cli 0.2.0__py3-none-any.whl

toolbelt/__init__.py

@@ -0,0 +1,4 @@
+"""Toolbelt CLI package."""
+
+__version__ = "0.2.0"
+__all__ = ["__version__"]

toolbelt/cli.py

@@ -0,0 +1,46 @@
+"""Entry point for the Toolbelt CLI using Typer."""
+
+from __future__ import annotations
+
+import typer
+
+from .commands import audit, commit, new, version
+
+app = typer.Typer(
+    name="toolbelt",
+    help=(
+        "Toolbelt – developer productivity CLI: scaffolding, AI commits, and audits."
+    ),
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+# Explicitly register subcommands with designated names
+app.command(
+    name="new",
+    help="Scaffold a new project (python, node, java) with opinionated defaults.",
+)(new.main)
+
+app.command(
+    name="commit",
+    help="Generate Conventional Commit messages from diff using Claude API.",
+)(commit.main)
+
+app.command(
+    name="audit",
+    help="Audit repo for README sections, .gitignore, licenses, and CI.",
+)(audit.main)
+
+app.command(
+    name="version",
+    help="Print installed version and check PyPI for updates.",
+)(version.main)
+
+
+def main() -> None:
+    """Run the Toolbelt CLI application."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

toolbelt/commands/__init__.py

@@ -0,0 +1 @@
+"""Toolbelt command modules."""

toolbelt/commands/audit.py

@@ -0,0 +1,63 @@
+"""Implementation of `toolbelt audit [path]` command."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+from rich import box
+from rich.table import Table
+
+from ..services.auditor import Auditor
+from ..utils.console import get_console
+
+
+def main(
+    path: str = typer.Argument(".", help="Path to repository to audit."),
+    json_output: bool = typer.Option(
+        False, "--json", help="Output machine-readable JSON."
+    ),
+    fix: bool = typer.Option(
+        False, "--fix", help="Auto-create missing .gitignore and LICENSE."
+    ),
+) -> None:
+    """Audit repo for README sections, .gitignore, licenses, and CI."""
+    console = get_console()
+    repo_path = Path(path).resolve()
+
+    if not repo_path.exists() or not repo_path.is_dir():
+        console.print(f"[bold red]Error:[/bold red] Invalid directory: {path}")
+        raise typer.Exit(code=1)
+
+    auditor = Auditor(repo_path, console=console)
+    results = auditor.run(fix=fix)
+
+    if json_output:
+        data = [r.to_dict() for r in results]
+        console.print(json.dumps(data, indent=2))
+    else:
+        table = Table(
+            title=f"Repository Audit: {repo_path.name}",
+            box=box.ROUNDED,
+            show_header=True,
+            header_style="bold cyan",
+        )
+        table.add_column("Check", style="bold white", min_width=25)
+        table.add_column("Status", justify="center", width=8)
+        table.add_column("Details", style="dim white")
+
+        for res in results:
+            status_symbol = (
+                "[bold green]✅[/bold green]"
+                if res.passed
+                else "[bold red]❌[/bold red]"
+            )
+            table.add_row(res.name, status_symbol, res.details)
+
+        console.print(table)
+
+    all_passed = all(r.passed for r in results)
+    if not all_passed:
+        raise typer.Exit(code=1)
+    raise typer.Exit(code=0)

toolbelt/commands/commit.py

@@ -0,0 +1,84 @@
+"""Implementation of `toolbelt commit` command."""
+
+from __future__ import annotations
+
+import typer
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+from ..services.llm import CommitMessageGenerator
+from ..utils.console import get_console
+from ..utils.git import git_commit, git_diff_staged
+
+
+def main(
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Print proposed commit message without committing."
+    ),
+    commit_type: str | None = typer.Option(
+        None, "--type", "-t", help="Force commit type (feat, fix, docs, etc.)."
+    ),
+    scope: str | None = typer.Option(None, "--scope", "-s", help="Force commit scope."),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation prompt and commit immediately."
+    ),
+) -> None:
+    """Generate Conventional Commit message from staged diff using Claude."""
+    console = get_console()
+
+    try:
+        diff = git_diff_staged()
+    except Exception as exc:
+        console.print(f"[bold red]Git error:[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    if not diff or not diff.strip():
+        console.print("[bold red]Nothing staged. Run git add first.[/bold red]")
+        raise typer.Exit(code=1)
+
+    generator = CommitMessageGenerator()
+    message = generator.generate(diff, commit_type=commit_type, scope=scope)
+
+    if len(message.strip()) < 10:
+        console.print(
+            "[bold red]Commit message too short (< 10 chars); aborting.[/bold red]"
+        )
+        raise typer.Exit(code=1)
+
+    console.print(Panel(message, title="Proposed Commit Message", border_style="cyan"))
+
+    if dry_run:
+        console.print("[green]Dry run – commit not performed.[/green]")
+        raise typer.Exit(code=0)
+
+    if not yes:
+        choice = (
+            Prompt.ask(
+                "Apply commit? [y/n/edit]",
+                choices=["y", "n", "edit", "e"],
+                default="y",
+            )
+            .strip()
+            .lower()
+        )
+
+        if choice in {"n", "no"}:
+            console.print("[yellow]Commit aborted by user.[/yellow]")
+            raise typer.Exit(code=1)
+
+        if choice in {"edit", "e"}:
+            edited = Prompt.ask("Edit message", default=message).strip()
+            if len(edited) < 10:
+                console.print(
+                    "[bold red]Commit message too short (< 10 chars).[/bold red]"
+                )
+                raise typer.Exit(code=1)
+            message = edited
+
+    try:
+        git_commit(message)
+    except Exception as exc:
+        console.print(f"[bold red]Commit failed:[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    console.print("[bold green]✅ Commit created successfully![/bold green]")

toolbelt/commands/new.py

@@ -0,0 +1,116 @@
+"""Implementation of `toolbelt new <type> <name>` command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich import box
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from ..services.scaffolder import Scaffolder
+from ..utils.console import get_console
+from ..utils.git import get_git_user_name
+
+
+def main(
+    project_type: str = typer.Argument(..., help="Project type: python, node, java"),
+    name: str = typer.Argument(..., help="Project directory / package name"),
+    author: str | None = typer.Option(None, "--author", "-a", help="Author name"),
+    license_choice: str | None = typer.Option(
+        None, "--license", "-l", help="License: MIT, Apache-2.0, none"
+    ),
+    ci: bool | None = typer.Option(
+        None, "--ci/--no-ci", help="Include CI configuration"
+    ),
+    docker: bool | None = typer.Option(
+        None, "--docker/--no-docker", help="Include Dockerfile"
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Accept all defaults without prompting"
+    ),
+) -> None:
+    """Scaffold a new Python, Node, or Java project with opinionated structure."""
+    console = get_console()
+    normalized_type = project_type.strip().lower()
+
+    if normalized_type not in {"python", "node", "java"}:
+        console.print(
+            f"[bold red]Error:[/bold red] Unsupported project type '{project_type}'. "
+            "Choose from: python, node, java."
+        )
+        raise typer.Exit(code=1)
+
+    target_dir = Path(name).resolve()
+    if target_dir.exists() and any(target_dir.iterdir()):
+        console.print(
+            f"[bold red]Error:[/bold red] Target directory '{name}' "
+            "already exists and is not empty."
+        )
+        raise typer.Exit(code=1)
+
+    # Interactive prompts (or flag values / defaults)
+    default_author = get_git_user_name() or "Developer"
+    if author is None:
+        if yes:
+            author = default_author
+        else:
+            author = Prompt.ask("Author name", default=default_author)
+
+    if license_choice is None:
+        if yes:
+            license_choice = "MIT"
+        else:
+            license_choice = Prompt.ask(
+                "License",
+                choices=["MIT", "Apache-2.0", "none"],
+                default="MIT",
+            )
+    elif license_choice not in {"MIT", "Apache-2.0", "none"}:
+        console.print(
+            f"[bold red]Error:[/bold red] Invalid license '{license_choice}'. "
+            "Choose MIT, Apache-2.0, or none."
+        )
+        raise typer.Exit(code=1)
+
+    if ci is None:
+        if yes:
+            ci = True
+        else:
+            ci = Confirm.ask("Include CI? (y/n)", default=True)
+
+    if docker is None:
+        if yes:
+            docker = False
+        else:
+            docker = Confirm.ask("Include Docker? (y/n)", default=False)
+
+    scaffolder = Scaffolder(
+        project_type=normalized_type,
+        project_name=target_dir.name,
+        author=author,
+        license=license_choice,
+        include_ci=ci,
+        include_docker=docker,
+        destination=target_dir,
+    )
+    scaffolder.run()
+
+    if normalized_type == "python":
+        commands = f"cd {target_dir.name} && make install && make test"
+    elif normalized_type == "node":
+        commands = f"cd {target_dir.name} && npm install && npm test"
+    else:
+        commands = f"cd {target_dir.name} && mvn clean test"
+
+    console.print(
+        Panel(
+            f"[bold green]✨ Project successfully scaffolded![/bold green]\n\n"
+            f"[dim]Next steps:[/dim]\n"
+            f"[bold cyan]{commands}[/bold cyan]",
+            title="🎉 Toolbelt Scaffold",
+            border_style="green",
+            box=box.ROUNDED,
+        )
+    )

toolbelt/commands/version.py

@@ -0,0 +1,47 @@
+"""Implementation of `toolbelt version` command."""
+
+from __future__ import annotations
+
+import importlib.metadata
+
+import httpx
+from rich.panel import Panel
+
+from ..utils.console import get_console
+
+
+def main() -> None:
+    """Print the current version and check PyPI for newer releases."""
+    console = get_console()
+    try:
+        current_version = importlib.metadata.version("toolbelt-cli")
+    except Exception:
+        current_version = "0.2.0"
+
+    console.print(
+        Panel(
+            f"[bold]toolbelt-cli version:[/bold] {current_version}",
+            style="green",
+            border_style="green",
+        )
+    )
+
+    pypi_url = "https://pypi.org/pypi/toolbelt-cli/json"
+    try:
+        resp = httpx.get(pypi_url, timeout=5.0)
+        resp.raise_for_status()
+        data = resp.json()
+        latest = data.get("info", {}).get("version")
+        if latest and latest != current_version:
+            console.print(
+                Panel(
+                    f"[yellow]A newer version {latest} is available![/yellow]\n"
+                    f"Run: [bold cyan]pip install -U toolbelt-cli[/bold cyan]",
+                    style="yellow",
+                    border_style="yellow",
+                    title="Update Available",
+                )
+            )
+    except Exception:
+        # Ignore network errors or unavailable PyPI endpoint
+        pass

toolbelt/services/__init__.py

@@ -0,0 +1 @@
+"""Service layer for Toolbelt CLI."""

toolbelt/services/auditor.py

@@ -0,0 +1,295 @@
+"""Repository auditing service."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+MIT_TEMPLATE = """MIT License
+
+Copyright (c) {year} {author}
+
+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.
+"""
+
+APACHE_TEMPLATE = """                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright (c) {year} {author}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+"""
+
+DEFAULT_GITIGNORE = """# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.env
+.venv
+env/
+venv/
+ENV/
+
+# Node
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Java
+target/
+*.class
+
+# IDE
+.idea/
+.vscode/
+*.swp
+"""
+
+
+class AuditResult:
+    """Individual audit check result."""
+
+    def __init__(self, name: str, passed: bool, details: str = "") -> None:
+        self.name = name
+        self.passed = passed
+        self.details = details
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "passed": self.passed,
+            "status": "✅" if self.passed else "❌",
+            "details": self.details,
+        }
+
+
+class Auditor:
+    """Inspects a repository path for standards, files, and conventions."""
+
+    def __init__(self, repo_path: Path, console: Console | None = None) -> None:
+        self.repo_path = repo_path.resolve()
+        self.console = console or Console()
+
+    def _file_content(self, relative_path: str) -> str | None:
+        target = self.repo_path / relative_path
+        if target.is_file():
+            try:
+                return target.read_text(encoding="utf-8")
+            except Exception:
+                return None
+        return None
+
+    def fix_missing(self, interactive: bool = True) -> None:
+        """Prompt to fix missing .gitignore and LICENSE."""
+        gitignore_path = self.repo_path / ".gitignore"
+        license_path = self.repo_path / "LICENSE"
+
+        if not gitignore_path.exists():
+            create_gi = True
+            if interactive:
+                try:
+                    create_gi = Confirm.ask(
+                        "Missing .gitignore. Create default .gitignore?", default=True
+                    )
+                except Exception:
+                    create_gi = True
+            if create_gi:
+                gitignore_path.write_text(DEFAULT_GITIGNORE, encoding="utf-8")
+                self.console.print("[green]Created .gitignore[/green]")
+
+        if not license_path.exists():
+            create_lic = True
+            choice = "MIT"
+            if interactive:
+                try:
+                    create_lic = Confirm.ask(
+                        "Missing LICENSE file. Create one?", default=True
+                    )
+                    if create_lic:
+                        choice = Prompt.ask(
+                            "Select license",
+                            choices=["MIT", "Apache-2.0"],
+                            default="MIT",
+                        )
+                except Exception:
+                    create_lic = True
+                    choice = "MIT"
+            if create_lic:
+                template = APACHE_TEMPLATE if choice == "Apache-2.0" else MIT_TEMPLATE
+                content = template.format(year="2026", author="Author")
+                license_path.write_text(content, encoding="utf-8")
+                self.console.print(f"[green]Created LICENSE ({choice})[/green]")
+
+    def run(self, fix: bool = False, interactive: bool = True) -> list[AuditResult]:
+        """Run all audit checks."""
+        if fix:
+            self.fix_missing(interactive=interactive)
+
+        results: list[AuditResult] = []
+
+        # 1. README.md exists
+        readme_content = self._file_content("README.md")
+        if readme_content is not None:
+            line_count = len(readme_content.splitlines())
+            results.append(AuditResult("README.md exists", True, f"{line_count} lines"))
+        else:
+            results.append(AuditResult("README.md exists", False, "file missing"))
+
+        # 2. README has Install
+        if readme_content and re.search(
+            r"##\s+Install(ation)?", readme_content, re.IGNORECASE
+        ):
+            results.append(
+                AuditResult("README has Install", True, 'found "## Installation"')
+            )
+        else:
+            results.append(
+                AuditResult(
+                    "README has Install", False, 'missing "## Installation" section'
+                )
+            )
+
+        # 3. README has Usage
+        if readme_content and re.search(r"##\s+Usage", readme_content, re.IGNORECASE):
+            results.append(AuditResult("README has Usage", True, 'found "## Usage"'))
+        else:
+            results.append(
+                AuditResult("README has Usage", False, 'missing "## Usage" section')
+            )
+
+        # 4. README has License
+        if readme_content and re.search(r"##\s+License", readme_content, re.IGNORECASE):
+            results.append(
+                AuditResult("README has License", True, 'found "## License"')
+            )
+        else:
+            results.append(
+                AuditResult("README has License", False, "no License section")
+            )
+
+        # 5. LICENSE file
+        license_content = self._file_content("LICENSE")
+        if license_content is not None:
+            if "Apache" in license_content:
+                lic_type = "Apache-2.0"
+            elif "MIT" in license_content:
+                lic_type = "MIT"
+            else:
+                first_line = (
+                    license_content.strip().splitlines()[0][:20]
+                    if license_content.strip()
+                    else "Found"
+                )
+                lic_type = first_line
+            results.append(AuditResult("LICENSE file", True, lic_type))
+        else:
+            results.append(AuditResult("LICENSE file", False, "missing"))
+
+        # 6. .gitignore exists
+        gitignore_content = self._file_content(".gitignore")
+        if gitignore_content is not None:
+            entries = [
+                line
+                for line in gitignore_content.splitlines()
+                if line.strip() and not line.strip().startswith("#")
+            ]
+            results.append(
+                AuditResult(".gitignore exists", True, f"{len(entries)} entries")
+            )
+        else:
+            results.append(AuditResult(".gitignore exists", False, "file missing"))
+
+        # 7. .gitignore has __pycache__
+        if gitignore_content is not None and "__pycache__" in gitignore_content:
+            results.append(AuditResult(".gitignore has __pycache__", True, ""))
+        else:
+            results.append(
+                AuditResult(
+                    ".gitignore has __pycache__", False, 'missing "__pycache__"'
+                )
+            )
+
+        # 8. Tests directory
+        tests_dir = self.repo_path / "tests"
+        test_dir = self.repo_path / "test"
+        src_test_dir = self.repo_path / "src" / "test"
+        has_tests = (
+            (tests_dir.is_dir() and any(tests_dir.iterdir()))
+            or (test_dir.is_dir() and any(test_dir.iterdir()))
+            or (src_test_dir.is_dir() and any(src_test_dir.iterdir()))
+        )
+        if has_tests:
+            results.append(AuditResult("Tests directory", True, "tests/ found"))
+        else:
+            results.append(AuditResult("Tests directory", False, "missing"))
+
+        # 9. CI config
+        ci_yml = self.repo_path / ".github" / "workflows" / "ci.yml"
+        ci_yaml = self.repo_path / ".github" / "workflows" / "ci.yaml"
+        workflows_dir = self.repo_path / ".github" / "workflows"
+        has_ci = (
+            ci_yml.exists()
+            or ci_yaml.exists()
+            or (workflows_dir.is_dir() and any(workflows_dir.glob("*.y*ml")))
+        )
+        if has_ci:
+            results.append(AuditResult("CI config", True, ".github/workflows/ci.yml"))
+        else:
+            results.append(AuditResult("CI config", False, "missing"))
+
+        # 10. pyproject.toml
+        pyproject = self.repo_path / "pyproject.toml"
+        if pyproject.is_file():
+            results.append(AuditResult("pyproject.toml", True, ""))
+        else:
+            results.append(AuditResult("pyproject.toml", False, "missing"))
+
+        return results