lcode-cli 0.16.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.16.0"
+__version__ = "0.17.0"

lcode/agent.py

@@ -130,7 +130,14 @@ def git_info(cwd: Path) -> str:
             return "not a git repository"
         changed = git("status", "--short").stdout.strip().splitlines()
         log = git("log", "--oneline", "-5").stdout.strip() or "(no commits)"
-        return f"branch {branch.stdout.strip()}, {len(changed)} changed file(s)\nRecent commits:\n{log}"
+        dirs = git("rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir").stdout.split()
+        worktree = (
+            "\nThis folder is a git worktree, separate from the repository's main checkout: read, change and "
+            "commit files only here, with paths inside this folder."
+            if len(dirs) == 2 and dirs[0] != dirs[1]
+            else ""
+        )
+        return f"branch {branch.stdout.strip()}, {len(changed)} changed file(s){worktree}\nRecent commits:\n{log}"
     except (OSError, subprocess.TimeoutExpired):
         return "unknown"
 
@@ -242,6 +249,7 @@ class Agent:
         # Set on subagents (see lcode.subagents):
         self.allowed_tools: set[str] | None = None  # None: every tool
         self.read_only = False  # only read-only shell commands
+        self.no_changes = ""  # set during a review: why nothing may change (read-only tools only)
         self.cancel: threading.Event | None = None  # set from another thread to stop
         self.on_tool = None  # called with (name, arguments) before each tool runs
         self.response = None  # the streaming response, so another thread can abort it
@@ -931,4 +939,6 @@ class Agent:
         else:
             note = ""
         self.settings.context = tokens
+        if getattr(self.ollama, "kind", "ollama") != "ollama":  # the server keeps its own window
+            return f"lcode now uses {format_tokens(tokens)} tokens of the context window{note}, and summarizes sooner."
         return f"Context window set to {format_tokens(tokens)} tokens{note}. The model reloads on the next request."

lcode/cli.py

@@ -626,6 +626,17 @@ def cmd_chat(args) -> None:
     cwd = Path(args.repo).expanduser().resolve()
     if not cwd.is_dir():
         fail(f"not a directory: {cwd}")
+    worktree = None
+    if args.worktree is not None:
+        from lcode import gitflow
+
+        try:
+            worktree = gitflow.start_worktree(cwd, args.worktree)
+        except gitflow.GitError as e:
+            fail(f"--worktree: {e}")
+        cwd = worktree.cwd
+        state = "a new worktree" if worktree.created_branch else "the worktree"
+        console.print(f"[dim]Working in {state} {worktree.path}, on branch {escape(worktree.branch)}.[/]")
     ollama = connect(cfg)
     hw = detect()
     check_ollama(ollama, hw)
@@ -714,6 +725,8 @@ def cmd_chat(args) -> None:
             agent.mcp.close()
         if agent.sandbox:
             agent.sandbox.stop()
+        if worktree is not None:
+            console.print(f"[dim]{escape(worktree.finish())}[/]")
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -736,6 +749,14 @@ def build_parser() -> argparse.ArgumentParser:
         metavar="SESSION",
         help="resume a saved session: pick from a list, or give its number, name or id",
     )
+    parser.add_argument(
+        "-w",
+        "--worktree",
+        nargs="?",
+        const="",
+        metavar="NAME",
+        help="work in a git worktree of its own, on branch NAME (new, or continue one); removed if nothing changed",
+    )
     parser.add_argument("--plan", action="store_true", help="start in plan mode: agree on a plan before any change")
     parser.add_argument("--auto-edit", action="store_true", help="apply file edits without asking")
     parser.add_argument("--yolo", action="store_true", help="never ask for permission (edits and commands)")

lcode/gitflow.py

