imp-git 0.0.26__py3-none-any.whl

imp/__init__.py

@@ -0,0 +1,7 @@
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _v
+
+try:
+   __version__ = _v ("imp")
+except PackageNotFoundError:
+   __version__ = "dev"

imp/__main__.py

@@ -0,0 +1,3 @@
+from imp.main import app
+
+app ()

imp/ai.py

@@ -0,0 +1,130 @@
+import json
+import subprocess
+import urllib.error
+import urllib.request
+
+import typer
+
+from imp import config, console
+
+MAX_DIFF_LINES = 2000
+
+
+def _claude (prompt: str, model: str) -> str:
+   result = subprocess.run (
+      [
+         "claude", "-p",
+         "--model", model,
+         "--max-turns", "1",
+         "--tools", "",
+      ],
+      input=prompt,
+      capture_output=True,
+      text=True,
+   )
+
+   if result.returncode != 0:
+      console.err ("claude CLI failed")
+      raise typer.Exit (1)
+
+   return result.stdout
+
+
+def _ollama (prompt: str, model: str) -> str:
+   payload = json.dumps ({
+      "model": model,
+      "prompt": prompt,
+      "stream": False,
+   }).encode ()
+
+   req = urllib.request.Request (
+      "http://localhost:11434/api/generate",
+      data=payload,
+      headers={"Content-Type": "application/json"},
+   )
+
+   try:
+      with urllib.request.urlopen (req) as resp:
+         body = json.loads (resp.read ())
+         return body.get ("response", "")
+   except (urllib.error.URLError, json.JSONDecodeError, OSError) as e:
+      console.err (f"ollama request failed: {e}")
+      raise typer.Exit (1) from None
+
+
+def _call (prompt: str, model: str) -> str:
+   provider = config.get ("provider")
+   if provider == "claude":
+      return _claude (prompt, model)
+   elif provider == "ollama":
+      return _ollama (prompt, model)
+   else:
+      console.err (f"Unknown AI provider: {provider}")
+      raise typer.Exit (1)
+
+
+def fast (prompt: str, spin: bool = True) -> str:
+   model = config.get ("model:fast")
+   if spin:
+      result = console.spin ("Thinking...", _call, prompt, model)
+   else:
+      result = _call (prompt, model)
+   if not result or not result.strip ():
+      console.err ("Empty response from AI")
+      raise typer.Exit (1)
+
+   return result
+
+
+def smart (prompt: str, spin: bool = True) -> str:
+   model = config.get ("model:smart")
+   if spin:
+      result = console.spin ("Thinking...", _call, prompt, model)
+   else:
+      result = _call (prompt, model)
+   if not result or not result.strip ():
+      console.err ("Empty response from AI")
+      raise typer.Exit (1)
+
+   return result
+
+
+def ping () -> bool:
+   try:
+      model = config.get ("model:fast")
+      result = _call ("Reply with OK", model)
+      return bool (result and result.strip ())
+   except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError):
+      return False
+   except SystemExit:
+      return False
+
+
+def oneline (text: str) -> str:
+   return text.replace ("\n", "").strip ()
+
+
+def truncate (text: str, max_lines: int = MAX_DIFF_LINES) -> str:
+   lines = text.splitlines ()
+   if len (lines) <= max_lines:
+      return text
+   return "\n".join (lines [:max_lines])
+
+
+def commit_message (prompt: str) -> str:
+   from imp import validate
+
+   msg = fast (prompt)
+   msg = oneline (msg)
+
+   if not validate.commit (msg):
+      console.warn ("Retrying (invalid format)...")
+      msg = fast (prompt)
+      msg = oneline (msg)
+
+      if not validate.commit (msg):
+         console.err ("AI output not in Conventional Commits format")
+         console.muted (msg)
+         raise typer.Exit (1)
+
+   return msg

imp/commands/amend.py

