pushpilot 1.1.0__py3-none-any.whl

autopush/detector.py

@@ -0,0 +1,342 @@
+"""
+Language, Framework, and Stack Detection for Autopush.
+Detects project stacks, component types, and supplies tailored .gitignore templates.
+"""
+
+import json
+from pathlib import Path
+from typing import NamedTuple
+
+
+class ProjectStack(NamedTuple):
+    language: str
+    framework: str | None
+    ecosystem: str
+    build_tool: str | None
+
+
+class StackDetector:
+    """Detects programming languages, frameworks, and architecture patterns."""
+
+    @classmethod
+    def detect(cls, root: Path) -> ProjectStack:
+        # Check Node.js / TypeScript / JavaScript
+        pkg_json = root / "package.json"
+        if pkg_json.is_file():
+            try:
+                with open(pkg_json, "r", encoding="utf-8", errors="ignore") as f:
+                    data = json.load(f)
+                deps = {
+                    **data.get("dependencies", {}),
+                    **data.get("devDependencies", {}),
+                }
+
+                framework = None
+                if "next" in deps:
+                    framework = "Next.js"
+                elif "react" in deps and "react-native" in deps:
+                    framework = "React Native"
+                elif "react" in deps:
+                    framework = "React"
+                elif "vue" in deps or "nuxt" in deps:
+                    framework = "Nuxt.js" if "nuxt" in deps else "Vue.js"
+                elif "@angular/core" in deps:
+                    framework = "Angular"
+                elif "svelte" in deps or "@sveltejs/kit" in deps:
+                    framework = "Svelte"
+                elif "@nestjs/core" in deps:
+                    framework = "NestJS"
+                elif "express" in deps:
+                    framework = "Express.js"
+                elif "vite" in deps:
+                    framework = "Vite App"
+
+                is_ts = any(root.glob("tsconfig*.json")) or "typescript" in deps
+                lang = "TypeScript" if is_ts else "JavaScript"
+                return ProjectStack(
+                    language=lang,
+                    framework=framework or "Node.js",
+                    ecosystem="npm/node",
+                    build_tool="npm" if not (root / "yarn.lock").exists() else "yarn",
+                )
+            except Exception:
+                pass
+
+        # Check Python
+        py_files = list(root.glob("*.py"))
+        req_txt = root / "requirements.txt"
+        pyproject = root / "pyproject.toml"
+        pipfile = root / "Pipfile"
+
+        if py_files or req_txt.exists() or pyproject.exists() or pipfile.exists():
+            framework = None
+            # Check for Django
+            if (root / "manage.py").exists() or any(root.glob("*/settings.py")):
+                framework = "Django"
+            else:
+                # Check requirements or imports
+                req_content = ""
+                if req_txt.is_file():
+                    req_content += req_txt.read_text(encoding="utf-8", errors="ignore")
+                if pyproject.is_file():
+                    req_content += pyproject.read_text(encoding="utf-8", errors="ignore")
+
+                req_lower = req_content.lower()
+                if "fastapi" in req_lower:
+                    framework = "FastAPI"
+                elif "flask" in req_lower:
+                    framework = "Flask"
+                elif "torch" in req_lower or "tensorflow" in req_lower:
+                    framework = "AI/Machine Learning"
+
+            return ProjectStack(
+                language="Python",
+                framework=framework or "Standard Python",
+                ecosystem="pip/python",
+                build_tool="poetry" if (root / "poetry.lock").exists() else "pip",
+            )
+
+        # Check Rust
+        if (root / "Cargo.toml").exists():
+            return ProjectStack(
+                language="Rust",
+                framework="Cargo App",
+                ecosystem="cargo",
+                build_tool="cargo",
+            )
+
+        # Check Go
+        if (root / "go.mod").exists() or list(root.glob("*.go")):
+            return ProjectStack(
+                language="Go",
+                framework="Go Module",
+                ecosystem="go",
+                build_tool="go",
+            )
+
+        # Check Flutter / Dart
+        if (root / "pubspec.yaml").exists():
+            content = (root / "pubspec.yaml").read_text(encoding="utf-8", errors="ignore")
+            is_flutter = "flutter:" in content
+            return ProjectStack(
+                language="Dart",
+                framework="Flutter" if is_flutter else "Dart Console",
+                ecosystem="pub",
+                build_tool="flutter" if is_flutter else "dart",
+            )
+
+        # Check Java / Kotlin
+        if (root / "pom.xml").exists():
+            return ProjectStack(
+                language="Java",
+                framework="Maven Project",
+                ecosystem="maven",
+                build_tool="mvn",
+            )
+        if (root / "build.gradle").exists() or (root / "build.gradle.kts").exists():
+            is_kotlin = (root / "build.gradle.kts").exists()
+            return ProjectStack(
+                language="Kotlin" if is_kotlin else "Java",
+                framework="Gradle Project",
+                ecosystem="gradle",
+                build_tool="gradle",
+            )
+
+        # Check C# / .NET
+        if list(root.glob("*.csproj")) or list(root.glob("*.sln")):
+            return ProjectStack(
+                language="C#",
+                framework=".NET Core / C#",
+                ecosystem="dotnet",
+                build_tool="dotnet",
+            )
+
+        # Check PHP
+        if (root / "composer.json").exists() or list(root.glob("*.php")):
+            framework = "Laravel" if (root / "artisan").exists() else "PHP App"
+            return ProjectStack(
+                language="PHP",
+                framework=framework,
+                ecosystem="composer",
+                build_tool="composer",
+            )
+
+        # Check Ruby
+        if (root / "Gemfile").exists():
+            framework = "Ruby on Rails" if (root / "bin" / "rails").exists() else "Ruby App"
+            return ProjectStack(
+                language="Ruby",
+                framework=framework,
+                ecosystem="rubygems",
+                build_tool="bundle",
+            )
+
+        # Default fallback
+        return ProjectStack(
+            language="Universal",
+            framework="Generic Project",
+            ecosystem="git",
+            build_tool=None,
+        )
+
+    @classmethod
+    def get_recommended_gitignore(cls, stack: ProjectStack) -> str:
+        """Returns recommended .gitignore rules tailored to the detected language and framework."""
+        common = """# OS & Editor temp files
+.DS_Store
+Thumbs.db
+*.swp
+*.bak
+.idea/
+.vscode/
+*.log
+.env
+.env.local
+.env.*.local
+"""
+        lang = stack.language.lower()
+        if "python" in lang:
+            return common + """
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.venv/
+env/
+venv/
+ENV/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.coverage
+htmlcov/
+"""
+        elif "javascript" in lang or "typescript" in lang or "node" in lang:
+            return common + """
+# Node & Web
+node_modules/
+dist/
+build/
+.next/
+out/
+.nuxt/
+.svelte-kit/
+.turbo/
+coverage/
+*.tsbuildinfo
+"""
+        elif "rust" in lang:
+            return common + """
+# Rust
+target/
+**/*.rs.bk
+Cargo.lock
+"""
+        elif "go" in lang:
+            return common + """
+# Go
+bin/
+pkg/
+*.exe
+*.test
+vendor/
+"""
+        elif "dart" in lang:
+            return common + """
+# Flutter & Dart
+.dart_tool/
+.packages
+build/
+.flutter-plugins
+.flutter-plugins-dependencies
+"""
+        elif "java" in lang or "kotlin" in lang:
+            return common + """
+# Java & Gradle / Maven
+target/
+build/
+.gradle/
+*.class
+*.jar
+*.war
+"""
+        elif "c#" in lang:
+            return common + """
+# .NET
+bin/
+obj/
+*.user
+*.suo
+"""
+        elif "php" in lang:
+            return common + """
+# PHP & Composer
+vendor/
+composer.phar
+.phpunit.result.cache
+"""
+        return common
+
+
+def classify_file_role(filepath: str) -> tuple[str, str]:
+    """Classifies a changed file into (category, component_name).
+    Returns category (e.g. 'ui', 'api', 'model', 'auth', 'test', 'docs', 'config')
+    and a clean component label.
+    """
+    path_obj = Path(filepath)
+    filename = path_obj.name.lower()
+    parts = [p.lower() for p in path_obj.parts]
+
+    # Documentation
+    if filename.endswith((".md", ".txt", ".rst")) or "doc" in parts or "docs" in parts:
+        return "docs", "documentation"
+
+    # Tests
+    if (
+        "test" in filename
+        or "spec" in filename
+        or "tests" in parts
+        or "test" in parts
+        or "__tests__" in parts
+    ):
+        stem = path_obj.stem.replace(".test", "").replace(".spec", "").replace("test_", "")
+        return "test", stem
+
+    # Configuration / Dependencies / Pipelines
+    if filename in (
+        "package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
+        "requirements.txt", "pyproject.toml", "pipfile", "pipfile.lock",
+        "cargo.toml", "cargo.lock", "go.mod", "go.sum", "pom.xml",
+        "build.gradle", "build.gradle.kts", "composer.json", "gemfile",
+        "dockerfile", "docker-compose.yml", "docker-compose.yaml",
+        ".gitignore", "tsconfig.json", "vite.config.ts", "vite.config.js"
+    ) or ".github" in parts:
+        return "config", path_obj.stem
+
+    # Authentication
+    if any(k in filename or k in parts for k in ("auth", "login", "register", "token", "session", "user", "jwt")):
+        return "auth", path_obj.stem
+
+    # API / Controllers / Routes
+    if any(k in filename or k in parts for k in ("api", "route", "controller", "endpoint", "handler", "viewset", "rpc")):
+        return "api", path_obj.stem
+
+    # Database / Models / Schemas
+    if any(k in filename or k in parts for k in ("model", "models", "schema", "entity", "migration", "migrations", "db")):
+        return "model", path_obj.stem
+
+    # Frontend Components & Views
+    if any(k in filename or k in parts for k in ("component", "components", "pages", "app", "views", "screens", "widgets")):
+        return "ui", path_obj.stem
+
+    # Styling
+    if filename.endswith((".css", ".scss", ".sass", ".less", ".tailwind")):
+        return "style", path_obj.stem
+
+    # Services / Utils / Helpers
+    if any(k in filename or k in parts for k in ("service", "services", "util", "utils", "helper", "helpers", "lib")):
+        return "service", path_obj.stem
+
+    return "core", path_obj.stem