@@ -0,0 +1,640 @@
+"""Git workflow: /commit, /review, /pr, and sessions in a worktree of their own (lcode --worktree).
+
+/commit and /pr ask the model for a message (or a title and description) in one extra request
+alongside the conversation, so it knows why the changes were made and Ollama reuses the cached
+prompt; that request isn't kept in the conversation. Nothing is committed, pushed or opened
+without the user's yes, also in yolo mode. /review runs as a normal request in which the model can
+read but not change anything.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import hashlib
+import json
+import re
+import secrets
+import shutil
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.markup import escape
+from rich.panel import Panel
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+
+# Files that often hold secrets: /commit leaves them out unless the user stages them.
+SENSITIVE = (".env", ".env.*", "*.pem", "*.key", "*.p12", "*.pfx", "id_rsa*", "id_ed25519*", "id_ecdsa*",
+             "*credentials*", "*secret*", "*.keystore", "*.jks", ".netrc", ".pgpass")  # fmt: skip
+MAX_UNTRACKED_LINES = 200  # of a new file, in the diff the model sees
+MIN_DIFF_CHARS = 6000
+MAX_DIFF_CHARS = 120_000
+
+COMMIT_SCHEMA = {
+    "type": "object",
+    "properties": {"files": {"type": "array", "items": {"type": "string"}}, "message": {"type": "string"}},
+    "required": ["files", "message"],
+}
+PR_SCHEMA = {
+    "type": "object",
+    "properties": {"branch": {"type": "string"}, "title": {"type": "string"}, "body": {"type": "string"}},
+    "required": ["branch", "title", "body"],
+}
+
+COMMIT_PROMPT = """Write the git commit message for the changes below.{hint}
+
+The repository's recent commit messages; match their style (length, tense, capitals, prefixes such as "fix:", trailers):
+{style}
+
+Changed files{which}:
+{files}
+
+{diff}
+
+Reply with JSON. "message" is the whole commit message: a subject line of at most 72 characters and, when the change needs explaining, a blank line and a body wrapped at 72 characters that says why, not what the diff already shows. {files_rule} Use what you know from this conversation about why the changes were made. Don't mention yourself or lcode."""
+
+FILES_CHOSEN = """"files" lists the files that belong in this commit, from the list above: leave out files unrelated to the work (scratch files, logs, local experiments). When in doubt, include a file."""
+FILES_STAGED = """The user staged exactly what to commit, so "files" is an empty list."""
+
+PR_PROMPT = """Write a pull request for the branch's changes below, into {base}.{hint}
+
+Commits:
+{commits}
+
+{diff}
+{template}
+Reply with JSON. "title" is a short title (at most 70 characters) in the style of the commits. "body" is the description in Markdown: what changes and why, and how it was tested when you know. Keep it short and concrete; no headings for a small change. {branch_rule} Use what you know from this conversation. Don't mention yourself or lcode."""
+
+REVIEW_PROMPT = """Review {what} before it's {next}.
+
+{stat}
+{diff}
+
+Look for:
+1. Bugs: wrong logic, missed edge cases, error handling, wrong assumptions about inputs, races.
+2. Tests: changed behaviour without a test, tests that don't check what they claim.
+3. Security: injection, secrets in the code, unchecked input, too-broad permissions.
+4. Clarity: confusing names, dead code, duplication, comments that no longer match the code. Only what matters.
+
+Read the surrounding code where you need it: a diff alone can mislead. Don't change any files: this is a review. If the project's instructions or a skill describe how to review here, follow them.
+
+Report each finding as `path:line`, its kind (bug, test, security or clarity), what's wrong and how to fix it, most important first. If nothing needs changing, say so in a sentence; don't invent problems."""
+
+
+class GitError(Exception):
+    pass
+
+
+def git(cwd: Path, *args: str, check: bool = True, stdin: str | None = None, timeout: float = 120) -> str:
+    try:
+        r = subprocess.run(
+            ["git", *args], cwd=cwd, input=stdin, capture_output=True, text=True, timeout=timeout
+        )  # fmt: skip
+    except (OSError, subprocess.SubprocessError) as e:
+        raise GitError(f"git {args[0]} failed: {e}") from e
+    if r.returncode != 0 and check:
+        raise GitError((r.stderr or r.stdout).strip() or f"git {args[0]} failed")
+    return r.stdout
+
+
+def repo_root(cwd: Path) -> Path:
+    try:
+        return Path(git(cwd, "rev-parse", "--show-toplevel").strip())
+    except GitError as e:
+        raise GitError("this isn't a git repository") from e
+
+
+def has_commits(root: Path) -> bool:
+    return bool(git(root, "rev-parse", "--verify", "-q", "HEAD", check=False).strip())
+
+
+# ----------------------------------------------------------------------------- changes
+
+
+@dataclass
+class Change:
+    path: str
+    code: str  # git's two status letters, e.g. " M", "A ", "??"
+
+    @property
+    def staged(self) -> bool:
+        return self.code[0] not in " ?"
+
+    @property
+    def untracked(self) -> bool:
+        return self.code == "??"
+
+
+def changes(root: Path) -> list[Change]:
+    out = git(root, "status", "--porcelain=v1", "-z", "--untracked-files=all")
+    found, parts, i = [], out.split("\0"), 0
+    while i < len(parts):
+        entry = parts[i]
+        i += 1
+        if len(entry) < 4:
+            continue
+        code, path = entry[:2], entry[3:]
+        if code[0] in "RC":
+            i += 1  # the old name follows
+        found.append(Change(path, code))
+    return found
+
+
+def sensitive(path: str) -> bool:
+    name = Path(path).name.lower()
+    return any(fnmatch.fnmatch(name, pattern) for pattern in SENSITIVE)
+
+
+def diff_budget(agent: Agent) -> int:
+    """How much diff (in characters) fits next to the conversation."""
+    room = int(agent.settings.context * 0.8) - agent.ctx_used - 3000
+    return max(MIN_DIFF_CHARS, min(MAX_DIFF_CHARS, room * 3))
+
+
+def shorten(text: str, limit: int, what: str) -> str:
+    if len(text) <= limit:
+        return text
+    return text[:limit] + f"\n[… {len(text) - limit:,} more characters of the {what} not shown]"
+
+
+def new_files(root: Path, paths: list[str]) -> str:
+    parts = []
+    for rel in paths:
+        path = root / rel
+        try:
+            if path.is_symlink() or not path.is_file() or path.stat().st_size > 1_000_000:
+                parts.append(f"new file: {rel} (not shown)")
+                continue
+            data = path.read_bytes()
+        except OSError:
+            continue
+        if b"\0" in data[:4096]:
+            parts.append(f"new file: {rel} (binary)")
+            continue
+        lines = data.decode(errors="replace").splitlines()
+        more = f"\n[… {len(lines) - MAX_UNTRACKED_LINES} more lines]" if len(lines) > MAX_UNTRACKED_LINES else ""
+        parts.append(f"new file: {rel}\n" + "\n".join(lines[:MAX_UNTRACKED_LINES]) + more)
+    return "\n\n".join(parts)
+
+
+def changes_diff(root: Path, files: list[Change], staged_only: bool, limit: int) -> str:
+    """The diff of these changes, new files included, cut to `limit` characters."""
+    tracked = [c.path for c in files if not c.untracked]
+    text = ""
+    if staged_only:
+        text = git(root, "diff", "--cached", "--no-color")
+    elif tracked:
+        against = ["HEAD"] if has_commits(root) else ["--cached"]
+        text = git(root, "diff", "--no-color", *against, "--", *tracked)
+    untracked = new_files(root, [c.path for c in files if c.untracked])
+    return shorten("\n\n".join(p for p in (text.strip(), untracked) if p), limit, "diff")
+
+
+def style(root: Path) -> str:
+    if not has_commits(root):
+        return "(no commits yet)"
+    subjects = git(root, "log", "-n", "15", "--no-merges", "--format=%s").strip()
+    bodies = git(root, "log", "-n", "3", "--no-merges", "--format=--- %B").strip()
+    return f"{subjects}\n\nThe latest three in full:\n{bodies}"
+
+
+# ----------------------------------------------------------------------------- asking the model
+
+
+def parse_json(content: str) -> dict:
+    for candidate in (content, *re.findall(r"\{.*\}", content, re.S)):
+        try:
+            data = json.loads(candidate)
+        except (json.JSONDecodeError, TypeError):
+            continue
+        if isinstance(data, dict):
+            return data
+    return {}
+
+
+def ask(agent: Agent, request: str, schema: dict) -> dict:
+    """One structured answer, with the conversation as context; the request isn't kept in it."""
+    history = agent.messages
+    if agent.ctx_used + len(request) // 3 > agent.settings.context * 0.85:
+        history = agent.messages[:1]  # too long: the instructions only
+    payload = {
+        "model": agent.settings.model,
+        "messages": [*history, {"role": "user", "content": request}],
+        "tools": agent.tool_schemas(),  # the same as the session's, so the cached prompt is reused
+        "think": False,
+        "format": schema,
+        "keep_alive": agent.settings.keep_alive,
+        "options": agent.options(),
+    }
+    reply = agent.ollama.chat(payload)
+    return parse_json((reply.get("message") or {}).get("content") or "")
+
+
+def clean_message(text: str) -> str:
+    text = re.sub(r"^```\w*\n|\n```$", "", text.strip()).strip()
+    return "\n".join(line.rstrip() for line in text.splitlines()).strip()
+
+
+def confirm(agent: Agent, question: str, editable: str | None = None) -> str:
+    """'y', 'e' (when there's something to edit) or 'n'."""
+    try:
+        answer = input(question).strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        agent.console.print()
+        return "n"
+    if answer in ("y", "yes"):
+        return "y"
+    if answer in ("e", "edit") and editable is not None:
+        return "e"
+    return "n"
+
+
+# ----------------------------------------------------------------------------- /commit
+
+
+def commit_command(agent: Agent, hint: str = "") -> None:
+    c = agent.console
+    try:
+        root = repo_root(agent.cwd)
+        found = changes(root)
+    except GitError as e:
+        c.print(f"[red]{escape(str(e))}[/]")
+        return
+    if not found:
+        c.print("Nothing to commit: the working tree is clean.")
+        return
+    staged = [ch for ch in found if ch.staged]
+    risky: list[str] = []
+    if staged:
+        candidates = staged
+        unstaged = len([ch for ch in found if not ch.staged])
+        c.print(
+            f"[dim]Committing the {len(staged)} staged file(s)"
+            + (f"; {unstaged} other changed file(s) stay out of it." if unstaged else ".")
+            + "[/]"
+        )
+    else:
+        risky = [ch.path for ch in found if sensitive(ch.path)]
+        candidates = [ch for ch in found if not sensitive(ch.path)]
+        if not candidates:
+            c.print(
+                f"Only files that may hold secrets changed ({escape(', '.join(risky))}). "
+                "If they belong in a commit, stage them yourself (git add) and run /commit again."
+            )
+            return
+    paths = [ch.path for ch in candidates]
+    request = COMMIT_PROMPT.format(
+        hint=f" The user adds: {hint}" if hint else "",
+        style=style(root),
+        which=" (staged)" if staged else "",
+        files="\n".join(f"{ch.code.strip() or 'M'} {ch.path}" for ch in candidates),
+        diff=changes_diff(root, candidates, bool(staged), diff_budget(agent)),
+        files_rule=FILES_STAGED if staged else FILES_CHOSEN,
+    )
+    from lcode.ollama import OllamaError
+
+    try:
+        with c.status("[cyan]Writing the commit message…[/]", spinner="dots"):
+            answer = ask(agent, request, COMMIT_SCHEMA)
+    except KeyboardInterrupt:
+        c.print("[dim]Cancelled.[/]")
+        return
+    except OllamaError as e:
+        c.print(f"[red]Couldn't write a commit message: {escape(str(e))}[/]")
+        return
+    message = clean_message(str(answer.get("message") or ""))
+    if not message:
+        c.print("[red]The model didn't write a commit message.[/] Try again, or commit yourself.")
+        return
+    files = paths
+    if not staged:
+        chosen = [f for f in answer.get("files") or [] if f in paths]
+        files = chosen or paths
+    left_out = [p for p in paths if p not in files]
+    while True:
+        c.print(Panel(escape(message), title="Commit message", title_align="left", border_style="cyan"))
+        c.print(f"  [bold]Files[/] {escape(', '.join(files))}")
+        if left_out:
+            c.print(f"  [dim]Left out (unrelated, the model thinks): {escape(', '.join(left_out))}[/]")
+        if risky:
+            c.print(f"  [dim]Left out (may hold secrets; stage them yourself if needed): {escape(', '.join(risky))}[/]")
+        choice = confirm(agent, "  [y] commit · [e] edit the message · [n] cancel: ", message)
+        if choice == "e":
+            from lcode.planning import edit_text
+
+            message = clean_message(edit_text(message)) or message
+            continue
+        break
+    if choice != "y":
+        c.print("Not committed.")
+        return
+    try:
+        if not staged:
+            git(root, "add", "-A", "--", *files)
+        git(root, "commit", "-q", "-F", "-", stdin=message + "\n", timeout=600)  # commit hooks may run tests
+        summary = git(root, "log", "-1", "--format=%h %s").strip()
+    except GitError as e:
+        c.print(f"[red]git commit failed:[/] {escape(str(e))}")
+        return
+    c.print(f"[green]✓ Committed[/] {escape(summary)}")
+
+
+# ----------------------------------------------------------------------------- /review
+
+
+def default_branch(root: Path) -> str:
+    head = git(root, "symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD", check=False).strip()
+    if head:
+        return head.removeprefix("origin/")
+    for name in ("main", "master", "trunk", "develop"):
+        if git(root, "rev-parse", "--verify", "-q", name, check=False).strip():
+            return name
+    return "main"
+
+
+def base_ref(root: Path, base: str, remote: str = "origin") -> str:
+    """<remote>/<base> when there is one (the local branch may be behind), else <base>."""
+    for ref in (f"{remote}/{base}", base):
+        if git(root, "rev-parse", "--verify", "-q", ref, check=False).strip():
+            return ref
+    raise GitError(f"there's no branch called {base}")
+
+
+def is_branch(root: Path, name: str, remote: str = "origin") -> bool:
+    refs = (f"refs/heads/{name}", f"refs/remotes/{remote}/{name}")
+    return any(git(root, "rev-parse", "--verify", "-q", ref, check=False).strip() for ref in refs)
+
+
+def review_prompt(agent: Agent, base: str = "") -> str:
+    """The request for a review of the uncommitted changes, or of the branch against `base`.
+
+    Uncommitted changes to tracked files are the work in progress, so they come first; otherwise
+    (or with a base) the branch's changes since it left the base. New files are shown either way.
+    """
+    root = repo_root(agent.cwd)
+    limit = diff_budget(agent)
+    found = changes(root)
+    untracked = [ch.path for ch in found if ch.untracked]
+    work_in_progress = any(not ch.untracked for ch in found)
+    commits = fork = ""
+    explicit = bool(base)
+    if base or (has_commits(root) and not work_in_progress):
+        if not has_commits(root):
+            raise GitError("nothing to compare with yet: the repository has no commits")
+        base = base or default_branch(root)
+        if is_branch(root, base):
+            fork = git(root, "merge-base", base_ref(root, base), "HEAD").strip()
+        elif explicit and git(root, "rev-parse", "--verify", "-q", base, check=False).strip():
+            fork = git(root, "merge-base", base, "HEAD").strip()
+        elif explicit:
+            raise GitError(f"there's no branch or commit called {base}")
+        if fork:
+            commits = git(root, "log", "--format=- %s", f"{fork}..HEAD").strip()
+    if fork and (commits or explicit or work_in_progress):
+        branch = git(root, "branch", "--show-current").strip() or "HEAD"
+        tracked = git(root, "diff", "--no-color", fork)  # the branch's commits and any uncommitted changes
+        what, next_step = f"the changes on {branch} compared with {base}", "merged"
+        stat = (
+            f"Commits:\n{commits or '(none: uncommitted changes only)'}\n\n{git(root, 'diff', '--stat', fork).strip()}"
+        )
+    elif found:
+        tracked = git(root, "diff", "--no-color", "HEAD") if has_commits(root) else ""
+        what, next_step = "the uncommitted changes", "committed"
+        stat = git(root, "diff", "--stat", "HEAD").strip() if has_commits(root) else ""
+    else:
+        where = f" and nothing on this branch that {base} doesn't have" if base else ""
+        raise GitError(f"nothing to review: no uncommitted changes{where}")
+    if untracked:
+        stat += ("\n" if stat else "") + "New files, not yet added to git: " + ", ".join(untracked)
+    diff = "\n\n".join(p for p in (tracked.strip(), new_files(root, untracked)) if p)
+    if not diff:
+        raise GitError(f"nothing to review: {what} are empty")
+    return REVIEW_PROMPT.format(
+        what=what, next=next_step, stat=stat, diff=f"```diff\n{shorten(diff, limit, 'diff')}\n```"
+    )
+
+
+# ----------------------------------------------------------------------------- /pr
+
+
+def pr_command(agent: Agent, arg: str = "") -> None:
+    c = agent.console
+    if not shutil.which("gh"):
+        c.print("[red]/pr needs the GitHub CLI:[/] install it from https://cli.github.com and run `gh auth login`.")
+        return
+    try:
+        root = repo_root(agent.cwd)
+        if not git(root, "remote").split():
+            raise GitError("this repository has no remote to push to")
+        branch = git(root, "branch", "--show-current").strip()
+        if not branch:
+            raise GitError("HEAD isn't on a branch (detached); switch to one first")
+        uncommitted = [ch for ch in changes(root) if not ch.untracked]
+        if uncommitted:
+            c.print(
+                f"There are uncommitted changes ({len(uncommitted)} file(s)). Commit them first with /commit, "
+                "then run /pr again."
+            )
+            return
+        remotes = git(root, "remote").split()
+        remote = "origin" if "origin" in remotes else remotes[0]
+        first, _, rest = arg.strip().partition(" ")
+        if first and is_branch(root, first, remote):  # /pr develop, or /pr develop <what to say>
+            base, hint = first, rest.strip()
+        else:
+            base, hint = default_branch(root), arg.strip()
+        ref = base_ref(root, base, remote)
+        commits = git(root, "log", "--format=- %s%n%b", f"{ref}..HEAD").strip()
+    except GitError as e:
+        c.print(f"[red]{escape(str(e))}[/]")
+        return
+    if not commits:
+        c.print(f"No commits to open a pull request with: {escape(branch)} has nothing that {escape(ref)} doesn't.")
+        return
+    existing = subprocess.run(
+        ["gh", "pr", "view", branch, "--json", "url,state", "-q", 'select(.state == "OPEN") | .url'],
+        cwd=root, capture_output=True, text=True, timeout=60,
+    ).stdout.strip() if branch != base else ""  # fmt: skip
+    if existing:
+        c.print(f"A pull request for {escape(branch)} is already open: {existing}")
+        if confirm(agent, f"  Push the new commits to {remote}/{branch}? [y] push · [n] no: ") == "y":
+            push(agent, root, remote, branch)
+        return
+    new_branch = branch == base  # the commits are on the base branch: they go to a new branch
+    template = next(
+        (p for p in (root / ".github" / "pull_request_template.md", root / "docs" / "pull_request_template.md",
+                     root / "PULL_REQUEST_TEMPLATE.md") if p.is_file()),
+        None,
+    )  # fmt: skip
+    request = PR_PROMPT.format(
+        base=base,
+        hint=f" The user adds: {hint}" if hint else "",
+        commits=commits,
+        diff=f"```diff\n{shorten(git(root, 'diff', '--no-color', f'{ref}...HEAD'), diff_budget(agent), 'diff')}\n```",
+        template=f"\nFill in the repository's pull request template:\n{template.read_text()[:4000]}\n"
+        if template
+        else "",
+        branch_rule=(
+            '"branch" is a short name for a new branch for these commits, such as fix-login-timeout.'
+            if new_branch
+            else '"branch" is an empty string.'
+        ),
+    )
+    from lcode.ollama import OllamaError
+
+    try:
+        with c.status("[cyan]Writing the pull request…[/]", spinner="dots"):
+            answer = ask(agent, request, PR_SCHEMA)
+    except KeyboardInterrupt:
+        c.print("[dim]Cancelled.[/]")
+        return
+    except OllamaError as e:
+        c.print(f"[red]Couldn't write the pull request: {escape(str(e))}[/]")
+        return
+    title = " ".join(str(answer.get("title") or "").split())
+    body = clean_message(str(answer.get("body") or ""))
+    if not title:
+        c.print("[red]The model didn't write a title.[/] Try again, or use gh pr create yourself.")
+        return
+    head = branch
+    if new_branch:
+        head = branch_name(str(answer.get("branch") or "")) or f"lcode-{time.strftime('%m%d')}-{secrets.token_hex(2)}"
+    while True:
+        c.print(
+            Panel(escape(f"{title}\n\n{body}".strip()), title="Pull request", title_align="left", border_style="cyan")
+        )
+        if new_branch:
+            c.print(f"  [dim]The commits are on {escape(base)}, so they go to a new branch: {escape(head)}[/]")
+        choice = confirm(
+            agent,
+            f"  Push {head} to {remote} and open the pull request into {base}? [y] yes · [e] edit · [n] no: ",
+            body,
+        )
+        if choice == "e":
+            from lcode.planning import edit_text
+
+            edited = edit_text(f"{title}\n\n{body}").strip()
+            if edited:
+                title, _, body = edited.partition("\n")
+                title, body = title.strip(), body.strip()
+            continue
+        break
+    if choice != "y":
+        c.print("No pull request opened.")
+        return
+    try:
+        if new_branch:
+            git(root, "switch", "-q", "-c", head)
+            c.print(f"[dim]Switched to the new branch {escape(head)}; {escape(base)} still has the commits locally.[/]")
+        if not push(agent, root, remote, head):
+            return
+        with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as f:
+            f.write(body + "\n")
+        try:
+            r = subprocess.run(
+                ["gh", "pr", "create", "--base", base, "--head", head, "--title", title, "--body-file", f.name],
+                cwd=root, capture_output=True, text=True, timeout=120,
+            )  # fmt: skip
+        finally:
+            Path(f.name).unlink(missing_ok=True)
+    except (GitError, OSError, subprocess.SubprocessError) as e:
+        c.print(f"[red]{escape(str(e))}[/]")
+        return
+    if r.returncode != 0:
+        c.print(f"[red]gh pr create failed:[/] {escape((r.stderr or r.stdout).strip())}")
+        return
+    c.print(f"[green]✓ Opened[/] {r.stdout.strip().splitlines()[-1] if r.stdout.strip() else 'the pull request'}")
+
+
+def push(agent: Agent, root: Path, remote: str, branch: str) -> bool:
+    try:
+        with agent.console.status(f"Pushing {escape(branch)}…", spinner="dots"):
+            git(root, "push", "-q", "-u", remote, branch, timeout=300)
+    except GitError as e:
+        agent.console.print(f"[red]git push failed:[/] {escape(str(e))}")
+        return False
+    agent.console.print(f"[green]✓ Pushed[/] {escape(branch)}")
+    return True
+
+
+def branch_name(text: str) -> str:
+    name = re.sub(r"[^A-Za-z0-9._/-]+", "-", text.strip()).strip("-/.")
+    return re.sub(r"-{2,}", "-", name)[:60]
+
+
+# ----------------------------------------------------------------------------- lcode --worktree
+
+
+@dataclass
+class WorktreeSession:
+    root: Path  # the repository's main working tree
+    path: Path
+    branch: str
+    base: str  # the commit the main working tree was on when the session started
+    created_branch: bool
+    cwd: Path
+
+    def finish(self) -> str:
+        """Remove the worktree when nothing changed in it; otherwise say where the work is."""
+        try:
+            dirty = git(self.path, "status", "--porcelain").strip()
+            ahead = int(git(self.root, "rev-list", "--count", f"{self.base}..{self.branch}").strip() or 0)
+        except (GitError, ValueError):
+            return f"The worktree stays at {self.path}."
+        if not dirty and not ahead:
+            git(self.root, "worktree", "remove", str(self.path), check=False)
+            if self.created_branch:
+                git(self.root, "branch", "-D", self.branch, check=False)
+            return f"Nothing changed in the worktree, so it was removed{' with its branch' if self.created_branch else ''}."
+        parts = [f"{ahead} commit(s)" if ahead else "", "uncommitted changes" if dirty else ""]
+        return (
+            f"The worktree stays at {self.path} (branch {self.branch}: {' and '.join(p for p in parts if p)}). "
+            f"Continue there with `lcode --worktree {self.branch}`; merge with `git merge {self.branch}`; "
+            f"remove it with `git worktree remove {self.path}`."
+        )
+
+
+def main_checkout(cwd: Path) -> Path:
+    """The repository's main working tree, also from inside one of its worktrees."""
+    root = repo_root(cwd)
+    common = Path(git(root, "rev-parse", "--path-format=absolute", "--git-common-dir").strip())
+    return common.parent if common.name == ".git" else root
+
+
+def worktree_path(root: Path, name: str) -> Path:
+    """Outside the repository: inside it, the main checkout's path would lead models astray."""
+    from lcode import config
+    from lcode.memory import slugify
+
+    key = hashlib.sha256(str(root.resolve()).encode()).hexdigest()[:8]
+    return config.STATE_DIR / "worktrees" / f"{slugify(root.name, 40) or 'repo'}-{key}" / name.replace("/", "-")
+
+
+def start_worktree(cwd: Path, name: str) -> WorktreeSession:
+    """A worktree on its own branch, for a session that works in parallel with others."""
+    root = main_checkout(cwd)
+    if not has_commits(root):
+        raise GitError("a worktree needs a repository with at least one commit")
+    name = name or f"lcode-{time.strftime('%m%d')}-{secrets.token_hex(2)}"
+    if git(root, "check-ref-format", "--branch", name, check=False).strip() != name:
+        raise GitError(f"{name!r} isn't a valid branch name")
+    path = worktree_path(root, name)
+    base = git(root, "rev-parse", "HEAD").strip()
+    created = False
+    if not (path / ".git").exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        git(root, "worktree", "prune")  # forget worktrees whose folders were deleted
+        if git(root, "rev-parse", "--verify", "-q", f"refs/heads/{name}", check=False).strip():
+            git(root, "worktree", "add", "-q", str(path), name)
+        else:
+            git(root, "worktree", "add", "-q", "-b", name, str(path), "HEAD")
+            created = True
+    here = cwd.resolve()
+    sub = here.relative_to(root.resolve()) if here.is_relative_to(root.resolve()) else Path()
+    inside = path / sub
+    return WorktreeSession(root, path, name, base, created, inside if inside.is_dir() else path)

