killeros 2.0.1 → 2.0.3

package/killeros/notifications.ts

@@ -0,0 +1,167 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import type { StopReason } from "@earendil-works/pi-ai";
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+export interface NotificationPreferenceStore {
+  load(): boolean;
+  save(enabled: boolean): void;
+}
+
+export interface CompletionNotificationDependencies {
+  store: NotificationPreferenceStore;
+  ring(): void;
+}
+
+export const COMPLETION_BELL_GLYPH = "󰂚";
+
+const defaultSettingsPath = (): string => join(getAgentDir(), "killeros.json");
+
+type StoredSettings = Record<string, unknown>;
+
+function readStoredSettings(settingsPath: string): StoredSettings {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("KillerOS settings must contain a JSON object");
+    }
+    return parsed as StoredSettings;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+export function createNotificationPreferenceStore(
+  settingsPath = defaultSettingsPath(),
+): NotificationPreferenceStore {
+  return {
+    load: () => readStoredSettings(settingsPath).completionSound === true,
+    save: (enabled) => {
+      const current = readStoredSettings(settingsPath);
+      mkdirSync(dirname(settingsPath), { recursive: true });
+      const temporaryPath = `${settingsPath}.${process.pid}.${randomUUID()}.tmp`;
+      try {
+        writeFileSync(
+          temporaryPath,
+          `${JSON.stringify({ ...current, completionSound: enabled }, null, 2)}\n`,
+          { encoding: "utf8", mode: 0o600 },
+        );
+        renameSync(temporaryPath, settingsPath);
+      } finally {
+        rmSync(temporaryPath, { force: true });
+      }
+    },
+  };
+}
+
+export function formatNotificationTitle(
+  cwd: string,
+  sessionName: string | undefined,
+  enabled: boolean,
+): string {
+  const directory = basename(cwd);
+  const base = sessionName ? `π - ${sessionName} - ${directory}` : `π - ${directory}`;
+  return enabled ? `${base} ${COMPLETION_BELL_GLYPH}` : base;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function registerCompletionNotifications(
+  pi: ExtensionAPI,
+  dependencies?: CompletionNotificationDependencies,
+): void {
+  const runtime = dependencies ?? {
+    store: createNotificationPreferenceStore(),
+    ring: () => { process.stdout.write("\x07"); },
+  };
+  let enabled = false;
+  let requestPending = false;
+  let lastStopReason: StopReason | undefined;
+
+  const applyTitle = (ctx: ExtensionContext): void => {
+    if (ctx.mode !== "tui") return;
+    ctx.ui.setTitle(formatNotificationTitle(ctx.cwd, pi.getSessionName(), enabled));
+  };
+
+  pi.registerCommand("notification", {
+    description: "Configure the completion sound",
+    handler: async (_args, ctx) => {
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/notification requires TUI mode", "error");
+        return;
+      }
+      const selected = await ctx.ui.select("Completion sound", [
+        enabled ? "On ← current" : "On",
+        enabled ? "Off" : "Off ← current",
+      ]);
+      if (!selected) return;
+      const nextEnabled = selected.startsWith("On");
+      try {
+        runtime.store.save(nextEnabled);
+      } catch (error) {
+        ctx.ui.notify(`Completion sound setting could not be saved: ${errorMessage(error)}`, "error");
+        return;
+      }
+      enabled = nextEnabled;
+      applyTitle(ctx);
+      ctx.ui.notify(`Completion sound: ${enabled ? "On" : "Off"}`, "info");
+    },
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    requestPending = false;
+    lastStopReason = undefined;
+    if (ctx.mode !== "tui") return;
+    try {
+      enabled = runtime.store.load();
+    } catch (error) {
+      enabled = false;
+      ctx.ui.notify(`Completion sound settings could not be read: ${errorMessage(error)}`, "error");
+    }
+    applyTitle(ctx);
+  });
+
+  pi.on("session_info_changed", (_event, ctx) => applyTitle(ctx));
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    requestPending = true;
+    lastStopReason = undefined;
+  });
+
+  pi.on("agent_end", (event, ctx) => {
+    if (ctx.mode !== "tui" || !requestPending) return;
+    lastStopReason = undefined;
+    for (let index = event.messages.length - 1; index >= 0; index -= 1) {
+      const message = event.messages[index];
+      if (message?.role !== "assistant") continue;
+      lastStopReason = message.stopReason;
+      break;
+    }
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (ctx.mode !== "tui" || !requestPending) return;
+    if (!ctx.isIdle() || ctx.hasPendingMessages()) return;
+    requestPending = false;
+    if (!enabled || lastStopReason === "aborted") return;
+    try {
+      runtime.ring();
+    } catch (error) {
+      ctx.ui.notify(`Completion sound failed: ${errorMessage(error)}`, "error");
+    }
+  });
+
+  pi.on("session_shutdown", () => {
+    requestPending = false;
+    lastStopReason = undefined;
+  });
+}

package/killeros/question.ts

