pushpilot 1.1.0__py3-none-any.whl

autopush/cli.py

@@ -0,0 +1,316 @@
+"""
+Autopush Command-Line Interface.
+Professional multi-language & multi-framework Git automation.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+# Ensure UTF-8 console output on Windows
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+if hasattr(sys.stderr, "reconfigure"):
+    sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+
+from autopush import __version__
+from autopush.commit_gen import generate_commit_message
+from autopush.detector import StackDetector
+from autopush.git_ops import (
+    GitError,
+    commit,
+    ensure_gitignore,
+    ensure_repo_ready,
+    get_current_branch,
+    get_git_diff_summary,
+    get_git_status_changes,
+    get_remotes,
+    has_unpushed_commits,
+    is_git_repo,
+    push,
+    setup_remote_interactive,
+    stage_all,
+)
+from autopush.watcher import FeatureWatcher
+
+
+def banner():
+    print(
+        f"""
+╔═════════════════════════════════════════════════════════════╗
+║                   PUSHPILOT v{__version__}                          ║
+║   Intelligent Multi-Framework Git & GitHub Autopilot        ║
+╚═════════════════════════════════════════════════════════════╝
+"""
+    )
+
+
+def run_single_sync(
+    root: Path,
+    repo_url: str | None = None,
+    message: str | None = None,
+    branch: str | None = None,
+    remote: str = "origin",
+    dry_run: bool = False,
+    interactive: bool = True,
+    allow_ai: bool = True,
+) -> bool:
+    """Performs a full automated check, stage, commit, and push cycle."""
+    # Disable interactive prompts if dry_run or stdin is not a terminal
+    if dry_run or not sys.stdin.isatty():
+        interactive = False
+
+    # 1. Detect Stack
+    stack = StackDetector.detect(root)
+    print(f"[STACK] Detected: {stack.language} | Framework: {stack.framework or 'None'} | Ecosystem: {stack.ecosystem}")
+
+    # 2. Ensure Git & Remote Setup
+    ready, remote_was_just_linked = ensure_repo_ready(root, repo_url=repo_url, interactive=interactive)
+
+    # 3. Ensure .gitignore
+    ensure_gitignore(root, stack, interactive=interactive)
+
+    # Active branch and remotes
+    active_branch = branch or get_current_branch(root)
+    remotes = get_remotes(root)
+
+    print(f"[BRANCH] Active Branch : {active_branch}")
+    if remote in remotes:
+        print(f"[REMOTE] Target Remote : {remote} ({remotes[remote]})")
+    else:
+        print(f"[REMOTE] Warning: Remote '{remote}' is not configured.")
+
+    # 4. Check Changes
+    changes = get_git_status_changes(root)
+    if not changes:
+        remotes = get_remotes(root)
+        if remote in remotes and (remote_was_just_linked or has_unpushed_commits(root, remote, active_branch)):
+            print("[INFO] Working tree clean, but unpushed commits exist. Pushing to GitHub...")
+            if not dry_run:
+                try:
+                    push(root, remote, active_branch)
+                    print(f"\n[SUCCESS] Pushed all commits to GitHub ({remote}/{active_branch}) successfully!")
+                except GitError as e:
+                    print(f"\n[ERROR] Push failed: {e}")
+                    return False
+            else:
+                print(f"[DRY-RUN] Would push to {remote}/{active_branch}")
+            return True
+        else:
+            print("[INFO] Working tree clean and up to date with remote. Nothing to push.")
+            return True
+
+    print(f"[CHANGES] Detected {len(changes)} modified/new file(s):")
+    for status, file_path in changes[:8]:
+        print(f"   [{status or '?'}] {file_path}")
+    if len(changes) > 8:
+        print(f"   ... and {len(changes) - 8} more file(s)")
+
+    # 5. Generate Commit Message
+    diff_summary = get_git_diff_summary(root)
+    commit_msg, ai_source = generate_commit_message(
+        changes,
+        stack,
+        custom_msg=message,
+        root=root,
+        diff_summary=diff_summary,
+        allow_ai=allow_ai,
+    )
+    if ai_source:
+        print(f"[AI] Detected coding with AI: {ai_source}")
+        print(f"[COMMIT] AI-Generated Message: \"{commit_msg}\"")
+    else:
+        print(f"[COMMIT] Generated Message: \"{commit_msg}\"")
+
+    if dry_run:
+        print(f"[DRY-RUN] Would stage all files ('git add -A')")
+        print(f"[DRY-RUN] Would commit with message: \"{commit_msg}\"")
+        if remote in remotes:
+            print(f"[DRY-RUN] Would push to {remote}/{active_branch}")
+        return True
+
+    # 6. Stage & Commit
+    print("[STAGING] Staging all files...")
+    stage_all(root)
+
+    print("[COMMITTING] Committing changes...")
+    commit(root, commit_msg)
+    print("[SUCCESS] Changes committed successfully.")
+
+    # 7. Push to Remote
+    remotes = get_remotes(root)
+    if remote not in remotes:
+        print(f"\n[NOTICE] Remote '{remote}' not linked yet.")
+        if interactive:
+            new_remote = setup_remote_interactive(root)
+            if not new_remote:
+                print("[INFO] Commit saved locally. Link a remote when you are ready to push.")
+                return True
+        else:
+            print(f"[WARNING] Remote '{remote}' not configured. Run 'auto-push <repo-url>' to link a GitHub repo.")
+            return True
+
+    print(f"[PUSHING] Pushing to GitHub ({remote}/{active_branch})...")
+    try:
+        push(root, remote, active_branch)
+        print(f"\n[SUCCESS] Feature pushed to GitHub ({remote}/{active_branch}) successfully!")
+        return True
+    except GitError as e:
+        print(f"\n[ERROR] Push failed: {e}")
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="pushpilot",
+        description="PushPilot - Intelligent Multi-Framework Git & GitHub Autopilot.",
+    )
+    parser.add_argument(
+        "repo_url",
+        nargs="?",
+        default=None,
+        help="Optional GitHub repository URL (e.g. https://github.com/user/repo.git). Automatically initializes git and links remote.",
+    )
+    parser.add_argument(
+        "-m", "--message",
+        type=str,
+        default=None,
+        help="Custom commit message (if omitted, conventional semantic message is generated).",
+    )
+    parser.add_argument(
+        "-w", "--watch",
+        action="store_true",
+        help="Enable Feature-Watcher mode: monitors files and auto-pushes when features are completed.",
+    )
+    parser.add_argument(
+        "--cooldown",
+        type=float,
+        default=8.0,
+        help="Feature completion settlement window in seconds for watch mode (default: 8.0s).",
+    )
+    parser.add_argument(
+        "-b", "--branch",
+        type=str,
+        default=None,
+        help="Target git branch (default: active branch).",
+    )
+    parser.add_argument(
+        "-r", "--remote",
+        type=str,
+        default="origin",
+        help="Git remote name (default: 'origin').",
+    )
+    parser.add_argument(
+        "--setup",
+        action="store_true",
+        help="Interactive GitHub repository setup / change remote URL.",
+    )
+    parser.add_argument(
+        "--detect",
+        action="store_true",
+        help="Inspect detected language, framework, ecosystem, and build tools for this project.",
+    )
+    parser.add_argument(
+        "--init-gitignore",
+        action="store_true",
+        help="Generate or reset a framework-tailored .gitignore file.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Simulate actions without staging, committing, or pushing.",
+    )
+    parser.add_argument(
+        "--no-ai",
+        action="store_true",
+        help="Disable AI commit message generation and force default rule-based message.",
+    )
+    parser.add_argument(
+        "--ai",
+        action="store_true",
+        help="Explicitly enable AI commit message generation (auto-detected by default).",
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"PushPilot v{__version__}",
+    )
+
+    args = parser.parse_args()
+    root = Path.cwd()
+    allow_ai = not args.no_ai
+
+    banner()
+
+    # --detect command
+    if args.detect:
+        stack = StackDetector.detect(root)
+        print("=" * 50)
+        print(" PROJECT STACK INSPECTION")
+        print("=" * 50)
+        print(f"Language   : {stack.language}")
+        print(f"Framework  : {stack.framework or 'None / Standard'}")
+        print(f"Ecosystem  : {stack.ecosystem}")
+        print(f"Build Tool : {stack.build_tool or 'None detected'}")
+        print(f"Git Repo   : {'Yes' if is_git_repo(root) else 'No (run auto-push to initialize)'}")
+        remotes = get_remotes(root) if is_git_repo(root) else {}
+        print(f"Remotes    : {remotes or 'None'}")
+        return
+
+    # --init-gitignore command
+    if args.init_gitignore:
+        stack = StackDetector.detect(root)
+        ensure_gitignore(root, stack, interactive=False)
+        return
+
+    # --setup command
+    if args.setup:
+        ensure_repo_ready(root, repo_url=args.repo_url, interactive=False)
+        setup_remote_interactive(root)
+        return
+
+    # --watch mode
+    if args.watch:
+        stack = StackDetector.detect(root)
+        ensure_repo_ready(root, repo_url=args.repo_url, interactive=True)
+        ensure_gitignore(root, stack, interactive=True)
+
+        def on_feature_complete(changes):
+            run_single_sync(
+                root=root,
+                repo_url=args.repo_url,
+                message=args.message,
+                branch=args.branch,
+                remote=args.remote,
+                dry_run=args.dry_run,
+                interactive=False,
+                allow_ai=allow_ai,
+            )
+
+        watcher = FeatureWatcher(
+            root=root,
+            stack=stack,
+            on_feature_complete=on_feature_complete,
+            settle_window_sec=args.cooldown,
+        )
+        watcher.start()
+        return
+
+    # Default: One-command sync
+    success = run_single_sync(
+        root=root,
+        repo_url=args.repo_url,
+        message=args.message,
+        branch=args.branch,
+        remote=args.remote,
+        dry_run=args.dry_run,
+        interactive=True,
+        allow_ai=allow_ai,
+    )
+
+    if not success:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

autopush/commit_gen.py

@@ -0,0 +1,144 @@
+"""
+Conventional Commit Message Generator.
+Generates human-readable, semantic, and professional commit messages:
+1. If the developer is coding with AI (Google Antigravity, Cursor, Aider,
+   Claude Code, Cline, or configured Gemini/OpenAI/Anthropic/Groq/Ollama APIs),
+   it leverages the internal AI context to produce an ultra-accurate commit message.
+2. If the developer is not coding with AI, it automatically falls back to the
+   default rule-based heuristic generator.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from autopush.detector import ProjectStack, classify_file_role
+
+
+def generate_default_commit_message(
+    changes: list[tuple[str, str]],
+    stack: ProjectStack,
+) -> str:
+    """Default rule-based conventional commit generator (used when not coding with AI)."""
+    if not changes:
+        return f"chore: sync project updates [{stack.language}]"
+
+    # Analyze change classifications
+    roles: dict[str, list[str]] = {}
+    actions = {"add": 0, "modify": 0, "delete": 0}
+
+    for status, file_path in changes:
+        if "?" in status or "A" in status:
+            actions["add"] += 1
+        elif "D" in status:
+            actions["delete"] += 1
+        else:
+            actions["modify"] += 1
+
+        role, comp = classify_file_role(file_path)
+        roles.setdefault(role, []).append(Path(file_path).name)
+
+    # Determine primary role
+    # Priority: auth > api > ai > model > ui > service > test > docs > config > core
+    priority_order = ["auth", "api", "ai", "model", "ui", "service", "test", "docs", "config", "core"]
+    primary_role = "core"
+    for r in priority_order:
+        if r in roles:
+            primary_role = r
+            break
+
+    # Determine Conventional Commit Prefix
+    if primary_role == "docs":
+        prefix = "docs"
+    elif primary_role == "test":
+        prefix = "test"
+    elif primary_role == "config":
+        prefix = "chore(deps)" if any("package" in f or "req" in f or "cargo" in f for f in roles[primary_role]) else "chore(config)"
+    elif actions["add"] > actions["modify"]:
+        prefix = f"feat({primary_role})"
+    elif actions["delete"] > (actions["add"] + actions["modify"]):
+        prefix = f"refactor({primary_role})"
+    else:
+        prefix = f"refactor({primary_role})" if actions["modify"] > 0 else f"feat({primary_role})"
+
+    # Construct descriptive subject
+    primary_files = roles.get(primary_role, [Path(changes[0][1]).name])
+    file_sample = primary_files[0]
+    stem_name = Path(file_sample).stem.replace("_", " ").replace("-", " ").title()
+
+    if primary_role == "docs":
+        subject = "update project documentation and guides"
+    elif primary_role == "config":
+        subject = "update configuration and dependencies"
+    elif primary_role == "test":
+        subject = f"add/update test suite for {stem_name}"
+    elif primary_role == "auth":
+        subject = f"implement authentication workflow ({stem_name})"
+    elif primary_role == "api":
+        subject = f"update API endpoints and handlers ({stem_name})"
+    elif primary_role == "model":
+        subject = f"update database schemas and data models ({stem_name})"
+    elif primary_role == "ui":
+        subject = f"update UI components and layouts ({stem_name})"
+    elif primary_role == "style":
+        subject = f"improve styling and visual presentation ({stem_name})"
+    elif primary_role == "ai":
+        subject = f"integrate AI-assisted features and enhancements ({stem_name})"
+    else:
+        if actions["add"] > 0 and actions["modify"] == 0:
+            subject = f"add new {stem_name} module"
+        elif actions["delete"] > 0 and actions["add"] == 0:
+            subject = f"clean up and remove {stem_name}"
+        else:
+            subject = f"update {stem_name} and related features"
+
+    # Context tag if framework is detected
+    fw_tag = f" in {stack.framework}" if stack.framework and stack.framework != "Generic Project" else ""
+
+    return f"{prefix}: {subject}{fw_tag}"
+
+
+def generate_commit_message(
+    changes: list[tuple[str, str]],
+    stack: ProjectStack,
+    custom_msg: Optional[str] = None,
+    root: Optional[Path] = None,
+    diff_summary: Optional[str] = None,
+    allow_ai: bool = True,
+) -> tuple[str, Optional[str]]:
+    """
+    Generates a professional conventional commit message.
+
+    Workflow:
+    1. If user provided a custom commit message (-m / --message), use it directly.
+    2. If allow_ai is True, checks if the developer is coding with AI (Antigravity IDE,
+       Cursor, Aider, Claude Code, Cline, or configured Gemini/OpenAI/Anthropic/Groq/Ollama APIs).
+       If AI is detected, generates an accurate message using the internal AI context.
+    3. If the developer is NOT coding with AI, seamlessly uses the default heuristic generator.
+
+    Returns:
+        (commit_message, ai_source_description_or_none)
+    """
+    if custom_msg and custom_msg.strip():
+        return custom_msg.strip(), None
+
+    if not changes:
+        return f"chore: sync project updates [{stack.language}]", None
+
+    # Check internal AI if enabled
+    if allow_ai:
+        try:
+            from autopush.ai_commit import generate_ai_commit_message
+            ai_msg, ai_source = generate_ai_commit_message(
+                changes=changes,
+                stack=stack,
+                diff_summary=diff_summary or "",
+                root=root or Path.cwd(),
+            )
+            if ai_msg:
+                return ai_msg, ai_source
+        except Exception:
+            pass
+
+    # Seamless fallback to default rule-based commit generator
+    default_msg = generate_default_commit_message(changes, stack)
+    return default_msg, None