shmakk 1.1.0

package/src/global-setup.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function run(cmd) {
+  try { return execSync(cmd, { encoding: 'utf8' }).trim(); }
+  catch { return ''; }
+}
+
+function ensureLine(filePath, line) {
+  let content = '';
+  try { content = fs.readFileSync(filePath, 'utf8'); } catch {}
+  if (content.includes(line)) return false;
+  const next = content.endsWith('\n') || content.length === 0 ? content : `${content}\n`;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${next}${line}\n`, 'utf8');
+  return true;
+}
+
+function main() {
+  const home = os.homedir();
+  const prefix = run('npm config get prefix') || '/usr/local';
+  const npmBin = path.join(prefix, 'bin');
+  const shell = process.env.SHELL || '';
+
+  const fishConf = path.join(home, '.config/fish/config.fish');
+  const bashrc = path.join(home, '.bashrc');
+  const zshrc = path.join(home, '.zshrc');
+
+  const fishLine = `fish_add_path -g ${npmBin}`;
+  const shLine = `export PATH="${npmBin}:$PATH"`;
+
+  let changed = false;
+
+  if (shell.includes('fish')) {
+    changed = ensureLine(fishConf, fishLine) || changed;
+  } else if (shell.includes('zsh')) {
+    changed = ensureLine(zshrc, shLine) || changed;
+  } else {
+    changed = ensureLine(bashrc, shLine) || changed;
+  }
+
+  // Also add fish config as many users launch fish from other login shells.
+  changed = ensureLine(fishConf, fishLine) || changed;
+
+  console.log('Global PATH setup');
+  console.log('-----------------');
+  console.log('npm prefix :', prefix);
+  console.log('npm bin    :', npmBin);
+  console.log('shell      :', shell || '(unknown)');
+  if (changed) {
+    console.log('\nUpdated shell config. Open a new terminal, then run:');
+    console.log('  shmakk --help');
+  } else {
+    console.log('\nShell config already contains npm global bin path.');
+    console.log('Open a new terminal, then run:');
+    console.log('  shmakk --help');
+  }
+}
+
+main();

package/src/glossary.js

@@ -0,0 +1,235 @@
+// Static, no-execution command glossary.
+//
+// We never run binaries to extract help. Instead we:
+//   1. List executables on PATH (just names + paths).
+//   2. Parse fish completion files: `complete -c CMD -s X -l LONG -a '...'`
+//   3. Parse bash-completion files for `--long-flag` tokens (best-effort).
+//
+// This is intentionally less rich than running `--help`, but it is safe:
+// no programs are launched, no TTY/X/Wayland/dbus interaction occurs, and
+// nothing on the user's system can be modified by the scan.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const HELP_KEEP_BYTES = 4 * 1024;
+
+function defaultGlossaryPath() {
+  const base = process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share');
+  return path.join(base, 'shmakk', 'command-glossary.json');
+}
+
+// ── PATH enumeration ───────────────────────────────────────────────────────
+
+function listPathBinaries() {
+  const seen = new Map();
+  const dirs = (process.env.PATH || '').split(':').filter(Boolean);
+  for (const dir of dirs) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (e.isDirectory()) continue;
+      const full = path.join(dir, e.name);
+      try {
+        const st = fs.statSync(full);
+        if (!(st.mode & 0o111)) continue;
+      } catch { continue; }
+      if (!seen.has(e.name)) seen.set(e.name, []);
+      const list = seen.get(e.name);
+      if (!list.includes(full)) list.push(full);
+    }
+  }
+  return seen;
+}
+
+// ── fish completions ───────────────────────────────────────────────────────
+//
+// Lines look like:
+//   complete -c git -n '__fish_git_using_command status' -l short -d 'short fmt'
+//   complete -c git -a 'add commit push' -d 'commands'
+//   complete -c npm -s g -l global
+
+function fishCompletionDirs() {
+  const dirs = [];
+  const home = os.homedir();
+  if (process.env.XDG_DATA_HOME) {
+    dirs.push(path.join(process.env.XDG_DATA_HOME, 'fish', 'vendor_completions.d'));
+  }
+  dirs.push(
+    path.join(home, '.config', 'fish', 'completions'),
+    path.join(home, '.local', 'share', 'fish', 'vendor_completions.d'),
+    '/usr/share/fish/completions',
+    '/usr/share/fish/vendor_completions.d',
+    '/usr/local/share/fish/completions',
+    '/usr/local/share/fish/vendor_completions.d',
+  );
+  return dirs.filter((d) => { try { return fs.statSync(d).isDirectory(); } catch { return false; } });
+}
+
+const FISH_COMPLETE = /^\s*complete\b(.*)$/;
+// extract value of -c / -s / -l / -a / -d, supporting both quoted and bare
+function parseCompleteArgs(line) {
+  const out = { c: null, s: [], l: [], a: [] };
+  // Tokenize respecting single/double quotes. Simple split is unsafe.
+  const toks = tokenize(line);
+  for (let i = 0; i < toks.length; i++) {
+    const t = toks[i];
+    if (t === '-c' || t === '--command') out.c = toks[++i];
+    else if (t === '-s' || t === '--short-option') out.s.push(toks[++i]);
+    else if (t === '-l' || t === '--long-option') out.l.push(toks[++i]);
+    else if (t === '-o' || t === '--old-option') out.l.push(toks[++i]);
+    else if (t === '-a' || t === '--arguments') out.a.push(toks[++i]);
+  }
+  return out;
+}
+
+function tokenize(s) {
+  const out = [];
+  let i = 0; const n = s.length;
+  while (i < n) {
+    while (i < n && /\s/.test(s[i])) i++;
+    if (i >= n) break;
+    const ch = s[i];
+    if (ch === '"' || ch === "'") {
+      const q = ch; i++;
+      let v = '';
+      while (i < n && s[i] !== q) { v += s[i++]; }
+      i++; // closing
+      out.push(v);
+    } else {
+      let v = '';
+      while (i < n && !/\s/.test(s[i])) { v += s[i++]; }
+      out.push(v);
+    }
+  }
+  return out;
+}
+
+function parseFishCompletions(commands) {
+  for (const dir of fishCompletionDirs()) {
+    let files;
+    try { files = fs.readdirSync(dir); } catch { continue; }
+    for (const f of files) {
+      if (!f.endsWith('.fish')) continue;
+      const cmdName = f.replace(/\.fish$/, '');
+      const entry = ensureEntry(commands, cmdName);
+      let text;
+      try { text = fs.readFileSync(path.join(dir, f), 'utf8'); } catch { continue; }
+      for (const rawLine of text.split('\n')) {
+        const m = FISH_COMPLETE.exec(rawLine);
+        if (!m) continue;
+        const args = parseCompleteArgs(m[1]);
+        const target = args.c || cmdName;
+        const e = ensureEntry(commands, target);
+        for (const sh of args.s) if (sh) e.flags.add('-' + sh);
+        for (const lo of args.l) if (lo) e.flags.add('--' + lo);
+        for (const a of args.a) {
+          for (const sub of String(a).split(/\s+/)) {
+            if (sub && /^[a-z][a-z0-9_-]{0,30}$/i.test(sub)) e.subcommands.add(sub);
+          }
+        }
+        e.sources.add('fish:' + path.basename(dir));
+        if (entry !== e) entry.aliasOf = target;
+      }
+    }
+  }
+}
+
+// ── bash completions ───────────────────────────────────────────────────────
+// Best-effort: extract long flags that appear after the command's COMPREPLY
+// generation. We just regex `--[a-z][\w-]*` from the file.
+
+function bashCompletionDirs() {
+  return [
+    '/usr/share/bash-completion/completions',
+    '/usr/local/share/bash-completion/completions',
+    '/etc/bash_completion.d',
+  ].filter((d) => { try { return fs.statSync(d).isDirectory(); } catch { return false; } });
+}
+
+const FLAG_RE = /(--[a-zA-Z][\w-]*)/g;
+
+function parseBashCompletions(commands) {
+  for (const dir of bashCompletionDirs()) {
+    let files;
+    try { files = fs.readdirSync(dir); } catch { continue; }
+    for (const f of files) {
+      const cmdName = f; // bash-completion files are typically named after the command
+      let text;
+      try { text = fs.readFileSync(path.join(dir, f), 'utf8'); } catch { continue; }
+      const e = ensureEntry(commands, cmdName);
+      let m; let count = 0;
+      while ((m = FLAG_RE.exec(text)) !== null) {
+        e.flags.add(m[1]);
+        if (++count > 200) break;
+      }
+      if (count) e.sources.add('bash:' + path.basename(dir));
+    }
+  }
+}
+
+// ── shape & write ──────────────────────────────────────────────────────────
+
+function ensureEntry(commands, name) {
+  if (!commands[name]) {
+    commands[name] = {
+      paths: [],
+      flags: new Set(),
+      subcommands: new Set(),
+      sources: new Set(),
+    };
+  }
+  return commands[name];
+}
+
+function freezeEntry(e) {
+  return {
+    paths: e.paths,
+    flags: Array.from(e.flags).sort().slice(0, 200),
+    subcommands: Array.from(e.subcommands).sort().slice(0, 100),
+    sources: Array.from(e.sources).sort(),
+  };
+}
+
+async function buildGlossary({ onProgress } = {}) {
+  const bins = listPathBinaries();
+  const commands = {};
+
+  let i = 0; const total = bins.size;
+  for (const [name, paths] of bins) {
+    const e = ensureEntry(commands, name);
+    e.paths = paths;
+    if (onProgress && ++i % 200 === 0) onProgress(i, total);
+  }
+
+  parseFishCompletions(commands);
+  parseBashCompletions(commands);
+
+  const out = {};
+  for (const [name, e] of Object.entries(commands)) out[name] = freezeEntry(e);
+  return { generatedAt: new Date().toISOString(), commands: out };
+}
+
+async function updateGlossary() {
+  const out = defaultGlossaryPath();
+  fs.mkdirSync(path.dirname(out), { recursive: true });
+  process.stderr.write('[shmakk] scanning PATH and completion files (no programs are executed)...\n');
+  const data = await buildGlossary({
+    onProgress: (d, t) => process.stderr.write(`[shmakk] ${d}/${t} binaries\r`),
+  });
+  fs.writeFileSync(out, JSON.stringify(data, null, 2));
+  const n = Object.keys(data.commands).length;
+  const withFlags = Object.values(data.commands).filter((e) => e.flags.length).length;
+  process.stderr.write(`\n[shmakk] wrote ${n} commands (${withFlags} with completion data) → ${out}\n`);
+  return out;
+}
+
+function loadGlossary() {
+  try {
+    const txt = fs.readFileSync(defaultGlossaryPath(), 'utf8');
+    return JSON.parse(txt);
+  } catch { return null; }
+}
+
+module.exports = { updateGlossary, loadGlossary, defaultGlossaryPath, buildGlossary };

package/src/history-parser.js

@@ -0,0 +1,166 @@
+// History parser — reads bash, zsh, fish history files and builds a
+// frequency map of command usage for tie-breaking in corrections.
+//
+// Frequency map format:
+//   { "git": 4521, "ls": 10982, "npm": 893, "cat": 542, ... }
+//
+// Stored at: .shmakk/state/command-freq.json
+//
+// The user controls what goes in — no auto-learning from corrections.
+
+const fs = require('fs');
+const path = require('path');
+
+const STATE_DIR = path.join(process.cwd(), '.shmakk', 'state');
+const FREQ_FILE = path.join(STATE_DIR, 'command-freq.json');
+
+// ── Parsers per shell format ──────────────────────────────────────────────
+
+// Bash: one command per line, no timestamps.
+function parseBashHistory(content) {
+  const freq = {};
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const cmd = trimmed.split(/\s+/)[0];
+    if (cmd) freq[cmd] = (freq[cmd] || 0) + 1;
+  }
+  return freq;
+}
+
+// Zsh: : <timestamp>:<duration>;<command>
+// Example: : 1776037585:0;ll
+function parseZshHistory(content) {
+  const freq = {};
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    // Format: : ts:duration;command
+    const semi = trimmed.indexOf(';');
+    if (trimmed.startsWith(':') && semi !== -1) {
+      const cmd = trimmed.slice(semi + 1).trim().split(/\s+/)[0];
+      if (cmd) freq[cmd] = (freq[cmd] || 0) + 1;
+    } else {
+      // Fallback: treat as bare command
+      const cmd = trimmed.split(/\s+/)[0];
+      if (cmd) freq[cmd] = (freq[cmd] || 0) + 1;
+    }
+  }
+  return freq;
+}
+
+// Fish: YAML-like format
+// - cmd: <command>
+//   when: <timestamp>
+function parseFishHistory(content) {
+  const freq = {};
+  let inEntry = false;
+  let lastCmd = null;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('- cmd:')) {
+      // flush previous
+      if (lastCmd) freq[lastCmd] = (freq[lastCmd] || 0) + 1;
+      lastCmd = trimmed.slice(6).trim();
+      inEntry = true;
+    } else if (inEntry && trimmed.startsWith('when:')) {
+      // end of entry — next line will start a new one or EOF
+      inEntry = false;
+    } else if (!trimmed) {
+      inEntry = false;
+    }
+  }
+  // Flush last entry
+  if (lastCmd) freq[lastCmd] = (freq[lastCmd] || 0) + 1;
+  return freq;
+}
+
+// Detect format and parse a single history file.
+// Returns a frequency map for that file.
+function parseHistoryFile(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch (e) {
+    process.stderr.write(`[shmakk] warning: cannot read ${filePath}: ${e.message}\n`);
+    return {};
+  }
+  if (!content.trim()) return {};
+
+  const name = path.basename(filePath);
+
+  // Fish history: YAML-like with "- cmd:" entries
+  if (name === 'fish_history' || content.includes('- cmd:')) {
+    return parseFishHistory(content);
+  }
+
+  // Zsh history: lines start with ": <timestamp>:"
+  if (content.match(/^:\s+\d+:\d+;/m)) {
+    return parseZshHistory(content);
+  }
+
+  // Bash history: one command per line (default fallback)
+  return parseBashHistory(content);
+}
+
+// Auto-detect common history files on this system.
+function autoDetectHistoryFiles() {
+  const home = process.env.HOME || '/home/' + (process.env.USER || 'unknown');
+  const candidates = [
+    path.join(home, '.bash_history'),
+    path.join(home, '.zsh_history'),
+    path.join(home, '.local/share/fish/fish_history'),
+    path.join(home, '.config/fish/fish_history'),
+  ];
+  return candidates.filter((f) => {
+    try { return fs.statSync(f).isFile(); } catch { return false; }
+  });
+}
+
+// Parse one or more history files and merge into a single frequency map.
+function buildFreqMap(filePaths) {
+  const merged = {};
+  for (const fp of filePaths) {
+    const freq = parseHistoryFile(fp);
+    for (const [cmd, count] of Object.entries(freq)) {
+      merged[cmd] = (merged[cmd] || 0) + count;
+    }
+  }
+  return merged;
+}
+
+// ── Load / save the frequency map ─────────────────────────────────────────
+
+function freqMapPath(baseDir) {
+  return path.join(baseDir || process.cwd(), '.shmakk', 'state', 'command-freq.json');
+}
+
+function loadFreqMap(baseDir) {
+  const fp = freqMapPath(baseDir);
+  try {
+    const raw = fs.readFileSync(fp, 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed === 'object' && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function saveFreqMap(freqMap, baseDir) {
+  const dir = path.join(baseDir || process.cwd(), '.shmakk', 'state');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  const fp = path.join(dir, 'command-freq.json');
+  fs.writeFileSync(fp, JSON.stringify(freqMap, null, 2) + '\n');
+  return fp;
+}
+
+module.exports = {
+  parseBashHistory,
+  parseZshHistory,
+  parseFishHistory,
+  parseHistoryFile,
+  autoDetectHistoryFiles,
+  buildFreqMap,
+  loadFreqMap,
+  saveFreqMap,
+};

package/src/hooks/bash.js

@@ -0,0 +1,43 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const INIT = `
+[ -f /etc/bash.bashrc ] && . /etc/bash.bashrc
+[ -f "$HOME/.bashrc" ] && . "$HOME/.bashrc"
+
+__shmakk_armed=1
+__shmakk_preexec() {
+    [ -n "$COMP_LINE" ] && return
+    [ -z "$__shmakk_armed" ] && return
+    [ "$BASH_COMMAND" = "$PROMPT_COMMAND" ] && return
+    __shmakk_armed=
+    local cmd
+    cmd=$(printf '%s' "$BASH_COMMAND" | base64 -w0 2>/dev/null || printf '%s' "$BASH_COMMAND" | base64)
+    printf '\\e]6973;B;%s\\a' "$cmd"
+}
+__shmakk_precmd() {
+    local ec=$?
+    local p
+    p=$(printf '%s' "$PWD" | base64 -w0 2>/dev/null || printf '%s' "$PWD" | base64)
+    printf '\\e]6973;C;%s\\a' "$ec"
+    printf '\\e]6973;D;%s\\a' "$p"
+    __shmakk_armed=1
+}
+trap '__shmakk_preexec' DEBUG
+PROMPT_COMMAND="__shmakk_precmd\${PROMPT_COMMAND:+;\$PROMPT_COMMAND}"
+`;
+
+function configure() {
+  const dir = path.join(os.tmpdir(), `shmakk-bash-${process.pid}`);
+  fs.mkdirSync(dir, { recursive: true });
+  const rcfile = path.join(dir, 'bashrc');
+  fs.writeFileSync(rcfile, INIT, { mode: 0o600 });
+  return {
+    args: ['--rcfile', rcfile, '-i'],
+    env: {},
+    cleanup: () => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} },
+  };
+}
+
+module.exports = { configure };

package/src/hooks/fish.js

@@ -0,0 +1,25 @@
+// Returns { args, env, cleanup } for spawning fish with markers wired up.
+// fish supports `-C COMMAND` to run init code after config.fish.
+
+const INIT = `
+function __shmakk_pre --on-event fish_preexec
+    set -l c (printf '%s' "$argv" | base64 -w0 2>/dev/null; or printf '%s' "$argv" | base64)
+    printf '\\e]6973;B;%s\\a' "$c"
+end
+function __shmakk_post --on-event fish_postexec
+    set -l ec $status
+    set -l p (printf '%s' "$PWD" | base64 -w0 2>/dev/null; or printf '%s' "$PWD" | base64)
+    printf '\\e]6973;C;%s\\a' $ec
+    printf '\\e]6973;D;%s\\a' "$p"
+end
+`.trim();
+
+function configure() {
+  return {
+    args: ['-i', '-l', '-C', INIT],
+    env: {},
+    cleanup: () => {},
+  };
+}
+
+module.exports = { configure };

package/src/hooks/index.js

@@ -0,0 +1,14 @@
+const fish = require('./fish');
+const bash = require('./bash');
+const zsh = require('./zsh');
+
+function configureForShell(name) {
+  switch (name) {
+    case 'fish': return fish.configure();
+    case 'bash': return bash.configure();
+    case 'zsh': return zsh.configure();
+    default: return { args: ['-i'], env: {}, cleanup: () => {} };
+  }
+}
+
+module.exports = { configureForShell };

package/src/hooks/zsh.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ZSHRC = `
+# preserve real ZDOTDIR so user config is sourced
+if [ -n "$SHMAKK_REAL_ZDOTDIR" ]; then
+    [ -f "$SHMAKK_REAL_ZDOTDIR/.zshrc" ] && source "$SHMAKK_REAL_ZDOTDIR/.zshrc"
+elif [ -f "$HOME/.zshrc" ]; then
+    source "$HOME/.zshrc"
+fi
+
+__shmakk_preexec() {
+    local cmd
+    cmd=$(printf '%s' "$1" | base64 -w0 2>/dev/null || printf '%s' "$1" | base64)
+    printf '\\e]6973;B;%s\\a' "$cmd"
+}
+__shmakk_precmd() {
+    local ec=$?
+    local p
+    p=$(printf '%s' "$PWD" | base64 -w0 2>/dev/null || printf '%s' "$PWD" | base64)
+    printf '\\e]6973;C;%s\\a' "$ec"
+    printf '\\e]6973;D;%s\\a' "$p"
+}
+typeset -ag preexec_functions precmd_functions
+preexec_functions+=(__shmakk_preexec)
+precmd_functions+=(__shmakk_precmd)
+`;
+
+function configure() {
+  const dir = path.join(os.tmpdir(), `shmakk-zsh-${process.pid}`);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, '.zshrc'), ZSHRC, { mode: 0o600 });
+  const realZ = process.env.ZDOTDIR || '';
+  return {
+    args: ['-i'],
+    env: { ZDOTDIR: dir, SHMAKK_REAL_ZDOTDIR: realZ },
+    cleanup: () => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} },
+  };
+}
+
+module.exports = { configure };