@asterxsk/kiln 0.3.0 → 0.4.2

package/agent.bak.20260905-190020/extensions/shared/test/child-session.test.ts

@@ -1,270 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import test from "node:test";
-import {
-  createAgentSession,
-  DefaultResourceLoader,
-  defineTool,
-  ProjectTrustStore,
-  SessionManager,
-  SettingsManager,
-  type SessionShutdownEvent,
-} from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import {
-  bindChildSessionExtensions,
-  CHILD_EXCLUDED_TOOL_NAMES,
-  childToolPolicy,
-  createChildResources,
-  resolveStandaloneChildProjectTrust,
-  shutdownAndDisposeChildSession,
-  type DisposableChildSession,
-} from "../child-session.ts";
-
-async function withTempDir(run: (directory: string) => Promise<void>) {
-  const directory = await mkdtemp(path.join(tmpdir(), "pi-child-policy-"));
-  try {
-    await run(directory);
-  } finally {
-    await rm(directory, { recursive: true, force: true });
-  }
-}
-
-test("child denylist keeps extension and workflow structured tools available", async () => {
-  await withTempDir(async (directory) => {
-    let starts = 0;
-    let shutdowns = 0;
-    const settingsManager = SettingsManager.inMemory(undefined, {
-      projectTrusted: false,
-    });
-    const inlineLoader = new DefaultResourceLoader({
-      cwd: directory,
-      agentDir: path.join(directory, "inline-agent"),
-      settingsManager,
-      extensionFactories: [
-        (pi) => {
-          pi.on("session_start", () => {
-            starts++;
-          });
-          pi.on("session_shutdown", () => {
-            shutdowns++;
-          });
-          for (const name of [
-            "fixture_extension_tool",
-            ...CHILD_EXCLUDED_TOOL_NAMES,
-          ]) {
-            pi.registerTool({
-              name,
-              label: name,
-              description: name,
-              parameters: Type.Object({}),
-              async execute() {
-                return {
-                  content: [{ type: "text", text: "ok" }],
-                  details: {},
-                };
-              },
-            });
-          }
-        },
-      ],
-    });
-    await inlineLoader.reload();
-
-    const structuredOutput = defineTool({
-      name: "structured_output",
-      label: "Structured Output",
-      description: "fixture structured result",
-      parameters: Type.Object({ value: Type.String() }),
-      async execute(_id, params) {
-        return {
-          content: [{ type: "text", text: params.value }],
-          details: {},
-        };
-      },
-    });
-    const { session } = await createAgentSession({
-      cwd: directory,
-      agentDir: path.join(directory, "inline-agent"),
-      resourceLoader: inlineLoader,
-      settingsManager,
-      sessionManager: SessionManager.inMemory(directory),
-      customTools: [structuredOutput],
-      ...childToolPolicy(),
-    });
-    await bindChildSessionExtensions(session);
-
-    assert.deepEqual(
-      [...CHILD_EXCLUDED_TOOL_NAMES],
-      [
-        "subagent_spawn",
-        "subagent_wait",
-        "subagent_cancel",
-        "subagent_check",
-        "subagent_list",
-        "workflow",
-        "ask_user",
-      ],
-    );
-    const allTools = new Set(session.getAllTools().map((tool) => tool.name));
-    const activeTools = new Set(session.getActiveToolNames());
-    assert.equal(starts, 1);
-    assert.equal(allTools.has("fixture_extension_tool"), true);
-    assert.equal(activeTools.has("fixture_extension_tool"), true);
-    assert.equal(allTools.has("structured_output"), true);
-    assert.equal(activeTools.has("structured_output"), true);
-    for (const denied of CHILD_EXCLUDED_TOOL_NAMES) {
-      assert.equal(allTools.has(denied), false, `${denied} should be denied`);
-      assert.equal(
-        activeTools.has(denied),
-        false,
-        `${denied} should be inactive`,
-      );
-    }
-    for (const builtin of ["read", "bash", "edit", "write"]) {
-      assert.equal(
-        activeTools.has(builtin),
-        true,
-        `${builtin} should stay active`,
-      );
-    }
-
-    await Promise.all([
-      shutdownAndDisposeChildSession(session),
-      shutdownAndDisposeChildSession(session),
-    ]);
-    assert.equal(shutdowns, 1);
-  });
-});
-
-test("resource loading gates project extensions but retains global extensions", async () => {
-  await withTempDir(async (directory) => {
-    const cwd = path.join(directory, "project");
-    const agentDir = path.join(directory, "agent");
-    await mkdir(path.join(cwd, ".pi", "extensions"), { recursive: true });
-    await mkdir(path.join(agentDir, "extensions"), { recursive: true });
-    const extensionSource = (name: string) => `
-      export default function (pi) {
-        pi.registerTool({
-          name: ${JSON.stringify(name)}, label: ${JSON.stringify(name)},
-          description: "fixture", parameters: { type: "object", properties: {} },
-          async execute() { return { content: [{ type: "text", text: "ok" }] }; }
-        });
-      }
-    `;
-    await writeFile(
-      path.join(agentDir, "extensions", "global.ts"),
-      extensionSource("global_fixture"),
-    );
-    await writeFile(
-      path.join(cwd, ".pi", "extensions", "project.ts"),
-      extensionSource("project_fixture"),
-    );
-
-    const untrusted = await createChildResources({
-      cwd,
-      agentDir,
-      projectTrusted: false,
-    });
-    const untrustedTools = untrusted.loader
-      .getExtensions()
-      .extensions.flatMap((extension) => [...extension.tools.keys()]);
-    assert.equal(untrustedTools.includes("global_fixture"), true);
-    assert.equal(untrustedTools.includes("project_fixture"), false);
-
-    const trusted = await createChildResources({
-      cwd,
-      agentDir,
-      projectTrusted: true,
-    });
-    const trustedTools = trusted.loader
-      .getExtensions()
-      .extensions.flatMap((extension) => [...extension.tools.keys()]);
-    assert.equal(trustedTools.includes("global_fixture"), true);
-    assert.equal(trustedTools.includes("project_fixture"), true);
-  });
-});
-
-test("alternate standalone cwd only uses explicit saved trust", async () => {
-  await withTempDir(async (directory) => {
-    const parentCwd = path.join(directory, "parent");
-    const childCwd = path.join(directory, "alternate");
-    const agentDir = path.join(directory, "agent");
-    await mkdir(parentCwd, { recursive: true });
-    await mkdir(childCwd, { recursive: true });
-
-    assert.equal(
-      resolveStandaloneChildProjectTrust({
-        parentCwd,
-        childCwd: parentCwd,
-        parentTrusted: true,
-        agentDir,
-      }),
-      true,
-    );
-    assert.equal(
-      resolveStandaloneChildProjectTrust({
-        parentCwd,
-        childCwd,
-        parentTrusted: true,
-        agentDir,
-      }),
-      false,
-    );
-
-    new ProjectTrustStore(agentDir).set(childCwd, true);
-    assert.equal(
-      resolveStandaloneChildProjectTrust({
-        parentCwd,
-        childCwd,
-        parentTrusted: false,
-        agentDir,
-      }),
-      true,
-    );
-  });
-});
-
-test("shutdown helper balances hooks and disposal despite errors", async () => {
-  let emits = 0;
-  let disposals = 0;
-  const session: DisposableChildSession = {
-    extensionRunner: {
-      hasHandlers: () => true,
-      async emit(event: SessionShutdownEvent) {
-        emits++;
-        assert.deepEqual(event, { type: "session_shutdown", reason: "quit" });
-        throw new Error("fixture shutdown failure");
-      },
-    },
-    dispose() {
-      disposals++;
-    },
-  };
-
-  await Promise.all([
-    shutdownAndDisposeChildSession(session),
-    shutdownAndDisposeChildSession(session),
-    shutdownAndDisposeChildSession(session),
-  ]);
-  assert.equal(emits, 1);
-  assert.equal(disposals, 1);
-});
-
-test("shutdown helper bounds a stuck hook before disposal", async () => {
-  let disposals = 0;
-  const session: DisposableChildSession = {
-    extensionRunner: {
-      hasHandlers: () => true,
-      emit: () => new Promise(() => {}),
-    },
-    dispose() {
-      disposals++;
-    },
-  };
-
-  await shutdownAndDisposeChildSession(session, { timeoutMs: 10 });
-  assert.equal(disposals, 1);
-});

