@pennyfarthing/core 11.3.2 → 11.3.4

package/pennyfarthing_scripts/deadcode/cli.py

@@ -1,163 +0,0 @@
-"""
-CLI commands for dead code detection.
-
-Usage:
-    pf deadcode stale [OPTIONS]
-    pf deadcode exports [OPTIONS]
-"""
-
-from __future__ import annotations
-
-import asyncio
-from pathlib import Path
-
-import click
-
-
-@click.group()
-def deadcode():
-    """Dead code detection tools.
-
-    \b
-    Commands:
-      stale    - Find files with no recent commits
-      exports  - Find unused TypeScript exports via ts-prune
-    """
-    pass
-
-
-def _common_options(fn):
-    """Shared options for deadcode 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=180, 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)
-    return fn
-
-
-def _run_analysis(repo: str | None, repo_path: str | None, days: int, exclude: tuple, branch: str):
-    """Run analysis and return result."""
-    from pennyfarthing_scripts.common.config import get_project_root
-    from pennyfarthing_scripts.deadcode.analyze import analyze_repo
-
-    excludes = list(exclude) if exclude else None
-
-    if repo_path:
-        p = Path(repo_path).resolve()
-        return asyncio.run(analyze_repo(p.name, p, days, excludes, branch))
-    elif repo:
-        project_root = get_project_root()
-        from pennyfarthing_scripts.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:
-            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:
-        project_root = get_project_root()
-        return asyncio.run(analyze_repo(project_root.name, project_root, days, excludes, branch))
-
-
-def _output_result(result, fmt: str, output_file: str | None, top: int):
-    """Format and output the analysis result."""
-    from pennyfarthing_scripts.deadcode.formatters import (
-        export_csv,
-        export_json,
-        format_table,
-    )
-
-    if fmt == "json":
-        text = export_json(result)
-    elif fmt == "csv":
-        text = export_csv(result.stale_files[:top])
-    else:
-        text = format_table(result.stale_files, top)
-
-    if output_file:
-        Path(output_file).write_text(text)
-        click.echo(f"Output written to {output_file}", err=True)
-    else:
-        click.echo(text)
-
-
-@deadcode.command()
-@_common_options
-def stale(repo, repo_path, days, top, fmt, output_file, exclude, branch):
-    """Find files with no recent git commits."""
-    result = _run_analysis(repo, repo_path, days, exclude, branch)
-    _output_result(result, fmt, output_file, top)
-
-
-def _exports_options(fn):
-    """Shared options for exports subcommand."""
-    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("--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)
-    return fn
-
-
-def _run_exports_analysis(repo: str | None, repo_path: str | None):
-    """Run unused export analysis and return result."""
-    from pennyfarthing_scripts.common.config import get_project_root
-    from pennyfarthing_scripts.deadcode.analyze import find_unused_exports
-
-    if repo_path:
-        p = Path(repo_path).resolve()
-        return asyncio.run(find_unused_exports(p))
-    elif repo:
-        project_root = get_project_root()
-        from pennyfarthing_scripts.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(find_unused_exports(project_root / rpath))
-        else:
-            candidate = project_root / repo
-            if candidate.exists():
-                return asyncio.run(find_unused_exports(candidate))
-            raise click.ClickException(f"Repo not found: {repo}")
-    else:
-        project_root = get_project_root()
-        return asyncio.run(find_unused_exports(project_root))
-
-
-def _output_exports_result(result, fmt: str, output_file: str | None, top: int):
-    """Format and output the exports analysis result."""
-    from pennyfarthing_scripts.deadcode.formatters import (
-        export_exports_csv,
-        export_exports_json,
-        format_exports_table,
-    )
-
-    if fmt == "json":
-        text = export_exports_json(result)
-    elif fmt == "csv":
-        text = export_exports_csv(result.unused_exports[:top])
-    else:
-        text = format_exports_table(result.unused_exports, top)
-
-    if output_file:
-        Path(output_file).write_text(text)
-        click.echo(f"Output written to {output_file}", err=True)
-    else:
-        click.echo(text)
-
-
-@deadcode.command()
-@_exports_options
-def exports(repo, repo_path, top, fmt, output_file):
-    """Find unused TypeScript exports via ts-prune."""
-    result = _run_exports_analysis(repo, repo_path)
-    _output_exports_result(result, fmt, output_file, top)

package/pennyfarthing_scripts/deadcode/formatters.py

@@ -1,106 +0,0 @@
-"""
-Output formatters for dead code analysis results.
-
-Supports table, JSON, and CSV output formats.
-"""
-
-from __future__ import annotations
-
-import csv
-import io
-import json
-from dataclasses import asdict
-
-from pennyfarthing_scripts.deadcode.models import (
-    DeadCodeResult,
-    StaleFile,
-    UnusedExport,
-    UnusedExportResult,
-)
-
-
-def format_table(stale_files: list[StaleFile], top_n: int = 20) -> str:
-    """Format stale files as a human-readable table."""
-    if not stale_files:
-        return "No stale files found."
-
-    files = stale_files[:top_n]
-
-    # Column widths
-    path_width = max(len("Path"), max(len(f.path) for f in files))
-    header = f"{'Path':<{path_width}}  {'Days':>6}  {'Size':>10}  {'Last Commit'}"
-    separator = "-" * len(header)
-
-    lines = [header, separator]
-    for f in files:
-        size_str = _format_size(f.size_bytes)
-        date_str = f.last_commit_date[:10] if f.last_commit_date else "unknown"
-        lines.append(
-            f"{f.path:<{path_width}}  {f.days_since_last_commit:>6}  {size_str:>10}  {date_str}"
-        )
-
-    return "\n".join(lines)
-
-
-def _format_size(size_bytes: int) -> str:
-    """Format bytes as human-readable size."""
-    if size_bytes < 1024:
-        return f"{size_bytes} B"
-    elif size_bytes < 1024 * 1024:
-        return f"{size_bytes / 1024:.1f} KB"
-    else:
-        return f"{size_bytes / (1024 * 1024):.1f} MB"
-
-
-def export_json(result: DeadCodeResult) -> str:
-    """Export result as JSON."""
-    return json.dumps(asdict(result), indent=2)
-
-
-def export_csv(stale_files: list[StaleFile]) -> str:
-    """Export stale files as CSV."""
-    output = io.StringIO()
-    writer = csv.writer(output)
-    writer.writerow(["path", "last_commit_date", "days_since_last_commit", "size_bytes"])
-    for f in stale_files:
-        writer.writerow([f.path, f.last_commit_date, f.days_since_last_commit, f.size_bytes])
-    return output.getvalue()
-
-
-# ---- Unused export formatters ----
-
-
-def format_exports_table(unused_exports: list[UnusedExport], top_n: int = 20) -> str:
-    """Format unused exports as a human-readable table."""
-    if not unused_exports:
-        return "No unused exports found."
-
-    exports = unused_exports[:top_n]
-
-    file_width = max(len("File"), max(len(ue.file) for ue in exports))
-    symbol_width = max(len("Symbol"), max(len(ue.symbol) for ue in exports))
-    header = f"{'File':<{file_width}}  {'Line':>5}  {'Symbol':<{symbol_width}}  {'Type'}"
-    separator = "-" * len(header)
-
-    lines = [header, separator]
-    for ue in exports:
-        lines.append(
-            f"{ue.file:<{file_width}}  {ue.line:>5}  {ue.symbol:<{symbol_width}}  {ue.export_type}"
-        )
-
-    return "\n".join(lines)
-
-
-def export_exports_json(result: UnusedExportResult) -> str:
-    """Export unused export result as JSON."""
-    return json.dumps(asdict(result), indent=2)
-
-
-def export_exports_csv(unused_exports: list[UnusedExport]) -> str:
-    """Export unused exports as CSV."""
-    output = io.StringIO()
-    writer = csv.writer(output)
-    writer.writerow(["symbol", "file", "line", "export_type"])
-    for ue in unused_exports:
-        writer.writerow([ue.symbol, ue.file, ue.line, ue.export_type])
-    return output.getvalue()

package/pennyfarthing_scripts/dependencies/__init__.py

@@ -1,20 +0,0 @@
-"""
-Dependency staleness and security analysis for Node.js projects.
-
-Wraps npm outdated and npm audit to detect outdated packages
-and security vulnerabilities.
-"""
-
-from pennyfarthing_scripts.dependencies.analyze import analyze_dependencies
-from pennyfarthing_scripts.dependencies.models import (
-    DependenciesResult,
-    OutdatedPackage,
-    SecurityAdvisory,
-)
-
-__all__ = [
-    "OutdatedPackage",
-    "SecurityAdvisory",
-    "DependenciesResult",
-    "analyze_dependencies",
-]

package/pennyfarthing_scripts/dependencies/__main__.py

@@ -1,5 +0,0 @@
-"""Allow running as: python -m pennyfarthing_scripts.dependencies"""
-
-from pennyfarthing_scripts.dependencies.cli import dependencies
-
-dependencies()

package/pennyfarthing_scripts/dependencies/analyze.py

@@ -1,155 +0,0 @@
-"""
-Core dependency analysis engine.
-
-Wraps npm outdated --json and npm audit --json.
-Parses output into models following ADR-0008 result pattern.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import shutil
-from collections import Counter
-from pathlib import Path
-
-from pennyfarthing_scripts.dependencies.models import (
-    DependenciesResult,
-    OutdatedPackage,
-    SecurityAdvisory,
-)
-
-
-def _find_npm(target_path: Path) -> Path | None:
-    """Find npm binary via shutil.which."""
-    npm = shutil.which("npm")
-    return Path(npm) if npm else None
-
-
-def _check_package_json(target_path: Path) -> bool:
-    """Check if package.json exists in target directory."""
-    return (target_path / "package.json").exists()
-
-
-def _parse_outdated_output(output: str) -> list[OutdatedPackage]:
-    """Parse npm outdated --json output into OutdatedPackage models.
-
-    npm outdated --json returns: {pkg_name: {current, wanted, latest, type, ...}}
-    """
-    if not output:
-        return []
-    try:
-        data = json.loads(output)
-    except (json.JSONDecodeError, TypeError):
-        return []
-
-    if not data or not isinstance(data, dict):
-        return []
-
-    packages = []
-    for name, info in data.items():
-        packages.append(OutdatedPackage(
-            name=name,
-            current=info.get("current", ""),
-            wanted=info.get("wanted", ""),
-            latest=info.get("latest", ""),
-            type=info.get("type", ""),
-        ))
-    return packages
-
-
-def _parse_audit_output(output: str) -> list[SecurityAdvisory]:
-    """Parse npm audit --json output into SecurityAdvisory models.
-
-    npm audit --json returns: {vulnerabilities: {name: {severity, ...}}, metadata: ...}
-    Aggregates by severity level.
-    """
-    if not output:
-        return []
-    try:
-        data = json.loads(output)
-    except (json.JSONDecodeError, TypeError):
-        return []
-
-    vulns = data.get("vulnerabilities", {})
-    if not vulns:
-        return []
-
-    severity_counts: Counter[str] = Counter()
-    for info in vulns.values():
-        sev = info.get("severity", "unknown")
-        severity_counts[sev] += 1
-
-    return [
-        SecurityAdvisory(severity=sev, count=count)
-        for sev, count in severity_counts.items()
-    ]
-
-
-async def _run_npm_outdated(npm_bin: Path, target_path: Path) -> tuple[str, str, int]:
-    """Run npm outdated --json subprocess."""
-    proc = await asyncio.create_subprocess_exec(
-        str(npm_bin),
-        "outdated",
-        "--json",
-        cwd=str(target_path),
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-    )
-    stdout, stderr = await proc.communicate()
-    return (
-        stdout.decode("utf-8", errors="replace"),
-        stderr.decode("utf-8", errors="replace"),
-        proc.returncode or 0,
-    )
-
-
-async def _run_npm_audit(npm_bin: Path, target_path: Path) -> tuple[str, str, int]:
-    """Run npm audit --json subprocess."""
-    proc = await asyncio.create_subprocess_exec(
-        str(npm_bin),
-        "audit",
-        "--json",
-        cwd=str(target_path),
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-    )
-    stdout, stderr = await proc.communicate()
-    return (
-        stdout.decode("utf-8", errors="replace"),
-        stderr.decode("utf-8", errors="replace"),
-        proc.returncode or 0,
-    )
-
-
-async def analyze_dependencies(target_path: Path) -> DependenciesResult:
-    """Analyze dependencies of a Node.js project."""
-    resolved = target_path.resolve()
-
-    npm_bin = _find_npm(resolved)
-    if npm_bin is None:
-        return DependenciesResult(
-            success=False,
-            target_path=str(resolved),
-            error="npm not found. Install Node.js to use dependency analysis.",
-        )
-
-    if not _check_package_json(resolved):
-        return DependenciesResult(
-            success=False,
-            target_path=str(resolved),
-            error="No package.json found in target directory.",
-        )
-
-    outdated_stdout, _, _ = await _run_npm_outdated(npm_bin, resolved)
-    audit_stdout, _, _ = await _run_npm_audit(npm_bin, resolved)
-
-    outdated = _parse_outdated_output(outdated_stdout)
-    advisories = _parse_audit_output(audit_stdout)
-
-    return DependenciesResult(
-        success=True,
-        target_path=str(resolved),
-        outdated=outdated,
-        advisories=advisories,
-    )

