imp-git 0.0.26__py3-none-any.whl

imp/commands/status.py

@@ -0,0 +1,96 @@
+from imp import console, git
+
+
+def _file_style (code: str) -> str:
+   if code in ("M ", "AM"):
+      return "green"
+   if code == " M" or code == "MM":
+      return "yellow"
+   if code.strip () == "D":
+      return "red"
+   if code.startswith ("A"):
+      return "green"
+   if code.startswith ("R"):
+      return f"{console.theme.accent}"
+   if code == "??":
+      return "dim"
+   return "default"
+
+
+def status ():
+   """Show repository overview.
+
+   Displays the current branch, file changes with line-level stats,
+   commits since the last tag, worktrees, and the last release version.
+   Suggests a next action based on the current state.
+   """
+
+   git.require ()
+
+   name = git.repo_name ()
+   b = git.branch ()
+   tag = git.last_tag ()
+
+   console.header (name)
+
+   console.label ("Branch")
+   console.item (b)
+   console.out.print ()
+
+   changes = git.status_short ()
+   if changes:
+      numstat_raw = git.diff_numstat ()
+      stats = {}
+      for line in numstat_raw.splitlines ():
+         parts = line.split ("\t")
+         if len (parts) == 3:
+            added, removed, path = parts
+            stats [path] = (added, removed)
+
+      console.label ("Changes")
+      for line in changes.splitlines ():
+         if len (line) < 4:
+            continue
+         code = line [:2]
+         path = line [2:].lstrip (" ")
+         style = _file_style (code)
+
+         stat_str = ""
+         if path in stats:
+            a, r = stats [path]
+            stat_str = f" [green]+{a}[/green] [red]-{r}[/red]"
+
+         console.out.print (f"  [{style}]{code.strip ()}[/{style}]  {path}{stat_str}")
+      console.out.print ()
+
+   if tag:
+      unpushed = git.log_oneline (rev_range=f"{tag}..HEAD")
+   else:
+      unpushed = git.log_oneline (count=10)
+
+   if unpushed:
+      count = len (unpushed.splitlines ())
+      console.items (f"Commits since {tag or 'start'} ({count})", unpushed)
+
+   wt = git.worktree_list ()
+   wt_lines = wt.splitlines () if wt else []
+   if len (wt_lines) > 1:
+      console.label ("Worktrees")
+      from pathlib import Path
+      cwd = str (Path.cwd ())
+      for line in wt_lines:
+         if line.startswith (cwd + " "):
+            console.item (f"{line} (here)")
+         else:
+            console.item (line)
+      console.out.print ()
+
+   if tag:
+      console.muted (f"Last release: {tag}")
+
+   if changes:
+      console.hint ("git add <files>, then imp commit")
+   elif unpushed:
+      console.hint ("imp release to ship")
+   else:
+      console.hint ("make changes, then imp commit")

imp/commands/sync.py

@@ -0,0 +1,64 @@
+import typer
+
+from imp import console, git
+
+
+def sync (
+   yes: bool = typer.Option (False, "--yes", "-y", help="Push without confirmation"),
+):
+   """Pull, rebase, and push current branch.
+
+   Fetches from origin, rebases local commits on top of upstream changes,
+   and offers to push. Requires a clean working tree and an upstream
+   tracking branch. Aborts cleanly if the rebase fails.
+   """
+
+   git.require ()
+   git.require_clean ("imp commit first")
+
+   console.header ("Sync")
+
+   b = git.branch ()
+
+   if not git.has_upstream ():
+      console.err ("No upstream branch")
+      console.hint (f"git push -u origin {b}")
+      raise typer.Exit (1)
+
+   console.label ("Branch")
+   console.item (b)
+   console.out.print ()
+
+   console.spin ("Fetching...", git.fetch)
+
+   behind = git.count_behind ()
+   ahead = git.count_ahead ()
+
+   if behind == 0 and ahead == 0:
+      console.success ("Already up to date")
+      raise typer.Exit (0)
+
+   if behind > 0:
+      console.label ("Behind")
+      console.item (f"{behind} commits")
+
+   if ahead > 0:
+      console.label ("Ahead")
+      console.item (f"{ahead} commits")
+
+   console.out.print ()
+
+   if behind > 0:
+      console.muted ("Rebasing...")
+      if not git.rebase ():
+         console.err ("Rebase failed")
+         console.hint ("imp resolve to fix conflicts, or git rebase --abort")
+         raise typer.Exit (1)
+      console.success ("Rebased")
+
+   if ahead > 0 or behind > 0:
+      if yes or console.confirm ("Push?"):
+         git.push ()
+         console.success ("Pushed")
+
+   console.hint ("imp status to see overview")

imp/commands/undo.py

@@ -0,0 +1,45 @@
+import typer
+
+from imp import console, git
+
+
+def undo (
+   count: int | None = typer.Argument (1, help="Number of commits to undo"),
+):
+   """Undo last N commits, keeping changes staged.
+
+   Soft-resets HEAD back by N commits so the changes remain staged and
+   ready to recommit. Warns if any of the commits have already been
+   pushed to the remote.
+   """
+
+   git.require ()
+
+   console.header ("Undo")
+
+   if git.commit_count () == 0:
+      console.muted ("No commits to undo")
+      raise typer.Exit (0)
+
+   total = git.commit_count ()
+   if count > total:
+      console.err (f"Only {total} commits available")
+      raise typer.Exit (1)
+
+   log = git.log_oneline (count=count)
+   console.items ("Commits to undo", log)
+
+   if git.has_upstream ():
+      ahead = git.count_ahead ()
+      if count > ahead:
+         console.warn ("Some commits are already pushed")
+         console.out.print ()
+
+   if not console.confirm (f"Undo {count} commit(s)? (changes stay staged)"):
+      console.muted ("Cancelled")
+      raise typer.Exit (0)
+
+   git.reset (f"HEAD~{count}", soft=True)
+
+   console.success (f"Undone {count} commit(s)")
+   console.hint ("imp commit to recommit, or keep editing")