@@ -0,0 +1,68 @@
+import typer
+
+from imp import ai, console, git, prompts
+
+
+def amend (
+   yes: bool = typer.Option (False, "--yes", "-y", help="Accept AI message without review"),
+   whisper: str = typer.Option ("", "--whisper", "-w", help="Hint to guide the AI"),
+):
+   """Amend last commit with a new AI-generated message.
+
+   Stages any uncommitted changes, regenerates the commit message from the
+   full diff, and amends the previous commit. You can review, edit, or
+   cancel the new message before it's applied.
+   """
+
+   git.require ()
+
+   console.header ("Amend")
+
+   total = git.commit_count ()
+   if total == 0:
+      console.err ("No commits to amend")
+      console.hint ("imp commit first")
+      raise typer.Exit (1)
+
+   last_msg = git.show ("HEAD", fmt="%s")
+
+   if total == 1:
+      combined = git.show ("HEAD")
+      changes = git.diff ()
+      if changes:
+         combined = combined + "\n" + changes
+   else:
+      combined = git.diff_range ("HEAD~1")
+
+   if not combined:
+      console.err ("Nothing to amend")
+      raise typer.Exit (1)
+
+   msg = ai.commit_message (prompts.commit (combined, whisper=whisper))
+
+   console.label ("Previous")
+   console.item (last_msg)
+   console.out.print ()
+
+   git.stage (all=True)
+
+   if yes:
+      console.item (msg)
+      git.commit (msg, amend=True)
+   else:
+      choice = console.review (msg)
+
+      if choice == "Edit":
+         msg = console.edit (msg)
+         if not msg.strip ():
+            console.muted ("Empty message, cancelled")
+            raise typer.Exit (0)
+         git.commit (msg, amend=True)
+      elif choice == "Yes":
+         git.commit (msg, amend=True)
+      else:
+         console.muted ("Cancelled")
+         raise typer.Exit (0)
+
+   console.success ("Amended")
+   console.hint ("imp commit again, or imp release when ready")

imp/commands/branch.py

@@ -0,0 +1,72 @@
+import typer
+
+from imp import ai, console, git, prompts, validate
+
+
+def branch (
+   description: list [str] | None = typer.Argument (None, help="Branch description"),
+   yes: bool = typer.Option (False, "--yes", "-y", help="Accept suggested branch name"),
+   whisper: str = typer.Option ("", "--whisper", "-w", help="Hint to guide the AI"),
+):
+   """Create or switch branches. No args: interactive picker.
+
+   With arguments, uses AI to generate a clean branch name from your
+   description. Without arguments, shows local branches with their age
+   and lets you pick one to switch to.
+   """
+
+   git.require ()
+
+   if not description:
+      _switch ()
+   else:
+      _create (" ".join (description), whisper, yes)
+
+
+def _switch ():
+   console.header ("Branches")
+
+   branches = git.branches_local ()
+   if len (branches) <= 1:
+      console.muted ("Only one branch exists")
+      raise typer.Exit (0)
+
+   labels = []
+   for b in branches:
+      age = git.branch_age (b)
+      labels.append (f"{b}  ({age})")
+
+   choice = console.choose ("Switch to:", labels)
+   target = choice.split ("  (") [0]
+
+   current = git.branch ()
+   if target == current:
+      console.muted (f"Already on {target}")
+      raise typer.Exit (0)
+
+   git.require_clean ()
+   git.checkout (target)
+   console.success (f"Switched to {target}")
+
+
+def _create (desc: str, whisper: str = "", yes: bool = False):
+   console.header ("Branch")
+
+   name = ai.fast (prompts.branch_name (desc, whisper))
+   name = ai.oneline (name)
+
+   if not validate.branch (name):
+      console.err (f"Invalid branch name: {name}")
+      raise typer.Exit (1)
+
+   console.label ("Suggested")
+   console.item (name)
+   console.out.print ()
+
+   if yes or console.confirm ("Create branch?"):
+      git.checkout (name, create=True)
+      console.success (f"Switched to {name}")
+      console.hint ("make changes, then imp commit")
+   else:
+      console.muted ("Cancelled")
+      raise typer.Exit (0)

imp/commands/clean.py

@@ -0,0 +1,47 @@
+import typer
+
+from imp import console, git
+
+
+def clean ():
+   """Delete branches already merged into base.
+
+   Fetches from origin, finds local branches fully merged into the base
+   branch (main/master), and deletes them locally and remotely. Prompts
+   for confirmation before deleting.
+   """
+
+   git.require ()
+
+   console.header ("Clean")
+
+   base = git.base_branch ()
+
+   console.spin ("Fetching...", git.fetch, True)
+
+   merged = git.branches_merged (base)
+
+   if not merged:
+      console.success ("No merged branches to clean")
+      raise typer.Exit (0)
+
+   console.label (f"Merged into {base}")
+   for b in merged:
+      console.item (b)
+   console.out.print ()
+
+   count = len (merged)
+   if not console.confirm (f"Delete {count} branch(es)?"):
+      console.muted ("Cancelled")
+      raise typer.Exit (0)
+
+   console.out.print ()
+   for b in merged:
+      git.delete_branch (b)
+      console.success (f"Deleted {b}")
+
+      if git.remote_has_branch (b):
+         git.delete_branch (b, remote=True)
+         console.success (f"Deleted remote {b}")
+
+   console.hint ("imp branch to start something new")

imp/commands/commit.py