package/agent.bak.20260905-190020/extensions/shared/test/context-utilization.test.ts

@@ -1,48 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import {
-  contextPercent,
-  formatContextUtilization,
-} from "../context-utilization.ts";
-
-test("formats current context occupancy against model capacity", () => {
-  assert.equal(
-    formatContextUtilization({ tokens: 26_040, contextWindow: 372_000 }),
-    "7%/372k",
-  );
-});
-
-test("formats the latest post-compaction usage rather than prior cumulative usage", () => {
-  const latestUsage = { tokens: 18_000, contextWindow: 200_000 };
-  assert.equal(formatContextUtilization(latestUsage), "9%/200k");
-});
-
-test("clamps over-capacity and nonsensical token values", () => {
-  assert.equal(
-    contextPercent({ tokens: 500_000, contextWindow: 200_000 }),
-    100,
-  );
-  assert.equal(
-    formatContextUtilization({
-      tokens: Number.POSITIVE_INFINITY,
-      contextWindow: 200_000,
-    }),
-    "?%/200k",
-  );
-  assert.equal(
-    formatContextUtilization({ tokens: -1, contextWindow: 200_000 }),
-    "?%/200k",
-  );
-});
-
-test("handles missing usage or capacity without NaN or Infinity", () => {
-  assert.equal(
-    formatContextUtilization({ tokens: null, contextWindow: 372_000 }),
-    "?%/372k",
-  );
-  assert.equal(formatContextUtilization({ tokens: 12_000 }), "");
-  assert.equal(
-    formatContextUtilization({ tokens: 12_000, contextWindow: 0 }),
-    "",
-  );
-});

