pal-code 0.1.1__tar.gz → 0.1.2__tar.gz

{pal_code-0.1.1 → pal_code-0.1.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Nandini Singh
+Copyright (c) 2026 Vrushal More
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{pal_code-0.1.1 → pal_code-0.1.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pal-code
-Version: 0.1.1
+Version: 0.1.2
 Summary: Pal: build and plan with AI in your terminal (pal cli) or browser (pal web), on a layer that cuts tokens and latency.
-Author: Nandini Singh
+Author: Vrushal More
 License: MIT
 Keywords: ai,coding-assistant,cli,llm,ollama,tokens,code-graph
 Classifier: Development Status :: 4 - Beta

{pal_code-0.1.1 → pal_code-0.1.2}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pal-code"
-version = "0.1.1"
+version = "0.1.2"
 description = "Pal: build and plan with AI in your terminal (pal cli) or browser (pal web), on a layer that cuts tokens and latency."
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
-authors = [{ name = "Nandini Singh" }]
+authors = [{ name = "Vrushal More" }]
 keywords = ["ai", "coding-assistant", "cli", "llm", "ollama", "tokens", "code-graph"]
 classifiers = [
   "Development Status :: 4 - Beta",

{pal_code-0.1.1 → pal_code-0.1.2}/src/pal/__init__.py

@@ -13,7 +13,7 @@ def _version() -> str:
             return version(name)
         except PackageNotFoundError:
             continue
-    return "0.1.1"           # a source checkout that is not installed
+    return "0.1.2"           # a source checkout that is not installed
 
 
 __version__ = _version()

{pal_code-0.1.1 → pal_code-0.1.2}/src/pal/cli.py

@@ -212,7 +212,7 @@ def load_dotenv(path: str | os.PathLike | None = None, env=None) -> list[str]:
     return loaded
 
 
-def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph=None, documents: list | None = None) -> int:
+def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph=None, documents: list | None = None, project_dir=None) -> int:
     from pal.chat import ChatService
     from pal.web import create_app
 
@@ -221,7 +221,7 @@ def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph
     service = ChatService(settings, graph=graph) if graph is not None else ChatService(settings)
     if documents:
         service.preload_docs = list(documents)
-    app = create_app(service)
+    app = create_app(service, studio={"project_dir": project_dir}) if project_dir else create_app(service)
     if s.host not in _LOOPBACK:
         print(f"WARNING: listening on {s.host}. Pal has no login: anyone who can reach this port can use "
               "your API keys' quota and read stored memory. Put it behind an authenticating reverse proxy.",
@@ -239,6 +239,9 @@ def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph
               "the app still works and sends everything to the API model.", file=sys.stderr)
     else:
         print(f"Local model: {status['detail']}")
+    import threading as _t
+    from pal.context_window import context_window
+    _t.Thread(target=lambda: context_window("openai", "gpt-4o"), daemon=True).start()   # loads LiteLLM's model list now, not on the first page load
     if open_browser:
         import threading
         import webbrowser

pal_code-0.1.2/src/pal/context_window.py

@@ -0,0 +1,42 @@
+"""How many tokens a model can take in one request (its context window), for the "tokens left" counters in the terminal and the web page.
+
+API models: the size LiteLLM knows for the model, else a safe default. Local models: the context Pal gives Ollama (num_ctx), which is what
+really limits them here, whatever the model could do on paper."""
+from __future__ import annotations
+
+from functools import lru_cache
+
+LOCAL_CONTEXT = 8192            # Pal runs local models with num_ctx 8192 (pal.terminal.backend.make_core)
+API_DEFAULT = 128_000           # a model LiteLLM does not know: most current API models take at least this
+LOCAL_PROVIDERS = ("local", "ollama", "lmstudio", "vllm", "llamacpp", "llama.cpp", "huggingface")
+
+
+@lru_cache(maxsize=256)
+def context_window(provider: str, model: str) -> int:
+    provider = (provider or "").lower()
+    if provider in LOCAL_PROVIDERS:
+        return LOCAL_CONTEXT
+    if not model:
+        return API_DEFAULT
+    try:
+        import litellm
+        for name in (f"{provider}/{model}" if provider else model, model, model.split("/")[-1]):
+            try:
+                info = litellm.get_model_info(name)
+            except Exception:  # noqa: BLE001  (not in LiteLLM's table under this name)
+                continue
+            size = info.get("max_input_tokens") or info.get("max_tokens")
+            if size:
+                return int(size)
+    except Exception:  # noqa: BLE001  (LiteLLM missing or broken: the default)
+        pass
+    return API_DEFAULT
+
+
+def tokens_left(window: int, last_prompt: int) -> int:
+    """What is left of the window after the last request's input (the next one is usually at least as big)."""
+    return max(0, window - max(0, last_prompt))
+
+
+def short(n: int) -> str:
+    return f"{n / 1000:.1f}k".replace(".0k", "k") if n >= 10_000 else f"{n:,}"

{pal_code-0.1.1 → pal_code-0.1.2}/src/pal/studio/routes.py

@@ -49,7 +49,7 @@ def clean_references(raw) -> list[dict]:
 
 
 def register_studio(app, service, *, planner_core: Callable | None = None, core_factory: Callable | None = None, discover_fn: Callable | None = None,
-                    hot_turns: int | None = None) -> RunStore:
+                    hot_turns: int | None = None, project_dir: Path | None = None) -> RunStore:
     """Add the Studio page and endpoints to the app. The three callables are for tests: the planner's model, the builder's model, local-model discovery."""
     cfg = service.settings
     home = Path(cfg.storage_dir).expanduser() if cfg.storage_dir else data_dir()
