@asterxsk/kiln 0.1.0 → 0.2.0

package/agent/extensions/subagents/by-the-way.test.ts

@@ -1,29 +1,29 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  BTW_TITLE_MAX_LENGTH,
-  deriveBtwTitle,
-  isModelVisible,
-} from "./src/by-the-way.ts";
-
-test("deriveBtwTitle uses the first non-empty line and bounds the title", () => {
-  assert.equal(
-    deriveBtwTitle("\n   Why   does this work?   \nignore me"),
-    "Why does this work?",
-  );
-  assert.equal(deriveBtwTitle(" \n\t"), "by the way");
-
-  const title = deriveBtwTitle("x".repeat(BTW_TITLE_MAX_LENGTH + 10));
-  assert.equal(title.length, BTW_TITLE_MAX_LENGTH);
-  assert.equal(title, `${"x".repeat(BTW_TITLE_MAX_LENGTH - 1)}…`);
-
-  const emojiTitle = deriveBtwTitle(
-    `${"x".repeat(BTW_TITLE_MAX_LENGTH - 2)}😀 more`,
-  );
-  assert.equal(emojiTitle, `${"x".repeat(BTW_TITLE_MAX_LENGTH - 2)}😀…`);
-});
-
-test("only model-origin snapshots are visible to model-facing tools", () => {
-  assert.equal(isModelVisible({ origin: "model" }), true);
-  assert.equal(isModelVisible({ origin: "btw" }), false);
-});
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  BTW_TITLE_MAX_LENGTH,
+  deriveBtwTitle,
+  isModelVisible,
+} from "./src/by-the-way.ts";
+
+test("deriveBtwTitle uses the first non-empty line and bounds the title", () => {
+  assert.equal(
+    deriveBtwTitle("\n   Why   does this work?   \nignore me"),
+    "Why does this work?",
+  );
+  assert.equal(deriveBtwTitle(" \n\t"), "by the way");
+
+  const title = deriveBtwTitle("x".repeat(BTW_TITLE_MAX_LENGTH + 10));
+  assert.equal(title.length, BTW_TITLE_MAX_LENGTH);
+  assert.equal(title, `${"x".repeat(BTW_TITLE_MAX_LENGTH - 1)}…`);
+
+  const emojiTitle = deriveBtwTitle(
+    `${"x".repeat(BTW_TITLE_MAX_LENGTH - 2)}😀 more`,
+  );
+  assert.equal(emojiTitle, `${"x".repeat(BTW_TITLE_MAX_LENGTH - 2)}😀…`);
+});
+
+test("only model-origin snapshots are visible to model-facing tools", () => {
+  assert.equal(isModelVisible({ origin: "model" }), true);
+  assert.equal(isModelVisible({ origin: "btw" }), false);
+});

package/agent/extensions/subagents/claude.test.ts

