shmakk 1.1.0

package/src/safety.js

@@ -0,0 +1,77 @@
+const path = require('path');
+const os = require('os');
+
+// run-tool / shell-command danger patterns. Matched against the literal cmd
+// string the agent passes to `run`. If matched → 'unsafe' (always prompts).
+const DANGER_RE = new RegExp([
+  // privilege escalation
+  '\\bsudo\\b', '\\bsu\\s', '\\bdoas\\b', '\\bpkexec\\b',
+  // any deletion (recursive or not — user wants confirmation on every delete)
+  '\\brm\\b(?!\\s+--?(version|help))', '\\brmdir\\b', '\\bunlink\\b',
+  '\\btrash(-put)?\\b', '\\bgio\\s+trash\\b',
+  '\\bchmod\\s+-R\\b', '\\bchown\\s+-R\\b',
+  '\\bfind\\b[^\\n]*-delete\\b',
+  // disk / fs
+  '\\bmkfs\\b', '\\bdd\\s+if=', '\\bshred\\b', '\\bwipe\\b',
+  // pipe-to-shell
+  '\\|\\s*(sh|bash|zsh|fish)\\b',
+  // redirect into system paths
+  '>\\s*/(?!tmp|home|var/tmp|dev/null)',
+  // personal config / display state mutation (lessons learned)
+  '\\bsetxkbmap\\b', '\\blocalectl\\s+set\\b', '\\bgsettings\\s+set\\b',
+  '\\bxset\\b', '\\bxrandr\\b', '\\bchsh\\b', '\\bcrontab\\s+-r\\b',
+  '\\bsystemctl\\b(?!\\s+(status|cat|show|is-))', // status-y reads ok
+  '\\bgit\\s+config\\s+--global\\b',
+  // package manager: global / system installs run arbitrary code
+  '\\bnpm\\s+(i|install|add)\\s+(-g|--global)\\b',
+  '\\bpip\\d?\\s+install\\b', '\\bpipx\\s+install\\b',
+  '\\bcargo\\s+install\\b', '\\bgo\\s+install\\b', '\\bgem\\s+install\\b',
+  '\\bbrew\\s+install\\b',
+  '\\bapt(-get)?\\s+(install|remove|purge|upgrade|dist-upgrade)\\b',
+  '\\bdnf\\s+(install|remove|upgrade)\\b',
+  '\\bpacman\\s+-[A-Z]*[SR]\\b', '\\byay\\s+-S\\b', '\\bparu\\s+-S\\b',
+  '\\bzypper\\s+(in|install|rm|remove)\\b',
+].join('|'), 'i');
+
+function classifyRunCommand(cmd) {
+  if (!cmd) return 'safe';
+  return DANGER_RE.test(cmd) ? 'unsafe' : 'safe';
+}
+
+// Paths whose read OR write should always prompt (even in auto mode).
+// Match against the *resolved relative path* we present to the agent, plus
+// the absolute path so e.g. ~/.ssh works when workspace is ~.
+const SECRET_RE = [
+  /(^|\/)\.env(\..*)?$/,
+  /(^|\/)\.netrc$/,
+  /(^|\/)\.npmrc$/,
+  /(^|\/)\.pypirc$/,
+  /(^|\/)\.gem\/credentials$/,
+  /(^|\/)\.ssh(\/|$)/,
+  /(^|\/)\.gnupg(\/|$)/,
+  /(^|\/)\.aws(\/|$)/,
+  /(^|\/)\.kube\/config(\/|$)/,
+  /(^|\/)\.docker\/config\.json$/,
+  /(^|\/)\.config\/gh(\/|$)/,
+  /\.pem$/i,
+  /\.key$/i,
+  /(^|\/)id_(rsa|ed25519|dsa|ecdsa)(\.pub)?$/,
+  /(^|\/)credentials(\.json|\.yaml|\.yml)?$/i,
+];
+
+function isSecretPath(p) {
+  if (!p) return false;
+  return SECRET_RE.some((r) => r.test(p));
+}
+
+function workspaceWarning(workspace) {
+  if (!workspace) return null;
+  const r = path.resolve(workspace);
+  const home = os.homedir();
+  if (r === '/' || r === '/etc' || r === home) {
+    return `workspace is ${r} — that's broad. Consider \`shmakk --workspace <project-dir>\` to keep AI scope smaller.`;
+  }
+  return null;
+}
+
+module.exports = { classifyRunCommand, isSecretPath, workspaceWarning, DANGER_RE };

package/src/services/stt.js

