imp-git 0.0.26__py3-none-any.whl

imp/commands/resolve.py

@@ -0,0 +1,161 @@
+import subprocess
+from pathlib import Path
+
+import typer
+from rich.panel import Panel
+
+from imp import ai, console, git, prompts
+from imp.theme import theme
+
+MARKER = "<<<<<<<"
+
+
+def _theirs_branch () -> str:
+   git_dir = subprocess.run (
+      [ "git", "rev-parse", "--git-dir" ],
+      capture_output=True,
+      text=True,
+      check=False,
+   ).stdout.strip ()
+
+   merge_msg = Path (git_dir, "MERGE_MSG")
+   if merge_msg.exists ():
+      first_line = merge_msg.read_text ().splitlines () [0]
+      parts = first_line.split ("'")
+      if len (parts) >= 2:
+         return parts [1]
+
+   return "incoming"
+
+
+def _checkout_ours (path: str):
+   subprocess.run (
+      [ "git", "checkout", "--ours", "--", path ],
+      check=True,
+      capture_output=True,
+   )
+
+
+def _checkout_theirs (path: str):
+   subprocess.run (
+      [ "git", "checkout", "--theirs", "--", path ],
+      check=True,
+      capture_output=True,
+   )
+
+
+def resolve (
+   whisper: str = typer.Option ("", "--whisper", "-w", help="Hint to guide the AI"),
+):
+   """Resolve merge conflicts with AI assistance.
+
+   Walks through each conflicted file, sends it to AI for resolution,
+   and lets you accept, edit, or choose ours/theirs for each file.
+   """
+
+   git.require ()
+
+   files = git.conflicts ()
+   if not files:
+      console.muted ("No conflicts to resolve")
+      raise typer.Exit (0)
+
+   console.header ("Resolve")
+
+   console.label (f"{len (files)} conflicted file(s)")
+   for f in files:
+      console.item (f)
+   console.out.print ()
+
+   ours = git.branch () or "HEAD"
+   theirs = _theirs_branch ()
+
+   num_resolved = 0
+   num_skipped = 0
+
+   for path in files:
+      console.label (path)
+
+      content = git.conflict_content (path)
+      has_markers = MARKER in content
+
+      if not has_markers:
+         console.muted ("No conflict markers (delete/rename conflict)")
+
+         choice = console.choose (
+            "Resolution",
+            [ "Keep", "Delete", "Skip" ],
+         )
+
+         if choice == "Keep":
+            git.add ([ path ])
+            num_resolved += 1
+         elif choice == "Delete":
+            subprocess.run (
+               [ "git", "rm", "--", path ],
+               check=True,
+               capture_output=True,
+            )
+            num_resolved += 1
+         else:
+            num_skipped += 1
+
+         continue
+
+      result = ai.smart (prompts.resolve (content, path, ours, theirs, whisper))
+
+      if MARKER in result:
+         console.warn ("AI left conflict markers, retrying...")
+         result = ai.smart (prompts.resolve (content, path, ours, theirs, whisper))
+
+         if MARKER in result:
+            console.warn ("AI still left markers, showing best attempt")
+
+      console.out.print (Panel (
+         result,
+         border_style=theme.accent,
+         title=path,
+         title_align="left",
+         padding=(1, 2),
+      ))
+      console.out.print ()
+
+      choice = console.choose (
+         "Resolution",
+         [ "AI suggestion", "Ours", "Theirs", "Edit", "Skip" ],
+      )
+
+      if choice == "AI suggestion":
+         Path (path).write_text (result)
+         git.add ([ path ])
+         num_resolved += 1
+      elif choice == "Ours":
+         _checkout_ours (path)
+         git.add ([ path ])
+         num_resolved += 1
+      elif choice == "Theirs":
+         _checkout_theirs (path)
+         git.add ([ path ])
+         num_resolved += 1
+      elif choice == "Edit":
+         edited = console.edit (result)
+         if edited.strip ():
+            Path (path).write_text (edited)
+            git.add ([ path ])
+            num_resolved += 1
+         else:
+            console.muted ("Empty content, skipped")
+            num_skipped += 1
+      else:
+         num_skipped += 1
+
+   console.out.print ()
+   console.success (f"{num_resolved} resolved, {num_skipped} skipped")
+
+   if num_skipped == 0 and num_resolved > 0:
+      if git.merge_in_progress ():
+         console.hint ("git merge --continue")
+      elif git.rebase_in_progress ():
+         console.hint ("git rebase --continue")
+      else:
+         console.hint ("All conflicts resolved")

imp/commands/revert.py