@@ -71,7 +71,7 @@ def register_studio(app, service, *, planner_core: Callable | None = None, core_
             raise UserInputError("no local model is chosen: start Ollama and pull a model, or switch to an API model")
         return local_core(m["model"], num_ctx())
 
-    runs = RunStore(home / "studio", core_factory or default_core_factory, max_runs=cfg.studio.max_runs, hot_turns=hot_turns)
+    runs = RunStore(home / "studio", core_factory or default_core_factory, max_runs=cfg.studio.max_runs, hot_turns=hot_turns, project_dir=project_dir)
     app.extensions["studio_runs"] = runs
 
     def local() -> dict:

{pal_code-0.1.1 → pal_code-0.1.2}/src/pal/studio/runs.py

@@ -95,9 +95,22 @@ class Run:
         return self.arms[name]
 
 
+def build_target(project: Path, folder: str) -> Path:
+    """Where a build is written in the folder Pal was started in: the folder itself when it is empty, else a new subfolder named after the
+    product (with -2, -3 ... when that name is taken), so nothing that is already there is overwritten."""
+    project = Path(project)
+    if not any(p for p in project.iterdir() if not p.name.startswith(".")):
+        return project
+    target, n = project / folder, 2
+    while target.exists() and (not target.is_dir() or any(target.iterdir())):
+        target, n = project / f"{folder}-{n}", n + 1
+    return target
+
+
 class RunStore:
-    def __init__(self, root: Path, core_factory: Callable, max_runs: int = 6, hot_turns: int | None = None):
+    def __init__(self, root: Path, core_factory: Callable, max_runs: int = 6, hot_turns: int | None = None, project_dir: Path | None = None):
         self.root, self.core_factory, self.max_runs, self.hot_turns = Path(root), core_factory, max_runs, hot_turns
+        self.project_dir = Path(project_dir).resolve() if project_dir else None      # pal web's folder: the build is written there
         self._runs: dict[str, Run] = {}
         self._editors: dict[tuple[str, str], EditorSession] = {}
         self._lock = threading.Lock()
@@ -140,11 +153,17 @@ class RunStore:
                     break
                 policy = Policy(dict(plan["permissions"]))
                 save = plan["permissions"].get("write_project")
-                state = ArmState(arm, label, (self.root / run.id / arm / plan["product"]["folder"]) if save else None)
+                where = None
+                if save:
+                    where = (build_target(self.project_dir, plan["product"]["folder"]) if self.project_dir and arm != "baseline"
+                             else self.root / run.id / arm / plan["product"]["folder"])  # the plain client's comparison copy stays in Pal's folder
+                state = ArmState(arm, label, where)
                 run.arms[arm] = state
                 if state.workspace:
                     state.workspace.mkdir(parents=True, exist_ok=True)
                 run.emit("arm_start", f"{label}: starting" if twice else "Starting", arm=arm)
+                if state.workspace and self.project_dir and arm != "baseline":
+                    run.emit("saved_to", f"Files are written to {state.workspace}", arm=arm, path=str(state.workspace))
                 client: PlainClient | PalClient
                 if arm == "baseline":
                     client = PlainClient(core, SYSTEM)

{pal_code-0.1.1 → pal_code-0.1.2}/src/pal/terminal/bench.py

@@ -67,6 +67,7 @@ class BenchResult:
     plain: Arm
     pal: Arm
     when: float = field(default_factory=time.time)
+    pal_files: dict = field(default_factory=dict, repr=False)     # what Pal's way wrote: {path: bytes}, offered to keep in your folder
 
     @property
     def saved(self) -> int:
@@ -78,6 +79,7 @@ class BenchResult:
 
     def to_dict(self) -> dict:
         d = asdict(self)
+        d.pop("pal_files", None)
         d.update(saved=self.saved, saved_pct=self.saved_pct, plain_total=self.plain.total, pal_total=self.pal.total)
         return d
 
@@ -161,7 +163,12 @@ def run_bench(folder: Path, task: str, core_factory: Callable[[], Any], model: s
             pal_arm = _run_arm("pal", pal, steps, progress)
         finally:
             client.close()
-    result = BenchResult(task, model, str(folder), plain_arm, pal_arm)
+        kept = {}
+        for rel in sorted({f for st in pal_arm.steps for f in st.files}):
+            f = pal_dir / rel
+            if f.is_file():
+                kept[rel] = f.read_bytes()
+    result = BenchResult(task, model, str(folder), plain_arm, pal_arm, pal_files=kept)
     save(result, home)
     return result
 

{pal_code-0.1.1 → pal_code-0.1.2}/src/pal/terminal/cli.py

@@ -70,7 +70,7 @@ def build_parser() -> argparse.ArgumentParser:
     a.add_argument("--build", action="store_true", help="use the Build agent: it may propose file changes (asks before writing)")
     b = sub.add_parser("bench", help="run one task as a plain chat and through Pal, on the same model, and compare the real tokens")
     _common(b, suppress=True)
-    b.add_argument("task", nargs="+", help="what to build, as you would type it")
+    b.add_argument("task", nargs="*", help="what to build, as you would type it (leave it out to open the bench screen and type tasks there)")
     b.add_argument("--then", action="append", default=None, metavar="MESSAGE", help="a follow-up message (repeat for more; default: two standard ones)")
     b.add_argument("--no-follow-ups", action="store_true", help="only the task itself")
     b.add_argument("--json", action="store_true", help="print the result as JSON")
@@ -79,13 +79,17 @@ def build_parser() -> argparse.ArgumentParser:
     return p
 
 
-def bench(args) -> int:
-    """pal bench: the same task, plain chat versus Pal, on the same model."""
+def bench(args, core_factory: Callable | None = None) -> int:
+    """pal bench: the same task, plain chat versus Pal, on the same model. Without a task it opens the usual Pal screen (\"pal bench\"), and every
+    task typed there is run both ways, with the results as a table and bar charts."""
     import json as _json
 
-    from rich.table import Table
-
-    from pal.terminal.bench import run_bench
+    if not args.task:
+        if not (sys.stdin.isatty() and sys.stdout.isatty()):
+            print("pal bench: give a task, e.g.  pal bench \"make a todo app\"", file=sys.stderr)
+            return 2
+        args.bench_screen = True
+        return interactive(args, core_factory)
     console = ui.make_console()
     host = args.host or backend.DEFAULT_HOST
     prefs = backend.load_prefs()
@@ -103,17 +107,36 @@ def bench(args) -> int:
     except PalError as e:
         print(f"pal bench: {e}", file=sys.stderr)
         return 2
-    follow = [] if args.no_follow_ups else args.then
-    task = " ".join(args.task)
-    status = console.status(Text("Starting\u2026", style=theme.MUTED), spinner="dots", spinner_style=theme.RED)
-    with status:
-        result = run_bench(Path(args.dir), task, lambda: backend.make_core(provider, model, host), model, follow,
-                           progress=lambda m: status.update(Text(m, style=theme.MUTED)))
+    result = bench_run(console, Path(args.dir), " ".join(args.task), provider, model, host, [] if args.no_follow_ups else args.then)
     if args.json:
         print(_json.dumps(result.to_dict(), indent=1))
         return 0
-    ui.say(console, Text.assemble(("pal bench  ", f"bold {theme.WHITE}"), (f"{model} ({provider})  \u00B7  {ui.short_path(Path(args.dir).resolve())}", theme.MUTED)))
-    ui.say(console, Text(f"Task: {task}", style=theme.INK))
+    show_bench(console, result, provider, model, Path(args.dir))
+    return 0
+
+
+def bench_run(console, folder: Path, task: str, provider: str, model: str, host: str, follow=None, core_factory: Callable | None = None):
+    from pal.terminal.bench import run_bench
+    status = console.status(Text("Starting\u2026", style=theme.MUTED), spinner="dots", spinner_style=theme.RED)
+    with status:
+        return run_bench(folder, task, lambda: (core_factory or backend.make_core)(provider, model, host), model, follow,
+                         progress=lambda m: status.update(Text(m, style=theme.MUTED)))
+
+
+def bars(console, title: str, rows: list[tuple[str, float, str]], width: int = 46) -> None:
+    """A horizontal bar chart in the terminal: (label, value, shown value). Plain chat in grey, Pal in red."""
+    top = max((v for _, v, _ in rows), default=0) or 1
+    ui.say(console, Text(title, style=f"bold {theme.WHITE}"))
+    for label, value, shown in rows:
+        n = max(1, round(width * value / top)) if value > 0 else 0
+        colour = theme.RED if label.lower().startswith("pal") else theme.MUTED
+        ui.say(console, Text.assemble(("  " + f"{label:<11}", theme.INK), ("\u2588" * n, colour), (" " * (width - n + 2), ""), (shown, f"bold {theme.WHITE}")))
+
+
+def show_bench(console, result, provider: str, model: str, folder: Path) -> None:
+    from rich.table import Table
+    ui.say(console, Text.assemble(("pal bench  ", f"bold {theme.WHITE}"), (f"{model} ({provider})  \u00B7  {ui.short_path(Path(folder).resolve())}", theme.MUTED)))
+    ui.say(console, Text(f"Task: {result.task}", style=theme.INK))
     console.print()
     grid = Table(box=None, padding=(0, 2), header_style=f"bold {theme.WHITE}")
     for col, just in (("step", "left"), ("agent", "left"), ("plain chat", "right"), ("Pal", "right"), ("saved", "right")):
@@ -129,6 +152,13 @@ def bench(args) -> int:
                  Text(f"{result.saved:,} ({result.saved_pct:g}%)", style=f"bold {theme.RED_HI}"))
     ui.say(console, grid)
     console.print()
+    bars(console, "Tokens", [("plain chat", result.plain.total, f"{result.plain.total:,}"), ("Pal", result.pal.total, f"{result.pal.total:,}")])
+    console.print()
+    bars(console, "Time", [("plain chat", result.plain.seconds, f"{result.plain.seconds:g}s"), ("Pal", result.pal.seconds, f"{result.pal.seconds:g}s")])
+    console.print()
+    verdict = (f"Pal used {result.saved:,} fewer tokens ({result.saved_pct:g}% less)." if result.saved > 0 else
+               f"Pal used {-result.saved:,} more tokens on this task (it pays off with bigger projects, documents and longer conversations).")
+    ui.say(console, Text(verdict, style=f"bold {theme.RED_HI}"))
     for arm in (result.plain, result.pal):
         files = sorted({f for s in arm.steps for f in s.files})
         ui.say(console, Text(f"{arm.name:<6} {arm.seconds:g}s \u00B7 {arm.calls} model call{'s' if arm.calls != 1 else ''} \u00B7 wrote: {', '.join(files) or 'no files'}"
@@ -137,7 +167,28 @@ def bench(args) -> int:
     ui.say(console, Text("Token counts are the model's own." if not est else f"{est} call(s) had no token count from the model, so those are estimates (characters / 4).", style=theme.MUTED))
     ui.say(console, Text("Pal's local helper jobs are off in the bench, so its saving here comes from the project map, graph, documents and history alone.", style=theme.MUTED))
     console.print()
-    return 0
+
+
+def keep_bench_files(console, result, folder: Path) -> list[str]:
+    """Both ways build in temporary copies; offer to write Pal's version into the folder (asking first, never overwriting without saying so)."""
+    if not result.pal_files:
+        return []
+    folder = Path(folder).resolve()
+    clash = [p for p in result.pal_files if (folder / p).exists()]
+    question = f"Save Pal's version ({len(result.pal_files)} file{'s' if len(result.pal_files) != 1 else ''}) in {ui.short_path(folder)}?" + (
+        f" It replaces {len(clash)} existing file{'s' if len(clash) != 1 else ''}." if clash else "")
+    if not ui.confirm(console, question):
+        return []
+    written = []
+    for rel, data in result.pal_files.items():
+        target = (folder / rel).resolve()
+        if folder not in target.parents:
+            continue                                           # never outside the folder
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(data)
+        written.append(rel)
+    ui.say(console, Text(f"Saved: {', '.join(written)}", style=theme.INK))
+    return written
 
 
 def setup(args) -> int:
@@ -165,7 +216,7 @@ def first_run() -> None:
         console.print()
 
 
-def prepare_folder(args, console, core_factory: Callable | None = None) -> tuple[str, Project | None]:
+def prepare_folder(args, console, core_factory: Callable | None = None, choose: bool = True) -> tuple[str, Project | None]:
     """Before a session: get local models ready (install and start Ollama, download the models for this GPU, asking first), then set up the
     folder: documents to markdown, the project map, the code graph (in the background). Returns (a line about the local model, the Project)."""
     from pal.terminal.project import Project
@@ -173,7 +224,7 @@ def prepare_folder(args, console, core_factory: Callable | None = None) -> tuple
     local = ""
     if core_factory is None:
         tty = sys.stdin.isatty() and sys.stdout.isatty()
-        local = ensure_local(console, backend.hardware(), args.host or backend.DEFAULT_HOST, interactive=tty).detail
+        local = ensure_local(console, backend.hardware(), args.host or backend.DEFAULT_HOST, interactive=tty, choose=choose).detail
     folder = Path(getattr(args, "dir", ".") or ".")
     if os.environ.get("PAL_SKIP_PROJECT"):
         return local, None
@@ -217,7 +268,7 @@ def web(args) -> int:
         from pal.terminal.project import ProjectGraph
         graph = ProjectGraph(project.root / "graph", settings.knowledge_graph)
     return _serve(settings, open_browser=not args.no_open, page="studio" if args.page == "studio" else "", graph=graph,
-                  documents=project.documents() if project is not None else None)
+                  documents=project.documents() if project is not None else None, project_dir=Path(getattr(args, "dir", ".") or ".").resolve())
 
 
 def _utf8() -> None:
@@ -488,6 +539,14 @@ def handle(line: str, args, session: PalSession, console, core_factory, box: dic
         return session, True
     if cmd == "/help":
         ui.show_help(console)
+    elif cmd == "/agent":
+        from pal.terminal.setup import choose_agent
+        mode = rest if rest in MODES else choose_agent(console, current=session.mode)
+        if mode:
+            session.mode = mode
+            backend.save_prefs(mode=mode)
+            ui.say(console, Text(f"Agent: {mode.capitalize()} ({AGENT_ABOUT[mode]})", style=theme.MUTED))
+        console.print()
     elif cmd == "/mode":
         if rest in MODES:
             session.mode = rest
@@ -707,13 +766,37 @@ def voice_flow(console) -> str:
     return heard.text
 
 
+def choosing(args, core_factory: Callable | None = None) -> bool:
+    """pal cli asks for its models at every start (nothing preselected), unless they were given on the command line or this is not a terminal."""
+    return (core_factory is None and not args.provider and not args.model and sys.stdin.isatty() and sys.stdout.isatty()
+            and not os.environ.get("PAL_SKIP_SETUP") and not api_only(backend.hardware()))
+
+
+def ensure_ready_line(args) -> str:
+    """The local-model line again, after the models were chosen (and maybe downloaded)."""
+    from pal.terminal.setup import ensure_local
+    return ensure_local(ui.make_console(), backend.hardware(), args.host or backend.DEFAULT_HOST, interactive=False, choose=False).detail
+
+
 def interactive(args, core_factory: Callable | None = None) -> int:
     console = ui.make_console()
-    local, project = prepare_folder(args, console, core_factory)
+    ask = choosing(args, core_factory)
+    local, project = prepare_folder(args, console, core_factory, choose=not ask)
+    if ask:
+        from pal.terminal.setup import choose_models
+        console.print()
+        if not choose_models(console, backend.hardware(), args.host or backend.DEFAULT_HOST):
+            console.print(Text("\nNo model chosen. Run  pal cli  again to choose one.\n", style=theme.MUTED))
+            return 1
+        if not args.mode:
+            from pal.terminal.setup import choose_agent
+            args.mode = choose_agent(console) or None
+        local = ensure_ready_line(args)
     session = start(args, core_factory, project)
     if session is None:
         return 1
     session.local_status = local
+    session.brand = "bench" if getattr(args, "bench_screen", False) else "cli"
     if project is not None:
         ui.show_project(console, session)
         console.print()
@@ -753,6 +836,14 @@ def interactive(args, core_factory: Callable | None = None) -> int:
                     session, go = handle(text, args, session, console, core_factory, box)
                     if not go:
                         break
+                elif text and getattr(args, "bench_screen", False):     # pal bench: the task both ways, then the comparison
+                    host = args.host or backend.DEFAULT_HOST
+                    try:
+                        result = bench_run(console, session.cwd, text, session.provider, session.model, host, core_factory=core_factory)
+                        show_bench(console, result, session.provider, session.model, session.cwd)
+                        keep_bench_files(console, result, session.cwd)
+                    except PalError as e:
+                        ui.say(console, Text(f"The bench stopped: {e}", style=theme.RED_HI))
                 elif text:
                     flow_cli.run_turn(box["wf"], text, console)
             except KeyboardInterrupt:                     # Esc or Ctrl+C at an awkward moment: back to the box, never out of Pal
@@ -813,7 +904,7 @@ def main(argv: Sequence[str] | None = None, core_factory: Callable | None = None
     if args.cmd == "setup":
         return setup(args)
     if args.cmd == "bench":
-        return bench(args)
+        return bench(args, core_factory)
     if args.cmd == "ask":
         return ask_once(args, core_factory)
     if not (sys.stdin.isatty() and sys.stdout.isatty()) and core_factory is None:

pal_code-0.1.2/src/pal/terminal/logo.py

@@ -0,0 +1,140 @@
+"""The Pal logo (two people hugging, white and red with a black outline) as pixels for the terminal.
+
+Drawn from the logo image at 24 x 26 pixels with half blocks, two pixel rows per text line, so it shows in any terminal with colour and needs no
+image support. W white, R red, K the black outline, . see-through (the terminal's own background).
+"""
+from __future__ import annotations
+
+from pal.terminal import theme
+
+GRID = [
+    '......KKKK.....K........',
+    '.....KWWWWWK.KRRRK......',
+    '....KWWWWWWWKRRRRRK.....',
+    '....KWWWWWWWKRRRRRRK....',
+    '....KWWWWWWWWKRRRRRR....',
+    '....KWWWWWWWWKRRRRRR....',
+    '....KWWWWWWWWKRRRRRR....',
+    '....KWWWWWWWWWRRRRRR....',
+    '....KWWWWWWWWKRRRRRK....',
+    '...KRKWWWWWWWKRRRRKKK...',
+    '..KRRKKWWWWWWKRRRKWWK...',
+    '..KRRRKKWWWWKRRRRKWWK...',
+    '...KRRRRKKKKRRRRRKKKK...',
+    '..KKKRRRRRRRRRRRRRRRRK..',
+    '..WWWKRRRRRRRRKKWKRRRR..',
+    '.KWWWWKRRRRRRKWWWKRRRRK.',
+    '.KWWWWWKKRRRKWWWWKRRRRR.',
+    'KWWWWWWWWKKKWWWWKRRRRRRK',
+    'KWWWWWWWWWWWWWWWKRRRRRRK',
+    'KWWWWWWWWWWWWWWKRRRRRRRK',
+    'KWWWWWWWWWWWWWKRRRRRRRRK',
+    'KWWWWWWWWWWWWKRRRRRRRRRK',
+    'KWWWWWWWWWKKRRRRRRRRRRRK',
+    'KWWWWWWWWKRRRRRRRRRRRRRK',
+    'KWWWWWWWWKRRRRRRRRRRRRRK',
+    'KKKKKKKKKKKKKKKKKKKKKKKK',
+]
+COLOURS = {"W": theme.WHITE, "R": theme.RED, "K": "#000000"}
+
+
+def logo_lines(grid: list[str] | None = None) -> list[list[tuple[str, str]]]:
+    """Lines of (characters, style). The style is 'fg bg' in hex, or '' for nothing drawn: rich and prompt_toolkit both read it after a small change."""
+    g = grid or GRID
+    out: list[list[tuple[str, str]]] = []
+    for y in range(0, len(g), 2):
+        top, bottom = g[y], g[y + 1] if y + 1 < len(g) else "." * len(g[y])
+        line: list[tuple[str, str]] = []
+        for t, b in zip(top, bottom):
+            ct, cb = COLOURS.get(t), COLOURS.get(b)
+            if ct is None and cb is None:
+                line.append((" ", ""))
+            elif ct is None:
+                line.append(("▄", f"{cb}|"))
+            elif cb is None or ct == cb:
+                line.append(("▀" if cb is None else "█", f"{ct}|"))
+            else:
+                line.append(("▀", f"{ct}|{cb}"))
+        out.append(line)
+    return out
+
+
+def rich_style(style: str) -> str:
+    fg, _, bg = style.partition("|")
+    return (fg + (f" on {bg}" if bg else "")) if fg else ""
+
+
+def ptk_style(style: str) -> str:
+    fg, _, bg = style.partition("|")
+    return (f"fg:{fg}" + (f" bg:{bg}" if bg else "")) if fg else ""
+
+
+# The start screen's logo: drawn from the logo image as solid pixels (half blocks, two pixel rows per text line), at two sizes.
+LOGO = ['.....KKKK...........', '....KWWWWK.KRRR.....', '....WWWWWWKRRRRR....', '...KWWWWWWWKRRRRK...', '...KWWWWWWWKRRRRK...',
+        '...KWWWWWWWKRRRRK...', '....WWWWWWWKRRRRK...', '...KKWWWWWWKRRRRK...', '..KRKWWWWWWKRRRKW...', '..KRRKWWWWKRRRKWWK..',
+        '..KRRRKKKKRRRRKKK...', '..KKRRRRRRRRRKRRRK..', '.KWWKRRRRRRRKWKRRRK.', '.WWWWWKRRRRKWWKRRRR.', '.WWWWWWKRKKWWWKRRRRK',
+        'KWWWWWWWWWWWWKRRRRRK', 'KWWWWWWWWWWWKRRRRRRK', 'KWWWWWWWWWWKRRRRRRRK', 'KWWWWWWWWWKRRRRRRRRK', 'KWWWWWWWKRRRRRRRRRRK',
+        'KWWWWWWWKRRRRRRRRRRK']
+LOGO_SMALL = ['....KK..K.....', '...WWWWKRRR...', '...WWWWKRRRK..', '..KWWWWWRRRR..', '..KWWWWWRRRR..', '..KWWWWWRRRK..', '..RKWWWKRRKW..',
+              '..RRKWKRRRKK..', '.KKRRRRRRKRRK.', '.WWWRRRRWWRRR.', '.WWWWKRWWWRRRR', 'WWWWWWWWWKRRRR', 'WWWWWWWWKRRRRR', 'WWWWWWWKRRRRRR',
+              'WWWWWWRRRRRRRR', 'KWWWWKRRRRRRRK']
+
+# The wordmark "pal code" in pixel letters. Rows 0-1 ascenders, 2-6 the letters, 7-8 the tail of the p.
+FONT = {
+    "p": [".....", ".....", "####.", "#...#", "#...#", "#...#", "####.", "#....", "#....", "....."],
+    "a": [".....", ".....", ".###.", "....#", ".####", "#...#", ".####", ".....", ".....", "....."],
+    "l": ["##.", ".#.", ".#.", ".#.", ".#.", ".#.", ".##", "...", "...", "..."],
+    "c": [".....", ".....", ".####", "#....", "#....", "#....", ".####", ".....", ".....", "....."],
+    "o": [".....", ".....", ".###.", "#...#", "#...#", "#...#", ".###.", ".....", ".....", "....."],
+    "d": ["....#", "....#", ".####", "#...#", "#...#", "#...#", ".####", ".....", ".....", "....."],
+    "e": [".....", ".....", ".###.", "#...#", "#####", "#....", ".####", ".....", ".....", "....."],
+    "i": ["#", ".", "#", "#", "#", "#", "#", ".", ".", "."],
+    "w": [".......", ".......", "#.....#", "#.....#", "#..#..#", "#.#.#.#", ".#...#.", ".......", ".......", "......."],
+    "b": ["#....", "#....", "####.", "#...#", "#...#", "#...#", "####.", ".....", ".....", "....."],
+    "n": [".....", ".....", "####.", "#...#", "#...#", "#...#", "#...#", ".....", ".....", "....."],
+    "h": ["#....", "#....", "####.", "#...#", "#...#", "#...#", "#...#", ".....", ".....", "....."],
+}
+WORDS = {"cli": "pal code", "web": "pal code", "bench": "pal code"}    # the wordmark everywhere: "pal" in white, "code" in red
+
+
+def word_for(kind: str = "cli") -> list[str]:
+    text = WORDS.get(kind, WORDS["cli"])
+    return word_grid(text, "WWW " + "R" * (len(text) - 4))
+
+
+def word_grid(text: str = "pal code", colours: str = "WWW RRRR") -> list[str]:
+    rows = [""] * 10
+    for ch, col in zip(text, colours):
+        if ch == " ":
+            rows = [r + "..." for r in rows]
+            continue
+        rows = [r + FONT[ch][y].replace("#", col) + "." for y, r in enumerate(rows)]
+    width = max(len(r.rstrip(".")) for r in rows)
+    return [r[:width] for r in rows]
+
+
+def _see_through(grid: list[str]) -> list[str]:
+    """The black outline is left to the terminal's own background, so it matches any dark theme."""
+    return [r.replace("K", ".") for r in grid]
+
+
+def banner(size: str = "full", kind: str = "cli") -> list[list[tuple[str, str]]]:
+    """The start screen's mark as lines of (characters, 'fg|bg') runs: the logo with the wordmark beside it ('full' or 'small'), or the
+    wordmark alone ('word')."""
+    word = logo_lines(word_for(kind))
+    if size == "word":
+        return word
+    art = logo_lines(_see_through(LOGO if size == "full" else LOGO_SMALL))
+    gap, top = 4, (len(art) - len(word)) // 2
+    blank_art = [(" " * len(art[0]), "")]
+    out = []
+    for i in range(max(len(art), len(word) + top)):
+        left = art[i] if i < len(art) else blank_art
+        right = word[i - top] if 0 <= i - top < len(word) else []
+        line = list(left) + [(" " * gap, "")] + list(right)
+        width = sum(len(c) for c, _ in line)
+        out.append(line + [(" " * (len(art[0]) + gap + len(word[0]) - width), "")])     # every line the same width, so centring keeps the shape
+    return out
+
+
+BANNER_ROWS = {size: len(banner(size)) for size in ("full", "small", "word")}

{pal_code-0.1.1 → pal_code-0.1.2}/src/pal/terminal/session.py

@@ -169,6 +169,7 @@ class PalSession:
         self.history_tokens = 0                      # what a plain chat would carry along: every earlier message and reply
         self.history_paste = 0                       # the part of that history that is @files pasted into earlier messages
         self.turns = 0
+        self.last_prompt = 0                         # the input tokens of the last request: how full the model's context was
         self.pal_tokens = self.helper_tokens = self.plain_tokens = 0
         self.cost_usd = 0.0                          # what the model calls cost so far, when the provider's price is known
         self.seconds = 0.0
@@ -194,6 +195,17 @@ class PalSession:
         own = self.role_models.get(mode or self.mode)
         return own if own else (self.provider, self.model)
 
+    def tokens_left(self) -> tuple[int, int]:
+        """(tokens left in the active agent's context window, the window). Shown under the input box and in the status line."""
+        from pal.context_window import context_window, tokens_left
+        provider, model = self.model_for()
+        window = context_window(provider, model)
+        return tokens_left(window, self.last_prompt), window
+
+    def budget_left(self) -> int | None:
+        """What is left of the session's token cap (/budget), or None without one."""
+        return max(0, self.budget - self.pal_tokens) if self.budget else None
+
     def client_add_documents(self) -> None:
         """After /project rebuild: index the folder's documents and map again in this conversation."""
         add = getattr(self.client, "add_documents", None)
@@ -345,6 +357,7 @@ class PalSession:
         self.records.append(Record(text, reply.prompt_tokens + reply.completion_tokens, reply.helper_tokens, plain_prompt + reply.completion_tokens, saved_by,
                                    reply.seconds, getattr(reply, "route", "api")))
         self.last_reply = reply.text.strip()
+        self.last_prompt = reply.prompt_tokens or self.last_prompt
         turn = Turn(text=reply.text.strip(), warnings=warnings, prompt_tokens=reply.prompt_tokens, completion_tokens=reply.completion_tokens,
                     helper_tokens=reply.helper_tokens, plain_estimate=plain_prompt + reply.completion_tokens, seconds=reply.seconds or round(time.perf_counter() - t0, 1), saved_by=saved_by)
         if self.mode == "ask":                           # the Ask agent may ask the person to choose, instead of guessing