imp-git 0.0.26__py3-none-any.whl

imp/git.py

@@ -0,0 +1,428 @@
+import subprocess
+
+import typer
+
+from imp import console
+
+
+def _run (*args: str, check: bool = True, timeout: int = 60, env: dict [str, str] | None = None) -> subprocess.CompletedProcess [str]:
+   import os
+
+   run_env = None
+   if env:
+      run_env = { **os.environ, **env }
+
+   try:
+      return subprocess.run (
+         [ "git", *args ],
+         capture_output=True,
+         text=True,
+         check=check,
+         timeout=timeout,
+         env=run_env,
+      )
+   except subprocess.TimeoutExpired:
+      console.err (f"git {args [0]} timed out")
+      raise typer.Exit (1) from None
+
+
+def require ():
+   result = _run ("rev-parse", "--git-dir", check=False)
+   if result.returncode != 0:
+      console.err ("Not a git repository")
+      raise typer.Exit (1)
+
+
+def require_clean (hint: str = "imp commit first"):
+   if not is_clean ():
+      console.err ("Uncommitted changes")
+      console.hint (hint)
+      raise typer.Exit (1)
+
+
+def stage (all: bool = False):
+   if all:
+      _run ("add", "-A")
+
+
+def add (files: list [str]):
+   _run ("add", "--", *files)
+
+
+def staged_files () -> list [str]:
+   result = _run ("diff", "--cached", "--name-only", check=False)
+   return [ f.strip () for f in result.stdout.splitlines () if f.strip () ]
+
+
+def diff (staged: bool = False) -> str:
+   args = [ "diff" ]
+   if staged:
+      args.append ("--cached")
+
+   result = _run (*args)
+   return result.stdout
+
+
+def diff_range (rev_range: str, max_lines: int = 0) -> str:
+   args = [ "diff", rev_range ]
+   result = _run (*args, check=False)
+   text = result.stdout
+   if max_lines > 0:
+      lines = text.splitlines ()
+      text = "\n".join (lines [:max_lines])
+   return text
+
+
+def diff_names () -> list [str]:
+   staged = _run ("diff", "--cached", "--name-only", check=False).stdout.strip ()
+   unstaged = _run ("diff", "--name-only", check=False).stdout.strip ()
+   untracked = _run (
+      "ls-files", "--others", "--exclude-standard",
+      check=False,
+   ).stdout.strip ()
+
+   names = set ()
+   for block in [ staged, unstaged, untracked ]:
+      for line in block.splitlines ():
+         line = line.strip ()
+         if line:
+            names.add (line)
+
+   return sorted (names)
+
+
+def diff_file (path: str) -> str:
+   result = _run ("diff", "HEAD", "--", path, check=False)
+   text = result.stdout
+   if not text:
+      result = _run ("diff", "--cached", "--", path, check=False)
+      text = result.stdout
+   return text
+
+
+def diff_numstat () -> str:
+   staged = _run ("diff", "--cached", "--numstat", check=False).stdout.strip ()
+   unstaged = _run ("diff", "--numstat", check=False).stdout.strip ()
+   combined = ""
+   if staged:
+      combined += staged + "\n"
+   if unstaged:
+      combined += unstaged
+   return combined.strip ()
+
+
+def branch () -> str:
+   result = _run ("branch", "--show-current", check=False)
+   return result.stdout.strip ()
+
+
+def branches_local () -> list [str]:
+   result = _run ("branch", "--format=%(refname:short)", check=False)
+   return [ b.strip () for b in result.stdout.splitlines () if b.strip () ]
+
+
+def branches_merged (base: str) -> list [str]:
+   result = _run ("branch", "--merged", base, check=False)
+   current = branch ()
+   merged = []
+   for line in result.stdout.splitlines ():
+      name = line.removeprefix ("* ").strip ()
+      if name and name != base and name != current:
+         merged.append (name)
+   return merged
+
+
+def commit (msg: str, amend: bool = False, date: str = ""):
+   args = [ "commit", "-m", msg ]
+   if amend:
+      args.insert (1, "--amend")
+   if date:
+      args.extend ([ "--date", date ])
+
+   _run (*args, env={ "GIT_COMMITTER_DATE": date } if date else {})
+
+
+def commit_count () -> int:
+   result = _run ("rev-list", "--count", "HEAD", check=False)
+   try:
+      return int (result.stdout.strip ())
+   except ValueError:
+      return 0
+
+
+def is_clean () -> bool:
+   result = _run ("status", "--porcelain")
+   return result.stdout.strip () == ""
+
+
+def base_branch () -> str:
+   for name in [ "main", "master" ]:
+      result = _run ("rev-parse", "--verify", name, check=False)
+      if result.returncode == 0:
+         return name
+
+   return "main"
+
+
+def last_tag () -> str:
+   result = _run ("describe", "--tags", "--abbrev=0", check=False)
+   return result.stdout.strip ()
+
+
+def highest_tag () -> str:
+   result = _run ("tag", "-l", "v*", "--sort=-v:refname", check=False)
+   lines = result.stdout.strip ().splitlines ()
+   return lines [0].strip () if lines and lines [0].strip () else ""
+
+
+def tag (name: str):
+   _run ("tag", name)
+
+
+def tag_exists (name: str) -> bool:
+   result = _run ("rev-parse", name, check=False)
+   return result.returncode == 0
+
+
+def tag_delete (name: str):
+   _run ("tag", "-d", name, check=False)
+
+
+def has_upstream () -> bool:
+   result = _run ("rev-parse", "--verify", "@{u}", check=False)
+   return result.returncode == 0
+
+
+def count_ahead () -> int:
+   result = _run ("rev-list", "--count", "@{u}..HEAD", check=False)
+   try:
+      return int (result.stdout.strip ())
+   except ValueError:
+      return 0
+
+
+def count_behind () -> int:
+   result = _run ("rev-list", "--count", "HEAD..@{u}", check=False)
+   try:
+      return int (result.stdout.strip ())
+   except ValueError:
+      return 0
+
+
+def log_oneline (count: int = 10, rev_range: str = "") -> str:
+   args = [ "log", "--oneline" ]
+   if rev_range:
+      args.append (rev_range)
+   else:
+      args.extend ([ "-n", str (count) ])
+   result = _run (*args, check=False)
+   return result.stdout.strip ()
+
+
+def log_graph (count: int = 20, ref: str = "") -> str:
+   args = [
+      "log", "--oneline", "--graph",
+      "--decorate", "--color=always",
+      "-n", str (count),
+   ]
+   if ref:
+      args.append (ref)
+   result = _run (*args, check=False)
+   return result.stdout.strip ()
+
+
+def log_subjects (rev_range: str = "", count: int = 0) -> str:
+   args = [ "log", "--format=%s" ]
+   if rev_range:
+      args.append (rev_range)
+   elif count > 0:
+      args.extend ([ "-n", str (count) ])
+   result = _run (*args, check=False)
+   return result.stdout.strip ()
+
+
+def fetch (prune: bool = False):
+   args = [ "fetch" ]
+   if prune:
+      args.append ("--prune")
+   _run (*args, check=False)
+
+
+def rebase () -> bool:
+   result = _run ("rebase", check=False)
+   return result.returncode == 0
+
+
+def push (
+   force_lease: bool = False,
+   set_upstream: bool = False,
+   target: str = "",
+   ref: str = "",
+):
+   args = [ "push" ]
+   if force_lease:
+      args.append ("--force-with-lease")
+   if set_upstream:
+      args.extend ([ "-u", "origin" ])
+      if target:
+         args.append (target)
+   elif ref:
+      args.extend ([ "origin", ref ])
+   _run (*args)
+
+
+def merge (ref: str, no_ff: bool = False) -> bool:
+   args = [ "merge" ]
+   if no_ff:
+      args.append ("--no-ff")
+   args.append (ref)
+   result = _run (*args, check=False)
+   return result.returncode == 0
+
+
+def is_merged (branch_name: str, into: str) -> bool:
+   result = _run ("merge-base", "--is-ancestor", branch_name, into, check=False)
+   return result.returncode == 0
+
+
+def pull ():
+   _run ("pull", check=False)
+
+
+def revert_commit (ref: str, no_commit: bool = False):
+   args = [ "revert" ]
+   if no_commit:
+      args.append ("--no-commit")
+   args.append (ref)
+   _run (*args)
+
+
+def revert_abort ():
+   _run ("revert", "--abort", check=False)
+
+
+def reset (ref: str, soft: bool = False, hard: bool = False):
+   args = [ "reset" ]
+   if soft:
+      args.append ("--soft")
+   elif hard:
+      args.append ("--hard")
+   args.append (ref)
+   _run (*args)
+
+
+def checkout (ref: str, create: bool = False):
+   args = [ "checkout" ]
+   if create:
+      args.append ("-b")
+   args.append (ref)
+   _run (*args)
+
+
+def show (ref: str = "HEAD", fmt: str = "", stat: bool = False) -> str:
+   args = [ "show" ]
+   if fmt:
+      args.append (f"--format={fmt}")
+   else:
+      args.append ("--format=")
+   if stat:
+      args.append ("--stat")
+   args.append (ref)
+   result = _run (*args, check=False)
+   return result.stdout.strip ()
+
+
+def status_short () -> str:
+   result = _run ("status", "--short")
+   return result.stdout.strip ()
+
+
+def worktree_list () -> str:
+   result = _run ("worktree", "list", check=False)
+   return result.stdout.strip ()
+
+
+def remote_has_branch (name: str) -> bool:
+   result = _run ("ls-remote", "--heads", "origin", name, check=False)
+   return name in result.stdout
+
+
+def remote_exists () -> bool:
+   result = _run ("remote", check=False)
+   return result.stdout.strip () != ""
+
+
+def delete_branch (name: str, force: bool = False, remote: bool = False) -> bool:
+   if remote:
+      result = _run ("push", "origin", "--delete", name, check=False)
+      return result.returncode == 0
+   else:
+      flag = "-D" if force else "-d"
+      result = _run ("branch", flag, name, check=False)
+      return result.returncode == 0
+
+
+def unstage (files: list [str] | None = None):
+   if files:
+      if commit_count () > 0:
+         _run ("reset", "HEAD", "--", *files, check=False)
+      else:
+         _run ("rm", "--cached", "--", *files, check=False)
+   elif commit_count () > 0:
+      _run ("reset", "HEAD", check=False)
+   else:
+      _run ("rm", "-r", "--cached", ".", check=False)
+
+
+def repo_root () -> str:
+   result = _run ("rev-parse", "--show-toplevel", check=False)
+   return result.stdout.strip ()
+
+
+def repo_name () -> str:
+   from pathlib import Path
+   return Path (repo_root ()).name
+
+
+def rev_parse (ref: str) -> str:
+   result = _run ("rev-parse", ref, check=False)
+   return result.stdout.strip ()
+
+
+def rev_parse_short (ref: str) -> str:
+   result = _run ("rev-parse", "--short", ref, check=False)
+   return result.stdout.strip ()
+
+
+def conflicts () -> list [str]:
+   result = _run ("diff", "--name-only", "--diff-filter=U", check=False)
+   lines = result.stdout.strip ().splitlines ()
+   return [ line.strip () for line in lines if line.strip () ]
+
+
+def conflict_content (path: str) -> str:
+   from pathlib import Path
+
+   return Path (path).read_text ()
+
+
+def merge_in_progress () -> bool:
+   from pathlib import Path
+
+   git_dir = _run ("rev-parse", "--git-dir", check=False).stdout.strip ()
+   return Path (git_dir, "MERGE_HEAD").exists ()
+
+
+def rebase_in_progress () -> bool:
+   from pathlib import Path
+
+   git_dir = _run ("rev-parse", "--git-dir", check=False).stdout.strip ()
+   return (
+      Path (git_dir, "rebase-merge").exists ()
+      or Path (git_dir, "rebase-apply").exists ()
+   )
+
+
+def branch_age (name: str) -> str:
+   result = _run ("log", "-1", "--format=%cr", name, check=False)
+   return result.stdout.strip () or "unknown"

