@asterxsk/kiln 0.2.0 → 0.3.0

package/agent.bak.20260905-190020/extensions/background-terminals/test/output.test.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { OutputBuffer } from "../src/output.ts";
+
+test("push/view roundtrip preserves text and counts bytes", () => {
+  const buf = new OutputBuffer(1024);
+  buf.push("hello ");
+  buf.push("world\n");
+  const view = buf.view();
+  assert.equal(view.text, "hello world\n");
+  assert.equal(view.totalBytes, Buffer.byteLength("hello world\n"));
+  assert.equal(view.truncatedBytes, 0);
+});
+
+test("head chunks are evicted past the cap and accounted as truncated", () => {
+  const buf = new OutputBuffer(10);
+  buf.push("aaaa"); // 4 bytes
+  buf.push("bbbb"); // 8 bytes
+  buf.push("cccc"); // 12 bytes -> evict "aaaa" (8 retained)
+  const view = buf.view();
+  assert.equal(view.text, "bbbbcccc");
+  assert.equal(view.totalBytes, 12);
+  assert.equal(view.truncatedBytes, 4);
+});
+
+test("a single chunk larger than the cap is trimmed to its tail — retention stays bounded", () => {
+  const buf = new OutputBuffer(4);
+  buf.push("0123456789");
+  // Only the newest cap-worth of bytes is retained; the head is truncated.
+  assert.equal(buf.view().text, "6789");
+  assert.equal(buf.view().totalBytes, 10);
+  assert.equal(buf.view().truncatedBytes, 6);
+  buf.push("x");
+  // "6789" + "x" exceeds the cap; the older whole chunk is evicted.
+  assert.equal(buf.view().text, "x");
+  assert.equal(buf.view().totalBytes, 11);
+  assert.equal(buf.view().truncatedBytes, 10);
+});
+
+test("an oversized chunk evicts everything retained before it", () => {
+  const buf = new OutputBuffer(8);
+  buf.push("abcd");
+  buf.push("0123456789"); // 10 bytes > cap: "abcd" evicted, chunk tail-trimmed
+  const view = buf.view();
+  assert.equal(view.text, "23456789");
+  assert.equal(view.totalBytes, 14);
+  assert.equal(view.truncatedBytes, 6);
+});
+
+test("an oversized chunk cut lands on a UTF-8 code point boundary", () => {
+  const buf = new OutputBuffer(5);
+  buf.push("ééééé"); // 10 bytes; naive cut at byte 5 would split an é
+  const view = buf.view();
+  assert.equal(view.text, "éé"); // 4 bytes retained (5 would split)
+  assert.equal(view.totalBytes, 10);
+  assert.equal(view.truncatedBytes, 6);
+  assert.ok(!view.text.includes("�"));
+});
+
+test("spill receives the complete oversized chunk before trimming", () => {
+  const spilled: string[] = [];
+  const buf = new OutputBuffer(4, (chunk) => spilled.push(chunk));
+  buf.push("0123456789");
+  assert.deepEqual(spilled, ["0123456789"]);
+  assert.equal(buf.view().text, "6789");
+});
+
+test("push reports spill backpressure while retaining the chunk", () => {
+  const buf = new OutputBuffer(1024, () => false);
+  assert.equal(buf.push("queued"), false);
+  assert.equal(buf.view().text, "queued");
+});
+
+test("byte accounting uses UTF-8 byte length, not string length", () => {
+  const buf = new OutputBuffer(1024);
+  buf.push("héllo"); // é is 2 bytes
+  assert.equal(buf.view().totalBytes, 6);
+});
+
+test("multibyte chunks are never split by eviction", () => {
+  const buf = new OutputBuffer(8);
+  buf.push("ééé"); // 6 bytes
+  buf.push("üüü"); // 6 bytes -> evicts the first chunk whole
+  const view = buf.view();
+  assert.equal(view.text, "üüü");
+  assert.equal(view.truncatedBytes, 6);
+});
+
+test("spill callback receives every chunk in order, even after eviction", () => {
+  const spilled: string[] = [];
+  const buf = new OutputBuffer(4, (chunk) => spilled.push(chunk));
+  buf.push("aaaa");
+  buf.push("bbbb");
+  buf.push("cccc");
+  assert.deepEqual(spilled, ["aaaa", "bbbb", "cccc"]);
+  assert.equal(buf.view().text, "cccc");
+});
+
+test("view text is cached between pushes and version increments per push", () => {
+  const buf = new OutputBuffer(1024);
+  buf.push("a");
+  const first = buf.view();
+  const second = buf.view();
+  assert.equal(first.text, second.text);
+  const versionBefore = buf.version;
+  buf.push("b");
+  assert.equal(buf.version, versionBefore + 1);
+  assert.equal(buf.view().text, "ab");
+});

