ipyai 0.0.1__tar.gz

ipyai-0.0.1/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: ipyai
+Version: 0.0.1
+Summary: Minimal IPython backtick-to-AI extension
+Author-email: Jeremy Howard <info@answer.ai>
+License: Apache-2.0
+Project-URL: Source, https://github.com/answerdotai/fastship
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastcore
+Requires-Dist: ipython>=9
+Requires-Dist: lisette>=0.0.47
+Requires-Dist: rich
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: fastship>=0.0.6; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+
+# ipyai
+
+`ipyai` is an IPython extension that turns any input starting with `` ` `` into an AI prompt.
+
+It is aimed at terminal IPython, not notebook frontends. Prompts stream through `lisette`, final output is rendered with `rich`, and prompt history is stored alongside normal IPython history in the same SQLite database.
+
+## Install
+
+```bash
+pip install ipyai
+```
+
+## Load
+
+```python
+%load_ext ipyai
+```
+
+If you change the package in a running shell:
+
+```python
+%reload_ext ipyai
+```
+
+## How To Auto-Load `ipyai`
+
+`ipyai` is designed for terminal IPython. To auto-load it, add this to an `ipython_config.py` file used by terminal `ipython`:
+
+```python
+c.TerminalIPythonApp.extensions = ["ipyai"]
+```
+
+Good places for that file include:
+
+- env-local: `{sys.prefix}/etc/ipython/ipython_config.py`
+- user-local: `~/.ipython/profile_default/ipython_config.py`
+- system-wide IPython config directories
+
+In a virtualenv, the env-local path is usually:
+
+- `.venv/etc/ipython/ipython_config.py`
+
+To see which config paths your current `ipython` is searching, run:
+
+```bash
+ipython --debug -c 'exit()' 2>&1 | grep Searching
+```
+
+## Usage
+
+Only the leading backtick is special. There is no closing delimiter.
+
+Single line:
+
+```python
+`write a haiku about sqlite
+```
+
+Multiline paste:
+
+```python
+`summarize this module:
+focus on state management
+and persistence behavior
+```
+
+Backslash-Enter continuation in the terminal:
+
+```python
+`draft a migration plan \
+with risks and rollback steps
+```
+
+`ipyai` also provides a line and cell magic named `%ipyai` / `%%ipyai`.
+
+## `%ipyai` commands
+
+```python
+%ipyai
+%ipyai model claude-sonnet-4-6
+%ipyai think m
+%ipyai search h
+%ipyai code_theme monokai
+%ipyai reset
+```
+
+Behavior:
+
+- `%ipyai` prints the active model, think level, search level, code theme, config path, and system prompt path
+- `%ipyai model ...`, `%ipyai think ...`, `%ipyai search ...`, `%ipyai code_theme ...` change the current session only
+- `%ipyai reset` deletes AI prompt history for the current IPython session and resets the code-context baseline
+
+## Tools
+
+To expose a function from the active IPython namespace as a tool for the current conversation, reference it as `&\`name\`` in the prompt:
+
+```python
+def weather(city): return f"Sunny in {city}"
+
+`use &`weather` to answer the question about Brisbane
+```
+
+## Output Rendering
+
+Responses are streamed directly to the terminal during generation. After streaming completes:
+
+- the stored response remains the original full `lisette` output
+- the visible terminal output is re-rendered with `rich.Markdown`
+- tool call detail blocks are compacted to a short single-line form such as `🔧 f(x=1) => 2`
+
+## Configuration
+
+On first load, `ipyai` creates two files under the XDG config directory:
+
+- `~/.config/ipyai/config.json`
+- `~/.config/ipyai/sysp.txt`
+
+`config.json` currently supports:
+
+```json
+{
+  "model": "claude-sonnet-4-6",
+  "think": "l",
+  "search": "l",
+  "code_theme": "monokai"
+}
+```
+
+Notes:
+
+- `model` defaults from `IPYAI_MODEL` if that environment variable is set when the config file is first created
+- `think` and `search` must be one of `l`, `m`, or `h`
+- `code_theme` is passed to Rich for fenced and inline code styling
+
+`sysp.txt` is used as the system prompt passed to `lisette.Chat`.
+
+## Development
+
+See [DEV.md](DEV.md) for project layout, architecture, persistence details, and development workflow.

ipyai-0.0.1/README.md

@@ -0,0 +1,139 @@
+# ipyai
+
+`ipyai` is an IPython extension that turns any input starting with `` ` `` into an AI prompt.
+
+It is aimed at terminal IPython, not notebook frontends. Prompts stream through `lisette`, final output is rendered with `rich`, and prompt history is stored alongside normal IPython history in the same SQLite database.
+
+## Install
+
+```bash
+pip install ipyai
+```
+
+## Load
+
+```python
+%load_ext ipyai
+```
+
+If you change the package in a running shell:
+
+```python
+%reload_ext ipyai
+```
+
+## How To Auto-Load `ipyai`
+
+`ipyai` is designed for terminal IPython. To auto-load it, add this to an `ipython_config.py` file used by terminal `ipython`:
+
+```python
+c.TerminalIPythonApp.extensions = ["ipyai"]
+```
+
+Good places for that file include:
+
+- env-local: `{sys.prefix}/etc/ipython/ipython_config.py`
+- user-local: `~/.ipython/profile_default/ipython_config.py`
+- system-wide IPython config directories
+
+In a virtualenv, the env-local path is usually:
+
+- `.venv/etc/ipython/ipython_config.py`
+
+To see which config paths your current `ipython` is searching, run:
+
+```bash
+ipython --debug -c 'exit()' 2>&1 | grep Searching
+```
+
+## Usage
+
+Only the leading backtick is special. There is no closing delimiter.
+
+Single line:
+
+```python
+`write a haiku about sqlite
+```
+
+Multiline paste:
+
+```python
+`summarize this module:
+focus on state management
+and persistence behavior
+```
+
+Backslash-Enter continuation in the terminal:
+
+```python
+`draft a migration plan \
+with risks and rollback steps
+```
+
+`ipyai` also provides a line and cell magic named `%ipyai` / `%%ipyai`.
+
+## `%ipyai` commands
+
+```python
+%ipyai
+%ipyai model claude-sonnet-4-6
+%ipyai think m
+%ipyai search h
+%ipyai code_theme monokai
+%ipyai reset
+```
+
+Behavior:
+
+- `%ipyai` prints the active model, think level, search level, code theme, config path, and system prompt path
+- `%ipyai model ...`, `%ipyai think ...`, `%ipyai search ...`, `%ipyai code_theme ...` change the current session only
+- `%ipyai reset` deletes AI prompt history for the current IPython session and resets the code-context baseline
+
+## Tools
+
+To expose a function from the active IPython namespace as a tool for the current conversation, reference it as `&\`name\`` in the prompt:
+
+```python
+def weather(city): return f"Sunny in {city}"
+
+`use &`weather` to answer the question about Brisbane
+```
+
+## Output Rendering
+
+Responses are streamed directly to the terminal during generation. After streaming completes:
+
+- the stored response remains the original full `lisette` output
+- the visible terminal output is re-rendered with `rich.Markdown`
+- tool call detail blocks are compacted to a short single-line form such as `🔧 f(x=1) => 2`
+
+## Configuration
+
+On first load, `ipyai` creates two files under the XDG config directory:
+
+- `~/.config/ipyai/config.json`
+- `~/.config/ipyai/sysp.txt`
+
+`config.json` currently supports:
+
+```json
+{
+  "model": "claude-sonnet-4-6",
+  "think": "l",
+  "search": "l",
+  "code_theme": "monokai"
+}
+```
+
+Notes:
+
+- `model` defaults from `IPYAI_MODEL` if that environment variable is set when the config file is first created
+- `think` and `search` must be one of `l`, `m`, or `h`
+- `code_theme` is passed to Rich for fenced and inline code styling
+
+`sysp.txt` is used as the system prompt passed to `lisette.Chat`.
+
+## Development
+
+See [DEV.md](DEV.md) for project layout, architecture, persistence details, and development workflow.

ipyai-0.0.1/ipyai/__init__.py

@@ -0,0 +1,3 @@
+from .core import AI_LAST_PROMPT, AI_LAST_RESPONSE, DEFAULT_MODEL, IPyAIExtension, create_extension, load_ipython_extension, unload_ipython_extension
+__version__ = "0.0.1"
+

ipyai-0.0.1/ipyai/core.py

@@ -0,0 +1,444 @@
+from __future__ import annotations
+
+import html,json,os,re,sqlite3,sys
+from dataclasses import dataclass,field
+from functools import partial
+from pathlib import Path
+from typing import Callable
+
+from fastcore.xdg import xdg_config_home
+from IPython import get_ipython
+from IPython.core.inputtransformer2 import leading_empty_lines
+from IPython.core.magic import Magics, line_cell_magic, magics_class
+from lisette.core import Chat,StreamFormatter
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.text import Text
+
+DEFAULT_MODEL = "claude-sonnet-4-6"
+DEFAULT_THINK = "l"
+DEFAULT_SEARCH = "l"
+DEFAULT_CODE_THEME = "monokai"
+DEFAULT_SYSTEM_PROMPT = """You are an AI assistant running inside IPython.
+
+The user interacts with you through `ipyai`, an IPython extension that turns input starting with a backtick into an AI prompt.
+
+You may receive:
+- a `<context>` XML block containing recent IPython code and optional outputs
+- a `<user-request>` XML block containing the user's actual request
+
+You can respond in Markdown. Your final visible output in terminal IPython will be rendered with Rich, so normal Markdown formatting, fenced code blocks, lists, and tables are appropriate when useful.
+
+When the user mentions `&`-backtick tool references such as `&`tool_name``, the corresponding callable from the active IPython namespace may be available to you as a tool. Use tools when they will materially improve correctness or completeness; otherwise answer directly.
+
+Assume you are helping an interactive Python user. Prefer concise, accurate, practical responses. When writing code, default to Python unless the user asks for something else.
+"""
+AI_MAGIC_NAME = "ipyai"
+AI_LAST_PROMPT = "_ai_last_prompt"
+AI_LAST_RESPONSE = "_ai_last_response"
+AI_EXTENSION_NS = "_ipyai"
+AI_EXTENSION_ATTR = "_ipyai_extension"
+AI_RESET_LINE_NS = "_ipyai_reset_line"
+AI_PROMPTS_TABLE = "ai_prompts"
+
+__all__ = "AI_EXTENSION_ATTR AI_EXTENSION_NS AI_LAST_PROMPT AI_LAST_RESPONSE AI_MAGIC_NAME AI_PROMPTS_TABLE AI_RESET_LINE_NS DEFAULT_MODEL " \
+          "IPyAIExtension create_extension default_config_path default_sysp_path is_backtick_prompt load_ipython_extension prompt_from_lines " \
+          "stream_to_stdout transform_backticks unload_ipython_extension".split()
+
+_prompt_template = """{context}<user-request>{prompt}</user-request>"""
+_tool_re = re.compile(r"&`(\w+)`")
+_tool_block_re = re.compile(r"<details class='tool-usage-details'>\s*<summary>(.*?)</summary>\s*```json\s*(.*?)\s*```\s*</details>", flags=re.DOTALL)
+
+
+def is_backtick_prompt(lines: list[str]) -> bool: return bool(lines) and lines[0].startswith("`")
+
+
+def _drop_continuation_backslashes(lines: list[str]) -> list[str]:
+    res = []
+    for i,line in enumerate(lines):
+        if i < len(lines)-1 and line.endswith("\\\n"): line = line[:-2] + "\n"
+        res.append(line)
+    return res
+
+
+def prompt_from_lines(lines: list[str]) -> str | None:
+    if not is_backtick_prompt(lines): return None
+    first,*rest = lines
+    return "".join(_drop_continuation_backslashes([first[1:], *rest]))
+
+
+def transform_backticks(lines: list[str], magic: str=AI_MAGIC_NAME) -> list[str]:
+    prompt = prompt_from_lines(lines)
+    if prompt is None: return lines
+    return [f"get_ipython().run_cell_magic({magic!r}, '', {prompt!r})\n"]
+
+
+def _xml_attr(o) -> str: return html.escape(str(o), quote=True)
+
+
+def _xml_text(o) -> str: return html.escape(str(o), quote=False)
+
+
+def _tag(name: str, content="", **attrs) -> str:
+    ats = "".join(f' {k}="{_xml_attr(v)}"' for k,v in attrs.items())
+    return f"<{name}{ats}>{content}</{name}>"
+
+
+def _is_ipyai_input(source: str) -> bool:
+    src = source.lstrip()
+    return src.startswith("`") or src.startswith("%ipyai") or src.startswith("%%ipyai")
+
+
+def _tool_names(text: str) -> set[str]: return set(_tool_re.findall(text or ""))
+
+
+def _tool_refs(prompt: str, hist: list[dict]) -> set[str]:
+    names = _tool_names(prompt)
+    for o in hist: names |= _tool_names(o["prompt"])
+    return names
+
+
+def _single_line(s: str) -> str: return re.sub(r"\s+", " ", s.strip())
+
+
+def _truncate_short(s: str, mx: int=100) -> str:
+    s = _single_line(s)
+    return s if len(s) <= mx else s[:mx-3] + "..."
+
+
+def compact_tool_display(text: str, result_chars: int=100) -> str:
+    def _repl(m):
+        summary,payload = m.groups()
+        try: result = json.loads(payload).get("result", "")
+        except Exception: return m.group(0)
+        return f"🔧 {_single_line(summary)} => {_truncate_short(str(result), mx=result_chars)}"
+    return _tool_block_re.sub(_repl, text)
+
+
+def _with_trailing_newline(text: str) -> str: return text if not text or text.endswith("\n") else text + "\n"
+
+
+def _display_line_count(out, shown: str) -> int:
+    if not shown: return 0
+    console = Console(file=out, force_terminal=getattr(out, "isatty", lambda: False)(), soft_wrap=True)
+    lines = console.render_lines(Text(shown), pad=False)
+    return len(lines)
+
+
+def _clear_terminal_block(out, shown: str):
+    nlines = _display_line_count(out, shown)
+    if nlines > 1: out.write(f"\x1b[{nlines-1}F")
+    out.write("\x1b[J")
+    out.flush()
+
+
+def _render_markdown(out, text: str, code_theme: str, console_cls=Console, markdown_cls=Markdown):
+    md = markdown_cls(text, code_theme=code_theme, inline_code_theme=code_theme, inline_code_lexer="python")
+    console = console_cls(file=out, force_terminal=getattr(out, "isatty", lambda: False)(), soft_wrap=True)
+    console.print(md)
+
+
+def _rewrite_terminal_output(out, shown: str, rewritten: str, code_theme: str, console_cls=Console, markdown_cls=Markdown):
+    if not getattr(out, "isatty", lambda: False)(): return
+    _clear_terminal_block(out, shown)
+    _render_markdown(out, rewritten, code_theme, console_cls=console_cls, markdown_cls=markdown_cls)
+
+
+def stream_to_stdout(stream, formatter_cls: Callable[..., StreamFormatter]=StreamFormatter, out=None, code_theme: str=DEFAULT_CODE_THEME,
+                     console_cls=Console, markdown_cls=Markdown) -> str:
+    out = sys.stdout if out is None else out
+    fmt = formatter_cls()
+    res = []
+    for chunk in fmt.format_stream(stream):
+        if not chunk: continue
+        out.write(chunk)
+        out.flush()
+        res.append(chunk)
+    text = "".join(res)
+    shown = _with_trailing_newline(text)
+    if shown != text:
+        out.write("\n")
+        out.flush()
+    rewritten = compact_tool_display(text)
+    if getattr(out, "isatty", lambda: False)(): _rewrite_terminal_output(out, shown, rewritten, code_theme, console_cls=console_cls, markdown_cls=markdown_cls)
+    return text
+
+
+def default_config_path() -> Path: return xdg_config_home()/"ipyai"/"config.json"
+
+
+def default_sysp_path() -> Path: return xdg_config_home()/"ipyai"/"sysp.txt"
+
+
+def _validate_level(name: str, value: str, default: str) -> str:
+    value = (value or default).strip().lower()
+    if value not in {"l", "m", "h"}: raise ValueError(f"{name} must be one of h/m/l, got {value!r}")
+    return value
+
+
+def _default_config():
+    return dict(model=os.environ.get("IPYAI_MODEL", DEFAULT_MODEL), think=DEFAULT_THINK, search=DEFAULT_SEARCH, code_theme=DEFAULT_CODE_THEME)
+
+
+def load_config(path=None) -> dict:
+    path = Path(path or default_config_path())
+    cfg = _default_config()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        data = json.loads(path.read_text())
+        if not isinstance(data, dict): raise ValueError(f"Invalid config format in {path}")
+        cfg.update({k:v for k,v in data.items() if k in cfg})
+    else: path.write_text(json.dumps(cfg, indent=2) + "\n")
+    cfg["model"] = str(cfg["model"]).strip() or DEFAULT_MODEL
+    cfg["think"] = _validate_level("think", cfg["think"], DEFAULT_THINK)
+    cfg["search"] = _validate_level("search", cfg["search"], DEFAULT_SEARCH)
+    cfg["code_theme"] = str(cfg["code_theme"]).strip() or DEFAULT_CODE_THEME
+    return cfg
+
+
+def load_sysp(path=None) -> str:
+    path = Path(path or default_sysp_path())
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists(): path.write_text(DEFAULT_SYSTEM_PROMPT)
+    return path.read_text()
+
+
+@magics_class
+class AIMagics(Magics):
+    def __init__(self, shell, ext):
+        super().__init__(shell)
+        self.ext = ext
+
+    @line_cell_magic("ipyai")
+    def ipyai(self, line: str="", cell: str | None=None):
+        if cell is None: return self.ext.handle_line(line)
+        return self.ext.run_prompt(cell)
+
+
+@dataclass
+class IPyAIExtension:
+    shell: object
+    model: str|None=None
+    think: str|None=None
+    search: str|None=None
+    code_theme: str|None=None
+    system_prompt: str|None=None
+    chat_cls: Callable[..., Chat]=Chat
+    formatter_cls: Callable[..., StreamFormatter]=StreamFormatter
+    magic_name: str=AI_MAGIC_NAME
+    config_path: Path|None=None
+    sysp_path: Path|None=None
+    loaded: bool=False
+    transformer: Callable = field(init=False)
+
+    def __post_init__(self):
+        self.config_path = Path(self.config_path or default_config_path())
+        self.sysp_path = Path(self.sysp_path or default_sysp_path())
+        cfg = load_config(self.config_path)
+        self.model = self.model or cfg["model"]
+        self.think = _validate_level("think", self.think if self.think is not None else cfg["think"], DEFAULT_THINK)
+        self.search = _validate_level("search", self.search if self.search is not None else cfg["search"], DEFAULT_SEARCH)
+        self.code_theme = str(self.code_theme or cfg["code_theme"]).strip() or DEFAULT_CODE_THEME
+        self.system_prompt = self.system_prompt if self.system_prompt is not None else load_sysp(self.sysp_path)
+        self.transformer = partial(transform_backticks, magic=self.magic_name)
+
+    @property
+    def history_manager(self): return getattr(self.shell, "history_manager", None)
+
+    @property
+    def session_number(self): return getattr(self.history_manager, "session_number", 0)
+
+    @property
+    def reset_line(self): return self.shell.user_ns.get(AI_RESET_LINE_NS, 0)
+
+    @property
+    def db(self):
+        hm = self.history_manager
+        return None if hm is None else hm.db
+
+    def ensure_prompt_table(self):
+        if self.db is None: return
+        with self.db:
+            self.db.execute(
+                f"""CREATE TABLE IF NOT EXISTS {AI_PROMPTS_TABLE} (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session INTEGER NOT NULL,
+                prompt TEXT NOT NULL,
+                response TEXT NOT NULL,
+                history_line INTEGER NOT NULL DEFAULT 0
+            )"""
+            )
+            cols = {o[1] for o in self.db.execute(f"PRAGMA table_info({AI_PROMPTS_TABLE})")}
+            if "history_line" not in cols:
+                self.db.execute(f"ALTER TABLE {AI_PROMPTS_TABLE} ADD COLUMN history_line INTEGER NOT NULL DEFAULT 0")
+            self.db.execute(f"CREATE INDEX IF NOT EXISTS idx_{AI_PROMPTS_TABLE}_session_id ON {AI_PROMPTS_TABLE} (session, id)")
+
+    def prompt_records(self, session: int | None=None) -> list:
+        if self.db is None: return []
+        self.ensure_prompt_table()
+        session = self.session_number if session is None else session
+        cur = self.db.execute(f"SELECT id, prompt, response, history_line FROM {AI_PROMPTS_TABLE} WHERE session=? ORDER BY id", (session,))
+        return cur.fetchall()
+
+    def prompt_rows(self, session: int | None=None) -> list: return [(p, r) for _,p,r,_ in self.prompt_records(session=session)]
+
+    def last_prompt_line(self, session: int | None=None) -> int:
+        rows = self.prompt_records(session=session)
+        return rows[-1][3] if rows else self.reset_line
+
+    def current_prompt_line(self) -> int:
+        c = getattr(self.shell, "execution_count", 1)
+        return max(c-1, 0)
+
+    def code_history(self, start: int, stop: int) -> list:
+        hm = self.history_manager
+        if hm is None or stop <= start: return []
+        return list(hm.get_range(session=0, start=start, stop=stop, raw=True, output=True))
+
+    def code_context(self, start: int, stop: int) -> str:
+        entries = self.code_history(start, stop)
+        parts = []
+        for _,line,pair in entries:
+            source,output = pair
+            if not source or _is_ipyai_input(source): continue
+            parts.append(_tag("code", _xml_text(source)))
+            if output is not None: parts.append(_tag("output", _xml_text(output)))
+        if not parts: return ""
+        return _tag("context", "".join(parts)) + "\n"
+
+    def format_prompt(self, prompt: str, start: int, stop: int) -> str:
+        ctx = self.code_context(start, stop)
+        return _prompt_template.format(context=ctx, prompt=prompt.strip())
+
+    def dialog_history(self, current_prompt_line: int) -> list:
+        hist,res = [],[]
+        prev_line = self.reset_line
+        for pid,prompt,response,history_line in self.prompt_records():
+            hist += [self.format_prompt(prompt, prev_line+1, history_line), response]
+            res.append(dict(id=pid, prompt=prompt, response=response, history_line=history_line))
+            prev_line = history_line
+        return hist,res
+
+    def resolve_tools(self, prompt: str, hist: list[dict]) -> list:
+        ns = self.shell.user_ns
+        names = _tool_refs(prompt, hist)
+        missing = [o for o in _tool_names(prompt) if o not in ns]
+        if missing: raise NameError(f"Missing tool(s) in user_ns: {', '.join(sorted(missing))}")
+        bad = [o for o in _tool_names(prompt) if o in ns and not callable(ns[o])]
+        if bad: raise TypeError(f"Non-callable tool(s): {', '.join(sorted(bad))}")
+        return [ns[o] for o in sorted(names) if o in ns and callable(ns[o])]
+
+    def save_prompt(self, prompt: str, response: str, history_line: int):
+        if self.db is None: return
+        self.ensure_prompt_table()
+        with self.db: self.db.execute(f"INSERT INTO {AI_PROMPTS_TABLE} (session, prompt, response, history_line) VALUES (?, ?, ?, ?)",
+                                      (self.session_number, prompt, response, history_line))
+
+    def reset_session_history(self) -> int:
+        if self.db is None: return 0
+        self.ensure_prompt_table()
+        with self.db: cur = self.db.execute(f"DELETE FROM {AI_PROMPTS_TABLE} WHERE session=?", (self.session_number,))
+        self.shell.user_ns.pop(AI_LAST_PROMPT, None)
+        self.shell.user_ns.pop(AI_LAST_RESPONSE, None)
+        self.shell.user_ns[AI_RESET_LINE_NS] = self.current_prompt_line()
+        return cur.rowcount or 0
+
+    def load(self):
+        if self.loaded: return self
+        self.ensure_prompt_table()
+        cts = self.shell.input_transformer_manager.cleanup_transforms
+        if self.transformer not in cts:
+            idx = 1 if cts and cts[0] is leading_empty_lines else 0
+            cts.insert(idx, self.transformer)
+        self.shell.register_magics(AIMagics(self.shell, self))
+        self.shell.user_ns[AI_EXTENSION_NS] = self
+        self.shell.user_ns.setdefault(AI_RESET_LINE_NS, 0)
+        setattr(self.shell, AI_EXTENSION_ATTR, self)
+        self.loaded = True
+        return self
+
+    def unload(self):
+        if not self.loaded: return self
+        cts = self.shell.input_transformer_manager.cleanup_transforms
+        if self.transformer in cts: cts.remove(self.transformer)
+        if self.shell.user_ns.get(AI_EXTENSION_NS) is self: self.shell.user_ns.pop(AI_EXTENSION_NS, None)
+        if getattr(self.shell, AI_EXTENSION_ATTR, None) is self: delattr(self.shell, AI_EXTENSION_ATTR)
+        self.loaded = False
+        return self
+
+    def handle_line(self, line: str):
+        line = line.strip()
+        if not line:
+            print(f"Model: {self.model}")
+            print(f"Think: {self.think}")
+            print(f"Search: {self.search}")
+            print(f"Code theme: {self.code_theme}")
+            print(f"Config: {self.config_path}")
+            print(f"System prompt: {self.sysp_path}")
+            return None
+        if line == "model":
+            print(f"Model: {self.model}")
+            return None
+        if line == "think":
+            print(f"Think: {self.think}")
+            return None
+        if line == "search":
+            print(f"Search: {self.search}")
+            return None
+        if line == "code_theme":
+            print(f"Code theme: {self.code_theme}")
+            return None
+        if line == "reset":
+            n = self.reset_session_history()
+            print(f"Deleted {n} AI prompts from session {self.session_number}.")
+            return None
+        if line.startswith("model "):
+            self.model = line.split(None, 1)[1].strip()
+            print(f"Model: {self.model}")
+            return None
+        if line.startswith("think "):
+            self.think = _validate_level("think", line.split(None, 1)[1], self.think)
+            print(f"Think: {self.think}")
+            return None
+        if line.startswith("search "):
+            self.search = _validate_level("search", line.split(None, 1)[1], self.search)
+            print(f"Search: {self.search}")
+            return None
+        if line.startswith("code_theme "):
+            self.code_theme = line.split(None, 1)[1].strip() or DEFAULT_CODE_THEME
+            print(f"Code theme: {self.code_theme}")
+            return None
+        return self.run_prompt(line)
+
+    def run_prompt(self, prompt: str):
+        prompt = (prompt or "").rstrip("\n")
+        if not prompt.strip(): return None
+        prompt_line = self.current_prompt_line()
+        hist,recs = self.dialog_history(prompt_line)
+        tools = self.resolve_tools(prompt, recs)
+        full_prompt = self.format_prompt(prompt, self.last_prompt_line()+1, prompt_line)
+        self.shell.user_ns[AI_LAST_PROMPT] = prompt
+        chat = self.chat_cls(model=self.model, sp=self.system_prompt, ns=self.shell.user_ns, hist=hist, tools=tools or None)
+        text = stream_to_stdout(chat(full_prompt, stream=True, think=self.think, search=self.search),
+                                formatter_cls=self.formatter_cls, code_theme=self.code_theme)
+        self.shell.user_ns[AI_LAST_RESPONSE] = text
+        self.save_prompt(prompt, text, prompt_line)
+        return None
+
+
+def create_extension(shell=None, **kwargs):
+    shell = shell or get_ipython()
+    if shell is None: raise RuntimeError("No active IPython shell found")
+    ext = getattr(shell, AI_EXTENSION_ATTR, None)
+    if ext is None: ext = IPyAIExtension(shell=shell, **kwargs)
+    if not ext.loaded: ext.load()
+    return ext
+
+
+def load_ipython_extension(ipython): return create_extension(ipython)
+
+
+def unload_ipython_extension(ipython):
+    ext = getattr(ipython, AI_EXTENSION_ATTR, None)
+    if ext is None: return
+    ext.unload()