@@ -1,4 +1,4 @@
-import { keyHint, type ExtensionAPI, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import {
   decodeKittyPrintable,
   Editor,
@@ -174,6 +174,21 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
         };
         finishFromAbort = () => finish({ kind: "aborted" });
 
+        const keyHint = (
+          keybinding: Parameters<typeof keybindings.getKeys>[0],
+          description: string,
+        ): string => {
+          const keyText = keybindings.getKeys(keybinding)
+            .join("/")
+            .split("/")
+            .map((key) => key
+              .split("+")
+              .map((part) => process.platform === "darwin" && part.toLocaleLowerCase() === "alt" ? "option" : part)
+              .join("+"))
+            .join("/");
+          return theme.fg("dim", keyText) + theme.fg("muted", ` ${description}`);
+        };
+
         const editorTheme: EditorTheme = {
           borderColor: (text) => theme.fg("accent", text),
           selectList: {

package/killeros/runtime.ts

@@ -23,13 +23,13 @@ export interface GoalState {
   blockedAuditStartTurn: number;
   baselineTokens: number;
   result?: string;
+  resumeAfterManualCompaction?: true;
 }
 
 export interface GoalRuntime {
   state?: GoalState;
   continuationScheduled: boolean;
   continuationHeld: boolean;
-  continuationHeldForCompaction: boolean;
   goalTurnInFlight: boolean;
   agentEndObserved: boolean;
   persistenceRetryNeeded: boolean;
@@ -46,7 +46,6 @@ export function createGoalRuntime(): GoalRuntime {
   return {
     continuationScheduled: false,
     continuationHeld: false,
-    continuationHeldForCompaction: false,
     goalTurnInFlight: false,
     agentEndObserved: false,
     persistenceRetryNeeded: false,
@@ -61,26 +60,3 @@ export function resetInitRuntime(state: InitRuntime): void {
   state.projectRoot = undefined;
   state.activeTools = undefined;
 }
-
-export interface CompactionRuntime {
-  compactionInFlight: boolean;
-  automaticCompactionArmed: boolean;
-  automaticCompactionAwaitingHook: boolean;
-  automaticCompactionPending: boolean;
-  compactionOperationId: number;
-  sessionGeneration: number;
-  lastCompactionAt?: number;
-  thresholdPercent: number;
-}
-
-export function createCompactionRuntime(): CompactionRuntime {
-  return {
-    compactionInFlight: false,
-    automaticCompactionArmed: true,
-    automaticCompactionAwaitingHook: false,
-    automaticCompactionPending: false,
-    compactionOperationId: 0,
-    sessionGeneration: 0,
-    thresholdPercent: 40,
-  };
-}

package/killeros/shell-ui.ts

@@ -42,6 +42,7 @@ const STARTUP_TIPS = [
   "Press Shift+Enter to insert a line break without sending.",
   "Run /variants to tune the model's reasoning depth.",
   "Type / to browse every command available in this session.",
+  "Run /notification to enable a terminal bell when work settles.",
 ] as const;
 
 export function resolveGitBranch(cwd: string): Promise<string | undefined> {
@@ -369,8 +370,17 @@ class PiCodeEditor extends CustomEditor {
   }
 }
 
+const ACTIVITY_FRAMES = [
+  "·", "✢", "✱", "✶", "✻", "✽",
+  "✽", "✻", "✶", "✱", "✢", "·",
+] as const;
+const ACTIVITY_FRAME_INTERVAL_MS = 120;
 const ACTIVITY_WORDS = ["Brewing", "Pondering", "Tinkering", "Wrangling", "Noodling", "Cooking"] as const;
 
+function formatActivityMessage(word: string, theme: Theme): string {
+  return `${theme.fg("accent", `${word}…`)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · thinking)`)}`;
+}
+
 export function registerShellUi(pi: ExtensionAPI): void {
   let activeHeader: PiStartupHeader | undefined;
   let activityDeck: string[] = [];
@@ -413,7 +423,10 @@ export function registerShellUi(pi: ExtensionAPI): void {
         return activeHeader;
       });
       clearActivityTimer();
-      ctx.ui.setWorkingIndicator({ frames: [ctx.ui.theme.fg("accent", "✻")] });
+      ctx.ui.setWorkingIndicator({
+        frames: ACTIVITY_FRAMES.map((frame) => ctx.ui.theme.fg("accent", frame)),
+        intervalMs: ACTIVITY_FRAME_INTERVAL_MS,
+      });
       ctx.ui.setHiddenThinkingLabel("└ Thinking…");
       ctx.ui.setEditorComponent((tui, editorTheme, keybindings) =>
         new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme, () => availableCommandNames(pi)));
@@ -425,7 +438,7 @@ export function registerShellUi(pi: ExtensionAPI): void {
   pi.on("agent_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
     clearActivityTimer();
-    const updateWorkingWord = (): void => ctx.ui.setWorkingMessage(`${nextActivityWord()}…`);
+    const updateWorkingWord = (): void => ctx.ui.setWorkingMessage(formatActivityMessage(nextActivityWord(), ctx.ui.theme));
     updateWorkingWord();
     activityTimer = setInterval(updateWorkingWord, 2_500);
     activityTimer.unref?.();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "killeros",
-  "version": "2.0.1",
-  "description": "A production-hardened TUI and workflow extension for the Pi coding agent.",
+  "version": "2.0.3",
+  "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [
     "pi-package",