@@ -0,0 +1,83 @@
+import typer
+
+from imp import ai, console, git, prompts
+
+
+def revert (
+   ref: str | None = typer.Argument (None, help="Commit hash to revert"),
+   whisper: str = typer.Option ("", "--whisper", "-w", help="Hint to guide the AI"),
+):
+   """Safely revert a pushed commit.
+
+   Pass a commit hash, or omit it to pick from the last 10 commits
+   interactively. Shows the changes that will be undone, then uses AI to
+   generate a revert commit message that you can review or edit before
+   committing.
+   """
+
+   git.require ()
+
+   console.header ("Revert")
+
+   if not ref:
+      log = git.log_oneline (count=10)
+      if not log:
+         console.muted ("No commits to revert")
+         raise typer.Exit (0)
+
+      lines = log.splitlines ()
+      choice = console.choose ("Select commit to revert:", lines)
+      ref = choice.split (" ", 1) [0]
+
+   if not ref:
+      console.muted ("Cancelled")
+      raise typer.Exit (0)
+
+   if not git.rev_parse (ref):
+      console.err (f"Invalid commit: {ref}")
+      raise typer.Exit (1)
+
+   commit_msg = git.show (ref, fmt="%s")
+   commit_hash = git.rev_parse_short (ref)
+
+   console.label ("Reverting")
+   console.item (f"{commit_hash} {commit_msg}")
+   console.out.print ()
+
+   stat = git.show (ref, stat=True)
+   if stat:
+      console.muted ("Changes to undo:")
+      for line in stat.splitlines ():
+         if line.strip ():
+            console.item (line)
+      console.out.print ()
+
+   if not console.confirm ("Create revert commit?"):
+      console.muted ("Cancelled")
+      raise typer.Exit (0)
+
+   d = git.diff_range (f"{ref}~1..{ref}", max_lines=500)
+
+   msg = ai.fast (prompts.revert (commit_msg, d, whisper))
+   msg = ai.oneline (msg)
+
+   git.revert_commit (ref, no_commit=True)
+
+   choice = console.review (msg)
+
+   if choice == "Edit":
+      msg = console.edit (msg)
+      if not msg.strip ():
+         git.revert_abort ()
+         console.muted ("Empty message, cancelled")
+         raise typer.Exit (0)
+      git.commit (msg)
+   elif choice == "Yes":
+      git.commit (msg)
+   else:
+      git.revert_abort ()
+      console.muted ("Cancelled")
+      raise typer.Exit (0)
+
+   console.success (f"Reverted {commit_hash}")
+   console.hint ("imp sync to push, or imp undo to cancel")

imp/commands/review.py

@@ -0,0 +1,76 @@
+import shutil
+import subprocess
+import tempfile
+
+import typer
+
+from imp import ai, console, git, prompts
+
+
+def _handoff (findings: str):
+   if not shutil.which ("claude"):
+      console.err ("Claude Code not found")
+      console.hint ("curl -fsSL https://claude.ai/install.sh | bash")
+      raise typer.Exit (1)
+
+   prompt = f"Fix the following code review findings. Apply each fix directly to the files.\n\n{findings}"
+
+   with tempfile.NamedTemporaryFile (mode="w", suffix=".md", delete=True) as f:
+      f.write (prompt)
+      f.flush ()
+
+      console.out.print ()
+      console.muted ("Handing off to Claude Code...")
+      subprocess.run (
+         [ "claude", f"Read {f.name} and follow the instructions inside." ],
+         check=False,
+      )
+
+
+def review (
+   fix: bool = typer.Option (False, "--fix", "-f", help="Send review findings to Claude Code for fixing"),
+   whisper: str = typer.Option ("", "--whisper", "-w", help="Hint to guide the AI"),
+):
+   """AI code review of current changes.
+
+   Sends staged changes (or unstaged if nothing is staged) to the smart
+   AI model for review. Outputs feedback in markdown covering bugs, style
+   issues, and suggestions. Use --fix to send findings to Claude Code.
+   """
+
+   git.require ()
+
+   console.header ("Review")
+
+   d = git.diff (staged=True)
+   context = "staged changes"
+
+   if not d:
+      d = git.diff ()
+      context = "unstaged changes"
+
+   if not d:
+      console.muted ("No changes to review")
+      console.hint ("make some changes first")
+      raise typer.Exit (0)
+
+   d = ai.truncate (d)
+
+   result = console.spin (
+      "Thinking...",
+      ai.smart,
+      prompts.review (d, whisper),
+      False,
+   )
+
+   console.divider ()
+   console.md (result)
+   console.divider ()
+
+   should_fix = fix
+   if not fix:
+      choice = console.choose ("Next?", [ "Fix with Claude Code", "Done" ])
+      should_fix = choice == "Fix with Claude Code"
+
+   if should_fix:
+      _handoff (result)

imp/commands/ship.py