package/pennyfarthing_scripts/dependencies/cli.py

@@ -1,76 +0,0 @@
-"""
-CLI commands for dependency analysis.
-
-Usage:
-    python -m pennyfarthing_scripts.dependencies analyze [OPTIONS]
-"""
-
-from __future__ import annotations
-
-import asyncio
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from pennyfarthing_scripts.dependencies.models import DependenciesResult
-
-
-@click.group()
-def dependencies():
-    """Dependency staleness and security analysis.
-
-    \b
-    Commands:
-      analyze  - Analyze dependency health
-    """
-    pass
-
-
-def _run_analysis(target_path: str | None) -> DependenciesResult:
-    """Run analysis and return result."""
-    from pennyfarthing_scripts.dependencies.analyze import analyze_dependencies
-
-    p = Path(target_path).resolve() if target_path else Path(".").resolve()
-    return asyncio.run(analyze_dependencies(p))
-
-
-def _output_result(result, fmt: str, output_file: str | None):
-    """Format and output the analysis result."""
-    from pennyfarthing_scripts.dependencies.formatters import (
-        export_csv,
-        export_json,
-        format_audit_table,
-        format_outdated_table,
-    )
-
-    if fmt == "json":
-        text = export_json(result)
-    elif fmt == "csv":
-        text = export_csv(result.outdated)
-    else:
-        parts = [format_outdated_table(result.outdated)]
-        if result.advisories:
-            parts.append("")
-            parts.append(format_audit_table(result.advisories))
-        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)
-
-
-@dependencies.command()
-@click.option("--path", "target_path", type=click.Path(exists=True),
-              help="Directory to analyze")
-@click.option("--format", "fmt", type=click.Choice(["table", "json", "csv"]),
-              default="table", show_default=True)
-@click.option("--output", "output_file", type=click.Path(),
-              help="Write output to file")
-def analyze(target_path, fmt, output_file):
-    """Analyze dependency health."""
-    result = _run_analysis(target_path)
-    _output_result(result, fmt, output_file)

