killeros 2.0.4 → 2.0.6

package/killeros/hooks.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 import { CONFIG_DIR_NAME, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { reportError } from "./errors.ts";
 import { MAX_NODE_TIMER_MS } from "./limits.ts";
@@ -44,6 +45,10 @@ function loadKillerosHooks(ctx: ExtensionContext): KillerosHookConfig {
       const candidates = parsed.hooks?.[event];
       if (!Array.isArray(candidates)) continue;
       hooks[event] = candidates.filter((hook, index) => {
+        if (event === "agent_settled" && hook?.matcher !== undefined) {
+          ctx.ui.notify(`Ignored ${event} hook ${index + 1}: matchers are only valid for tool events`, "warning");
+          return false;
+        }
         const valid = hook
           && typeof hook.command === "string"
           && hook.command.trim().length > 0
@@ -80,9 +85,19 @@ function matchesHook(hook: KillerosHook, value: string): boolean {
   }
 }
 
-function appendBounded(current: string, chunk: Buffer | string): string {
-  if (current.length >= HOOK_OUTPUT_LIMIT) return current;
-  return (current + chunk.toString()).slice(0, HOOK_OUTPUT_LIMIT);
+interface HookOutputBuffer {
+  bytes: number;
+  decoder: StringDecoder;
+  text: string;
+}
+
+function appendBounded(output: HookOutputBuffer, chunk: Buffer | string): void {
+  const remaining = HOOK_OUTPUT_LIMIT - output.bytes;
+  if (remaining <= 0) return;
+  const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+  const captured = bytes.subarray(0, remaining);
+  output.bytes += captured.length;
+  output.text += output.decoder.write(captured);
 }
 
 function terminateHookProcess(child: ReturnType<typeof spawn>, force: boolean): void {
@@ -130,8 +145,8 @@ export function executeHook(
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
     });
-    let stdout = "";
-    let stderr = "";
+    const stdout: HookOutputBuffer = { bytes: 0, decoder: new StringDecoder("utf8"), text: "" };
+    const stderr: HookOutputBuffer = { bytes: 0, decoder: new StringDecoder("utf8"), text: "" };
     let completed = false;
     let termination: "timeout" | "cancelled" | undefined;
     let timer: NodeJS.Timeout | undefined;
@@ -146,8 +161,8 @@ export function executeHook(
       signal?.removeEventListener("abort", abort);
       resolve({
         code,
-        stdout,
-        stderr,
+        stdout: stdout.text,
+        stderr: stderr.text,
         timedOut: termination === "timeout",
         cancelled: termination === "cancelled",
         exitUnconfirmed,
@@ -167,10 +182,10 @@ export function executeHook(
     const abort = (): void => beginTermination("cancelled");
     signal?.addEventListener("abort", abort, { once: true });
     if (signal?.aborted) beginTermination("cancelled");
-    child.stdout.on("data", (chunk) => { stdout = appendBounded(stdout, chunk); });
-    child.stderr.on("data", (chunk) => { stderr = appendBounded(stderr, chunk); });
+    child.stdout.on("data", (chunk) => appendBounded(stdout, chunk));
+    child.stderr.on("data", (chunk) => appendBounded(stderr, chunk));
     child.on("error", (error) => {
-      stderr = appendBounded(stderr, error.message);
+      appendBounded(stderr, error.message);
       finish(termination ? terminationCode() : 1);
     });
     child.once("close", (code) => finish(termination ? terminationCode() : code ?? 1));

package/killeros/init-evidence.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 
 export const INIT_READ_TOOL = "killeros_init_read";
 export const INIT_LIST_TOOL = "killeros_init_list";
@@ -91,7 +92,7 @@ async function collectCandidates(projectRoot: string): Promise<string[]> {
 
 async function gitIgnoredPaths(projectRoot: string, candidates: readonly string[]): Promise<ReadonlySet<string>> {
   if (!candidates.length) return new Set();
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     let stdout = Buffer.alloc(0);
     const child = spawn("git", ["-C", projectRoot, "check-ignore", "--stdin", "-z"], {
@@ -99,7 +100,13 @@ async function gitIgnoredPaths(projectRoot: string, candidates: readonly string[
       stdio: ["pipe", "pipe", "ignore"],
       windowsHide: true,
     });
-    const finish = (value: ReadonlySet<string>): void => {
+    const fail = (): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error("Git ignore inspection failed; /init did not build repository evidence"));
+    };
+    const succeed = (value: ReadonlySet<string>): void => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
@@ -107,30 +114,59 @@ async function gitIgnoredPaths(projectRoot: string, candidates: readonly string[
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      finish(new Set());
+      fail();
     }, 2_000);
     child.stdout.on("data", (chunk: Buffer) => {
-      if (stdout.length <= 256 * 1024) stdout = Buffer.concat([stdout, chunk]);
+      if (stdout.length + chunk.length > 256 * 1024) {
+        child.kill("SIGKILL");
+        fail();
+        return;
+      }
+      stdout = Buffer.concat([stdout, chunk]);
+    });
+    child.once("error", fail);
+    child.stdin.once("error", () => {
+      child.kill("SIGKILL");
+      fail();
     });
-    child.once("error", () => finish(new Set()));
     child.once("close", (code) => {
-      if (code === 1) return finish(new Set());
-      if (code !== 0 || stdout.length > 256 * 1024 || stdout.at(-1) !== 0) return finish(new Set());
+      if (code === 1) {
+        if (stdout.length) fail();
+        else succeed(new Set());
+        return;
+      }
+      if (code !== 0 || !stdout.length || stdout.at(-1) !== 0) {
+        fail();
+        return;
+      }
+      let values: string[];
+      try {
+        values = new TextDecoder("utf-8", { fatal: true }).decode(stdout.subarray(0, -1)).split("\0");
+      } catch {
+        fail();
+        return;
+      }
       const candidateSet = new Set(candidates.map(evidenceKey));
-      const values = stdout.subarray(0, -1).toString("utf8").split("\0");
-      if (values.some((value) => !value || !candidateSet.has(evidenceKey(value)))) return finish(new Set());
-      finish(new Set(values.map(evidenceKey)));
+      const ignored = new Set(values.map(evidenceKey));
+      if (values.some((value) => !value || !candidateSet.has(evidenceKey(value))) || ignored.size !== values.length) {
+        fail();
+        return;
+      }
+      succeed(ignored);
     });
-    child.stdin.on("error", () => {});
     child.stdin.end(`${candidates.join("\0")}\0`);
   });
 }
 
+function decodeCompleteUtf8(bytes: Buffer): string {
+  return new StringDecoder("utf8").write(bytes);
+}
+
 function appendWithinLimit(current: string, section: string, limit: number): string {
   const remaining = limit - Buffer.byteLength(current, "utf8");
   if (remaining <= 0) return current;
   const bytes = Buffer.from(section, "utf8");
-  return current + bytes.subarray(0, remaining).toString("utf8");
+  return current + decodeCompleteUtf8(bytes.subarray(0, remaining));
 }
 
 async function validateAndRead(projectRoot: string, absolutePath: string, limit: number): Promise<{ content: string; truncated: boolean }> {
@@ -157,7 +193,7 @@ async function validateAndRead(projectRoot: string, absolutePath: string, limit:
     const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
     const data = buffer.subarray(0, Math.min(bytesRead, limit));
     if (data.includes(0)) throw new Error("/init rejects binary files");
-    return { content: data.toString("utf8"), truncated: bytesRead > limit };
+    return { content: decodeCompleteUtf8(data), truncated: bytesRead > limit };
   } finally {
     await handle.close();
   }

package/killeros/notifications.ts

@@ -65,7 +65,7 @@ export function formatNotificationTitle(
   sessionName: string | undefined,
   enabled: boolean,
 ): string {
-  const directory = basename(cwd);
+  const directory = basename(cwd) || cwd;
   const base = sessionName ? `π - ${sessionName} - ${directory}` : `π - ${directory}`;
   return enabled ? `${base} ${COMPLETION_BELL_GLYPH}` : base;
 }