package/agent.bak.20260905-190020/extensions/background-terminals/test/prompt.test.ts

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { OutputView, TerminalSnapshot } from "../src/domain.ts";
+import {
+  BG_START_PARAMETER_DESCRIPTIONS,
+  BG_START_TOOL_DESCRIPTION,
+  buildKillReport,
+  buildStatusResult,
+  buildTerminalResultMessage,
+} from "../src/prompt.ts";
+
+test("start descriptions identify the platform-specific shell contract", () => {
+  assert.match(BG_START_TOOL_DESCRIPTION, /sh -c on POSIX/);
+  assert.match(BG_START_TOOL_DESCRIPTION, /cmd\.exe \/d \/s \/c on Windows/);
+  assert.match(BG_START_PARAMETER_DESCRIPTIONS.command, /sh -c on POSIX/);
+  assert.match(
+    BG_START_PARAMETER_DESCRIPTIONS.command,
+    /cmd\.exe \/d \/s \/c on Windows/,
+  );
+});
+
+function view(overrides: Partial<OutputView> = {}): OutputView {
+  return { text: "", totalBytes: 0, truncatedBytes: 0, ...overrides };
+}
+
+function snap(overrides: Partial<TerminalSnapshot> = {}): TerminalSnapshot {
+  return {
+    id: "bt-1",
+    command: "sleep 999",
+    title: "test",
+    cwd: "/tmp",
+    pid: 123,
+    status: "done",
+    createdAt: Date.now() - 5_000,
+    settledAt: Date.now(),
+    exitCode: 0,
+    stdout: view(),
+    stderr: view(),
+    ...overrides,
+  };
+}
+
+test("kill report distinguishes killed / raced natural exit / already settled", () => {
+  const report = buildKillReport([
+    {
+      id: "bt-1",
+      title: "a",
+      status: "killed",
+      wasRunning: true,
+      killed: true,
+      exit: "SIGTERM",
+    },
+    {
+      id: "bt-2",
+      title: "b",
+      status: "done",
+      wasRunning: true,
+      killed: false,
+      exit: "exit 0",
+    },
+    {
+      id: "bt-3",
+      title: "c",
+      status: "failed",
+      wasRunning: false,
+      killed: false,
+      exit: "exit 1",
+    },
+  ]);
+  const lines = report.split("\n");
+  assert.equal(lines[0], 'Killed bt-1 "a" (SIGTERM).');
+  assert.match(lines[1], /exited on its own before the kill landed \(exit 0\)/);
+  assert.match(lines[2], /was already failed \(exit 1\)/);
+});
+
+test("status result marks head-truncated output with a pointer at the full log", () => {
+  const text = buildStatusResult(
+    snap({
+      stdout: view({
+        text: "tail of the log\n",
+        totalBytes: 5 * 1024 * 1024,
+        truncatedBytes: 5 * 1024 * 1024 - 16,
+        spillPath: "/tmp/bt-1.stdout.log",
+      }),
+    }),
+  );
+  assert.match(text, /stdout truncated: showing last /);
+  assert.match(text, /Full log: \/tmp\/bt-1\.stdout\.log/);
+});
+
+test("completion message reports kill vs exit and omits empty stderr", () => {
+  const killed = buildTerminalResultMessage(
+    snap({ status: "killed", exitCode: undefined, signal: "SIGTERM" }),
+  );
+  assert.match(killed, /was killed after/);
+  assert.ok(!killed.includes("stderr"), "empty stderr section omitted");
+
+  const failed = buildTerminalResultMessage(
+    snap({
+      status: "failed",
+      exitCode: 3,
+      stderr: view({ text: "boom\n", totalBytes: 5 }),
+    }),
+  );
+  assert.match(failed, /exited \(exit 3\)/);
+  assert.match(failed, /stderr:\nboom/);
+});
+
+test("completion output is a shorter tail than the detailed status view", () => {
+  const output = Array.from(
+    { length: 100 },
+    (_, index) => `line-${index + 1}`,
+  ).join("\n");
+  const terminal = snap({
+    stdout: view({ text: output, totalBytes: Buffer.byteLength(output) }),
+  });
+
+  const completion = buildTerminalResultMessage(terminal);
+  const status = buildStatusResult(terminal);
+
+  assert.ok(!completion.includes("line-1\n"));
+  assert.match(completion, /line-100/);
+  assert.match(completion, /stdout truncated/);
+  assert.match(status, /line-1\n/);
+});