@@ -0,0 +1,131 @@
+import subprocess
+from datetime import date
+from pathlib import Path
+
+import typer
+
+from imp import ai, console, git, prompts, version
+from imp.commands.release import (
+   _push_release,
+   _rollback_release,
+   _squash_commits,
+   _write_changelog,
+)
+
+
+def ship (
+   level: str = typer.Argument ("patch", help="Version bump: patch, minor, or major"),
+   whisper: str = typer.Option ("", "--whisper", "-w", help="Hint to guide the AI"),
+):
+   """Commit all changes and release in one shot.
+
+   Stages everything, generates a commit message, bumps the version,
+   updates the changelog, squashes, tags, and pushes. No prompts.
+   Equivalent to imp commit -a followed by imp release with auto-accept.
+   """
+
+   git.require ()
+
+   base = git.base_branch ()
+   if git.branch () != base:
+      console.warn (f"Releasing from {git.branch ()}, not {base}")
+
+   if level not in ("patch", "minor", "major"):
+      console.err (f"Invalid level: {level}")
+      console.hint ("use patch, minor, or major")
+      raise typer.Exit (1)
+
+   console.header ("Ship")
+
+   git.stage (all=True)
+   d = git.diff (staged=True)
+
+   if not d:
+      console.muted ("No changes to ship")
+      raise typer.Exit (0)
+
+   b = git.branch ()
+   msg = ai.commit_message (prompts.commit (d, b, whisper))
+
+   console.label ("Commit")
+   console.item (msg)
+   git.commit (msg)
+   console.success ("Committed")
+   console.out.print ()
+
+   tag = git.last_tag ()
+
+   log = ""
+   if tag:
+      log = git.log_oneline (rev_range=f"{tag}..HEAD")
+
+   if not log:
+      log = git.log_oneline (count=20)
+      tag = ""
+
+   if not log:
+      console.muted ("No commits to release")
+      raise typer.Exit (0)
+
+   count = len (log.splitlines ())
+
+   highest = git.highest_tag ()
+   current = highest.lstrip ("v") if highest else "0.0.0"
+   if not current:
+      current = "0.0.0"
+
+   new_version = version.bump (current, level)
+
+   if git.tag_exists (f"v{new_version}"):
+      console.err (f"Tag v{new_version} already exists")
+      console.hint (f"pick a different version, or: git tag -d v{new_version}")
+      raise typer.Exit (1)
+
+   if tag:
+      subjects = git.log_subjects (rev_range=f"{tag}..HEAD")
+   else:
+      subjects = git.log_subjects (count=count)
+
+   entry = version.changelog_from_commits (subjects)
+   summary = f"chore: release v{new_version}"
+   today = date.today ().isoformat ()
+   new_entry = f"## [{new_version}] - {today}\n\n{entry}"
+
+   root = git.repo_root ()
+   changelog_path = Path (root) / "CHANGELOG.md"
+
+   original_head = git.rev_parse ("HEAD")
+   original_changelog = ""
+   if changelog_path.is_file ():
+      original_changelog = changelog_path.read_text ()
+
+   committed = False
+
+   try:
+      _write_changelog (changelog_path, new_entry)
+      console.success ("Updated CHANGELOG.md")
+
+      can_squash = _squash_commits (tag, summary, changelog_path, count)
+      committed = True
+
+      git.tag (f"v{new_version}")
+      console.success (f"Tagged v{new_version}")
+
+   except (subprocess.CalledProcessError, OSError) as e:
+      msg = getattr (e, "stderr", "") or str (e)
+      console.err (f"Release failed: {msg.strip ()}")
+      _rollback_release (
+         new_version, original_head, changelog_path,
+         original_changelog, committed,
+      )
+      raise typer.Exit (1) from None
+
+   if git.remote_exists ():
+      try:
+         _push_release (new_version, entry, can_squash)
+      except (subprocess.CalledProcessError, OSError) as e:
+         msg = getattr (e, "stderr", "") or str (e)
+         console.err (f"Push failed: {msg.strip ()}")
+         raise typer.Exit (1) from None
+   else:
+      console.muted ("No remote, skipped push")

imp/commands/split.py

