shmakk 1.1.0

package/src/setup-voice.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+// shmakk voice setup — checks all dependencies for --stt / --tts / --sts
+// Run via: npm run setup:voice  or  node src/setup-voice.js
+
+const { execSync } = require('child_process');
+
+const ok    = (s) => process.stdout.write(`  \x1b[32m✓\x1b[0m ${s}\n`);
+const warn  = (s) => process.stdout.write(`  \x1b[33m⚠\x1b[0m ${s}\n`);
+const fail  = (s) => process.stdout.write(`  \x1b[31m✗\x1b[0m ${s}\n`);
+const title = (s) => process.stdout.write(`\n\x1b[1m${s}\x1b[0m\n`);
+
+let allGood = true;
+
+function cmd(c) {
+  try {
+    return execSync(c, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 }).trim();
+  } catch { return null; }
+}
+
+title('shmakk voice setup check');
+
+// ── Node deps ────────────────────────────────────────────────────────────────
+title('Node.js optional dependencies');
+
+for (const dep of ['@huggingface/transformers', 'kokoro-js', 'wavefile']) {
+  try {
+    require.resolve(dep);
+    ok(dep);
+  } catch {
+    fail(`${dep} — not installed`);
+    allGood = false;
+  }
+}
+
+// ── System audio recorder ────────────────────────────────────────────────────
+title('Audio recorder (microphone input)');
+
+const recorders = ['rec', 'sox', 'ffmpeg', 'arecord'];
+let recorderFound = false;
+for (const r of recorders) {
+  if (cmd(`which ${r}`)) {
+    ok(`${r} found`);
+    recorderFound = true;
+    break;
+  }
+}
+if (!recorderFound) {
+  fail('No audio recorder found');
+  warn('Install sox:  sudo pacman -S sox        (Arch/EndeavourOS)');
+  warn('              sudo apt install sox       (Debian/Ubuntu)');
+  warn('              brew install sox           (macOS)');
+  allGood = false;
+}
+
+// ── System audio player ──────────────────────────────────────────────────────
+title('Audio player (TTS playback)');
+
+const players = ['paplay', 'aplay', 'afplay'];
+let playerFound = false;
+for (const p of players) {
+  if (cmd(`which ${p}`)) {
+    ok(`${p} found`);
+    playerFound = true;
+    break;
+  }
+}
+if (!playerFound) {
+  fail('No audio player found');
+  warn('Install:  sudo pacman -S libpulse        (Arch/EndeavourOS)');
+  allGood = false;
+}
+
+// ── Audio server ─────────────────────────────────────────────────────────────
+title('Audio server');
+
+const paInfo = cmd('pactl info');
+if (paInfo) {
+  const server = paInfo.match(/Server Name:\s*(.+)/)?.[1] || 'unknown';
+  ok(`Running: ${server}`);
+} else {
+  fail('PulseAudio/PipeWire not running');
+  warn('Start:  systemctl --user start pipewire-pulse');
+  allGood = false;
+}
+
+// ── Microphone ───────────────────────────────────────────────────────────────
+title('Microphone sources');
+
+const sources = cmd('pactl list sources short');
+if (sources) {
+  sources.split('\n').filter(Boolean).forEach(s => {
+    ok(s.trim().split('\t')[1] || s.trim());
+  });
+} else {
+  warn('Could not list audio sources');
+}
+
+// ── Summary ──────────────────────────────────────────────────────────────────
+process.stdout.write('\n');
+if (allGood) {
+  process.stdout.write('\x1b[32m\x1b[1m✓ All good! Try: shmakk --sts\x1b[0m\n\n');
+} else {
+  process.stdout.write('\x1b[33m\x1b[1m⚠ Issues found above. Fix them then re-run: npm run setup:voice\x1b[0m\n\n');
+  process.stdout.write('Quick fix (Arch/EndeavourOS):\n');
+  process.stdout.write('  sudo pacman -S sox\n');
+  process.stdout.write('  npm install --include=optional\n\n');
+  process.exit(1);
+}

