shmakk 1.1.0

package/src/completions.js

@@ -0,0 +1,167 @@
+// Shell tab-completion scripts for shmakk.
+//
+// Generate with:
+//   shmakk --completion bash  > ~/.shmakk-completion.bash && source ~/.shmakk-completion.bash
+//   shmakk --completion zsh   > ~/.shmakk-completion.zsh  && source ~/.shmakk-completion.zsh
+//   shmakk --completion fish  > ~/.config/fish/completions/shmakk.fish
+//
+// For permanent install:
+//   bash: echo 'source ~/.shmakk-completion.bash' >> ~/.bashrc
+//   zsh:  echo 'source ~/.shmakk-completion.zsh'  >> ~/.zshrc
+
+// All known flags in one place so the completion scripts stay in sync.
+const FLAGS = [
+  // booleans (no argument)
+  { flag: '--review', arg: false, desc: 'Review mode (confirm every AI action)' },
+  { flag: '--yes-files', arg: false, desc: 'Auto-accept AI file writes/edits' },
+  { flag: '--no-ai', arg: false, desc: 'Disable AI entirely (pure passthrough)' },
+  { flag: '--no-correction', arg: false, desc: 'Disable command correction' },
+  { flag: '--help', arg: false, desc: 'Show help' },
+  { flag: '--debug', arg: false, desc: 'Verbose logging' },
+  { flag: '--print-config', arg: false, desc: 'Print resolved config and exit' },
+  { flag: '--update-command-glossary', arg: false, desc: 'Scan PATH and build command glossary' },
+  { flag: '--status', arg: false, desc: 'Show whether inside shmakk' },
+  { flag: '--stats', arg: false, desc: 'Show session/task stats' },
+  { flag: '--compact', arg: false, desc: 'Clear conversation + task journal' },
+  { flag: '--list-skills', arg: false, desc: 'List registered local skills' },
+  { flag: '--skill-status', arg: false, desc: 'Show active skill and registry status' },
+  { flag: '--resume-status', arg: false, desc: 'Show task journal summary' },
+  { flag: '--exit', arg: false, desc: 'Cleanly exit parent shmakk' },
+  { flag: '--restart', arg: false, desc: 'Restart inner shell' },
+  { flag: '--reset', arg: false, desc: 'Clear AI conversation history' },
+  { flag: '--stt', arg: false, desc: 'Speech-to-Text: mic → text input' },
+  { flag: '--tts', arg: false, desc: 'Text-to-Speech: spoken responses' },
+  { flag: '--sts', arg: false, desc: 'Speech-to-Speech: always-on mic + TTS' },
+  { flag: '--voice', arg: false, desc: 'Enable voice input (stt shortcut)' },
+
+  // flags with arguments
+  { flag: '--workspace', arg: '<path>', desc: 'Override workspace root' },
+  { flag: '--profile', arg: '<name>', desc: 'Startup profile (tiny|balanced|deep|builder|large-app)' },
+  { flag: '--profile-set', arg: '<name>', desc: 'Switch profile and restart' },
+  { flag: '--endpoint', arg: '<name>', desc: 'Use endpoint preset from .shmakk/endpoints.json' },
+  { flag: '--colors', arg: '<true|false>', desc: 'Toggle ANSI colors' },
+  { flag: '--load-skill', arg: '<name>', desc: 'Load a skill into workspace state' },
+  { flag: '--unload-skill', arg: '<name>', desc: 'Remove skill from registry' },
+  { flag: '--install-skill', arg: '<url>', desc: 'Download and install skill from URL' },
+  { flag: '--build-history', arg: '[files...]', desc: 'Parse shell history for frequency map' },
+  { flag: '--completion', arg: '<bash|zsh|fish>', desc: 'Output shell completion script' },
+  // voice tunables
+  { flag: '--voice-language', arg: '<code>', desc: 'Language hint (en, es, fr)' },
+  { flag: '--voice-max-sec', arg: '<sec>', desc: 'Max recording seconds' },
+  { flag: '--voice-silence-sec', arg: '<sec>', desc: 'VAD silence before stopping' },
+  { flag: '--voice-silence-threshold', arg: '<%>', desc: 'VAD amplitude threshold' },
+  { flag: '--voice-silence-start-sec', arg: '<sec>', desc: 'Sound before recording starts' },
+  { flag: '--voice-pad-start-sec', arg: '<sec>', desc: 'Padding before recording' },
+  { flag: '--tts-voice', arg: '<name>', desc: 'Override Kokoro voice' },
+];
+
+function bash() {
+  const lines = [];
+  lines.push('# shmakk bash completion');
+  lines.push('_shmakk_completion() {');
+  lines.push('  local cur prev words cword');
+  lines.push('  _init_completion || return');
+  lines.push('');
+  lines.push('  case $prev in');
+
+  for (const f of FLAGS) {
+    if (!f.arg) continue;
+    // flags that take an arg
+    lines.push(`    ${f.flag})`);
+    if (f.flag === '--profile' || f.flag === '--profile-set') {
+      lines.push('      COMPREPLY=($(compgen -W "tiny balanced deep builder large-app" -- "$cur"))');
+      lines.push('      return');
+    } else if (f.flag === '--completion') {
+      lines.push('      COMPREPLY=($(compgen -W "bash zsh fish" -- "$cur"))');
+      lines.push('      return');
+    } else if (f.flag === '--colors') {
+      lines.push('      COMPREPLY=($(compgen -W "true false" -- "$cur"))');
+      lines.push('      return');
+    } else {
+      lines.push('      COMPREPLY=()');
+      lines.push('      return');
+    }
+    lines.push('      ;;');
+  }
+
+  lines.push('  esac');
+  lines.push('');
+  lines.push('  # complete flags');
+  const flagNames = FLAGS.map((f) => f.flag).join(' ');
+  lines.push(`  COMPREPLY=($(compgen -W "${flagNames}" -- "$cur"))`);
+  lines.push('}');
+  lines.push('');
+  lines.push('complete -F _shmakk_completion shmakk');
+  return lines.join('\n') + '\n';
+}
+
+function zsh() {
+  const lines = [];
+  lines.push('#compdef shmakk');
+  lines.push('');
+  lines.push('_shmakk() {');
+  lines.push('  local -a flags_bool flags_arg');
+  lines.push('');
+
+  const bools = FLAGS.filter((f) => !f.arg).map((f) => f.flag);
+  lines.push(`  flags_bool=(${bools.map((f) => `"${f}"`).join(' ')})`);
+
+  const withArgs = FLAGS.filter((f) => f.arg);
+  lines.push(`  flags_arg=(${withArgs.map((f) => `"${f.flag}"`).join(' ')})`);
+
+  lines.push('');
+  lines.push('  _arguments -s \\');
+  for (const f of FLAGS) {
+    if (!f.arg) {
+      lines.push(`    "${f.flag}[${f.desc}]" \\`);
+    } else if (f.flag === '--profile' || f.flag === '--profile-set') {
+      lines.push(`    "${f.flag}[${f.desc}]:profile:(tiny balanced deep builder large-app)" \\`);
+    } else if (f.flag === '--completion') {
+      lines.push(`    "${f.flag}[${f.desc}]:shell:(bash zsh fish)" \\`);
+    } else if (f.flag === '--colors') {
+      lines.push(`    "${f.flag}[${f.desc}]:value:(true false)" \\`);
+    } else {
+      lines.push(`    "${f.flag}[${f.desc}]: :" \\`);
+    }
+  }
+
+  lines.push('    && return 0');
+  lines.push('}');
+  lines.push('');
+  lines.push('_shmakk');
+  return lines.join('\n') + '\n';
+}
+
+function fish() {
+  const lines = [];
+  lines.push('# shmakk fish completion');
+  lines.push('');
+
+  for (const f of FLAGS) {
+    if (!f.arg) {
+      lines.push(`complete -c shmakk -l ${f.flag.slice(2)} -d '${f.desc}'`);
+    } else if (f.flag === '--profile' || f.flag === '--profile-set') {
+      lines.push(`complete -c shmakk -l ${f.flag.slice(2)} -d '${f.desc}' -xa 'tiny balanced deep builder large-app'`);
+    } else if (f.flag === '--completion') {
+      lines.push(`complete -c shmakk -l ${f.flag.slice(2)} -d '${f.desc}' -xa 'bash zsh fish'`);
+    } else if (f.flag === '--colors') {
+      lines.push(`complete -c shmakk -l ${f.flag.slice(2)} -d '${f.desc}' -xa 'true false'`);
+    } else {
+      // arg but no specific completions
+      lines.push(`complete -c shmakk -l ${f.flag.slice(2)} -d '${f.desc}' -r`);
+    }
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+function generate(shell) {
+  switch (shell) {
+    case 'bash': return bash();
+    case 'zsh': return zsh();
+    case 'fish': return fish();
+    default: throw new Error(`unknown shell: ${shell}. Use: bash, zsh, fish`);
+  }
+}
+
+module.exports = { generate, FLAGS };

package/src/control.js

@@ -0,0 +1,250 @@
+// Control commands run from *inside* an shmakk session (the orchestrator
+// puts its own PID in SHMAKK_PID for the child shell's environment).
+
+function getParentPid() {
+  const pid = parseInt(process.env.SHMAKK_PID || '0', 10);
+  return pid > 0 ? pid : 0;
+}
+
+function profileSignalPath(pid) {
+  return `/tmp/shmakk-profile-${pid}.txt`;
+}
+
+function taskJournalPath(cwd = process.cwd()) {
+  return require('path').join(cwd, '.shmakk', 'state', 'task-journal.json');
+}
+
+function activeSkillMetaPath(cwd = process.cwd()) {
+  return require('path').join(cwd, '.shmakk', 'state', 'active-skill.json');
+}
+
+function isAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function status() {
+  const pid = getParentPid();
+  if (!pid) {
+    process.stdout.write('shmakk: not running (this terminal is not inside shmakk)\n');
+    return 1;
+  }
+  if (!isAlive(pid)) {
+    process.stdout.write(`shmakk: stale SHMAKK_PID=${pid} (parent not alive)\n`);
+    return 2;
+  }
+  process.stdout.write(`shmakk: running, parent pid ${pid}\n`);
+  return 0;
+}
+
+function exitParent() {
+  const pid = getParentPid();
+  if (!pid || !isAlive(pid)) {
+    process.stderr.write('shmakk --exit: not inside an shmakk session\n');
+    return 1;
+  }
+  try { process.kill(pid, 'SIGTERM'); } catch (e) {
+    process.stderr.write(`shmakk --exit: ${e.message}\n`); return 1;
+  }
+  return 0;
+}
+
+function restartParent() {
+  const pid = getParentPid();
+  if (!pid || !isAlive(pid)) {
+    process.stderr.write('shmakk --restart: not inside an shmakk session\n');
+    return 1;
+  }
+  try { process.kill(pid, 'SIGUSR1'); } catch (e) {
+    process.stderr.write(`shmakk --restart: ${e.message}\n`); return 1;
+  }
+  return 0;
+}
+
+function resetConversation() {
+  const pid = getParentPid();
+  if (!pid || !isAlive(pid)) {
+    process.stderr.write('shmakk --reset: not inside an shmakk session\n');
+    return 1;
+  }
+  try { process.kill(pid, 'SIGUSR2'); } catch (e) {
+    process.stderr.write(`shmakk --reset: ${e.message}\n`); return 1;
+  }
+  return 0;
+}
+
+function setProfileAndRestart(profileName) {
+  const pid = getParentPid();
+  if (!pid || !isAlive(pid)) {
+    process.stderr.write('shmakk --profile-set: not inside an shmakk session\n');
+    return 1;
+  }
+  const name = String(profileName || '').trim().toLowerCase();
+  if (!name) {
+    process.stderr.write('shmakk --profile-set: missing profile name\n');
+    return 1;
+  }
+  try {
+    require('fs').writeFileSync(profileSignalPath(pid), name + '\n', 'utf8');
+    process.kill(pid, 'SIGUSR1');
+  } catch (e) {
+    process.stderr.write(`shmakk --profile-set: ${e.message}\n`);
+    return 1;
+  }
+  return 0;
+}
+
+function resumeStatus() {
+  const p = taskJournalPath();
+  try {
+    const fs = require('fs');
+    if (!fs.existsSync(p)) {
+      process.stdout.write('shmakk: no resume journal found\n');
+      return 0;
+    }
+    const j = JSON.parse(fs.readFileSync(p, 'utf8'));
+    process.stdout.write('shmakk resume status\n');
+    process.stdout.write('--------------------\n');
+    process.stdout.write(`status: ${j.status || 'unknown'}\n`);
+    process.stdout.write(`profile: ${j.profile || 'unknown'}\n`);
+    process.stdout.write(`updated: ${j.updatedAt || 'unknown'}\n`);
+    process.stdout.write(`input: ${String(j.input || '').slice(0, 120)}\n`);
+    process.stdout.write(`touched_files: ${Array.isArray(j.touchedFiles) ? j.touchedFiles.length : 0}\n`);
+    return 0;
+  } catch (e) {
+    process.stderr.write(`shmakk --resume-status: ${e.message}\n`);
+    return 1;
+  }
+}
+
+function compactContext() {
+  const pid = getParentPid();
+  if (pid && isAlive(pid)) {
+    try { process.kill(pid, 'SIGUSR2'); } catch (e) {
+      process.stderr.write(`shmakk --compact: ${e.message}\n`);
+      return 1;
+    }
+    process.stdout.write('shmakk: compact requested (conversation + task journal cleared)\n');
+    return 0;
+  }
+
+  try {
+    const fs = require('fs');
+    fs.rmSync(taskJournalPath(), { force: true });
+    process.stdout.write('shmakk: compacted local task journal (no active session)\n');
+    return 0;
+  } catch (e) {
+    process.stderr.write(`shmakk --compact: ${e.message}\n`);
+    return 1;
+  }
+}
+
+function stats() {
+  const fs = require('fs');
+  const audit = require('./audit');
+  const pid = getParentPid();
+  const running = !!(pid && isAlive(pid));
+  let journal = null;
+  let activeSkill = null;
+  let auditLines = 0;
+
+  try {
+    const p = taskJournalPath();
+    if (fs.existsSync(p)) journal = JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {}
+  try {
+    const p = activeSkillMetaPath();
+    if (fs.existsSync(p)) activeSkill = JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {}
+  try {
+    const p = audit.logPath();
+    if (fs.existsSync(p)) auditLines = fs.readFileSync(p, 'utf8').split(/\r?\n/).filter(Boolean).length;
+  } catch {}
+
+  process.stdout.write('shmakk stats\n');
+  process.stdout.write('-----------\n');
+  process.stdout.write(`session_running: ${running ? 'yes' : 'no'}\n`);
+  process.stdout.write(`session_pid: ${running ? pid : 'n/a'}\n`);
+  process.stdout.write(`resume_status: ${journal?.status || 'none'}\n`);
+  process.stdout.write(`resume_updated: ${journal?.updatedAt || 'n/a'}\n`);
+  process.stdout.write(`resume_touched_files: ${Array.isArray(journal?.touchedFiles) ? journal.touchedFiles.length : 0}\n`);
+  process.stdout.write(`profile: ${journal?.profile || 'n/a'}\n`);
+  process.stdout.write(`active_skill: ${activeSkill?.name || 'none'}\n`);
+  process.stdout.write(`active_skill_loaded_at: ${activeSkill?.loadedAt || 'n/a'}\n`);
+  process.stdout.write(`audit_events_total: ${auditLines}\n`);
+  process.stdout.write('token_stats: unavailable (provider usage streaming not persisted yet)\n');
+  return 0;
+}
+
+function loadSkill(name) {
+  const { loadSkillToWorkspace } = require('./skills');
+  const res = loadSkillToWorkspace(name, process.cwd());
+  if (!res.ok) {
+    process.stderr.write(`shmakk --load-skill: ${res.error}\n`);
+    if (res.searched) process.stderr.write(`searched:\n- ${res.searched.join('\n- ')}\n`);
+    return 1;
+  }
+  process.stdout.write(`shmakk: loaded skill '${res.name}'\n`);
+  process.stdout.write(`source: ${res.source}\n`);
+  process.stdout.write(`local: ${res.localPath}\n`);
+  return 0;
+}
+
+function listSkills() {
+  const { listSkills: ls } = require('./skills');
+  const all = ls(process.cwd());
+  if (!all.length) {
+    process.stdout.write('shmakk: no skills loaded in registry\n');
+    return 0;
+  }
+  process.stdout.write('shmakk skills\n');
+  process.stdout.write('------------\n');
+  for (const s of all) {
+    process.stdout.write(`- ${s.name}${s.version ? ` v${s.version}` : ''}${s.active ? ' [active]' : ''}\n`);
+  }
+  return 0;
+}
+
+function skillStatus() {
+  const { skillStatus: ss } = require('./skills');
+  const st = ss(process.cwd());
+  process.stdout.write('shmakk skill status\n');
+  process.stdout.write('------------------\n');
+  process.stdout.write(`total: ${st.total}\n`);
+  if (!st.active) {
+    process.stdout.write('active: none\n');
+    return 0;
+  }
+  process.stdout.write(`active: ${st.active.name}\n`);
+  process.stdout.write(`version: ${st.active.version}\n`);
+  process.stdout.write(`loaded_at: ${st.active.loadedAt || 'n/a'}\n`);
+  process.stdout.write(`bytes: ${st.active.bytes || 0}\n`);
+  process.stdout.write(`source: ${st.active.source || 'n/a'}\n`);
+  return 0;
+}
+
+function unloadSkill(name) {
+  const { unloadSkill: us } = require('./skills');
+  const res = us(name, process.cwd());
+  if (!res.ok) {
+    process.stderr.write(`shmakk --unload-skill: ${res.error}\n`);
+    return 1;
+  }
+  process.stdout.write(`shmakk: unloaded skill '${res.name}'\n`);
+  return 0;
+}
+
+async function installSkill(url) {
+  const { installSkillFromUrl } = require('./skills');
+  const res = await installSkillFromUrl(url, process.cwd());
+  if (!res.ok) {
+    process.stderr.write(`shmakk --install-skill: ${res.error}\n`);
+    return 1;
+  }
+  process.stdout.write(`shmakk: installed + loaded skill '${res.name}'\n`);
+  process.stdout.write(`source: ${res.source}\n`);
+  process.stdout.write(`local: ${res.localPath}\n`);
+  return 0;
+}
+
+module.exports = { status, exitParent, restartParent, resetConversation, setProfileAndRestart, profileSignalPath, resumeStatus, compactContext, stats, loadSkill, listSkills, skillStatus, unloadSkill, installSkill };

package/src/correction.js

@@ -0,0 +1,159 @@
+// Deterministic command correction with frequency-weighted distance matching.
+// No LLM, no API calls, sub-millisecond.
+//
+// Only fires when a shell command exits with non-zero.
+// First token matched against glossary commands; subsequent tokens matched
+// against the corrected command's subcommands. Ties broken by usage frequency
+// from the user's shell history.
+
+const { loadFreqMap } = require('./history-parser');
+
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  const m = a.length, n = b.length;
+  if (!m) return n; if (!n) return m;
+  const dp = new Array(n + 1);
+  for (let j = 0; j <= n; j++) dp[j] = j;
+  for (let i = 1; i <= m; i++) {
+    let prev = dp[0]; dp[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const tmp = dp[j];
+      dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+      prev = tmp;
+    }
+  }
+  return dp[n];
+}
+
+// Natural-language pre-filter. If the input reads like a sentence or question,
+// skip correction entirely and route to the task agent.
+const NL_WORDS = new RegExp(
+  '\\b(' +
+  'I|me|my|you|your|the|this|that|these|those|a|an|is|are|was|were|do|does|did|' +
+  'can|could|would|should|please|why|what|how|where|when|who|which|' +
+  'fix|tell|show|explain|help|find|look|check|run|make|build|install|create|update|' +
+  'add|remove|delete|change|setup|set\\s+up|debug' +
+  ')\\b',
+  'i'
+);
+
+function looksLikeNaturalLanguage(input) {
+  if (!input) return false;
+  const trimmed = input.trim();
+  if (trimmed.includes('?')) return true;
+  const tokens = trimmed.split(/\s+/);
+  if (tokens.length > 5) return true;
+  if (tokens.length > 2 && NL_WORDS.test(trimmed)) return true;
+  return false;
+}
+
+// Score candidates: lower distance = better, higher frequency = better.
+// Returns the best match or null if none are close enough.
+// Threshold scales with word length to avoid false positives on short tokens.
+function bestMatch(word, candidates, freqMap) {
+  if (!candidates || !candidates.length) return null;
+  if (candidates.includes(word)) return word; // exact match
+
+  const wlen = word.length;
+  // Max distance scales with word length to catch transpositions on short
+  // words (e.g. gti→git dist 2) while avoiding false matches on 1-char tokens.
+  //   wlen=1 → maxDist=1, wlen=3 → maxDist=2, wlen=5+ → maxDist=3
+  const maxDist = Math.max(1, Math.min(3, Math.floor(wlen / 2) + 1));
+
+  const scored = candidates.map((c) => ({
+    name: c,
+    dist: levenshtein(word.toLowerCase(), c.toLowerCase()),
+    freq: freqMap[c] || 0,
+  }));
+
+  // Filter: only keep within distance threshold
+  const withinThreshold = scored.filter((s) => s.dist <= maxDist && s.dist > 0);
+  if (!withinThreshold.length) return null;
+
+  // Sort: distance ASC, then frequency DESC, then alphabetically for stability
+  withinThreshold.sort((a, b) => {
+    if (a.dist !== b.dist) return a.dist - b.dist;
+    if (b.freq !== a.freq) return b.freq - a.freq;
+    return a.name.localeCompare(b.name);
+  });
+
+  return withinThreshold[0].name;
+}
+
+// Should a token be left as-is? (flags, paths, shell expansions, etc.)
+function isStaticToken(tok) {
+  return tok === '.'
+    || tok === '..'
+    || tok.startsWith('-')
+    || tok.startsWith('$')
+    || tok.startsWith('/')
+    || tok.startsWith('~')
+    || tok.startsWith('--');
+}
+
+async function correct({ input, glossary, signal: _unused }) {
+  // Pre-filter natural language
+  if (looksLikeNaturalLanguage(input)) {
+    return { category: 'not_a_correction', proposed: null, safety: 'uncertain', reason: 'looks like natural language' };
+  }
+
+  // No glossary? Can't correct anything.
+  if (!glossary || !glossary.commands) {
+    return { category: 'not_a_correction', proposed: null, safety: 'uncertain', reason: 'no glossary available' };
+  }
+
+  const freqMap = loadFreqMap();
+  const tokens = input.trim().split(/\s+/);
+  if (!tokens.length) {
+    return { category: 'not_a_correction', proposed: null, safety: 'uncertain', reason: 'empty input' };
+  }
+
+  // ── Token 0: correct the command name ──
+  const cmd = tokens[0];
+  const allCommandNames = Object.keys(glossary.commands);
+  const correctedCmd = bestMatch(cmd, allCommandNames, freqMap);
+
+  // No close match for the command — pass through to task agent
+  if (!correctedCmd) {
+    return { category: 'not_a_correction', proposed: null, safety: 'uncertain', reason: 'no close command match' };
+  }
+
+  const fixedTokens = [correctedCmd];
+  const cmdEntry = glossary.commands[correctedCmd];
+  const subcommands = cmdEntry?.subcommands || [];
+
+  // ── Tokens 1+: correct subcommands and known arguments ──
+  for (let i = 1; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (isStaticToken(tok)) {
+      fixedTokens.push(tok);
+      continue;
+    }
+    // Already a known subcommand? Keep it.
+    if (subcommands.includes(tok)) {
+      fixedTokens.push(tok);
+      continue;
+    }
+    // Try to match against subcommands
+    const bestSub = bestMatch(tok, subcommands, freqMap);
+    if (bestSub) {
+      fixedTokens.push(bestSub);
+    } else {
+      fixedTokens.push(tok); // keep original
+    }
+  }
+
+  const proposed = fixedTokens.join(' ');
+  if (proposed === input.trim()) {
+    return { category: 'not_a_correction', proposed: null, safety: 'uncertain', reason: 'no correction needed' };
+  }
+
+  return {
+    category: 'command_correction',
+    proposed,
+    safety: 'safe',
+    reason: '',
+  };
+}
+
+module.exports = { correct, looksLikeNaturalLanguage };

package/src/endpoints.js

@@ -0,0 +1,52 @@
+// Named endpoint presets. Loads .shmakk/endpoints.json from the workspace
+// root (or the nearest ancestor) and applies the selected preset by setting
+// process.env.SHMAKK_* variables before any other module reads them.
+//
+// Format (.shmakk/endpoints.json):
+// {
+//   "makkorch": {
+//     "base_url": "https://api.example.com/v1",
+//     "api_key": "sk-...",
+//     "model": "gpt-4o-mini",
+//     "headers": "x-custom=value"
+//   }
+// }
+
+const fs = require('fs');
+const path = require('path');
+
+function configPath(cwd) {
+  // Look in the workspace root (usually cwd). The endpoint config is
+  // a user-local file and doesn't need ancestor traversal like state.
+  return path.join(cwd, '.shmakk', 'endpoints.json');
+}
+
+function loadEndpoints(cwd) {
+  try {
+    const raw = fs.readFileSync(configPath(cwd || process.cwd()), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function applyEndpoint(name, cwd) {
+  const endpoints = loadEndpoints(cwd);
+  if (!endpoints || !endpoints[name]) return false;
+
+  const cfg = endpoints[name];
+  if (cfg.base_url)  process.env.SHMAKK_BASE_URL  = cfg.base_url;
+  if (cfg.api_key)   process.env.SHMAKK_API_KEY   = cfg.api_key;
+  if (cfg.model)     process.env.SHMAKK_MODEL     = cfg.model;
+  if (cfg.headers)   process.env.SHMAKK_HEADERS   = cfg.headers;
+
+  return true;
+}
+
+function listEndpoints(cwd) {
+  const endpoints = loadEndpoints(cwd);
+  if (!endpoints) return [];
+  return Object.keys(endpoints);
+}
+
+module.exports = { applyEndpoint, listEndpoints };

package/src/global-doctor.js

@@ -0,0 +1,33 @@
+const { execSync } = require('child_process');
+
+function run(cmd) {
+  try { return execSync(cmd, { encoding: 'utf8' }).trim(); }
+  catch (e) { return (e.stdout || e.message || '').toString().trim(); }
+}
+
+const prefix = run('npm config get prefix');
+const root = run('npm root -g');
+const whichShmakk = run('which shmakk || true');
+const pathValue = process.env.PATH || '';
+
+console.log('Global doctor');
+console.log('-------------');
+console.log('npm prefix :', prefix);
+console.log('npm root   :', root);
+console.log('which shmakk:', whichShmakk || '(not found)');
+
+if (!whichShmakk) {
+  console.log('\n`shmakk` is not on PATH.');
+  console.log('Run: npm run global:setup');
+  console.log('Then open a new terminal and run:');
+  console.log('  shmakk --help');
+}
+
+if (whichShmakk) {
+  console.log('\nLooks good. Try:');
+  console.log('  shmakk --help');
+}
+
+if (!pathValue.includes('/bin')) {
+  console.log('\nPATH looks unusual; verify your shell init files.');
+}