package/agent.bak.20260905-190020/extensions/background-terminals/test/ps.test.ts

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  reconcileDashboardSelection,
+  type DashboardSelection,
+} from "../src/ui/ps.ts";
+import {
+  buildOutputLines,
+  createOutputLineCache,
+  sanitizeText,
+} from "../src/ui/output-view.ts";
+
+test("dashboard selection follows its terminal id and falls back by row", () => {
+  const selection: DashboardSelection = { id: "bt-7", index: 6 };
+
+  reconcileDashboardSelection(selection, [
+    { id: "bt-new" },
+    ...Array.from({ length: 8 }, (_, index) => ({ id: `bt-${index + 1}` })),
+  ]);
+  assert.deepEqual(selection, { id: "bt-7", index: 7 });
+
+  reconcileDashboardSelection(selection, [
+    ...Array.from({ length: 6 }, (_, index) => ({ id: `bt-${index + 1}` })),
+    { id: "bt-8" },
+    { id: "bt-9" },
+  ]);
+  assert.deepEqual(selection, { id: "bt-9", index: 7 });
+
+  reconcileDashboardSelection(selection, [{ id: "bt-1" }, { id: "bt-2" }]);
+  assert.deepEqual(selection, { id: "bt-2", index: 1 });
+
+  reconcileDashboardSelection(selection, []);
+  assert.deepEqual(selection, { id: undefined, index: 0 });
+});
+
+test("sanitizeText strips ANSI, tabs, and control characters", () => {
+  assert.equal(sanitizeText("\u001b[31mred\u001b[0m"), "red");
+  assert.equal(sanitizeText("\u001b[12345Cshifted"), "shifted");
+  assert.equal(sanitizeText("\u001b]0;window title\u0007output"), "output");
+  assert.equal(
+    sanitizeText("\u001b]8;;https://example.com\u001b\\link\u001b]8;;\u001b\\"),
+    "link",
+  );
+  assert.equal(sanitizeText("\u001b]0;title\u009coutput"), "output");
+  assert.equal(sanitizeText("\u009d0;title\u0007output"), "output");
+  assert.equal(sanitizeText("a\u0085b"), "ab");
+  assert.equal(sanitizeText("a\tb"), "a  b");
+  assert.equal(sanitizeText("a\u0007b\u0000c"), "abc");
+});
+
+test("output line cache reuses a version/width key and invalidates either dimension", () => {
+  const cache = createOutputLineCache();
+  const first = cache.get("first", 1, 80);
+  const sameKey = cache.get("different text is intentionally ignored", 1, 80);
+  assert.equal(sameKey, first);
+  assert.deepEqual(sameKey, ["first"]);
+
+  const newVersion = cache.get("second", 2, 80);
+  assert.notEqual(newVersion, first);
+  assert.deepEqual(newVersion, ["second"]);
+
+  const newWidth = cache.get("x".repeat(25), 2, 10);
+  assert.notEqual(newWidth, newVersion);
+  assert.ok(newWidth.length > 1);
+});
+
+test("buildOutputLines wraps long lines and keeps only the final CR segment", () => {
+  const lines = buildOutputLines("progress 1\rprogress 2\rdone\nnext", 80);
+  assert.deepEqual(lines, ["done", "next"]);
+  assert.deepEqual(buildOutputLines("progress 1\rprogress 2\r", 80), [
+    "progress 2",
+  ]);
+
+  const wrapped = buildOutputLines("x".repeat(25), 10);
+  assert.ok(wrapped.length > 1);
+  assert.equal(wrapped.join(""), "x".repeat(25));
+});
+
+test("buildOutputLines drops one trailing empty line from a trailing newline", () => {
+  assert.deepEqual(buildOutputLines("a\nb\n", 80), ["a", "b"]);
+  assert.deepEqual(buildOutputLines("a\n\n", 80), ["a", ""]);
+});

