@micsushi/agent-hotline 0.5.1

package/packages/backend/src/settings-store.js

@@ -0,0 +1,191 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const APP_NAME = "Agent Hotline";
+const SETTINGS_FILE = "settings.json";
+const READ_BEHAVIORS = new Set(["manual", "auto"]);
+const TTS_ENGINES = new Set(["webview", "kokoro", "kokoro-ts"]);
+const NOTIFICATION_OPENS = new Set(["full", "mini"]);
+const AUDIO_CACHE_LIMIT_MAX_MB = 100000;
+
+const DEFAULT_SETTINGS = Object.freeze({
+  readBehavior: "manual",
+  mute: false,
+  engine: "webview",
+  voice: "",
+  kokoroVoice: "af_heart",
+  rate: 0.92,
+  volume: 1,
+  skipRules: Object.freeze({
+    codeBlocks: true,
+    diffs: true,
+    logs: true,
+    tables: true,
+    json: true,
+    longBulletLists: true
+  }),
+  codexEnabled: true,
+  claudeEnabled: true,
+  antigravityEnabled: true,
+  notifyOnNewReply: false,
+  notificationOpens: "full",
+  highlightSpokenText: false,
+  audioCacheLimitMb: 1024
+});
+
+function getDefaultDataDir(env = process.env, platform = process.platform) {
+  if (platform === "win32") {
+    return path.join(env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), APP_NAME);
+  }
+
+  if (platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", APP_NAME);
+  }
+
+  return path.join(env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), APP_NAME);
+}
+
+function getSettingsPath(options = {}) {
+  if (options.settingsPath) {
+    return options.settingsPath;
+  }
+
+  return path.join(
+    options.dataDir || getDefaultDataDir(options.env, options.platform),
+    SETTINGS_FILE
+  );
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function booleanOrDefault(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function stringOrDefault(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+
+function finiteNumberOrDefault(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function numberInRangeOrDefault(value, fallback, min, max) {
+  const number = finiteNumberOrDefault(value, fallback);
+  return number >= min && number <= max ? number : fallback;
+}
+
+function normalizeSettings(input) {
+  const source = isPlainObject(input) ? input : {};
+  const defaults = DEFAULT_SETTINGS;
+  const sourceSkipRules = isPlainObject(source.skipRules) ? source.skipRules : {};
+
+  return {
+    readBehavior: READ_BEHAVIORS.has(source.readBehavior)
+      ? source.readBehavior
+      : defaults.readBehavior,
+    mute: booleanOrDefault(source.mute, defaults.mute),
+    engine: TTS_ENGINES.has(source.engine) ? source.engine : defaults.engine,
+    voice: stringOrDefault(source.voice, defaults.voice),
+    kokoroVoice: stringOrDefault(source.kokoroVoice, defaults.kokoroVoice),
+    rate: numberInRangeOrDefault(source.rate, defaults.rate, 0.1, 10),
+    volume: numberInRangeOrDefault(source.volume, defaults.volume, 0, 1),
+    skipRules: {
+      codeBlocks: booleanOrDefault(sourceSkipRules.codeBlocks, defaults.skipRules.codeBlocks),
+      diffs: booleanOrDefault(sourceSkipRules.diffs, defaults.skipRules.diffs),
+      logs: booleanOrDefault(sourceSkipRules.logs, defaults.skipRules.logs),
+      tables: booleanOrDefault(sourceSkipRules.tables, defaults.skipRules.tables),
+      json: booleanOrDefault(sourceSkipRules.json, defaults.skipRules.json),
+      longBulletLists: booleanOrDefault(
+        sourceSkipRules.longBulletLists,
+        defaults.skipRules.longBulletLists
+      )
+    },
+    codexEnabled: booleanOrDefault(source.codexEnabled, defaults.codexEnabled),
+    claudeEnabled: booleanOrDefault(source.claudeEnabled, defaults.claudeEnabled),
+    antigravityEnabled: booleanOrDefault(source.antigravityEnabled, defaults.antigravityEnabled),
+    notifyOnNewReply: booleanOrDefault(source.notifyOnNewReply, defaults.notifyOnNewReply),
+    notificationOpens: NOTIFICATION_OPENS.has(source.notificationOpens)
+      ? source.notificationOpens
+      : defaults.notificationOpens,
+    highlightSpokenText: booleanOrDefault(source.highlightSpokenText, defaults.highlightSpokenText),
+    audioCacheLimitMb: numberInRangeOrDefault(
+      source.audioCacheLimitMb,
+      defaults.audioCacheLimitMb,
+      10,
+      AUDIO_CACHE_LIMIT_MAX_MB
+    )
+  };
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tempFile = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tempFile, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  fs.renameSync(tempFile, file);
+}
+
+function loadSettings(options = {}) {
+  return normalizeSettings(readJson(getSettingsPath(options)));
+}
+
+function saveSettings(settings, options = {}) {
+  const nextSettings = normalizeSettings(settings);
+  writeJson(getSettingsPath(options), nextSettings);
+  return nextSettings;
+}
+
+function updateSettings(patch, options = {}) {
+  const current = loadSettings(options);
+  const source = isPlainObject(patch) ? patch : {};
+  const nextSettings = normalizeSettings({
+    ...current,
+    ...source,
+    skipRules: {
+      ...current.skipRules,
+      ...(isPlainObject(source.skipRules) ? source.skipRules : {})
+    }
+  });
+
+  return saveSettings(nextSettings, options);
+}
+
+function createSettingsStore(options = {}) {
+  return {
+    path: getSettingsPath(options),
+    load() {
+      return loadSettings(options);
+    },
+    save(settings) {
+      return saveSettings(settings, options);
+    },
+    update(patch) {
+      return updateSettings(patch, options);
+    }
+  };
+}
+
+module.exports = {
+  DEFAULT_SETTINGS,
+  AUDIO_CACHE_LIMIT_MAX_MB,
+  READ_BEHAVIORS: Array.from(READ_BEHAVIORS),
+  TTS_ENGINES: Array.from(TTS_ENGINES),
+  createSettingsStore,
+  getDefaultDataDir,
+  getSettingsPath,
+  loadSettings,
+  normalizeSettings,
+  saveSettings,
+  updateSettings
+};

package/packages/backend/src/speakable-filter.js

@@ -0,0 +1,251 @@
+const SPOKEN_HEADING =
+  /^[ \t]*(?:#{1,6}[ \t]*)?(?:\*\*|__)?[ \t]*Spoken[ \t]*:?[ \t]*(?:\*\*|__)?[ \t]*$/imu;
+const SECTION_HEADING =
+  /^[ \t]*(?:#{1,6}[ \t]*)?(?:\*\*|__)?[ \t]*(?:Displayed|Display|Details|Detail|Code|Commands?|Logs?|Output)[ \t]*:?[ \t]*(?:\*\*|__)?[ \t]*$/imu;
+const SEPARATOR_LINE = /^[ \t]*[=*_-]{3,}[ \t]*$/;
+const FENCED_BLOCK = /```[\s\S]*?```/g;
+const INLINE_CODE = /`([^`\n]{1,120})`/g;
+const TABLE_SEPARATOR = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+const TABLE_ROW = /^\s*\|.*\|\s*$/;
+const BULLET = /^\s*(?:[-*+]|\d+[.)])\s+/;
+const STACK_TRACE = /^\s*at\s+\S.*\([^)]+:\d+:\d+\)\s*$/;
+const LOG_LINE = /^\s*(?:\[[^\]]+\]\s*)?(?:TRACE|DEBUG|INFO|WARN|WARNING|ERROR|FATAL)\b/i;
+const DIFF_LINE = /^\s*(?:diff --git|index [a-f0-9]|@@\s|[-+]{3}\s|[-+](?![-+]))/;
+
+function filterSpeakableText(input) {
+  if (typeof input !== "string" || input.trim() === "") {
+    return skipResult();
+  }
+
+  const spoken = extractSpokenSection(input);
+  if (spoken) {
+    const text = styleSpokenText(normalizeSpeakableText(removeUnsafeBlocks(spoken)), {
+      maxSentences: 0
+    });
+    if (isSpeakable(text)) {
+      return {
+        shouldSpeak: true,
+        text,
+        reason: "spoken_section",
+        source: "spoken"
+      };
+    }
+  }
+
+  const text = styleSpokenText(normalizeSpeakableText(removeUnsafeBlocks(input)));
+  if (!isSpeakable(text)) {
+    return skipResult();
+  }
+
+  return {
+    shouldSpeak: true,
+    text,
+    reason: "speakable_text",
+    source: "prose"
+  };
+}
+
+function skipResult() {
+  return {
+    shouldSpeak: false,
+    text: "",
+    reason: "no_speakable_text",
+    source: "filtered"
+  };
+}
+
+function extractSpokenSection(input) {
+  const match = SPOKEN_HEADING.exec(input);
+  if (!match) {
+    return "";
+  }
+
+  const start = match.index + match[0].length;
+  const rest = input.slice(start);
+  const nextSection = SECTION_HEADING.exec(rest);
+  return (nextSection ? rest.slice(0, nextSection.index) : rest).trim();
+}
+
+function removeUnsafeBlocks(input) {
+  const withoutFences = input.replace(FENCED_BLOCK, "\n");
+  const lines = withoutFences.split(/\r?\n/);
+  const output = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+
+    if (isJsonBlockStart(line)) {
+      index = skipJsonBlock(lines, index);
+      continue;
+    }
+
+    if (isLongBulletListAt(lines, index)) {
+      index = skipLineRun(lines, index, (candidate) => BULLET.test(candidate));
+      continue;
+    }
+
+    if (shouldSkipLine(line)) {
+      continue;
+    }
+
+    output.push(line);
+  }
+
+  return stripInlineMarkdown(output.join("\n").replace(INLINE_CODE, "$1"));
+}
+
+function stripInlineMarkdown(input) {
+  return input
+    .replace(/`+/g, "")
+    .replace(/(\*\*|__)(.*?)\1/g, "$2")
+    .replace(/\*\*|__/g, "")
+    .replace(/~~/g, "")
+    .replace(/\*/g, "")
+    .replace(/^[ \t]*#{1,6}[ \t]*/gm, "")
+    .replace(/^[ \t]*>[ \t]?/gm, "")
+    .replace(/(^|[\s(])_([^_\n]+)_(?=[\s).,!?]|$)/g, "$1$2");
+}
+
+function shouldSkipLine(line) {
+  return (
+    SEPARATOR_LINE.test(line) ||
+    TABLE_SEPARATOR.test(line) ||
+    TABLE_ROW.test(line) ||
+    DIFF_LINE.test(line) ||
+    LOG_LINE.test(line) ||
+    STACK_TRACE.test(line) ||
+    looksLikeJsonLine(line)
+  );
+}
+
+function isLongBulletListAt(lines, start) {
+  if (!BULLET.test(lines[start])) {
+    return false;
+  }
+
+  let count = 0;
+  for (let index = start; index < lines.length && BULLET.test(lines[index]); index += 1) {
+    count += 1;
+  }
+
+  return count >= 6;
+}
+
+function skipLineRun(lines, start, predicate) {
+  let index = start;
+  while (index + 1 < lines.length && predicate(lines[index + 1])) {
+    index += 1;
+  }
+  return index;
+}
+
+function isJsonBlockStart(line) {
+  return /^\s*[{[]\s*$/.test(line);
+}
+
+function skipJsonBlock(lines, start) {
+  let depth = 0;
+
+  for (let index = start; index < lines.length; index += 1) {
+    const line = lines[index];
+    depth += countMatches(line, /[{[]/g);
+    depth -= countMatches(line, /[}\]]/g);
+
+    if (depth <= 0 && index > start) {
+      return index;
+    }
+  }
+
+  return start;
+}
+
+function countMatches(value, pattern) {
+  return (value.match(pattern) || []).length;
+}
+
+function looksLikeJsonLine(line) {
+  return /^\s*"[^"]+"\s*:/.test(line) || /^\s*[}\]],?\s*$/.test(line);
+}
+
+function normalizeSpeakableText(input) {
+  return input
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function styleSpokenText(input, options = {}) {
+  const maxSentences = Number.isInteger(options.maxSentences) ? options.maxSentences : 3;
+  let text = input
+    .replace(/\bHere is\b/gi, "Here's")
+    .replace(/\bHere are\b/gi, "Here are")
+    .replace(/\bI have\b/g, "I've")
+    .replace(/\bI am\b/g, "I'm")
+    .replace(/\bI will\b/g, "I'll")
+    .replace(/\bI would\b/g, "I'd")
+    .replace(/(^|[.!?]\s+)It is\b/g, "$1It's")
+    .replace(/(^|[.!?]\s+)That is\b/g, "$1That's")
+    .replace(/(^|[.!?]\s+)There is\b/g, "$1There's")
+    .replace(/\bdo not\b/gi, "don't")
+    .replace(/\bdoes not\b/gi, "doesn't")
+    .replace(/\bcannot\b/gi, "can't")
+    .replace(/\bwill not\b/gi, "won't")
+    .replace(/\bshould not\b/gi, "shouldn't")
+    .replace(/\bwould not\b/gi, "wouldn't")
+    .replace(/\bcould not\b/gi, "couldn't")
+    .replace(/\butilize\b/gi, "use")
+    .replace(/\bapproximately\b/gi, "about")
+    .replace(/\btherefore\b/gi, "so")
+    .replace(/\bhowever\b/gi, "but")
+    .replace(/\bcommence\b/gi, "start")
+    .replace(/\bterminate\b/gi, "stop")
+    .replace(/\bThe following\b/gi, "This")
+    .replace(/\bIn conclusion,\s*/gi, "")
+    .replace(/\bTo summarize,\s*/gi, "")
+    .replace(/\s+/g, " ")
+    .trim();
+
+  const trimmed = maxSentences > 0 ? keepFirstUsefulSentences(text, maxSentences) : text;
+  return capitalizeSentenceStarts(trimmed);
+}
+
+function keepFirstUsefulSentences(input, limit) {
+  const sentences = input.match(/[^.!?]+[.!?]+|[^.!?]+$/g) || [];
+  const kept = [];
+
+  for (const sentence of sentences) {
+    const clean = sentence.trim();
+    if (!clean) continue;
+    kept.push(clean);
+    if (kept.length >= limit) break;
+  }
+
+  return kept.join(" ").trim();
+}
+
+function capitalizeSentenceStarts(input) {
+  return input.replace(/(^|[.!?]\s+)([a-z])/g, (_match, prefix, letter) => {
+    return `${prefix}${letter.toUpperCase()}`;
+  });
+}
+
+function isSpeakable(text) {
+  if (!text) {
+    return false;
+  }
+
+  const wordCount = text.split(/\s+/).filter(Boolean).length;
+  if (wordCount < 4) {
+    return false;
+  }
+
+  return !/:\s*$/.test(text);
+}
+
+module.exports = {
+  filterSpeakableText,
+  styleSpokenText
+};