agent7 0.1.0__tar.gz

agent7-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.py[cod]
+.env
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.ruff_cache/

agent7-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r1cardohj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent7-0.1.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.5
+Name: agent7
+Version: 0.1.0
+Summary: The simplest coding agent — four tools, one loop, ~1200 lines of Python
+Project-URL: Homepage, https://github.com/r1cardohj/agent7
+Project-URL: Repository, https://github.com/r1cardohj/agent7
+Project-URL: Issues, https://github.com/r1cardohj/agent7/issues
+Author-email: r1cardohj <2413302357@qq.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,cli,coding-agent,deepseek,kimi,llm,openai-compatible
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: openai>=1.40.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: rich>=13.0.0
+Description-Content-Type: text/markdown
+
+# agent7
+
+**The simplest coding agent. ~1200 lines of Python, four tools, one loop.**
+
+No orchestration: no plan mode, no subagents, no parallel tasks, no background jobs.
+You give it one sentence; it reads files, edits files, runs commands, then stops.
+Built for people who work on one thing at a time — you hold one task in your head, and so does it.
+
+```
+agent7/        1252 lines
+  __main__.py   355   CLI + REPL + @path completion
+  agent.py      398   tools + agent loop + compaction
+  commands.py   236   slash commands + model switching
+  providers.py  161   API key auth
+  session.py    101   session state
+```
+
+## Install
+
+```bash
+pip install agent7
+# or: uv tool install agent7
+# or from source: uv sync && uv run agent7
+```
+
+## Auth
+
+Paste an API key; there is no OAuth. Keys are stored in `~/.config/agent7/auth.json`.
+
+```bash
+export DEEPSEEK_API_KEY=sk-...
+# export KIMI_API_KEY=...
+# export MOONSHOT_API_KEY=sk-...
+# export AGENT7_MODEL=deepseek-flash
+```
+
+You can also log in from inside the REPL:
+
+```text
+/login deepseek
+/login kimi              # optional: /login kimi global
+/login moonshot
+/model                   # list models for every logged-in provider
+/model deepseek-flash
+```
+
+## Usage
+
+```bash
+uv run agent7 "create hello.py that prints hi"   # one-shot
+uv run agent7                                    # REPL
+```
+
+REPL commands: `/help` `/model` `/status` `/login` `/logout` `/compact`.
+Exit with an empty line or Ctrl-D.
+
+Type `@` in the REPL to recursively complete files and directories from the cwd:
+`fix @agent7/agent.py`.
+Tab accepts, directories keep going (`@agent7/` → `@agent7/session.py`), and spaces
+are escaped (`@my\ file.txt`), so the path the model sees is the path it can read.
+
+`--cwd` sets the working directory, `--max-turns` caps the loop (default 30 turns;
+when it runs out you get `# (stopped after N turns)`). A run that ends with no visible
+text never ends silently: you get either `# (stopped after N turns)`,
+`# no text in the reply …` or `# … hit the output token limit …`.
+
+## Only four tools
+
+| Tool | What it does | Output budget |
+|---|---|---|
+| `read` | Read a file with line numbers | 200 lines per call by default; page with `offset=` |
+| `write` | Write a file; with `old_string=` replace one unique span | `path  +N -M` diff stats |
+| `bash` | Run a shell command in the cwd | ~12k chars |
+| `grep` | rg/grep search | 100 lines / ~12k chars |
+
+That's it. No `edit`, no `list_dir`, no `todo`, no `task`.
+Need more capability? Let the agent use `bash`.
+
+Tools run **serially**, one after another — so the log always reads in order and
+you never get three outputs interleaved. Edits are applied without a confirmation
+prompt; you just get a one-line diff stat.
+
+## Context
+
+At 75% context usage, old tool/assistant text is compacted automatically: the last
+3 user turns are kept, or for one-shot tasks the last 4 tool results. `/compact`
+triggers the same compaction manually.
+
+`AGENT7_CONTEXT_LIMIT` overrides the context limit.
+
+## What it is not
+
+- Not an orchestrator: no branching, no subagents
+- Not a parallel framework: single-threaded, one thing at a time
+- Not a background service: a foreground process, stopped with Ctrl-C
+- No sandbox: tools run as you, and `bash` can do anything your account can do
+
+If that kind of "small" is exactly what you want, this is enough. If it's missing
+the abstraction you had in mind, that omission is probably the point — not an oversight.