package/agent.bak.20260905-190020/extensions/background-terminals/test/result-delivery.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createDeferredResultDelivery } from "../src/result-delivery.ts";
+
+test("a result consumed by a kill/status is not delivered", () => {
+  const delivery = createDeferredResultDelivery<{
+    id: string;
+    output: string;
+  }>();
+
+  delivery.defer({ id: "bt-1", output: "done" });
+  delivery.consume(["bt-1"]);
+
+  assert.deepEqual(delivery.drain(), []);
+});
+
+test("unconsumed results are delivered once in settlement order", () => {
+  const delivery = createDeferredResultDelivery<{ id: string }>();
+  const first = { id: "bt-1" };
+  const second = { id: "bt-2" };
+
+  delivery.defer(first);
+  delivery.defer(second);
+
+  assert.deepEqual(delivery.drain(), [first, second]);
+  assert.deepEqual(delivery.drain(), []);
+});
+
+test("re-deferring the same id replaces rather than duplicates", () => {
+  const delivery = createDeferredResultDelivery<{ id: string; n: number }>();
+  delivery.defer({ id: "bt-1", n: 1 });
+  delivery.defer({ id: "bt-1", n: 2 });
+  assert.deepEqual(delivery.drain(), [{ id: "bt-1", n: 2 }]);
+});
+
+test("a drained result can be retained for retry after delivery fails", () => {
+  const delivery = createDeferredResultDelivery<{ id: string }>();
+  const result = { id: "bt-1" };
+  delivery.defer(result);
+
+  for (const drained of delivery.drain()) delivery.defer(drained);
+
+  assert.deepEqual(delivery.drain(), [result]);
+});

package/agent.bak.20260905-190020/extensions/background-terminals/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "plugins": [{ "name": "@effect/language-service" }]
+  },
+  "include": ["index.ts", "src/**/*.ts", "test/**/*.test.ts"]
+}

package/agent.bak.20260905-190020/extensions/destructive/README.md