package/pennyfarthing_scripts/dependencies/formatters.py

@@ -1,63 +0,0 @@
-"""
-Output formatters for dependency analysis results.
-
-Supports table, JSON, and CSV output — no external dependencies.
-"""
-
-from __future__ import annotations
-
-import csv
-import io
-import json
-from dataclasses import asdict
-
-from pennyfarthing_scripts.dependencies.models import (
-    DependenciesResult,
-    OutdatedPackage,
-    SecurityAdvisory,
-)
-
-
-def format_outdated_table(packages: list[OutdatedPackage]) -> str:
-    """Format outdated packages as column-aligned table."""
-    if not packages:
-        return "  No outdated packages found."
-
-    hdr = f"{'Package':<30}  {'Current':<12}  {'Wanted':<12}  {'Latest':<12}  Type"
-    sep = f"{'-' * 30}  {'-' * 12}  {'-' * 12}  {'-' * 12}  ----"
-
-    lines = [hdr, sep]
-    for p in packages:
-        lines.append(
-            f"{p.name:<30}  {p.current:<12}  {p.wanted:<12}  {p.latest:<12}  {p.type}"
-        )
-    return "\n".join(lines)
-
-
-def format_audit_table(advisories: list[SecurityAdvisory]) -> str:
-    """Format security advisories as table."""
-    if not advisories:
-        return "  No vulnerabilities found."
-
-    hdr = f"{'Severity':<12}  {'Count':>6}"
-    sep = f"{'-' * 12}  {'-' * 6}"
-
-    lines = [hdr, sep]
-    for a in advisories:
-        lines.append(f"{a.severity:<12}  {a.count:>6}")
-    return "\n".join(lines)
-
-
-def export_json(result: DependenciesResult) -> str:
-    """Serialize result to JSON string."""
-    return json.dumps(asdict(result), indent=2, default=str)
-
-
-def export_csv(packages: list[OutdatedPackage]) -> str:
-    """Export outdated packages as CSV."""
-    buf = io.StringIO()
-    writer = csv.writer(buf)
-    writer.writerow(["name", "current", "wanted", "latest", "type"])
-    for p in packages:
-        writer.writerow([p.name, p.current, p.wanted, p.latest, p.type])
-    return buf.getvalue()