agent7-0.1.0/README.md

@@ -0,0 +1,99 @@
+# agent7
+
+**The simplest coding agent. ~1200 lines of Python, four tools, one loop.**
+
+No orchestration: no plan mode, no subagents, no parallel tasks, no background jobs.
+You give it one sentence; it reads files, edits files, runs commands, then stops.
+Built for people who work on one thing at a time — you hold one task in your head, and so does it.
+
+```
+agent7/        1252 lines
+  __main__.py   355   CLI + REPL + @path completion
+  agent.py      398   tools + agent loop + compaction
+  commands.py   236   slash commands + model switching
+  providers.py  161   API key auth
+  session.py    101   session state
+```
+
+## Install
+
+```bash
+pip install agent7
+# or: uv tool install agent7
+# or from source: uv sync && uv run agent7
+```
+
+## Auth
+
+Paste an API key; there is no OAuth. Keys are stored in `~/.config/agent7/auth.json`.
+
+```bash
+export DEEPSEEK_API_KEY=sk-...
+# export KIMI_API_KEY=...
+# export MOONSHOT_API_KEY=sk-...
+# export AGENT7_MODEL=deepseek-flash
+```
+
+You can also log in from inside the REPL:
+
+```text
+/login deepseek
+/login kimi              # optional: /login kimi global
+/login moonshot
+/model                   # list models for every logged-in provider
+/model deepseek-flash
+```
+
+## Usage
+
+```bash
+uv run agent7 "create hello.py that prints hi"   # one-shot
+uv run agent7                                    # REPL
+```
+
+REPL commands: `/help` `/model` `/status` `/login` `/logout` `/compact`.
+Exit with an empty line or Ctrl-D.
+
+Type `@` in the REPL to recursively complete files and directories from the cwd:
+`fix @agent7/agent.py`.
+Tab accepts, directories keep going (`@agent7/` → `@agent7/session.py`), and spaces
+are escaped (`@my\ file.txt`), so the path the model sees is the path it can read.
+
+`--cwd` sets the working directory, `--max-turns` caps the loop (default 30 turns;
+when it runs out you get `# (stopped after N turns)`). A run that ends with no visible
+text never ends silently: you get either `# (stopped after N turns)`,
+`# no text in the reply …` or `# … hit the output token limit …`.
+
+## Only four tools
+
+| Tool | What it does | Output budget |
+|---|---|---|
+| `read` | Read a file with line numbers | 200 lines per call by default; page with `offset=` |
+| `write` | Write a file; with `old_string=` replace one unique span | `path  +N -M` diff stats |
+| `bash` | Run a shell command in the cwd | ~12k chars |
+| `grep` | rg/grep search | 100 lines / ~12k chars |
+
+That's it. No `edit`, no `list_dir`, no `todo`, no `task`.
+Need more capability? Let the agent use `bash`.
+
+Tools run **serially**, one after another — so the log always reads in order and
+you never get three outputs interleaved. Edits are applied without a confirmation
+prompt; you just get a one-line diff stat.
+
+## Context
+
+At 75% context usage, old tool/assistant text is compacted automatically: the last
+3 user turns are kept, or for one-shot tasks the last 4 tool results. `/compact`
+triggers the same compaction manually.
+
+`AGENT7_CONTEXT_LIMIT` overrides the context limit.
+
+## What it is not
+
+- Not an orchestrator: no branching, no subagents
+- Not a parallel framework: single-threaded, one thing at a time
+- Not a background service: a foreground process, stopped with Ctrl-C
+- No sandbox: tools run as you, and `bash` can do anything your account can do
+
+If that kind of "small" is exactly what you want, this is enough. If it's missing
+the abstraction you had in mind, that omission is probably the point — not an oversight.

agent7-0.1.0/agent7/__init__.py

@@ -0,0 +1,3 @@
+"""agent7 — minimal coding agent."""
+
+__version__ = "0.1.0"

agent7-0.1.0/agent7/__main__.py

