killeros 2.0.2 → 2.0.4

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

@@ -1,11 +1,21 @@
+import type { InitEvidenceIndex } from "./init-evidence.ts";
+import type { InitTargetBaseline } from "./init-target.ts";
+
+export type InitOutcome =
+  | { kind: "pending" }
+  | { kind: "written" }
+  | { kind: "policy-conflict"; reason: string }
+  | { kind: "no-outcome" };
+
 export interface InitRuntime {
   active: boolean;
   targetPath?: string;
-  writeAttempted: boolean;
-  writeSucceeded: boolean;
   projectRoot?: string;
   activeTools?: string[];
-  settle?: (writeSucceeded: boolean) => void;
+  evidence?: InitEvidenceIndex;
+  baseline?: InitTargetBaseline;
+  outcome: InitOutcome;
+  settle?: (outcome: InitOutcome) => void;
 }
 
 export type GoalStatus = "active" | "paused" | "blocked" | "complete";
@@ -23,13 +33,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;
@@ -39,14 +49,13 @@ export interface GoalRuntime {
 }
 
 export function createInitRuntime(): InitRuntime {
-  return { active: false, writeAttempted: false, writeSucceeded: false };
+  return { active: false, outcome: { kind: "pending" } };
 }
 
 export function createGoalRuntime(): GoalRuntime {
   return {
     continuationScheduled: false,
     continuationHeld: false,
-    continuationHeldForCompaction: false,
     goalTurnInFlight: false,
     agentEndObserved: false,
     persistenceRetryNeeded: false,
@@ -56,31 +65,10 @@ export function createGoalRuntime(): GoalRuntime {
 export function resetInitRuntime(state: InitRuntime): void {
   state.active = false;
   state.targetPath = undefined;
-  state.writeAttempted = false;
-  state.writeSucceeded = false;
   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,
-  };
+  state.evidence = undefined;
+  state.baseline = undefined;
+  state.outcome = { kind: "pending" };
+  state.settle = undefined;
 }

package/killeros/shell-ui.ts

@@ -11,7 +11,6 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
   Container,
-  CURSOR_MARKER,
   Text,
   truncateToWidth,
   visibleWidth,
@@ -19,7 +18,6 @@ import {
   type EditorTheme,
   type TUI,
 } from "@earendil-works/pi-tui";
-import { availableCommandNames } from "./commands.ts";
 import { formatCwd, padRight } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { formatModel } from "./footer.ts";
@@ -42,6 +40,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> {
@@ -150,113 +149,6 @@ class PiStartupHeader {
 }
 
 const ANSI_REGEX = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-const ANSI_SEQUENCE_AT_START = /^\x1b\[[0-?]*[ -/]*[@-~]/u;
-const COMMAND_TOKEN_PATTERN = /(^|[ \t])(\/[A-Za-z0-9:_-]*)/gu;
-
-function controlSequenceAt(text: string, index: number): string | undefined {
-  if (text.startsWith(CURSOR_MARKER, index)) return CURSOR_MARKER;
-  return text.slice(index).match(ANSI_SEQUENCE_AT_START)?.[0];
-}
-
-interface CommandToken {
-  text: string;
-  start: number;
-  end: number;
-  valid: boolean;
-}
-
-interface EditorVisualLine {
-  logicalLine: number;
-  startCol: number;
-  length: number;
-}
-
-function commandTokens(text: string, normalizedNames: readonly string[]): CommandToken[] {
-  return [...text.matchAll(COMMAND_TOKEN_PATTERN)].map((match) => {
-    const token = match[2] ?? "";
-    const prefix = token.slice(1).toLocaleLowerCase();
-    const start = (match.index ?? 0) + (match[1]?.length ?? 0);
-    return {
-      text: token,
-      start,
-      end: start + token.length,
-      valid: normalizedNames.some((name) => name.startsWith(prefix)),
-    };
-  });
-}
-
-function highlightTextRanges(
-  text: string,
-  ranges: Array<{ start: number; end: number }>,
-  color: (value: string) => string,
-): string {
-  if (ranges.length === 0) return text;
-
-  let output = "";
-  let buffer = "";
-  let bufferHighlighted: boolean | undefined;
-  let plainIndex = 0;
-  const flush = (): void => {
-    if (!buffer) return;
-    output += bufferHighlighted ? color(buffer) : buffer;
-    buffer = "";
-  };
-
-  for (let index = 0; index < text.length;) {
-    const control = controlSequenceAt(text, index);
-    if (control) {
-      flush();
-      output += control;
-      index += control.length;
-      continue;
-    }
-
-    const highlighted = ranges.some((range) => plainIndex >= range.start && plainIndex < range.end);
-    if (bufferHighlighted !== highlighted) {
-      flush();
-      bufferHighlighted = highlighted;
-    }
-    buffer += text[index];
-    plainIndex += 1;
-    index += 1;
-  }
-  flush();
-  return output;
-}
-
-function highlightEditorLines(
-  lines: string[],
-  sourceLines: string[],
-  visualLines: EditorVisualLine[],
-  scrollOffset: number,
-  commandNames: ReadonlySet<string>,
-  color: (value: string) => string,
-): { lines: string[]; bottomBorderIndex: number } {
-  let bottomBorderIndex = -1;
-  for (let index = lines.length - 1; index >= 1; index -= 1) {
-    if (isBorderLine(lines[index] ?? "")) {
-      bottomBorderIndex = index;
-      break;
-    }
-  }
-  if (bottomBorderIndex < 0) bottomBorderIndex = lines.length - 1;
-
-  const normalizedNames = [...commandNames].map((name) => name.toLocaleLowerCase());
-  for (let index = 1; index < bottomBorderIndex; index += 1) {
-    const visualLine = visualLines[scrollOffset + index - 1];
-    if (!visualLine) continue;
-    const visibleStart = visualLine.startCol;
-    const visibleEnd = visibleStart + visualLine.length;
-    const ranges = commandTokens(sourceLines[visualLine.logicalLine] ?? "", normalizedNames)
-      .filter((token) => token.valid && token.start < visibleEnd && token.end > visibleStart)
-      .map((token) => ({
-        start: Math.max(token.start, visibleStart) - visibleStart,
-        end: Math.min(token.end, visibleEnd) - visibleStart,
-      }));
-    lines[index] = highlightTextRanges(lines[index] ?? "", ranges, color);
-  }
-  return { lines, bottomBorderIndex };
-}
 
 function stripAnsi(text: string): string {
   return text.replace(ANSI_REGEX, "").trim();
@@ -275,19 +167,16 @@ function isScrolledTopBorder(line: string): boolean {
 class PiCodeEditor extends CustomEditor {
   private readonly appKeybindings: KeybindingsManager;
   private readonly runtimeTheme: Theme;
-  private readonly getCommandNames: () => ReadonlySet<string>;
 
   constructor(
     tui: TUI,
     theme: EditorTheme,
     appKeybindings: KeybindingsManager,
     runtimeTheme: Theme,
-    getCommandNames: () => ReadonlySet<string>,
   ) {
     super(tui, theme, appKeybindings);
     this.appKeybindings = appKeybindings;
     this.runtimeTheme = runtimeTheme;
-    this.getCommandNames = getCommandNames;
   }
 
   override handleInput(data: string): void {
@@ -304,37 +193,19 @@ class PiCodeEditor extends CustomEditor {
     super.handleInput(data);
   }
 
-  private renderWithCommandHighlighting(
-    width: number,
-    color: (value: string) => string,
-  ): { lines: string[]; bottomBorderIndex: number } {
-    const lines = super.render(width);
-    const internals = this as unknown as {
-      lastWidth: number;
-      scrollOffset: number;
-      buildVisualLineMap: (layoutWidth: number) => EditorVisualLine[];
-    };
-    return highlightEditorLines(
-      lines,
-      this.getLines(),
-      internals.buildVisualLineMap(internals.lastWidth),
-      internals.scrollOffset,
-      this.getCommandNames(),
-      color,
-    );
-  }
-
   override render(width: number): string[] {
     if (width <= 0) return [];
-    const colorCommand = (value: string): string => this.runtimeTheme.fg("mdLink", value);
-    if (width < 4) {
-      return this.renderWithCommandHighlighting(width, colorCommand)
-        .lines.map((line) => truncateToWidth(line, width, ""));
-    }
+    if (width < 4) return super.render(width).map((line) => truncateToWidth(line, width, ""));
     const innerWidth = width - 2;
-    const highlighted = this.renderWithCommandHighlighting(innerWidth, colorCommand);
-    const { lines, bottomBorderIndex } = highlighted;
+    const lines = super.render(innerWidth);
     if (lines.length < 2) return lines.map((line) => truncateToWidth(line, width, ""));
+    let bottomBorderIndex = lines.length - 1;
+    for (let index = lines.length - 1; index >= 1; index -= 1) {
+      if (isBorderLine(lines[index] ?? "")) {
+        bottomBorderIndex = index;
+        break;
+      }
+    }
 
     const gray = (text: string): string => this.runtimeTheme.fg("dim", text);
     const framed: string[] = [];
@@ -380,6 +251,8 @@ function formatActivityMessage(word: string, theme: Theme): string {
   return `${theme.fg("accent", `${word}…`)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · thinking)`)}`;
 }
 
+let killerosEditorFactory: ReturnType<ExtensionContext["ui"]["getEditorComponent"]>;
+
 export function registerShellUi(pi: ExtensionAPI): void {
   let activeHeader: PiStartupHeader | undefined;
   let activityDeck: string[] = [];
@@ -427,8 +300,12 @@ export function registerShellUi(pi: ExtensionAPI): void {
         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)));
+      const existingEditorFactory = ctx.ui.getEditorComponent?.();
+      if (!existingEditorFactory || existingEditorFactory === killerosEditorFactory) {
+        killerosEditorFactory = (tui, editorTheme, keybindings) =>
+          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme);
+        ctx.ui.setEditorComponent(killerosEditorFactory);
+      }
     } catch (error) {
       reportError(ctx, "Killeros UI failed to initialize", error);
     }

package/package.json

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