lcode/repl.py

@@ -26,7 +26,7 @@ from rich.rule import Rule
 from rich.table import Table
 from rich.text import Text
 
-from lcode import __version__, backends, catalog, extensions, limits, sessions, web
+from lcode import __version__, backends, catalog, extensions, gitflow, limits, sessions, web
 from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.agent import AUTO_COMPACT_RATIO, INIT_PROMPT, Agent
@@ -62,8 +62,12 @@ COMMANDS = {
     "/mode": "Permission mode: ask | plan | auto-edit | yolo (Shift+Tab cycles)",
     "/cd": "Change the working directory",
     "/todos": "Show the current todo list",
+    "/commit": "Commit the changes with a message in the repository's style, after you approve it",
+    "/review": "Review the uncommitted changes, or the branch against a base: /review [base]",
+    "/pr": "Push the branch and open a GitHub pull request, after you approve it: /pr [base] [notes]",
     "/exit": "Quit",
 }
+REPLACEABLE = {"/commit", "/review", "/pr"}  # a command of your own with the same name runs instead
 
 
 class InputCompleter(Completer):
@@ -420,7 +424,11 @@ def custom_commands(agent: Agent) -> dict[str, str]:
     ext = agent.extensions()
     found = {f"/{name}": skill.description for name, skill in ext.skills.items()}
     found.update({f"/{name}": command.description for name, command in ext.commands.items()})