imp/main.py

@@ -0,0 +1,74 @@
+import typer
+from rich.console import Console
+
+from imp import __version__
+from imp.commands.amend import amend
+from imp.commands.branch import branch
+from imp.commands.clean import clean
+from imp.commands.commit import commit
+from imp.commands.config import configure
+from imp.commands.doctor import doctor
+from imp.commands.done import done
+from imp.commands.fix import fix
+from imp.commands.help import help
+from imp.commands.log import log
+from imp.commands.pr import pr
+from imp.commands.push import push
+from imp.commands.release import release
+from imp.commands.resolve import resolve
+from imp.commands.revert import revert
+from imp.commands.review import review
+from imp.commands.ship import ship
+from imp.commands.split import split
+from imp.commands.status import status
+from imp.commands.sync import sync
+from imp.commands.undo import undo
+
+app = typer.Typer (
+   name="imp",
+   no_args_is_help=True,
+   rich_markup_mode="rich",
+   add_completion=False,
+)
+
+
+def _version (value: bool):
+   if value:
+      Console ().print (f"imp {__version__}")
+      raise typer.Exit ()
+
+
+@app.callback ()
+def main (
+   version: bool | None = typer.Option (
+      None,
+      "--version", "-v",
+      help="Show version and exit",
+      callback=_version,
+      is_eager=True,
+   ),
+):
+   """[green]imp[/green] — AI-powered git workflow"""
+
+
+app.command () (amend)
+app.command () (branch)
+app.command () (clean)
+app.command () (commit)
+app.command ("config") (configure)
+app.command () (doctor)
+app.command () (done)
+app.command () (fix)
+app.command () (help)
+app.command () (log)
+app.command () (pr)
+app.command () (push)
+app.command () (release)
+app.command () (resolve)
+app.command () (revert)
+app.command () (review)
+app.command () (ship)
+app.command () (split)
+app.command () (status)
+app.command () (sync)
+app.command () (undo)

