windowpp 0.1.1

package/framework/src/FileSystem/filesystem_search_service.cpp

@@ -0,0 +1,414 @@
+// ============================================================================
+//  FileSystem/filesystem_search_service.cpp
+//  Multi-threaded streamed filesystem search with cancellation.
+// ============================================================================
+
+#include "filesystem_search_service.h"
+
+#include "file_index_service.h"
+
+#include <filesystem>
+#include <thread>
+#include <algorithm>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <shlwapi.h>
+#pragma comment(lib, "shlwapi.lib")
+#endif
+
+namespace wpp::fs {
+
+// ─── ThreadPool Implementation ───────────────────────────────────────────────────
+
+ThreadPool::ThreadPool(size_t num_threads) {
+    // Default to hardware concurrency if not specified, min 2, max 8
+    size_t actual_threads = num_threads;
+    if (actual_threads == 0) {
+        actual_threads = std::thread::hardware_concurrency();
+        actual_threads = std::max(size_t(2), std::min(actual_threads, size_t(8)));
+    }
+
+    workers_.reserve(actual_threads);
+    for (size_t i = 0; i < actual_threads; ++i) {
+        workers_.emplace_back(&ThreadPool::worker_thread, this);
+    }
+}
+
+ThreadPool::~ThreadPool() {
+    shutdown();
+}
+
+void ThreadPool::worker_thread() {
+    while (true) {
+        std::function<void()> task;
+        {
+            std::unique_lock<std::mutex> lock(mutex_);
+            cv_.wait(lock, [this] { return stop_.load() || !tasks_.empty(); });
+
+            if (stop_.load() && tasks_.empty()) {
+                return;
+            }
+
+            task = std::move(tasks_.front());
+            tasks_.pop();
+        }
+        task();
+    }
+}
+
+void ThreadPool::shutdown() {
+    stop_.store(true);
+    cv_.notify_all();
+    for (auto& worker : workers_) {
+        if (worker.joinable()) {
+            worker.join();
+        }
+    }
+    workers_.clear();
+}
+
+// ─── Platform-specific glob matching ────────────────────────────────────────────
+
+#ifdef _WIN32
+
+// Windows: Use PathMatchSpecW for fast native glob matching
+static std::wstring toWide(const std::string& utf8) {
+    if (utf8.empty()) return {};
+    int len = MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, nullptr, 0);
+    std::wstring ws(len, L'\0');
+    MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, ws.data(), len);
+    if (!ws.empty() && ws.back() == L'\0') ws.pop_back();
+    return ws;
+}
+
+static bool matches_glob(const std::string& filename, const std::string& pattern) {
+    std::wstring wfilename = toWide(filename);
+    std::wstring wpattern = toWide(pattern);
+    return PathMatchSpecW(wfilename.c_str(), wpattern.c_str()) != 0;
+}
+
+#else
+
+// POSIX: Use fnmatch for fast native glob matching
+#include <fnmatch.h>
+
+static bool matches_glob(const std::string& filename, const std::string& pattern) {
+#if defined(__APPLE__)
+    return fnmatch(pattern.c_str(), filename.c_str(), FNM_CASEFOLD) == 0;
+#else
+    return fnmatch(pattern.c_str(), filename.c_str(), 0) == 0;
+#endif
+}
+
+#endif
+
+static bool is_hidden_entry(const std::filesystem::directory_entry& entry) {
+    const auto filename = entry.path().filename().u8string();
+    if (!filename.empty() && filename[0] == '.') {
+        return true;
+    }
+
+#ifdef _WIN32
+    const DWORD attributes = GetFileAttributesW(entry.path().c_str());
+    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_HIDDEN) != 0;
+#else
+    return false;
+#endif
+}
+
+// ─── FileSearchService Implementation ───────────────────────────────────────────
+
+FileSearchService::FileSearchService() : threadPool_(4) {}
+
+FileSearchService::~FileSearchService() {
+    threadPool_.shutdown();
+}
+
+FileSearchService& FileSearchService::instance() {
+    static FileSearchService service;
+    return service;
+}
+
+void FileSearchService::configure_cache_root(const std::string& cacheRoot) {
+    FileIndexService::instance().configure_cache_root(cacheRoot);
+}
+
+std::string FileSearchService::start(const std::vector<std::string>& roots,
+                                     const SearchOptions& options,
+                                     StreamBatchCallback onBatch,
+                                     StreamDoneCallback onDone,
+                                     const std::string& preferredId) {
+    auto state = std::make_shared<SearchState>();
+    state->id = preferredId.empty()
+        ? std::to_string(next_id_.fetch_add(1))
+        : preferredId;
+    state->roots = roots;
+    state->options = options;
+    state->onBatch = std::move(onBatch);
+    state->onDone = std::move(onDone);
+
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        searches_[state->id] = state;
+    }
+
+    std::thread([this, state]() {
+        run_search(state);
+    }).detach();
+
+    return state->id;
+}
+
+void FileSearchService::cancel(const std::string& searchId) {
+    std::shared_ptr<SearchState> state;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = searches_.find(searchId);
+        if (it == searches_.end()) {
+            return;
+        }
+        state = it->second;
+    }
+    state->cancelled.store(true);
+}
+
+void FileSearchService::search_root(const std::shared_ptr<SearchState>& state,
+                                  const std::string& root,
+                                  std::vector<std::string>& results,
+                                  std::mutex& resultsMutex) {
+    const auto pattern = state->options.pattern.empty() ? std::string("*") : state->options.pattern;
+    const auto max_results = state->options.maxResults;
+    const auto recursive = state->options.recursive;
+    const auto includeHidden = state->options.includeHidden;
+    const auto includeDirectories = state->options.includeDirectories;
+
+    if (recursive) {
+        uint64_t indexed_entries = 0;
+        const auto indexed = FileIndexService::instance().get_or_build_root_index(
+            root,
+            &state->cancelled,
+            indexed_entries);
+        state->scannedCount.fetch_add(indexed_entries);
+
+        for (const auto& entry : indexed) {
+            if (state->cancelled.load()) {
+                return;
+            }
+
+            if (!includeHidden && entry.isHidden) {
+                continue;
+            }
+
+            if (max_results > 0 && state->matchedCount.load() >= max_results) {
+                return;
+            }
+
+            if (entry.isDir && !includeDirectories) {
+                continue;
+            }
+
+            if (matches_glob(entry.name, pattern)) {
+                std::lock_guard<std::mutex> lock(resultsMutex);
+                results.push_back(entry.path);
+                state->matchedCount.fetch_add(1);
+            }
+        }
+        return;
+    }
+
+    auto is_file = [&](const std::filesystem::path& path) -> bool {
+        std::error_code ec;
+        return std::filesystem::is_regular_file(path, ec);
+    };
+
+    auto is_dir = [&](const std::filesystem::path& path) -> bool {
+        std::error_code ec;
+        return std::filesystem::is_directory(path, ec);
+    };
+
+    // Start processing from root
+    if (is_file(root)) {
+        state->scannedCount.fetch_add(1);
+        std::filesystem::path path(root);
+        const auto filename = path.filename().u8string();
+        if (matches_glob(filename, pattern)) {
+            std::lock_guard<std::mutex> lock(resultsMutex);
+            results.push_back(root);
+            state->matchedCount.fetch_add(1);
+        }
+    } else if (is_dir(root)) {
+        std::vector<std::filesystem::path> pending_dirs;
+        pending_dirs.push_back(root);
+
+        while (!pending_dirs.empty()) {
+            if (state->cancelled.load()) {
+                return;
+            }
+
+            const std::filesystem::path dir = std::move(pending_dirs.back());
+            pending_dirs.pop_back();
+
+            std::error_code ec;
+            auto it = std::filesystem::directory_iterator(
+                dir,
+                std::filesystem::directory_options::skip_permission_denied,
+                ec);
+            if (ec) {
+                continue;
+            }
+
+            for (const auto& entry : it) {
+                if (state->cancelled.load()) {
+                    return;
+                }
+
+                if (max_results > 0 && state->matchedCount.load() >= max_results) {
+                    return;
+                }
+
+                if (!includeHidden && is_hidden_entry(entry)) {
+                    continue;
+                }
+
+                state->scannedCount.fetch_add(1);
+                const bool is_directory = is_dir(entry.path());
+                if (is_directory) {
+                    const auto dirname = entry.path().filename().u8string();
+                    if (includeDirectories && matches_glob(dirname, pattern)) {
+                        std::lock_guard<std::mutex> lock(resultsMutex);
+                        results.push_back(entry.path().u8string());
+                        state->matchedCount.fetch_add(1);
+                        if (max_results > 0 && state->matchedCount.load() >= max_results) {
+                            return;
+                        }
+                    }
+                    if (recursive) {
+                        pending_dirs.push_back(entry.path());
+                    }
+                    continue;
+                }
+
+                const auto filename = entry.path().filename().u8string();
+                if (matches_glob(filename, pattern)) {
+                    std::lock_guard<std::mutex> lock(resultsMutex);
+                    results.push_back(entry.path().u8string());
+                    state->matchedCount.fetch_add(1);
+                }
+            }
+        }
+    }
+}
+
+void FileSearchService::run_search(const std::shared_ptr<SearchState>& state) {
+    StreamSearchSummary summary;
+    const auto max_results = state->options.maxResults;
+
+    std::vector<std::string> batch;
+    batch.reserve(24);
+    std::mutex batchMutex;
+
+    std::vector<std::string> allResults;
+    std::mutex resultsMutex;
+
+    // Auto-flush timer for instant UI updates without manual intervals
+    auto flush_batch = [&]() {
+        std::lock_guard<std::mutex> lock(batchMutex);
+        if (batch.empty()) return;
+
+        // Flush immediately, no waiting
+        state->onBatch(state->id, std::move(batch));
+        batch.clear();
+        batch.reserve(24);
+    };
+
+    try {
+        // Enqueue all roots for parallel processing
+        for (const auto& root : state->roots) {
+            if (root.empty()) {
+                continue;
+            }
+
+            std::error_code ec;
+            if (!std::filesystem::exists(root, ec)) {
+                if (summary.error.empty()) {
+                    summary.error = "Path does not exist: " + root;
+                }
+                continue;
+            }
+
+            state->activeWorkers.fetch_add(1);
+            threadPool_.enqueue([this, state, root, &allResults, &resultsMutex]() {
+                search_root(state, root, allResults, resultsMutex);
+                state->activeWorkers.fetch_sub(1);
+            });
+        }
+
+        // Wait for all workers to complete or cancellation
+        while (!state->cancelled.load() && state->activeWorkers.load() > 0) {
+            // Flush frequently for immediate feedback - every 8 items or every 5ms
+            if (batch.size() >= 3) {
+                flush_batch();
+            }
+
+            // Collect any new results into batch immediately
+            {
+                std::lock_guard<std::mutex> lock(resultsMutex);
+                if (!allResults.empty()) {
+                    size_t to_take = std::min(allResults.size(), size_t(8) - batch.size());
+                    if (to_take > 0) {
+                        batch.insert(batch.end(),
+                                   std::make_move_iterator(allResults.begin()),
+                                   std::make_move_iterator(allResults.begin() + to_take));
+                        allResults.erase(allResults.begin(), allResults.begin() + to_take);
+                        if (batch.size() >= 2) {
+                            flush_batch();
+                        }
+                    }
+                }
+            }
+
+            if (max_results > 0 && state->matchedCount.load() >= max_results) {
+                break;
+            }
+
+            // Very short sleep - just yield to reduce CPU while staying responsive
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+
+        // Collect any remaining results
+        {
+            std::lock_guard<std::mutex> lock(resultsMutex);
+            if (!allResults.empty()) {
+                batch.insert(batch.end(),
+                           std::make_move_iterator(allResults.begin()),
+                           std::make_move_iterator(allResults.end()));
+                allResults.clear();
+            }
+        }
+
+    } catch (const std::exception& e) {
+        summary.error = e.what();
+    } catch (...) {
+        summary.error = "Unknown filesystem search error";
+    }
+
+    summary.scannedEntries = state->scannedCount.load();
+    summary.matchedEntries = state->matchedCount.load();
+    summary.cancelled = state->cancelled.load();
+    summary.truncated = (max_results > 0 && state->matchedCount.load() >= max_results);
+
+    flush_batch();
+    finish_search(state, summary);
+}
+
+void FileSearchService::finish_search(const std::shared_ptr<SearchState>& state,
+                                      const StreamSearchSummary& summary) {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        searches_.erase(state->id);
+    }
+    state->onDone(state->id, summary);
+}
+
+} // namespace wpp::fs