@@ -0,0 +1,34 @@
+# destructive
+
+Asks before running destructive (deletion) commands.
+
+## What it does
+
+Intercepts `bash` / `powershell` tool calls and prompts:
+
+```text
+Do you want to allow pi to run:
+{destructive-part(s) only}
+
+1. Allow
+2. Deny
+```
+
+Only the destructive segment(s) are shown — e.g. `echo hi && rm -rf /tmp/foo`
+prompts with just `rm -rf /tmp/foo`.
+
+Anything other than **Allow** — including Deny or dismissing with Esc —
+blocks the command. In non-interactive mode (no UI) deletion commands are
+blocked by default.
+
+## Blocked commands
+
+| Group | Matches |
+|---|---|
+| File deleters | `rm`, `rmdir`, `unlink`, `shred`, `del`, `erase`, `rd`, `remove-item`, `ri` (plus `sudo`/`doas` prefixes, full paths, compound commands split on `&&`, `\|\|`, `;`, `\|`, newlines) |
+| Destructive git | `git rm`, `git branch -d/-D/--delete`, `git tag -d/--delete`, `git push -d/-D/--delete`, `git push <remote> :<branch>`, `git stash drop/clear`, `git clean` with `-f`, `git worktree remove`, `git notes remove/prune` |
+
+## Files
+
+- `index.ts` — `tool_call` hook, command matching (`isDestructiveCommand` / `getDestructiveSegments`), confirm prompt, `/destructive` toggle command
+- `README.md` — this file

package/agent.bak.20260905-190020/extensions/destructive/index.ts

