@dexto/tui 1.6.2

package/dist/utils/soundNotification.js

@@ -0,0 +1,188 @@
+import { existsSync } from "fs";
+import { isAbsolute, normalize, resolve, sep } from "path";
+import { fileURLToPath } from "node:url";
+import { execFile } from "child_process";
+import { getDextoGlobalPath } from "@dexto/agent-management";
+const CUSTOM_SOUND_EXTENSIONS = [".wav", ".mp3", ".ogg", ".oga", ".aiff", ".m4a"];
+function getSoundFileKey(soundType) {
+  switch (soundType) {
+    case "startup":
+      return "startupSoundFile";
+    case "approval":
+      return "approvalSoundFile";
+    case "complete":
+      return "completeSoundFile";
+  }
+}
+function resolvePathWithinSoundsDir(soundPath) {
+  if (soundPath.trim().length === 0) return null;
+  const soundsDir = normalize(getDextoGlobalPath("sounds"));
+  const resolved = isAbsolute(soundPath) ? normalize(soundPath) : resolve(soundsDir, soundPath);
+  if (resolved === soundsDir || resolved.startsWith(soundsDir + sep)) {
+    return resolved;
+  }
+  return null;
+}
+const PLATFORM_SOUNDS = {
+  darwin: {
+    // macOS system sounds
+    approval: "/System/Library/Sounds/Blow.aiff",
+    complete: "/System/Library/Sounds/Glass.aiff"
+  },
+  linux: {
+    // Common Linux sound paths (freedesktop)
+    approval: "/usr/share/sounds/freedesktop/stereo/message-new-instant.oga",
+    complete: "/usr/share/sounds/freedesktop/stereo/complete.oga"
+  },
+  win32: {
+    // Windows system sounds (handled differently via PowerShell)
+    approval: "SystemAsterisk",
+    complete: "SystemHand"
+  }
+};
+const BUNDLED_STARTUP_SOUND_PATH = fileURLToPath(
+  new URL("../../assets/sounds/startup.wav", import.meta.url)
+);
+function getDefaultSoundSpec(soundType) {
+  if (soundType === "startup") {
+    return BUNDLED_STARTUP_SOUND_PATH;
+  }
+  const platformSounds = PLATFORM_SOUNDS[process.platform];
+  return platformSounds?.[soundType] ?? null;
+}
+function playSound(soundPath) {
+  const execOrBell = (cmd, args, onError) => {
+    execFile(cmd, args, { windowsHide: true }, (error) => {
+      if (!error) return;
+      if (onError) {
+        onError();
+        return;
+      }
+      playTerminalBell();
+    });
+  };
+  switch (process.platform) {
+    case "darwin": {
+      execOrBell("afplay", [soundPath]);
+      return;
+    }
+    case "linux": {
+      const lowerSoundPath = soundPath.toLowerCase();
+      const isOgg = lowerSoundPath.endsWith(".oga") || lowerSoundPath.endsWith(".ogg");
+      if (isOgg) {
+        execOrBell("paplay", [soundPath], () => {
+          execOrBell("ogg123", ["-q", soundPath]);
+        });
+      } else {
+        execOrBell("paplay", [soundPath], () => {
+          execOrBell("aplay", ["-q", soundPath]);
+        });
+      }
+      return;
+    }
+    case "win32": {
+      if (["SystemAsterisk", "SystemHand", "SystemExclamation", "SystemQuestion"].includes(
+        soundPath
+      )) {
+        const systemSoundName = soundPath.replace("System", "");
+        execOrBell("powershell", [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `[System.Media.SystemSounds]::${systemSoundName}.Play()`
+        ]);
+        return;
+      }
+      execOrBell("powershell", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "& { param([string]$p) (New-Object System.Media.SoundPlayer $p).PlaySync() }",
+        soundPath
+      ]);
+      return;
+    }
+    default: {
+      playTerminalBell();
+      return;
+    }
+  }
+}
+function playSoundFile(soundPath) {
+  playSound(soundPath);
+}
+function playTerminalBell() {
+  process.stdout.write("\x07");
+}
+function resolveNotificationSoundSpec(soundType, config) {
+  const configuredRelativePath = config?.[getSoundFileKey(soundType)];
+  if (configuredRelativePath) {
+    const resolved = resolvePathWithinSoundsDir(configuredRelativePath);
+    if (resolved && existsSync(resolved)) {
+      return resolved;
+    }
+  }
+  const defaultSpec = getDefaultSoundSpec(soundType);
+  if (!defaultSpec) return null;
+  if (process.platform === "win32") {
+    return defaultSpec;
+  }
+  return existsSync(defaultSpec) ? defaultSpec : null;
+}
+function playNotificationSound(soundType, config) {
+  const soundSpec = resolveNotificationSoundSpec(soundType, config);
+  if (!soundSpec) {
+    playTerminalBell();
+    return;
+  }
+  playSound(soundSpec);
+}
+class SoundNotificationService {
+  config;
+  constructor(config) {
+    this.config = { ...config };
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Play CLI startup sound if enabled
+   */
+  playStartupSound() {
+    if (this.config.enabled && this.config.onStartup) {
+      playNotificationSound("startup", this.config);
+    }
+  }
+  /**
+   * Play approval required sound if enabled
+   */
+  playApprovalSound() {
+    if (this.config.enabled && this.config.onApprovalRequired) {
+      playNotificationSound("approval", this.config);
+    }
+  }
+  /**
+   * Play task complete sound if enabled
+   */
+  playCompleteSound() {
+    if (this.config.enabled && this.config.onTaskComplete) {
+      playNotificationSound("complete", this.config);
+    }
+  }
+}
+export {
+  CUSTOM_SOUND_EXTENSIONS,
+  SoundNotificationService,
+  getDefaultSoundSpec,
+  playNotificationSound,
+  playSoundFile
+};

package/dist/utils/soundNotification.test.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_child_process = require("child_process");
+var import_soundNotification = require("./soundNotification.js");
+import_vitest.vi.mock("child_process", async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    execFile: import_vitest.vi.fn((_file, _args, _options, callback) => {
+      const cb = typeof _options === "function" ? _options : callback;
+      if (cb) cb(null, "", "");
+    })
+  };
+});
+const mockedExecFile = import_vitest.vi.mocked(import_child_process.execFile);
+const TEST_CONFIG = {
+  enabled: true,
+  onStartup: false,
+  onApprovalRequired: true,
+  onTaskComplete: true
+};
+(0, import_vitest.describe)("SoundNotificationService", () => {
+  let originalStdoutWrite;
+  let writeSpy;
+  (0, import_vitest.beforeEach)(() => {
+    originalStdoutWrite = process.stdout.write;
+    writeSpy = import_vitest.vi.fn();
+    process.stdout.write = writeSpy;
+  });
+  (0, import_vitest.afterEach)(() => {
+    process.stdout.write = originalStdoutWrite;
+  });
+  (0, import_vitest.describe)("constructor", () => {
+    (0, import_vitest.it)("should accept full config", () => {
+      const service = new import_soundNotification.SoundNotificationService(TEST_CONFIG);
+      (0, import_vitest.expect)(service.getConfig()).toEqual(TEST_CONFIG);
+    });
+    (0, import_vitest.it)("should allow disabling specific sounds", () => {
+      const config = {
+        enabled: true,
+        onStartup: false,
+        onApprovalRequired: false,
+        onTaskComplete: true
+      };
+      const service = new import_soundNotification.SoundNotificationService(config);
+      (0, import_vitest.expect)(service.getConfig()).toEqual(config);
+    });
+  });
+  (0, import_vitest.describe)("setConfig", () => {
+    (0, import_vitest.it)("should update config", () => {
+      const service = new import_soundNotification.SoundNotificationService({ ...TEST_CONFIG, enabled: false });
+      service.setConfig({ enabled: true });
+      (0, import_vitest.expect)(service.getConfig().enabled).toBe(true);
+    });
+  });
+  (0, import_vitest.describe)("playApprovalSound", () => {
+    (0, import_vitest.it)("should not play when sounds disabled", () => {
+      const service = new import_soundNotification.SoundNotificationService({ ...TEST_CONFIG, enabled: false });
+      service.playApprovalSound();
+      (0, import_vitest.expect)(writeSpy).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should not play when approval sounds disabled", () => {
+      const service = new import_soundNotification.SoundNotificationService({
+        ...TEST_CONFIG,
+        onApprovalRequired: false
+      });
+      service.playApprovalSound();
+      (0, import_vitest.expect)(writeSpy).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should attempt to play sound when enabled", () => {
+      const service = new import_soundNotification.SoundNotificationService(TEST_CONFIG);
+      mockedExecFile.mockClear();
+      writeSpy.mockClear();
+      service.playApprovalSound();
+      const soundAttempted = mockedExecFile.mock.calls.length > 0 || writeSpy.mock.calls.length > 0;
+      (0, import_vitest.expect)(soundAttempted).toBe(true);
+    });
+  });
+  (0, import_vitest.describe)("playStartupSound", () => {
+    (0, import_vitest.it)("should not play when startup sounds disabled", () => {
+      const service = new import_soundNotification.SoundNotificationService({
+        ...TEST_CONFIG,
+        onStartup: false
+      });
+      mockedExecFile.mockClear();
+      writeSpy.mockClear();
+      service.playStartupSound();
+      (0, import_vitest.expect)(writeSpy).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockedExecFile).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should attempt to play sound when enabled", () => {
+      const service = new import_soundNotification.SoundNotificationService({
+        ...TEST_CONFIG,
+        onStartup: true
+      });
+      mockedExecFile.mockClear();
+      writeSpy.mockClear();
+      service.playStartupSound();
+      const soundAttempted = mockedExecFile.mock.calls.length > 0 || writeSpy.mock.calls.length > 0;
+      (0, import_vitest.expect)(soundAttempted).toBe(true);
+    });
+  });
+  (0, import_vitest.describe)("playCompleteSound", () => {
+    (0, import_vitest.it)("should not play when sounds disabled", () => {
+      const service = new import_soundNotification.SoundNotificationService({ ...TEST_CONFIG, enabled: false });
+      service.playCompleteSound();
+      (0, import_vitest.expect)(writeSpy).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should not play when complete sounds disabled", () => {
+      const service = new import_soundNotification.SoundNotificationService({
+        ...TEST_CONFIG,
+        onTaskComplete: false
+      });
+      service.playCompleteSound();
+      (0, import_vitest.expect)(writeSpy).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should attempt to play sound when enabled", () => {
+      const service = new import_soundNotification.SoundNotificationService(TEST_CONFIG);
+      mockedExecFile.mockClear();
+      writeSpy.mockClear();
+      service.playCompleteSound();
+      const soundAttempted = mockedExecFile.mock.calls.length > 0 || writeSpy.mock.calls.length > 0;
+      (0, import_vitest.expect)(soundAttempted).toBe(true);
+    });
+  });
+});