package/framework/src/FileSystem/filesystem_search_service.h

@@ -0,0 +1,94 @@
+// ============================================================================
+//  FileSystem/filesystem_search_service.h
+//  Cross-platform streamed filesystem search with cancellation and multi-threading.
+// ============================================================================
+
+#pragma once
+
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "filesystem_handler.h"
+
+namespace wpp::fs {
+
+// Thread pool for parallel file scanning
+class ThreadPool {
+public:
+    explicit ThreadPool(size_t num_threads = 0);
+    ~ThreadPool();
+
+    template<typename F>
+    void enqueue(F&& task) {
+        {
+            std::unique_lock<std::mutex> lock(mutex_);
+            tasks_.emplace(std::forward<F>(task));
+        }
+        cv_.notify_one();
+    }
+
+    void shutdown();
+
+private:
+    void worker_thread();
+
+    std::vector<std::thread> workers_;
+    std::queue<std::function<void()>> tasks_;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+    std::atomic<bool> stop_{false};
+};
+
+class FileSearchService {
+public:
+    static FileSearchService& instance();
+
+    void configure_cache_root(const std::string& cacheRoot);
+
+    std::string start(const std::vector<std::string>& roots,
+                      const SearchOptions& options,
+                      StreamBatchCallback onBatch,
+                      StreamDoneCallback onDone,
+                      const std::string& preferredId = "");
+
+    void cancel(const std::string& searchId);
+
+private:
+    struct SearchState {
+        std::string         id;
+        std::vector<std::string> roots;
+        SearchOptions       options;
+        StreamBatchCallback onBatch;
+        StreamDoneCallback  onDone;
+        std::atomic<bool>   cancelled{false};
+        std::atomic<uint64_t> matchedCount{0};
+        std::atomic<uint64_t> scannedCount{0};
+        std::atomic<size_t>  activeWorkers{0};
+    };
+
+    std::mutex mutex_;
+    std::unordered_map<std::string, std::shared_ptr<SearchState>> searches_;
+    std::atomic<uint64_t> next_id_{1};
+
+    // Thread pool for parallel directory scanning
+    ThreadPool threadPool_;
+
+    FileSearchService();
+    ~FileSearchService();
+
+    void run_search(const std::shared_ptr<SearchState>& state);
+    void search_root(const std::shared_ptr<SearchState>& state, const std::string& root,
+                    std::vector<std::string>& results, std::mutex& resultsMutex);
+    void finish_search(const std::shared_ptr<SearchState>& state,
+                       const StreamSearchSummary& summary);
+};
+
+} // namespace wpp::fs