@@ -0,0 +1,176 @@
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+import typer
+
+from imp import ai, console, git, prompts, validate
+
+
+def _build_file_diffs (root: str, files: list [str]) -> str:
+   parts = []
+   for f in files:
+      d = git.diff_file (f)
+
+      full = Path (root) / f
+      if not d and full.is_file ():
+         try:
+            lines = full.read_text ().splitlines (keepends=True) [:30]
+            d = "".join ("+" + line for line in lines)
+         except (OSError, UnicodeDecodeError):
+            pass
+
+      if d:
+         snippet = "\n".join (d.splitlines () [:30])
+         parts.append (f"--- {f} ---\n{snippet}")
+      else:
+         parts.append (f"--- {f} --- (no diff available)")
+
+   return "\n".join (parts)
+
+
+def _validate_response (response: str, all_files: list [str]) -> list [dict] | None:
+   try:
+      groups = json.loads (response)
+   except json.JSONDecodeError:
+      console.err ("AI returned invalid JSON")
+      return None
+
+   if not isinstance (groups, list) or len (groups) == 0:
+      console.err ("AI returned empty or non-array response")
+      return None
+
+   grouped = set ()
+   for g in groups:
+      for f in g.get ("files", []):
+         grouped.add (f)
+
+   expected = set (all_files)
+   if grouped != expected:
+      console.err ("File mismatch: AI groups don't cover all files")
+      missing = expected - grouped
+      extra = grouped - expected
+      if missing:
+         console.items ("Missing", "\n".join (sorted (missing)))
+      if extra:
+         console.items ("Extra", "\n".join (sorted (extra)))
+      return None
+
+   for g in groups:
+      msg = g.get ("message", "")
+      if not validate.commit (msg):
+         console.err ("AI output not in Conventional Commits format")
+         console.muted (msg)
+         return None
+
+   return groups
+
+
+def split (
+   yes: bool = typer.Option (False, "--yes", "-y", help="Accept AI grouping without review"),
+   whisper: str = typer.Option ("", "--whisper", "-w", help="Hint to guide the AI"),
+):
+   """Group dirty files into logical commits via AI.
+
+   Analyzes all changed files and uses AI to partition them into logical
+   groups, each with its own Conventional Commits message. Commits each
+   group sequentially. Rolls back if any commit fails. Requires at least
+   two changed files.
+   """
+
+   git.require ()
+
+   root = git.repo_root ()
+
+   files = git.diff_names ()
+
+   if not files:
+      console.err ("No changes to split")
+      console.hint ("make some changes first")
+      raise typer.Exit (1)
+
+   if len (files) == 1:
+      console.err ("Only 1 file changed")
+      console.hint ("use imp commit instead")
+      raise typer.Exit (1)
+
+   console.header ("Split")
+
+   console.items (f"Files ({len (files)})", "\n".join (files))
+
+   file_diffs = _build_file_diffs (root, files)
+   file_diffs = ai.truncate (file_diffs)
+   b = git.branch ()
+
+   response = ai.smart (prompts.split (file_diffs, b, whisper))
+   response = re.sub (r"^```\w*\n?", "", response, flags=re.MULTILINE)
+   response = re.sub (r"\n?```$", "", response.strip ())
+
+   groups = _validate_response (response, files)
+
+   if groups is None:
+      console.warn ("Retrying...")
+      response = ai.smart (prompts.split (file_diffs, b, whisper))
+      response = re.sub (r"^```\w*\n?", "", response, flags=re.MULTILINE)
+      response = re.sub (r"\n?```$", "", response.strip ())
+      groups = _validate_response (response, files)
+
+      if groups is None:
+         console.err ("Split failed after retry")
+         raise typer.Exit (1)
+
+   if len (groups) == 1:
+      console.warn ("AI grouped everything into a single commit")
+      console.hint ("use imp commit instead")
+      raise typer.Exit (0)
+
+   console.out.print ()
+   for i, g in enumerate (groups):
+      console.label (f"Group {i + 1}: {g ['message']}")
+      for f in g ["files"]:
+         console.item (f)
+      console.out.print ()
+
+   if not yes and not console.confirm (f"Commit {len (groups)} groups?"):
+      console.muted ("Cancelled")
+      raise typer.Exit (0)
+
+   for g in groups:
+      mtimes = []
+      for f in g ["files"]:
+         full = Path (root) / f
+         if full.exists ():
+            mtimes.append (full.stat ().st_mtime)
+      g ["date"] = max (mtimes) if mtimes else 0
+
+   groups.sort (key=lambda g: g ["date"])
+
+   original_head = git.rev_parse ("HEAD")
+   is_fresh = git.commit_count () == 0
+
+   git.stage (all=True)
+
+   try:
+      for i, g in enumerate (groups):
+         git.unstage ()
+         git.add (g ["files"])
+
+         date = ""
+         if g ["date"] > 0:
+            dt = datetime.fromtimestamp (g ["date"], tz=timezone.utc)
+            date = dt.strftime ("%Y-%m-%dT%H:%M:%S%z")
+
+         git.commit (g ["message"], date=date)
+         console.success (f"Group {i + 1}: {g ['message']}")
+   except Exception as e:
+      console.err (f"Split failed: {e}")
+      console.warn ("Rolling back...")
+      if is_fresh:
+         git.unstage ()
+      else:
+         git.reset (original_head, soft=True)
+         git.unstage ()
+      raise typer.Exit (1) from None
+
+   console.hint ("imp log to review")