package/dist/utils/soundNotification.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=soundNotification.test.d.ts.map

package/dist/utils/soundNotification.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soundNotification.test.d.ts","sourceRoot":"","sources":["../../src/utils/soundNotification.test.ts"],"names":[],"mappings":""}

package/dist/utils/soundNotification.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { execFile } from "child_process";
+import { SoundNotificationService } from "./soundNotification.js";
+vi.mock("child_process", async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    execFile: vi.fn((_file, _args, _options, callback) => {
+      const cb = typeof _options === "function" ? _options : callback;
+      if (cb) cb(null, "", "");
+    })
+  };
+});
+const mockedExecFile = vi.mocked(execFile);
+const TEST_CONFIG = {
+  enabled: true,
+  onStartup: false,
+  onApprovalRequired: true,
+  onTaskComplete: true
+};
+describe("SoundNotificationService", () => {
+  let originalStdoutWrite;
+  let writeSpy;
+  beforeEach(() => {
+    originalStdoutWrite = process.stdout.write;
+    writeSpy = vi.fn();
+    process.stdout.write = writeSpy;
+  });
+  afterEach(() => {
+    process.stdout.write = originalStdoutWrite;
+  });
+  describe("constructor", () => {
+    it("should accept full config", () => {
+      const service = new SoundNotificationService(TEST_CONFIG);
+      expect(service.getConfig()).toEqual(TEST_CONFIG);
+    });
+    it("should allow disabling specific sounds", () => {
+      const config = {
+        enabled: true,
+        onStartup: false,
+        onApprovalRequired: false,
+        onTaskComplete: true
+      };
+      const service = new SoundNotificationService(config);
+      expect(service.getConfig()).toEqual(config);
+    });
+  });
+  describe("setConfig", () => {
+    it("should update config", () => {
+      const service = new SoundNotificationService({ ...TEST_CONFIG, enabled: false });
+      service.setConfig({ enabled: true });
+      expect(service.getConfig().enabled).toBe(true);
+    });
+  });
+  describe("playApprovalSound", () => {
+    it("should not play when sounds disabled", () => {
+      const service = new SoundNotificationService({ ...TEST_CONFIG, enabled: false });
+      service.playApprovalSound();
+      expect(writeSpy).not.toHaveBeenCalled();
+    });
+    it("should not play when approval sounds disabled", () => {
+      const service = new SoundNotificationService({
+        ...TEST_CONFIG,
+        onApprovalRequired: false
+      });
+      service.playApprovalSound();
+      expect(writeSpy).not.toHaveBeenCalled();
+    });
+    it("should attempt to play sound when enabled", () => {
+      const service = new SoundNotificationService(TEST_CONFIG);
+      mockedExecFile.mockClear();
+      writeSpy.mockClear();
+      service.playApprovalSound();
+      const soundAttempted = mockedExecFile.mock.calls.length > 0 || writeSpy.mock.calls.length > 0;
+      expect(soundAttempted).toBe(true);
+    });
+  });
+  describe("playStartupSound", () => {
+    it("should not play when startup sounds disabled", () => {
+      const service = new SoundNotificationService({
+        ...TEST_CONFIG,
+        onStartup: false
+      });
+      mockedExecFile.mockClear();
+      writeSpy.mockClear();
+      service.playStartupSound();
+      expect(writeSpy).not.toHaveBeenCalled();
+      expect(mockedExecFile).not.toHaveBeenCalled();
+    });
+    it("should attempt to play sound when enabled", () => {
+      const service = new SoundNotificationService({
+        ...TEST_CONFIG,
+        onStartup: true
+      });
+      mockedExecFile.mockClear();
+      writeSpy.mockClear();
+      service.playStartupSound();
+      const soundAttempted = mockedExecFile.mock.calls.length > 0 || writeSpy.mock.calls.length > 0;
+      expect(soundAttempted).toBe(true);
+    });
+  });
+  describe("playCompleteSound", () => {
+    it("should not play when sounds disabled", () => {
+      const service = new SoundNotificationService({ ...TEST_CONFIG, enabled: false });
+      service.playCompleteSound();
+      expect(writeSpy).not.toHaveBeenCalled();
+    });
+    it("should not play when complete sounds disabled", () => {
+      const service = new SoundNotificationService({
+        ...TEST_CONFIG,
+        onTaskComplete: false
+      });
+      service.playCompleteSound();
+      expect(writeSpy).not.toHaveBeenCalled();
+    });
+    it("should attempt to play sound when enabled", () => {
+      const service = new SoundNotificationService(TEST_CONFIG);
+      mockedExecFile.mockClear();
+      writeSpy.mockClear();
+      service.playCompleteSound();
+      const soundAttempted = mockedExecFile.mock.calls.length > 0 || writeSpy.mock.calls.length > 0;
+      expect(soundAttempted).toBe(true);
+    });
+  });
+});