package/framework/src/Input/API/Input.ts

@@ -0,0 +1,161 @@
+export interface InputKeyEvent {
+  type: 'keydown' | 'keyup';
+  key: string;
+  keyName: string;
+  keycode: number;
+  scancode: number;
+  ctrl: boolean;
+  shift: boolean;
+  alt: boolean;
+  meta: boolean;
+  repeat: boolean;
+  global: boolean;
+  windowId: string;
+  pressedKeys: string[];
+}
+
+export interface ShortcutEvent {
+  id: string;
+  event: InputKeyEvent;
+}
+
+interface PendingCall {
+  resolve: (value: any) => void;
+  reject: (reason: Error) => void;
+}
+
+let callId = 0;
+const pending = new Map<string, PendingCall>();
+const keyListeners = new Set<(event: InputKeyEvent) => void>();
+const shortcutListeners = new Set<(event: ShortcutEvent) => void>();
+let streamEnabled = false;
+
+function getGlobal(): any {
+  if (typeof window !== 'undefined') return window;
+  if (typeof globalThis !== 'undefined') return globalThis;
+  return {};
+}
+
+const globalObject = getGlobal();
+const previousResponse = globalObject.__response__;
+const previousInputEvent = globalObject.__wpp_input_event__;
+
+globalObject.__response__ = function(id: string, result: any, error?: string) {
+  const request = pending.get(id);
+  if (request) {
+    pending.delete(id);
+    if (error) {
+      request.reject(new Error(error));
+    } else {
+      request.resolve(result);
+    }
+    return;
+  }
+
+  if (previousResponse) {
+    previousResponse(id, result, error);
+  }
+};
+
+globalObject.__wpp_input_event__ = function(eventName: string, payload: any) {
+  if (eventName === 'key') {
+    keyListeners.forEach((listener) => listener(payload as InputKeyEvent));
+  } else if (eventName === 'shortcut') {
+    shortcutListeners.forEach((listener) => listener(payload as ShortcutEvent));
+  }
+
+  if (previousInputEvent) {
+    previousInputEvent(eventName, payload);
+  }
+};
+
+function invoke<T>(method: string, params: unknown[] = []): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const id = `input:${++callId}`;
+    pending.set(id, { resolve, reject });
+    const payload = JSON.stringify({ id, method, params });
+
+    if (globalObject.__native_invoke__) {
+      globalObject.__native_invoke__(payload);
+      return;
+    }
+
+    if (globalObject.chrome?.webview?.postMessage) {
+      globalObject.chrome.webview.postMessage(payload);
+      return;
+    }
+
+    pending.delete(id);
+    reject(new Error('Native bridge not available'));
+  });
+}
+
+async function ensureStreamEnabled() {
+  if (streamEnabled) {
+    return;
+  }
+  await invoke<void>('input:setEventStreamEnabled', [true]);
+  streamEnabled = true;
+}
+
+export async function onKeyEvent(listener: (event: InputKeyEvent) => void): Promise<() => void> {
+  await ensureStreamEnabled();
+  keyListeners.add(listener);
+  return () => {
+    keyListeners.delete(listener);
+  };
+}
+
+export function onShortcut(listener: (event: ShortcutEvent) => void): () => void {
+  shortcutListeners.add(listener);
+  return () => {
+    shortcutListeners.delete(listener);
+  };
+}
+
+export function getPressedKeys(): Promise<string[]> {
+  return invoke<string[]>('input:getPressedKeys');
+}
+
+export function isPressed(key: string): Promise<boolean> {
+  return invoke<boolean>('input:isPressed', [key]);
+}
+
+export function registerLocalShortcut(id: string, shortcut: string): Promise<void> {
+  return invoke<void>('input:registerLocalShortcut', [id, shortcut]);
+}
+
+export function registerAppShortcut(id: string, shortcut: string): Promise<void> {
+  return registerLocalShortcut(id, shortcut);
+}
+
+export function registerGlobalHotkey(id: string, shortcut: string): Promise<void> {
+  return invoke<void>('input:registerGlobalHotkey', [id, shortcut]);
+}
+
+export function registerGlobalShortcut(id: string, shortcut: string): Promise<void> {
+  return registerGlobalHotkey(id, shortcut);
+}
+
+export function unregisterShortcut(id: string): Promise<void> {
+  return invoke<void>('input:unregisterShortcut', [id]);
+}
+
+export function clearShortcuts(): Promise<void> {
+  return invoke<void>('input:clearShortcuts');
+}
+
+export const input = {
+  onKeyEvent,
+  onShortcut,
+  getPressedKeys,
+  isPressed,
+  registerAppShortcut,
+  registerLocalShortcut,
+  registerGlobalShortcut,
+  registerGlobalHotkey,
+  unregisterShortcut,
+  clearShortcuts,
+};
+
+export default input;