autopush/git_ops.py

@@ -0,0 +1,256 @@
+"""
+Git Operations Layer for Autopush.
+Handles repository status, remote configuration, branch management,
+staging, committing, and upstream pushing.
+"""
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+from autopush.detector import ProjectStack, StackDetector
+
+
+class GitError(Exception):
+    pass
+
+
+def run_git(cmd: list[str], cwd: Path) -> tuple[int, str, str]:
+    """Execute git command and return (code, stdout, stderr)."""
+    try:
+        proc = subprocess.run(
+            ["git"] + cmd,
+            cwd=str(cwd),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+        return proc.returncode, proc.stdout.strip(), proc.stderr.strip()
+    except FileNotFoundError:
+        raise GitError("Git is not installed or not in PATH.")
+    except Exception as e:
+        raise GitError(str(e))
+
+
+def is_git_repo(root: Path) -> bool:
+    code, stdout, _ = run_git(["rev-parse", "--is-inside-work-tree"], cwd=root)
+    return code == 0 and stdout == "true"
+
+
+def get_current_branch(root: Path) -> str:
+    code, stdout, _ = run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd=root)
+    if code == 0 and stdout and stdout != "HEAD":
+        return stdout
+    code, stdout, _ = run_git(["symbolic-ref", "--short", "HEAD"], cwd=root)
+    if code == 0 and stdout:
+        return stdout
+    return "main"
+
+
+def get_remotes(root: Path) -> dict[str, str]:
+    """Returns mapping of remote name -> fetch URL."""
+    code, stdout, _ = run_git(["remote", "-v"], cwd=root)
+    if code != 0 or not stdout:
+        return {}
+    remotes = {}
+    for line in stdout.splitlines():
+        parts = line.split()
+        if len(parts) >= 2 and "(fetch)" in line:
+            remotes[parts[0]] = parts[1]
+    return remotes
+
+
+def ensure_gitignore(root: Path, stack: ProjectStack, interactive: bool = True) -> bool:
+    """Checks if .gitignore exists. If missing, creates a framework-tailored .gitignore."""
+    gitignore_path = root / ".gitignore"
+    if gitignore_path.exists():
+        return True
+
+    print(f"\n[NOTICE] No .gitignore found in this {stack.language} ({stack.framework or 'project'}) repository.")
+    content = StackDetector.get_recommended_gitignore(stack)
+    try:
+        gitignore_path.write_text(content, encoding="utf-8")
+        print(f"[OK] Generated framework-specific .gitignore for {stack.language} ({stack.framework or 'General'}).")
+        return True
+    except Exception as e:
+        print(f"[WARNING] Could not create .gitignore: {e}")
+        return False
+
+
+def setup_remote_interactive(root: Path) -> str | None:
+    """Prompts user to link a GitHub repository if none is configured."""
+    print("\n" + "=" * 60)
+    print(" GITHUB REPOSITORY SETUP")
+    print("=" * 60)
+    print("No GitHub remote repository is currently linked to this project.")
+    print("To auto-push, enter your GitHub repository URL.")
+    print("Examples:")
+    print("  - HTTPS: https://github.com/username/my-repo.git")
+    print("  - SSH:   git@github.com:username/my-repo.git\n")
+
+    try:
+        repo_url = input("Enter GitHub repository URL (or press Enter to skip): ").strip()
+    except (EOFError, KeyboardInterrupt):
+        return None
+
+    if not repo_url:
+        print("[INFO] Skipped remote setup.")
+        return None
+
+    # Clean URL
+    repo_url = repo_url.strip("'\"")
+
+    # Add remote
+    code, _, stderr = run_git(["remote", "add", "origin", repo_url], cwd=root)
+    if code == 0:
+        print(f"[OK] Linked remote 'origin': {repo_url}")
+        # Standardize default branch to main if in initial state
+        run_git(["branch", "-M", "main"], cwd=root)
+        return repo_url
+    else:
+        # Check if origin already existed and update it
+        run_git(["remote", "set-url", "origin", repo_url], cwd=root)
+        print(f"[OK] Updated remote 'origin': {repo_url}")
+        return repo_url
+
+
+def ensure_repo_ready(root: Path, repo_url: str | None = None, interactive: bool = True) -> tuple[bool, bool]:
+    """Ensures git is initialized and ready.
+    Returns (is_ready, remote_was_just_linked).
+    """
+    if not is_git_repo(root):
+        print(f"[INFO] Initializing new Git repository in: {root}")
+        code, stdout, stderr = run_git(["init"], cwd=root)
+        if code != 0:
+            raise GitError(f"Failed to initialize git repository: {stderr}")
+        run_git(["branch", "-M", "main"], cwd=root)
+        print("[OK] Git repository initialized with default branch 'main'.")
+
+    remotes = get_remotes(root)
+    remote_was_just_linked = False
+
+    if repo_url and repo_url.strip():
+        clean_url = repo_url.strip().strip("'\"")
+        if "origin" in remotes:
+            run_git(["remote", "set-url", "origin", clean_url], cwd=root)
+            print(f"[OK] Updated remote 'origin': {clean_url}")
+        else:
+            code, _, stderr = run_git(["remote", "add", "origin", clean_url], cwd=root)
+            if code != 0:
+                run_git(["remote", "set-url", "origin", clean_url], cwd=root)
+            print(f"[OK] Linked remote 'origin': {clean_url}")
+        run_git(["branch", "-M", "main"], cwd=root)
+        remote_was_just_linked = True
+    elif "origin" not in remotes and interactive:
+        linked_url = setup_remote_interactive(root)
+        if linked_url:
+            remote_was_just_linked = True
+
+    return True, remote_was_just_linked
+
+
+def get_git_status_changes(root: Path) -> list[tuple[str, str]]:
+    """Returns list of (status, filename) from git status --porcelain."""
+    code, stdout, stderr = run_git(["status", "--porcelain"], cwd=root)
+    if code != 0 or not stdout:
+        return []
+
+    changes = []
+    for line in stdout.splitlines():
+        if len(line) >= 3:
+            status = line[:2].strip()
+            filename = line[2:].strip().strip('"')
+            if filename:
+                changes.append((status, filename))
+    return changes
+
+
+def get_git_diff_summary(root: Path, max_chars: int = 3500) -> str:
+    """Returns a concise diff summary of staged, unstaged, and untracked changes."""
+    _, diff_unstaged, _ = run_git(["diff", "--no-color"], cwd=root)
+    _, diff_staged, _ = run_git(["diff", "--cached", "--no-color"], cwd=root)
+    _, status_out, _ = run_git(["status", "--short"], cwd=root)
+
+    combined = []
+    if status_out:
+        combined.append(f"Changed files:\n{status_out.strip()}\n")
+    if diff_staged:
+        combined.append(f"Staged changes:\n{diff_staged.strip()}\n")
+    if diff_unstaged:
+        combined.append(f"Working tree changes:\n{diff_unstaged.strip()}\n")
+
+    full_text = "\n".join(combined)
+    if len(full_text) > max_chars:
+        return full_text[:max_chars] + "\n... [diff truncated]"
+    return full_text
+
+
+def has_unpushed_commits(root: Path, remote: str = "origin", branch: str = "main") -> bool:
+    """Check if local commits exist that are not on remote."""
+    # 1. Does local branch have any commits?
+    code, head_commit, _ = run_git(["rev-parse", "HEAD"], cwd=root)
+    if code != 0 or not head_commit:
+        return False  # No commits in repository
+
+    # 2. Check if remote tracking branch exists locally
+    code, remote_commit, _ = run_git(["rev-parse", "--verify", f"{remote}/{branch}"], cwd=root)
+    if code != 0:
+        # Remote tracking branch does not exist locally (branch never pushed/fetched)
+        return True
+
+    # 3. If remote tracking branch exists, check if local is ahead
+    code, stdout, _ = run_git(["log", f"{remote}/{branch}..{branch}"], cwd=root)
+    return code == 0 and bool(stdout.strip())
+
+
+def stage_all(root: Path) -> None:
+    code, _, stderr = run_git(["add", "-A"], cwd=root)
+    if code != 0:
+        raise GitError(f"Failed to stage changes: {stderr}")
+
+
+def commit(root: Path, message: str) -> None:
+    code, stdout, stderr = run_git(["commit", "-m", message], cwd=root)
+    if code != 0:
+        raise GitError(f"Failed to commit: {stderr or stdout}")
+
+
+def pull_rebase(root: Path, remote: str, branch: str) -> bool:
+    # Attempt 1: Standard pull rebase with autostash
+    code, stdout, stderr = run_git(["pull", "--rebase", "--autostash", remote, branch], cwd=root)
+    if code == 0:
+        return True
+
+    # Clean up any paused rebase attempt
+    run_git(["rebase", "--abort"], cwd=root)
+
+    # Attempt 2: Pull rebase preferring local project files on conflict (-X ours)
+    # This automatically resolves conflicts when GitHub initialized a default README or .gitignore
+    code, stdout, stderr = run_git(["pull", "--rebase", "-X", "ours", remote, branch], cwd=root)
+    if code == 0:
+        return True
+
+    # If still stuck, abort cleanly so user's work tree is preserved
+    run_git(["rebase", "--abort"], cwd=root)
+    return False
+
+
+def push(root: Path, remote: str = "origin", branch: str = "main") -> bool:
+    """Push local branch to remote with upstream tracking."""
+    # First attempt: git push -u remote branch
+    code, stdout, stderr = run_git(["push", "-u", remote, branch], cwd=root)
+    if code == 0:
+        return True
+
+    err = (stderr or stdout).lower()
+    # If branch rejected because remote has commits not present locally:
+    if "fetch first" in err or "non-fast-forward" in err or "rejected" in err:
+        print("[INFO] Remote contains newer commits (e.g. GitHub initial commit). Syncing with local project...")
+        if pull_rebase(root, remote, branch):
+            code, stdout, stderr = run_git(["push", "-u", remote, branch], cwd=root)
+            if code == 0:
+                return True
+
+    raise GitError(f"Git push failed:\n{stderr or stdout}")