@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/core/modules/ide/commands.js

@@ -0,0 +1,191 @@
+import { commandHelp } from "./command-help.js";
+const punctuationByCode = {
+    Space: " ",
+    Minus: "-",
+    Equal: "=",
+    BracketLeft: "[",
+    BracketRight: "]",
+    Backslash: "\\",
+    Semicolon: ";",
+    Quote: "'",
+    Backquote: "`",
+    Comma: ",",
+    Period: ".",
+    Slash: "/",
+    IntlBackslash: "\\",
+};
+/** Буква, цифра и знак — по позиции клавиши US QWERTY. Enter, F2 и стрелки остаются `event.key`. */
+export function shortcutKey(event) {
+    const code = event.code ?? "";
+    if (/^Key[A-Z]$/.test(code))
+        return code.slice(3).toLowerCase();
+    if (/^Digit[0-9]$/.test(code))
+        return code.slice(5);
+    return punctuationByCode[code] ?? event.key;
+}
+export function matchesContext(when, context) {
+    return !when || Object.entries(when).every(([key, value]) => context[key] === value);
+}
+export function matchesKey(key, event) {
+    const parts = key.toLowerCase().split("+");
+    const name = parts.pop();
+    const pressed = shortcutKey(event);
+    const mod = parts.includes("mod");
+    return ((name === pressed.toLowerCase() || (name === "space" && pressed === " ")) &&
+        (mod ? !!(event.ctrlKey || event.metaKey) : !!event.ctrlKey === parts.includes("ctrl")) &&
+        (mod ? !(event.ctrlKey && event.metaKey) : !!event.metaKey === parts.includes("meta")) &&
+        !!event.altKey === parts.includes("alt") &&
+        !!event.shiftKey === parts.includes("shift"));
+}
+export function parseKeybindings(value) {
+    if (!Array.isArray(value) || value.length > 500)
+        throw new Error("Ожидается список до 500 привязок");
+    return value.map((item) => {
+        if (!item ||
+            typeof item !== "object" ||
+            typeof item.command !== "string" ||
+            !item.command.trim() ||
+            typeof item.key !== "string" ||
+            !item.key.trim())
+            throw new Error("Укажите command и key для каждой привязки");
+        const parts = item.key.split("+");
+        if (!parts.at(-1) ||
+            parts
+                .slice(0, -1)
+                .some((part) => !["mod", "ctrl", "meta", "alt", "shift"].includes(part.toLowerCase())) ||
+            new Set(parts.map((part) => part.toLowerCase())).size !== parts.length ||
+            (parts.some((part) => part.toLowerCase() === "mod") &&
+                parts.some((part) => ["ctrl", "meta"].includes(part.toLowerCase()))))
+            throw new Error(`Некорректная клавиша: ${item.key}`);
+        if (item.when !== undefined &&
+            (!item.when ||
+                Array.isArray(item.when) ||
+                typeof item.when !== "object" ||
+                Object.values(item.when).some((value) => value !== null && !["string", "boolean", "number"].includes(typeof value))))
+            throw new Error("when должен содержать значения ключей контекста");
+        for (const field of ["disabled", "allowInput"])
+            if (item[field] !== undefined && typeof item[field] !== "boolean")
+                throw new Error(`${field} должен быть boolean`);
+        return {
+            key: item.key,
+            command: item.command,
+            ...(item.when === undefined ? {} : { when: { ...item.when } }),
+            ...(item.args === undefined ? {} : { args: item.args }),
+            ...(item.disabled === undefined ? {} : { disabled: item.disabled }),
+            ...(item.allowInput === undefined ? {} : { allowInput: item.allowInput }),
+        };
+    });
+}
+export function createCommandService(defaults = []) {
+    const scopes = new Map();
+    const listeners = new Set();
+    let overrides = [];
+    let activeScope = "";
+    const notify = () => {
+        for (const listener of listeners)
+            listener();
+    };
+    // A user entry replaces this command's default bindings, including explicit unbinding.
+    const bindings = () => [
+        ...defaults.filter((rule) => !overrides.some((entry) => entry.command === rule.command)),
+        ...overrides,
+    ].filter((rule) => !rule.disabled);
+    function describe(scope, id, args) {
+        const entry = scopes.get(scope);
+        const command = entry?.commands.get(id);
+        if (!entry || !command)
+            return;
+        return {
+            id,
+            title: command.title,
+            description: command.description ?? commandHelp(id).description,
+            arguments: { ...(command.arguments ?? commandHelp(id).arguments) },
+            ...(command.palette === false ? { palette: false } : {}),
+            scope,
+            enabled: command.enabled?.(args) ?? true,
+            shortcut: bindings()
+                .findLast((rule) => rule.command === id && matchesContext(rule.when, entry.context()))
+                ?.key.replace(/Mod/g, "Ctrl"),
+        };
+    }
+    async function executeCommand(id, args, options = {}) {
+        const scope = options.scope ?? activeScope;
+        const entry = scopes.get(scope);
+        const command = entry?.commands.get(id);
+        if (!command)
+            throw new Error(`Команда ${id} не зарегистрирована в области ${scope || "(нет активной области)"}`);
+        if (options.signal?.aborted) {
+            const error = new Error("Выполнение отменено");
+            error.name = "AbortError";
+            throw error;
+        }
+        if (!describe(scope, id, args)?.enabled)
+            throw new Error(`Команда ${id} сейчас недоступна`);
+        return (await command.run(args, { signal: options.signal }));
+    }
+    function createScope(id, context) {
+        if (scopes.has(id))
+            throw new Error(`Область команд ${id} уже зарегистрирована`);
+        const entry = { context, commands: new Map() };
+        scopes.set(id, entry);
+        notify();
+        return {
+            id,
+            activate() {
+                activeScope = id;
+            },
+            registerCommand(command) {
+                if (entry.commands.has(command.id))
+                    throw new Error(`Команда ${command.id} уже зарегистрирована`);
+                entry.commands.set(command.id, command);
+                notify();
+                return () => {
+                    if (entry.commands.get(command.id) === command) {
+                        entry.commands.delete(command.id);
+                        notify();
+                    }
+                };
+            },
+            describe: (command, args) => describe(id, command, args),
+            executeCommand: (command, args, options = {}) => executeCommand(command, args, { ...options, scope: id }),
+            resolveKeybinding(event, inputFocus = false) {
+                if (event.isComposing || event.repeat)
+                    return;
+                const contextKeys = { ...context(), inputFocus };
+                return bindings().findLast((rule) => (rule.allowInput || !inputFocus) &&
+                    matchesKey(rule.key, event) &&
+                    matchesContext(rule.when, contextKeys) &&
+                    describe(id, rule.command, rule.args)?.enabled);
+            },
+            dispose() {
+                if (scopes.get(id) === entry) {
+                    scopes.delete(id);
+                    if (activeScope === id)
+                        activeScope = "";
+                    notify();
+                }
+            },
+        };
+    }
+    return {
+        createScope,
+        describeCommand: describe,
+        executeCommand,
+        getCommands: () => [...scopes.keys()].flatMap((scope) => [...scopes.get(scope).commands.keys()].map((id) => describe(scope, id))),
+        getActiveScope: () => activeScope,
+        getScopes: () => [...scopes.entries()].map(([id, scope]) => ({ id, context: scope.context() })),
+        getKeybindings: () => structuredClone(bindings()),
+        getDefaultKeybindings: () => structuredClone(defaults),
+        getKeybindingOverrides: () => structuredClone(overrides),
+        setKeybindings(value) {
+            overrides = parseKeybindings(value);
+            notify();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/packages/core/modules/ide/index.js

@@ -0,0 +1,6 @@
+export { createCommandService, parseKeybindings, matchesKey, matchesContext, shortcutKey, } from "./commands.js";
+export { defaultKeybindings } from "./keybindings.js";
+export { editKeybinding, recordedKey } from "./keybinding-editor.js";
+export { paletteCommands } from "./palette.js";
+export { agentCommandHandler } from "./agent-command.js";
+export { commandIsSafe } from "./safety.js";

package/packages/core/modules/ide/keybinding-editor.js

@@ -0,0 +1,34 @@
+import { shortcutKey } from "./commands.js";
+// Replacing one row must preserve the command's other bindings and all other commands.
+export function editKeybinding(defaults, overrides, command, index, key) {
+    const custom = overrides.filter((rule) => rule.command === command);
+    const rules = structuredClone(custom.length ? custom : defaults.filter((rule) => rule.command === command));
+    const previous = rules[index];
+    const replacement = {
+        ...previous,
+        command,
+        key: key ?? previous?.key ?? "Unassigned",
+        disabled: key === null,
+    };
+    if (previous)
+        rules[index] = replacement;
+    else
+        rules.push(replacement);
+    return [...overrides.filter((rule) => rule.command !== command), ...rules];
+}
+export function recordedKey(event) {
+    if (event.isComposing ||
+        event.repeat ||
+        ["Control", "Meta", "Alt", "Shift", "Dead", "Unidentified", "+"].includes(event.key))
+        return;
+    const key = shortcutKey(event);
+    return [
+        event.ctrlKey && "Ctrl",
+        event.metaKey && "Meta",
+        event.altKey && "Alt",
+        event.shiftKey && "Shift",
+        key === " " ? "Space" : key.length === 1 ? key.toUpperCase() : key,
+    ]
+        .filter(Boolean)
+        .join("+");
+}

package/packages/core/modules/ide/keybindings.js

@@ -0,0 +1,45 @@
+const tree = { surface: "fileTree" };
+export const defaultKeybindings = [
+    { key: "Mod+Shift+P", command: "ide.workbench.commandPalette.open", allowInput: true },
+    { key: "F1", command: "ide.workbench.commandPalette.open", allowInput: true },
+    { key: "F2", command: "ide.fileTree.file.rename", when: { ...tree, entryKind: "file" } },
+    {
+        key: "F2",
+        command: "ide.fileTree.directory.rename",
+        when: { ...tree, entryKind: "directory" },
+    },
+    { key: "Delete", command: "ide.fileTree.entry.delete", when: tree },
+    { key: "Mod+C", command: "ide.fileTree.entry.copy", when: tree },
+    { key: "Mod+X", command: "ide.fileTree.entry.cut", when: tree },
+    { key: "Mod+V", command: "ide.fileTree.entry.paste", when: tree },
+    { key: "Enter", command: "ide.fileTree.file.open", when: { ...tree, entryKind: "file" } },
+    {
+        key: "Enter",
+        command: "ide.fileTree.directory.toggle",
+        when: { ...tree, entryKind: "directory" },
+    },
+    { key: "Shift+F10", command: "ide.fileTree.contextMenu", when: tree },
+    { key: "ContextMenu", command: "ide.fileTree.contextMenu", when: tree },
+    { key: "ArrowRight", command: "ide.workbench.tabs.next" },
+    { key: "ArrowLeft", command: "ide.workbench.tabs.previous" },
+    { key: "Home", command: "ide.workbench.tabs.first" },
+    { key: "End", command: "ide.workbench.tabs.last" },
+    { key: "Shift+F10", command: "ide.workbench.tabs.contextMenu" },
+    { key: "ContextMenu", command: "ide.workbench.tabs.contextMenu" },
+    { key: "F2", command: "ide.workbench.tabs.rename" },
+    { key: "Alt+PageDown", command: "ide.workbench.tab.next" },
+    { key: "Alt+PageUp", command: "ide.workbench.tab.previous" },
+    { key: "Mod+S", command: "ide.editor.file.save", when: { surface: "editor" }, allowInput: true },
+    {
+        key: "Mod+Shift+L",
+        command: "ide.editor.selection.toChat",
+        when: { surface: "editor" },
+        allowInput: true,
+    },
+    {
+        key: "Mod+Shift+M",
+        command: "ide.editor.markdown.toggleSource",
+        when: { surface: "editor" },
+        allowInput: true,
+    },
+];

package/packages/core/modules/ide/palette.js

@@ -0,0 +1,33 @@
+export function paletteCommands(commands, scopes, sourceScope, query = "") {
+    const contexts = new Map(scopes.map((scope) => [scope.id, scope.context]));
+    const source = contexts.get(sourceScope);
+    const selected = new Map();
+    for (const command of commands) {
+        if (command.palette === false)
+            continue;
+        const context = contexts.get(command.scope);
+        if (source?.projectId && context?.projectId && context.projectId !== source.projectId)
+            continue;
+        const group = context?.surface === "fileTree"
+            ? "Файлы"
+            : context?.surface === "editor"
+                ? "Редактор"
+                : context?.namespace === "ide.workbench.tabs"
+                    ? "Вкладки"
+                    : context?.surface === "keybindings"
+                        ? "Горячие клавиши"
+                        : "IDE";
+        const previous = selected.get(command.id);
+        if (!previous ||
+            command.scope === sourceScope ||
+            (previous.scope !== sourceScope && command.enabled && !previous.enabled))
+            selected.set(command.id, { ...command, group });
+    }
+    const tokens = query.trim().replace(/^>\s*/, "").toLocaleLowerCase().split(/\s+/).filter(Boolean);
+    return [...selected.values()]
+        .filter((command) => tokens.every((token) => `${command.title} ${command.id} ${command.group}`.toLocaleLowerCase().includes(token)))
+        .sort((a, b) => Number(b.enabled) - Number(a.enabled) ||
+        Number(b.scope === sourceScope) - Number(a.scope === sourceScope) ||
+        a.title.localeCompare(b.title, "ru") ||
+        a.id.localeCompare(b.id));
+}

package/packages/core/modules/ide/safety.js

@@ -0,0 +1,10 @@
+const CHANGING = new Set("delete remove rm clear kill stop reset discard revert push pull commit stage unstage merge clone install uninstall password run exec start restart save import write create new rename move add set apply send input login logout shell prune build up down".split(" "));
+const LOOKING = new Set("read result list get info search refresh describe status find more filter open toggle focus show copy recent diff log worktree".split(" "));
+/**
+ * Commands that only look at or open something do not need the user's permission. The words of a
+ * command id are split at dots, dashes, underscores and camel-case boundaries.
+ */
+export function commandIsSafe(command) {
+    const words = command.split(/[.\-_]|(?<=[a-z])(?=[A-Z])/).map((word) => word.toLowerCase());
+    return words.some((word) => LOOKING.has(word)) && !words.some((word) => CHANGING.has(word));
+}

package/packages/core/modules/launcher/actions.js

@@ -0,0 +1,5 @@
+/** Search results expose primary actions only; detail owns the full action policy. */
+export async function resolveLauncherAction(client, item, id, detail) {
+    const actions = detail?.actions ?? (await client.detail(item.id)).actions;
+    return actions.find((action) => action.id === id);
+}

package/packages/core/modules/launcher/index.js

@@ -0,0 +1,5 @@
+export { createLauncherClient, launchSectionTitles } from "./launcher.js";
+export { shortcuts } from "./launcher.js";
+export { createLauncherModel } from "./launcher-model.js";
+export { parseLaunchQuery, launchScopeTitles } from "./query.js";
+export { resolveLauncherAction } from "./actions.js";

package/packages/core/modules/launcher/launcher-model.js

@@ -0,0 +1,236 @@
+/** UI-independent search, selection and launch state shared by GTK and Vue. */
+export function createLauncherModel(client) {
+    const state = {
+        query: "",
+        focus: null,
+        detail: null,
+        detailLoading: false,
+        detailReady: false,
+        items: [],
+        selected: 0,
+        loading: true,
+        busy: false,
+        error: "",
+        warning: "",
+        notice: "",
+        route: "",
+    };
+    const listeners = new Set();
+    let generation = 0;
+    let timer;
+    let controller;
+    let disposed = false;
+    const emit = () => {
+        if (!disposed)
+            for (const listener of listeners)
+                listener({ ...state });
+    };
+    let detailController;
+    const leave = () => {
+        detailController?.abort();
+        state.focus = null;
+        state.detail = null;
+        state.detailReady = false;
+        state.detailLoading = false;
+    };
+    const invalidate = () => {
+        generation++;
+        clearTimeout(timer);
+        controller?.abort();
+    };
+    async function search(background = false) {
+        invalidate();
+        const current = generation;
+        controller = new AbortController();
+        if (!background)
+            state.loading = true;
+        state.error = "";
+        emit();
+        try {
+            const data = await client.search(state.query, AbortSignal.any([controller.signal, AbortSignal.timeout(15000)]));
+            if (disposed || current !== generation)
+                return;
+            state.items = data.items;
+            state.warning = data.warning ?? "";
+            state.selected = 0;
+        }
+        catch (error) {
+            if (!disposed && current === generation) {
+                state.items = [];
+                state.selected = 0;
+                state.warning = "";
+                state.error = error instanceof Error ? error.message : "Не удалось выполнить поиск";
+            }
+        }
+        finally {
+            if (!disposed && current === generation) {
+                state.loading = false;
+                emit();
+            }
+        }
+    }
+    let stopEvents;
+    let refreshTimer;
+    /** Quiet reload after a process event: keeps the selected row and the open card. */
+    async function refresh() {
+        if (disposed || state.busy || state.loading)
+            return;
+        const selectedId = state.items[state.selected]?.id;
+        const focused = state.focus;
+        await search(true);
+        const index = state.items.findIndex((entry) => entry.id === selectedId);
+        if (index >= 0 && !disposed) {
+            state.selected = index;
+            emit();
+        }
+        if (focused && state.focus?.id === focused.id) {
+            try {
+                const detail = await client.detail(focused.id, AbortSignal.timeout(15000));
+                if (!disposed && state.focus?.id === focused.id) {
+                    state.detail = detail;
+                    state.detailReady = true;
+                    emit();
+                }
+            }
+            catch {
+                /* The card keeps its previous data until the next event. */
+            }
+        }
+    }
+    return {
+        get state() {
+            return state;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            listener({ ...state });
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        search,
+        refresh,
+        /** Follows process events while enabled (the palette is visible). */
+        live(enabled) {
+            stopEvents?.();
+            stopEvents = undefined;
+            clearTimeout(refreshTimer);
+            if (!enabled || disposed || !client.subscribe)
+                return;
+            stopEvents = client.subscribe(() => {
+                clearTimeout(refreshTimer);
+                refreshTimer = setTimeout(() => void refresh(), 150);
+            });
+        },
+        setQuery(query) {
+            leave();
+            state.query = query;
+            state.notice = "";
+            invalidate();
+            state.loading = true;
+            emit();
+            timer = setTimeout(() => {
+                void search();
+            }, 80);
+        },
+        select(index) {
+            state.selected = Math.max(0, Math.min(state.items.length - 1, index));
+            emit();
+        },
+        move(delta) {
+            this.select(state.selected + delta);
+        },
+        /** Действие по умолчанию — первое у элемента; `inline` оставляет переход клиенту. */
+        /** Вход в элемент: загружает все его действия и последний сбой запуска. */
+        async enter(item = state.items[state.selected]) {
+            if (!item || state.busy || disposed)
+                return false;
+            leave();
+            state.focus = item;
+            state.detail = { actions: item.actions ?? [] };
+            state.detailLoading = true;
+            state.error = "";
+            detailController = new AbortController();
+            const current = detailController;
+            emit();
+            try {
+                const detail = await client.detail(item.id, AbortSignal.any([current.signal, AbortSignal.timeout(15000)]));
+                if (disposed || current.signal.aborted)
+                    return true;
+                state.detail = detail;
+                state.detailReady = true;
+            }
+            catch (error) {
+                if (!disposed && !current.signal.aborted)
+                    state.error = error instanceof Error ? error.message : "Не удалось загрузить действия";
+            }
+            finally {
+                if (!disposed && !current.signal.aborted) {
+                    state.detailLoading = false;
+                    emit();
+                }
+            }
+            return true;
+        },
+        leave() {
+            leave();
+            emit();
+        },
+        async launch(item = state.items[state.selected], action, inline = false) {
+            const chosen = typeof action === "string"
+                ? (item?.actions?.find((entry) => entry.id === action) ?? { id: action, title: "" })
+                : (action ?? item?.actions?.[0]);
+            if (!item || state.busy || state.loading || disposed)
+                return false;
+            state.busy = true;
+            state.error = "";
+            state.notice = "";
+            state.route = "";
+            emit();
+            try {
+                const result = await client.launch(item.id, chosen?.id, inline, chosen?.arg);
+                if (disposed)
+                    return false;
+                state.route = result?.route ?? "";
+                state.notice = `${item.name} — ${chosen?.id === "favorite"
+                    ? result?.favorite
+                        ? "добавлено в избранное"
+                        : "убрано из избранного"
+                    : chosen?.id === "folder"
+                        ? result?.favorite
+                            ? "папка добавлена в избранные"
+                            : "папка убрана из избранных"
+                        : chosen?.id === "create"
+                            ? "проект создан"
+                            : chosen?.id === "import"
+                                ? "клонировано и добавлено"
+                                : chosen?.id === "open"
+                                    ? "открыто"
+                                    : chosen?.id === "stop"
+                                        ? "остановлено"
+                                        : "запущено"}`;
+                return true;
+            }
+            catch (error) {
+                state.error = error instanceof Error ? error.message : "Не удалось запустить";
+                return false;
+            }
+            finally {
+                state.busy = false;
+                emit();
+            }
+        },
+        reportError(error) {
+            state.error = error instanceof Error ? error.message : String(error);
+            emit();
+        },
+        dispose() {
+            disposed = true;
+            detailController?.abort();
+            stopEvents?.();
+            clearTimeout(refreshTimer);
+            invalidate();
+            listeners.clear();
+        },
+    };
+}

package/packages/core/modules/launcher/launcher.js

@@ -0,0 +1,76 @@
+export const shortcuts = ["", "Ctrl+Alt+Space", "Super+Space", "Alt+Space"];
+export const launchSectionTitles = {
+    favorites: "Избранное",
+    running: "Работает",
+    recent: "Недавние",
+    projects: "Проекты",
+    disk: "На диске",
+    apps: "Приложения",
+};
+/** Same HTTP contract in the browser and the native Node process. */
+export function createLauncherClient(baseUrl = "") {
+    async function request(path, body, signal) {
+        const response = await fetch(baseUrl + path, {
+            method: body === undefined ? "GET" : "POST",
+            headers: body === undefined ? undefined : { "Content-Type": "application/json" },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: signal ?? AbortSignal.timeout(15000),
+        });
+        const data = await response.json();
+        if (!response.ok)
+            throw new Error(data.error || `Ошибка запроса (${response.status})`);
+        return data;
+    }
+    return {
+        search: (query, signal, options) => {
+            const params = new URLSearchParams({ q: query });
+            if (options?.disk === false)
+                params.set("disk", "0");
+            return request(`/api/launcher/search?${params}`, undefined, signal);
+        },
+        /** `inline` — клиент сам перейдёт по `route`, сервер не открывает окно. */
+        launch: (id, action, inline = false, arg) => request("/api/launcher/launch", { id, action, inline, arg }),
+        detail: (id, signal) => request(`/api/launcher/detail?id=${encodeURIComponent(id)}`, undefined, signal),
+        /**
+         * Server-sent `status` events about project processes. Uses fetch streaming so that the
+         * browser and the native Node process share one implementation; reconnects until stopped.
+         */
+        subscribe(onStatus) {
+            const controller = new AbortController();
+            void (async () => {
+                while (!controller.signal.aborted) {
+                    try {
+                        const response = await fetch(`${baseUrl}/api/events`, { signal: controller.signal });
+                        if (!response.ok || !response.body)
+                            throw new Error(String(response.status));
+                        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+                        let buffer = "";
+                        for (;;) {
+                            const { value, done } = await reader.read();
+                            if (done)
+                                break;
+                            buffer += value;
+                            let end;
+                            while ((end = buffer.indexOf("\n\n")) >= 0) {
+                                const block = buffer.slice(0, end);
+                                buffer = buffer.slice(end + 2);
+                                if (/^event: status$/m.test(block))
+                                    onStatus();
+                            }
+                        }
+                    }
+                    catch {
+                        /* Retry below unless stopped. */
+                    }
+                    if (!controller.signal.aborted)
+                        await new Promise((done) => setTimeout(done, 2000));
+                }
+            })();
+            return () => controller.abort();
+        },
+        hide: () => request("/api/app/hide", {}),
+        open: (toggle = false, mode) => request("/api/app/open", { toggle, mode }),
+        quit: () => request("/api/app/quit", {}),
+        restart: () => request("/api/app/restart", {}),
+    };
+}