shmakk 1.2.4 → 1.2.5

package/src/cli/connectBrowser.js

@@ -0,0 +1,137 @@
+// CLI entry point for `shmakk connect-browser`.
+// Connects to a running Chrome instance via CDP, enabling the agent
+// to interact with the user's own authenticated browser sessions.
+//
+// Usage:
+//   shmakk connect-browser              # auto-detect CDP port
+//   shmakk connect-browser --port 9222  # connect to specific port
+//   shmakk connect-browser --disconnect # disconnect
+//   shmakk connect-browser --status     # show connection status
+
+const path = require('path');
+const fs = require('fs');
+
+function resolveConnector() {
+  try {
+    return require('../core/browserConnector');
+  } catch (e) {
+    process.stderr.write(
+      '[shmakk] Browser connector unavailable.\n' +
+      '[shmakk] Install playwright: npm install playwright\n' +
+      `[shmakk] Details: ${e.message}\n`,
+    );
+    process.exit(1);
+  }
+}
+
+function parseArgs(argv) {
+  const args = {
+    port: null,
+    disconnect: false,
+    status: false,
+    help: false,
+  };
+
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === '--port' || a === '-p') {
+      args.port = parseInt(argv[++i], 10);
+      if (isNaN(args.port) || args.port < 1 || args.port > 65535) {
+        process.stderr.write(`[shmakk] invalid port: ${argv[i]}\n`);
+        process.exit(2);
+      }
+    } else if (a === '--disconnect' || a === '-d') {
+      args.disconnect = true;
+    } else if (a === '--status' || a === '-s') {
+      args.status = true;
+    } else if (a === '--help' || a === '-h') {
+      args.help = true;
+    } else if (a === 'connect-browser') {
+      // skip the subcommand name itself
+    } else {
+      process.stderr.write(`[shmakk] connect-browser: unknown option: ${a}\n`);
+      args.help = true;
+    }
+    i++;
+  }
+
+  return args;
+}
+
+const HELP = `shmakk connect-browser — connect to a running Chrome instance via CDP
+
+Usage:
+  shmakk connect-browser [options]
+
+Options:
+  --port, -p <port>    Connect to Chrome on a specific CDP port (default: auto-detect)
+  --disconnect, -d     Disconnect from Chrome
+  --status, -s         Show connection status
+  --help, -h           Show this help
+
+Before running this command, start Chrome with remote debugging enabled:
+  google-chrome-stable --remote-debugging-port=9222
+
+When connected, the agent's browser tool will interact with your
+Chrome instance, preserving logins, cookies, and extensions.
+`;
+
+async function main() {
+  const rawArgs = process.argv.slice(2);
+
+  // If no subcommand-like arg, default to connect.
+  const args = parseArgs(rawArgs);
+
+  if (args.help) {
+    process.stdout.write(HELP);
+    process.exit(0);
+  }
+
+  const bc = resolveConnector();
+
+  if (!bc.isAvailable()) {
+    process.stderr.write(
+      '[shmakk] playwright is required for browser CDP connection.\n' +
+      '[shmakk] Run: npm install playwright && npx playwright install chromium\n',
+    );
+    process.exit(1);
+  }
+
+  if (args.disconnect) {
+    const result = await bc.disconnect();
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    process.exit(0);
+  }
+
+  if (args.status) {
+    const result = await bc.getStatus();
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    process.exit(0);
+  }
+
+  // Default: connect
+  const connectArgs = {};
+  if (args.port) connectArgs.port = args.port;
+
+  process.stdout.write('[shmakk] connecting to Chrome via CDP...\n');
+
+  const result = await bc.connect(connectArgs);
+
+  if (result.ok) {
+    process.stdout.write(
+      `[shmakk] connected to Chrome (port ${result.port})\n` +
+      `[shmakk] current page: ${result.url || '(about:blank)'}\n` +
+      `[shmakk] title: ${result.title || '(none)'}\n`,
+    );
+    process.exit(0);
+  } else {
+    process.stderr.write(`[shmakk] connection failed: ${result.error}\n`);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`[shmakk] connect-browser fatal: ${err && err.stack || err}\n`);
+  process.exit(1);
+});

