@pennyfarthing/core 11.3.3 → 11.3.4

package/pennyfarthing-dist/pf/hotspots/cli.py

@@ -0,0 +1,154 @@
+"""
+CLI commands for hotspot analysis.
+
+Usage:
+    pf hotspots analyze [OPTIONS]
+    pf hotspots files [OPTIONS]
+    pf hotspots dirs [OPTIONS]
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import click
+
+
+@click.group()
+def hotspots():
+    """Git history hotspot detection.
+
+    \b
+    Commands:
+      analyze  - Full hotspot analysis (files + directories)
+      files    - File-level hotspot report
+      dirs     - Directory-level hotspot report
+    """
+    pass
+
+
+def _common_options(fn):
+    """Shared options for all hotspot commands."""
+    fn = click.option("--repo", help="Analyze a single named repo from repos.yaml")(fn)
+    fn = click.option("--path", "repo_path", type=click.Path(exists=True), help="Analyze a standalone repo path")(fn)
+    fn = click.option("--days", default=90, show_default=True, help="Time window in days")(fn)
+    fn = click.option("--top", default=20, show_default=True, help="Number of top results to show")(fn)
+    fn = click.option("--format", "fmt", type=click.Choice(["table", "json", "csv"]), default="table", show_default=True)(fn)
+    fn = click.option("--output", "output_file", type=click.Path(), help="Write output to file")(fn)
+    fn = click.option("--exclude", multiple=True, help="Additional exclude patterns (repeatable)")(fn)
+    fn = click.option("--branch", default="--all", show_default=True, help="Branch spec for git log")(fn)
+    fn = click.option("--skip-type", "skip_type", multiple=True, help="Skip repos by type (repeatable, e.g. --skip-type orchestrator)")(fn)
+    return fn
+
+
+def _run_analysis(repo: str | None, repo_path: str | None, days: int, exclude: tuple, branch: str, skip_type: tuple = ()):
+    """Run analysis and return result."""
+    from pf.common.config import get_project_root
+    from pf.hotspots.analyze import analyze_all_repos, analyze_repo
+
+    excludes = list(exclude) if exclude else None
+    skip_types = list(skip_type) if skip_type else None
+
+    if repo_path:
+        # Standalone analysis of a specific path
+        p = Path(repo_path).resolve()
+        return asyncio.run(analyze_repo(p.name, p, days, excludes, branch))
+    elif repo:
+        # Single named repo from project
+        project_root = get_project_root()
+        from pf.common.config import load_yaml_config
+        repos_yaml = load_yaml_config(project_root / ".pennyfarthing" / "repos.yaml")
+        if repos_yaml and repo in repos_yaml:
+            cfg = repos_yaml[repo]
+            rpath = cfg.get("path", repo) if isinstance(cfg, dict) else str(cfg)
+            return asyncio.run(
+                analyze_repo(repo, project_root / rpath, days, excludes, branch)
+            )
+        else:
+            # Try as a subdirectory name
+            candidate = project_root / repo
+            if candidate.exists():
+                return asyncio.run(
+                    analyze_repo(repo, candidate, days, excludes, branch)
+                )
+            raise click.ClickException(f"Repo not found: {repo}")
+    else:
+        # All repos
+        project_root = get_project_root()
+        return asyncio.run(
+            analyze_all_repos(project_root, days, excludes, branch, skip_types)
+        )
+
+
+def _output_result(result, fmt: str, output_file: str | None, top: int, mode: str):
+    """Format and output the analysis result."""
+    from pf.hotspots.formatters import (
+        export_csv,
+        export_json,
+        format_dir_table,
+        format_file_table,
+        format_summary,
+    )
+    from pf.hotspots.models import MultiRepoHotspotResult
+
+    # Collect all repo results
+    if isinstance(result, MultiRepoHotspotResult):
+        repo_results = result.repo_results
+    else:
+        repo_results = [result]
+
+    if fmt == "json":
+        text = export_json(result)
+    elif fmt == "csv":
+        # CSV only supports file-level
+        all_files = []
+        for r in repo_results:
+            all_files.extend(r.file_hotspots)
+        all_files.sort(key=lambda h: h.hotspot_score, reverse=True)
+        text = export_csv(all_files[:top])
+    else:
+        # Table output
+        parts = []
+        for r in repo_results:
+            if not r.success:
+                parts.append(f"Error ({r.repo_name}): {r.error}")
+                continue
+            format_summary(r)
+            if mode in ("analyze", "files"):
+                parts.append("\nFile Hotspots:")
+                parts.append(format_file_table(r.file_hotspots, top))
+            if mode in ("analyze", "dirs"):
+                parts.append("\nDirectory Hotspots:")
+                parts.append(format_dir_table(r.directory_hotspots, top))
+        text = "\n".join(parts)
+
+    if output_file:
+        Path(output_file).write_text(text)
+        click.echo(f"Output written to {output_file}", err=True)
+    else:
+        click.echo(text)
+
+
+@hotspots.command()
+@_common_options
+def analyze(repo, repo_path, days, top, fmt, output_file, exclude, branch, skip_type):
+    """Full hotspot analysis — files and directories."""
+    result = _run_analysis(repo, repo_path, days, exclude, branch, skip_type)
+    _output_result(result, fmt, output_file, top, "analyze")
+
+
+@hotspots.command()
+@_common_options
+def files(repo, repo_path, days, top, fmt, output_file, exclude, branch, skip_type):
+    """File-level hotspot report."""
+    result = _run_analysis(repo, repo_path, days, exclude, branch, skip_type)
+    _output_result(result, fmt, output_file, top, "files")
+
+
+@hotspots.command()
+@_common_options
+def dirs(repo, repo_path, days, top, fmt, output_file, exclude, branch, skip_type):
+    """Directory-level hotspot report."""
+    result = _run_analysis(repo, repo_path, days, exclude, branch, skip_type)
+    _output_result(result, fmt, output_file, top, "dirs")

package/pennyfarthing-dist/pf/hotspots/formatters.py

@@ -0,0 +1,109 @@
+"""
+Output formatters for hotspot analysis results.
+
+Supports table, JSON, and CSV output — no external dependencies.
+Uses common/output.py for colored terminal output.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import sys
+from dataclasses import asdict
+from typing import TextIO
+
+from pf.common.output import header, info
+from pf.hotspots.models import (
+    DirectoryHotspot,
+    FileHotspot,
+    HotspotResult,
+    MultiRepoHotspotResult,
+)
+
+
+def format_file_table(hotspots: list[FileHotspot], top_n: int = 20) -> str:
+    """Format file hotspots as a column-aligned table."""
+    if not hotspots:
+        return "  No file hotspots found."
+
+    items = hotspots[:top_n]
+
+    # Column headers and widths
+    hdr = f"{'Score':>6}  {'Changes':>8}  {'Fixes':>6}  {'Authors':>8}  {'Churn':>8}  File"
+    sep = f"{'------':>6}  {'--------':>8}  {'------':>6}  {'--------':>8}  {'--------':>8}  ----"
+
+    lines = [hdr, sep]
+    for h in items:
+        lines.append(
+            f"{h.hotspot_score:>6.1f}  {h.change_count:>8}  {h.bug_fix_count:>6}  "
+            f"{h.author_count:>8}  {h.churn:>8}  {h.path}"
+        )
+
+    return "\n".join(lines)
+
+
+def format_dir_table(hotspots: list[DirectoryHotspot], top_n: int = 20) -> str:
+    """Format directory hotspots as a column-aligned table."""
+    if not hotspots:
+        return "  No directory hotspots found."
+
+    items = hotspots[:top_n]
+
+    hdr = f"{'Score':>6}  {'Files':>6}  {'Changes':>8}  {'Fixes':>6}  {'Avg Auth':>9}  Directory"
+    sep = f"{'------':>6}  {'------':>6}  {'--------':>8}  {'------':>6}  {'---------':>9}  ---------"
+
+    lines = [hdr, sep]
+    for d in items:
+        lines.append(
+            f"{d.hotspot_score:>6.1f}  {d.file_count:>6}  {d.total_changes:>8}  "
+            f"{d.total_bug_fixes:>6}  {d.avg_author_count:>9.1f}  {d.path}"
+        )
+
+    return "\n".join(lines)
+
+
+def format_summary(result: HotspotResult, file: TextIO = sys.stderr) -> None:
+    """Print a summary header for a single repo result."""
+    header(f"  Hotspots: {result.repo_name}", char="=", width=60, file=file)
+    info(f"Path: {result.repo_path}", file=file)
+    info(f"Time window: {result.time_window_days} days", file=file)
+    info(f"Commits analyzed: {result.commit_count}", file=file)
+    info(f"File hotspots: {len(result.file_hotspots)}", file=file)
+    info(f"Directory hotspots: {len(result.directory_hotspots)}", file=file)
+
+
+def export_json(result: HotspotResult | MultiRepoHotspotResult) -> str:
+    """Serialize result to JSON string."""
+    return json.dumps(asdict(result), indent=2, default=str)
+
+
+def export_csv(hotspots: list[FileHotspot]) -> str:
+    """Export file hotspots as CSV."""
+    buf = io.StringIO()
+    writer = csv.writer(buf)
+    writer.writerow([
+        "path",
+        "change_count",
+        "bug_fix_count",
+        "author_count",
+        "lines_added",
+        "lines_deleted",
+        "churn",
+        "last_changed",
+        "hotspot_score",
+    ])
+    for h in hotspots:
+        writer.writerow([
+            h.path,
+            h.change_count,
+            h.bug_fix_count,
+            h.author_count,
+            h.lines_added,
+            h.lines_deleted,
+            h.churn,
+            h.last_changed,
+            h.hotspot_score,
+        ])
+    return buf.getvalue()