imp/config.py

@@ -0,0 +1,51 @@
+import json
+import os
+from pathlib import Path
+
+_DEFAULTS = {
+   "provider": "claude",
+   "model:fast": "haiku",
+   "model:smart": "sonnet",
+}
+
+_ENV_OVERRIDES = {
+   "provider": "IMP_AI_PROVIDER",
+   "model:fast": "IMP_AI_MODEL_FAST",
+   "model:smart": "IMP_AI_MODEL_SMART",
+}
+
+
+def path () -> Path:
+   xdg = os.environ.get ("XDG_CONFIG_HOME", "")
+   if not xdg:
+      xdg = str (Path.home () / ".config")
+   return Path (xdg) / "imp" / "config.json"
+
+
+def load () -> dict:
+   cfg = dict (_DEFAULTS)
+
+   p = path ()
+   if p.is_file ():
+      try:
+         stored = json.loads (p.read_text ())
+         cfg.update (stored)
+      except (json.JSONDecodeError, OSError):
+         pass
+
+   for key, env in _ENV_OVERRIDES.items ():
+      val = os.environ.get (env, "")
+      if val:
+         cfg [key] = val
+
+   return cfg
+
+
+def save (cfg: dict):
+   p = path ()
+   p.parent.mkdir (parents=True, exist_ok=True)
+   p.write_text (json.dumps (cfg, indent=3) + "\n")
+
+
+def get (key: str) -> str:
+   return load ().get (key, _DEFAULTS.get (key, ""))

imp/console.py

@@ -0,0 +1,168 @@
+import subprocess
+import tempfile
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, TypeVar
+
+import questionary
+import typer
+from prompt_toolkit.styles import Style as PTStyle
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.theme import Theme as RichTheme
+
+from imp.theme import theme
+
+T = TypeVar ("T")
+
+_rich_theme = RichTheme ({
+   "accent": f"bold {theme.accent}",
+   "success": theme.success,
+   "error": f"bold {theme.error}",
+   "warning": theme.warning,
+   "muted": theme.muted,
+   "highlight": theme.highlight,
+})
+
+out = Console (theme=_rich_theme)
+
+_pt_style = PTStyle ([
+   ("qmark", theme.accent),
+   ("question", f"bold {theme.accent}"),
+   ("pointer", f"bold {theme.highlight}"),
+   ("highlighted", f"bold {theme.highlight}"),
+   ("selected", theme.accent),
+   ("answer", f"bold {theme.accent}"),
+])
+
+
+def header (title: str):
+   out.print ()
+   out.print (f"[accent]{title}[/accent]")
+   out.print ()
+
+
+def label (text: str):
+   out.print (f"[{theme.accent}]{text}[/{theme.accent}]")
+
+
+def item (text: str):
+   out.print (f"  [muted]{text}[/muted]")
+
+
+def items (title: str, data: str):
+   label (title)
+   for line in data.splitlines ():
+      if line.strip ():
+         item (line)
+   out.print ()
+
+
+def divider ():
+   out.print (
+      "[muted]────────────────────────────────────────[/muted]"
+   )
+
+
+def success (msg: str):
+   out.print (f"[success]✓[/success] {msg}")
+
+
+def err (msg: str):
+   out.print (Panel (
+      msg,
+      border_style=theme.error,
+      title="Error",
+      title_align="left",
+   ))
+
+
+def fatal (msg: str):
+   err (msg)
+   raise typer.Exit (1)
+
+
+def warn (msg: str):
+   out.print (f"[warning]{msg}[/warning]")
+
+
+def hint (msg: str):
+   out.print ()
+   out.print (f"[muted]→ {msg}[/muted]")
+
+
+def muted (msg: str):
+   out.print (f"[muted]{msg}[/muted]")
+
+
+def md (text: str):
+   out.print (Markdown (text.strip ()))
+
+
+def review (text: str) -> str:
+   panel = Panel (
+      text,
+      border_style=theme.accent,
+      padding=(1, 2),
+   )
+   out.print (panel)
+   out.print ()
+
+   return choose ("Use this message?", [ "Yes", "Edit", "No" ])
+
+
+def confirm (msg: str) -> bool:
+   return choose (msg, [ "Yes", "No" ]) == "Yes"
+
+
+def choose (title: str, options: list [str]) -> str:
+   result = questionary.select (
+      title,
+      choices=options,
+      style=_pt_style,
+      qmark="▸",
+      pointer="▸",
+      use_arrow_keys=True,
+      use_jk_keys=False,
+   ).ask ()
+
+   if result is None:
+      return options [-1]
+
+   return result
+
+
+def prompt (label: str, placeholder: str = "") -> str:
+   result = questionary.text (
+      label,
+      default=placeholder,
+      style=_pt_style,
+      qmark="▸",
+   ).ask ()
+
+   return result or ""
+
+
+def edit (text: str) -> str:
+   import os
+
+   editor = os.environ.get ("EDITOR", "vim")
+   with tempfile.NamedTemporaryFile (
+      mode="w",
+      suffix=".md",
+      delete=False,
+   ) as f:
+      f.write (text)
+      path = Path (f.name)
+
+   try:
+      subprocess.run ([ editor, str (path) ], check=True)
+      return path.read_text ()
+   finally:
+      path.unlink (missing_ok=True)
+
+
+def spin (title: str, fn: Callable [..., T], *args: Any) -> T:
+   with out.status (f"[accent]{title}[/accent]", spinner="dots"):
+      return fn (*args)