fship 0.1.0__tar.gz

fship-0.1.0/.claude/settings.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(pipx install *)",
+      "Bash(~/.local/bin/pyproject-build)"
+    ]
+  }
+}

fship-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install build tools
+        run: python -m pip install build twine
+
+      - name: Build distribution
+        run: python -m build
+
+      - name: Upload to PyPI
+        run: twine upload dist/* --non-interactive
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}

fship-0.1.0/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-05-08
+
+### Added
+
+- Initial release of fship
+- CLI for orchestrating Flutter release workflows to Firebase App Distribution
+- Interactive version bumping (interactive, auto-increment, or exact version)
+- CHANGELOG generation via git-chglog
+- Release notes generation from git log
+- Git tagging and commit management
+- APK building for Flutter flavors
+- Firebase App Distribution integration
+- `fship init` command for project setup
+- `fship validate` command for configuration validation
+- `fship release` command with flavor support (e.g., `fship release qa`)
+- PyPI publish workflow

fship-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: fship
+Version: 0.1.0
+Summary: Flutter Ship — orchestrate release workflows to Firebase App Distribution
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: ruamel-yaml>=0.18
+Requires-Dist: typer[all]>=0.12

fship-0.1.0/README.md

@@ -0,0 +1,176 @@
+# fship — Flutter Ship
+
+Memorable, easy CLI for orchestrating Flutter release workflows to Firebase App Distribution.
+
+```bash
+fship release qa                    # Interactive version bump + full release
+fship release qa --version 1.2.4+46  # Exact version
+fship release qa --bump patch       # Auto-increment patch
+```
+
+## Quick Start
+
+1. **Install**: `pip install fship`
+2. **Initialize**: `cd /path/to/flutter/project && fship init`
+3. **Configure**: Edit `fship.yaml` with your Firebase app IDs
+4. **Validate**: `fship validate`
+5. **Release**: `fship release qa` (or your flavor name)
+
+## What It Does (Full Flow)
+
+1. **Bump version** in `pubspec.yaml` (interactive or auto)
+2. **Generate CHANGELOG.md** via `git-chglog`
+3. **Generate release_note.txt** from git log since last tag
+4. **Git commit** version changes
+5. **Git tag** the release
+6. **Build APK** for the flavor
+7. **Distribute to Firebase App Distribution**
+
+## Installation
+
+**Via PyPI (Recommended)**
+```bash
+pip install fship
+```
+
+**From Source (Development)**
+```bash
+git clone https://github.com/MrShakila/F-ship.git
+cd F-ship
+pip install -e .
+```
+
+## Setup (One Time)
+
+```bash
+cd /path/to/your/flutter/project
+
+# Copy default config
+fship init
+
+# Edit fship.yaml — set your Firebase app IDs, entry points, APK paths
+vi fship.yaml
+
+# Validate setup
+fship validate
+```
+
+### fship.yaml Example
+
+```yaml
+flavors:
+  qa:
+    firebase_app_id_env: APPIDANDROID_QA
+    entrypoint: lib/main_qa.dart
+    apk_path: build/app/outputs/flutter-apk/app-qa-release.apk
+    groups: testers
+
+  prod:
+    firebase_app_id_env: APPIDANDROID_PROD
+    entrypoint: lib/main_prod.dart
+    apk_path: build/app/outputs/flutter-apk/app-prod-release.apk
+    groups: testers
+```
+
+## Usage
+
+### Interactive Version Bump
+
+```bash
+fship release qa
+# Current version: 1.2.3+45
+# New version: 1.2.4+46
+# [shows full release workflow with progress]
+```
+
+### Exact Version (Non-Interactive)
+
+```bash
+fship release qa --version 1.2.4+46
+```
+
+### Auto-Increment
+
+```bash
+fship release qa --bump patch    # 1.2.3+45 → 1.2.4+0
+fship release qa --bump minor    # 1.2.3+45 → 1.3.0+0
+fship release qa --bump major    # 1.2.3+45 → 2.0.0+0
+```
+
+### Dry Run (Skip Build & Distribution)
+
+```bash
+fship release qa --skip-build --skip-distribute
+# Only bumps version, generates changelog, commits, tags
+```
+
+## Prerequisites
+
+- Python 3.11+
+- Flutter SDK
+- Firebase CLI: `npm install -g firebase-tools`
+- git-chglog: `brew install git-chglog` (macOS) or `npm install -g git-chglog`
+
+## Environment Setup
+
+**First run creates `.env.dev` template:**
+```bash
+fship release qa
+# Creates .env.dev with placeholders, prompts you to fill in Android app IDs
+```
+
+Edit `.env.dev` with your Firebase Android app IDs:
+```bash
+# .env.dev (add to .gitignore)
+APPIDANDROID_QA=1:123456:android:abcdef...
+APPIDANDROID_UAT=1:345678:android:ghijkl...
+APPIDANDROID_PROD=1:789012:android:mnopqr...
+```
+
+Get app IDs from Firebase Console > Project Settings > Your apps (Android).
+
+fship automatically loads from `.env.dev` when you run `fship release`.
+
+## Commands
+
+```bash
+fship release <flavor> [--version X.Y.Z+B] [--bump patch|minor|major] [--skip-build] [--skip-distribute]
+fship init                         # Copy default fship.yaml
+fship validate                     # Check tools and config
+fship version                      # Show fship version
+fship --help                       # Full help
+```
+
+## Troubleshooting
+
+**"fship.yaml not found"**
+```bash
+fship init
+vi fship.yaml  # customize
+```
+
+**"Firebase CLI not found"**
+```bash
+npm install -g firebase-tools
+firebase login
+```
+
+**"git-chglog not found"**
+```bash
+brew install git-chglog
+# or
+npm install -g git-chglog
+```
+
+**"Commits/tags not created, but version was bumped"**
+- Ensure you're in a git repo and have uncommitted changes allowed
+- Check `git status`
+
+## Development
+
+```bash
+git clone https://github.com/MrShakila/F-ship.git
+cd F-ship
+pip install -e .
+fship --help
+```

fship-0.1.0/fship.yaml

@@ -0,0 +1,21 @@
+# fship — Flutter Ship release configuration
+# Copy this to your Flutter project root and customize app IDs, paths, and groups
+
+flavors:
+  qa:
+    firebase_app_id_env: FIREBASE_QA_APP_ID
+    entrypoint: lib/main_qa.dart
+    apk_path: build/app/outputs/flutter-apk/app-qa-release.apk
+    groups: testers
+
+  uat:
+    firebase_app_id_env: FIREBASE_UAT_APP_ID
+    entrypoint: lib/main_uat.dart
+    apk_path: build/app/outputs/flutter-apk/app-uat-release.apk
+    groups: testers
+
+  prod:
+    firebase_app_id_env: FIREBASE_PROD_APP_ID
+    entrypoint: lib/main_prod.dart
+    apk_path: build/app/outputs/flutter-apk/app-prod-release.apk
+    groups: testers

fship-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fship"
+version = "0.1.0"
+description = "Flutter Ship — orchestrate release workflows to Firebase App Distribution"
+requires-python = ">=3.11"
+dependencies = [
+    "typer[all]>=0.12",
+    "rich>=13.7",
+    "pyyaml>=6.0",
+    "ruamel.yaml>=0.18",
+]
+
+[project.scripts]
+fship = "fship.main:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fship"]

fship-0.1.0/src/fship/__init__.py

@@ -0,0 +1,3 @@
+"""Flutter Ship — release orchestration CLI."""
+
+__version__ = "0.1.0"

fship-0.1.0/src/fship/builder.py

@@ -0,0 +1,65 @@
+import subprocess
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+
+def build_apk(flavor: str, entrypoint: str) -> tuple[bool, str]:
+    """Build Flutter APK for flavor."""
+    cmd = [
+        "flutter",
+        "build",
+        "apk",
+        "--flavor",
+        flavor,
+        "-t",
+        entrypoint,
+    ]
+
+    try:
+        console.print(f"[dim]$ {' '.join(cmd)}[/dim]")
+        result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+
+        if result.returncode != 0:
+            console.print(
+                f"[red]✗ Flutter build failed:[/red]\n{result.stderr[:500]}"
+            )
+            return False, ""
+
+        console.print("[green]✓[/green] APK built successfully")
+
+        apk_path = find_built_apk(flavor)
+        if apk_path:
+            console.print(f"[green]✓[/green] Found APK: {apk_path}")
+            return True, str(apk_path)
+        else:
+            console.print(
+                "[yellow]Warning: Could not locate built APK. Check build output.[/yellow]"
+            )
+            return True, ""
+
+    except FileNotFoundError:
+        console.print(
+            "[red]✗ Flutter not found. Install Flutter SDK or add to PATH.[/red]"
+        )
+        return False, ""
+    except Exception as e:
+        console.print(f"[red]✗ Build failed: {e}[/red]")
+        return False, ""
+
+
+def find_built_apk(flavor: str) -> Path | None:
+    """Try to locate the built APK by checking standard paths."""
+    standard_paths = [
+        f"build/app/outputs/flutter-apk/app-{flavor}-release.apk",
+        f"build/app/outputs/apk/{flavor}/release/app-{flavor}-release.apk",
+        f"build/app/outputs/apk/release/app-release.apk",
+    ]
+
+    for p in standard_paths:
+        path = Path(p)
+        if path.exists():
+            return path
+
+    return None

fship-0.1.0/src/fship/changelog.py

@@ -0,0 +1,119 @@
+import subprocess
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+
+def get_previous_tag() -> str:
+    """Get the previous tag, skipping the latest one."""
+    try:
+        result = subprocess.run(
+            [
+                "bash",
+                "-c",
+                "git describe --tags --abbrev=0 $(git rev-list --tags --skip=1 --max-count=1)",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    return ""
+
+
+def generate_changelog() -> bool:
+    """Generate CHANGELOG.md using git-chglog. Non-fatal if config missing."""
+    try:
+        result = subprocess.run(
+            ["git-chglog", "-o", "CHANGELOG.md"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            console.print("[green]✓[/green] CHANGELOG.md generated")
+            return True
+        else:
+            console.print(
+                "[yellow]⚠[/yellow] git-chglog skipped (missing .chglog/config.yml or other error)"
+            )
+            return True  # non-fatal; continue with release
+
+    except FileNotFoundError:
+        console.print(
+            "[yellow]⚠[/yellow] git-chglog not found. Install: brew install git-chglog"
+        )
+        return True  # non-fatal; continue
+
+
+def generate_release_notes(flavor: str) -> bool:
+    """Generate release_note.txt from git log since last tag."""
+    prev_tag = get_previous_tag()
+
+    if not prev_tag:
+        console.print(
+            "[yellow]Warning: No previous tag found. Using all commits.[/yellow]"
+        )
+        rev_range = "HEAD"
+    else:
+        rev_range = f"{prev_tag}..HEAD"
+
+    try:
+        result = subprocess.run(
+            [
+                "bash",
+                "-c",
+                f'git log --pretty="- %s (%an)" {rev_range}',
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        release_notes = result.stdout.strip()
+
+        if not release_notes:
+            release_notes = f"Release {flavor} - no new commits"
+
+        Path("release_note.txt").write_text(release_notes)
+        console.print("[green]✓[/green] release_note.txt generated")
+        return True
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]✗ Failed to generate release notes: {e}[/red]")
+        return False
+
+
+def git_add_and_commit(version: str, flavor: str) -> bool:
+    """Stage and commit version bump + changelog. Only add files that exist."""
+    try:
+        files_to_add = ["pubspec.yaml"]
+        if Path("CHANGELOG.md").exists():
+            files_to_add.append("CHANGELOG.md")
+        if Path("release_note.txt").exists():
+            files_to_add.append("release_note.txt")
+
+        subprocess.run(["git", "add"] + files_to_add, check=True)
+        subprocess.run(
+            ["git", "commit", "-m", f"chore: release {version}-{flavor}"],
+            check=True,
+        )
+        console.print(f"[green]✓[/green] Committed: chore: release {version}-{flavor}")
+        return True
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]✗ Git commit failed: {e}[/red]")
+        return False
+
+
+def git_tag(version: str, flavor: str) -> bool:
+    """Create git tag for release."""
+    tag = f"v{version}-{flavor}"
+    try:
+        subprocess.run(["git", "tag", tag], check=True)
+        console.print(f"[green]✓[/green] Tagged: {tag}")
+        return True
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]✗ Git tag failed: {e}[/red]")
+        return False

fship-0.1.0/src/fship/config.py

@@ -0,0 +1,151 @@
+import json
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+CONFIG_DIR = Path.cwd() / ".config"
+CONFIG_FILE = CONFIG_DIR / "fship.json"
+ENV_FILE = Path.cwd() / ".env.dev"
+
+DEFAULT_CFG = {
+    "flavors": {
+        "qa": {
+            "firebase_app_id_env": "APPIDANDROID_QA",
+            "entrypoint": "lib/main_qa.dart",
+            "apk_path": "build/app/outputs/flutter-apk/app-qa-release.apk",
+            "groups": "testers",
+        },
+        "uat": {
+            "firebase_app_id_env": "APPIDANDROID_UAT",
+            "entrypoint": "lib/main_uat.dart",
+            "apk_path": "build/app/outputs/flutter-apk/app-uat-release.apk",
+            "groups": "testers",
+        },
+        "prod": {
+            "firebase_app_id_env": "APPIDANDROID_PROD",
+            "entrypoint": "lib/main_prod.dart",
+            "apk_path": "build/app/outputs/flutter-apk/app-prod-release.apk",
+            "groups": "testers",
+        },
+    }
+}
+
+
+def load_env_file() -> None:
+    """Load environment variables from .env.dev if it exists."""
+    if not ENV_FILE.exists():
+        _create_env_template()
+        return
+
+    try:
+        for line in ENV_FILE.read_text().strip().split("\n"):
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" in line:
+                key, value = line.split("=", 1)
+                os.environ[key.strip()] = value.strip().strip("'\"")
+        console.print(f"[dim]Loaded env from {ENV_FILE}[/dim]")
+    except Exception as e:
+        console.print(f"[yellow]Warning: Failed to load {ENV_FILE}: {e}[/yellow]")
+
+
+def _create_env_template() -> None:
+    """Create .env.dev template and prompt user to fill in Android app IDs."""
+    template = """# Firebase Android App IDs for each flavor
+# Get these from Firebase Console > App settings
+
+APPIDANDROID_QA=
+APPIDANDROID_UAT=
+APPIDANDROID_PROD=
+"""
+    ENV_FILE.write_text(template)
+    console.print(f"[yellow]⚠  Created template: {ENV_FILE}[/yellow]")
+    console.print(f"[yellow]Please edit and add your Android app IDs:[/yellow]")
+    console.print(f"[dim]  APPIDANDROID_QA=1:123456:android:abcdef...[/dim]")
+    console.print(f"[dim]  APPIDANDROID_UAT=1:345678:android:ghijkl...[/dim]")
+    console.print(f"[dim]  APPIDANDROID_PROD=1:789012:android:mnopqr...[/dim]")
+    console.print(f"[dim]Get values from: Firebase Console > App settings[/dim]")
+    console.print()
+    raise SystemExit("Configure .env.dev and run again")
+
+
+@dataclass
+class FlavorConfig:
+    firebase_app_id_env: str
+    entrypoint: str
+    apk_path: str
+    groups: str
+
+
+@dataclass
+class Config:
+    flavors: dict[str, FlavorConfig]
+
+
+def load_config() -> Config:
+    """Load config from .config/fship.json or create with defaults."""
+    load_env_file()
+    CONFIG_DIR.mkdir(exist_ok=True)
+
+    if not CONFIG_FILE.exists():
+        CONFIG_FILE.write_text(json.dumps(DEFAULT_CFG, indent=2))
+        _ensure_gitignore()
+
+    try:
+        cfg = {**DEFAULT_CFG, **json.loads(CONFIG_FILE.read_text())}
+    except json.JSONDecodeError as e:
+        console.print(f"[red]✗ Invalid JSON in {CONFIG_FILE}: {e}[/red]")
+        raise
+
+    flavors = {}
+    for flavor_name, flavor_data in cfg.get("flavors", {}).items():
+        flavors[flavor_name] = FlavorConfig(
+            firebase_app_id_env=flavor_data["firebase_app_id_env"],
+            entrypoint=flavor_data["entrypoint"],
+            apk_path=flavor_data["apk_path"],
+            groups=flavor_data.get("groups", "testers"),
+        )
+
+    return Config(flavors=flavors)
+
+
+def save_config(config: dict) -> None:
+    """Save config to .config/fship.json."""
+    CONFIG_DIR.mkdir(exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(config, indent=2))
+    _ensure_gitignore()
+    console.print(f"[green]✓[/green] Config saved to {CONFIG_FILE}")
+
+
+def _ensure_gitignore() -> None:
+    """Add .config/ to .gitignore if git repo exists."""
+    gitignore = Path.cwd() / ".gitignore"
+    if not gitignore.exists():
+        return
+
+    content = gitignore.read_text()
+    if ".config/" not in content:
+        gitignore.write_text(content.rstrip() + "\n.config/\n")
+
+
+def require_config(*keys: str) -> dict:
+    """Load config and exit if required keys missing."""
+    cfg = load_config()
+    missing = [k for k in keys if k not in cfg.flavors]
+    if missing:
+        console.print(f"[red]✗ Missing flavors: {', '.join(missing)}[/red]")
+        console.print(f"[dim]Edit: {CONFIG_FILE}[/dim]")
+        sys.exit(1)
+    return cfg.__dict__
+
+
+def get_flavor(config: Config, flavor: str) -> FlavorConfig:
+    if flavor not in config.flavors:
+        available = ", ".join(config.flavors.keys())
+        raise ValueError(f"Unknown flavor '{flavor}'. Available: {available}")
+    return config.flavors[flavor]

fship-0.1.0/src/fship/distributor.py

@@ -0,0 +1,78 @@
+import os
+import subprocess
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+
+def distribute_to_firebase(
+    apk_path: str,
+    firebase_app_id_env: str,
+    groups: str = "testers",
+    release_notes_file: str = "release_note.txt",
+) -> bool:
+    """Distribute APK to Firebase App Distribution."""
+    app_id = os.getenv(firebase_app_id_env)
+
+    if not app_id:
+        console.print(
+            f"[red]✗ Environment variable {firebase_app_id_env} not set.[/red]\n"
+            f"[dim]Add to .env.dev: {firebase_app_id_env}=<your-app-id>[/dim]\n"
+            f"[dim]Or export: export {firebase_app_id_env}=<your-app-id>[/dim]"
+        )
+        return False
+
+    if not Path(apk_path).exists():
+        console.print(f"[red]✗ APK not found: {apk_path}[/red]")
+        return False
+
+    if not Path(release_notes_file).exists():
+        console.print(
+            f"[yellow]Warning: {release_notes_file} not found. Distributing without notes.[/yellow]"
+        )
+        cmd = [
+            "firebase",
+            "appdistribution:distribute",
+            apk_path,
+            "--app",
+            app_id,
+            "--groups",
+            groups,
+        ]
+    else:
+        cmd = [
+            "firebase",
+            "appdistribution:distribute",
+            apk_path,
+            "--app",
+            app_id,
+            "--release-notes-file",
+            release_notes_file,
+            "--groups",
+            groups,
+        ]
+
+    try:
+        console.print(f"[dim]$ {' '.join(cmd)}[/dim]")
+        result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+
+        if result.returncode != 0:
+            console.print(
+                f"[red]✗ Firebase distribution failed:[/red]\n{result.stderr[:500]}"
+            )
+            return False
+
+        console.print("[green]✓[/green] APK distributed to Firebase")
+        if "share-link" in result.stdout or "http" in result.stdout:
+            console.print(f"[dim]{result.stdout}[/dim]")
+        return True
+
+    except FileNotFoundError:
+        console.print(
+            "[red]✗ Firebase CLI not found. Install: npm install -g firebase-tools[/red]"
+        )
+        return False
+    except Exception as e:
+        console.print(f"[red]✗ Distribution failed: {e}[/red]")
+        return False

fship-0.1.0/src/fship/main.py

@@ -0,0 +1,191 @@
+import typer
+import os
+import json
+import sys
+from pathlib import Path
+from rich.console import Console
+from rich.prompt import Prompt
+from fship.config import load_config, get_flavor, CONFIG_FILE, CONFIG_DIR, save_config, DEFAULT_CFG
+from fship.runner import run_release
+
+app = typer.Typer(
+    help="fship — Flutter Ship. Orchestrate release workflows to Firebase App Distribution.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command()
+def release(
+    flavor: str = typer.Argument(
+        ..., help="Flavor to release (qa, uat, prod, or custom)"
+    ),
+    version: str = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Exact version to release (e.g. 1.2.4+46). Interactive if omitted.",
+    ),
+    bump: str = typer.Option(
+        None,
+        "--bump",
+        "-b",
+        help="Auto-increment version: patch, minor, or major. Resets build to 0.",
+    ),
+    skip_build: bool = typer.Option(
+        False, "--skip-build", help="Skip Flutter build step (for testing)"
+    ),
+    skip_distribute: bool = typer.Option(
+        False,
+        "--skip-distribute",
+        help="Skip Firebase distribution (for dry-run)",
+    ),
+):
+    """Release a flavor to Firebase App Distribution.
+
+    Examples:
+        fship release qa                    # Interactive version prompt
+        fship release qa --version 1.2.4+46  # Exact version
+        fship release qa --bump patch       # Auto-bump patch version
+        fship release prod --bump minor     # Bump minor, reset patch
+    """
+    try:
+        config = load_config()
+        flavor_config = get_flavor(config, flavor)
+    except (FileNotFoundError, ValueError) as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+    if bump and version:
+        console.print("[red]Error: Cannot specify both --version and --bump[/red]")
+        raise typer.Exit(1)
+
+    success = run_release(
+        flavor,
+        flavor_config,
+        version=version,
+        bump=bump,
+        skip_build=skip_build,
+        skip_distribute=skip_distribute,
+    )
+
+    raise typer.Exit(0 if success else 1)
+
+
+@app.command()
+def configure():
+    """Interactive setup: configure flavors and app IDs."""
+    CONFIG_DIR.mkdir(exist_ok=True)
+
+    if CONFIG_FILE.exists():
+        overwrite = Prompt.ask(
+            f"{CONFIG_FILE} already exists. Overwrite?",
+            choices=["y", "n"],
+            default="n",
+        )
+        if overwrite == "n":
+            console.print("[dim]Using existing config.[/dim]")
+            return
+
+    console.rule("[bold cyan]fship Configure[/bold cyan]")
+    console.print("Configure your Flutter release flavors.\n")
+
+    cfg = {"flavors": {}}
+
+    while True:
+        flavor_name = Prompt.ask("Flavor name (e.g. qa, uat, prod, or done to finish)")
+
+        if flavor_name.lower() == "done":
+            break
+
+        console.print(f"\n[cyan]{flavor_name}:[/cyan]")
+        firebase_app_id_env = Prompt.ask(
+            "  Firebase app ID env var",
+            default=f"FIREBASE_{flavor_name.upper()}_APP_ID",
+        )
+        entrypoint = Prompt.ask(
+            "  Entry point", default=f"lib/main_{flavor_name}.dart"
+        )
+        apk_path = Prompt.ask(
+            "  APK path",
+            default=f"build/app/outputs/flutter-apk/app-{flavor_name}-release.apk",
+        )
+        groups = Prompt.ask("  Firebase groups", default="testers")
+
+        cfg["flavors"][flavor_name] = {
+            "firebase_app_id_env": firebase_app_id_env,
+            "entrypoint": entrypoint,
+            "apk_path": apk_path,
+            "groups": groups,
+        }
+
+        console.print(f"[green]✓[/green] Added {flavor_name}\n")
+
+    if not cfg["flavors"]:
+        console.print("[red]No flavors configured. Aborting.[/red]")
+        raise typer.Exit(1)
+
+    save_config(cfg)
+    console.print(f"\n[green]✓ Config saved to {CONFIG_FILE}[/green]")
+
+
+@app.command()
+def validate():
+    """Validate config and required tools."""
+    try:
+        config = load_config()
+        console.print(f"[green]✓[/green] Config loaded from {CONFIG_FILE}\n")
+
+        console.print("[bold]Configured Flavors:[/bold]")
+        for flavor, cfg in config.flavors.items():
+            console.print(f"  [cyan]{flavor}:[/cyan] {cfg.entrypoint}")
+            app_id = os.getenv(cfg.firebase_app_id_env)
+            if app_id:
+                console.print(f"    [green]✓[/green] {cfg.firebase_app_id_env} set")
+            else:
+                console.print(
+                    f"    [yellow]⚠[/yellow] {cfg.firebase_app_id_env} not set"
+                )
+
+    except Exception as e:
+        console.print(f"[red]✗ Config validation failed: {e}[/red]")
+        raise typer.Exit(1)
+
+    tools = [
+        ("flutter", "flutter --version"),
+        ("firebase", "firebase --version"),
+        ("git", "git --version"),
+        ("git-chglog", "git-chglog --version"),
+    ]
+
+    console.print("\n[bold]Checking Tools:[/bold]")
+    import subprocess
+
+    for tool, cmd in tools:
+        try:
+            result = subprocess.run(
+                cmd.split(),
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                console.print(f"[green]✓[/green] {tool}")
+            else:
+                console.print(f"[yellow]⚠[/yellow] {tool} (not working)")
+        except FileNotFoundError:
+            console.print(f"[red]✗[/red] {tool} (not found)")
+        except Exception as e:
+            console.print(f"[yellow]⚠[/yellow] {tool} ({e})")
+
+
+@app.command()
+def version():
+    """Show fship version."""
+    from fship import __version__
+
+    console.print(f"fship {__version__}")
+
+
+if __name__ == "__main__":
+    app()

fship-0.1.0/src/fship/runner.py

@@ -0,0 +1,132 @@
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from fship.config import Config, FlavorConfig
+from fship.versioning import (
+    read_version,
+    write_version,
+    resolve_version,
+)
+from fship.changelog import (
+    generate_changelog,
+    generate_release_notes,
+    git_add_and_commit,
+    git_tag,
+)
+from fship.builder import build_apk
+from fship.distributor import distribute_to_firebase
+
+console = Console()
+
+
+def run_release(
+    flavor: str,
+    flavor_config: FlavorConfig,
+    version: str = None,
+    bump: str = None,
+    skip_build: bool = False,
+    skip_distribute: bool = False,
+) -> bool:
+    """Orchestrate full release flow."""
+
+    console.rule(f"[bold cyan]fship release {flavor}[/bold cyan]")
+
+    try:
+        current_version = read_version()
+        new_version = resolve_version(current_version, version, bump)
+
+        steps = [
+            ("Update pubspec.yaml", lambda: update_pubspec(new_version)),
+            ("Generate CHANGELOG.md", lambda: generate_changelog()),
+            ("Generate release notes", lambda: generate_release_notes(flavor)),
+            ("Commit & tag", lambda: commit_and_tag(new_version, flavor)),
+        ]
+
+        if not skip_build:
+            steps.append(
+                ("Build APK", lambda: build_apk_step(flavor, flavor_config))
+            )
+
+        if not skip_distribute:
+            steps.append(
+                (
+                    "Distribute to Firebase",
+                    lambda: distribute_step(flavor_config),
+                )
+            )
+
+        for step_name, step_fn in steps:
+            console.print(f"\n[bold blue]→[/bold blue] {step_name}")
+            if not step_fn():
+                console.print(f"\n[bold red]Release stopped at: {step_name}[/bold red]")
+                return False
+
+        console.print(
+            f"\n[bold green]✓ Release {new_version} to {flavor} complete![/bold green]"
+        )
+        show_summary(new_version, flavor)
+        return True
+
+    except Exception as e:
+        console.print(f"\n[bold red]Error: {e}[/bold red]")
+        return False
+
+
+def update_pubspec(version: str) -> bool:
+    """Update pubspec.yaml with new version."""
+    try:
+        current = read_version()
+        write_version(version)
+        console.print(f"[green]✓[/green] pubspec.yaml: {current} → {version}")
+        return True
+    except Exception as e:
+        console.print(f"[red]✗ Failed to update pubspec.yaml: {e}[/red]")
+        return False
+
+
+def commit_and_tag(version: str, flavor: str) -> bool:
+    """Stage, commit, and tag the release."""
+    if not git_add_and_commit(version, flavor):
+        return False
+    if not git_tag(version, flavor):
+        return False
+    return True
+
+
+def build_apk_step(flavor: str, flavor_config: FlavorConfig) -> tuple[bool, str]:
+    """Build APK and return (success, apk_path)."""
+    success, apk_path = build_apk(flavor, flavor_config.entrypoint)
+    if success:
+        console.print(f"[green]✓[/green] APK ready: {apk_path or 'built'}")
+    return success
+
+
+def distribute_step(flavor_config: FlavorConfig) -> bool:
+    """Distribute APK to Firebase."""
+    apk_path = flavor_config.apk_path
+    if not Path(apk_path).exists():
+        console.print(f"[red]✗ APK path not found: {apk_path}[/red]")
+        return False
+
+    return distribute_to_firebase(
+        apk_path,
+        flavor_config.firebase_app_id_env,
+        flavor_config.groups,
+    )
+
+
+def show_summary(version: str, flavor: str) -> None:
+    """Display summary table of what was done."""
+    table = Table(title=f"Release Summary: {version} → {flavor}")
+    table.add_column("Component", style="cyan")
+    table.add_column("Status", style="green")
+
+    table.add_row("Version Bumped", "pubspec.yaml updated")
+    table.add_row("Changelog", "CHANGELOG.md generated")
+    table.add_row("Release Notes", "release_note.txt generated")
+    table.add_row("Git Commit", f"chore: release {version}-{flavor}")
+    table.add_row("Git Tag", f"v{version}-{flavor}")
+    table.add_row("Build", "APK compiled")
+    table.add_row("Distribution", f"Firebase App Distribution")
+
+    console.print(table)

fship-0.1.0/src/fship/versioning.py

@@ -0,0 +1,92 @@
+from pathlib import Path
+from ruamel.yaml import YAML
+from rich.console import Console
+from rich.prompt import Prompt
+
+console = Console()
+
+
+def read_version(pubspec_path: Path = None) -> str:
+    """Read version from pubspec.yaml. Format: X.Y.Z+B"""
+    path = pubspec_path or Path.cwd() / "pubspec.yaml"
+
+    if not path.exists():
+        raise FileNotFoundError(f"pubspec.yaml not found at {path}")
+
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    yaml.default_flow_style = False
+
+    data = yaml.load(path)
+    return data.get("version", "0.0.0+0")
+
+
+def write_version(new_version: str, pubspec_path: Path = None) -> None:
+    """Write version to pubspec.yaml, preserving formatting."""
+    path = pubspec_path or Path.cwd() / "pubspec.yaml"
+
+    if not path.exists():
+        raise FileNotFoundError(f"pubspec.yaml not found at {path}")
+
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    yaml.default_flow_style = False
+
+    data = yaml.load(path)
+    data["version"] = new_version
+
+    with open(path, "w") as f:
+        yaml.dump(data, f)
+
+
+def parse_version(version_str: str) -> tuple[int, int, int, int]:
+    """Parse 'X.Y.Z+B' into (major, minor, patch, build)."""
+    parts = version_str.split("+")
+    semantic = parts[0].split(".")
+    build = int(parts[1]) if len(parts) > 1 else 0
+
+    return (
+        int(semantic[0]),
+        int(semantic[1]) if len(semantic) > 1 else 0,
+        int(semantic[2]) if len(semantic) > 2 else 0,
+        build,
+    )
+
+
+def format_version(major: int, minor: int, patch: int, build: int) -> str:
+    """Format (major, minor, patch, build) to 'X.Y.Z+B'."""
+    return f"{major}.{minor}.{patch}+{build}"
+
+
+def bump_version(current: str, part: str) -> str:
+    """Bump version part: 'patch', 'minor', or 'major'. Resets build to 0."""
+    major, minor, patch, build = parse_version(current)
+
+    if part == "patch":
+        patch += 1
+    elif part == "minor":
+        minor += 1
+        patch = 0
+    elif part == "major":
+        major += 1
+        minor = 0
+        patch = 0
+    else:
+        raise ValueError(f"Unknown bump part: {part}")
+
+    return format_version(major, minor, patch, 0)
+
+
+def resolve_version(current: str, version: str = None, bump: str = None) -> str:
+    """Resolve new version from flags or interactive prompt."""
+    if version:
+        return version
+
+    if bump:
+        new_version = bump_version(current, bump)
+        console.print(f"[cyan]{current}[/cyan] → [green]{new_version}[/green]")
+        return new_version
+
+    console.print(f"Current version: [cyan]{current}[/cyan]")
+    new_version = Prompt.ask("New version")
+    return new_version