package/src/cli.js

@@ -21,7 +21,9 @@ function parseArgs(argv) {
     globalSkills: false,
     resumeStatus: false,
     showPlan: false,
+    newSession: false,
     mcpStatus: false,
+    consolidateWorkspace: false,
     exitNow: false,
     restart: false,
     profile: null,
@@ -30,6 +32,10 @@ function parseArgs(argv) {
     markdown: null,
     endpoint: null,
     modelRecommendation: false,
+    vim: 'vi',
+    vimEditor: null,
+    vimReal: null,
+    vimAi: null,
     voice: false,
     stt: false,
     tts: false,
@@ -45,12 +51,35 @@ function parseArgs(argv) {
     completion: null,
     helpCategory: null,
     shell: null,
+    browserDaemon: false,
+    browserDaemonPort: null,
+    // connect-browser subcommand
+    connectBrowser: false,
+    connectBrowserPort: null,
+    connectBrowserDisconnect: false,
+    connectBrowserStatus: false,
     unknown: [],
   };
+  const setVoiceCliMode = (mode) => {
+    if (mode === 'stt') {
+      opts.stt = true;
+      opts.voice = true;
+    } else if (mode === 'tts') {
+      opts.tts = true;
+    } else if (mode === 'sts') {
+      opts.sts = true;
+      opts.voice = true;
+      opts.tts = true;
+    }
+  };
 
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     switch (a) {
+      case '--':
+        opts.unknown.push(...argv.slice(i + 1));
+        i = argv.length;
+        break;
       case '--review': opts.review = true; break;
       case '--yes-files': opts.yesFiles = true; break;
       case '--update-command-glossary': opts.updateGlossary = true; break;
@@ -79,7 +108,9 @@ function parseArgs(argv) {
       case '--install-skill': opts.installSkill = argv[++i] || null; break;
       case '--resume-status': opts.resumeStatus = true; break;
       case '--show-plan': opts.showPlan = true; break;
+      case '--new-session': opts.newSession = true; break;
       case '--mcp-status': opts.mcpStatus = true; break;
+      case '--consolidate-workspace': opts.consolidateWorkspace = true; break;
       case '--exit': opts.exitNow = true; break;
       case '--restart': opts.restart = true; break;
       case '--reset': opts.reset = true; break;
@@ -93,10 +124,10 @@ function parseArgs(argv) {
         }
         if (!opts.buildHistory.length) opts.buildHistory = null; // flag with no files = auto-detect
         break;
-      case '--stt': opts.stt = true; opts.voice = true; break;
-      case '--tts': opts.tts = true; break;
-      case '--sts': opts.sts = true; opts.stt = true; opts.tts = true; opts.voice = true; break;
-      case '--voice': opts.stt = true; opts.voice = true; break;
+      case '--stt': setVoiceCliMode('stt'); break;
+      case '--tts': setVoiceCliMode('tts'); break;
+      case '--sts': setVoiceCliMode('sts'); break;
+      case '--voice': setVoiceCliMode('stt'); break;
       case '--voice-language': opts.voiceLanguage = argv[++i] || null; break;
       case '--voice-max-sec': opts.voiceMaxDuration = parseInt(argv[++i], 10) || null; break;
       case '--voice-silence-sec': opts.voiceSilenceSec = argv[++i] || null; break;
@@ -110,6 +141,19 @@ function parseArgs(argv) {
       case '--markdown': opts.markdown = argv[++i] || null; break;
       case '--endpoint': opts.endpoint = argv[++i] || null; break;
       case '--model-recommendation': opts.modelRecommendation = true; break;
+      case '--vim':
+        {
+          const v = (argv[++i] || 'vi').toLowerCase();
+          if (!['vi', 'vim', 'disable', 'enable'].includes(v)) {
+            process.stderr.write('[shmakk] invalid --vim. Use: vi|vim|disable\n');
+            process.exit(2);
+          }
+          opts.vim = v === 'enable' ? 'vim' : v;
+        }
+        break;
+      case '--vim-editor': opts.vimEditor = argv[++i] || null; break;
+      case '--vim-real': opts.vimReal = argv[++i] || null; break;
+      case '--vim-ai': opts.vimAi = argv[++i] || null; break;
       case '--shell':
         {
           const v = argv[++i];
@@ -120,6 +164,53 @@ function parseArgs(argv) {
           opts.shell = v;
         }
         break;
+      case 'connect-browser':
+        opts.connectBrowser = true;
+        // Consume subsequent flags that belong to connect-browser
+        while (i + 1 < argv.length) {
+          const n = argv[i + 1];
+          if (n === '--port' || n === '-p') {
+            i++;
+            opts.connectBrowserPort = parseInt(argv[++i], 10);
+            if (isNaN(opts.connectBrowserPort)) {
+              process.stderr.write(`[shmakk] connect-browser: invalid port: ${argv[i]}\n`);
+              process.exit(2);
+            }
+          } else if (n === '--disconnect' || n === '-d') {
+            i++;
+            opts.connectBrowserDisconnect = true;
+          } else if (n === '--status' || n === '-s') {
+            i++;
+            opts.connectBrowserStatus = true;
+          } else if (n === '--help' || n === '-h') {
+            i++;
+            opts.help = true;
+            opts.helpCategory = 'mcp';
+          } else {
+            break; // unknown or next subcommand
+          }
+        }
+        break;
+      case 'browser-daemon':
+        opts.browserDaemon = true;
+        while (i + 1 < argv.length) {
+          const n = argv[i + 1];
+          if (n === '--port' || n === '-p') {
+            i++;
+            opts.browserDaemonPort = parseInt(argv[++i], 10);
+            if (isNaN(opts.browserDaemonPort)) {
+              process.stderr.write(`[shmakk] browser-daemon: invalid port: ${argv[i]}\n`);
+              process.exit(2);
+            }
+          } else if (n === '--help' || n === '-h') {
+            i++;
+            opts.help = true;
+            opts.helpCategory = 'mcp';
+          } else {
+            break;
+          }
+        }
+        break;
       default: opts.unknown.push(a);
     }
   }
@@ -144,10 +235,12 @@ Categories (shmakk --help <name> for details):
   session      Status, stats, restart, exit, control signals
   skills       Skill discovery, loading, listing, management
   models       Provider configuration, endpoint presets
+  vim          Vim/vi integration and AI suggestions
   voice        Speech-to-Text / Text-to-Speech options
   env          Environment variable reference
   mcp          MCP servers and browser automation
   ssh          Remote host execution
+  vibedit      Visual editing overlay (web + Electron)
   self         Natural-language self-commands (inside a session)
 
 `;
@@ -177,9 +270,11 @@ HELP_SECTIONS.launch = `══════════════════
   --print-config                   Print resolved configuration and exit
 
   --workspace <path>               Override workspace root
+  --new-session                    Force a new session instead of resuming
   --profile <name>                 Startup profile: tiny|balanced|deep|builder|large-app
   --colors <true|false>            Enable or disable ANSI colors
   --markdown <true|false>          Enable or disable markdown rendering
+  --vim <vi|vim|disable>           Intercept vi/vim inside shmakk (default: vi)
   --notify                         Desktop notifications for Y/n prompts
 `;
 
@@ -190,17 +285,62 @@ HELP_SECTIONS.models = `══════════════════
   --endpoint <name>                Use model preset from ~/.config/shmakk/endpoints.json
   --model-recommendation           Main model chooses best model per call
 
-  Providers: openai-compatible | codex | anthropic | google
+  Providers: openai-compatible | codex | anthropic | google | nvidia
   Configure in ~/.config/shmakk/endpoints.json:
     {
       "main": "claude",
+      "fast": "flash",
       "models": {
         "claude":       { "provider":"anthropic", "model":"claude-sonnet-4-5-...", "api_key":"..." },
+        "flash":        { "provider":"google",    "model":"gemini-flash",       "api_key":"..." },
         "gpt5":         { "provider":"codex",     "model":"gpt-5-codex",        "api_key":"..." },
+        "kimi":         { "provider":"nvidia",    "model":"moonshotai/kimi-k2.6", "api_key":"nvapi-..." },
         "local-qwen":   { "provider":"openai-compatible", "base_url":"http://127.0.0.1:1234/v1",
                           "model":"qwen/qwen3.5-9b" }
       }
     }
+
+  main is used for normal agent work. fast is used for low-latency paths such
+  as Vim suggestions. Override with SHMAKK_FAST_ENDPOINT or
+  SHMAKK_VIM_SUGGEST_ENDPOINT.
+`;
+
+HELP_SECTIONS.vim = `═══════════════════════════════════════════════════════════════════════════
+  VIM / VI
+═══════════════════════════════════════════════════════════════════════════
+
+  --vim <vi|vim|disable>           Intercept vi/vim inside shmakk (default: vi)
+
+  When enabled, shmakk puts a temporary vi or vim shim at the front of PATH
+  inside the shmakk shell. The shim launches your real editor, loads your
+  normal vimrc/plugins/colors first, then sources a small shmakk plugin.
+
+  Commands inside Vim:
+    :G <prompt>                    Generate code at the cursor
+    :Tw <prompt>                   Write prose or documentation at the cursor
+    :Cmd <command>                 Run a shell command in a scratch buffer
+    :ShmakkSuggest                 Ask for a full-block suggestion
+    :ShmakkAccept                  Preview and accept pending auto-suggestion
+    :ShmakkPreview                 Preview pending auto-suggestion
+    :ShmakkDeny                    Clear pending auto-suggestion
+
+  Mappings:
+    <C-Space>                      Manual full-block suggestion with preview
+    <leader>sa                     Accept pending auto-suggestion
+    <leader>sp                     Preview pending auto-suggestion
+    <leader>sd                     Deny pending auto-suggestion
+
+  Lowercase :g is not overridden; it remains Vim's native :global command.
+  Use :G for shmakk generation. Native commands such as :%s/foo/bar/g still
+  work normally.
+
+  Optional auto-suggest in vimrc:
+    let g:shmakk_auto_suggest = 1
+    let g:shmakk_auto_suggest_delay_ms = 2000
+    let g:shmakk_auto_suggest_min_chars = 20
+
+  Suggestions prefer SHMAKK_VIM_SUGGEST_ENDPOINT, then SHMAKK_FAST_ENDPOINT,
+  then the endpoint registry's fast model, then the current model.
 `;
 
 HELP_SECTIONS.session = `═══════════════════════════════════════════════════════════════════════════
@@ -214,6 +354,7 @@ HELP_SECTIONS.session = `══════════════════
   shmakk --mcp-status              MCP servers and their tools
 
   shmakk --compact                 Clear conversation + task journal
+  shmakk --consolidate-workspace   Merge nested .shmakk dirs into root
   shmakk --reset                   Clear AI conversation history (keep session)
   shmakk --restart                 Restart the inner shell (keeps window)
   shmakk --exit                    Cleanly exit the parent shmakk
@@ -240,6 +381,7 @@ HELP_SECTIONS.voice = `═══════════════════
   --sts                            Speech-to-Speech: always-on mic + TTS
   --stt                            Speech-to-Text: mic input, text output
   --tts                            Text-to-Speech: text input, spoken output
+                                  These modes are exclusive; the last one wins.
 
   --voice-language <code>          Language hint (e.g. en, es, fr)
   --voice-max-sec <sec>            Max recording seconds (default: 30)
@@ -261,10 +403,17 @@ HELP_SECTIONS.env = `═══════════════════
   SHMAKK_BASE_URL                  OpenAI-compatible base URL
   SHMAKK_API_KEY                   API key
   SHMAKK_MODEL                     Default model
-  SHMAKK_PROVIDER                  Provider: openai-compatible|codex|anthropic|google
+  SHMAKK_FAST_ENDPOINT             Named endpoint for low-latency tasks
+  SHMAKK_VIM_SUGGEST_ENDPOINT      Named endpoint for Vim suggestions
+  SHMAKK_PROVIDER                  Provider: openai-compatible|codex|anthropic|google|nvidia
   SHMAKK_HEADERS                   Extra headers: k=v,k=v
   SHMAKK_REGISTRY                  Model registry filter (comma-separated)
   SHMAKK_MODEL_RECOMMENDATION      Set to 1 to let main model choose per call
+  SHMAKK_VIM_SHIM_DIR              Internal PATH shim for enhanced vi/vim
+  SHMAKK_REAL_PATH                 Original PATH before shmakk vim shims
+  SHMAKK_VIM_SUGGEST_MAX_CHARS     Max context chars sent for Vim suggestions
+  SHMAKK_VIM_SUGGEST_BEFORE_LINES  Lines before cursor for Vim suggestions
+  SHMAKK_VIM_SUGGEST_AFTER_LINES   Lines after cursor for Vim suggestions
 
   SHMAKK_HF_CACHE                  HuggingFace cache directory (voice models)
   SHMAKK_TTS_VOICE                 Pin a specific TTS voice
@@ -281,12 +430,37 @@ HELP_SECTIONS.mcp = `═══════════════════
 ═══════════════════════════════════════════════════════════════════════════
 
   MCP servers: configure in ~/.config/shmakk/mcp.json or .shmakk/mcp.json
-    { "mcpServers": { "name": { "command": "...", "args": [...] } } }
+    {
+      "mcpServers": {
+        "name": {
+          "command": "...",
+          "args": ["..."],
+          "env": { "TOKEN": "\${TOKEN}" },
+          "safety": "uncertain",
+          "safeTools": ["read"],
+          "unsafeTools": ["delete"],
+          "timeout": 30000,
+          "disabled": false
+        }
+      }
+    }
 
-  Browser automation: requires playwright
+  Agent browser tool: headless Playwright for non-interactive browsing.
     npm install playwright && npx playwright install chromium
   Tools: navigate, click, type, read_page, screenshot, evaluate, select,
   wait, scroll, close.
+
+  Extension automation for the current Chrome tab:
+    shmakk browser-daemon                  run global extension backend
+    shmakk browser-daemon --port 3947      use a custom extension port
+
+  CDP connection is for live debugging / Electron-style targets:
+    shmakk connect-browser                 auto-detect and connect
+    shmakk connect-browser --port 9222     connect to specific port
+    shmakk connect-browser --status        show connection status
+    shmakk connect-browser --disconnect    disconnect
+
+  shmakk --mcp-status              Show configured servers and discovered tools
 `;
 
 HELP_SECTIONS.ssh = `═══════════════════════════════════════════════════════════════════════════
@@ -317,6 +491,50 @@ HELP_SECTIONS.ssh = `═══════════════════
       ControlPersist 600
 `;
 
+HELP_SECTIONS['vibedit'] = `═══════════════════════════════════════════════════════════════════════════
+  VIBEDIT  (web + Electron)
+═══════════════════════════════════════════════════════════════════════════
+
+  Vibedit is the visual editing overlay. It opens a Chromium browser tab,
+  injects a chat panel with a shadow-DOM overlay, captures screenshots for
+  vision-model analysis, and applies code changes directly to your project.
+
+  ── Web mode ──
+
+  Inside a session:
+    /vibedit <url | file | package.json | dir>
+
+  Opens a Playwright Chromium browser, injects the overlay, and auto-starts
+  a dev server if given a package.json or project directory. The overlay
+  appears as a puck in the bottom-right corner.
+
+  ── Electron mode ──
+
+  Inside a session:
+    /vibedit-electron <debug-port>
+    /ve <debug-port>              (short alias)
+
+  Connects to an already-running Electron app via Chrome DevTools Protocol.
+  The app must be launched with --remote-debugging-port=<port>.
+  No new browser window is opened — the overlay is injected into the
+  existing Electron window.
+
+  ── Specs ──
+
+  Use the overlay's Save button to capture a spec (screenshot + description).
+  The spec is immediately sent to the agent for implementation. If the
+  agent is already busy, the spec is queued and applied on the next run.
+
+  ── Dependencies ──
+
+  Both modes require:  npm install playwright && npx playwright install chromium
+  Electron mode also needs the target app's debug port accessible.
+
+  Project-local state: .shmakk/state/vibedit-*
+  Extension daemon state: ~/.config/shmakk/browser-daemon.json
+  Vibedit control port: auto-assigned per overlay session
+`;
+
 HELP_SECTIONS.self = `═══════════════════════════════════════════════════════════════════════════
   SELF-COMMANDS  (type inside an shmakk session)
 ═══════════════════════════════════════════════════════════════════════════
@@ -372,6 +590,15 @@ HELP_SECTIONS.self = `═══════════════════
   enable yes-files  |  disable yes-files
   enable colors  |  disable colors
   enable debug  |  disable debug
+  enable stt  |  disable stt        Ctrl+O voice input; disables TTS/STS
+  enable tts  |  disable tts        Spoken agent replies; disables STT/STS
+  enable sts  |  disable sts        Always-on speech-to-speech; disables STT/TTS
+
+  -- Vibedit --
+  /vibedit <url | path>            Launch visual editing overlay on a web app
+  /vibedit-electron <port>         Connect overlay to an Electron app via CDP
+  /ve <port>                       Short alias for /vibedit-electron
+  shmakk browser-daemon            Run Chrome extension automation backend
 
   -- Workflows --
   list workflows                    Show available automation workflows

package/src/completions.js

@@ -41,6 +41,7 @@ const FLAGS = [
   { flag: '--profile-set', arg: '<name>', desc: 'Switch profile and restart' },
   { flag: '--endpoint', arg: '<name>', desc: 'Use model preset from ~/.config/shmakk/endpoints.json' },
   { flag: '--colors', arg: '<true|false>', desc: 'Toggle ANSI colors' },
+  { flag: '--vim', arg: '<vi|vim|disable>', desc: 'Intercept vi/vim with shmakk Vim mode' },
   { 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' },
@@ -79,6 +80,9 @@ function bash() {
     } else if (f.flag === '--colors') {
       lines.push('      COMPREPLY=($(compgen -W "true false" -- "$cur"))');
       lines.push('      return');
+    } else if (f.flag === '--vim') {
+      lines.push('      COMPREPLY=($(compgen -W "vi vim disable" -- "$cur"))');
+      lines.push('      return');
     } else {
       lines.push('      COMPREPLY=()');
       lines.push('      return');
@@ -122,6 +126,8 @@ function zsh() {
       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 if (f.flag === '--vim') {
+      lines.push(`    "${f.flag}[${f.desc}]:mode:(vi vim disable)" \\`);
     } else {
       lines.push(`    "${f.flag}[${f.desc}]: :" \\`);
     }
@@ -148,6 +154,8 @@ function fish() {
       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 if (f.flag === '--vim') {
+      lines.push(`complete -c shmakk -l ${f.flag.slice(2)} -d '${f.desc}' -xa 'vi vim disable'`);
     } else {
       // arg but no specific completions
       lines.push(`complete -c shmakk -l ${f.flag.slice(2)} -d '${f.desc}' -r`);