@mindexec/cli 0.2.0

package/wwwroot/_content/MindExecution.Shared/js/titlebar-handler.js

@@ -0,0 +1,191 @@
+/**
+ * titlebar-handler.js
+ * Virtual titlebar drag + double-click handling
+ * - Drag while maximized: restore then move (Windows standard behavior)
+ * - Double-click: toggle maximize/restore
+ * - Drag threshold (distinguish click vs drag)
+ */
+
+(function () {
+    'use strict';
+
+    let isPotentialDrag = false;  // Ready-to-drag state (pointer down)
+    let isDragging = false;       // Actively dragging
+    let titlebarElement = null;
+    let dotNetHelper = null;
+
+    // Drag start position/state
+    let dragStartX = 0;
+    let dragStartY = 0;
+    let dragStartScreenX = 0;
+    let dragStartScreenY = 0;
+    let dragMouseXRatio = 0;
+    let currentPointerId = null;
+
+    // Drag threshold (px) - must move at least this far to count as a drag
+    const DRAG_THRESHOLD = 5;
+
+    /**
+    * Initialize titlebar handler
+    * @param {HTMLElement} element - Titlebar element
+     * @param {object} helper - Blazor DotNetObjectReference
+     */
+    window.initTitlebarHandler = function (element, helper) {
+        if (!element) {
+            console.warn('[TitlebarHandler] Element is null');
+            return;
+        }
+
+        titlebarElement = element;
+        dotNetHelper = helper;
+
+        // Remove old listeners (avoid duplicates)
+        element.removeEventListener('pointerdown', onPointerDown);
+        element.removeEventListener('dblclick', onDoubleClick);
+
+        // Register new listeners
+        element.addEventListener('pointerdown', onPointerDown);
+        element.addEventListener('dblclick', onDoubleClick);
+
+        console.log('[TitlebarHandler] Initialized');
+    };
+
+    /**
+     * Double-click handler - toggle maximize/restore
+     */
+    function onDoubleClick(e) {
+        // Ignore double-clicks on buttons
+        if (e.target.closest('.window-buttons') || e.target.closest('button')) {
+            return;
+        }
+
+        e.preventDefault();
+        e.stopPropagation();
+
+        if (dotNetHelper) {
+            dotNetHelper.invokeMethodAsync('OnTitlebarDoubleClick');
+        }
+    }
+
+    /**
+     * Pointer down handler - prepare for dragging
+     */
+    function onPointerDown(e) {
+        // Left button only
+        if (e.button !== 0) return;
+
+        // Don't start dragging from buttons
+        if (e.target.closest('.window-buttons') || e.target.closest('button')) {
+            return;
+        }
+
+        // Enter potential-drag state (not an actual drag yet)
+        isPotentialDrag = true;
+        isDragging = false;
+        currentPointerId = e.pointerId;
+
+        // Save start position
+        dragStartX = e.clientX;
+        dragStartY = e.clientY;
+        dragStartScreenX = e.screenX;
+        dragStartScreenY = e.screenY;
+
+        // Mouse X ratio within titlebar (0.0 ~ 1.0)
+        const rect = titlebarElement.getBoundingClientRect();
+        dragMouseXRatio = (e.clientX - rect.left) / rect.width;
+
+        // Register global listeners
+        document.addEventListener('pointermove', onPointerMove);
+        document.addEventListener('pointerup', onPointerUp);
+        document.addEventListener('pointercancel', onPointerUp);
+
+        // Pointer capture
+        titlebarElement.setPointerCapture(e.pointerId);
+    }
+
+    /**
+     * Pointer move handler - check threshold and start actual drag
+     */
+    function onPointerMove(e) {
+        if (!isPotentialDrag) return;
+
+        // ▼▼▼ [New] Mouse button state check - end drag if no buttons are pressed ▼▼▼
+        // If buttons is 0, no buttons are pressed (defensive against missed events)
+        if (e.buttons === 0) {
+            console.log('[TitlebarHandler] Mouse button released (detected in pointermove)');
+            onPointerUp(e);
+            return;
+        }
+        // ▲▲▲ [New] ▲▲▲
+
+        // If already dragging, the C# timer handles it
+        if (isDragging) return;
+
+        // Compute movement distance
+        const deltaX = e.clientX - dragStartX;
+        const deltaY = e.clientY - dragStartY;
+        const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+
+        // Start actual drag once threshold is exceeded
+        if (distance >= DRAG_THRESHOLD) {
+            isDragging = true;
+
+            console.log(`[TitlebarHandler] Drag started (moved ${distance.toFixed(1)}px)`);
+
+            // Notify Blazor that dragging started (use current mouse position)
+            if (dotNetHelper) {
+                dotNetHelper.invokeMethodAsync('OnTitlebarDragStart', e.screenX, e.screenY, dragMouseXRatio);
+            }
+        }
+    }
+
+    /**
+    * Pointer up handler - finish dragging
+     */
+    function onPointerUp(e) {
+        if (!isPotentialDrag) return;
+
+        const wasDragging = isDragging;
+
+        isPotentialDrag = false;
+        isDragging = false;
+        currentPointerId = null;
+
+        // Remove global listeners
+        document.removeEventListener('pointermove', onPointerMove);
+        document.removeEventListener('pointerup', onPointerUp);
+        document.removeEventListener('pointercancel', onPointerUp);
+
+        // Release pointer capture
+        if (titlebarElement && e.pointerId !== undefined) {
+            try {
+                titlebarElement.releasePointerCapture(e.pointerId);
+            } catch (ex) {
+                // Already released
+            }
+        }
+
+        // Notify drag end only if a real drag happened
+        if (wasDragging && dotNetHelper) {
+            dotNetHelper.invokeMethodAsync('OnTitlebarDragEnd');
+        }
+    }
+
+    /**
+    * Cleanup
+     */
+    window.disposeTitlebarHandler = function () {
+        if (titlebarElement) {
+            titlebarElement.removeEventListener('pointerdown', onPointerDown);
+            titlebarElement.removeEventListener('dblclick', onDoubleClick);
+        }
+        document.removeEventListener('pointermove', onPointerMove);
+        document.removeEventListener('pointerup', onPointerUp);
+        document.removeEventListener('pointercancel', onPointerUp);
+        titlebarElement = null;
+        dotNetHelper = null;
+        isPotentialDrag = false;
+        isDragging = false;
+    };
+
+})();

