raise-cli 2.2.1__py3-none-any.whl

raise_cli/output/formatters/skill.py

@@ -0,0 +1,298 @@
+"""Output formatters for skill commands."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from raise_cli.skills.name_checker import NameCheckResult
+from raise_cli.skills.scaffold import ScaffoldResult
+from raise_cli.skills.schema import Skill
+from raise_cli.skills.validator import ValidationResult
+
+
+def format_skill_list_human(
+    skills: list[Skill],
+    grouped: dict[str, list[Skill]],
+    console: Console,
+) -> None:
+    """Format skill list for human output.
+
+    Args:
+        skills: All skills (for count).
+        grouped: Skills grouped by lifecycle.
+        console: Rich console for output.
+    """
+    if not skills:
+        console.print("No skills found in .claude/skills/")
+        return
+
+    console.print(f"[bold]Skills[/bold] ({len(skills)} found)\n")
+
+    # Define lifecycle order for consistent output
+    lifecycle_order = [
+        "session",
+        "epic",
+        "story",
+        "discovery",
+        "utility",
+        "meta",
+        "unknown",
+    ]
+
+    # Show all lifecycles: ordered first, then any unknown ones alphabetically
+    ordered_set = set(lifecycle_order)
+    extra_lifecycles = sorted(lc for lc in grouped if lc not in ordered_set)
+    display_order = lifecycle_order + extra_lifecycles
+
+    for lifecycle in display_order:
+        if lifecycle not in grouped:
+            continue
+
+        lifecycle_skills = grouped[lifecycle]
+        console.print(f"[bold cyan]{lifecycle.capitalize()}[/bold cyan]")
+
+        table = Table(show_header=False, box=None, padding=(0, 2, 0, 0))
+        table.add_column("Name", style="green")
+        table.add_column("Version", style="dim")
+        table.add_column("Description")
+
+        for skill in sorted(lifecycle_skills, key=lambda s: s.name):
+            # Truncate description if too long
+            desc = skill.description
+            if len(desc) > 50:
+                desc = desc[:47] + "..."
+            table.add_row(
+                skill.name,
+                skill.version or "-",
+                desc,
+            )
+
+        console.print(table)
+        console.print()
+
+
+def format_skill_list_json(
+    skills: list[Skill],
+    skill_dir: str,
+) -> str:
+    """Format skill list as JSON.
+
+    Args:
+        skills: List of skills to format.
+        skill_dir: Path to skill directory.
+
+    Returns:
+        JSON string.
+    """
+    skill_data: list[dict[str, Any]] = []
+    for skill in sorted(skills, key=lambda s: s.name):
+        skill_data.append(
+            {
+                "name": skill.name,
+                "version": skill.version,
+                "lifecycle": skill.lifecycle,
+                "description": skill.description,
+                "path": skill.path,
+            }
+        )
+
+    output = {
+        "skills": skill_data,
+        "skill_dir": skill_dir,
+        "count": len(skills),
+    }
+
+    return json.dumps(output, indent=2)
+
+
+def format_validation_human(
+    results: list[ValidationResult],
+    console: Console,
+) -> None:
+    """Format validation results for human output.
+
+    Args:
+        results: List of validation results.
+        console: Rich console for output.
+    """
+    total_errors = sum(r.error_count for r in results)
+    total_warnings = sum(r.warning_count for r in results)
+
+    for result in results:
+        console.print(f"\n[bold]Validating:[/bold] {result.path}")
+
+        if result.is_valid and result.warning_count == 0:
+            console.print("[green]✓ All checks passed[/green]")
+            continue
+
+        # Show errors
+        for error in result.errors:
+            console.print(f"[red]✗ {error}[/red]")
+
+        # Show warnings
+        for warning in result.warnings:
+            console.print(f"[yellow]⚠ {warning}[/yellow]")
+
+    # Summary
+    console.print()
+    if total_errors == 0 and total_warnings == 0:
+        console.print(f"[green]All {len(results)} skill(s) valid[/green]")
+    else:
+        parts: list[str] = []
+        if total_errors > 0:
+            parts.append(f"[red]{total_errors} error(s)[/red]")
+        if total_warnings > 0:
+            parts.append(f"[yellow]{total_warnings} warning(s)[/yellow]")
+        console.print(f"{len(results)} skill(s) checked: {', '.join(parts)}")
+
+
+def format_validation_json(results: list[ValidationResult]) -> str:
+    """Format validation results as JSON.
+
+    Args:
+        results: List of validation results.
+
+    Returns:
+        JSON string.
+    """
+    output: list[dict[str, Any]] = []
+    for result in results:
+        output.append(
+            {
+                "path": result.path,
+                "valid": result.is_valid,
+                "errors": result.errors,
+                "warnings": result.warnings,
+            }
+        )
+
+    return json.dumps(
+        {
+            "results": output,
+            "total_errors": sum(r.error_count for r in results),
+            "total_warnings": sum(r.warning_count for r in results),
+            "all_valid": all(r.is_valid for r in results),
+        },
+        indent=2,
+    )
+
+
+def format_name_check_human(result: NameCheckResult, console: Console) -> None:
+    """Format name check result for human output.
+
+    Args:
+        result: Name check result.
+        console: Rich console for output.
+    """
+    console.print(f"\n[bold]Checking name:[/bold] {result.name}\n")
+
+    # Pattern check
+    if result.valid_pattern:
+        console.print("[green]✓ Follows {domain}-{action} pattern[/green]")
+    else:
+        console.print("[red]✗ Does not follow {domain}-{action} pattern[/red]")
+
+    # Skill conflict
+    if result.no_skill_conflict:
+        console.print("[green]✓ No conflict with existing skills[/green]")
+    else:
+        console.print(
+            f"[red]✗ Conflicts with existing skill: {result.conflicting_skill}[/red]"
+        )
+
+    # CLI conflict
+    if result.no_cli_conflict:
+        console.print("[green]✓ No CLI command conflict[/green]")
+    else:
+        console.print(
+            f"[red]✗ Conflicts with CLI command: {result.conflicting_command}[/red]"
+        )
+
+    # Lifecycle check
+    if result.known_lifecycle:
+        console.print("[green]✓ Domain is a known lifecycle[/green]")
+    else:
+        console.print("[yellow]⚠ Domain is not a standard lifecycle[/yellow]")
+
+    # Final verdict
+    console.print()
+    if result.is_valid:
+        console.print(f"[bold green]Name '{result.name}' is valid.[/bold green]")
+    else:
+        console.print(f"[bold red]Name '{result.name}' is not valid.[/bold red]")
+
+    # Suggestions
+    if result.suggestions:
+        console.print()
+        for suggestion in result.suggestions:
+            console.print(f"[dim]→ {suggestion}[/dim]")
+
+
+def format_name_check_json(result: NameCheckResult) -> str:
+    """Format name check result as JSON.
+
+    Args:
+        result: Name check result.
+
+    Returns:
+        JSON string.
+    """
+    return json.dumps(
+        {
+            "name": result.name,
+            "valid": result.is_valid,
+            "checks": {
+                "valid_pattern": result.valid_pattern,
+                "no_skill_conflict": result.no_skill_conflict,
+                "no_cli_conflict": result.no_cli_conflict,
+                "known_lifecycle": result.known_lifecycle,
+            },
+            "conflicts": {
+                "skill": result.conflicting_skill,
+                "command": result.conflicting_command,
+            },
+            "suggestions": result.suggestions,
+        },
+        indent=2,
+    )
+
+
+def format_scaffold_human(result: ScaffoldResult, console: Console) -> None:
+    """Format scaffold result for human output.
+
+    Args:
+        result: Scaffold result.
+        console: Rich console for output.
+    """
+    if result.created:
+        console.print(f"\n[green]✓ Created skill at:[/green] {result.path}")
+        console.print("\n[dim]Next steps:[/dim]")
+        console.print("  1. Edit the SKILL.md to add description and steps")
+        console.print("  2. Run [cyan]raise skill validate[/cyan] to check structure")
+        console.print("  3. Test the skill with Claude Code")
+    else:
+        console.print("\n[red]✗ Failed to create skill[/red]")
+        console.print(f"[red]  {result.error}[/red]")
+
+
+def format_scaffold_json(result: ScaffoldResult) -> str:
+    """Format scaffold result as JSON.
+
+    Args:
+        result: Scaffold result.
+
+    Returns:
+        JSON string.
+    """
+    return json.dumps(
+        {
+            "created": result.created,
+            "path": result.path,
+            "error": result.error,
+        },
+        indent=2,
+    )

raise_cli/publish/__init__.py

@@ -0,0 +1,3 @@
+"""Publish module — quality gates, version management, and release workflow."""
+
+from __future__ import annotations

raise_cli/publish/changelog.py

@@ -0,0 +1,80 @@
+"""Changelog parsing and updating for Keep a Changelog format."""
+
+from __future__ import annotations
+
+import re
+
+
+def has_unreleased_entries(content: str) -> bool:
+    """Check if the changelog has entries under the [Unreleased] section.
+
+    Args:
+        content: Full changelog text.
+
+    Returns:
+        True if there are non-whitespace entries between [Unreleased] and the next section.
+    """
+    match = re.search(
+        r"^## \[Unreleased\]\s*$(.*?)(?=^## \[|\Z)",
+        content,
+        re.DOTALL | re.MULTILINE,
+    )
+    if not match:
+        return False
+    return len(match.group(1).strip()) > 0
+
+
+def promote_unreleased(content: str, version: str, date: str) -> str:
+    """Move unreleased entries into a new versioned section.
+
+    Args:
+        content: Full changelog text.
+        version: New version string (e.g. "2.0.0").
+        date: Release date string (e.g. "2026-02-14").
+
+    Returns:
+        Updated changelog text.
+
+    Raises:
+        ValueError: If there are no unreleased entries to promote.
+    """
+    if not has_unreleased_entries(content):
+        msg = "No unreleased entries to promote"
+        raise ValueError(msg)
+
+    # Extract the unreleased body
+    match = re.search(
+        r"(^## \[Unreleased\])\s*$(.*?)(?=^## \[)",
+        content,
+        re.DOTALL | re.MULTILINE,
+    )
+    if not match:
+        msg = "No unreleased entries to promote"
+        raise ValueError(msg)
+
+    unreleased_header = match.group(1)
+    unreleased_body = match.group(2).rstrip()
+
+    # Build replacement: empty Unreleased + new version section
+    replacement = f"{unreleased_header}\n\n## [{version}] - {date}\n{unreleased_body}"
+    content = content[: match.start()] + replacement + content[match.end() :]
+
+    # Update link references if they exist
+    # Replace: [Unreleased]: .../compare/vOLD...HEAD
+    # With:    [Unreleased]: .../compare/vNEW...HEAD
+    #          [NEW]: .../compare/vOLD...vNEW
+    old_link_match = re.search(
+        r"\[Unreleased\]:\s*(https?://\S+/compare/)v([\d.]+\S*)\.\.\.HEAD",
+        content,
+    )
+    if old_link_match:
+        base_url = old_link_match.group(1)
+        old_version = old_link_match.group(2)
+        new_unreleased_link = f"[Unreleased]: {base_url}v{version}...HEAD"
+        new_version_link = f"[{version}]: {base_url}v{old_version}...v{version}"
+        content = content.replace(
+            old_link_match.group(0),
+            f"{new_unreleased_link}\n{new_version_link}",
+        )
+
+    return content

raise_cli/publish/check.py

@@ -0,0 +1,179 @@
+"""Quality gate runner for pre-publish checks."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Gate:
+    """Definition of a quality gate."""
+
+    name: str
+    command: str
+    required: bool = True
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    """Result of a single quality gate check."""
+
+    gate: str
+    passed: bool
+    message: str
+
+
+# Subprocess gates (executed via shell)
+_COMMAND_GATES: list[Gate] = [
+    Gate(name="Tests pass", command="uv run pytest --cov --tb=no -q"),
+    Gate(name="Type checks clean", command="uv run pyright src/"),
+    Gate(name="Lint clean", command="uv run ruff check src/"),
+    Gate(name="Security scan", command="uv run bandit -r src/ -q -ll"),
+    Gate(name="Build succeeds", command="uv build"),
+    Gate(name="Package validates", command="uv run twine check dist/*"),
+]
+
+
+def _run_command(command: str, cwd: Path) -> tuple[bool, str]:
+    """Run a shell command and return (success, output).
+
+    Args:
+        command: Shell command string.
+        cwd: Working directory.
+
+    Returns:
+        Tuple of (passed, message).
+    """
+    try:
+        import shlex
+
+        result = subprocess.run(
+            shlex.split(command),
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+        output = result.stdout.strip() or result.stderr.strip()
+        if result.returncode == 0:
+            return (True, output or "OK")
+        return (False, output or f"Exit code {result.returncode}")
+    except subprocess.TimeoutExpired:
+        return (False, "Timed out after 300s")
+    except FileNotFoundError:
+        return (False, f"Command not found: {command}")
+
+
+def _extract_version(path: Path, pattern: str) -> str | None:
+    """Extract a version string from a file using a regex pattern.
+
+    Args:
+        path: File to read.
+        pattern: Regex with a capture group for the version.
+
+    Returns:
+        Extracted version string or None.
+    """
+    if not path.exists():
+        return None
+    content = path.read_text(encoding="utf-8")
+    match = re.search(pattern, content)
+    if match:
+        return match.group(1)
+    return None
+
+
+def run_checks(
+    *,
+    project_root: Path,
+    pyproject_path: Path,
+    init_path: Path,
+    changelog_path: Path,
+) -> list[CheckResult]:
+    """Run all quality gates and return results.
+
+    Args:
+        project_root: Project root directory.
+        pyproject_path: Path to pyproject.toml.
+        init_path: Path to __init__.py with __version__.
+        changelog_path: Path to CHANGELOG.md.
+
+    Returns:
+        List of CheckResult for each gate.
+    """
+    from raise_cli.publish.changelog import has_unreleased_entries
+    from raise_cli.publish.version import is_pep440
+
+    results: list[CheckResult] = []
+
+    # 1-7: Command-based gates
+    for gate in _COMMAND_GATES:
+        passed, message = _run_command(gate.command, project_root)
+        results.append(CheckResult(gate=gate.name, passed=passed, message=message))
+
+    # 8: Changelog has unreleased entries
+    if changelog_path.exists():
+        content = changelog_path.read_text(encoding="utf-8")
+        has_entries = has_unreleased_entries(content)
+        results.append(
+            CheckResult(
+                gate="CHANGELOG has unreleased entries",
+                passed=has_entries,
+                message="Unreleased entries found"
+                if has_entries
+                else "No unreleased entries",
+            )
+        )
+    else:
+        results.append(
+            CheckResult(
+                gate="CHANGELOG has unreleased entries",
+                passed=False,
+                message=f"File not found: {changelog_path}",
+            )
+        )
+
+    # 9: Version is PEP 440 compliant
+    pyproject_version = _extract_version(pyproject_path, r'version\s*=\s*"([^"]*)"')
+    if pyproject_version and is_pep440(pyproject_version):
+        results.append(
+            CheckResult(
+                gate="Version PEP 440 compliant",
+                passed=True,
+                message=f"{pyproject_version} is valid PEP 440",
+            )
+        )
+    else:
+        results.append(
+            CheckResult(
+                gate="Version PEP 440 compliant",
+                passed=False,
+                message=f"'{pyproject_version}' is not valid PEP 440"
+                if pyproject_version
+                else "Could not read version from pyproject.toml",
+            )
+        )
+
+    # 10: Version sync between pyproject.toml and __init__.py
+    init_version = _extract_version(init_path, r'__version__\s*=\s*"([^"]*)"')
+    if pyproject_version and init_version and pyproject_version == init_version:
+        results.append(
+            CheckResult(
+                gate="Version sync",
+                passed=True,
+                message=f"Both files: {pyproject_version}",
+            )
+        )
+    else:
+        results.append(
+            CheckResult(
+                gate="Version sync",
+                passed=False,
+                message=f"pyproject.toml={pyproject_version}, __init__.py={init_version}",
+            )
+        )
+
+    return results