-    return {name: description for name, description in found.items() if name not in COMMANDS}
+    return {
+        name: description
+        for name, description in found.items()
+        if name not in COMMANDS or (name in REPLACEABLE and name[1:] in ext.commands)
+    }
 
 
 def help_extensions(agent: Agent) -> None:
@@ -430,7 +438,11 @@ def help_extensions(agent: Agent) -> None:
         for column in ("Command", "Does", "From"):
             table.add_column(column)
         for command in ext.commands.values():
-            hidden = " [yellow](hidden by the built-in command)[/]" if f"/{command.name}" in COMMANDS else ""
+            hidden = ""
+            if f"/{command.name}" in REPLACEABLE:
+                hidden = " [dim](replaces the built-in command)[/]"
+            elif f"/{command.name}" in COMMANDS:
+                hidden = " [yellow](hidden by the built-in command)[/]"
             usage = f"/{command.name}" + (f" {command.argument_hint}" if command.argument_hint else "")
             table.add_row(escape(usage), escape(command.description) + hidden, escape(agent.tools.rel(command.path)))
         c.print(table)
@@ -767,6 +779,27 @@ def web_status(agent: Agent) -> str:
 LONG_REQUEST = 30  # seconds: a request this long sends a notification when it's done (notification hooks)
 
 