@@ -0,0 +1,357 @@
+"""CLI: python -m agent7 [task] [--cwd DIR]"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import re
+import sys
+import time
+from pathlib import Path
+
+from openai import AsyncOpenAI
+from prompt_toolkit import PromptSession
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.completion import Completer, Completion, CompleteEvent
+from prompt_toolkit.document import Document
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.key_binding.vi_state import InputMode
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.text import Text
+
+from .agent import SYSTEM, Interrupted, run_agent, tool_summary
+from .commands import dispatch, fetch_models, known_names, switch_model
+from .providers import get_provider, resolve_all, resolve_default
+from .session import Session, format_context_prompt
+
+console, err = Console(stderr=False), Console(stderr=True)
+_THINK_FRAMES = ("thinking   ", "thinking.  ", "thinking.. ", "thinking...")
+
+def _load_dotenv(path: Path = Path(".env")) -> None:
+    if not path.is_file():
+        return
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        os.environ.setdefault(key.strip(), val.strip().strip("'").strip('"'))
+
+def _force_utf8_stdio() -> None:
+    for stream in (sys.stdin, sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+        except Exception:
+            pass
+    os.environ.setdefault("PYTHONIOENCODING", "utf-8")
+
+class ReplyPrinter:
+    def __init__(self) -> None:
+        self.buf: list[str] = []
+        self._chars = 0
+        self._thinking_open = False
+        self._thinking_t0 = 0.0
+        self._counting = False
+
+    def __enter__(self) -> ReplyPrinter:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self._close_thinking()
+        self._clear_counter()
+        text = "".join(self.buf)
+        self.buf.clear()
+        self._chars = 0
+        if text.strip():
+            console.print()
+            console.print(Markdown(text))
+            console.print()
+
+    def _clear_status_line(self) -> None:
+        if err.is_terminal:
+            sys.stderr.write("\r\033[K")
+            sys.stderr.flush()
+
+    def _close_thinking(self) -> None:
+        if self._thinking_open:
+            self._clear_status_line()
+            self._thinking_open = False
+
+    def _clear_counter(self) -> None:
+        if self._counting:
+            self._clear_status_line()
+            self._counting = False
+
+    def _show_counter(self) -> None:
+        if not err.is_terminal:
+            return
+        self._close_thinking()
+        self._counting = True
+        sys.stderr.write(f"\r\033[K  … {self._chars} chars")
+        sys.stderr.flush()
+
+    def on_thinking(self, text: str) -> None:
+        if not text:
+            return
+        self._clear_counter()
+        if not self._thinking_open:
+            self._thinking_open, self._thinking_t0 = True, time.monotonic()
+        if err.is_terminal:
+            frame = int((time.monotonic() - self._thinking_t0) / 0.4) % len(_THINK_FRAMES)
+            sys.stderr.write(f"\r\033[K  {_THINK_FRAMES[frame]}")
+            sys.stderr.flush()
+
+    def on_answer_to_thinking(self) -> None:
+        if not self.buf:
+            return
+        self.buf.clear()
+        self._chars = 0
+        self._clear_counter()
+        self.on_thinking(".")
+
+    def on_delta(self, text: str) -> None:
+        self.buf.append(text)
+        self._chars += len(text)
+        self._show_counter()
+
+    def on_tool(self, turn: int, name: str, args: dict, result: str) -> None:
+        self._close_thinking()
+        self._clear_counter()
+        self.buf.clear()
+        self._chars = 0
+        ok = not result.startswith("error:")
+        mark = "[green]✓[/green]" if ok else "[red]✗[/red]"
+        meta = ""
+        if name == "bash" and result.startswith("exit="):
+            code = result.split("\n", 1)[0].removeprefix("exit=")
+            color = "green" if code == "0" else "yellow"
+            meta = f"  [{color}]exit={code}[/{color}]"
+        err.print(f"  {mark} [bold]{name:<5}[/bold] [dim]{tool_summary(name, args)}[/dim]{meta}")
+
+    def on_preview(self, stats: str) -> None:
+        self._close_thinking()
+        self._clear_counter()
+        line = (stats.splitlines() or [""])[0]
+        if not line:
+            return
+        path, _, rest = line.rpartition("  ")
+        head = Text("# write  ", style="dim")
+        head.append(path or line, style="dim")
+        if path and rest.startswith("+"):
+            head.append("  ")
+            for part in rest.split():
+                head.append(part + " ", style="green bold" if part[0] == "+" else "red bold")
+            head.right_crop(1)
+        err.print(head)
+
+_AT_PATH = re.compile(r"(?<![A-Za-z0-9_.\-/@])@((?:\\ |[^\s@])*)$")
+
+def at_path_prefix(text: str) -> str | None:
+    """The path fragment after an '@' that starts the current word ('@' -> '')."""
+    m = _AT_PATH.search(text)
+    return m.group(1) if m else None
+
+def path_completions(cwd: Path, text: str) -> list[Completion]:
+    """Complete files/dirs as `@path` for the word being typed at the end of text."""
+    fragment = at_path_prefix(text)
+    if fragment is None:
+        return []
+    raw = os.path.expanduser(fragment.replace("\\ ", " "))
+    head, _, prefix = raw.rpartition("/")
+    target = Path(head) if head else Path()
+    if not target.is_absolute():
+        target = cwd / target
+    entries: list[tuple[Path, str]] = []
+    show_hidden = prefix.startswith(".")
+    for root, dirs, files in os.walk(target):
+        if not show_hidden:
+            dirs[:] = [name for name in dirs if not name.startswith(".")]
+        for name in dirs + files:
+            if (name.startswith(".") and not show_hidden) or not name.startswith(prefix):
+                continue
+            p = Path(root) / name
+            entries.append((p, p.relative_to(target).as_posix()))
+    entries.sort(key=lambda entry: (not entry[0].is_dir(), entry[1].lower()))
+    out = []
+    for p, path in entries:
+        is_dir = p.is_dir()
+        rel = f"{head}/{path}" if head else path
+        out.append(Completion(
+            (rel + "/" if is_dir else rel).replace(" ", "\\ "),
+            start_position=-len(fragment),
+            display=path + ("/" if is_dir else ""),
+        ))
+    return out
+
+class ReplCompleter(Completer):
+    """Slash commands, plus `@path` file completion from the cwd."""
+
+    def __init__(self, session: Session) -> None:
+        self.session = session
+
+    def get_completions(self, document: Document, complete_event: CompleteEvent):
+        text = document.text_before_cursor
+        if not text.startswith("/"):
+            yield from path_completions(self.session.cwd, text)
+            return
+        parts = text[1:].split(" ", 1)
+        cmd = parts[0].lower()
+        if len(parts) == 1 and " " not in text:
+            for name in known_names():
+                if name.startswith(cmd):
+                    yield Completion(name, start_position=-len(cmd), display=f"/{name}")
+            return
+        if len(parts) == 2:
+            prefix = parts[1]
+            if cmd == "model":
+                for mid in self.session.models_cache or []:
+                    bare = mid.partition("/")[2]
+                    if mid.startswith(prefix) or bare.startswith(prefix) or prefix.lower() in mid.lower():
+                        yield Completion(mid, start_position=-len(prefix), display=mid)
+            elif cmd in ("login", "logout"):
+                for mid in ("deepseek", "kimi", "moonshot", "global"):
+                    if mid.startswith(prefix.lower()):
+                        yield Completion(mid, start_position=-len(prefix), display=mid)
+
+NO_TEXT_NOTICE = "no text in the reply — the model stopped without content (retry, or /model)"
+TRUNCATED_NOTICE = "no text in the reply — the model hit the output token limit (retry with a smaller step)"
+STOPPED_PREFIX = "(stopped after "
+
+def reply_notice(answer: str, finish_reason: str | None = None) -> str | None:
+    """Dim note for a run that produced nothing visible on screen."""
+    if answer.startswith(STOPPED_PREFIX):  # "ran out of turns" is itself the message
+        return answer
+    if answer.strip():
+        return None
+    return TRUNCATED_NOTICE if finish_reason == "length" else NO_TEXT_NOTICE
+
+async def _run_once(session: Session, task: str) -> str:
+    finish: list[str] = []
+    with ReplyPrinter() as rp:
+        answer = await run_agent(
+            task, cwd=session.cwd, client=session.client, model=session.model,
+            max_turns=session.max_turns, messages=session.messages,
+            on_delta=rp.on_delta, on_thinking=rp.on_thinking,
+            on_answer_to_thinking=rp.on_answer_to_thinking, on_tool=rp.on_tool,
+            on_preview=rp.on_preview, on_usage=session.update_usage,
+            context_limit=session.context_limit, prompt_tokens=session.prompt_tokens,
+            on_compact=lambda n: err.print(f"[dim]# compacted {n} message(s)[/dim]"),
+            on_finish=finish.append,
+        )
+    # never leave a tool call as the last thing on screen
+    if notice := reply_notice(answer, finish[-1] if finish else None):
+        err.print(f"[dim]# {notice}[/dim]")
+    return answer
+
+async def async_main(argv: list[str] | None = None) -> None:
+    _force_utf8_stdio()
+    _load_dotenv()
+    p = argparse.ArgumentParser(description="agent7 — minimal coding agent")
+    p.add_argument("task", nargs="*", help="task; omit for REPL")
+    p.add_argument("--cwd", type=Path, default=None)
+    p.add_argument("--max-turns", type=int, default=30)
+    args = p.parse_args(argv)
+    task = " ".join(args.task).strip() or None
+    cwd = (args.cwd or Path.cwd()).resolve()
+    model = os.environ.get("AGENT7_MODEL") or ""
+
+    all_creds = resolve_all()
+    picked = resolve_default()
+    if picked is None and all_creds:
+        pid = next(iter(all_creds))
+        prov = get_provider(pid)
+        picked = (prov, all_creds[pid]) if prov else None
+    if picked:
+        prov, cred = picked
+        client = prov.make_client(cred)
+    else:
+        client = AsyncOpenAI(api_key="missing", base_url="https://api.deepseek.com")
+        if task:
+            print("No credentials. Set DEEPSEEK_API_KEY / KIMI_API_KEY / MOONSHOT_API_KEY,\n"
+                  "or run `uv run agent7` and `/login`.", file=sys.stderr)
+            sys.exit(1)
+        prov, cred = None, None
+    state = Session(
+        model=model or "pending", cwd=cwd, client=client, max_turns=args.max_turns,
+        messages=[{"role": "system", "content": SYSTEM}],
+        provider_id=prov.id if prov else None, cred_source=cred.source if cred else None,
+        credential=cred, credentials=dict(all_creds),
+    )
+    try:
+        ids: list[str] = []
+        if all_creds:
+            try:
+                ids = await fetch_models(state)
+            except Exception as e:  # noqa: BLE001
+                err.print(f"[dim]# models fetch failed: {e}[/dim]")
+        if model:
+            result = await switch_model(state, model)
+            if result.message.startswith(("unknown", "ambiguous")):
+                err.print(f"[dim]# {result.message}[/dim]")
+                if ids:
+                    await switch_model(state, ids[0])
+                else:
+                    state.set_model(model)
+        elif state.model in ("", "pending"):
+            if ids:
+                await switch_model(state, ids[0])
+            else:
+                state.set_model("deepseek-chat")
+        err.print(f"[dim]# agent7  model={state.model_ref or state.model}  "
+                  f"providers=[{','.join(state.credentials) or 'none'}]  cwd={state.cwd}[/dim]")
+        if task:
+            try:
+                await _run_once(state, task)
+            except Interrupted:
+                err.print("\n[dim]# interrupted[/dim]")
+            return
+        err.print("[dim]# REPL  /help · /login · /model · @file · empty line / Ctrl-D to quit[/dim]")
+        if not all_creds:
+            err.print("[dim]# no credentials — /login deepseek | /login kimi[/dim]")
+
+        def _vi_rprompt() -> HTML:
+            mode = get_app().vi_state.input_mode
+            label, color = ("INSERT", "ansigreen") if mode in (InputMode.INSERT, InputMode.INSERT_MULTIPLE) else (
+                ("NORMAL", "ansiyellow") if mode == InputMode.NAVIGATION else ("REPLACE", "ansired")
+            )
+            return HTML(f'<style fg="{color}">-- {label} --</style>')
+
+        prompt = PromptSession(
+            history=InMemoryHistory(),
+            completer=ReplCompleter(state),
+            complete_while_typing=True,
+            editing_mode=EditingMode.VI,
+            rprompt=_vi_rprompt,
+        )
+        while True:
+            try:
+                line = (await prompt.prompt_async(lambda: f"{format_context_prompt(state)} > ")).strip()
+            except (EOFError, KeyboardInterrupt):
+                print(file=sys.stderr)
+                break
+            if not line:
+                break
+            result = await dispatch(state, line)
+            if result is not None:
+                for row in result.message.splitlines():
+                    err.print(f"[dim]{row}[/dim]")
+                continue
+            if state.credential is None:
+                err.print("[yellow]# login first: /login deepseek | /login kimi[/yellow]")
+                continue
+            try:
+                await _run_once(state, line)
+            except (Interrupted, asyncio.CancelledError, KeyboardInterrupt):
+                err.print("\n[dim]# interrupted[/dim]")
+    finally:
+        await state.client.close()
+
+def main(argv: list[str] | None = None) -> None:
+    asyncio.run(async_main(argv))
+
+if __name__ == "__main__":
+    main()