package/agent.bak.20260905-190020/extensions/shared/test/tool-call-timeout.test.ts

@@ -1,117 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import {
-  createToolCallTimeoutGuard,
-  runWithToolCallTimeout,
-  CHILD_TOOL_CALL_TIMEOUT_MS,
-  ToolCallTimeoutError,
-} from "../tool-call-timeout.ts";
-
-test("the production timeout error names the tool and three-minute limit", () => {
-  assert.equal(
-    new ToolCallTimeoutError("fixture_tool", CHILD_TOOL_CALL_TIMEOUT_MS)
-      .message,
-    'Tool call "fixture_tool" timed out after 3 minutes.',
-  );
-});
-
-test("a hung tool call fails clearly and receives an abort signal", async () => {
-  let executionSignal: AbortSignal | undefined;
-
-  await assert.rejects(
-    runWithToolCallTimeout("hung_fixture", 10, undefined, (signal) => {
-      executionSignal = signal;
-      return new Promise(() => {});
-    }),
-    (error: unknown) => {
-      assert.equal(error instanceof ToolCallTimeoutError, true);
-      assert.equal(
-        error instanceof Error ? error.message : "",
-        'Tool call "hung_fixture" timed out after 10 ms.',
-      );
-      return true;
-    },
-  );
-
-  assert.equal(executionSignal?.aborted, true);
-  assert.equal(executionSignal?.reason instanceof ToolCallTimeoutError, true);
-});
-
-test("parent cancellation still stops the timeout wrapper immediately", async () => {
-  const controller = new AbortController();
-  const reason = new Error("cancelled fixture");
-  const pending = runWithToolCallTimeout(
-    "hung_fixture",
-    60_000,
-    controller.signal,
-    () => new Promise(() => {}),
-  );
-
-  controller.abort(reason);
-
-  await assert.rejects(pending, (error: unknown) => error === reason);
-});
-
-test("the guard wraps each definition once and can discover later tools", () => {
-  const definitions = new Map<string, ToolDefinition>();
-  const createDefinition = (name: string): ToolDefinition => ({
-    name,
-    label: name,
-    description: name,
-    parameters: Type.Object({}),
-    async execute() {
-      return { content: [{ type: "text", text: "done" }], details: {} };
-    },
-  });
-  const first = createDefinition("first");
-  definitions.set(first.name, first);
-  const registry = {
-    getAllTools: () => [...definitions.keys()].map((name) => ({ name })),
-    getToolDefinition: (name: string) => definitions.get(name),
-  };
-  const guard = createToolCallTimeoutGuard(10);
-
-  const firstExecute = first.execute;
-  guard.apply(registry);
-  const firstWrappedExecute = first.execute;
-  assert.notEqual(firstWrappedExecute, firstExecute);
-
-  const second = createDefinition("second");
-  const secondExecute = second.execute;
-  definitions.set(second.name, second);
-  guard.apply(registry);
-
-  assert.equal(first.execute, firstWrappedExecute);
-  assert.notEqual(second.execute, secondExecute);
-});
-
-test("successful and terminating tool results pass through unchanged", async () => {
-  const result = {
-    content: [{ type: "text" as const, text: "recorded" }],
-    details: { value: "fixture" },
-    terminate: true,
-  };
-
-  assert.equal(
-    await runWithToolCallTimeout(
-      "structured_output",
-      10,
-      undefined,
-      async () => result,
-    ),
-    result,
-  );
-});
-
-test("the timeout is fresh for each tool call, not shared across calls", async () => {
-  const execute = () =>
-    runWithToolCallTimeout("slow_fixture", 100, undefined, async () => {
-      await new Promise((resolve) => setTimeout(resolve, 60));
-      return "done";
-    });
-
-  assert.equal(await execute(), "done");
-  assert.equal(await execute(), "done");
-});