imp/prompts.py

@@ -0,0 +1,168 @@
+import re
+
+
+def _ticket_rule (branch: str) -> str:
+   match = re.search (r"([A-Z]+-[0-9]+)", branch)
+   if not match:
+      return ""
+
+   ticket = match.group (1)
+   return f'- Include ticket {ticket} after the type, e.g. "fix: {ticket} message"\n'
+
+
+def _whisper (text: str) -> str:
+   if not text:
+      return ""
+   return f"\nUser hint: {text}\n"
+
+
+def commit (diff: str, branch: str = "", whisper: str = "") -> str:
+   return f"""\
+Generate a Conventional Commits message for this diff.
+{_whisper (whisper)}\
+Format: type: message
+Types: feat, fix, refactor, build, chore, docs, test, style, perf, ci
+{_ticket_rule (branch)}
+Rules:
+- Subject only, one line, max 72 chars, no period
+- ALL LOWERCASE after the colon (except ticket IDs like IMP-123)
+- Imperative mood: "add" not "added", "fix" not "fixes"
+- Pick the type that best fits the primary change
+- No markdown, no backticks, no quotes
+- No body, no bullet points, just the subject line
+- Output will be validated against commitlint rules; it must pass
+
+Diff:
+{diff}
+
+Output ONLY the commit message, nothing else:"""
+
+
+def review (diff: str, whisper: str = "") -> str:
+   return f"""\
+Review this code diff. Be concise and actionable.
+{_whisper (whisper)}\
+Check for:
+- Bugs or logic errors
+- Security issues
+- Performance problems
+- Code style issues
+- Missing error handling
+
+If the code looks good, say so briefly.
+
+Diff:
+{diff}
+
+Output ONLY the review:"""
+
+
+def branch_name (description: str, whisper: str = "") -> str:
+   return f"""\
+Suggest a git branch name for: {description}
+{_whisper (whisper)}\
+Rules:
+- Lowercase, hyphens only, no spaces
+- Max 30 chars
+- Format: type/short-name
+- Types: feat, fix, refactor, docs, test, chore
+
+Output ONLY the branch name:"""
+
+
+def revert (commit_msg: str, diff: str, whisper: str = "") -> str:
+   return f"""\
+Generate a commit message for reverting this change. Start with 'Revert:'. Max 50 chars:
+{_whisper (whisper)}\
+Original: {commit_msg}
+
+Changes reverted:
+{diff}
+
+Output ONLY the commit message:"""
+
+
+def fix (title: str, body: str, whisper: str = "") -> str:
+   return f"""\
+Suggest a git branch name for fixing this issue:
+{_whisper (whisper)}\
+Title: {title}
+Description: {body}
+
+Rules:
+- Lowercase, hyphens only
+- Max 30 chars
+- Format: fix/<short-name>
+- Include issue number if fits
+
+Output ONLY the branch name:"""
+
+
+def pr (branch: str, log: str, diff: str, whisper: str = "") -> str:
+   return f"""\
+Generate a GitHub pull request title and description.
+{_whisper (whisper)}\
+Branch: {branch}
+Commits:
+{log}
+
+Diff summary:
+{diff}
+
+Format:
+TITLE: <50 char title>
+
+DESCRIPTION:
+## Summary
+<2-3 bullet points>
+
+## Changes
+<list main changes>
+
+Output ONLY in this format:"""
+
+
+def split (file_diffs: str, branch: str = "", whisper: str = "") -> str:
+   return f"""\
+Group these changed files into logical commits. Each group = one commit.
+{_whisper (whisper)}\
+Format: type: message
+Types: feat, fix, refactor, build, chore, docs, test, style, perf, ci
+{_ticket_rule (branch)}
+Rules:
+- Output a JSON array, no markdown fences, no explanation
+- Each element: {{"files": ["path1", "path2"], "message": "type: description"}}
+- ALL LOWERCASE after the colon (except ticket IDs like IMP-123)
+- Imperative mood: "add" not "added", "fix" not "fixes"
+- Max 72 chars per message, no period at end
+- Every file must appear in exactly one group
+- Minimize number of groups (prefer fewer, larger groups)
+- Group by logical change, not by directory
+
+Branch: {branch}
+
+File diffs:
+{file_diffs}
+
+Output ONLY the JSON array:"""
+
+
+def resolve (content: str, path: str, ours: str, theirs: str, whisper: str = "") -> str:
+   return f"""\
+Resolve all merge conflicts in this file.
+{_whisper (whisper)}\
+Branches:
+- Ours (current): {ours}
+- Theirs (incoming): {theirs}
+
+File: {path}
+
+Rules:
+- Resolve every conflict marked by <<<<<<<, =======, >>>>>>>
+- Preserve all non-conflicted code exactly as-is
+- Output the complete resolved file, nothing else
+- No explanation, no markdown fences, no commentary
+
+{content}
+
+Output ONLY the resolved file:"""