package/src/shell.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+const path = require('path');
+
+function detectShell() {
+  const env = process.env.SHELL;
+  if (env && fs.existsSync(env)) {
+    return { path: env, name: path.basename(env) };
+  }
+  const fallbacks = ['/bin/bash', '/usr/bin/bash', '/bin/sh'];
+  for (const f of fallbacks) {
+    if (fs.existsSync(f)) return { path: f, name: path.basename(f) };
+  }
+  return { path: '/bin/sh', name: 'sh' };
+}
+
+function shellArgs(name) {
+  // Login + interactive so the user's normal init runs.
+  // We deliberately keep this minimal: do NOT inject rc files,
+  // do NOT alter prompt. Phase 2 will add hooks for command metadata.
+  switch (name) {
+    case 'fish':
+      return ['-i', '-l'];
+    case 'zsh':
+      return ['-i', '-l'];
+    case 'bash':
+      return ['-i', '-l'];
+    default:
+      return ['-i'];
+  }
+}
+
+module.exports = { detectShell, shellArgs };

package/src/skills.js

@@ -0,0 +1,309 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MAX_SKILL_BYTES = 64 * 1024;
+const DEFAULT_RENDER_BYTES = 12 * 1024;
+
+function safeName(name) {
+  return String(name || '').trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-');
+}
+
+function candidatePaths(name, cwd = process.cwd()) {
+  const n = safeName(name);
+  const home = os.homedir();
+  return [
+    path.join(cwd, '.claude', 'skills', `${n}.md`),
+    path.join(cwd, '.claude', 'skills', n, 'SKILL.md'),
+    path.join(cwd, '.codex', 'skills', `${n}.md`),
+    path.join(cwd, '.codex', 'skills', n, 'SKILL.md'),
+    path.join(home, '.claude', 'skills', `${n}.md`),
+    path.join(home, '.claude', 'skills', n, 'SKILL.md'),
+    path.join(home, '.codex', 'skills', `${n}.md`),
+    path.join(home, '.codex', 'skills', n, 'SKILL.md'),
+  ];
+}
+
+function stateDir(cwd = process.cwd()) {
+  return path.join(cwd, '.shmakk', 'state');
+}
+
+function skillsDir(cwd = process.cwd()) {
+  return path.join(cwd, '.shmakk', 'skills');
+}
+
+function registryPath(cwd = process.cwd()) {
+  return path.join(stateDir(cwd), 'skills-registry.json');
+}
+
+function activeSkillPath(cwd = process.cwd()) {
+  return path.join(stateDir(cwd), 'active-skill.json');
+}
+
+function ensureDirs(cwd = process.cwd()) {
+  fs.mkdirSync(stateDir(cwd), { recursive: true });
+  fs.mkdirSync(skillsDir(cwd), { recursive: true });
+}
+
+function sha256(s) {
+  return require('crypto').createHash('sha256').update(String(s || ''), 'utf8').digest('hex');
+}
+
+function parseFrontmatter(raw) {
+  const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/m.exec(String(raw || ''));
+  if (!m) return { meta: {}, body: String(raw || '') };
+  const meta = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const mm = /^([a-zA-Z0-9_-]+)\s*:\s*(.+)$/.exec(line.trim());
+    if (!mm) continue;
+    meta[mm[1].toLowerCase()] = mm[2].trim();
+  }
+  return { meta, body: m[2] };
+}
+
+function validateSkill(raw, sourcePath = '') {
+  const text = String(raw || '');
+  const issues = [];
+  if (!text.trim()) issues.push('empty skill content');
+  if (Buffer.byteLength(text, 'utf8') > MAX_SKILL_BYTES) issues.push(`skill exceeds ${MAX_SKILL_BYTES} bytes`);
+  if (!/^#\s+/m.test(text)) issues.push('missing markdown heading');
+  if (!/(instruction|rule|guideline|workflow|steps?|when to use|pattern|quick start|core concepts?)/i.test(text)) {
+    issues.push('no obvious instruction sections found');
+  }
+  if (/\b(ignore previous|bypass safety|exfiltrate|leak secret|disable security)\b/i.test(text)) {
+    issues.push('contains potentially unsafe instruction phrases');
+  }
+  const fm = parseFrontmatter(text);
+  const name = safeName(fm.meta.name || path.basename(sourcePath || '', path.extname(sourcePath || '')) || 'skill');
+  const version = String(fm.meta.version || '1').trim();
+  return {
+    ok: issues.length === 0,
+    issues,
+    normalizedName: name,
+    version,
+    body: fm.body,
+    raw: text,
+  };
+}
+
+function loadRegistry(cwd = process.cwd()) {
+  try {
+    const p = registryPath(cwd);
+    if (!fs.existsSync(p)) return { skills: {}, updatedAt: null };
+    const j = JSON.parse(fs.readFileSync(p, 'utf8'));
+    return { skills: j.skills || {}, updatedAt: j.updatedAt || null };
+  } catch {
+    return { skills: {}, updatedAt: null };
+  }
+}
+
+function saveRegistry(cwd, registry) {
+  ensureDirs(cwd);
+  const p = registryPath(cwd);
+  fs.writeFileSync(p, JSON.stringify({
+    skills: registry.skills || {},
+    updatedAt: new Date().toISOString(),
+  }, null, 2));
+}
+
+function loadSkillToWorkspace(name, cwd = process.cwd()) {
+  const n = safeName(name);
+  if (!n) return { ok: false, error: 'missing skill name' };
+  const found = candidatePaths(n, cwd).find((p) => fs.existsSync(p));
+  if (!found) {
+    return {
+      ok: false,
+      error: `skill not found: ${n}`,
+      searched: candidatePaths(n, cwd),
+    };
+  }
+
+  const raw = fs.readFileSync(found, 'utf8');
+  const validation = validateSkill(raw, found);
+  if (!validation.ok) {
+    return { ok: false, error: `skill failed validation: ${validation.issues.join('; ')}` };
+  }
+
+  ensureDirs(cwd);
+  const localSkillPath = path.join(skillsDir(cwd), `${validation.normalizedName}.md`);
+  fs.writeFileSync(localSkillPath, validation.raw, 'utf8');
+
+  const registry = loadRegistry(cwd);
+  const checksum = sha256(validation.raw);
+  registry.skills[validation.normalizedName] = {
+    name: validation.normalizedName,
+    version: validation.version,
+    source: found,
+    localPath: localSkillPath,
+    checksum,
+    bytes: Buffer.byteLength(validation.raw, 'utf8'),
+    loadedAt: new Date().toISOString(),
+    active: true,
+  };
+
+  for (const k of Object.keys(registry.skills)) {
+    if (k !== validation.normalizedName) registry.skills[k].active = false;
+  }
+
+  saveRegistry(cwd, registry);
+  fs.writeFileSync(activeSkillPath(cwd), JSON.stringify(registry.skills[validation.normalizedName], null, 2));
+
+  return { ok: true, name: validation.normalizedName, source: found, localPath: localSkillPath, version: validation.version };
+}
+
+function importSkillContent(raw, sourceLabel, cwd = process.cwd(), fallbackName = 'downloaded-skill') {
+  const validation = validateSkill(raw, sourceLabel);
+  if (!validation.ok) {
+    return { ok: false, error: `skill failed validation: ${validation.issues.join('; ')}` };
+  }
+
+  const name = validation.normalizedName || safeName(fallbackName) || 'downloaded-skill';
+  ensureDirs(cwd);
+  const localSkillPath = path.join(skillsDir(cwd), `${name}.md`);
+  fs.writeFileSync(localSkillPath, validation.raw, 'utf8');
+
+  const registry = loadRegistry(cwd);
+  registry.skills[name] = {
+    name,
+    version: validation.version,
+    source: sourceLabel,
+    localPath: localSkillPath,
+    checksum: sha256(validation.raw),
+    bytes: Buffer.byteLength(validation.raw, 'utf8'),
+    loadedAt: new Date().toISOString(),
+    active: true,
+  };
+  for (const k of Object.keys(registry.skills)) {
+    if (k !== name) registry.skills[k].active = false;
+  }
+  saveRegistry(cwd, registry);
+  fs.writeFileSync(activeSkillPath(cwd), JSON.stringify(registry.skills[name], null, 2));
+  return { ok: true, name, source: sourceLabel, localPath: localSkillPath, version: validation.version };
+}
+
+function readActiveSkill(cwd = process.cwd()) {
+  try {
+    const p = activeSkillPath(cwd);
+    if (!fs.existsSync(p)) return null;
+    const meta = JSON.parse(fs.readFileSync(p, 'utf8'));
+    if (!meta || !meta.localPath || !fs.existsSync(meta.localPath)) return null;
+    const content = fs.readFileSync(meta.localPath, 'utf8');
+    return { ...meta, content };
+  } catch {
+    return null;
+  }
+}
+
+function renderActiveSkillForPrompt(cwd = process.cwd(), maxBytes = DEFAULT_RENDER_BYTES) {
+  const skill = readActiveSkill(cwd);
+  if (!skill || !skill.content) return '';
+  const body = String(skill.content || '').slice(0, Math.max(1000, Number(maxBytes) || DEFAULT_RENDER_BYTES));
+  return `Active loaded skill (${skill.name}${skill.version ? ` v${skill.version}` : ''}) instructions:\n${body}`;
+}
+
+function listSkills(cwd = process.cwd()) {
+  const r = loadRegistry(cwd);
+  return Object.values(r.skills || {}).sort((a, b) => String(a.name).localeCompare(String(b.name)));
+}
+
+function unloadSkill(name, cwd = process.cwd()) {
+  const n = safeName(name);
+  const registry = loadRegistry(cwd);
+  const entry = registry.skills[n];
+  if (!entry) return { ok: false, error: `skill not found in registry: ${n}` };
+  delete registry.skills[n];
+  if (entry.localPath) {
+    try { fs.rmSync(entry.localPath, { force: true }); } catch {}
+  }
+  const active = readActiveSkill(cwd);
+  if (active && safeName(active.name) === n) {
+    try { fs.rmSync(activeSkillPath(cwd), { force: true }); } catch {}
+  }
+  saveRegistry(cwd, registry);
+  return { ok: true, name: n };
+}
+
+function skillStatus(cwd = process.cwd()) {
+  const active = readActiveSkill(cwd);
+  const all = listSkills(cwd);
+  return {
+    active: active ? {
+      name: active.name,
+      version: active.version || '1',
+      source: active.source,
+      loadedAt: active.loadedAt,
+      bytes: active.bytes || Buffer.byteLength(String(active.content || ''), 'utf8'),
+    } : null,
+    total: all.length,
+  };
+}
+
+async function installSkillFromUrl(url, cwd = process.cwd()) {
+  let u;
+  try { u = new URL(String(url || '')); } catch { return { ok: false, error: 'invalid URL' }; }
+  if (!/^https?:$/.test(u.protocol)) return { ok: false, error: 'only http(s) URLs are supported' };
+
+  async function resolveGitHubUrl(inputUrl) {
+    try {
+      const gu = new URL(inputUrl);
+      if (!/^(www\.)?github\.com$/i.test(gu.host)) return inputUrl;
+      const parts = gu.pathname.split('/').filter(Boolean);
+      // /owner/repo/tree/ref/path...
+      if (parts.length >= 5 && (parts[2] === 'tree' || parts[2] === 'blob')) {
+        const owner = parts[0];
+        const repo = parts[1];
+        const ref = parts[3];
+        const relPath = parts.slice(4).join('/');
+        if (parts[2] === 'blob') {
+          return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${relPath}`;
+        }
+        // tree: if direct markdown path, convert to raw
+        if (/\.(md|markdown)$/i.test(relPath)) {
+          return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${relPath}`;
+        }
+        // tree directory: discover SKILL.md first, then first markdown fallback
+        const api = `https://api.github.com/repos/${owner}/${repo}/contents/${relPath}?ref=${encodeURIComponent(ref)}`;
+        const resp = await fetch(api, { headers: { 'user-agent': 'shmakk-skill-installer/1.0' } });
+        if (!resp.ok) return inputUrl;
+        const arr = await resp.json();
+        if (!Array.isArray(arr)) return inputUrl;
+        const skillFile = arr.find((x) => x && x.type === 'file' && /^SKILL\.md$/i.test(String(x.name || '')) && x.download_url)
+          || arr.find((x) => x && x.type === 'file' && /\.(md|markdown)$/i.test(String(x.name || '')) && x.download_url);
+        return skillFile?.download_url || inputUrl;
+      }
+      return inputUrl;
+    } catch {
+      return inputUrl;
+    }
+  }
+
+  const resolvedUrl = await resolveGitHubUrl(u.href);
+  let finalUrl;
+  try { finalUrl = new URL(resolvedUrl); } catch { finalUrl = u; }
+
+  let text = '';
+  try {
+    const resp = await fetch(finalUrl.href, {
+      headers: { 'user-agent': 'shmakk-skill-installer/1.0' },
+    });
+    if (!resp.ok) return { ok: false, error: `download failed: HTTP ${resp.status}` };
+    text = await resp.text();
+  } catch (e) {
+    return { ok: false, error: `download failed: ${e.message}` };
+  }
+
+  const derived = safeName(path.basename(finalUrl.pathname || '', path.extname(finalUrl.pathname || '')) || 'downloaded-skill');
+  return importSkillContent(text, finalUrl.href, cwd, derived);
+}
+
+module.exports = {
+  loadSkillToWorkspace,
+  importSkillContent,
+  readActiveSkill,
+  renderActiveSkillForPrompt,
+  listSkills,
+  unloadSkill,
+  skillStatus,
+  installSkillFromUrl,
+  safeName,
+};

package/src/subagent.js

@@ -0,0 +1,42 @@
+// Auto-subagent planning pass. Runs short read-only sub-calls before the
+// main agent loop to scope work, identify risks, and outline a plan.
+// Extracted from agent.js.
+
+function shouldUseAutoSubagents(input, roots) {
+  if (String(process.env.SHMAKK_AUTO_SUBAGENTS || '1') === '0') return false;
+  const minLen = Math.max(40, Number(process.env.SHMAKK_AUTO_SUBAGENTS_MIN_INPUT_LEN) || 140);
+  const maxRoots = Math.max(1, Number(process.env.SHMAKK_AUTO_SUBAGENTS_MAX_ROOTS) || 2);
+  const s = String(input || '');
+  const broadSignals = /(large|across|multiple|refactor|architecture|investigate|analyz|codebase|project-wide|compare)/i.test(s);
+  return (s.length >= minLen && broadSignals) || (Array.isArray(roots) && roots.length >= maxRoots && s.length >= Math.floor(minLen * 0.7));
+}
+
+async function runAutoSubagents({ client, input, roots, signal }) {
+  const n = Math.max(1, Math.min(3, Number(process.env.SHMAKK_AUTO_SUBAGENTS_COUNT) || 2));
+  const focuses = [
+    'Scope and likely target files/modules',
+    'Risks, edge cases, and verification strategy',
+    'Concrete step-by-step implementation plan with minimal reads',
+  ].slice(0, n);
+
+  const out = [];
+  for (let i = 0; i < focuses.length; i++) {
+    try {
+      const r = await client.chat.completions.create({
+        model: process.env.SHMAKK_MODEL || 'gpt-4o-mini',
+        temperature: 0,
+        stream: false,
+        tool_choice: 'none',
+        messages: [
+          { role: 'system', content: `You are subagent ${i + 1}. Read-only planning only. No tool calls. Be concise.` },
+          { role: 'user', content: `Workspace roots: ${roots.join(', ')}\nTask: ${input}\nFocus: ${focuses[i]}\nReturn bullet points only.` },
+        ],
+      }, { signal });
+      const text = String(r.choices?.[0]?.message?.content || '').trim();
+      if (text) out.push(`Subagent ${i + 1} (${focuses[i]}):\n${text}`);
+    } catch {}
+  }
+  return out.join('\n\n');
+}
+
+module.exports = { shouldUseAutoSubagents, runAutoSubagents };