@@ -0,0 +1,67 @@
+from fnmatch import fnmatch
+from typing import Optional
+
+import typer
+
+from imp import ai, console, git, prompts
+
+
+def commit (
+   all: bool = typer.Option (False, "--all", "-a", help="Stage all changes first"),
+   exclude: Optional [list [str]] = typer.Option (None, "--exclude", "-E", help="Glob patterns to exclude from staging"),
+   yes: bool = typer.Option (False, "--yes", "-y", help="Accept AI message without review"),
+   whisper: str = typer.Option ("", "--whisper", "-w", help="Hint to guide the AI"),
+):
+   """Generate an AI commit message for staged changes.
+
+   Reads the staged diff and uses AI to produce a Conventional Commits
+   message. Use --all/-a to stage everything first. You can review, edit,
+   or cancel the message before committing.
+   """
+
+   git.require ()
+
+   if all:
+      git.stage (all=True)
+
+   if exclude:
+      staged = git.staged_files ()
+      to_unstage = [
+         f for f in staged
+         if any (fnmatch (f, pat) for pat in exclude)
+      ]
+      if to_unstage:
+         git.unstage (to_unstage)
+         console.muted (f"Excluded {len (to_unstage)} files")
+
+   d = git.diff (staged=True)
+   if not d:
+      console.err ("Nothing staged")
+      console.hint ("git add <files>, or imp commit -a")
+      raise typer.Exit (1)
+
+   console.header ("Commit")
+
+   b = git.branch ()
+   msg = ai.commit_message (prompts.commit (d, b, whisper))
+
+   if yes:
+      console.item (msg)
+      git.commit (msg)
+   else:
+      choice = console.review (msg)
+
+      if choice == "Edit":
+         msg = console.edit (msg)
+         if not msg.strip ():
+            console.muted ("Empty message, cancelled")
+            raise typer.Exit (0)
+         git.commit (msg)
+      elif choice == "Yes":
+         git.commit (msg)
+      else:
+         console.muted ("Cancelled")
+         raise typer.Exit (0)
+
+   console.success ("Committed")
+   console.hint ("imp commit again, or imp release when ready")

imp/commands/config.py

@@ -0,0 +1,62 @@
+from imp import config, console
+
+
+def _provider_choices () -> list [str]:
+   return [ "claude", "ollama" ]
+
+
+def _claude_models () -> list [str]:
+   return [ "haiku", "sonnet", "opus" ]
+
+
+def _ollama_models () -> list [str]:
+   return [
+      "llama3.2",
+      "llama3.1",
+      "mistral",
+      "codellama",
+      "custom",
+   ]
+
+
+def configure ():
+   """Interactively configure AI provider and models.
+
+   Sets the AI provider (Claude or Ollama) and which models to use for
+   fast and smart operations. Configuration is stored in
+   ~/.config/imp/config.json.
+   """
+
+   console.header ("Config")
+
+   cfg = config.load ()
+
+   console.muted (f"Config: {config.path ()}")
+   console.out.print ()
+
+   provider = console.choose ("AI provider", _provider_choices ())
+   cfg ["provider"] = provider
+
+   if provider == "claude":
+      models = _claude_models ()
+   else:
+      models = _ollama_models ()
+
+   fast = console.choose ("Fast model (commits, branches)", models)
+   if fast == "custom":
+      fast = console.prompt ("Model name:")
+   cfg ["model:fast"] = fast
+
+   smart = console.choose ("Smart model (review, PR, split)", models)
+   if smart == "custom":
+      smart = console.prompt ("Model name:")
+   cfg ["model:smart"] = smart
+
+   config.save (cfg)
+
+   console.out.print ()
+   console.success ("Saved")
+   console.muted (f"  provider:    {cfg ['provider']}")
+   console.muted (f"  model:fast:  {cfg ['model:fast']}")
+   console.muted (f"  model:smart: {cfg ['model:smart']}")
+   console.hint ("imp doctor to verify")

imp/commands/doctor.py