imp/theme.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+
+@dataclass (frozen=True)
+class Theme:
+   accent: str = "#1eff00"
+   success: str = "#00ff00"
+   error: str = "#ff3131"
+   warning: str = "#ff8000"
+   muted: str = "#4e7a4e"
+   highlight: str = "#a335ee"
+
+
+theme = Theme ()

imp/validate.py

@@ -0,0 +1,28 @@
+import re
+
+_COMMIT_RE = re.compile (
+   r"^(feat|fix|refactor|build|chore|docs|test|style|perf|ci)"
+   r"(\(.+\))?!?: .+"
+)
+
+_TICKET_RE = re.compile (r"^[A-Z]+-[0-9]")
+
+_BRANCH_RE = re.compile (r"^[a-zA-Z0-9][a-zA-Z0-9/_.-]*$")
+
+
+def commit (msg: str) -> bool:
+   subject = msg.split ("\n", 1) [0]
+
+   if not _COMMIT_RE.match (subject):
+      return False
+
+   parts = subject.split (": ", 1)
+   if len (parts) < 2 or not parts [1]:
+      return False
+
+   desc = parts [1]
+   return not (desc [0].isupper () and not _TICKET_RE.match (desc))
+
+
+def branch (name: str) -> bool:
+   return bool (_BRANCH_RE.match (name))