package/wwwroot/_content/MindExecution.Shared/js/token-manager.js

@@ -0,0 +1,37 @@
+(function () {
+    let worker = null;
+    const pendingRequests = new Map();
+
+    window.TokenManager = {
+        init: function () {
+            if (worker) return;
+            worker = new Worker('/_content/MindExecution.Shared/js/token-worker.js', { type: 'module' });
+
+            worker.onmessage = function (e) {
+                const { id, count, error } = e.data;
+
+                if (pendingRequests.has(id)) {
+                    const resolver = pendingRequests.get(id);
+                    if (error) {
+                        console.warn('[TokenManager] Worker error:', error);
+                        resolver(0);
+                    } else {
+                        resolver(count);
+                    }
+                    pendingRequests.delete(id);
+                }
+            };
+            console.log('[TokenManager] Web Worker initialized.');
+        },
+
+        countTokens: function (text) {
+            if (!worker) this.init();
+
+            return new Promise((resolve) => {
+                const id = crypto.randomUUID();
+                pendingRequests.set(id, resolve);
+                worker.postMessage({ id, text, action: 'count' });
+            });
+        }
+    };
+})();

package/wwwroot/_content/MindExecution.Shared/js/token-worker.js

@@ -0,0 +1,28 @@
+import { encoding_for_model } from "https://cdn.jsdelivr.net/npm/tiktoken@1.0.10/+esm";
+
+let enc = null;
+
+self.onmessage = async (e) => {
+    const { id, text, action } = e.data;
+
+    try {
+        if (!enc) {
+            enc = encoding_for_model("gpt-4");
+        }
+
+        if (action === 'count') {
+            if (!text) {
+                self.postMessage({ id, count: 0 });
+                return;
+            }
+
+            const tokens = enc.encode(text);
+            const count = tokens.length;
+
+            self.postMessage({ id, count });
+        }
+    } catch (error) {
+        console.error('[TokenWorker] Error:', error);
+        self.postMessage({ id, count: 0, error: error.message });
+    }
+};