mixdog 0.9.0 → 0.9.1

package/vendor/ink/build/ink.js

@@ -181,6 +181,11 @@ export default class Ink {
     // cells ({ x1, y1, x2, y2 } inclusive, normalized) or null. The App sets it
     // via setSelection(); onRender forwards it to the renderer for highlighting.
     selectionRect = null;
+    // [mixdog fork] Coalesce drag-selection repaints when a frame is pending.
+    isRendering = false;
+    selectionRepaintQueued = false;
+    selectionRepaintFlushPending = false;
+    selectionRepaintEpoch = 0;
     // [mixdog fork] text under the current selection rect, refreshed every render
     // from the output grid. Read back via getSelectionText() on drag-release.
     selectedText = null;
@@ -318,9 +323,9 @@ export default class Ink {
         this.log.setCursorPosition(position);
     };
     // [mixdog fork] Update the mouse drag-selection rectangle and repaint so the
-    // inverse highlight tracks the drag live. Called by the App's mouse handler.
+    // inverse highlight tracks the drag. Called by the App's mouse handler.
     // A no-op-equal update is skipped to avoid redundant frames during motion.
-    setSelection = (rect) => {
+    setSelection = (rect, options = {}) => {
         const a = this.selectionRect;
         const same = a === rect ||
             (a && rect &&
@@ -333,16 +338,47 @@ export default class Ink {
                 a.clipY2 === rect.clipY2 &&
                 a.captureText === rect.captureText);
         if (same) {
-            return;
+            if (!options.immediate) {
+                return;
+            }
+        }
+        else {
+            this.selectionRect = rect ?? null;
         }
-        this.selectionRect = rect ?? null;
         if (!this.isUnmounted) {
-            // Drag selection is a direct manipulation gesture. Route it through
-            // the unthrottled renderer so the highlight tracks the pointer
-            // instead of trailing behind at maxFps.
-            this.rootNode.onImmediateRender();
+            if (options.immediate) {
+                this.selectionRepaintEpoch++;
+                this.selectionRepaintFlushPending = false;
+                this.rootNode.onImmediateRender();
+                return;
+            }
+            this.scheduleSelectionRepaint();
         }
     };
+    scheduleSelectionRepaint = () => {
+        if (this.hasPendingThrottledRender) {
+            return;
+        }
+        if (this.isRendering) {
+            this.selectionRepaintQueued = true;
+            return;
+        }
+        if (this.selectionRepaintFlushPending) {
+            return;
+        }
+        this.selectionRepaintFlushPending = true;
+        const epoch = ++this.selectionRepaintEpoch;
+        queueMicrotask(() => {
+            this.selectionRepaintFlushPending = false;
+            if (epoch !== this.selectionRepaintEpoch || this.isUnmounted) {
+                return;
+            }
+            if (this.hasPendingThrottledRender) {
+                return;
+            }
+            this.rootNode.onImmediateRender();
+        });
+    };
     // [mixdog fork] Given a 0-based cell (x, y), return the inclusive rect of the
     // word (maximal run of non-whitespace cells) on that single row, or null if
     // the cell is whitespace/empty or out of range. Reuses the cached cell-value
@@ -401,6 +437,8 @@ export default class Ink {
             this.nextRenderCommit.resolve();
             this.nextRenderCommit = undefined;
         }
+        this.isRendering = true;
+        try {
         const startTime = performance.now();
         const { output, outputHeight, staticOutput, cursor, selectedText, plainRows } = render(this.rootNode, this.isScreenReaderEnabled, this.selectionRect);
         // [mixdog fork] Cache the text under the current selection rect so the App
@@ -488,6 +526,14 @@ export default class Ink {
             this.fullStaticOutput += staticOutput;
         }
         this.renderInteractiveFrame(output, outputHeight, hasStaticOutput ? staticOutput : '');
+        }
+        finally {
+            this.isRendering = false;
+            if (this.selectionRepaintQueued) {
+                this.selectionRepaintQueued = false;
+                this.scheduleSelectionRepaint();
+            }
+        }
     };
     render(node) {
         const tree = (React.createElement(AccessibilityContext.Provider, { value: { isScreenReaderEnabled: this.isScreenReaderEnabled } },

package/src/hooks/lib/permission-rules.cjs

@@ -1,170 +0,0 @@
-'use strict';
-/**
- * permission-rules.cjs
- * Pattern matcher and priority evaluator. Priority order and Tool(content)
- * parsing mirror Claude Code native logic; specifier matching uses a local
- * path/command glob (native delegates per-tool content matching to each tool).
- *
- * Priority (highest → lowest): deny > ask > allow > mode default
- *
- * Pattern forms:
- *   mcp__*              → toolName starts with "mcp__"
- *   ToolName            → exact toolName match (no parens)
- *   ToolName(*)         → toolName matches AND specifier glob matches any
- *   ToolName(specifier) → toolName matches AND specifier glob matches
- *                         toolInput.path / .command / .file
- *   Glob chars: * (any chars within segment), ** (any segments)
- *
- * No external deps; no eval/Function.
- */
-
-// Read-only tool set (mixdog tool names).
-const READ_ONLY_TOOLS = new Set([
-  'read', 'list', 'glob', 'grep', 'find_symbol', 'find_references', 'find_callers', 'explore',
-  'recall', 'search', 'fetch', 'web_fetch',
-  'schedule_status', 'list_models', 'job_wait', 'download_attachment',
-]);
-
-/**
- * Find the index of the first/last UNescaped occurrence of a char.
- * A char is escaped when preceded by an odd number of backslashes.
- * Mirrors native permissionRuleParser.findFirst/LastUnescapedChar.
- */
-function findFirstUnescapedChar(str, char) {
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] !== char) continue;
-    let bs = 0, j = i - 1;
-    while (j >= 0 && str[j] === '\\') { bs++; j--; }
-    if (bs % 2 === 0) return i;
-  }
-  return -1;
-}
-
-function findLastUnescapedChar(str, char) {
-  for (let i = str.length - 1; i >= 0; i--) {
-    if (str[i] !== char) continue;
-    let bs = 0, j = i - 1;
-    while (j >= 0 && str[j] === '\\') { bs++; j--; }
-    if (bs % 2 === 0) return i;
-  }
-  return -1;
-}
-
-/** Reverse escapeRuleContent: \( -> (, \) -> ), \\ -> \ (order matters). */
-function unescapeRuleContent(content) {
-  return content
-    .replace(/\\\(/g, '(')
-    .replace(/\\\)/g, ')')
-    .replace(/\\\\/g, '\\');
-}
-
-/**
- * Convert a glob pattern string to a RegExp.
- * Supports: * (non-slash wildcard), ** (any), ? (single char).
- * Safe: no eval.
- */
-function globToRegex(glob) {
-  let src = '';
-  let i = 0;
-  while (i < glob.length) {
-    const ch = glob[i];
-    if (ch === '*' && glob[i + 1] === '*') {
-      src += '.*';
-      i += 2;
-      if (glob[i] === '/') i++; // consume trailing slash
-    } else if (ch === '*') {
-      src += '[^/\\\\]*';
-      i++;
-    } else if (ch === '?') {
-      src += '[^/\\\\]';
-      i++;
-    } else {
-      // Escape regex metacharacters
-      src += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-      i++;
-    }
-  }
-  return new RegExp('^' + src + '$', 'i');
-}
-
-/**
- * Match a single pattern entry against (toolName, toolInput).
- * Returns true if the pattern applies.
- */
-function matchesPattern(pattern, toolName, toolInput) {
-  if (typeof pattern !== 'string') return false;
-
-  // Detect Tool(specifier) form. Escape-aware, mirroring native
-  // permissionRuleValueFromString: only UNescaped parens delimit the
-  // specifier, and the close paren must be the final char.
-  const parenIdx = findFirstUnescapedChar(pattern, '(');
-  const closeIdx = findLastUnescapedChar(pattern, ')');
-  if (parenIdx > 0 && closeIdx === pattern.length - 1 && closeIdx > parenIdx) {
-    const namePart = pattern.slice(0, parenIdx);
-    const rawSpecifier = pattern.slice(parenIdx + 1, closeIdx);
-
-    if (toolName !== namePart) return false;
-
-    // Empty "()" or wildcard "(*)" specifier → tool-wide rule, match any
-    if (rawSpecifier === '' || rawSpecifier === '*') return true;
-
-    // Unescape \( \) before glob matching
-    const specifier = unescapeRuleContent(rawSpecifier);
-    // Match specifier against known path-bearing fields
-    const specRe = globToRegex(specifier);
-    const inp = toolInput || {};
-    const candidates = [...new Set([
-      inp.path, inp.command, inp.file, inp.file_path, inp.base_path, inp.cwd,
-      ...(Array.isArray(inp.path)      ? inp.path.map(p => (p && typeof p === 'object' ? p.path : p)) : []),
-      ...(Array.isArray(inp.reads)     ? inp.reads.map(r => r?.path)                              : []),
-      ...(Array.isArray(inp.edits)     ? inp.edits.flatMap(e => [e?.path, e?.file_path])          : []),
-      ...(Array.isArray(inp.writes)    ? inp.writes.flatMap(w => [w?.path, w?.file_path])         : []),
-    ].filter(v => typeof v === 'string'))];
-
-    return candidates.some(c => specRe.test(c));
-  }
-
-  // Prefix wildcard: e.g. "mcp__*"
-  if (pattern.endsWith('*')) {
-    const prefix = pattern.slice(0, -1);
-    return toolName.startsWith(prefix);
-  }
-
-  // Glob on toolName itself (may contain * or **)
-  if (pattern.includes('*') || pattern.includes('?')) {
-    return globToRegex(pattern).test(toolName);
-  }
-
-  // Exact match
-  return toolName === pattern;
-}
-
-/**
- * Evaluate priority rules against a tool call.
- *
- * @param {string}   toolName
- * @param {object}   toolInput
- * @param {string[]} allowList
- * @param {string[]} denyList
- * @param {string[]} askList
- * @returns {'deny'|'ask'|'allow'|null}  null = no list matched (use mode default)
- */
-function evaluateRules(toolName, toolInput, allowList, denyList, askList) {
-  if (denyList.some(p => matchesPattern(p, toolName, toolInput))) return 'deny';
-  if (askList.some(p => matchesPattern(p, toolName, toolInput)))  return 'ask';
-  if (allowList.some(p => matchesPattern(p, toolName, toolInput))) return 'allow';
-  return null;
-}
-
-/**
- * Determine whether a tool is considered read-only.
- * For mcp__ tools: strip the mcp__ prefix chain and check the short tool name.
- */
-function isReadOnlyTool(toolName) {
-  // Strip mcp__plugin_...__  prefix (one or more double-underscore segments)
-  const parts = toolName.split('__');
-  const shortName = parts[parts.length - 1];
-  return READ_ONLY_TOOLS.has(shortName);
-}
-
-module.exports = { matchesPattern, evaluateRules, isReadOnlyTool, READ_ONLY_TOOLS };

package/src/hooks/lib/settings-loader.cjs

@@ -1,112 +0,0 @@
-'use strict';
-/**
- * settings-loader.cjs
- * Loads and merges Mixdog settings from three tiers (lowest → highest):
- *   1. User global:   $MIXDOG_CONFIG_DIR/settings.json (or ~/.mixdog/settings.json)
- *   2. Project:       $MIXDOG_PROJECT_DIR/.mixdog/settings.json  (or cwd/.mixdog/settings.json)
- *   3. Project local: $MIXDOG_PROJECT_DIR/.mixdog/settings.local.json
- *
- * Only `permissions` sub-tree is returned; the rest is ignored.
- * Pure fs/path — no external deps.
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// ── In-process mtime-driven cache ────────────────────────────────────────────
-// Keyed by resolved file path. Each entry: { mtime: number|null, data: any }.
-// Invalidated per-tier independently when mtime changes.
-// TTL: never-expire by default (mtime-driven only).
-const _fileCache = new Map();
-
-function readJsonCached(filePath) {
-  let entry = _fileCache.get(filePath);
-  let mtime = null;
-  try { mtime = fs.statSync(filePath).mtimeMs; } catch { /* file absent */ }
-  if (entry && entry.mtime === mtime) return entry.data;
-  let data = null;
-  if (mtime !== null) {
-    try { data = JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { data = null; }
-  }
-  _fileCache.set(filePath, { mtime, data });
-  return data;
-}
-
-/** Clear the entire settings cache (for test isolation). */
-function clearSettingsCache() {
-  _fileCache.clear();
-}
-
-/**
- * Merge two permissions objects (base then overlay).
- * Arrays are concatenated and de-duped; scalar fields are overwritten.
- */
-function mergePermissions(base, overlay) {
-  if (!overlay) return base || {};
-  if (!base) return overlay || {};
-
-  const merged = Object.assign({}, base);
-
-  for (const key of ['allow', 'deny', 'ask']) {
-    const b = Array.isArray(base[key]) ? base[key] : [];
-    const o = Array.isArray(overlay[key]) ? overlay[key] : [];
-    const combined = [...b, ...o];
-    if (combined.length) merged[key] = [...new Set(combined)];
-  }
-
-  // scalar: overlay wins
-  if (overlay.defaultMode !== undefined) merged.defaultMode = overlay.defaultMode;
-
-  return merged;
-}
-
-/**
- * Load and merge settings from all three tiers.
- * Returns `{ allow: string[], deny: string[], ask: string[], defaultMode: string }`.
- */
-function loadPermissions(projectDir) {
-  const userConfigDir = process.env.MIXDOG_CONFIG_DIR ||
-    path.join(os.homedir(), '.mixdog');
-  const projDir = projectDir ||
-    process.env.MIXDOG_PROJECT_DIR ||
-    process.cwd();
-
-  const userSettings    = readJsonCached(path.join(userConfigDir, 'settings.json'));
-  const projectSettings = readJsonCached(path.join(projDir, '.mixdog', 'settings.json'));
-  const localSettings   = readJsonCached(path.join(projDir, '.mixdog', 'settings.local.json'));
-
-  // Accept permissions from `settings.permissions` (canonical) OR top-level
-  // `allow`/`deny`/`ask`/`defaultMode` fields (common user shorthand).
-  function extractPerms(s) {
-    if (!s) return {};
-    const nested = (s.permissions && typeof s.permissions === 'object') ? s.permissions : {};
-    const topLevel = {};
-    for (const key of ['allow', 'deny', 'ask']) {
-      if (Array.isArray(s[key])) topLevel[key] = s[key];
-    }
-    if (typeof s.defaultMode === 'string') topLevel.defaultMode = s.defaultMode;
-    return mergePermissions(nested, topLevel);
-  }
-  const userPerms    = extractPerms(userSettings);
-  const projectPerms = extractPerms(projectSettings);
-  const localPerms   = extractPerms(localSettings);
-
-  let merged = mergePermissions({}, userPerms);
-  merged = mergePermissions(merged, projectPerms);
-  merged = mergePermissions(merged, localPerms);
-
-  const VALID_MODES = new Set(['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions', 'auto']);
-  const rawMode = merged.defaultMode;
-  const resolvedMode = (typeof rawMode === 'string' && VALID_MODES.has(rawMode))
-    ? rawMode
-    : 'default';
-  return {
-    allow:       Array.isArray(merged.allow)       ? merged.allow       : [],
-    deny:        Array.isArray(merged.deny)        ? merged.deny        : [],
-    ask:         Array.isArray(merged.ask)         ? merged.ask         : [],
-    defaultMode: resolvedMode,
-  };
-}
-
-module.exports = { loadPermissions, clearSettingsCache };

package/src/lib/hook-pipe-path.cjs

@@ -1,10 +0,0 @@
-'use strict';
-
-// Single source for the hook IPC path. Centralizes an existing platform
-// contract (not new heuristic). Rust mirror native/mixdog-shim/src/main.rs:34-43
-// must stay in sync.
-module.exports = function hookPipePath() {
-  return process.platform === 'win32'
-    ? '\\\\.\\pipe\\mixdog-hooks'
-    : require('path').join(process.env.XDG_RUNTIME_DIR || '/tmp', 'mixdog-hooks.sock');
-};