+def git_command(agent: Agent, cmd: str, arg: str) -> None:
+    """/commit, /review and /pr (a command of your own with the same name replaces them)."""
+    c = agent.console
+    if cmd == "/commit":
+        gitflow.commit_command(agent, arg)
+    elif cmd == "/pr":
+        gitflow.pr_command(agent, arg)
+    else:
+        try:
+            with c.status("Collecting the changes…", spinner="dots"):
+                prompt = gitflow.review_prompt(agent, arg)
+        except gitflow.GitError as e:
+            c.print(f"[yellow]{escape(str(e))}[/]")
+            return
+        agent.no_changes = "This is a review, so nothing can be changed: report what should change instead."
+        try:
+            run_safely(agent, prompt)
+        finally:
+            agent.no_changes = ""
+
+
 def run_safely(agent: Agent, text: str) -> None:
     started = time.monotonic()
     try:
@@ -900,6 +933,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
         agent.tools.show_todos()
     elif cmd == "/init":
         run_safely(agent, INIT_PROMPT)
+    elif cmd in REPLACEABLE and cmd[1:] not in agent.extensions().commands:
+        git_command(agent, cmd, arg)
     elif cmd[1:] in agent.extensions().commands:
         command = agent.extensions().commands[cmd[1:]]
         c.print(f"[dim]/{escape(command.name)} from {escape(agent.tools.rel(command.path))}[/]")