package/dist/utils/streamSplitter.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streamSplitter_exports = {};
+__export(streamSplitter_exports, {
+  checkForSplit: () => checkForSplit,
+  findLastSafeNewline: () => findLastSafeNewline,
+  findLastSafeSplitPoint: () => findLastSafeSplitPoint
+});
+module.exports = __toCommonJS(streamSplitter_exports);
+function isIndexInsideCodeBlock(content, indexToTest) {
+  let fenceCount = 0;
+  let searchPos = 0;
+  while (searchPos < content.length) {
+    const nextFence = content.indexOf("```", searchPos);
+    if (nextFence === -1 || nextFence >= indexToTest) {
+      break;
+    }
+    fenceCount++;
+    searchPos = nextFence + 3;
+  }
+  return fenceCount % 2 === 1;
+}
+function findEnclosingCodeBlockStart(content, index) {
+  if (!isIndexInsideCodeBlock(content, index)) {
+    return -1;
+  }
+  let currentSearchPos = 0;
+  while (currentSearchPos < index) {
+    const blockStartIndex = content.indexOf("```", currentSearchPos);
+    if (blockStartIndex === -1 || blockStartIndex >= index) {
+      break;
+    }
+    const blockEndIndex = content.indexOf("```", blockStartIndex + 3);
+    if (blockStartIndex < index) {
+      if (blockEndIndex === -1 || index < blockEndIndex + 3) {
+        return blockStartIndex;
+      }
+    }
+    if (blockEndIndex === -1) break;
+    currentSearchPos = blockEndIndex + 3;
+  }
+  return -1;
+}
+function findLastSafeSplitPoint(content) {
+  const enclosingBlockStart = findEnclosingCodeBlockStart(content, content.length);
+  if (enclosingBlockStart !== -1) {
+    return enclosingBlockStart;
+  }
+  let searchStartIndex = content.length;
+  while (searchStartIndex >= 0) {
+    const dnlIndex = content.lastIndexOf("\n\n", searchStartIndex);
+    if (dnlIndex === -1) {
+      break;
+    }
+    const potentialSplitPoint = dnlIndex + 2;
+    if (!isIndexInsideCodeBlock(content, potentialSplitPoint)) {
+      return potentialSplitPoint;
+    }
+    searchStartIndex = dnlIndex - 1;
+  }
+  return content.length;
+}
+function findLastSafeNewline(content) {
+  let searchPos = content.length;
+  while (searchPos > 0) {
+    const nlIndex = content.lastIndexOf("\n", searchPos - 1);
+    if (nlIndex === -1) {
+      break;
+    }
+    if (!isIndexInsideCodeBlock(content, nlIndex)) {
+      return nlIndex + 1;
+    }
+    searchPos = nlIndex;
+  }
+  return -1;
+}
+const MIN_PARAGRAPH_SPLIT_LENGTH = 200;
+const MAX_PENDING_LENGTH = 300;
+function checkForSplit(content) {
+  if (content.length < MIN_PARAGRAPH_SPLIT_LENGTH) {
+    return { shouldSplit: false };
+  }
+  const paragraphSplitPoint = findLastSafeSplitPoint(content);
+  if (paragraphSplitPoint > 80 && paragraphSplitPoint < content.length - 20) {
+    return {
+      shouldSplit: true,
+      splitIndex: paragraphSplitPoint,
+      before: content.substring(0, paragraphSplitPoint),
+      after: content.substring(paragraphSplitPoint)
+    };
+  }
+  if (content.length > MAX_PENDING_LENGTH) {
+    const lineSplitPoint = findLastSafeNewline(content);
+    if (lineSplitPoint > 80 && lineSplitPoint < content.length - 20) {
+      return {
+        shouldSplit: true,
+        splitIndex: lineSplitPoint,
+        before: content.substring(0, lineSplitPoint),
+        after: content.substring(lineSplitPoint)
+      };
+    }
+  }
+  return { shouldSplit: false };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkForSplit,
+  findLastSafeNewline,
+  findLastSafeSplitPoint
+});