package/pennyfarthing_scripts/gate/cli.py

@@ -1,56 +0,0 @@
-"""Gate CLI — gate file operations.
-
-Usage:
-    pf gate validate <file>    # Validate a gate file
-"""
-
-from __future__ import annotations
-
-import click
-
-from pennyfarthing_scripts.common.output import error, info, success
-
-
-@click.group()
-def gate():
-    """Gate file operations.
-
-    \b
-    Commands:
-      validate  - Validate a gate file for schema, depth, and cycles
-    """
-    pass
-
-
-@gate.command("validate")
-@click.argument("file", type=click.Path(exists=True))
-def gate_validate(file: str):
-    """Validate a gate file for schema, cycles, and depth.
-
-    Checks:
-      - Schema: <gate name="...">, <purpose>, <pass>, <fail>
-      - Depth: nesting does not exceed 3 levels
-      - Cycles: no duplicate gate names
-      - Completeness: all required elements non-empty
-
-    Reports ALL errors at once. On success, prints a structure summary.
-    """
-    from pennyfarthing_scripts.gate.validate import validate_gate_file
-
-    result = validate_gate_file(file)
-
-    if result.valid:
-        name = result.gate_name or "(unnamed)"
-        success(f"Gate '{name}' is valid")
-        info(f"  Model: {result.model or 'haiku'}")
-        if result.child_count > 0:
-            info(f"  Depth: {result.depth} ({result.child_count} nested gate(s))")
-        else:
-            info(f"  Depth: {result.depth} (no nesting)")
-        info(f"  Children: {result.child_count}")
-    else:
-        name = result.gate_name or file
-        error(f"Gate '{name}' has {len(result.errors)} error(s):")
-        for err in result.errors:
-            error(f"  - {err}")
-        raise SystemExit(1)