lcode/tools.py

@@ -440,6 +440,8 @@ class Toolbox:
             return f"Error: {name} isn't available to you. Available: {', '.join(sorted(allowed))}"
         if self.agent.planning() and name not in PLAN_MODE_TOOLS:
             return f"Error: {BLOCKED}"
+        if self.agent.no_changes and name not in PLAN_MODE_TOOLS:
+            return f"Error: {self.agent.no_changes}"
         if name == "present_plan" and not self.agent.planning():
             return "Error: plan mode is off, so there's nothing to present: carry on with the work."
         if self.agent.mcp and self.agent.mcp.owns(name):
@@ -484,6 +486,8 @@ class Toolbox:
         kind = self.agent.agent_types().get(type)
         if self.agent.planning() and kind and not kind.read_only:
             raise ToolError(f"plan mode is on: only read-only agents can run now ({BLOCKED})")
+        if self.agent.no_changes and kind and not kind.read_only:
+            raise ToolError(f"only read-only agents can run now: {self.agent.no_changes}")
         return subagents.run_one(self.agent, {"type": type, "task": task, "description": description})
 
     # -- plan mode
@@ -777,6 +781,8 @@ class Toolbox:
         sandbox = self.agent.sandbox
         if self.agent.planning() and not is_read_only(command):
             raise ToolError(f"{BLOCKED} Until then, only read-only commands run (ls, cat, grep, git log, …).")
