@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/core/modules/file-icons/contract.js

@@ -0,0 +1,177 @@
+import { z } from "zod";
+const names = z.array(z.string().min(1).max(256)).min(1);
+const iconId = z.string().min(1);
+const hex = /^#[\da-f]{6}$/i;
+const ruleSchema = z
+    .strictObject({
+    id: z.string().min(1),
+    kind: z.enum(["file", "directory"]),
+    names: names.optional(),
+    extensions: names.optional(),
+    patterns: names.optional(),
+    paths: names.optional(),
+    caseSensitive: z.boolean().optional(),
+    executable: z.boolean().optional(),
+    icon: iconId,
+    expandedIcon: iconId.optional(),
+})
+    .refine((rule) => Boolean(rule.names ||
+    rule.extensions ||
+    rule.patterns ||
+    rule.paths ||
+    rule.executable !== undefined), {
+    message: "A rule needs names, extensions, patterns, paths or executable",
+});
+export const fileIconThemeSchema = z
+    .strictObject({
+    $schema: z.string().optional(),
+    version: z.literal(1),
+    name: z.string().min(1),
+    palette: z.record(z.string(), z.string().regex(hex)),
+    icons: z.record(z.string(), z.strictObject({
+        // Same-origin assets only; no executable markup or remote requests from configuration.
+        src: z
+            .string()
+            .regex(/^\/file-icons\/(?:[\w-]+\/)*[\w.-]+\.svg$/)
+            .refine((src) => !src.includes("..")),
+        color: z.string().min(1),
+    })),
+    defaults: z.strictObject({ file: iconId, directory: iconId, expandedDirectory: iconId }),
+    rules: z.array(ruleSchema),
+})
+    .superRefine((theme, context) => {
+    const checkIcon = (id, path) => {
+        if (!Object.hasOwn(theme.icons, id))
+            context.addIssue({ code: "custom", path, message: `Unknown icon: ${id}` });
+    };
+    for (const [key, id] of Object.entries(theme.defaults))
+        checkIcon(id, ["defaults", key]);
+    for (const [id, icon] of Object.entries(theme.icons)) {
+        if (!hex.test(icon.color) && !Object.hasOwn(theme.palette, icon.color))
+            context.addIssue({
+                code: "custom",
+                path: ["icons", id, "color"],
+                message: `Unknown color: ${icon.color}`,
+            });
+    }
+    const ids = new Set();
+    theme.rules.forEach((rule, index) => {
+        if (ids.has(rule.id))
+            context.addIssue({
+                code: "custom",
+                path: ["rules", index, "id"],
+                message: `Duplicate rule: ${rule.id}`,
+            });
+        ids.add(rule.id);
+        checkIcon(rule.icon, ["rules", index, "icon"]);
+        if (rule.expandedIcon)
+            checkIcon(rule.expandedIcon, ["rules", index, "expandedIcon"]);
+        if (rule.kind === "directory" && rule.extensions)
+            context.addIssue({
+                code: "custom",
+                path: ["rules", index, "extensions"],
+                message: "Extensions only apply to files",
+            });
+        if (rule.kind === "directory" && rule.executable !== undefined)
+            context.addIssue({
+                code: "custom",
+                path: ["rules", index, "executable"],
+                message: "Executable only applies to files",
+            });
+    });
+});
+// * and ? stay inside a path segment; ** crosses folders; **/ also matches zero folders.
+function glob(pattern, sensitive) {
+    let source = "";
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        if (char === "*" && pattern[i + 1] === "*") {
+            i++;
+            if (pattern[i + 1] === "/") {
+                source += "(?:.*/)?";
+                i++;
+            }
+            else
+                source += ".*";
+        }
+        else if (char === "*")
+            source += "[^/]*";
+        else if (char === "?")
+            source += "[^/]";
+        else
+            source += char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    return new RegExp(`^${source}$`, sensitive ? "" : "i");
+}
+/** Framework-independent, immutable snapshot. Ordered rules: the first match wins. */
+export function createFileIconResolver(input) {
+    const theme = fileIconThemeSchema.parse(input);
+    const rules = theme.rules.map((rule) => {
+        const normalize = (value) => (rule.caseSensitive ? value : value.toLowerCase());
+        const names = new Set(rule.names?.map(normalize));
+        const extensions = rule.extensions?.map((value) => normalize(value.replace(/^\./, "")));
+        const patterns = rule.patterns?.map((value) => glob(value, !!rule.caseSensitive));
+        const paths = rule.paths?.map((value) => glob(value, !!rule.caseSensitive));
+        return {
+            rule,
+            matches(entry) {
+                if (entry.directory !== (rule.kind === "directory"))
+                    return false;
+                if (rule.executable !== undefined && rule.executable !== !!entry.executable)
+                    return false;
+                const name = normalize(entry.name);
+                const path = entry.path.replaceAll("\\", "/").replace(/^\.\//, "");
+                return ((rule.executable !== undefined &&
+                    !rule.names &&
+                    !rule.extensions &&
+                    !rule.patterns &&
+                    !rule.paths) ||
+                    names.has(name) ||
+                    extensions?.some((ext) => name.length > ext.length + 1 && name.endsWith(`.${ext}`)) ||
+                    patterns?.some((pattern) => pattern.test(entry.name)) ||
+                    paths?.some((pattern) => pattern.test(path)));
+            },
+        };
+    });
+    return {
+        name: theme.name,
+        resolve(entry, expanded = false) {
+            const rule = rules.find((rule) => rule.matches(entry))?.rule;
+            if (entry.directory) {
+                const id = expanded ? theme.defaults.expandedDirectory : theme.defaults.directory;
+                const badgeId = expanded ? (rule?.expandedIcon ?? rule?.icon) : rule?.icon;
+                const badge = badgeId &&
+                    badgeId !== id &&
+                    badgeId !== theme.defaults.directory &&
+                    badgeId !== theme.defaults.expandedDirectory
+                    ? theme.icons[badgeId]
+                    : undefined;
+                const icon = theme.icons[id];
+                const color = badge?.color ?? icon.color;
+                return {
+                    id,
+                    src: icon.src,
+                    color: theme.palette[color] ?? color,
+                    ruleId: rule?.id,
+                    ...(badge && badgeId
+                        ? {
+                            badge: {
+                                id: badgeId,
+                                src: badge.src,
+                                color: theme.palette[badge.color] ?? badge.color,
+                            },
+                        }
+                        : {}),
+                };
+            }
+            const id = rule?.icon ?? theme.defaults.file;
+            const icon = theme.icons[id];
+            return {
+                id,
+                src: icon.src,
+                color: theme.palette[icon.color] ?? icon.color,
+                ruleId: rule?.id,
+            };
+        },
+    };
+}

package/packages/core/modules/file-icons/index.js

@@ -0,0 +1 @@
+export { createFileIconResolver } from "./contract.js";

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

@@ -0,0 +1,23 @@
+import { normalizeGithubRepository } from "../project/index.js";
+export function githubProjectRoute(repository) {
+    const name = normalizeGithubRepository(repository);
+    return `/gh/projects/${name.split("/").map(encodeURIComponent).join("/")}`;
+}
+const REMOTE_URL = /^(?:https?|git|ssh):\/\/(?:[^@/]+@)?(?:ssh\.)?github\.com(?::\d+)?\/([^/?#]+)\/([^/?#]+)/i;
+const REMOTE_SCP = /^(?:[^@/]+@)?github\.com:([^/]+)\/(.+)$/i;
+/**
+ * `origin` remote of a local repository as `owner/repository`, or null when it does not point
+ * at GitHub. Accepts HTTPS, `git://`, `ssh://` and the scp-like `git@github.com:owner/repo.git`.
+ */
+export function githubRepositoryFromRemote(remote) {
+    const value = remote.trim();
+    const match = REMOTE_URL.exec(value) ?? REMOTE_SCP.exec(value);
+    if (!match)
+        return null;
+    try {
+        return normalizeGithubRepository(`${match[1]}/${match[2]}`);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,164 @@
+/** The only instance Projector is allowed to reach without explicit configuration. */
+export const GITLAB_DEFAULT_INSTANCE = "gitlab.com";
+export const GITLAB_PREFIX = "gl:/";
+const INVALID_INSTANCE = "Укажите адрес GitLab вида https://gitlab.example.com";
+const INVALID_PROJECT = "Укажите group/project или ссылку на проект GitLab";
+const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//;
+const PROJECT_SEGMENT = /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/;
+function authorityFromUrl(url) {
+    if (!["http:", "https:"].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        (url.pathname !== "" && url.pathname !== "/"))
+        throw new Error(INVALID_INSTANCE);
+    return url.host.toLowerCase();
+}
+/**
+ * `https://gitlab.example.com/`, `gitlab.example.com` or `gitlab.example.com:8443` as an authority.
+ * Credentials, paths, queries and hashes are rejected: the install prefix belongs to settings.
+ */
+export function normalizeGitlabInstance(value) {
+    const raw = value.trim();
+    if (!raw)
+        throw new Error(INVALID_INSTANCE);
+    let url;
+    try {
+        url = new URL(SCHEME.test(raw) ? raw : `http://${raw}`);
+    }
+    catch {
+        throw new Error(INVALID_INSTANCE);
+    }
+    return authorityFromUrl(url);
+}
+function projectSegments(name) {
+    const parts = name.split("/");
+    if (parts.length < 2 ||
+        parts.some((part) => !part ||
+            part === "." ||
+            part === ".." ||
+            !PROJECT_SEGMENT.test(part) ||
+            /\.(git|atom)$/i.test(part)))
+        throw new Error(INVALID_PROJECT);
+    return parts.join("/");
+}
+function projectPathFromUrl(url, instance) {
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+        throw new Error(INVALID_PROJECT);
+    if (instance) {
+        let expected;
+        try {
+            expected = normalizeGitlabInstance(instance);
+        }
+        catch {
+            throw new Error(INVALID_INSTANCE);
+        }
+        if (url.host.toLowerCase() !== expected)
+            throw new Error("Ссылка ведёт на другой инстанс GitLab. Проверьте адрес");
+    }
+    return url.pathname;
+}
+/**
+ * `group/sub/project` from a path or a link to an instance. `/-/tree/main`, `.git`, query and hash
+ * are removed; when `instance` is passed, a link to another host is rejected.
+ */
+export function normalizeGitlabProjectPath(value, instance) {
+    const raw = value.trim();
+    if (!raw)
+        throw new Error(INVALID_PROJECT);
+    let name;
+    if (SCHEME.test(raw)) {
+        let url;
+        try {
+            url = new URL(raw);
+        }
+        catch {
+            throw new Error(INVALID_PROJECT);
+        }
+        name = projectPathFromUrl(url, instance);
+    }
+    else if (raw.startsWith(GITLAB_PREFIX)) {
+        const rest = raw.slice(GITLAB_PREFIX.length);
+        const slash = rest.indexOf("/");
+        if (slash < 0)
+            throw new Error(INVALID_PROJECT);
+        const authority = rest.slice(0, slash);
+        if (instance && normalizeGitlabInstance(authority) !== normalizeGitlabInstance(instance))
+            throw new Error("Ссылка ведёт на другой инстанс GitLab. Проверьте адрес");
+        name = rest.slice(slash + 1);
+    }
+    else {
+        name = raw.split(/[?#]/, 1)[0] ?? "";
+        if (instance) {
+            const authority = normalizeGitlabInstance(instance);
+            if (name.toLowerCase().startsWith(`${authority}/`))
+                name = name.slice(authority.length + 1);
+        }
+    }
+    const project = name
+        .replace(/\/-\/.*$/, "")
+        .replace(/^\/+|\/+$/g, "")
+        .replace(/\.git$/i, "");
+    return projectSegments(project);
+}
+/** Browser route of a GitLab project; the authority is always the first segment. */
+export function gitlabProjectRoute(instance, path) {
+    const authority = normalizeGitlabInstance(instance);
+    const name = normalizeGitlabProjectPath(path, authority);
+    const host = encodeURIComponent(authority).replaceAll("%3A", ":");
+    const segments = name.split("/").map(encodeURIComponent);
+    return `/gl/projects/${host}/${segments.join("/")}`;
+}
+/** Stable text form: `gl:/<authority>/<group>/<project>`. */
+export function gitlabProjectKey(instance, path) {
+    const authority = normalizeGitlabInstance(instance);
+    return `${GITLAB_PREFIX}${authority}/${normalizeGitlabProjectPath(path, authority)}`;
+}
+const REMOTE_SCHEME = /^([A-Za-z][A-Za-z0-9+.-]*):\/\//;
+const REMOTE_SCP = /^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/;
+const WEB_REMOTE = new Set(["http", "https"]);
+const GIT_REMOTE = new Set(["git", "ssh"]);
+/**
+ * `origin` remote of a local repository as an instance and a project path, or null when the
+ * remote is not shaped like a GitLab project. Accepts HTTP(S), `git://`, `ssh://` and scp-like
+ * `git@host:group/project.git`. An HTTP(S) authority keeps its port; git and SSH ports are not
+ * web ports and are dropped. Host allowlisting belongs to the server, which knows the settings.
+ */
+export function gitlabRepositoryFromRemote(remote) {
+    const value = remote.trim();
+    if (!value)
+        return null;
+    let instance;
+    let path;
+    const scheme = REMOTE_SCHEME.exec(value)?.[1]?.toLowerCase();
+    if (scheme) {
+        if (!WEB_REMOTE.has(scheme) && !GIT_REMOTE.has(scheme))
+            return null;
+        let url;
+        try {
+            url = new URL(value);
+        }
+        catch {
+            return null;
+        }
+        instance = WEB_REMOTE.has(scheme) ? url.host : url.hostname;
+        path = url.pathname;
+    }
+    else {
+        const match = REMOTE_SCP.exec(value);
+        if (!match)
+            return null;
+        instance = match[1];
+        path = match[2];
+    }
+    try {
+        return {
+            instance: normalizeGitlabInstance(instance),
+            path: normalizeGitlabProjectPath(path),
+        };
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1 @@
+export { HUB_PROTOCOL, isDeviceId, hubReturnPath } from "./protocol.js";

package/packages/core/modules/hub/protocol.js

@@ -0,0 +1,19 @@
+export const HUB_PROTOCOL = 1;
+export function isDeviceId(value) {
+    return typeof value === "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(value);
+}
+/** Only a same-origin device page can be resumed after signing in. */
+export function hubReturnPath(value) {
+    if (typeof value !== "string" || !value.startsWith("/devices/") || value.includes("\\"))
+        return "/";
+    try {
+        const url = new URL(value, "https://hub.invalid");
+        if (url.origin !== "https://hub.invalid" ||
+            !/^\/devices\/[a-z0-9][a-z0-9-]{0,62}(?:\/|$)/.test(url.pathname))
+            return "/";
+        return url.pathname + url.search + url.hash;
+    }
+    catch {
+        return "/";
+    }
+}

package/packages/core/modules/ide/agent-command.js

@@ -0,0 +1,48 @@
+/**
+ * Runs an agent's command request against the live registry of one project. The scopes are
+ * filtered to the project plus the global workbench, keybindings and settings surfaces; an agent
+ * never reaches another project's tabs.
+ */
+export function agentCommandHandler(api, projectId) {
+    return async (request, signal) => {
+        const scopes = api
+            .getScopes()
+            .filter(({ context }) => context.projectId === projectId ||
+            (context.projectId === undefined &&
+                ["workbench", "keybindings", "settings"].includes(String(context.surface))));
+        const allowed = new Set(scopes.map(({ id }) => id));
+        if (request.operation === "list") {
+            const query = (request.query ?? "").toLocaleLowerCase();
+            return {
+                scopes,
+                commands: api
+                    .getCommands()
+                    .filter((command) => allowed.has(command.scope) &&
+                    `${command.id} ${command.title} ${command.description}`
+                        .toLocaleLowerCase()
+                        .includes(query))
+                    .map(({ id, title, scope, enabled }) => ({ id, title, scope, enabled })),
+            };
+        }
+        if (!request.scope || !allowed.has(request.scope))
+            throw new Error("Область недоступна в текущем проекте");
+        if (!request.command)
+            throw new Error("Укажите ID команды");
+        const command = api.describeCommand(request.scope, request.command, request.args);
+        if (!command)
+            throw new Error("Команда не зарегистрирована");
+        if (request.operation === "describe")
+            return {
+                ...command,
+                context: scopes.find(({ id }) => id === request.scope).context,
+            };
+        if (request.operation !== "execute")
+            throw new Error("Неизвестная операция");
+        return ((await api.executeCommand(request.command, request.args, {
+            scope: request.scope,
+            signal,
+        })) ?? {
+            completed: true,
+        });
+    };
+}

package/packages/core/modules/ide/command-help.js

@@ -0,0 +1,73 @@
+/** Shared built-in argument documentation. Extensions can override it on registration. */
+export function commandHelp(id) {
+    if (id.includes(".tabs.")) {
+        const action = id.split(".").at(-1);
+        return {
+            description: "Действие над вкладками области. Без id используется текущая вкладка. Закрытие несохранённого файла может запросить подтверждение.",
+            arguments: action === "reorder"
+                ? { ids: "string[]: все идентификаторы вкладок без повторений в новом порядке" }
+                : action === "rename"
+                    ? {
+                        id: "string (необязательно): идентификатор вкладки",
+                        label: "string (необязательно): новое имя; без label откроется ввод имени",
+                    }
+                    : { id: "string (необязательно): идентификатор вкладки" },
+        };
+    }
+    if (id.startsWith("ide.workbench.panel."))
+        return {
+            description: "Действие над блоком вкладки: разделить вправо или вниз, скрыть блок. Без id используется активная вкладка блока с фокусом. Разделить можно блок минимум с двумя вкладками.",
+            arguments: { id: "string (необязательно): идентификатор вкладки" },
+        };
+    if (id.startsWith("ide.fileTree.")) {
+        const args = {
+            path: "string (необязательно): путь относительно корня проекта; без него текущая запись дерева",
+        };
+        args.kind = "string (необязательно): directory для действий над папкой; иначе file";
+        if (/\.(create|duplicate|rename|paste)$/.test(id))
+            args.directory = "string (необязательно): каталог назначения относительно корня";
+        if (/\.(create|duplicate|rename)$/.test(id))
+            args.name = "string (необязательно): имя записи; без него откроется диалог";
+        if (id.endsWith(".delete"))
+            args.confirm =
+                "boolean: true только при явном запросе пользователя на удаление; иначе диалог подтверждения";
+        return {
+            description: "Действие в дереве файлов текущего проекта. Явный path не зависит от выбранной строки. Файловые операции возвращают source/destination; открытие файла или диалога возвращает после передачи действия UI.",
+            arguments: /\.(refresh|collapseAll|contextMenu)$/.test(id) ? {} : args,
+        };
+    }
+    if (id.startsWith("ide.git."))
+        return {
+            description: "Действие Git в текущем проекте. stage/unstage/discard: path файла, префикс папки или пустая строка для всей группы. discard (в т.ч. для папки) восстанавливает рабочий файл из индекса; untracked переносит в корзину.",
+            arguments: id.endsWith(".refresh")
+                ? {}
+                : {
+                    path: "string: путь относительно проекта",
+                    staged: "boolean (необязательно): true для индекса, false для рабочей версии",
+                    ...(id.endsWith(".discard")
+                        ? {
+                            confirm: "boolean: true только при явном запросе пользователя на откат; иначе подтверждение",
+                        }
+                        : {}),
+                },
+        };
+    if (id.startsWith("ide.editor.file."))
+        return {
+            description: "Действие над уже открытым файлом. Без id используется активный файл. file.open открывает рабочую версию активного сравнения.",
+            arguments: { id: "string (необязательно): идентификатор открытой вкладки" },
+        };
+    if (id === "ide.keybindings.save")
+        return {
+            description: "Сохранить сочетание, записанное в открытом диалоге редактора клавиш. Требуется запись с клавиатуры.",
+            arguments: {},
+        };
+    if (id.startsWith("ide.keybindings."))
+        return {
+            description: "Действие над видимой строкой редактора клавиш.",
+            arguments: { command: "string: ID команды строки", index: "number: индекс её привязки" },
+        };
+    return {
+        description: "Действие в указанной области Projector; использует её текущий UI-контекст.",
+        arguments: {},
+    };
+}