@@ -0,0 +1,131 @@
+// Speech-to-text via Whisper ONNX using @huggingface/transformers.
+// No Python, no server — 100% JS, runs locally in-process.
+// Model auto-downloads on first use (~45MB quantized whisper-tiny).
+
+const path = require('path');
+const fs = require('fs');
+const { WaveFile } = require('wavefile');
+
+let _pipeline = null;
+let _instance = null;
+let _loadPromise = null;
+let _env = null;
+
+async function _ensureModel() {
+  if (_instance) return _instance;
+
+  // Prevent concurrent loads
+  if (_loadPromise) return _loadPromise;
+
+  _loadPromise = (async () => {
+    let mod;
+    try {
+      mod = await import('@huggingface/transformers');
+    } catch {
+      throw new Error(
+        'Voice deps not installed. Run: npm run setup:voice\n' +
+        'Or: npm install --include=optional'
+      );
+    }
+    _pipeline = mod.pipeline;
+    _env = mod.env;
+
+    // Allow cache dir override
+    if (process.env.SHMAKK_HF_CACHE) {
+      _env.cacheDir = process.env.SHMAKK_HF_CACHE;
+    }
+
+    // Don't spam progress to stdout
+    _env.allowLocalModels = false;
+
+    _instance = await _pipeline(
+      'automatic-speech-recognition',
+      'Xenova/whisper-base',
+    );
+    return _instance;
+  })();
+
+  return _loadPromise;
+}
+
+/**
+ * Decode a WAV file to a mono 16kHz Float32Array, the format
+ * required by the transformers.js Whisper pipeline in Node.js.
+ */
+function _wavToFloat32(audioPath) {
+  const buffer = fs.readFileSync(audioPath);
+  const wav = new WaveFile(buffer);
+
+  wav.toBitDepth('32f');
+  wav.toSampleRate(16000);
+
+  let audioData = wav.getSamples();
+
+  // If multi-channel, merge to mono
+  if (Array.isArray(audioData)) {
+    if (audioData.length > 1) {
+      const SCALING_FACTOR = Math.sqrt(2);
+      for (let i = 0; i < audioData[0].length; ++i) {
+        audioData[0][i] =
+          (SCALING_FACTOR * (audioData[0][i] + audioData[1][i])) / 2;
+      }
+    }
+    audioData = audioData[0];
+  }
+
+  // Ensure Float32Array (getSamples may return a regular Array)
+  if (!(audioData instanceof Float32Array)) {
+    audioData = new Float32Array(audioData);
+  }
+
+  return audioData;
+}
+
+/**
+ * Transcribe a WAV file to text.
+ * @param {string} audioPath - path to WAV audio file
+ * @param {object} [opts]
+ * @param {string} [opts.language] - ISO language code hint (e.g. "en")
+ * @returns {Promise<string>} transcribed text
+ */
+async function transcribe(audioPath, opts = {}) {
+  if (!fs.existsSync(audioPath)) {
+    throw new Error(`Audio file not found: ${audioPath}`);
+  }
+
+  const transcriber = await _ensureModel();
+
+  // Decode WAV to Float32Array — pipeline can't use AudioContext in Node.js.
+  // See https://huggingface.co/docs/transformers.js/guides/node-audio-processing
+  const audioData = _wavToFloat32(audioPath);
+
+  const kwargs = { language: opts.language || 'english' };
+
+  const result = await transcriber(audioData, kwargs);
+  return (result.text || '').trim();
+}
+
+/**
+ * Check if the STT model files are already cached locally.
+ * Used for pre-flight warnings.
+ */
+function isCached() {
+  try {
+    // @huggingface/transformers caches in ~/.cache/huggingface by default
+    const hfHome = process.env.HF_HOME
+      || process.env.XDG_CACHE_HOME
+      || path.join(require('os').homedir(), '.cache', 'huggingface');
+
+    // Whisper-tiny has at minimum the config and quantized ONNX models
+    const modelDir = path.join(
+      hfHome,
+      'transformers',
+      'models--Xenova--whisper-base',
+    );
+    return fs.existsSync(modelDir);
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { transcribe, isCached, _ensureModel };

package/src/services/tts.js

@@ -0,0 +1,307 @@
+// Text-to-speech via Kokoro ONNX using kokoro-js.
+// No Python, no server — 100% JS, runs locally in-process.
+// Model auto-downloads on first use (~334MB quantized Kokoro-82M).
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawn, spawnSync } = require('child_process');
+const { WaveFile } = require('wavefile');
+
+let _tts = null;
+let _loadPromise = null;
+// Track current speak operation for interrupt support
+let _currentSpeakCtrl = null;
+let _currentSpeakAborted = false;
+
+/**
+ * Stop any active TTS playback immediately.
+ * Kills the audio player process and cancels sentence streaming.
+ */
+function stopSpeaking() {
+  _currentSpeakAborted = true;
+  if (_currentSpeakCtrl) {
+    try { _currentSpeakCtrl.abort(); } catch {}
+    _currentSpeakCtrl = null;
+  }
+  // Also kill the raw audio player process
+  try { require('./voice')._setTtsProc(null); } catch {}
+}
+
+async function _ensureModel() {
+  if (_tts) return _tts;
+
+  if (_loadPromise) return _loadPromise;
+
+  _loadPromise = (async () => {
+    let KokoroTTS;
+    try {
+      ({ KokoroTTS } = require('kokoro-js'));
+    } catch {
+      throw new Error(
+        'Voice deps not installed. Run: npm run setup:voice\n' +
+        'Or: npm install --include=optional'
+      );
+    }
+    _tts = await KokoroTTS.from_pretrained(
+      'onnx-community/Kokoro-82M-v1.0-ONNX',
+      { dtype: process.env.SHMAKK_TTS_DTYPE || 'fp16' },
+    );
+    return _tts;
+  })();
+
+  return _loadPromise;
+}
+
+/**
+ * Pick a voice deterministically based on current time.
+ * Changes every 2-5 hours (varied per day) so it feels random but is consistent
+ * within a session. No state needed — pure function of wall-clock time.
+ */
+function _scheduleVoice(voices) {
+  const now = new Date();
+  const day = now.getFullYear() * 10000 + (now.getMonth() + 1) * 100 + now.getDate();
+
+  // Use day as seed to determine bucket sizes for this day (2-5h each)
+  // Simple LCG-style hash
+  const daySeed = (day * 2654435761) >>> 0;
+
+  // Build time buckets for the day using the day seed
+  let bucketStart = 0;
+  let bucket = 0;
+  let bucketSeed = daySeed;
+  const minuteOfDay = now.getHours() * 60 + now.getMinutes();
+
+  while (bucketStart < minuteOfDay) {
+    bucketSeed = (bucketSeed * 1664525 + 1013904223) >>> 0;
+    const bucketMinutes = 120 + (bucketSeed % 180); // 2h to 5h in minutes
+    if (bucketStart + bucketMinutes > minuteOfDay) break;
+    bucketStart += bucketMinutes;
+    bucket++;
+  }
+
+  // Pick voice from bucket + day seed
+  const voiceSeed = (daySeed ^ (bucket * 2246822519)) >>> 0;
+  return voices[voiceSeed % voices.length].id;
+}
+
+/**
+ * List available Kokoro voices.
+ * @returns {Promise<Array<{id: string, name: string, language: string, gender: string}>>}
+ */
+async function listVoices() {
+  const tts = await _ensureModel();
+  const voices = [];
+  for (const [id, meta] of Object.entries(tts.voices)) {
+    voices.push({
+      id,
+      name: meta.name || id,
+      language: meta.language || 'unknown',
+      gender: (meta.gender || '').toLowerCase(),
+    });
+  }
+  return voices;
+}
+
+/**
+ * Write a Float32Array as a WAV file.
+ */
+function _writeWav(floatData, sampleRate, outputPath) {
+  const wav = new WaveFile();
+  wav.fromScratch(1, sampleRate, '32f', floatData);
+  fs.writeFileSync(outputPath, wav.toBuffer());
+}
+
+/**
+ * Generate speech from text.
+ *
+ * @param {string} text - text to speak
+ * @param {object} [opts]
+ * @param {string} [opts.voice] - voice name (default: "af_heart")
+ * @param {string} [opts.outputPath] - WAV output path (default: temp file)
+ * @returns {Promise<{audioPath: string, voice: string}>}
+ */
+async function generate(text, opts = {}) {
+  if (!text || !text.trim()) {
+    throw new Error('Empty text for TTS');
+  }
+
+  const voice = opts.voice || process.env.SHMAKK_TTS_VOICE || 'af_heart';
+  const tts = await _ensureModel();
+
+  // Validate voice
+  if (!tts.voices[voice]) {
+    // Try to find a matching voice (case-insensitive)
+    const lower = voice.toLowerCase();
+    const match = Object.keys(tts.voices).find(
+      (v) => v.toLowerCase() === lower,
+    );
+    if (match) {
+      opts.voice = match;
+    } else {
+      const available = Object.keys(tts.voices).slice(0, 8).join(', ');
+      throw new Error(
+        `Unknown voice: ${voice}. Available: ${available}...`,
+      );
+    }
+  }
+
+  const speed = parseFloat(opts.speed || process.env.SHMAKK_TTS_SPEED || '1.5');
+  const result = await tts.generate(text, { voice: opts.voice || voice, speed });
+
+  // result is a RawAudio with .audio (Float32Array) and .sampling_rate
+  const audioData = result.audio;
+  const sampleRate = result.sampling_rate || 24000;
+
+  const outPath =
+    opts.outputPath ||
+    path.join(os.tmpdir(), `shmakk-tts-${Date.now()}.wav`);
+
+  _writeWav(audioData, sampleRate, outPath);
+  return { audioPath: outPath, voice: opts.voice || voice };
+}
+
+/**
+ * Check whether a system audio player is available.
+ */
+function playerAvailable(name) {
+  try {
+    const r = spawnSync('which', [name], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2000,
+    });
+    return r.status === 0 && r.stdout && r.stdout.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Play a WAV file through system audio.
+ * Detects aplay (ALSA), paplay (PulseAudio), afplay (macOS).
+ * Returns true if a player was found and launched.
+ */
+function playAudio(audioPath) {
+  if (!fs.existsSync(audioPath)) {
+    throw new Error(`Audio file not found: ${audioPath}`);
+  }
+
+  let cmd, args;
+
+  // macOS
+  if (playerAvailable('afplay')) {
+    cmd = 'afplay';
+    args = [audioPath];
+  }
+
+  // Linux: PulseAudio
+  if (!cmd && playerAvailable('paplay')) {
+    cmd = 'paplay';
+    args = [audioPath];
+  }
+
+  // Linux: ALSA
+  if (!cmd && playerAvailable('aplay')) {
+    cmd = 'aplay';
+    args = ['-q', audioPath];
+  }
+
+  if (!cmd) {
+    return Promise.resolve(false);
+  }
+
+  return new Promise((resolve) => {
+    const proc = spawn(cmd, args, {
+      stdio: 'ignore',
+    });
+    // Track in voice.js for Ctrl+C interrupt kill
+    try { require('./voice')._setTtsProc(proc); } catch {}
+    proc.on('exit', () => {
+      try { require('./voice')._setTtsProc(null); } catch {}
+      resolve(true);
+    });
+    proc.on('error', () => {
+      try { require('./voice')._setTtsProc(null); } catch {}
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Split text into sentences for streaming TTS.
+ */
+function splitSentences(text) {
+  return text
+    .split(/(?<=[.!?])\s+|\n+/)
+    .map(s => s.trim())
+    .filter(s => s.length > 0);
+}
+
+/**
+ * Speak text sentence by sentence — first sentence starts playing
+ * immediately while the rest are generated, cutting perceived latency.
+ * Returns a promise that resolves when all audio is queued.
+ */
+async function speakStreaming(text, opts = {}) {
+  // Cancel any previous speak operation still in progress
+  stopSpeaking();
+  _currentSpeakAborted = false;
+  _currentSpeakCtrl = new AbortController();
+  const signal = _currentSpeakCtrl.signal;
+
+  const tts = await _ensureModel();
+  const voices = Object.keys(tts.voices);
+  // Use scheduled voice unless explicitly overridden via env or opts
+  const voice = opts.voice
+    || process.env.SHMAKK_TTS_VOICE
+    || _scheduleVoice(voices.map(id => ({ id })));
+  const sentences = splitSentences(text);
+  if (!sentences.length) return;
+
+  // Generate and play each sentence sequentially but start playing
+  // the first one as soon as it's ready without waiting for the rest.
+  for (const sentence of sentences) {
+    // Check if interrupted before each sentence
+    if (signal.aborted || _currentSpeakAborted) break;
+    const { _isTtsKilled } = require('./voice');
+    if (_isTtsKilled && _isTtsKilled()) break;
+    try {
+      const { audioPath } = await generate(sentence, { voice });
+      if (signal.aborted || _currentSpeakAborted) {
+        try { fs.unlinkSync(audioPath); } catch {}
+        break;
+      }
+      await playAudio(audioPath);
+      // Clean up after a delay
+      setTimeout(() => { try { fs.unlinkSync(audioPath); } catch {} }, 10000);
+    } catch {}
+  }
+  _currentSpeakCtrl = null;
+}
+
+async function speak(text, opts = {}) {
+  return speakStreaming(text, opts);
+}
+
+/**
+ * Check whether model files are cached locally.
+ */
+function isCached() {
+  try {
+    const hfHome =
+      process.env.HF_HOME ||
+      process.env.XDG_CACHE_HOME ||
+      path.join(os.homedir(), '.cache', 'huggingface');
+
+    const modelDir = path.join(
+      hfHome,
+      'transformers',
+      'models--onnx-community--Kokoro-82M-v1.0-ONNX',
+    );
+    return fs.existsSync(modelDir);
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { generate, speak, speakStreaming, playAudio, listVoices, isCached, stopSpeaking };