+        if self.agent.no_changes and not is_read_only(command):
+            raise ToolError(f"{self.agent.no_changes} Only read-only commands run (ls, cat, grep, git diff, …).")
         if self.agent.read_only and not is_read_only(command):
             raise ToolError(
                 "you can only run read-only commands (such as ls, cat, grep, find, git log, git diff), one at a "

{lcode_cli-0.16.0.dist-info → lcode_cli-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.16.0
+Version: 0.17.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/
@@ -101,6 +101,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
 - **Remembers what matters.** Corrections, decisions and where things live carry over to the next
   session as short notes, saved by the model, by you (`/remember`) or by a quick check at the end
   of a session. Not whole conversations, and never secrets.
+- **Git workflow.** `/commit` writes messages in your repository's style, `/review` checks the
+  changes with `file:line` findings, `/pr` opens the pull request, each after you approve it, and
+  `lcode --worktree` runs parallel sessions on one repository.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling. Or use LM Studio, llama.cpp, vLLM or MLX instead of Ollama.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
@@ -208,8 +211,8 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Git workflow: /commit, /review, /pr and parallel worktrees](https://github.com/nasser1941/lcode/issues/50)
 - [Automation: JSON output, a Python API and a GitHub Action for self-hosted runners](https://github.com/nasser1941/lcode/issues/48)
+- [Editor integration through the Agent Client Protocol](https://github.com/nasser1941/lcode/issues/49)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))
 
 ## Contributing

{lcode_cli-0.16.0.dist-info → lcode_cli-0.17.0.dist-info}/RECORD

@@ -1,17 +1,18 @@
-lcode/__init__.py,sha256=zacfVVvqhWmN_-V62Fl2VjpnxCnSmt1Y75XJ4_2KJ64,118
+lcode/__init__.py,sha256=m94TcHxJbJ3MaEvHqOhWfWdGVWdgYlJoeSId7er_5-Q,118
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
-lcode/agent.py,sha256=ZApMmW8TE4SMD5nc2TCE7M0U_VCwHq1xIl97hmFGcfo,46262
+lcode/agent.py,sha256=sFt7pfwvP0DMxIySznhWDyOLT7fujQa6jBMl9tQ2j8M,46979
 lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
 lcode/bench.py,sha256=XVdk0hDxmRcjgROOCgwwOsExcUhIxgh0B2vnxtGnA3o,40742
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=QAnmYqJ36Wyhp5WLI0DC6S-KIVgzx8vZ8Iv-rQLmqEk,40289
+lcode/cli.py,sha256=KjUezZD83VzSdLZEXMzSJO0I-mvNQSwSQdZgFpyGc-4,41090
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
 lcode/config.py,sha256=nFljzjHTFaCTTbagycagbh2X_PpLtsUs-yRODiy4QcU,10065
 lcode/context.py,sha256=qJymLE3eYeaF6qVOzlUwDURqlky__8cskl_6vXeU3AA,10701
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
+lcode/gitflow.py,sha256=y78dqqh80is-MiDTnSHnK9vjx0vFovor_SZ8hW1NJaU,27167
 lcode/hardware.py,sha256=2VbknZCxTZJwJUD8YWdQ7ryEQo_LcjtoOBOHOU9Y0fw,3085
 lcode/hooks.py,sha256=K0itOiAuH4rxndJ9gne_uCrqby6oWAzFPRrfB3tCq-E,9324
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
@@ -22,12 +23,12 @@ lcode/ollama.py,sha256=u5tnvL28cfaFS4GhmiEsHhTQe6w3Ng_Tej05UUzLQTQ,7715
 lcode/permissions.py,sha256=bSDpkSzq1tozC3LgzAzXmJX_DGRxoY9a3Kdx-AFQ3nI,5426
 lcode/planning.py,sha256=hZjVka7i9TswJrXLbjbZJ0PBc6zHpmO64JqMiaFYnMQ,6110
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
-lcode/repl.py,sha256=PRO4VG-s8kSowcHJ3svYHpHFBU0s4nsvsth8dyKG6mE,46117
+lcode/repl.py,sha256=zJ2hj1c-tx35Sms8V-1W4XsyfFZ9omu9bZgGpEgBYi8,47655
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
 lcode/subagents.py,sha256=kfDICxAYd4i9LtBFxTO9tdvbAB5JzF_iQXUUK9i6yc4,28813
-lcode/tools.py,sha256=ris8gXJ2phFY9Fr4UnUVkuyqjMRWMWONZc7onO7O-9c,41904
+lcode/tools.py,sha256=zpFFY3dK8-g9So_MmUoj7qU8Stmx5b6PQrpcNba-s6E,42360
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
@@ -45,8 +46,8 @@ lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
 lcode/servers/__init__.py,sha256=qrIhxEodEB8cjKEQ4Cicc0GsQhE2OH-9qlVHzr3-tq8,77
 lcode/servers/encord.py,sha256=WSauawL1UKYZCUAG1oalcKL_An3DVof-JM6xIgFyQSE,12769
 lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
-lcode_cli-0.16.0.dist-info/METADATA,sha256=vHaeTD3ZW6w2pDT_LhDDlfyVYrIa3lprUbWUof4WJtE,12126
-lcode_cli-0.16.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.16.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
-lcode_cli-0.16.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.16.0.dist-info/RECORD,,
+lcode_cli-0.17.0.dist-info/METADATA,sha256=dDApqW2hYQQr89fUFigiyVph4Ib-DyYO4Ho1_zggtS4,12376
+lcode_cli-0.17.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.17.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
+lcode_cli-0.17.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.17.0.dist-info/RECORD,,