ipyai-0.0.1/ipyai.egg-info/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: ipyai
+Version: 0.0.1
+Summary: Minimal IPython backtick-to-AI extension
+Author-email: Jeremy Howard <info@answer.ai>
+License: Apache-2.0
+Project-URL: Source, https://github.com/answerdotai/fastship
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastcore
+Requires-Dist: ipython>=9
+Requires-Dist: lisette>=0.0.47
+Requires-Dist: rich
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: fastship>=0.0.6; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+
+# ipyai
+
+`ipyai` is an IPython extension that turns any input starting with `` ` `` into an AI prompt.
+
+It is aimed at terminal IPython, not notebook frontends. Prompts stream through `lisette`, final output is rendered with `rich`, and prompt history is stored alongside normal IPython history in the same SQLite database.
+
+## Install
+
+```bash
+pip install ipyai
+```
+
+## Load
+
+```python
+%load_ext ipyai
+```
+
+If you change the package in a running shell:
+
+```python
+%reload_ext ipyai
+```
+
+## How To Auto-Load `ipyai`
+
+`ipyai` is designed for terminal IPython. To auto-load it, add this to an `ipython_config.py` file used by terminal `ipython`:
+
+```python
+c.TerminalIPythonApp.extensions = ["ipyai"]
+```
+
+Good places for that file include:
+
+- env-local: `{sys.prefix}/etc/ipython/ipython_config.py`
+- user-local: `~/.ipython/profile_default/ipython_config.py`
+- system-wide IPython config directories
+
+In a virtualenv, the env-local path is usually:
+
+- `.venv/etc/ipython/ipython_config.py`
+
+To see which config paths your current `ipython` is searching, run:
+
+```bash
+ipython --debug -c 'exit()' 2>&1 | grep Searching
+```
+
+## Usage
+
+Only the leading backtick is special. There is no closing delimiter.
+
+Single line:
+
+```python
+`write a haiku about sqlite
+```
+
+Multiline paste:
+
+```python
+`summarize this module:
+focus on state management
+and persistence behavior
+```
+
+Backslash-Enter continuation in the terminal:
+
+```python
+`draft a migration plan \
+with risks and rollback steps
+```
+
+`ipyai` also provides a line and cell magic named `%ipyai` / `%%ipyai`.
+
+## `%ipyai` commands
+
+```python
+%ipyai
+%ipyai model claude-sonnet-4-6
+%ipyai think m
+%ipyai search h
+%ipyai code_theme monokai
+%ipyai reset
+```
+
+Behavior:
+
+- `%ipyai` prints the active model, think level, search level, code theme, config path, and system prompt path
+- `%ipyai model ...`, `%ipyai think ...`, `%ipyai search ...`, `%ipyai code_theme ...` change the current session only
+- `%ipyai reset` deletes AI prompt history for the current IPython session and resets the code-context baseline
+
+## Tools
+
+To expose a function from the active IPython namespace as a tool for the current conversation, reference it as `&\`name\`` in the prompt:
+
+```python
+def weather(city): return f"Sunny in {city}"
+
+`use &`weather` to answer the question about Brisbane
+```
+
+## Output Rendering
+
+Responses are streamed directly to the terminal during generation. After streaming completes:
+
+- the stored response remains the original full `lisette` output
+- the visible terminal output is re-rendered with `rich.Markdown`
+- tool call detail blocks are compacted to a short single-line form such as `🔧 f(x=1) => 2`
+
+## Configuration
+
+On first load, `ipyai` creates two files under the XDG config directory:
+
+- `~/.config/ipyai/config.json`
+- `~/.config/ipyai/sysp.txt`
+
+`config.json` currently supports:
+
+```json
+{
+  "model": "claude-sonnet-4-6",
+  "think": "l",
+  "search": "l",
+  "code_theme": "monokai"
+}
+```
+
+Notes:
+
+- `model` defaults from `IPYAI_MODEL` if that environment variable is set when the config file is first created
+- `think` and `search` must be one of `l`, `m`, or `h`
+- `code_theme` is passed to Rich for fenced and inline code styling
+
+`sysp.txt` is used as the system prompt passed to `lisette.Chat`.
+
+## Development
+
+See [DEV.md](DEV.md) for project layout, architecture, persistence details, and development workflow.

ipyai-0.0.1/ipyai.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+ipyai/__init__.py
+ipyai/core.py
+ipyai.egg-info/PKG-INFO
+ipyai.egg-info/SOURCES.txt
+ipyai.egg-info/dependency_links.txt
+ipyai.egg-info/requires.txt
+ipyai.egg-info/top_level.txt
+tests/test_core.py

ipyai-0.0.1/ipyai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ipyai-0.0.1/ipyai.egg-info/requires.txt

@@ -0,0 +1,10 @@
+fastcore
+ipython>=9
+lisette>=0.0.47
+rich
+
+[dev]
+build>=1.0.0
+fastship>=0.0.6
+pytest
+twine>=5.0.0

ipyai-0.0.1/ipyai.egg-info/top_level.txt

@@ -0,0 +1 @@
+ipyai

ipyai-0.0.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ipyai"
+dynamic = ["version"]
+description = "Minimal IPython backtick-to-AI extension"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+authors = [{name = "Jeremy Howard", email = "info@answer.ai"}]
+dependencies = ["fastcore", "ipython>=9", "lisette>=0.0.47", "rich"]
+
+[project.urls]
+Source = "https://github.com/answerdotai/fastship"
+
+[project.optional-dependencies]
+dev = ["build>=1.0.0", "fastship>=0.0.6", "pytest", "twine>=5.0.0"]
+
+[tool.setuptools.dynamic]
+version = {attr = "ipyai.__version__"}
+
+[tool.setuptools.packages.find]
+include = ["ipyai", "ipyai.*"]
+
+[tool.fastship]
+branch = "main"
+changelog_file = "CHANGELOG.md"
+

ipyai-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ipyai-0.0.1/tests/test_core.py

@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+import io,json,sqlite3
+
+import pytest
+from IPython.core.inputtransformer2 import TransformerManager
+
+from ipyai.core import AI_EXTENSION_NS, AI_LAST_PROMPT, AI_LAST_RESPONSE, AI_RESET_LINE_NS
+from ipyai.core import DEFAULT_CODE_THEME, DEFAULT_SEARCH, DEFAULT_SYSTEM_PROMPT, DEFAULT_THINK
+from ipyai.core import IPyAIExtension, _clear_terminal_block, _display_line_count, compact_tool_display
+from ipyai.core import prompt_from_lines, stream_to_stdout, transform_backticks
+
+
+class DummyFormatter:
+    def format_stream(self, stream): yield from stream
+
+
+class TTYStringIO(io.StringIO):
+    def isatty(self): return True
+
+
+class DummyMarkdown:
+    def __init__(self, text, **kwargs): self.text,self.kwargs = text,kwargs
+
+
+class DummyConsole:
+    instances = []
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        self.printed = []
+        type(self).instances.append(self)
+
+    def print(self, obj):
+        self.printed.append(obj)
+        self.kwargs["file"].write(f"RICH:{obj.text}")
+
+
+class DummyChat:
+    instances = []
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        self.calls = []
+        type(self).instances.append(self)
+
+    def __call__(self, prompt, stream=False, **kwargs):
+        self.calls.append((prompt, stream, kwargs))
+        return ["first ", "second"]
+
+
+class DummyHistory:
+    def __init__(self, session_number=1):
+        self.session_number = session_number
+        self.db = sqlite3.connect(":memory:")
+        self.entries = {}
+
+    def add(self, line, source, output=None): self.entries[line] = (source, output)
+
+    def get_range(self, session=0, start=1, stop=None, raw=True, output=False):
+        if stop is None: stop = max(self.entries, default=0) + 1
+        for i in range(start, stop):
+            if i not in self.entries: continue
+            src,out = self.entries[i]
+            yield (0, i, (src, out) if output else src)
+
+
+class DummyInputTransformerManager:
+    def __init__(self): self.cleanup_transforms = []
+
+
+class DummyShell:
+    def __init__(self):
+        self.input_transformer_manager = DummyInputTransformerManager()
+        self.user_ns = {}
+        self.magics = []
+        self.history_manager = DummyHistory()
+        self.execution_count = 2
+
+    def register_magics(self, magics): self.magics.append(magics)
+
+
+@pytest.fixture(autouse=True)
+def _xdg_config_home(monkeypatch, tmp_path): monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+
+
+def test_prompt_from_lines_drops_continuation_backslashes():
+    lines = ["`plan this work\\\n", "with two lines\n"]
+    assert prompt_from_lines(lines) == "plan this work\nwith two lines\n"
+
+
+def test_transform_backticks_executes_ai_magic_call():
+    seen = {}
+
+    class DummyIPython:
+        def run_cell_magic(self, magic, line, cell): seen.update(magic=magic, line=line, cell=cell)
+
+    code = "".join(transform_backticks(["`hello\n", "world\n"]))
+    exec(code, {"get_ipython": lambda: DummyIPython()})
+    assert seen == dict(magic="ipyai", line="", cell="hello\nworld\n")
+
+
+def test_stream_to_stdout_collects_streamed_text():
+    out = io.StringIO()
+    text = stream_to_stdout(["a", "b"], formatter_cls=DummyFormatter, out=out)
+    assert text == "ab"
+    assert out.getvalue() == "ab\n"
+
+
+def test_compact_tool_display_uses_summary_and_truncates_result():
+    text = """Before
+
+<details class='tool-usage-details'>
+<summary>f(x=1)</summary>
+
+```json
+{"id":"toolu_1","call":{"function":"f","arguments":{"x":"1"}},"result":"%s"}
+```
+
+</details>
+
+After""" % ("a" * 120)
+
+    res = compact_tool_display(text)
+    assert "🔧 f(x=1) => " in res
+    assert "a" * 120 not in res
+    assert "..." in res
+    assert "\n\n\n🔧" not in res
+    assert "🔧 f(x=1)" in res
+
+
+def test_stream_to_stdout_rewrites_tty_display_but_returns_full_text():
+    tool_block = """<details class='tool-usage-details'>
+<summary>f(x=1)</summary>
+
+```json
+{"id":"toolu_1","call":{"function":"f","arguments":{"x":"1"}},"result":"2"}
+```
+
+</details>"""
+    out = TTYStringIO()
+    text = stream_to_stdout([tool_block], formatter_cls=DummyFormatter, out=out)
+    assert text == tool_block
+    assert "\x1b[" in out.getvalue()
+    assert "🔧 f(x=1) => 2" in out.getvalue()
+    assert "\n\n\n🔧" not in out.getvalue()
+
+
+def test_stream_to_stdout_renders_final_markdown_with_rich_options():
+    DummyConsole.instances = []
+    out = TTYStringIO()
+    text = stream_to_stdout(["`x`"], formatter_cls=DummyFormatter, out=out, code_theme="github-dark", console_cls=DummyConsole, markdown_cls=DummyMarkdown)
+
+    assert text == "`x`"
+    md = DummyConsole.instances[-1].printed[-1]
+    assert md.text == "`x`"
+    assert md.kwargs == dict(code_theme="github-dark", inline_code_theme="github-dark", inline_code_lexer="python")
+
+
+def test_display_line_count_accounts_for_wrapped_terminal_lines():
+    out = TTYStringIO()
+    assert _display_line_count(out, "x" * 200) > 1
+
+
+def test_clear_terminal_block_does_not_move_above_input_line():
+    out = TTYStringIO()
+    _clear_terminal_block(out, "abc\n")
+    assert out.getvalue().startswith("\x1b[1F\x1b[J")
+
+
+def test_extension_load_is_idempotent_and_tracks_last_response():
+    DummyChat.instances = []
+    shell = DummyShell()
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter).load()
+    ext.load()
+    assert shell.input_transformer_manager.cleanup_transforms == [ext.transformer]
+    assert len(shell.magics) == 1
+    assert shell.user_ns[AI_EXTENSION_NS] is ext
+
+    ext.run_prompt("tell me something")
+
+    assert DummyChat.instances[-1].kwargs["hist"] == []
+    assert DummyChat.instances[-1].calls == [(
+        "<user-request>tell me something</user-request>",
+        True,
+        dict(search=DEFAULT_SEARCH, think=DEFAULT_THINK),
+    )]
+    assert DummyChat.instances[-1].kwargs["model"] == ext.model
+    assert DummyChat.instances[-1].kwargs["sp"] == DEFAULT_SYSTEM_PROMPT
+    assert shell.user_ns[AI_LAST_PROMPT] == "tell me something"
+    assert shell.user_ns[AI_LAST_RESPONSE] == "first second"
+    assert ext.prompt_rows() == [("tell me something", "first second")]
+
+
+def test_config_file_is_created_and_loaded(tmp_path):
+    cfg_path = tmp_path/"ipyai"/"config.json"
+    sysp_path = tmp_path/"ipyai"/"sysp.txt"
+    shell = DummyShell()
+
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter, config_path=cfg_path, sysp_path=sysp_path)
+
+    assert cfg_path.exists()
+    assert sysp_path.exists()
+    data = json.loads(cfg_path.read_text())
+    assert data["model"] == ext.model
+    assert data["think"] == DEFAULT_THINK
+    assert data["search"] == DEFAULT_SEARCH
+    assert data["code_theme"] == DEFAULT_CODE_THEME
+    assert sysp_path.read_text() == DEFAULT_SYSTEM_PROMPT
+    assert ext.system_prompt == DEFAULT_SYSTEM_PROMPT
+
+
+def test_existing_sysp_file_is_loaded(tmp_path):
+    cfg_path = tmp_path/"ipyai"/"config.json"
+    sysp_path = tmp_path/"ipyai"/"sysp.txt"
+    sysp_path.parent.mkdir(parents=True, exist_ok=True)
+    sysp_path.write_text("custom sysp")
+    shell = DummyShell()
+
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter, config_path=cfg_path, sysp_path=sysp_path)
+
+    assert ext.system_prompt == "custom sysp"
+
+
+def test_config_values_drive_model_think_and_search(tmp_path):
+    cfg_path = tmp_path/"ipyai"/"config.json"
+    cfg_path.parent.mkdir(parents=True, exist_ok=True)
+    cfg_path.write_text(json.dumps(dict(model="cfg-model", think="m", search="h")))
+    DummyChat.instances = []
+    shell = DummyShell()
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter, config_path=cfg_path).load()
+
+    ext.run_prompt("tell me something")
+
+    assert ext.model == "cfg-model"
+    assert ext.think == "m"
+    assert ext.search == "h"
+    assert DummyChat.instances[-1].calls == [(
+        "<user-request>tell me something</user-request>",
+        True,
+        dict(search="h", think="m"),
+    )]
+
+
+def test_handle_line_can_report_and_set_model(capsys):
+    shell = DummyShell()
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter, model="old-model", think="m", search="h", code_theme="github-dark")
+
+    ext.handle_line("")
+    assert capsys.readouterr().out == (
+        f"Model: old-model\nThink: m\nSearch: h\nCode theme: github-dark\nConfig: {ext.config_path}\nSystem prompt: {ext.sysp_path}\n"
+    )
+
+    ext.handle_line("model new-model")
+    assert ext.model == "new-model"
+    assert capsys.readouterr().out == "Model: new-model\n"
+
+    ext.handle_line("think l")
+    assert ext.think == "l"
+    assert capsys.readouterr().out == "Think: l\n"
+
+    ext.handle_line("search m")
+    assert ext.search == "m"
+    assert capsys.readouterr().out == "Search: m\n"
+
+    ext.handle_line("code_theme ansi_dark")
+    assert ext.code_theme == "ansi_dark"
+    assert capsys.readouterr().out == "Code theme: ansi_dark\n"
+
+
+def test_second_prompt_uses_sqlite_prompt_history():
+    DummyChat.instances = []
+    shell = DummyShell()
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter).load()
+
+    ext.run_prompt("first prompt")
+    shell.execution_count = 3
+    ext.run_prompt("second prompt")
+
+    assert DummyChat.instances[1].kwargs["hist"] == [
+        "<user-request>first prompt</user-request>",
+        "first second",
+    ]
+    assert ext.prompt_rows() == [
+        ("first prompt", "first second"),
+        ("second prompt", "first second"),
+    ]
+
+
+def test_reset_only_deletes_current_session_history(capsys):
+    shell = DummyShell()
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter).load()
+
+    ext.save_prompt("s1 prompt", "s1 response", 1)
+    shell.history_manager.session_number = 2
+    shell.execution_count = 8
+    ext.save_prompt("s2 prompt", "s2 response", 7)
+
+    ext.handle_line("reset")
+
+    assert capsys.readouterr().out == "Deleted 1 AI prompts from session 2.\n"
+    assert ext.prompt_rows(session=1) == [("s1 prompt", "s1 response")]
+    assert ext.prompt_rows(session=2) == []
+    assert shell.user_ns[AI_RESET_LINE_NS] == 7
+
+
+def test_tools_resolve_from_ampersand_backticks():
+    shell = DummyShell()
+    shell.user_ns["demo"] = lambda: "ok"
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter).load()
+
+    tools = ext.resolve_tools("please call &`demo` now", [])
+    assert len(tools) == 1
+    assert tools[0]() == "ok"
+
+
+def test_context_xml_includes_code_and_outputs_since_last_prompt():
+    shell = DummyShell()
+    shell.history_manager.add(1, "a = 1")
+    shell.history_manager.add(2, "a", "1")
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter).load()
+
+    ctx = ext.code_context(1, 3)
+    assert "<context><code>a = 1</code><code>a</code><output>1</output></context>\n" == ctx
+
+
+def test_history_context_uses_lines_since_last_prompt_only():
+    shell = DummyShell()
+    shell.history_manager.add(1, "before = 1")
+    shell.history_manager.add(2, "`first prompt")
+    shell.history_manager.add(3, "after = 2")
+    shell.execution_count = 3
+    ext = IPyAIExtension(shell=shell, chat_cls=DummyChat, formatter_cls=DummyFormatter).load()
+    ext.save_prompt("first prompt", "first response", 2)
+
+    prompt = ext.format_prompt("second prompt", ext.last_prompt_line()+1, 4)
+    assert "before = 1" not in prompt
+    assert "after = 2" in prompt
+
+
+def test_cleanup_transform_prevents_help_syntax_interference():
+    tm = TransformerManager()
+    tm.cleanup_transforms.insert(1, transform_backticks)
+
+    code = tm.transform_cell("`I am testing my new AI prompt system.\\\nTell me do you see a newline in this prompt?")
+    assert code == "get_ipython().run_cell_magic('ipyai', '', 'I am testing my new AI prompt system.\\nTell me do you see a newline in this prompt?\\n')\n"
+    assert tm.check_complete("`I am testing my new AI prompt system.\\") == ("incomplete", 0)
+    assert tm.check_complete("`I am testing my new AI prompt system.\\\nTell me do you see a newline in this prompt?") == ("complete", None)