@huseynsnmz/pi-suite 0.0.0-stage → 0.1.0

package/packages/board/src/ui/waiting.ts

@@ -0,0 +1,30 @@
+/**
+ * Tells the board when a session is waiting on you. A permission prompt or any other dialog takes
+ * the keyboard from the prompt while a run is under way, whichever extension opened it.
+ */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { watchFocus } from "./focus.ts";
+
+const CHECK_MS = 500;
+
+export function watchWaiting(ctx: ExtensionContext, changed: (waiting: boolean) => void): () => void {
+	const focus = watchFocus(ctx, "agent-board-waiting");
+	let waiting = false;
+	const timer = setInterval(() => {
+		try {
+			const now = focus.known() && !ctx.isIdle() && focus.promptText() === undefined;
+			if (now === waiting) return;
+			waiting = now;
+			// If the run has ended too, its own end has already said so, and this would undo that.
+			if (now || !ctx.isIdle()) changed(now);
+		} catch {
+			// The session was replaced before this could be stopped. An error here would end Pi.
+			clearInterval(timer);
+		}
+	}, CHECK_MS);
+	timer.unref?.();
+	return () => {
+		clearInterval(timer);
+		focus.stop();
+	};
+}

package/packages/frame/CHANGELOG.md

@@ -0,0 +1,113 @@
+# Changelog
+
+## 0.6.0
+
+### Added
+
+- With a virtual model such as `router/auto`, the frame names the model that answered, such as `Auto → Haiku`.
+
+## 0.5.0
+
+### Added
+
+- A checklist the agent keeps while it works, in a frame above the editor, using a new `todo` tool. One call finishes a step and starts the next, and it survives `/reload`, resuming and moving around the session tree.
+- After compaction, the agent gets its unfinished list back.
+- `/todos` shows the list, and `/todos clear` empties it.
+
+## 0.4.1
+
+### Changed
+
+- Long sessions draw faster. Each response's timing line was built again on every redraw, which took over half the drawing time when typing or scrolling.
+
+## 0.4.0
+
+### Added
+
+- `Ctrl+R` searches what you've typed, here and in this folder's other recent sessions. It takes this key from Pi's Rename; `/name` still renames.
+- A `/command` or `!command` at the start of the prompt is colored.
+
+## 0.3.7
+
+### Added
+
+- A line under each response with when the call started, to the millisecond, the wait for the first token, server latency, thinking time, total time and speed. It updates while the response is written, names any stall of 2 seconds or more, and leaves stalls out of the speed.
+- Finished tool boxes show when they started and how long they took, to the millisecond.
+- A **Timings** setting in the Frame tab turns both off.
+
+## 0.3.6
+
+### Changed
+
+- The start card shows `/sandbox-disable` or `/sandbox-enable` instead of a key, and Option+S no longer turns `ß` into the sandbox's key.
+
+## 0.3.5
+
+### Changed
+
+- Option+S turns the sandbox on and off on a Mac even when the terminal types `ß`.
+- The extensions on the start card show their versions, like `pi-subagents@0.84.0`.
+- Updated `diff` to 9.0.0.
+
+## 0.3.4
+
+### Changed
+
+- Settings open with `Ctrl+S`, because `pi-sandbox` needs `Alt+S`. `Cmd+S` still works where the terminal can send it.
+- The start card no longer lists effort. `/effort` is unchanged.
+
+### Added
+
+- With `pi-sandbox` installed, the start card shows its on/off key, and the bottom line shows `sandbox: on` or `sandbox: off` after the mode.
+
+## 0.3.3
+
+### Changed
+
+- The bottom line starts with the mode, then a divider and the other statuses, then the session's numbers.
+
+## 0.3.2
+
+### Changed
+
+- The context, skills, prompts and extensions Pi loaded are rows in the start card, with `+N` for what doesn't fit. `Ctrl+O` still shows them in full, and problems still get their own frame.
+
+## 0.3.1
+
+### Added
+
+- `Cmd+S` and `Cmd+O` on a Mac, in a terminal with the kitty keyboard protocol, and the start card says so.
+
+## 0.3.0
+
+### Added
+
+- With a GitLab remote, the start card shows a failed pipeline and merge requests waiting on you, through `glab`.
+- `Ctrl+C` while something runs stops it and says `Aborted`. With nothing running, it clears the editor and says to press it again within 2 seconds to exit.
+- The red `yolo` frame for the new pi-modes mode.
+
+### Changed
+
+- What Pi loaded at startup (context, skills, prompts, extensions) is drawn in frames.
+- On a Mac, key hints say `option+` instead of `alt+`, or `cmd+` where it works: `Cmd+S` and `Cmd+O` in a terminal with the kitty keyboard protocol.
+- A status with no color of its own, like `perm-judge:`, is drawn dim like the rest of the footer.
+- When the start card's bottom edge is short of room, the key hints go before the count of what waits on you.
+
+## 0.2.0
+
+### Added
+
+- `/effort` picks the effort, and `/effort high` sets it directly.
+- With pi-modes, the editor frame's color follows the mode.
+
+### Changed
+
+- The effort shows as a divider and its level, without the meter.
+
+### Fixed
+
+- With pi-modes, the start card no longer says `shift+tab` changes the effort. It says `shift+tab mode`, and names `/effort` or your other effort key.
+
+## 0.1.0
+
+First release, forked from `@adeildo/pi-look` 6.0.0 and renamed to `pi-frame`: the package, settings keys, session entries and start card.

