agentvibes 3.5.9 → 4.0.0

package/src/services/agent-voice-store.js

@@ -0,0 +1,163 @@
+/**
+ * AgentVibes Agent Voice Store
+ * Epic 11: Stories 11.1, 11.3, 11.5
+ *
+ * Manages global BMAD agent voice assignments at ~/.agentvibes/bmad-voice-map.json.
+ * All path operations use path.resolve() to prevent traversal.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Single-voice provider detection (story 11.3)
+
+/**
+ * Known providers that only have one voice (limits party mode usefulness).
+ */
+const SINGLE_VOICE_PROVIDERS = Object.freeze(new Set(['soprano']));
+
+/**
+ * Returns true if the given provider only has one voice.
+ * @param {string} provider
+ * @returns {boolean}
+ */
+export function isSingleVoiceProvider(provider) {
+  return SINGLE_VOICE_PROVIDERS.has(provider?.toLowerCase());
+}
+
+// ---------------------------------------------------------------------------
+// BMAD agent scanner (story 11.5)
+
+/**
+ * Scan for BMAD agents in the project root.
+ * Looks in `_bmad/bmm/agents/` then `.bmad/agents/`.
+ *
+ * @param {string} projectRoot
+ * @returns {{ id: string, displayName: string }[]}
+ */
+export function scanBmadAgents(projectRoot) {
+  const safeRoot = path.resolve(projectRoot ?? process.cwd());
+  const candidateDirs = [
+    path.resolve(safeRoot, '_bmad', 'bmm', 'agents'),
+    path.resolve(safeRoot, '.bmad', 'agents'),
+  ];
+
+  for (const dir of candidateDirs) {
+    if (!fs.existsSync(dir)) continue;
+    try {
+      const files = fs.readdirSync(dir);
+      return files
+        .filter(f => f.endsWith('.md') && !f.includes('.backup') && !f.includes('.bak'))
+        .map(f => {
+          const id = f.replace(/\.md$/, '');
+          const displayName = id
+            .split('-')
+            .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+            .join(' ');
+          return { id, displayName };
+        })
+        .sort((a, b) => a.id.localeCompare(b.id));
+    } catch {
+      // Directory not readable — skip
+    }
+  }
+  return [];
+}
+
+// ---------------------------------------------------------------------------
+// AgentVoiceStore class (story 11.1)
+
+export class AgentVoiceStore {
+  /**
+   * @param {object} [opts]
+   * @param {string} [opts.homeDir] - User home dir. Defaults to os.homedir().
+   */
+  constructor(opts = {}) {
+    this._homeDir = path.resolve(opts.homeDir ?? os.homedir());
+    this._filePath = path.resolve(this._homeDir, '.agentvibes', 'bmad-voice-map.json');
+  }
+
+  /**
+   * Read the full voice map.
+   * @returns {{ voiceMap: object, partyMode: boolean }}
+   */
+  _readStore() {
+    if (!fs.existsSync(this._filePath)) {
+      return { voiceMap: {}, partyMode: false };
+    }
+    try {
+      const raw = fs.readFileSync(this._filePath, 'utf8');
+      const data = JSON.parse(raw);
+      return {
+        voiceMap:  data.voiceMap  ?? {},
+        partyMode: data.partyMode ?? false,
+      };
+    } catch {
+      return { voiceMap: {}, partyMode: false };
+    }
+  }
+
+  /**
+   * Atomically write store data.
+   * @param {{ voiceMap: object, partyMode: boolean }} data
+   */
+  _writeStore(data) {
+    const dir = path.dirname(this._filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmpPath = `${this._filePath}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(tmpPath, this._filePath);
+    fs.chmodSync(this._filePath, 0o600);
+  }
+
+  /**
+   * Get the agent → voice ID map.
+   * @returns {object}
+   */
+  getVoiceMap() {
+    return this._readStore().voiceMap;
+  }
+
+  /**
+   * Assign a voice to an agent.
+   * @param {string} agentId
+   * @param {string} voiceId
+   */
+  setVoice(agentId, voiceId) {
+    const store = this._readStore();
+    store.voiceMap[agentId] = voiceId;
+    this._writeStore(store);
+  }
+
+  /**
+   * Remove an agent's voice assignment (reset to default).
+   * @param {string} agentId
+   */
+  resetVoice(agentId) {
+    const store = this._readStore();
+    delete store.voiceMap[agentId];
+    this._writeStore(store);
+  }
+
+  /**
+   * Get party mode state.
+   * @returns {boolean}
+   */
+  getPartyMode() {
+    return this._readStore().partyMode;
+  }
+
+  /**
+   * Set party mode state.
+   * @param {boolean} enabled
+   */
+  setPartyMode(enabled) {
+    const store = this._readStore();
+    store.partyMode = Boolean(enabled);
+    this._writeStore(store);
+  }
+}
+
+export default AgentVoiceStore;

package/src/services/config-service.js

@@ -0,0 +1,240 @@
+/**
+ * AgentVibes Config Service
+ * Story 6.5: Command Routing & Entry Points (isInstalled, isBmadDetected stubs)
+ * Story 7.1: Provider & Voice Settings Group (full read/write implementation)
+ *
+ * Provides config hierarchy: global (~/.agentvibes/config.json)
+ * + project-level overrides (<projectRoot>/.agentvibes/config.json).
+ * All path operations use path.resolve() to prevent traversal.
+ * Config writes are atomic (write .tmp → rename) with chmod 600.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export class ConfigService {
+  /**
+   * @param {object} [opts]
+   * @param {string} [opts.projectRoot] - Project root for hook/config detection. Defaults to process.cwd().
+   * @param {string} [opts.homeDir]     - User home dir for global config. Defaults to os.homedir().
+   */
+  constructor(opts = {}) {
+    // path.resolve() on all roots prevents path-traversal at the source
+    this._projectRoot = path.resolve(opts.projectRoot ?? process.cwd());
+    this._homeDir = path.resolve(opts.homeDir ?? os.homedir());
+  }
+
+  /** Returns the resolved project root path. */
+  getProjectRoot() {
+    return this._projectRoot;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Detection (story 6.5)
+
+  /**
+   * Returns true if AgentVibes hooks are installed in this project.
+   * Detection: .claude/hooks/play-tts.sh exists in projectRoot.
+   */
+  isInstalled() {
+    const hooksFile = path.resolve(this._projectRoot, '.claude', 'hooks', 'play-tts.sh');
+    return fs.existsSync(hooksFile);
+  }
+
+  /**
+   * Returns true if BMAD framework is detected.
+   * Checks: _bmad/ or .bmad/ in projectRoot, OR global voice map.
+   */
+  isBmadDetected() {
+    const checks = [
+      path.resolve(this._projectRoot, '_bmad'),
+      path.resolve(this._projectRoot, '.bmad'),
+      path.resolve(this._homeDir, '.agentvibes', 'bmad-voice-map.json'),
+    ];
+    return checks.some(p => fs.existsSync(p));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Read (story 7.1)
+
+  /**
+   * Returns global config (~/.agentvibes/config.json).
+   * Returns {} if file does not exist.
+   */
+  getGlobalConfig() {
+    const filePath = path.resolve(this._homeDir, '.agentvibes', 'config.json');
+    return this._readConfigFile(filePath) ?? {};
+  }
+
+  /**
+   * Returns project config (<projectRoot>/.agentvibes/config.json) or null if not present.
+   */
+  getProjectConfig() {
+    const dir = path.resolve(this._projectRoot, '.agentvibes');
+    if (!fs.existsSync(dir)) return null;
+    const filePath = path.resolve(dir, 'config.json');
+    return this._readConfigFile(filePath);
+  }
+
+  /**
+   * Returns merged config: global + project overrides.
+   * Project config keys win on conflict (deep merge for nested objects).
+   */
+  getConfig() {
+    const global = this.getGlobalConfig();
+    const project = this.getProjectConfig();
+    return this._deepMerge(global, project);
+  }
+
+  /**
+   * Returns config schema version from merged config.
+   */
+  getVersion() {
+    return this.getConfig().version ?? '1.0';
+  }
+
+  // ---------------------------------------------------------------------------
+  // Path helpers
+
+  /** Returns the resolved global config file path. */
+  getGlobalConfigPath() {
+    return path.resolve(this._homeDir, '.agentvibes', 'config.json');
+  }
+
+  /** Returns the resolved local project config file path (regardless of whether it exists). */
+  getLocalConfigPath() {
+    return path.resolve(this._projectRoot, '.agentvibes', 'config.json');
+  }
+
+  /** Returns true if a local project config file exists. */
+  hasLocalConfig() {
+    return fs.existsSync(this.getLocalConfigPath());
+  }
+
+  // ---------------------------------------------------------------------------
+  // Bulk save
+
+  /**
+   * Overwrites the ENTIRE global config with the given object.
+   * Atomic write (tmp → rename). Creates dir if needed. chmod 600.
+   * @param {object} data
+   */
+  saveAllToGlobal(data) {
+    this._writeConfigAtomic(this.getGlobalConfigPath(), data);
+  }
+
+  /**
+   * Overwrites the ENTIRE local project config with the given object.
+   * Atomic write (tmp → rename). Creates dir if needed. chmod 600.
+   * @param {object} data
+   */
+  saveAllToLocal(data) {
+    this._writeConfigAtomic(this.getLocalConfigPath(), data);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Write (story 7.1)
+
+  /**
+   * Writes a key to project config if <projectRoot>/.agentvibes/ exists,
+   * otherwise writes to global config. Atomic write (tmp → rename). chmod 600.
+   * @param {string} key
+   * @param {*} value
+   */
+  set(key, value) {
+    const projDir = path.resolve(this._projectRoot, '.agentvibes');
+    if (fs.existsSync(projDir)) {
+      const filePath = path.resolve(projDir, 'config.json');
+      const current = this._readConfigFile(filePath) ?? {};
+      current[key] = value;
+      this._writeConfigAtomic(filePath, current);
+    } else {
+      this.setGlobal(key, value);
+    }
+  }
+
+  /**
+   * Always writes a key to global config (~/.agentvibes/config.json).
+   * Atomic write (tmp → rename). chmod 600. Creates dir if needed.
+   * @param {string} key
+   * @param {*} value
+   */
+  setGlobal(key, value) {
+    const filePath = path.resolve(this._homeDir, '.agentvibes', 'config.json');
+    const current = this._readConfigFile(filePath) ?? {};
+    current[key] = value;
+    this._writeConfigAtomic(filePath, current);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private helpers
+
+  /**
+   * Read and parse a JSON config file.
+   * Returns null if the file does not exist or is not a regular file.
+   * @param {string} filePath
+   * @returns {object|null}
+   */
+  _readConfigFile(filePath) {
+    if (!fs.existsSync(filePath)) return null;
+    try {
+      const raw = fs.readFileSync(filePath, 'utf8');
+      return JSON.parse(raw);
+    } catch {
+      // Corrupt or unreadable — treat as missing
+      return null;
+    }
+  }
+
+  /**
+   * Deep-merge two plain objects. Values from `override` win on conflict.
+   * Arrays are replaced (not merged). null override → returns copy of base.
+   * @param {object} base
+   * @param {object|null} override
+   * @returns {object}
+   */
+  _deepMerge(base, override) {
+    if (!override || typeof override !== 'object') return { ...base };
+    const result = { ...base };
+    for (const [k, v] of Object.entries(override)) {
+      if (
+        v !== null &&
+        typeof v === 'object' &&
+        !Array.isArray(v) &&
+        typeof result[k] === 'object' &&
+        result[k] !== null &&
+        !Array.isArray(result[k])
+      ) {
+        result[k] = this._deepMerge(result[k], v);
+      } else {
+        result[k] = v;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Atomically write data as JSON to filePath.
+   * Writes to {filePath}.tmp then renames — safe against partial reads.
+   * Creates parent directory if needed. Sets file permissions to 0o600.
+   * @param {string} filePath
+   * @param {object} data
+   */
+  _writeConfigAtomic(filePath, data) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+
+    const tmpPath = `${filePath}.tmp`;
+    const json = JSON.stringify(data, null, 2);
+
+    // Write to tmp, then atomic rename
+    fs.writeFileSync(tmpPath, json, { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(tmpPath, filePath);
+
+    // Ensure correct permissions on final file
+    fs.chmodSync(filePath, 0o600);
+  }
+}
+
+export default ConfigService;

package/src/services/navigation-service.js

@@ -0,0 +1,123 @@
+/**
+ * AgentVibes TUI Console — Navigation Service
+ * Story 6.2: Tab Bar & Global Keyboard Navigation
+ *
+ * Manages tab state, cycling, modal overlay state, and focus stack.
+ * Used by navigation.js (key bindings) and app.js (wiring).
+ */
+
+/** Ordered list of all tab IDs — used for cycling and validation */
+export const TAB_ORDER = ['install', 'settings', 'voices', 'music', 'readme', 'help'];
+
+export class NavigationService {
+  /**
+   * @param {string} [initialTab='settings'] - Tab to activate on launch
+   */
+  constructor(initialTab = 'settings') {
+    this._activeTab = TAB_ORDER.includes(initialTab) ? initialTab : 'settings';
+    this._switchCallbacks = [];
+    this._focusStack = [];
+    this._modalOpen = false;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Tab navigation
+
+  /** Returns the currently active tab ID */
+  getActiveTab() {
+    return this._activeTab;
+  }
+
+  /**
+   * Switch to the given tab.
+   * Ignores invalid tab IDs. Fires all registered onSwitch callbacks.
+   * @param {string} tabId
+   */
+  switchTab(tabId) {
+    if (!TAB_ORDER.includes(tabId)) return;
+    if (tabId === this._activeTab) return; // no-op: already on this tab
+    this._activeTab = tabId;
+    this._switchCallbacks.forEach(cb => cb(tabId));
+  }
+
+  /**
+   * Activate a tab unconditionally, bypassing the same-tab no-op guard.
+   * Used for initial UI setup: the constructor pre-sets _activeTab but
+   * onSwitch callbacks must still fire to render the initial state.
+   * @param {string} tabId
+   */
+  forceActivate(tabId) {
+    if (!TAB_ORDER.includes(tabId)) return;
+    this._activeTab = tabId;
+    this._switchCallbacks.forEach(cb => cb(tabId));
+  }
+
+  /**
+   * Cycle to the next tab in TAB_ORDER, wrapping from last back to first.
+   */
+  cycleTab() {
+    const idx = TAB_ORDER.indexOf(this._activeTab);
+    const nextIdx = (idx + 1) % TAB_ORDER.length;
+    this.switchTab(TAB_ORDER[nextIdx]);
+  }
+
+  /**
+   * Cycle to the previous tab in TAB_ORDER, wrapping from first back to last.
+   */
+  cycleTabPrev() {
+    const idx = TAB_ORDER.indexOf(this._activeTab);
+    const prevIdx = (idx - 1 + TAB_ORDER.length) % TAB_ORDER.length;
+    this.switchTab(TAB_ORDER[prevIdx]);
+  }
+
+  /**
+   * Register a callback fired whenever the active tab changes.
+   * @param {(tabId: string) => void} callback
+   */
+  onSwitch(callback) {
+    this._switchCallbacks.push(callback);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Modal state (story 6.4 will expand this)
+
+  /** Returns true if a modal is currently open */
+  isModalOpen() {
+    return this._modalOpen;
+  }
+
+  /**
+   * Open a modal. Sets modal-open state and calls the factory fn if provided.
+   * @param {Function|null} fn - Optional factory/callback invoked immediately
+   */
+  openModal(fn) {
+    this._modalOpen = true;
+    fn?.();
+  }
+
+  /** Close the current modal, restoring modal-closed state */
+  closeModal() {
+    this._modalOpen = false;
+  }
+
+
+  // ---------------------------------------------------------------------------
+  // Focus stack (story 7.6 will use this for button-level focus)
+
+  /**
+   * Push a Blessed element onto the focus stack
+   * @param {object} element - Blessed widget
+   */
+  pushFocus(element) {
+    this._focusStack.push(element);
+  }
+
+  /**
+   * Pop the last element from the focus stack.
+   * Returns undefined if the stack is empty.
+   * @returns {object|undefined}
+   */
+  popFocus() {
+    return this._focusStack.pop();
+  }
+}

package/src/services/provider-service.js

@@ -0,0 +1,132 @@
+/**
+ * AgentVibes Provider Service
+ * Story 7.1: Provider & Voice Settings Group
+ *
+ * Detects installed TTS providers, reads/writes active provider and voice
+ * through ConfigService. Gracefully degrades when detection fails.
+ */
+
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export class ProviderService {
+  /**
+   * @param {import('./config-service.js').ConfigService} configService
+   */
+  constructor(configService) {
+    this._config = configService;
+    this._installedProviders = null; // cached after first detection
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider
+
+  /**
+   * Returns the currently active TTS provider from config.
+   * Defaults to 'piper' if not configured.
+   * @returns {string}
+   */
+  getActiveProvider() {
+    return this._config.getConfig().provider ?? 'piper';
+  }
+
+  /**
+   * Sets the active TTS provider in config AND syncs to .claude/tts-provider.txt
+   * so the shell hooks (play-tts.sh → provider-manager.sh) pick up the change.
+   * @param {string} provider
+   */
+  setActiveProvider(provider) {
+    this._config.set('provider', provider);
+    this._syncProviderFile(provider);
+  }
+
+  /**
+   * Write provider to .claude/tts-provider.txt so shell hooks stay in sync.
+   * Writes to projectRoot/.claude/tts-provider.txt if .claude/ exists there,
+   * otherwise falls back to ~/.claude/tts-provider.txt.
+   * @param {string} provider
+   */
+  _syncProviderFile(provider) {
+    try {
+      const projectClaudeDir = path.resolve(this._config.getProjectRoot(), '.claude');
+      const targetDir = fs.existsSync(projectClaudeDir)
+        ? projectClaudeDir
+        : path.resolve(os.homedir(), '.claude');
+      const targetFile = path.resolve(targetDir, 'tts-provider.txt');
+      // Verify resolved path stays within targetDir (path traversal guard)
+      if (!targetFile.startsWith(targetDir + path.sep) && targetFile !== targetDir) return;
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(targetFile, provider, 'utf8');
+    } catch {
+      // Non-fatal — config.json is the authoritative source
+    }
+  }
+
+  /**
+   * Returns an array of installed/available TTS providers.
+   * Detection uses `which` binary check. Always returns at least ['piper']
+   * as graceful degradation (piper is the primary supported provider).
+   * @returns {string[]}
+   */
+  getInstalledProviders() {
+    if (this._installedProviders) return this._installedProviders;
+
+    const providers = [];
+
+    if (this._isAvailable('piper')) providers.push('piper');
+    if (this._isAvailable('soprano')) providers.push('soprano');
+
+    // macOS Say (darwin only)
+    if (process.platform === 'darwin' && this._isAvailable('say')) {
+      providers.push('macos');
+    }
+
+    // Graceful degradation: always return at least piper
+    if (providers.length === 0) providers.push('piper');
+
+    this._installedProviders = providers;
+    return providers;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Voice
+
+  /**
+   * Returns the currently active voice ID from config.
+   * Defaults to 'en_US-amy-medium' if not configured.
+   * @returns {string}
+   */
+  getActiveVoiceId() {
+    return this._config.getConfig().voice ?? 'en_US-amy-medium';
+  }
+
+  /**
+   * Sets the active voice ID in config.
+   * @param {string} voiceId
+   */
+  setActiveVoice(voiceId) {
+    this._config.set('voice', voiceId);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private
+
+  /**
+   * Check if a binary is available in PATH using `which`.
+   * Binary names are all hardcoded (not user input) — safe from injection.
+   * @param {string} binary - hardcoded binary name ('piper', 'soprano', 'say')
+   * @returns {boolean}
+   */
+  _isAvailable(binary) {
+    try {
+      execFileSync('which', [binary], { stdio: 'ignore', timeout: 2000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export default ProviderService;