@@ -0,0 +1,124 @@
+/**
+ * destructive - Asks before running destructive (deletion) commands.
+ *
+ * Intercepts `bash` / `powershell` tool calls and prompts:
+ *
+ *   Do you want to allow pi to run:
+ *   {destructive-segment(s) only}
+ *
+ *   1. Allow
+ *   2. Deny
+ *
+ * Anything else (including Deny, or dismissing with Esc) blocks the command.
+ * In non-interactive mode (no UI) deletion commands are blocked by default.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const FILE_DELETERS = new Set([
+  "rm",
+  "rmdir",
+  "unlink",
+  "shred",
+  "del",
+  "erase",
+  "rd",
+  "remove-item",
+  "ri",
+]);
+
+function isDestructiveGit(rest: string): boolean {
+  const args = rest.trim();
+  if (/^rm\b/.test(args)) return true;
+  if (/^branch\b.*(^|\s)(-[dD]|--delete)\b/.test(args)) return true;
+  if (/^tag\b.*(^|\s)(-d|--delete)\b/.test(args)) return true;
+  if (/^push\b.*(^|\s)(-[dD]|--delete)\b/.test(args)) return true;
+  if (/^push\b.*(^|\s)\S+:\S*(\s|$)/.test(args)) return true; // `git push origin :branch`
+  if (/^stash\b\s+(drop|clear)\b/.test(args)) return true;
+  if (/^clean\b/.test(args) && /(^|\s)-[a-zA-Z]*f/.test(args)) return true;
+  if (/^worktree\b\s+remove\b/.test(args)) return true;
+  if (/^notes\b.*\b(remove|prune)\b/.test(args)) return true;
+  return false;
+}
+
+function isDestructiveSegment(segment: string): boolean {
+  let s = segment.trim().replace(/^[({]+|[)}]+$/g, "").trim();
+  if (!s) return false;
+  s = s.replace(/^(sudo|doas)\s+/i, "");
+  const m = s.match(/^([^\s]+)\s*(.*)$/s);
+  if (!m) return false;
+  const bin = m[1].split("/").pop()!.toLowerCase();
+  const rest = m[2] ?? "";
+  if (FILE_DELETERS.has(bin)) return true;
+  if (bin === "git") return isDestructiveGit(rest);
+  return false;
+}
+
+export function getDestructiveSegments(command: string): string[] {
+  return command
+    .split(/&&|\|\||;|\||\n/)
+    .map((segment) => segment.trim())
+    .filter((segment) => segment && isDestructiveSegment(segment));
+}
+
+export function isDestructiveCommand(command: string): boolean {
+  return getDestructiveSegments(command).length > 0;
+}
+
+export default function (pi: ExtensionAPI) {
+  let destructiveEnabled = true;
+
+  pi.registerCommand("destructive", {
+    description: "Toggle destructive-command guard — /destructive, /destructive on, /destructive off",
+    handler: async (args, ctx) => {
+      const arg = (args || "").trim().toLowerCase();
+      if (arg === "on" || arg === "enable" || arg === "enabled") {
+        destructiveEnabled = true;
+        ctx.ui.notify("destructive guard: ON — deletion commands need confirmation", "info");
+        return;
+      }
+      if (arg === "off" || arg === "disable" || arg === "disabled") {
+        destructiveEnabled = false;
+        ctx.ui.notify("destructive guard: OFF — deletion commands run without confirmation", "warning");
+        return;
+      }
+      // toggle
+      destructiveEnabled = !destructiveEnabled;
+      ctx.ui.notify(
+        `destructive guard: ${destructiveEnabled ? "ON" : "OFF"}`,
+        destructiveEnabled ? "info" : "warning",
+      );
+    },
+  });
+
+  pi.on("tool_call", async (event, ctx) => {
+    if (!destructiveEnabled) return undefined;
+    if (event.toolName !== "bash" && event.toolName !== "powershell") {
+      return undefined;
+    }
+
+    const command = event.input.command as string | undefined;
+    const destructiveParts = command ? getDestructiveSegments(command) : [];
+    if (!command || destructiveParts.length === 0) return undefined;
+
+    const display = destructiveParts.join("\n");
+
+    if (!ctx.hasUI) {
+      return {
+        block: true,
+        reason: `Blocked deletion command (no UI to confirm): ${display}`,
+      };
+    }
+
+    const choice = await ctx.ui.select(
+      `Do you want to allow pi to run:\n${display}`,
+      ["1. Allow", "2. Deny"],
+    );
+
+    if (choice !== "1. Allow") {
+      return { block: true, reason: `User denied deletion command: ${display}` };
+    }
+
+    return undefined;
+  });
+}

package/agent.bak.20260905-190020/extensions/destructive/install.ps1

@@ -0,0 +1,23 @@
+#!/usr/bin/env pwsh
+# Per-extension installer — Windows / PowerShell
+# Installs npm dependencies for this extension. No-op if no package.json.
+$ErrorActionPreference = "Stop"
+$extDir = $PSScriptRoot
+if (-not $extDir) { $extDir = Split-Path -Parent $MyInvocation.MyCommand.Path }
+if (-not (Test-Path "$extDir/package.json")) {
+  Write-Host "  - no package.json — skipping" -ForegroundColor DarkGray
+  exit 0
+}
+if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
+  Write-Host "  x npm not found — install Node.js 22+" -ForegroundColor Red
+  exit 1
+}
+if (Test-Path "$extDir/package-lock.json") {
+  Write-Host "  - npm ci" -ForegroundColor DarkGray
+  npm --prefix $extDir ci --no-audit --no-fund
+} else {
+  Write-Host "  - npm install" -ForegroundColor DarkGray
+  npm --prefix $extDir install --no-audit --no-fund
+}
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+Write-Host "  + done" -ForegroundColor Green

package/agent.bak.20260905-190020/extensions/destructive/install.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+# Per-extension installer — macOS / Linux
+# Installs npm dependencies for this extension. No-op if no package.json.
+set -eu
+EXT_DIR="$(cd "$(dirname "$0")" && pwd)"
+if [ ! -f "$EXT_DIR/package.json" ]; then
+  echo "  · no package.json — skipping"
+  exit 0
+fi
+if ! command -v npm >/dev/null 2>&1; then
+  echo "  ✖ npm not found — install Node.js 22+" >&2
+  exit 1
+fi
+if [ -f "$EXT_DIR/package-lock.json" ]; then
+  echo "  · npm ci"
+  npm --prefix "$EXT_DIR" ci --no-audit --no-fund
+else
+  echo "  · npm install"
+  npm --prefix "$EXT_DIR" install --no-audit --no-fund
+fi
+echo "  ✓ done"