@asterxsk/kiln 0.1.0

package/agent/extensions/destructive/index.ts

@@ -0,0 +1,88 @@
+/**
+ * destructive - Asks before running destructive (deletion) commands.
+ *
+ * Intercepts `bash` / `powershell` tool calls and prompts:
+ *
+ *   Do you want to allow pi to run:
+ *   {full-command}
+ *
+ *   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 isDestructiveCommand(command: string): boolean {
+  return command.split(/&&|\|\||;|\||\n/).some(isDestructiveSegment);
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("tool_call", async (event, ctx) => {
+    if (event.toolName !== "bash" && event.toolName !== "powershell") {
+      return undefined;
+    }
+
+    const command = event.input.command as string | undefined;
+    if (!command || !isDestructiveCommand(command)) return undefined;
+
+    if (!ctx.hasUI) {
+      return {
+        block: true,
+        reason: `Blocked deletion command (no UI to confirm): ${command}`,
+      };
+    }
+
+    const choice = await ctx.ui.select(
+      `Do you want to allow pi to run:\n${command}`,
+      ["1. Allow", "2. Deny"],
+    );
+
+    if (choice !== "1. Allow") {
+      return { block: true, reason: `User denied deletion command: ${command}` };
+    }
+
+    return undefined;
+  });
+}

package/agent/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/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"

package/agent/extensions/file-search/index.spec.ts

@@ -0,0 +1,443 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, it } from "@effect/vitest";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { Effect, FileSystem } from "effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import {
+  buildFdArgs,
+  buildRgArgs,
+  FD_DEFAULT_LIMIT,
+  normalizeSearchPath,
+} from "./src/args.ts";
+import {
+  FD_INTEL_DARWIN_VERSION,
+  InstallError,
+  readBoundedResponse,
+  releaseAsset,
+  resolveBinary,
+  TOOL_SPECS,
+  UnsupportedPlatformError,
+  type BinaryEnv,
+  type ReleaseAsset,
+  type ResolvedBinary,
+} from "./src/binaries.ts";
+import { formatCapturedOutput, formatOutput } from "./src/output.ts";
+import { executeSearchProcess } from "./src/process.ts";
+import { installNotifications, makeBinaryInitializers } from "./index.ts";
+
+// --- argument construction -------------------------------------------------
+
+it("fd args: defaults list everything with the default limit", () => {
+  assert.deepEqual(buildFdArgs({}), [
+    "--color=never",
+    "--max-results",
+    String(FD_DEFAULT_LIMIT),
+    "--",
+    "",
+  ]);
+});
+
+it("fd args: all options are translated and pattern stays behind --", () => {
+  const args = buildFdArgs({
+    pattern: "-rf",
+    path: "@src",
+    type: "file",
+    extension: ".ts",
+    glob: true,
+    hidden: true,
+    max_depth: 3,
+    limit: 50,
+  });
+  assert.deepEqual(args, [
+    "--color=never",
+    "--hidden",
+    "--glob",
+    "--type",
+    "f",
+    "--extension",
+    "ts",
+    "--max-depth",
+    "3",
+    "--max-results",
+    "50",
+    "--",
+    "-rf",
+    "src",
+  ]);
+});
+
+it("fd args: out-of-range values are clamped", () => {
+  const args = buildFdArgs({ max_depth: 500, limit: 1_000_000 });
+  assert.deepEqual(args, [
+    "--color=never",
+    "--max-depth",
+    "64",
+    "--max-results",
+    "10000",
+    "--",
+    "",
+  ]);
+});
+
+it("rg args: defaults use smart-case and safe separators", () => {
+  assert.deepEqual(buildRgArgs({ pattern: "--help" }), [
+    "--line-number",
+    "--color=never",
+    "--no-heading",
+    "--with-filename",
+    "--smart-case",
+    "--max-count",
+    "100",
+    "--",
+    "--help",
+  ]);
+});
+
+it("rg args: all options are translated", () => {
+  const args = buildRgArgs({
+    pattern: "TODO",
+    path: "@lib",
+    glob: "*.ts",
+    file_type: "ts",
+    case_sensitive: true,
+    fixed_strings: true,
+    hidden: true,
+    context: 2,
+    limit: 10,
+  });
+  assert.deepEqual(args, [
+    "--line-number",
+    "--color=never",
+    "--no-heading",
+    "--with-filename",
+    "--case-sensitive",
+    "--fixed-strings",
+    "--hidden",
+    "--context",
+    "2",
+    "--glob",
+    "*.ts",
+    "--type",
+    "ts",
+    "--max-count",
+    "10",
+    "--",
+    "TODO",
+    "lib",
+  ]);
+});
+
+it("rg args: case_sensitive false forces ignore-case", () => {
+  const args = buildRgArgs({ pattern: "x", case_sensitive: false });
+  assert.isTrue(args.includes("--ignore-case"));
+  assert.isFalse(args.includes("--smart-case"));
+});
+
+it("path normalization strips leading @ and expands ~", () => {
+  assert.equal(normalizeSearchPath("@src/lib"), "src/lib");
+  assert.equal(normalizeSearchPath("~"), homedir());
+  assert.equal(normalizeSearchPath("~/projects"), join(homedir(), "projects"));
+  assert.equal(normalizeSearchPath(" plain "), "plain");
+});
+
+// --- binary resolution -----------------------------------------------------
+
+function makeEnv(options: {
+  available?: string[];
+  installShouldFail?: boolean;
+}): BinaryEnv & { installs: ReleaseAsset[]; probes: string[] } {
+  const installs: ReleaseAsset[] = [];
+  const probes: string[] = [];
+  const installed = new Set<string>();
+  return {
+    installs,
+    probes,
+    probe: (command) =>
+      Effect.sync(() => {
+        probes.push(command);
+        return (
+          (options.available ?? []).includes(command) || installed.has(command)
+        );
+      }),
+    install: (asset, destination) => {
+      if (options.installShouldFail) {
+        return Effect.fail(new InstallError({ message: "network down" }));
+      }
+      return Effect.sync(() => {
+        installs.push(asset);
+        installed.add(destination);
+      });
+    },
+  };
+}
+
+const darwinArm = { os: "darwin", arch: "arm64" } as const;
+
+it.effect("binary resolution: system fd wins and nothing is installed", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({ available: ["fd"] });
+    const resolved = yield* resolveBinary(
+      TOOL_SPECS.fd,
+      "/repo/bin",
+      darwinArm,
+      env,
+    );
+
+    assert.deepEqual(resolved, {
+      tool: "fd",
+      command: "fd",
+      source: "system",
+    });
+    assert.equal(env.installs.length, 0);
+  }),
+);
+
+it.effect("binary resolution: fdfind is accepted as a system fd", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({ available: ["fdfind"] });
+    const resolved = yield* resolveBinary(
+      TOOL_SPECS.fd,
+      "/repo/bin",
+      darwinArm,
+      env,
+    );
+
+    assert.deepEqual(resolved, {
+      tool: "fd",
+      command: "fdfind",
+      source: "system",
+    });
+    assert.equal(env.installs.length, 0);
+  }),
+);
+
+it.effect("binary resolution: existing bin fallback is used silently", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({ available: ["/repo/bin/rg"] });
+    const resolved = yield* resolveBinary(
+      TOOL_SPECS.rg,
+      "/repo/bin",
+      darwinArm,
+      env,
+    );
+
+    assert.deepEqual(resolved, {
+      tool: "rg",
+      command: "/repo/bin/rg",
+      source: "bundled",
+    });
+    assert.equal(env.installs.length, 0);
+  }),
+);
+
+it.effect(
+  "binary resolution: missing everywhere triggers exactly one install",
+  () =>
+    Effect.gen(function* () {
+      const env = makeEnv({ available: [] });
+      const resolved = yield* resolveBinary(
+        TOOL_SPECS.rg,
+        "/repo/bin",
+        darwinArm,
+        env,
+      );
+
+      assert.equal(resolved.source, "installed");
+      assert.equal(resolved.command, "/repo/bin/rg");
+      assert.equal(env.installs.length, 1);
+      assert.match(
+        env.installs[0].url,
+        /^https:\/\/github\.com\/BurntSushi\/ripgrep\//,
+      );
+    }),
+);
+
+it.effect("binary resolution: install failure surfaces a typed error", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({ available: [], installShouldFail: true });
+    const error = yield* Effect.flip(
+      resolveBinary(TOOL_SPECS.fd, "/repo/bin", darwinArm, env),
+    );
+
+    assert.instanceOf(error, InstallError);
+    assert.equal(error.message, "network down");
+  }),
+);
+
+it.effect(
+  "binary resolution: unsupported platform fails without installing",
+  () =>
+    Effect.gen(function* () {
+      const env = makeEnv({ available: [] });
+      const error = yield* Effect.flip(
+        resolveBinary(
+          TOOL_SPECS.fd,
+          "/repo/bin",
+          { os: "linux", arch: "s390x" },
+          env,
+        ),
+      );
+
+      assert.instanceOf(error, UnsupportedPlatformError);
+      assert.equal(env.installs.length, 0);
+    }),
+);
+
+it.effect("binary resolution: one failed tool does not disable the other", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({
+      available: ["rg"],
+      installShouldFail: true,
+    });
+    const initializers = makeBinaryInitializers("/repo/bin", darwinArm, env);
+
+    const fdError = yield* Effect.flip(initializers.fd);
+    const rg = yield* initializers.rg;
+
+    assert.instanceOf(fdError, InstallError);
+    assert.deepEqual(rg, { tool: "rg", command: "rg", source: "system" });
+  }),
+);
+
+it("release assets cover macOS and Linux on arm64 and x64 over HTTPS", () => {
+  for (const os of ["darwin", "linux"] as const) {
+    for (const arch of ["arm64", "x64"] as const) {
+      for (const tool of ["fd", "rg"] as const) {
+        const asset = releaseAsset(tool, { os, arch });
+        assert.isDefined(asset, `${tool} ${os}/${arch}`);
+        assert.match(asset.url, /^https:\/\//);
+        assert.isTrue(asset.url.endsWith(asset.fileName));
+        assert.match(asset.sha256, /^[a-f0-9]{64}$/);
+      }
+    }
+  }
+});
+
+it("linux assets use statically linked musl builds", () => {
+  const asset = releaseAsset("fd", { os: "linux", arch: "x64" });
+  assert.isTrue(asset?.url.includes("unknown-linux-musl"));
+});
+
+it("Intel macOS uses the latest fd release that publishes that target", () => {
+  const asset = releaseAsset("fd", { os: "darwin", arch: "x64" });
+  assert.equal(asset?.version, FD_INTEL_DARWIN_VERSION);
+});
+
+it.effect(
+  "bounded downloads reject oversized declared and streamed bodies",
+  () =>
+    Effect.gen(function* () {
+      const request = HttpClientRequest.get(
+        "https://example.com/archive.tar.gz",
+      );
+      const declared = HttpClientResponse.fromWeb(
+        request,
+        new Response("small", {
+          headers: { "content-length": "100" },
+        }),
+      );
+      const declaredError = yield* Effect.flip(
+        readBoundedResponse(declared, 10),
+      );
+      assert.match(declaredError.message, /size limit/);
+
+      const streamed = HttpClientResponse.fromWeb(
+        request,
+        new Response("this body is too large"),
+      );
+      const streamedError = yield* Effect.flip(
+        readBoundedResponse(streamed, 5),
+      );
+      assert.match(streamedError.message, /size limit/);
+    }),
+);
+
+// --- notification policy ----------------------------------------------------
+
+it("notifications: only fresh installs notify", () => {
+  const system: ResolvedBinary = {
+    tool: "fd",
+    command: "fd",
+    source: "system",
+  };
+  const bundled: ResolvedBinary = {
+    tool: "rg",
+    command: "/repo/bin/rg",
+    source: "bundled",
+  };
+  const installed: ResolvedBinary = {
+    tool: "rg",
+    command: "/repo/bin/rg",
+    source: "installed",
+    version: "15.2.0",
+  };
+
+  assert.deepEqual(installNotifications([system, bundled]), []);
+  const messages = installNotifications([system, installed]);
+  assert.equal(messages.length, 1);
+  assert.match(messages[0], /downloaded rg 15\.2\.0/);
+});
+
+// --- output truncation -------------------------------------------------------
+
+it.effect("process output is streamed to a complete spill file", () =>
+  Effect.gen(function* () {
+    const result = yield* executeSearchProcess({
+      command: process.execPath,
+      args: ["-e", 'process.stdout.write("line\\n".repeat(3000))'],
+      cwd: process.cwd(),
+      tempPrefix: "pi-search-test-",
+    });
+    const formatted = formatCapturedOutput(result.output);
+
+    assert.equal(result.code, 0);
+    assert.isTrue(formatted.truncated);
+    assert.equal(formatted.lineCount, 3000);
+    assert.match(formatted.text, /2000 of 3000 lines/);
+    assert.isDefined(formatted.fullOutputPath);
+
+    const fs = yield* FileSystem.FileSystem;
+    const fullOutput = yield* fs.readFileString(formatted.fullOutputPath);
+    assert.equal(fullOutput, "line\n".repeat(3000));
+    yield* fs.remove(dirname(formatted.fullOutputPath), {
+      recursive: true,
+      force: true,
+    });
+  }).pipe(Effect.provide(NodeServices.layer)),
+);
+
+it("output: small results pass through untouched", async () => {
+  const formatted = await formatOutput("a.ts\nb.ts\n", {
+    tempPrefix: "pi-fd-",
+    persistFullOutput: () => Promise.reject(new Error("should not persist")),
+  });
+  assert.equal(formatted.text, "a.ts\nb.ts");
+  assert.equal(formatted.lineCount, 2);
+  assert.isFalse(formatted.truncated);
+  assert.isUndefined(formatted.fullOutputPath);
+});
+
+it("output: oversized results are truncated and persisted", async () => {
+  const bigOutput = Array.from({ length: 3000 }, (_, i) => `file-${i}.ts`).join(
+    "\n",
+  );
+  let persisted: string | undefined;
+  const formatted = await formatOutput(bigOutput, {
+    tempPrefix: "pi-fd-",
+    persistFullOutput: async (full) => {
+      persisted = full;
+      return "/tmp/fake/output.txt";
+    },
+  });
+  assert.isTrue(formatted.truncated);
+  assert.equal(formatted.fullOutputPath, "/tmp/fake/output.txt");
+  assert.equal(persisted, bigOutput);
+  assert.match(formatted.text, /\[Output truncated: 2000 of 3000 lines/);
+  assert.match(
+    formatted.text,
+    /Full output saved to: \/tmp\/fake\/output\.txt\]/,
+  );
+  const shownLines = formatted.text.split("\n");
+  assert.equal(shownLines[0], "file-0.ts");
+});