package/packages/frame/CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# Contributing
+
+Issues are welcome. Pull requests are turned off, because this fork follows how its maintainer works and every line needs to be written and reviewed by them.
+
+If you have a fix, open an issue that describes the problem and how to reproduce it. For a problem that also affects `pi-look`, consider [reporting it there](https://github.com/felipeadeildo/pi-harness/issues) too.
+
+For security problems, follow [SECURITY.md](SECURITY.md) instead.

package/packages/frame/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 adeildo
+Copyright (c) 2026 Hüseyin Sönmez
+
+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.

package/packages/frame/README.md

@@ -0,0 +1,105 @@
+# pi-frame
+
+Part of [pi-suite](../../README.md). Turn it off with `/suite off frame`.
+
+A redrawn screen for [Pi](https://pi.dev): a start card, an editor framed with the branch and the model, a box around every tool call, and a footer with what the session costs.
+
+It started as a fork of [`@adeildo/pi-look`](https://github.com/felipeadeildo/pi-harness/tree/main/packages/look) 6.0.0 by [adeildo](https://adeildo.dev), so the design and most of the code are theirs, under the MIT license. I keep this fork so I can shape it around how I work. If you want the original with the rest of pi-harness, use that instead.
+
+## Quick start
+
+Requires Pi 1.5 or newer.
+
+1. Remove `pi-look` if you have it, because the two draw the same screen:
+
+   ```bash
+   pi remove npm:@adeildo/pi-look
+   ```
+
+2. Install it:
+
+   ```bash
+   pi install npm:@huseynsnmz/pi-suite@0.1.0
+   ```
+
+3. Restart Pi. The start card says `π-frame`.
+
+Your `pi-look` settings don't carry over. Press `Ctrl+S` and open the **Frame** tab to set them again.
+
+On a Mac, `Alt` means the Option key, which needs Left Option set to `Esc+` in iTerm2, `"terminal": { "option_as_meta": true }` in Zed, or "Use Option as Meta" in Terminal.app. Otherwise Option types a character such as `ß`. In a terminal that uses the kitty keyboard protocol, such as Ghostty or kitty, `Cmd+S` and `Cmd+O` work too, and the start card says so.
+
+## What you see
+
+- **Start card:** the folder, branch and model, then only what changed or waits on you since your last session in that folder: conflicts, a branch behind its remote, a failed CI run, a pull or merge request waiting on you. On a quiet day it says nothing is new. Below that, a row each for the context, skills, prompts and extensions Pi loaded, with `+N` for what doesn't fit. `Ctrl+O` shows them in full. CI and request lines use `gh` for a GitHub remote and `glab` for a GitLab one, and stay out without the tool or a network.
+- **Tool boxes:** each call shows the command, who allowed it and why, the output, when it started and how long it took.
+- **Timings:** a line under each response shows when the call started, the wait for the first token, server latency, thinking time, total time, any stall and the speed. It updates as the response is written. Turn it off under **Timings** in the Frame tab. An edit shows the diff, with only the changed words highlighted.
+- **Todo list:** for work with several steps, the agent keeps a checklist in a frame above the editor, with what it's doing now highlighted. Finished items make way first when the list is long, and `Ctrl+O` shows all of it. A finished list leaves at your next prompt. The list stays with its branch of the session, and the agent gets it back after compaction.
+- **Above the editor:** a stopwatch, the number of model calls, and how the last call went. Messages you send while the agent works wait here in a dashed frame.
+- **Editor frame:** the branch, folder, model, effort and how full the context is. With [pi-modes](https://github.com/huseynsnmz/pi-suite/tree/main/packages/modes), its color follows the mode: yellow for `auto`, the accent color for `plan`, green for `read-only`, red for `yolo`, using your theme's versions of those colors. In `normal` it stays Pi's own color.
+- **Footer:** first the `mode:` from [pi-modes](https://github.com/huseynsnmz/pi-suite/tree/main/packages/modes), then a divider and what other extensions report, then cost, tokens, cache and speeds.
+
+Some pieces, such as rooms, boards, peers and the remote page, appear only with other pi-harness packages installed.
+
+| Key | What it does |
+|---|---|
+| `Ctrl+C` | Stops a run and says `Aborted`. With nothing running, it clears the editor and says to press it again within 2 seconds to exit |
+| `Ctrl+R` | Search what you've typed, here and in this folder's other sessions. `Ctrl+R` again goes further back, `Enter` sends, `Esc` cancels, any other key keeps the match to edit. It replaces Pi's Rename on this key; `/name` still renames |
+| `Alt+O` | Scroll through the session's tool output, one call at a time |
+| `Ctrl+O` | Expand every call in the transcript |
+| `/todos` | Show the agent's todo list. `/todos clear` empties it and tells the agent |
+| `Ctrl+S` | Settings: icons, editor frame style, framed messages. With the editor frame off, use `/harness` |
+| `/effort` | Pick how hard the model thinks |
+| `/effort high` | Set it directly: `off`, `minimal`, `low`, `medium`, `high`, `xhigh` or `max`. If the model can't use that level, Pi picks the closest one and you're told |
+
+More detail is in [How it works](docs/how-it-works.md) and the [reference](docs/reference.md).
+
+## Using it with other extensions
+
+**`rpiv-todo`:** remove it if you have it, because both add a tool named `todo`.
+
+**`pi-modes`:** version 0.6.0 or newer lets the agent use its todo list in `plan` and `read-only`. It takes over `Shift+Tab`, so the start card says `shift+tab mode`. To keep a key for effort, set `app.thinking.cycle` in `~/.pi/agent/keybindings.json`, or use `/effort`.
+
+**`pi-sandbox`:** the bottom line shows `sandbox: on` or `sandbox: off` after the mode. Its longer status moves to `/sandbox`.
+
+**`pi-router`:** the frame shows which model answered, such as `Auto → Haiku`.
+
+**`pi-board`:** use `@huseynsnmz/pi-board`. The frame comes back when its board closes.
+
+**`pi-cloak`:** no changes are needed. Tool boxes, `Alt+O` and the session file all show the masked text, and the automated run covers it.
+
+**`pi-permission-system`, `pi-permission-classifier`:** no conflicts were found, and the automated run covers them together with `pi-modes`.
+
+**`pi-claude-code-ui`:** it also draws tool calls, so list it above pi-suite in `packages`. `pi install` adds packages last, so this is the order you get if you install pi-frame second. Even then, it draws a call to a tool that doesn't exist outside pi-frame's box, so escape sequences in that call's arguments still reach the terminal. In the other order, or with `pi-claude-code-ui` alone, arguments of real tools leak too. To close this, remove `pi-claude-code-ui`.
+
+## Security limits
+
+- **This isn't a sandbox.** Use a container for repositories you don't trust.
+- **It only cleans what it draws.** Pi draws assistant messages and some entries itself.
+- **`gh` and `glab` still run in their repositories,** and they call `git` for reads such as the remote list.
+- **`glab` needs a host with `gitlab` in its name.** It starts for that remote, and if a token is set in the environment (`GITLAB_TOKEN`), only for `gitlab.com` or `GITLAB_HOST`, because a repository picks its own remote.
+- **The `git status` protections cover the ways to run code that I know of.** New Git options could add others.
+- **`@adeildo/pi-kit` is still an upstream dependency,** pinned to exact version 6.0.0. Its settings stay in `~/.pi/agent/extensions/pi-harness/settings.json`.
+- **Another session's view isn't fully covered.** Opening one needs other pi-harness packages, and that view hasn't been tested.
+
+## Development
+
+```bash
+npm install --ignore-scripts
+npm run check
+npm test          # needs bun
+npm run e2e       # real Pi in a real terminal with a fake model, in a throwaway home directory
+```
+
+To test with other packages, list them in `PI_FRAME_E2E_WITH`, or in `PI_FRAME_E2E_AFTER` to load them later.
+
+## Contributing
+
+Issues are welcome, and pull requests are turned off. See [CONTRIBUTING.md](CONTRIBUTING.md) and [SECURITY.md](SECURITY.md).
+
+## Credits and license
+
+MIT. See [LICENSE](LICENSE), which keeps the original copyright notice.
+
+- [pi-look and pi-harness](https://github.com/felipeadeildo/pi-harness) by [adeildo](https://adeildo.dev)
+- The framed editor comes from [pi-open-tui](https://github.com/OldSuns/pi-open-tui), by way of pi-look.
+- The segments with priorities come from [oh-my-pi](https://github.com/can1357/oh-my-pi), by way of pi-look.

package/packages/frame/SECURITY.md

@@ -0,0 +1,16 @@
+# Security
+
+## Reporting a vulnerability
+
+Please don't open a public issue for a security problem. Use **Report a vulnerability** on the repository's Security tab, or email huseyin@snmz.org.
+
+Examples that count as security problems:
+
+- A repository that gets code to run through what pi-frame starts, such as `git status`.
+- Text from a tool, a model or a repository that reaches the terminal as a command through something pi-frame draws.
+
+Fixes go into the latest release only.
+
+## What this extension does not protect against
+
+pi-frame draws the screen and is not a sandbox. The limits are listed in the README under "Security limits". A problem that falls under one of those limits is a normal issue.

package/packages/frame/docs/how-it-works.md

@@ -0,0 +1,53 @@
+# How pi-frame works
+
+The [README](../README.md) covers what you see. This page covers the details.
+
+## The boxes
+
+Every command gets its own box, so you see it before it runs:
+
+- The top line has the tool's name.
+- Under it come the command, and who let it run and why.
+- A line separates the command from what it printed.
+- The bottom line says how it went and how long it took. A command that still runs says `running`.
+
+For an `edit` or a `write`, the box shows the diff. The line numbers sit on the left, and only the words that changed get a light background. While the model is still writing the call, the box shows what has arrived so far, with a cursor at the end.
+
+`Alt+O` opens the tool output of the session in a frame that you can scroll, one call at a time, newest first. `Ctrl+O` opens every call in the transcript at once.
+
+## The editor and the footer
+
+The editor's border starts with this session's name. It also shows the branch, the folder, the permission mode, the model with its effort after a divider, and how full the context is. The border warms up as the model thinks harder, and it takes the shell's color in bash mode.
+
+Instead of "Working", the spinner says what the model is doing: `waiting`, `thinking`, `writing`, `drafting bash` or `running bash`.
+
+Your messages sit in a frame named `you`, like the tool calls. `frame.userFrame` turns this off.
+
+The footer is about the session: the cost, the tokens sent and received, how much came from the cache, the average speeds, and how much of your plan is left, with when it resets.
+
+## Another session
+
+With the other pi-harness packages installed, you can use the `Alt+G` panel or the remote to open another session over the whole screen. You see its transcript with the same boxes as yours, and an editor box with its folder, machine and model. The top edge says `live` while the session runs and `ended` once it closes. `Alt+G` or `Esc` takes you back.
+
+## Nothing jumps around
+
+The numbers change on every frame, and the screen must not move with them.
+
+- Every number sits in a cell of fixed width, so `  17` and `2.8k` take the same room.
+- A value that nobody knows yet shows as `–`, instead of appearing later in the middle of the line.
+- The working time counts like a stopwatch: `0:59`, then `1:00`.
+- An estimate is drawn in a quieter color, so you know it is one.
+- The strip and the footer keep their line from the start, so the editor does not jump when the first answer arrives.
+
+## Details
+
+- A tool from an MCP server shows its server and tool, instead of `mcp__server__tool`.
+- A tool that brings no drawing of its own gets the same box, with its name and arguments on top.
+- Pi's own entries use the same frames: compactions and branch summaries under `π`, skills, and `!` commands.
+- The mark of a long phase moves: a clock while a call runs, an hourglass while it waits on you, and a spinner while the model writes it. The mark stops when the call ends.
+- The π on the start card rises from its feet once per launch. pi-frame sets pi's `quietStartup` to `header`, so pi's list of what it loaded stays out of the way.
+- Pi records usage without a duration, so each answer leaves a small entry with its time to the first token and its writing time. That keeps the averages right after you resume a session.
+
+## Your theme
+
+pi-frame never names a color. Every piece uses a theme token, so it follows whatever theme pi runs. The [reference](reference.md#colours) lists the token for each piece.

package/packages/frame/docs/reference.md

@@ -0,0 +1,78 @@
+# Reference
+
+Everything the [README](../README.md) leaves out: the colours, every setting and segment, and how a line fits.
+
+## Colours
+
+pi-frame never names a colour. Every piece names a **theme token**, so it follows whatever theme pi runs: `system`, `dark`, `light`, or a JSON of yours. Change the theme and every piece moves with it.
+
+| What                                          | Token                                                       |
+| --------------------------------------------- | ----------------------------------------------------------- |
+| Folder                                        | `accent`                                                    |
+| Branch                                        | `syntaxFunction`                                            |
+| Ahead, staged / behind, modified / conflicted | `success` / `warning` / `error`                             |
+| Machine, cache                                | `syntaxType`                                                |
+| Session name                                  | `mdHeading`                                                 |
+| Provider, model icon                          | `syntaxKeyword`                                             |
+| Model                                         | `text`, bold                                                |
+| Sent `↑`                                      | `mdLink`                                                    |
+| Received `↓`, speeds, done                    | `success`                                                   |
+| Time to first token, money                    | `syntaxNumber`, then `warning` past $1 and `error` past $10 |
+| Context                                       | `success`, `warning` past 70%, `error` past 90%             |
+| Effort level, the π                           | `thinkingMinimal` … `thinkingMax`, one per level            |
+| Labels, units, separators                     | `dim`                                                       |
+| Editor frame                                  | pi's effort border colour; with pi-modes, `warning` in auto, `accent` in plan, `success` in read-only |
+
+Syntax tokens are borrowed on purpose: a theme spends its hues there, so they give the line variety that stays in the theme's family. The table lives in `src/render/paint.ts` as `ROLE_TOKENS`, and a test fails if any entry is ever a colour instead of a token.
+
+## Settings
+
+They live in the file `@adeildo/pi-kit` keeps, `~/.pi/agent/extensions/pi-harness/settings.json`, under `frame.`.
+
+| Key           | Default     | Does                                                                                                                                   |
+| ------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `icons`       | `"auto"`    | `nerd`, `unicode` or `ascii`. Auto uses plain Unicode, or ASCII without UTF-8 |
+| `style`       | `"rounded"` | `rounded`, `square`, `heavy` or `line` (pi's two rules, written into)                                                                  |
+| `userFrame`   | `true`      | Your messages in a frame named `you`. Off, pi draws them its own way                                                                   |
+
+The rest is fixed. The line above the editor shows `elapsed` and `last`, with `board` on its right. The frame shows `branch` and `session` at the top left, `path` and `host` at the top right, the permission mode, `model` and `effort` at the bottom left, and `context` at the bottom right. The line below the editor shows `cost`, `tokens`, `cache`, `average` and `statuses`, with `quota` on its right. Every number has its word.
+
+### Segments
+
+What each piece of the screen shows.
+
+| Id             | Shows                                                                                                                                                                               |
+| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `path`         | The working folder, with home as `~`                                                                                                                                                |
+| `branch`       | The branch, ahead `↑` and behind `↓`, staged `+`, modified `~`, untracked `?`, conflicts `!`, stashes                                                                               |
+| `host`         | The machine, so a pasted line says where it came from                                                                                                                               |
+| `session`      | The session name, once it has one                                                                                                                                                   |
+| `board`        | The card being done (`+1` when there are more), then how many open cards are blocked (`⚑ 1`, in yellow), are to do (`⧗ 3`) and are done (`✓ 2`, in green), from the session's board |
+| `version`      | The pi version                                                                                                                                                                      |
+| `clock`        | The time                                                                                                                                                                            |
+| `model`        | `provider/model`, with the account in parentheses when one is in use                                                                                                                |
+| `provider`     | The provider on its own                                                                                                                                                             |
+| `quota`        | Every window of the plan, with its percent and its reset                                                                                                                            |
+| `effort`       | A divider and the effort level. Hidden for models that do not reason                                                                                                                    |
+| `context`      | Context used, the gauge, tokens over the window                                                                                                                                     |
+| `speed`        | This answer's speeds, received `↓` and sent `↑`                                                                                                                                     |
+| `wait`         | Time to the first token                                                                                                                                                             |
+| `server`       | The last call's time from the request leaving to the response headers                                                                                                               |
+| `elapsed`      | The agent's working time, as a stopwatch, and its calls                                                                                                                             |
+| `last`         | The last finished call: its wait, its thought time and its writing speed                                                                                                            |
+| `request`      | This answer's tokens, with the cache                                                                                                                                                |
+| `costRate`     | This answer's cost per million tokens                                                                                                                                               |
+| `cost`         | The session's cost                                                                                                                                                                  |
+| `tokens`       | The session's tokens, with the cache                                                                                                                                                |
+| `cache`        | The cache hit of the last prompt                                                                                                                                                    |
+| `average`      | The session's average speeds, both ways                                                                                                                                             |
+| `statuses`     | The mode and sandbox state first, then what other packages report through `setStatus`, minus the ones placed on their own                                                                                                  |
+| `status:<key>` | One package's status, by the key it passes to `setStatus`                                                                                                                           |
+
+A `status:<key>` segment is how a package gets a place of its own. [`@adeildo/pi-ask-permission`](../ask-permission) reports its mode as `pi-ask-permission:mode`, and the mode says what happens to what you type, so by default it sits in the frame next to the model instead of in the footer with everything else. `@adeildo/pi-providers` still reports its account as `pi-providers:account`, but the `model` segment draws it in parentheses, so the statuses segment skips it.
+
+## How it fits
+
+When a line runs out of room, the least important pieces take their short form first (the folder becomes its last part, the model loses its provider, the effort meter loses its label), and then leave, one at a time. The two sides of a border compete for the same width, so an unimportant piece on the right leaves before an important one on the left. A line never goes empty: the last piece stays and is cut.
+
+The frame is the editor pi already has. Typing, history, autocomplete and every app key stay pi's; the class only changes what the lines look like and shifts mouse clicks by the width of the frame. The spinner is pi's, embedded through pi's own hook, and the working line only speaks through `setWorkingMessage`.

package/packages/frame/package.json

@@ -0,0 +1,75 @@
+{
+	"name": "@huseynsnmz/pi-frame",
+	"version": "0.5.0",
+	"description": "Pi's start screen, a framed editor, a box around every tool call and a session footer. A fork of @adeildo/pi-look.",
+	"keywords": [
+		"pi",
+		"pi-coding-agent",
+		"pi-extension",
+		"pi-package",
+		"statusline",
+		"theme",
+		"tui"
+	],
+	"license": "MIT",
+	"author": {
+		"name": "Hüseyin Sönmez",
+		"email": "huseyin@snmz.org",
+		"url": "https://github.com/huseynsnmz"
+	},
+	"contributors": [
+		{
+			"name": "adeildo",
+			"url": "https://github.com/felipeadeildo"
+		}
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/huseynsnmz/pi-suite.git",
+		"directory": "packages/frame"
+	},
+	"files": [
+		"src",
+		"docs",
+		"README.md",
+		"CHANGELOG.md",
+		"LICENSE"
+	],
+	"type": "module",
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"check": "tsc --noEmit",
+		"test": "bun test",
+		"e2e": "python3 test/e2e/run.py"
+	},
+	"dependencies": {
+		"@adeildo/pi-kit": "6.0.0",
+		"diff": "9.0.0"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "1.5.0",
+		"@earendil-works/pi-coding-agent": "1.5.0",
+		"@earendil-works/pi-tui": "1.5.0",
+		"@types/bun": "1.4.4",
+		"@types/node": "26.6.6",
+		"typebox": "1.4.3",
+		"typescript": "7.0.2"
+	},
+	"pi": {
+		"extensions": [
+			"./src/index.ts"
+		]
+	},
+	"private": true
+}

package/packages/frame/src/data/git.ts

@@ -0,0 +1,90 @@
+import { processRunner, type Runner } from "./runner.ts";
+
+export interface GitState {
+	ahead: number;
+	behind: number;
+	staged: number;
+	modified: number;
+	untracked: number;
+	conflicted: number;
+	stashed: number;
+}
+
+export function emptyGit(): GitState {
+	return { ahead: 0, behind: 0, staged: 0, modified: 0, untracked: 0, conflicted: 0, stashed: 0 };
+}
+
+export function parseStatus(output: string): GitState {
+	const state = emptyGit();
+
+	for (const line of output.split("\n")) {
+		if (line.startsWith("# branch.ab ")) {
+			const [, , ahead, behind] = line.split(" ");
+			state.ahead = Math.abs(Number(ahead ?? "0")) || 0;
+			state.behind = Math.abs(Number(behind ?? "0")) || 0;
+		} else if (line.startsWith("# stash ")) {
+			state.stashed = Number(line.slice("# stash ".length)) || 0;
+		} else if (line.startsWith("1 ") || line.startsWith("2 ")) {
+			// `XY` is the index column, then the tree column, with `.` for unchanged.
+			const index = line[2];
+			const tree = line[3];
+			if (index !== undefined && index !== ".") state.staged++;
+			if (tree !== undefined && tree !== ".") state.modified++;
+		} else if (line.startsWith("u ")) {
+			state.conflicted++;
+		} else if (line.startsWith("? ")) {
+			state.untracked++;
+		}
+	}
+
+	return state;
+}
+
+/**
+ * `git status` runs after every tool call, outside any permission check, so nothing the repository
+ * configures may run through it: an agent can write `.git/config`, and a downloaded folder can bring one.
+ */
+const SAFE_STATUS = [
+	"-c",
+	"core.fsmonitor=false",
+	"-c",
+	"core.hooksPath=/dev/null",
+	"--no-optional-locks",
+];
+
+/** Keys and scopes separated by NUL, as `git config --show-scope --name-only --list -z` prints them. */
+export function hasRepoFilter(config: string): boolean {
+	const fields = config.split("\0");
+	for (let at = 0; at + 1 < fields.length; at += 2) {
+		const scope = fields[at];
+		if (scope !== "local" && scope !== "worktree") continue;
+		if (/^filter\..+\.(?:clean|smudge|process)$/is.test(fields[at + 1] ?? "")) return true;
+	}
+	return false;
+}
+
+export async function readGit(
+	cwd: string,
+	run: Runner = processRunner(cwd, 2000),
+): Promise<GitState | undefined> {
+	try {
+		// A filter's name is free, so no option can turn them all off.
+		const config = await run("git", ["-C", cwd, "config", "--show-scope", "--name-only", "--list", "-z"]);
+		if (hasRepoFilter(config)) return undefined;
+		return parseStatus(
+			await run("git", [
+				...SAFE_STATUS,
+				"-C",
+				cwd,
+				"status",
+				"--porcelain=v2",
+				"--branch",
+				"--show-stash",
+				"--ignore-submodules=all",
+			]),
+		);
+	} catch {
+		// Not a repository, or git did not answer: the card says nothing.
+		return undefined;
+	}
+}