package/pennyfarthing-dist/pf/jira/__init__.py

@@ -0,0 +1,97 @@
+"""
+Jira integration package for Pennyfarthing scripts.
+
+This package provides:
+- client: JiraClient REST API wrapper and helper functions
+- sync: Epic sync to Jira
+- bidirectional: Bidirectional sync between YAML and Jira
+- epic: Epic creation
+- story: Single story sync
+- claim: Story claiming
+
+Usage:
+    # Use the client module
+    from pf.jira import JiraClient
+    client = JiraClient()
+    issue = client.get_issue_sync("MSSCI-12345")
+
+    # Use CLI
+    python -m pf.jira <subcommand> [args]
+"""
+
+# Re-export from client for backwards compatibility
+# Import submodules to make them accessible
+# CLI entry point - import module, not function, so "from jira import cli" gets the module
+from pf.jira import (
+    bidirectional,
+    claim,
+    cli,
+    client,
+    create,
+    epic,
+    operations,
+    reconcile,
+    story,
+    sync,
+)
+from pf.jira.cli import main
+from pf.jira.client import (
+    # Constants
+    GITHUB_TO_JIRA_MAP,
+    JIRA_PROJECT,
+    JIRA_TO_STATUS,
+    JIRA_URL,
+    STATUS_TO_JIRA,
+    # Classes
+    JiraClient,
+    # Functions
+    add_comment,
+    check_dependencies,
+    extract_jira_key,
+    get_client,
+    get_issue,
+    get_jira_field,
+    get_story_points,
+    is_jira_cli_available,
+    map_github_to_jira,
+    map_jira_to_status,
+    map_status_to_jira,
+    update_issue_status,
+)
+
+__all__ = [
+    # Constants
+    "GITHUB_TO_JIRA_MAP",
+    "JIRA_PROJECT",
+    "JIRA_TO_STATUS",
+    "JIRA_URL",
+    "STATUS_TO_JIRA",
+    # Classes
+    "JiraClient",
+    # Functions
+    "add_comment",
+    "check_dependencies",
+    "extract_jira_key",
+    "get_client",
+    "get_issue",
+    "get_jira_field",
+    "get_story_points",
+    "is_jira_cli_available",
+    "map_github_to_jira",
+    "map_jira_to_status",
+    "map_status_to_jira",
+    "update_issue_status",
+    # Submodules
+    "bidirectional",
+    "claim",
+    "client",
+    "create",
+    "epic",
+    "operations",
+    "reconcile",
+    "story",
+    "sync",
+    # CLI
+    "cli",
+    "main",
+]

package/pennyfarthing-dist/pf/jira/__main__.py

@@ -0,0 +1,10 @@
+"""
+Entry point for python -m pf.jira
+"""
+
+import sys
+
+from pf.jira.cli import cli
+
+if __name__ == "__main__":
+    sys.exit(cli())