package/dist/utils/streamSplitter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Stream Splitter Utilities
+ *
+ * Provides markdown-aware splitting for streaming content to reduce flickering.
+ *
+ * Approach:
+ * - Find safe split points at paragraph boundaries (\n\n)
+ * - Protect code blocks from being split mid-block
+ * - Allow progressive finalization during streaming
+ */
+/**
+ * Find the last safe split point in the content.
+ *
+ * Safe split points are:
+ * 1. After paragraph breaks (\n\n) that are not inside code blocks
+ * 2. Before code blocks if we're inside one
+ *
+ * Returns the index to split at, or content.length if no split is needed.
+ */
+export declare function findLastSafeSplitPoint(content: string): number;
+/**
+ * Find the last newline that's not inside a code block.
+ * Used for line-based batching.
+ */
+export declare function findLastSafeNewline(content: string): number;
+/**
+ * Determines if content should be split for progressive finalization.
+ *
+ * Strategy:
+ * 1. First try paragraph splits (\n\n) for clean breaks
+ * 2. If content exceeds MAX_PENDING_LENGTH with no paragraph break,
+ *    fall back to line-based splits (\n) to prevent flickering
+ *
+ * Returns:
+ * - { shouldSplit: false } if no split needed
+ * - { shouldSplit: true, splitIndex, before, after } if split found
+ */
+export declare function checkForSplit(content: string): {
+    shouldSplit: boolean;
+    splitIndex?: number;
+    before?: string;
+    after?: string;
+};
+//# sourceMappingURL=streamSplitter.d.ts.map

package/dist/utils/streamSplitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamSplitter.d.ts","sourceRoot":"","sources":["../../src/utils/streamSplitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAmDH;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA2B9D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAiB3D;AAcD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG;IAC5C,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CA+BA"}