@@ -0,0 +1,87 @@
+import shutil
+import subprocess
+
+import typer
+
+from imp import ai, config, console
+
+
+def _check (name: str, cmd: str, url: str, required: bool = True) -> bool:
+   path = shutil.which (cmd)
+   if path:
+      try:
+         result = subprocess.run (
+            [ cmd, "--version" ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+         )
+         version = result.stdout.strip ().splitlines () [0] if result.stdout.strip () else "installed"
+      except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError):
+         version = "installed"
+      console.success (f"{name} ({version})")
+      return True
+
+   if required:
+      console.err (f"{name} not found")
+      console.item (url)
+      return False
+
+   console.muted (f"  {name} not found (optional)")
+   console.item (url)
+   return True
+
+
+def doctor ():
+   """Check tools and configuration.
+
+   Verifies that required (git) and optional (claude, ollama, gh) tools are
+   installed, shows their versions, and confirms at least one AI provider is
+   available. Also displays the active provider and model settings from
+   ~/.config/imp/config.json.
+   """
+
+   console.header ("Doctor")
+
+   ok = True
+   ok = _check ("git", "git", "https://git-scm.com") and ok
+   _check ("claude", "claude", "https://docs.anthropic.com/en/docs/claude-code", required=False)
+   _check ("ollama", "ollama", "https://ollama.com", required=False)
+   _check ("gh", "gh", "https://cli.github.com", required=False)
+
+   console.out.print ()
+
+   has_claude = shutil.which ("claude") is not None
+   has_ollama = shutil.which ("ollama") is not None
+
+   if not has_claude and not has_ollama:
+      console.err ("No AI provider found (need claude or ollama)")
+      ok = False
+
+   cfg = config.load ()
+   provider = cfg ["provider"]
+   console.muted (f"Provider: {provider}")
+   console.muted (f"Fast model: {cfg ['model:fast']}")
+   console.muted (f"Smart model: {cfg ['model:smart']}")
+   console.muted (f"Config: {config.path ()}")
+
+   console.out.print ()
+
+   if has_claude or has_ollama:
+      if console.spin ("Testing AI connection...", ai.ping):
+         console.success ("AI responding")
+      else:
+         console.err ("AI not responding")
+         if provider == "claude":
+            console.hint ("run: claude to authenticate")
+         else:
+            console.hint ("is ollama running? try: ollama serve")
+         ok = False
+
+   console.out.print ()
+
+   if ok:
+      console.success ("All good")
+   else:
+      console.warn ("Some issues found")
+      raise typer.Exit (1)

imp/commands/done.py

@@ -0,0 +1,98 @@
+import typer
+
+from imp import console, git
+
+
+def done (
+   target: str | None = typer.Argument (None, help="Branch to merge into"),
+   yes: bool = typer.Option (False, "--yes", "-y", help="Skip confirmation"),
+):
+   """Merge feature branch into target, then clean up.
+
+   Merges the current branch into a target branch (defaults to main/master),
+   then deletes the feature branch locally and remotely. If the branch was
+   already merged via PR, pulls the target instead of merging locally.
+   """
+
+   git.require ()
+   git.require_clean ("imp commit first")
+
+   feature = git.branch ()
+   base = target or git.base_branch ()
+
+   if feature == base:
+      console.err (f"Already on {base}")
+      console.hint ("switch to a feature branch first")
+      raise typer.Exit (1)
+
+   if target and not git.rev_parse (target):
+      if git.remote_has_branch (target):
+         git.checkout (target)
+         git.checkout (feature)
+      else:
+         console.err (f"Branch {target} does not exist")
+         raise typer.Exit (1)
+
+   console.header ("Done")
+
+   git.fetch (prune=True)
+
+   already_merged = False
+   remote_base = f"origin/{base}"
+   if git.rev_parse (remote_base):
+      already_merged = git.is_merged (feature, remote_base)
+
+   has_remote_feature = git.remote_has_branch (feature)
+
+   console.label (f"{feature} → {base}")
+   console.out.print ()
+   console.item (f"Switch to {base}")
+
+   if already_merged:
+      console.item ("Pull latest (already merged remotely)")
+   else:
+      console.item (f"Merge {feature} into {base} (--no-ff)")
+
+   console.item (f"Delete {feature} (local)")
+
+   if has_remote_feature:
+      console.item (f"Delete {feature} (remote)")
+
+   console.out.print ()
+
+   if not yes and not console.confirm ("Proceed?"):
+      console.muted ("Cancelled")
+      raise typer.Exit (0)
+
+   git.checkout (base)
+
+   if already_merged:
+      git.pull ()
+      console.success (f"Pulled {base} (already merged)")
+   else:
+      if git.has_upstream ():
+         git.pull ()
+
+      if not git.merge (feature, no_ff=True):
+         console.err ("Merge conflict")
+         console.hint ("imp resolve to fix conflicts")
+         raise typer.Exit (1)
+
+      console.success (f"Merged {feature} into {base}")
+
+   if git.delete_branch (feature):
+      console.success (f"Deleted local branch {feature}")
+   else:
+      console.warn (f"Branch {feature} has unmerged changes")
+      console.out.print ()
+      if console.confirm (f"Force delete {feature}?"):
+         git.delete_branch (feature, force=True)
+         console.success (f"Force deleted local branch {feature}")
+      else:
+         console.muted (f"Kept local branch {feature}")
+
+   if has_remote_feature:
+      git.delete_branch (feature, remote=True)
+      console.success (f"Deleted remote branch {feature}")
+
+   console.hint ("imp branch to start something new")