package/agent.bak.20260905-190020/extensions/shared/test/widget-order.test.ts

@@ -1,167 +0,0 @@
-/**
- * widget-order.test.ts — fixed stacking order for the above-editor widgets.
- *
- * Each extension loads in an isolated jiti module instance, so this test
- * imports a DIFFERENT vendored copy of the helper per widget key (mirroring
- * production) to prove the copies coordinate through the shared globalThis
- * registry. The fake ui replicates pi core's Map insertion-order semantics:
- * every setWidget moves the key to the end (closest to the input).
- *
- * Run: node --test agent/extensions/shared/widget-order.test.ts
- */
-
-import assert from "node:assert/strict";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { afterEach, test } from "node:test";
-import { fileURLToPath } from "node:url";
-
-// One copy per widget — exactly how the three extensions consume them.
-import {
-	hideOrderedWidget as hideTodos,
-	setOrderedWidget as setTodos,
-	WIDGET_ORDER,
-} from "../../todo/widget-order.ts";
-import {
-	hideOrderedWidget as hideTerms,
-	setOrderedWidget as setTerms,
-} from "../../background-terminals/src/widget-order.ts";
-import {
-	hideOrderedWidget as hideSubs,
-	setOrderedWidget as setSubs,
-} from "../../subagents/src/widget-order.ts";
-
-const TODOS = "rpiv-todos";
-const TERMS = "background-terminals";
-const SUBS = "subagents";
-
-/** Canonical order: todos furthest from the input, subagents closest. */
-const CANONICAL = [TODOS, TERMS, SUBS];
-
-interface FakeUI {
-	setWidget(key: string, content: unknown, options?: unknown): void;
-}
-
-function createFakeUI() {
-	// Map insertion order == pi core's widgetContainerAbove render order.
-	const map = new Map<string, unknown>();
-	const calls: Array<{ key: string; cleared: boolean }> = [];
-	const ui: FakeUI = {
-		setWidget(key: string, content: unknown) {
-			calls.push({ key, cleared: content === undefined });
-			if (content === undefined) map.delete(key);
-			else map.set(key, content);
-		},
-	};
-	return {
-		ui,
-		calls,
-		order: () => [...map.keys()],
-		contentOf: (key: string) => map.get(key),
-	};
-}
-
-const fac = (marker: string) => (_tui: unknown, _theme: unknown) => ({
-	render: () => [marker],
-	invalidate: () => {},
-});
-
-function resetRegistry(ui: FakeUI) {
-	// Hide-all returns every test to a clean slate (registry + fake pi map).
-	hideTodos(ui as never, TODOS as never);
-	hideTerms(ui as never, TERMS as never);
-	hideSubs(ui as never, SUBS as never);
-}
-
-afterEach(() => {
-	// Guard against registry leakage if a test fails mid-sequence.
-	resetRegistry(createFakeUI().ui);
-});
-
-test("canonical order is exported and matches the required stacking", () => {
-	assert.deepEqual([...WIDGET_ORDER], CANONICAL);
-});
-
-test("pins canonical order regardless of registration sequence", () => {
-	const f = createFakeUI();
-	resetRegistry(f.ui);
-	// Worst case: reverse registration order.
-	setSubs(f.ui as never, SUBS as never, fac("sub") as never);
-	setTerms(f.ui as never, TERMS as never, fac("bg") as never);
-	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
-	assert.deepEqual(f.order(), CANONICAL);
-});
-
-test("top widget registering last still lands on top (the reported bug)", () => {
-	const f = createFakeUI();
-	resetRegistry(f.ui);
-	// Terminals + subagents already visible when the todo overlay registers
-	// at agent_start. Naive setWidget would append todos at the bottom.
-	setTerms(f.ui as never, TERMS as never, fac("bg") as never);
-	setSubs(f.ui as never, SUBS as never, fac("sub") as never);
-	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
-	assert.deepEqual(f.order(), CANONICAL);
-});
-
-test("refreshing the middle widget keeps order and stores latest content", () => {
-	const f = createFakeUI();
-	resetRegistry(f.ui);
-	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
-	setTerms(f.ui as never, TERMS as never, fac("bg-1") as never);
-	setSubs(f.ui as never, SUBS as never, fac("sub") as never);
-	// Background count changes 1 -> 2: re-set must not sink it to the bottom.
-	setTerms(f.ui as never, TERMS as never, fac("bg-2") as never);
-	assert.deepEqual(f.order(), CANONICAL);
-	const current = f.contentOf(TERMS) as (_t: unknown, _th: unknown) => { render: () => string[] };
-	assert.deepEqual(current({}, {}).render(), ["bg-2"]);
-});
-
-test("hiding the middle widget preserves survivors; re-show restores slot", () => {
-	const f = createFakeUI();
-	resetRegistry(f.ui);
-	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
-	setTerms(f.ui as never, TERMS as never, fac("bg") as never);
-	setSubs(f.ui as never, SUBS as never, fac("sub") as never);
-	hideTerms(f.ui as never, TERMS as never);
-	assert.deepEqual(f.order(), [TODOS, SUBS]);
-	setTerms(f.ui as never, TERMS as never, fac("bg") as never);
-	assert.deepEqual(f.order(), CANONICAL);
-});
-
-test("setOrderedWidget with undefined content hides", () => {
-	const f = createFakeUI();
-	resetRegistry(f.ui);
-	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
-	assert.deepEqual(f.order(), [TODOS]);
-	setTodos(f.ui as never, TODOS as never, undefined);
-	assert.deepEqual(f.order(), []);
-});
-
-test("hiding an untracked key still clears pi directly", () => {
-	const f = createFakeUI();
-	resetRegistry(f.ui);
-	hideSubs(f.ui as never, SUBS as never);
-	assert.ok(
-		f.calls.some((c) => c.key === SUBS && c.cleared),
-		"expected a direct clear for the untracked key",
-	);
-	assert.deepEqual(f.order(), []);
-});
-
-test("undefined ui is a safe no-op", () => {
-	assert.doesNotThrow(() => {
-		setTodos(undefined as never, TODOS as never, fac("todo") as never);
-		hideTodos(undefined as never, TODOS as never);
-	});
-});
-
-test("vendored helper copies stay byte-identical", () => {
-	const here = path.dirname(fileURLToPath(import.meta.url));
-	const files = [
-		"../todo/widget-order.ts",
-		"../background-terminals/src/widget-order.ts",
-		"../subagents/src/widget-order.ts",
-	].map((rel) => fs.readFileSync(path.resolve(here, rel), "utf8"));
-	assert.equal(files[1], files[0], "background-terminals copy diverged from todo copy");
-	assert.equal(files[2], files[0], "subagents copy diverged from todo copy");
-});