@@ -1,119 +1,119 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { Effect } from "effect";
-import { SubagentManager } from "./src/manager.ts";
-import { claudeBackend } from "./src/backends/claude.ts";
-import type { ParentContext, SpawnTask } from "./src/domain.ts";
-import { createSubagentRuntime, runTool } from "./src/runtime.ts";
-
-const parent: ParentContext = {
-  parentCwd: process.cwd(),
-  projectTrusted: false,
-};
-
-function task(prompt: string): SpawnTask {
-  return {
-    prompt,
-    title: "live Claude test",
-    cwd: process.cwd(),
-    model: "haiku",
-    reasoningEffort: "off",
-    parent,
-  };
-}
-
-async function claudeAvailable() {
-  return Effect.runPromise(claudeBackend.available);
-}
-
-/** Rejecting deadline so a hung wait still reaches finally() and disposes. */
-function deadline<A>(operation: Promise<A>, timeoutMs: number) {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_resolve, reject) => {
-    timer = setTimeout(
-      () => reject(new Error(`Live Claude test exceeded ${timeoutMs}ms`)),
-      timeoutMs,
-    );
-  });
-  return Promise.race([operation, timeout]).finally(() => {
-    if (timer) clearTimeout(timer);
-  });
-}
-
-test(
-  "Claude backend completes a live manager run",
-  { timeout: 60_000 },
-  async (t) => {
-    if (!(await claudeAvailable())) {
-      t.skip("Claude Code executable is unavailable");
-      return;
-    }
-
-    const runtime = createSubagentRuntime();
-    try {
-      const manager = await runtime.runPromise(SubagentManager);
-      const started = await runTool(
-        runtime,
-        manager.spawn("claude", task("Reply with exactly: hello claude")),
-      );
-      await deadline(runTool(runtime, manager.waitFor([started.id])), 45_000);
-
-      const done = manager.view.get(started.id);
-      assert.equal(done?.status, "done");
-      assert.match(done?.finalText ?? "", /hello claude/i);
-      assert.ok(done?.meta.nativeSessionId);
-      assert.ok(done?.meta.sessionFilePath?.endsWith(".jsonl"));
-    } finally {
-      await runtime.dispose();
-    }
-  },
-);
-
-test(
-  "Claude backend interrupt settles a live run as aborted",
-  { timeout: 60_000 },
-  async (t) => {
-    if (!(await claudeAvailable())) {
-      t.skip("Claude Code executable is unavailable");
-      return;
-    }
-
-    const runtime = createSubagentRuntime();
-    try {
-      const manager = await runtime.runPromise(SubagentManager);
-      const started = await runTool(
-        runtime,
-        manager.spawn(
-          "claude",
-          task(
-            "Write a detailed 10,000-word essay about the history of computing.",
-          ),
-        ),
-      );
-
-      // Wait for streamed output so cancellation definitely lands mid-run and
-      // exercises the SDK's normal interrupt receipt/result path.
-      const streamDeadline = Date.now() + 15_000;
-      while (
-        manager.view.get(started.id)?.status === "running" &&
-        !manager.view.get(started.id)?.liveAssistant?.text &&
-        Date.now() < streamDeadline
-      ) {
-        await new Promise((resolve) => setTimeout(resolve, 20));
-      }
-      assert.equal(manager.view.get(started.id)?.status, "running");
-      assert.ok(manager.view.get(started.id)?.liveAssistant?.text);
-
-      const report = await deadline(
-        runTool(runtime, manager.cancel([started.id])),
-        20_000,
-      );
-
-      assert.equal(report[0]?.cancelled, true);
-      assert.equal(manager.view.get(started.id)?.status, "error");
-      assert.equal(manager.view.get(started.id)?.errorText, "Run was aborted");
-    } finally {
-      await runtime.dispose();
-    }
-  },
-);
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Effect } from "effect";
+import { SubagentManager } from "./src/manager.ts";
+import { claudeBackend } from "./src/backends/claude.ts";
+import type { ParentContext, SpawnTask } from "./src/domain.ts";
+import { createSubagentRuntime, runTool } from "./src/runtime.ts";
+
+const parent: ParentContext = {
+  parentCwd: process.cwd(),
+  projectTrusted: false,
+};
+
+function task(prompt: string): SpawnTask {
+  return {
+    prompt,
+    title: "live Claude test",
+    cwd: process.cwd(),
+    model: "haiku",
+    reasoningEffort: "off",
+    parent,
+  };
+}
+
+async function claudeAvailable() {
+  return Effect.runPromise(claudeBackend.available);
+}
+
+/** Rejecting deadline so a hung wait still reaches finally() and disposes. */
+function deadline<A>(operation: Promise<A>, timeoutMs: number) {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`Live Claude test exceeded ${timeoutMs}ms`)),
+      timeoutMs,
+    );
+  });
+  return Promise.race([operation, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+test(
+  "Claude backend completes a live manager run",
+  { timeout: 60_000 },
+  async (t) => {
+    if (!(await claudeAvailable())) {
+      t.skip("Claude Code executable is unavailable");
+      return;
+    }
+
+    const runtime = createSubagentRuntime();
+    try {
+      const manager = await runtime.runPromise(SubagentManager);
+      const started = await runTool(
+        runtime,
+        manager.spawn("claude", task("Reply with exactly: hello claude")),
+      );
+      await deadline(runTool(runtime, manager.waitFor([started.id])), 45_000);
+
+      const done = manager.view.get(started.id);
+      assert.equal(done?.status, "done");
+      assert.match(done?.finalText ?? "", /hello claude/i);
+      assert.ok(done?.meta.nativeSessionId);
+      assert.ok(done?.meta.sessionFilePath?.endsWith(".jsonl"));
+    } finally {
+      await runtime.dispose();
+    }
+  },
+);
+
+test(
+  "Claude backend interrupt settles a live run as aborted",
+  { timeout: 60_000 },
+  async (t) => {
+    if (!(await claudeAvailable())) {
+      t.skip("Claude Code executable is unavailable");
+      return;
+    }
+
+    const runtime = createSubagentRuntime();
+    try {
+      const manager = await runtime.runPromise(SubagentManager);
+      const started = await runTool(
+        runtime,
+        manager.spawn(
+          "claude",
+          task(
+            "Write a detailed 10,000-word essay about the history of computing.",
+          ),
+        ),
+      );
+
+      // Wait for streamed output so cancellation definitely lands mid-run and
+      // exercises the SDK's normal interrupt receipt/result path.
+      const streamDeadline = Date.now() + 15_000;
+      while (
+        manager.view.get(started.id)?.status === "running" &&
+        !manager.view.get(started.id)?.liveAssistant?.text &&
+        Date.now() < streamDeadline
+      ) {
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+      assert.equal(manager.view.get(started.id)?.status, "running");
+      assert.ok(manager.view.get(started.id)?.liveAssistant?.text);
+
+      const report = await deadline(
+        runTool(runtime, manager.cancel([started.id])),
+        20_000,
+      );
+
+      assert.equal(report[0]?.cancelled, true);
+      assert.equal(manager.view.get(started.id)?.status, "error");
+      assert.equal(manager.view.get(started.id)?.errorText, "Run was aborted");
+    } finally {
+      await runtime.dispose();
+    }
+  },
+);

package/agent/extensions/subagents/codex.test.ts

@@ -1,102 +1,102 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { Effect } from "effect";
-import { codexBackend } from "./src/backends/codex.ts";
-import type { ParentContext, SpawnTask } from "./src/domain.ts";
-import { SubagentManager } from "./src/manager.ts";
-import { createSubagentRuntime, runTool } from "./src/runtime.ts";
-
-const parent: ParentContext = {
-  parentCwd: process.cwd(),
-  projectTrusted: false,
-};
-
-function task(prompt: string): SpawnTask {
-  return {
-    prompt,
-    title: "live Codex test",
-    cwd: process.cwd(),
-    parent,
-  };
-}
-
-function deadline<A>(operation: Promise<A>, timeoutMs: number) {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_resolve, reject) => {
-    timer = setTimeout(
-      () => reject(new Error(`Live Codex test exceeded ${timeoutMs}ms`)),
-      timeoutMs,
-    );
-  });
-  return Promise.race([operation, timeout]).finally(() => {
-    if (timer) clearTimeout(timer);
-  });
-}
-
-async function codexAvailable() {
-  return Effect.runPromise(codexBackend.available);
-}
-
-test(
-  "Codex backend completes a live manager run",
-  { timeout: 75_000 },
-  async (t) => {
-    if (!(await codexAvailable())) {
-      t.skip("codex executable is unavailable");
-      return;
-    }
-
-    const runtime = createSubagentRuntime();
-    try {
-      const manager = await runtime.runPromise(SubagentManager);
-      const spawned = await runTool(
-        runtime,
-        manager.spawn("codex", task("Reply with exactly: hello codex")),
-      );
-
-      await deadline(runTool(runtime, manager.waitFor([spawned.id])), 60_000);
-      const done = manager.view.get(spawned.id);
-      assert.equal(done?.status, "done");
-      assert.match(done?.finalText ?? "", /hello codex/i);
-      assert.equal(done?.meta.backend, "codex");
-      assert.ok(done?.meta.nativeSessionId);
-      assert.ok(done?.meta.sessionFilePath);
-    } finally {
-      await runtime.dispose();
-    }
-  },
-);
-
-test(
-  "Codex backend interrupt settles a live manager run",
-  { timeout: 30_000 },
-  async (t) => {
-    if (!(await codexAvailable())) {
-      t.skip("codex executable is unavailable");
-      return;
-    }
-
-    const runtime = createSubagentRuntime();
-    try {
-      const manager = await runtime.runPromise(SubagentManager);
-      const spawned = await runTool(
-        runtime,
-        manager.spawn(
-          "codex",
-          task("Run `sleep 30`, then reply with the word finished."),
-        ),
-      );
-
-      await new Promise((resolve) => setTimeout(resolve, 250));
-      const result = await deadline(
-        runTool(runtime, manager.cancel([spawned.id])),
-        10_000,
-      );
-      assert.equal(result[0]?.cancelled, true);
-      assert.equal(manager.view.get(spawned.id)?.status, "error");
-      assert.equal(manager.view.get(spawned.id)?.errorText, "Run was aborted");
-    } finally {
-      await runtime.dispose();
-    }
-  },
-);
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Effect } from "effect";
+import { codexBackend } from "./src/backends/codex.ts";
+import type { ParentContext, SpawnTask } from "./src/domain.ts";
+import { SubagentManager } from "./src/manager.ts";
+import { createSubagentRuntime, runTool } from "./src/runtime.ts";
+
+const parent: ParentContext = {
+  parentCwd: process.cwd(),
+  projectTrusted: false,
+};
+
+function task(prompt: string): SpawnTask {
+  return {
+    prompt,
+    title: "live Codex test",
+    cwd: process.cwd(),
+    parent,
+  };
+}
+
+function deadline<A>(operation: Promise<A>, timeoutMs: number) {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`Live Codex test exceeded ${timeoutMs}ms`)),
+      timeoutMs,
+    );
+  });
+  return Promise.race([operation, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+async function codexAvailable() {
+  return Effect.runPromise(codexBackend.available);
+}
+
+test(
+  "Codex backend completes a live manager run",
+  { timeout: 75_000 },
+  async (t) => {
+    if (!(await codexAvailable())) {
+      t.skip("codex executable is unavailable");
+      return;
+    }
+
+    const runtime = createSubagentRuntime();
+    try {
+      const manager = await runtime.runPromise(SubagentManager);
+      const spawned = await runTool(
+        runtime,
+        manager.spawn("codex", task("Reply with exactly: hello codex")),
+      );
+
+      await deadline(runTool(runtime, manager.waitFor([spawned.id])), 60_000);
+      const done = manager.view.get(spawned.id);
+      assert.equal(done?.status, "done");
+      assert.match(done?.finalText ?? "", /hello codex/i);
+      assert.equal(done?.meta.backend, "codex");
+      assert.ok(done?.meta.nativeSessionId);
+      assert.ok(done?.meta.sessionFilePath);
+    } finally {
+      await runtime.dispose();
+    }
+  },
+);
+
+test(
+  "Codex backend interrupt settles a live manager run",
+  { timeout: 30_000 },
+  async (t) => {
+    if (!(await codexAvailable())) {
+      t.skip("codex executable is unavailable");
+      return;
+    }
+
+    const runtime = createSubagentRuntime();
+    try {
+      const manager = await runtime.runPromise(SubagentManager);
+      const spawned = await runTool(
+        runtime,
+        manager.spawn(
+          "codex",
+          task("Run `sleep 30`, then reply with the word finished."),
+        ),
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      const result = await deadline(
+        runTool(runtime, manager.cancel([spawned.id])),
+        10_000,
+      );
+      assert.equal(result[0]?.cancelled, true);
+      assert.equal(manager.view.get(spawned.id)?.status, "error");
+      assert.equal(manager.view.get(spawned.id)?.errorText, "Run was aborted");
+    } finally {
+      await runtime.dispose();
+    }
+  },
+);