shmakk 1.2.0 → 1.2.2

package/src/completions.js

@@ -33,12 +33,13 @@ const FLAGS = [
   { 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)' },
+  { flag: '--model-recommendation', arg: false, desc: 'Route each model call via main model recommendation' },
 
   // 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 ~/.config/shmakk/endpoints.js' },
+  { flag: '--endpoint', arg: '<name>', desc: 'Use model preset from ~/.config/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' },
@@ -53,6 +54,7 @@ const FLAGS = [
   { 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' },
+  { flag: '--notify', arg: false, desc: 'Send desktop notifications when shmakk needs your attention' },
 ];
 
 function bash() {

package/src/correction.js

@@ -27,12 +27,19 @@ function levenshtein(a, b) {
 
 // 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(' +
+// Only check the FIRST token — if it looks like a natural-language opener
+// ("Fix ...", "I ...", "Please ...") skip correction. This avoids matching
+// common action words that appear as command arguments (e.g. "install" in
+// "npm install").
+const NL_FIRST_WORD = new RegExp(
+  '^(' +
   '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' +
+  'add|remove|delete|change|setup|debug|' +
+  'hello|hi|hey|ok|okay|sure|yes|no|maybe|thanks|thank|sorry|' +
+  'let|lets|shall|will|might|must|need|want|got|get|give|take|' +
+  'here|there|now|then|just|also|only|very|really' +
   ')\\b',
   'i'
 );
@@ -43,7 +50,7 @@ function looksLikeNaturalLanguage(input) {
   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;
+  if (tokens.length >= 2 && NL_FIRST_WORD.test(trimmed)) return true;
   return false;
 }
 

package/src/endpoints.js

@@ -1,15 +1,26 @@
-// Named endpoint presets with hotswap support.
-// Loads ~/.config/shmakk/endpoints.js (or .json for backwards compat).
-// Can switch endpoints mid-session without restarting.
+// Named model endpoints with hotswap support.
+// Loads ~/.config/shmakk/endpoints.json (or .js for backwards compat).
+// Can switch models mid-session without restarting.
 //
-// Format (~/.config/shmakk/endpoints.js):
+// Preferred format (~/.config/shmakk/endpoints.json):
 // {
-//   "makkorch": {
-//     "base_url": "https://api.example.com/v1",
-//     "api_key": "sk-...",
-//     "model": "gpt-4o-mini",
-//     "headers": "x-custom=value",
-//     "registry": "claudeHaiku,claudeSonnet,ministral"
+//   "main": "gpt-5",
+//   "models": {
+//     "gpt-5": {
+//       "provider": "codex",
+//       "model": "gpt-5-codex",
+//       "api_key": "sk-..."
+//     },
+//     "claude": {
+//       "provider": "anthropic",
+//       "model": "claude-sonnet-4-5-20250929",
+//       "api_key": "sk-ant-..."
+//     },
+//     "local": {
+//       "provider": "openai-compatible",
+//       "base_url": "http://127.0.0.1:1234/v1",
+//       "model": "qwen/qwen3.5-9b"
+//     }
 //   }
 // }
 
@@ -23,13 +34,13 @@ let endpointsCwd = null;
 
 function configPath(cwd) {
   const configDir = path.join(os.homedir(), '.config', 'shmakk');
-  const jsPath = path.join(configDir, 'endpoints.js');
   const jsonPath = path.join(configDir, 'endpoints.json');
+  const jsPath = path.join(configDir, 'endpoints.js');
 
-  // Try .js first, fall back to .json for backwards compatibility
-  if (fs.existsSync(jsPath)) return jsPath;
+  // Prefer JSON for user-editable model registries; keep .js compatibility.
   if (fs.existsSync(jsonPath)) return jsonPath;
-  return jsPath; // Default to .js even if neither exists
+  if (fs.existsSync(jsPath)) return jsPath;
+  return jsonPath;
 }
 
 function loadEndpoints(cwd) {
@@ -49,26 +60,71 @@ function loadEndpoints(cwd) {
   }
 }
 
-function applyEndpoint(name, cwd) {
-  const endpoints = loadEndpoints(cwd);
-  if (!endpoints || !endpoints[name]) return false;
-
-  const cfg = endpoints[name];
-  currentEndpointName = name;
-
-  // Normalize: accept both camelCase and snake_case
-  const normalized = {
-    base_url: cfg.base_url || cfg.baseUrl,
-    api_key: cfg.api_key || cfg.apiKey,
-    model: cfg.model,
-    headers: cfg.headers,
-    registry: cfg.registry,
+function normalizeModelConfig(name, cfg) {
+  if (!cfg || typeof cfg !== 'object') return null;
+
+  const provider = String(cfg.provider || cfg.type || 'openai-compatible').toLowerCase();
+  return {
+    name,
+    provider,
+    base_url: cfg.base_url || cfg.baseUrl || cfg.host || cfg.url || null,
+    api_key: cfg.api_key || cfg.apiKey || cfg.key || null,
+    model: cfg.model || name,
+    headers: cfg.headers || cfg.headears || null,
+    registry: cfg.registry || null,
+    main: !!cfg.main,
   };
+}
+
+function normalizeRegistry(raw) {
+  if (!raw || typeof raw !== 'object') {
+    return { main: null, models: {} };
+  }
+
+  const explicitModels = raw.models || raw.endpoints;
+  const source = explicitModels && typeof explicitModels === 'object'
+    ? explicitModels
+    : Object.fromEntries(
+      Object.entries(raw).filter(([key, value]) => {
+        return key !== 'main' && value && typeof value === 'object' && !Array.isArray(value);
+      }),
+    );
+
+  const models = {};
+  for (const [name, cfg] of Object.entries(source)) {
+    const normalized = normalizeModelConfig(name, cfg);
+    if (normalized) models[name] = normalized;
+  }
+
+  let main = typeof raw.main === 'string' ? raw.main : null;
+  if (!main) {
+    const marked = Object.values(models).find((cfg) => cfg.main);
+    if (marked) main = marked.name;
+  }
+  if (!main && Object.keys(models).length === 1) {
+    main = Object.keys(models)[0];
+  }
+
+  return { main, models };
+}
+
+function loadModelRegistry(cwd) {
+  return normalizeRegistry(loadEndpoints(cwd));
+}
+
+function applyEndpoint(name, cwd) {
+  const registry = loadModelRegistry(cwd);
+  const selected = name === 'main' ? registry.main : name;
+  if (!selected || !registry.models[selected]) return false;
+
+  const normalized = registry.models[selected];
+  currentEndpointName = selected;
 
   currentEndpointConfig = normalized;
   endpointsCwd = cwd;
 
   // Also update env vars for backwards compatibility
+  if (normalized.provider)  process.env.SHMAKK_PROVIDER  = normalized.provider;
   if (normalized.base_url)  process.env.SHMAKK_BASE_URL  = normalized.base_url;
   if (normalized.api_key)   process.env.SHMAKK_API_KEY   = normalized.api_key;
   if (normalized.model)     process.env.SHMAKK_MODEL     = normalized.model;
@@ -88,9 +144,15 @@ function getCurrentEndpointName() {
 }
 
 function listEndpoints(cwd) {
-  const endpoints = loadEndpoints(cwd);
-  if (!endpoints) return [];
-  return Object.keys(endpoints);
+  return Object.keys(loadModelRegistry(cwd).models);
+}
+
+function getModelRegistry(cwd) {
+  const registry = loadModelRegistry(cwd || endpointsCwd || process.cwd());
+  return {
+    main: registry.main,
+    models: Object.fromEntries(Object.entries(registry.models).map(([name, cfg]) => [name, { ...cfg }])),
+  };
 }
 
 module.exports = {
@@ -98,4 +160,5 @@ module.exports = {
   listEndpoints,
   getCurrentEndpoint,
   getCurrentEndpointName,
+  getModelRegistry,
 };

package/src/guard.js

@@ -0,0 +1,101 @@
+// DSML leak detection, sanitization, streaming guard, and mutation-tool
+// approval helpers.  Used by agent.js and tools.js.
+//
+// See BUGFUXPAND.md for the full rationale — this module is the runtime
+// enforcement of every item in that document.
+
+// ── DSML leak detection ─────────────────────────────────────────────────────
+
+// DSML uses fullwidth vertical bars (U+FF5C): <｜DSML｜tool_calls>
+// Also catches double-bar variants and <function=name> format.
+const DSML_LEAK_RE =
+  /<(?:\s*\/?\s*(?:[｜|]+\s*(?:DSML\s*)?[｜|]+\s*(?:tool_calls|invoke|parameter)\b|[｜|]+(?:\s*tool_calls|\s*invoke|\s*parameter)\b)|\s*function\s*=\s*[a-zA-Z0-9_]+)/i;
+
+const DSML_TOOL_CALL_BLOCK_RE =
+  /<(?:\s*[｜|]+\s*(?:DSML\s*)?[｜|]+\s*tool_calls\s*>|\s*[｜|]+\s*tool_calls\s*[｜|]*\s*>)[\s\S]*?<\s*\/\s*(?:[｜|]+\s*(?:DSML\s*)?[｜|]+|[｜|]+)\s*tool_calls\s*[｜|]*\s*>/gi;
+
+/** Returns true when visible assistant text contains leaked internal tool
+ *  markup that should never reach the user. */
+function isLeakedToolMarkup(text) {
+  return DSML_LEAK_RE.test(text);
+}
+
+/** Remove complete leaked DSML blocks so remaining visible text can be used
+ *  if we decide to strip rather than block. */
+function stripInternalToolMarkup(text) {
+  return text.replace(DSML_TOOL_CALL_BLOCK_RE, "").trim();
+}
+
+/** One-stop sanitizer: returns clean visible text + a leak flag. */
+function sanitizeAssistantContent(raw) {
+  const hadInternalLeak = isLeakedToolMarkup(raw);
+  const visibleText = stripInternalToolMarkup(raw);
+  return { visibleText, hadInternalLeak };
+}
+
+// ── Streaming guard: lookbehind buffer ──────────────────────────────────────
+
+const PARTIAL_INTERNAL_PREFIXES = [
+  "<｜",
+  "<|",
+  "<｜｜",
+  "<||",
+  "<｜｜DSML",
+  "<||DSML",
+];
+
+/** Returns true when `tail` could be the beginning of an internal markup
+ *  string that hasn't finished streaming yet. */
+function mightBecomeInternalMarkup(tail) {
+  return PARTIAL_INTERNAL_PREFIXES.some(
+    (prefix) => tail.endsWith(prefix) || prefix.startsWith(tail),
+  );
+}
+
+// ── Mutation tool classification ───────────────────────────────────────────
+
+const MUTATION_TOOLS = new Set([
+  "edit_file",
+  "write_file",
+  "delete_file",
+  "make_dir",
+  "run",
+]);
+
+/** True when the named tool mutates the workspace or runs an external process. */
+function isMutationTool(name) {
+  return MUTATION_TOOLS.has(name);
+}
+
+// ── Args hashing (for approval validation) ──────────────────────────────────
+
+const crypto = require("crypto");
+
+function hashArgs(args) {
+  const raw = typeof args === "string" ? args : JSON.stringify(args || {});
+  return crypto.createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+
+// ── Retry message ───────────────────────────────────────────────────────────
+
+const DSML_RETRY_USER_MESSAGE = {
+  role: "user",
+  content:
+    "Your previous response emitted internal tool markup as visible text. " +
+    "Do not print DSML/XML/tool markup. Use only native structured tool " +
+    "calls or normal user-visible text.",
+};
+
+module.exports = {
+  DSML_LEAK_RE,
+  DSML_TOOL_CALL_BLOCK_RE,
+  PARTIAL_INTERNAL_PREFIXES,
+  isLeakedToolMarkup,
+  stripInternalToolMarkup,
+  sanitizeAssistantContent,
+  mightBecomeInternalMarkup,
+  MUTATION_TOOLS,
+  isMutationTool,
+  hashArgs,
+  DSML_RETRY_USER_MESSAGE,
+};

package/src/index.js

@@ -1,7 +1,7 @@
 const { parseArgs, HELP } = require('./cli');
 const { normalizeProfile, resolveProfile } = require('./profiles');
 const { applyEndpoint, getCurrentEndpoint, getCurrentEndpointName } = require('./endpoints');
-const { ensureMakkorch } = require('./llm');
+const { ensureModelRuntime } = require('./llm');
 const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
@@ -33,15 +33,18 @@ async function main() {
     }
   }
 
-  // Apply named endpoint preset from ~/.config/shmakk/endpoints.js before
+  if (opts.modelRecommendation) {
+    process.env.SHMAKK_MODEL_RECOMMENDATION = '1';
+  }
+
+  // Apply named model preset from ~/.config/shmakk/endpoints.json before
   // any other module reads SHMAKK_* environment variables.
   if (opts.endpoint) {
-    const configDir = path.join(require('os').homedir(), '.config', 'shmakk', 'endpoints.js');
+    const configDir = path.join(require('os').homedir(), '.config', 'shmakk', 'endpoints.json');
     if (!applyEndpoint(opts.endpoint, opts.workspace || process.cwd())) {
       process.stderr.write(`[shmakk] endpoint "${opts.endpoint}" not found in ${configDir}\n`);
     }
-    // Auto-start makkorch if needed
-    await ensureMakkorch();
+    await ensureModelRuntime();
   }
 
   if (opts.colors !== null) {
@@ -53,6 +56,15 @@ async function main() {
     opts.colors = v === 'true';
   }
 
+  if (opts.markdown !== null) {
+    const v = String(opts.markdown).toLowerCase();
+    if (v !== 'true' && v !== 'false') {
+      process.stderr.write('[shmakk] invalid --markdown. Use: true|false\n');
+      process.exit(2);
+    }
+    opts.markdown = v === 'true';
+  }
+
   if (opts.help) {
     process.stdout.write(HELP);
     process.exit(0);
@@ -86,6 +98,8 @@ async function main() {
       baseUrl: activeEndpoint?.base_url || process.env.SHMAKK_BASE_URL || null,
       apiKey: activeEndpoint?.api_key ? (activeEndpoint.api_key.slice(0, 8) + '...' + activeEndpoint.api_key.slice(-4)) : null,
       model: activeEndpoint?.model || process.env.SHMAKK_MODEL || null,
+      provider: activeEndpoint?.provider || process.env.SHMAKK_PROVIDER || null,
+      modelRecommendation: process.env.SHMAKK_MODEL_RECOMMENDATION === '1',
       registry: activeEndpoint?.registry || process.env.SHMAKK_REGISTRY || null,
       profile: profile.name,
       colors: opts.colors,