package/agent.bak.20260905-190020/extensions/shared/tool-call-timeout.ts

@@ -1,104 +0,0 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-
-export const CHILD_TOOL_CALL_TIMEOUT_MS = 3 * 60 * 1_000;
-
-interface ToolRegistry {
-  getAllTools(): Array<{ name: string }>;
-  getToolDefinition(name: string): ToolDefinition | undefined;
-}
-
-function formatTimeout(timeoutMs: number) {
-  if (timeoutMs % 60_000 === 0) {
-    const minutes = timeoutMs / 60_000;
-    return `${minutes} minute${minutes === 1 ? "" : "s"}`;
-  }
-  if (timeoutMs % 1_000 === 0) {
-    const seconds = timeoutMs / 1_000;
-    return `${seconds} second${seconds === 1 ? "" : "s"}`;
-  }
-  return `${timeoutMs} ms`;
-}
-
-export class ToolCallTimeoutError extends Error {
-  constructor(toolName: string, timeoutMs: number) {
-    super(
-      `Tool call "${toolName}" timed out after ${formatTimeout(timeoutMs)}.`,
-    );
-    this.name = "ToolCallTimeoutError";
-  }
-}
-
-export async function runWithToolCallTimeout<T>(
-  toolName: string,
-  timeoutMs: number,
-  signal: AbortSignal | undefined,
-  execute: (signal: AbortSignal) => Promise<T>,
-) {
-  const timeoutController = new AbortController();
-  const executionSignal = signal
-    ? AbortSignal.any([signal, timeoutController.signal])
-    : timeoutController.signal;
-  const timeoutError = new ToolCallTimeoutError(toolName, timeoutMs);
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_resolve, reject) => {
-    timer = setTimeout(() => {
-      reject(timeoutError);
-      timeoutController.abort(timeoutError);
-    }, timeoutMs);
-  });
-
-  let removeAbortListener: (() => void) | undefined;
-  const aborted = new Promise<never>((_resolve, reject) => {
-    if (!signal) return;
-    const onAbort = () => {
-      reject(
-        signal.reason instanceof Error
-          ? signal.reason
-          : new Error(`Tool call "${toolName}" was aborted.`),
-      );
-    };
-    if (signal.aborted) {
-      onAbort();
-      return;
-    }
-    signal.addEventListener("abort", onAbort, { once: true });
-    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-  });
-
-  try {
-    return await Promise.race([execute(executionSignal), timeout, aborted]);
-  } finally {
-    if (timer) clearTimeout(timer);
-    removeAbortListener?.();
-  }
-}
-
-/**
- * Wrap every currently registered child tool with an independent execution
- * timeout. Calling apply() again is safe and picks up tools registered later.
- */
-export function createToolCallTimeoutGuard(
-  timeoutMs = CHILD_TOOL_CALL_TIMEOUT_MS,
-) {
-  const wrapped = new WeakSet<ToolDefinition>();
-
-  const wrap = (definition: ToolDefinition) => {
-    if (wrapped.has(definition)) return;
-    wrapped.add(definition);
-
-    const execute = definition.execute;
-    definition.execute = async (toolCallId, params, signal, onUpdate, ctx) =>
-      runWithToolCallTimeout(definition.name, timeoutMs, signal, (signal) =>
-        execute.call(definition, toolCallId, params, signal, onUpdate, ctx),
-      );
-  };
-
-  return {
-    apply(session: ToolRegistry) {
-      for (const { name } of session.getAllTools()) {
-        const definition = session.getToolDefinition(name);
-        if (definition) wrap(definition);
-      }
-    },
-  };
-}