@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/cli/modules/projects/index.js

@@ -0,0 +1,118 @@
+import { existsSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve, sep } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+const PROJECTS_FILE = () => join(dataDir(), "projects.json");
+function expandHome(value) {
+    if (value === "~")
+        return homedir();
+    if (value.startsWith("~/") || value.startsWith("~\\"))
+        return join(homedir(), value.slice(2));
+    return value;
+}
+function absolutePath(value) {
+    return resolve(expandHome(value));
+}
+function looksLikePath(value) {
+    return (value === "." ||
+        value === ".." ||
+        value.startsWith("/") ||
+        value.startsWith("~") ||
+        value.startsWith(".") ||
+        /^[A-Za-z]:[\\/]/.test(value) ||
+        value.includes("/") ||
+        value.includes("\\"));
+}
+function samePath(left, right) {
+    const a = absolutePath(left);
+    const b = absolutePath(right);
+    return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function insideProject(path, root) {
+    const parent = absolutePath(root).replace(/[\\/]+$/, "");
+    const child = absolutePath(path);
+    return child === parent || child.startsWith(`${parent}${sep}`);
+}
+function isReference(value) {
+    return (value.startsWith("gh:/") ||
+        value.startsWith("gl:") ||
+        value.startsWith("project:") ||
+        value.startsWith("path:"));
+}
+function norm(value) {
+    return value.toLocaleLowerCase();
+}
+/** Works without the server: the CLI must be able to list projects while it is stopped. */
+export async function readStoredProjects() {
+    try {
+        const parsed = JSON.parse(await readFile(PROJECTS_FILE(), "utf8"));
+        return Array.isArray(parsed.projects) ? parsed.projects : [];
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return [];
+        throw new Error(`Не удалось прочитать ${PROJECTS_FILE()}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function projectsFor(api) {
+    if (await api.health())
+        return (await api.projects()).projects;
+    return readStoredProjects();
+}
+export function selectProject(projects, target, options = {}) {
+    const value = target ?? process.cwd();
+    const exact = projects.find((project) => project.id === value || norm(project.name) === norm(value) || samePath(project.path, value));
+    if (exact)
+        return exact;
+    const candidate = absolutePath(value);
+    if (!target || (options.containing && looksLikePath(target))) {
+        return projects
+            .filter((project) => insideProject(candidate, project.path))
+            .sort((left, right) => right.path.length - left.path.length)[0];
+    }
+    return undefined;
+}
+export async function resolveProject(api, target) {
+    const projects = await projectsFor(api);
+    const project = selectProject(projects, target, { containing: true });
+    if (project)
+        return project;
+    const value = target ?? process.cwd();
+    if (target && looksLikePath(target))
+        throw new Error(`Проект не зарегистрирован: ${absolutePath(target)}. Откройте его: projector open ${target}`);
+    throw new Error(`Проект не найден: ${value}`);
+}
+export async function resolveOpenTarget(api, target) {
+    if (isReference(target))
+        return target;
+    const projects = await projectsFor(api);
+    const project = selectProject(projects, target);
+    if (project)
+        return `project:${project.id}`;
+    const path = absolutePath(target);
+    if (existsSync(path)) {
+        if (!statSync(path).isDirectory())
+            throw new Error(`Это не папка: ${path}`);
+        return `path:${path}`;
+    }
+    if (looksLikePath(target))
+        throw new Error(`Папка не найдена: ${path}`);
+    throw new Error(`Проект не найден: ${target}`);
+}
+export function projectState(project) {
+    const status = project.runtime?.status;
+    if (status === "starting")
+        return "запускается";
+    if (status === "running")
+        return "работает";
+    if (status === "stopping")
+        return "останавливается";
+    if (status === "error")
+        return "ошибка";
+    return "остановлен";
+}
+export function projectUrl(project) {
+    return project.runtime?.url || project.url || "";
+}

package/packages/cli/modules/server/index.js

@@ -0,0 +1,226 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { open, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { os } from "../../../core/modules/os/index.js";
+import { SERVER_MODES, isServerMode, } from "../../../core/modules/server-mode/index.js";
+import { serverLogPath, writeServerMode } from "../../../core/modules/app-paths/index.js";
+import { createServerProcesses } from "../server-process/index.js";
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Starts, restarts and probes the one local Projector server. */
+export function createServerControl({ root, dataDir, appUrl, packaged, launchMode, options, out, }) {
+    const lockPath = join(dataDir, "launch.lock");
+    const serverProcesses = createServerProcesses({
+        root,
+        dataDir,
+        packaged,
+        launchMode,
+        options,
+    });
+    async function serverInfo() {
+        try {
+            const response = await fetch(`${appUrl}/api/health`, { signal: AbortSignal.timeout(500) });
+            const data = (await response.json());
+            return response.ok && data.ok === true && data.app === "projector"
+                ? data
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async function health() {
+        return Boolean(await serverInfo());
+    }
+    async function openApp(appOptions = {}, action = "open") {
+        const response = await fetch(`${appUrl}/api/app/${action}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(appOptions),
+        });
+        if (!response.ok) {
+            const body = (await response.json().catch(() => ({})));
+            throw new Error(body.error || "Не удалось открыть окно");
+        }
+        return response.json().catch(() => ({}));
+    }
+    async function acquireLock() {
+        mkdirSync(dataDir, { recursive: true });
+        for (let i = 0; i < 80; i += 1) {
+            try {
+                const handle = await open(lockPath, "wx");
+                await handle.writeFile(String(process.pid));
+                return async () => {
+                    await handle.close();
+                    await unlink(lockPath).catch(() => undefined);
+                };
+            }
+            catch {
+                const raw = await readFile(lockPath, "utf8").catch(() => "");
+                const pid = Number(raw.trim());
+                if (pid && !isPidAlive(pid)) {
+                    await unlink(lockPath).catch(() => undefined);
+                    continue;
+                }
+                if (await health())
+                    return async () => undefined;
+                await sleep(100);
+            }
+        }
+        throw new Error("Запуск уже выполняется");
+    }
+    async function waitUntilReady(timeoutMs = 30000, daemonPid) {
+        const started = Date.now();
+        while (Date.now() - started < timeoutMs) {
+            if (await health())
+                return;
+            if (daemonPid && !isPidAlive(daemonPid)) {
+                throw new Error(`Сервер сразу завершился. См. лог: ${serverLogPath()}`);
+            }
+            await sleep(200);
+        }
+        throw new Error(`Сервер не поднялся за ${Math.round(timeoutMs / 1000)} с. См. ${serverLogPath()}`);
+    }
+    /** Start Menu uses a hidden console — surface failures with a MessageBox on Windows. */
+    function alertFailure(message) {
+        const text = String(message);
+        console.error(text);
+        try {
+            mkdirSync(dataDir, { recursive: true });
+            appendFileSync(join(dataDir, "launch-err.log"), `${new Date().toISOString()} ${text}\n`);
+        }
+        catch {
+            /* log best-effort */
+        }
+        os.alertHiddenFailure(text);
+    }
+    async function ensureServer() {
+        const existing = await serverInfo();
+        if (existing)
+            return existing;
+        const release = await acquireLock();
+        try {
+            const startedByAnother = await serverInfo();
+            if (startedByAnother)
+                return startedByAnother;
+            const vp = serverProcesses.findVp();
+            serverProcesses.assertDevToolchain(vp);
+            await serverProcesses.ensureBuilt(vp, launchMode());
+            const daemonPid = serverProcesses.startDaemon(vp);
+            await waitUntilReady(30000, daemonPid);
+            const info = await serverInfo();
+            if (!info)
+                throw new Error(`Сервер не ответил после запуска. См. ${serverLogPath()}`);
+            return info;
+        }
+        finally {
+            await release();
+        }
+    }
+    async function startForegroundServer() {
+        const release = await acquireLock();
+        let released = false;
+        const done = async () => {
+            if (released)
+                return;
+            released = true;
+            await release();
+        };
+        try {
+            if (await health()) {
+                out(`уже запущен: ${appUrl}`);
+                return;
+            }
+            const vp = serverProcesses.findVp();
+            serverProcesses.assertDevToolchain(vp);
+            await serverProcesses.ensureBuilt(vp, launchMode());
+            await done();
+            serverProcesses.startForeground(vp);
+        }
+        finally {
+            await done();
+        }
+    }
+    /** Меняет режим на диске и, если сервер работает в другом режиме, перезапускает его. */
+    async function switchMode(targetMode, modeOptions) {
+        const release = await acquireLock();
+        try {
+            const info = await serverInfo();
+            if (!targetMode) {
+                if (modeOptions.json)
+                    out(JSON.stringify({
+                        mode: launchMode(),
+                        server: info ? { pid: info.pid, mode: info.mode ?? "dev" } : null,
+                    }, null, 2));
+                else {
+                    out(`режим: ${launchMode()}`);
+                    out(info ? `сервер: ${info.mode ?? "dev"} (pid ${info.pid})` : "сервер не запущен");
+                }
+                return;
+            }
+            if (!isServerMode(targetMode))
+                throw new Error(`Режим: ${SERVER_MODES.join(" | ")}`);
+            if (packaged && targetMode === "dev")
+                throw new Error("Режим dev доступен только в checkout исходников Projector");
+            const vp = serverProcesses.findVp();
+            // Сборку делаем до остановки сервера: при ошибке старый процесс и терминалы остаются.
+            if (targetMode === "prod" && !packaged)
+                await serverProcesses.buildFrontend(vp);
+            writeServerMode(targetMode);
+            if (!info) {
+                if (modeOptions.json)
+                    out(JSON.stringify({ mode: targetMode, server: null, changed: true }, null, 2));
+                else
+                    out(`режим ${targetMode} сохранён; сервер не запущен`);
+                return;
+            }
+            if ((info.mode ?? "dev") === targetMode) {
+                if (modeOptions.json)
+                    out(JSON.stringify({
+                        mode: targetMode,
+                        server: { pid: info.pid, mode: targetMode },
+                        changed: false,
+                    }, null, 2));
+                else
+                    out(`уже работает в режиме ${targetMode}`);
+                return;
+            }
+            if (!modeOptions.json)
+                out(`перезапуск в режиме ${targetMode}: терминалы и их процессы будут завершены`);
+            await openApp({}, "quit");
+            await os.processes.waitForExit(info.pid, 15000);
+            const daemonPid = serverProcesses.startDaemon(vp);
+            await waitUntilReady(30000, daemonPid);
+            await openApp({ tray: true });
+            const next = await serverInfo();
+            if (modeOptions.json)
+                out(JSON.stringify({
+                    mode: targetMode,
+                    server: next ? { pid: next.pid, mode: next.mode ?? targetMode } : null,
+                    changed: true,
+                }, null, 2));
+            else
+                out(`сервер работает в режиме ${targetMode}`);
+        }
+        finally {
+            await release();
+        }
+    }
+    return {
+        serverInfo,
+        health,
+        openApp,
+        ensureServer,
+        startForegroundServer,
+        switchMode,
+        alertFailure,
+    };
+}

package/packages/cli/modules/server-process/index.js

@@ -0,0 +1,204 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, writeSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { os } from "../../../core/modules/os/index.js";
+import { serverCommand } from "../../../core/modules/server-mode/index.js";
+import { openLog, serverLogPath } from "../../../core/modules/app-paths/index.js";
+/** Locates `vp`, builds the frontend and starts the server in foreground or as a daemon. */
+export function createServerProcesses({ root, dataDir, packaged, launchMode, options, }) {
+    function findVp() {
+        // Start Menu / wscript launches with a minimal PATH: prefer the checkout's
+        // vite-plus CLI (spawned via node) over a bare `vp` that only works in a prepared shell.
+        const shims = process.platform === "win32" ? ["vp.cmd", "vp"] : ["vp", "vp.cmd"];
+        const dirs = [os.toolchainBin(), join(root, "node_modules", ".bin")];
+        const candidates = [
+            process.env.VP,
+            join(root, "node_modules", "vite-plus", "bin", "vp"),
+            ...dirs.flatMap((dir) => shims.map((name) => join(dir, name))),
+            "vp",
+        ].filter((value) => Boolean(value));
+        for (const bin of candidates) {
+            if (isAbsolute(bin) && existsSync(bin))
+                return bin;
+            if (!isAbsolute(bin) && os.tools.commandExists(bin))
+                return bin;
+        }
+        return "vp";
+    }
+    function childEnv() {
+        const pathDirs = [os.toolchainBin(), join(root, "node_modules", ".bin")];
+        const env = {
+            ...process.env,
+            PATH: [...pathDirs, process.env.PATH].filter(Boolean).join(delimiter),
+        };
+        // Одноразовый режим доступа: не сохраняется на диск и не влияет на следующие запуски.
+        if (options.lan)
+            env.PROJECTOR_NETWORK = "lan";
+        else if (options.local)
+            env.PROJECTOR_NETWORK = "local";
+        return env;
+    }
+    /** Spawn `vp` whether it is a .cmd shim, a Unix binary, or the vite-plus JS CLI. */
+    function spawnVp(vp, vpArgs, spawnOptions) {
+        const win = process.platform === "win32";
+        const hide = spawnOptions.windowsHide ?? win;
+        if (/[\\/]vite-plus[\\/]bin[\\/]vp$/i.test(vp)) {
+            return spawn(process.execPath, [vp, ...vpArgs], {
+                ...spawnOptions,
+                windowsHide: hide,
+            });
+        }
+        return spawn(vp, vpArgs, {
+            ...spawnOptions,
+            shell: win && /\.(cmd|bat)$/i.test(vp),
+            windowsHide: hide,
+        });
+    }
+    function run(vp, commandArgs) {
+        return new Promise((resolve, reject) => {
+            const child = spawnVp(vp, commandArgs, {
+                cwd: root,
+                stdio: "inherit",
+                env: childEnv(),
+                windowsHide: false,
+            });
+            child.once("error", reject);
+            child.once("exit", (code) => code === 0
+                ? resolve()
+                : reject(new Error(`vp ${commandArgs.join(" ")} завершился (${code})`)));
+        });
+    }
+    function buildFrontend(vp) {
+        console.log("Сборка фронтенда (vp build)…");
+        return run(vp, ["build"]);
+    }
+    async function ensureBuilt(vp, serverMode) {
+        if (serverMode === "prod" && !existsSync(join(root, "dist", "index.html"))) {
+            if (packaged)
+                throw new Error("Повреждена установка: отсутствует dist/index.html");
+            await buildFrontend(vp);
+        }
+    }
+    function serverPaths(vp) {
+        return { vp, node: process.execPath, root, compiled: packaged };
+    }
+    /** `vp` is a wrapper: it spawns `vite.js` without CREATE_NO_WINDOW. */
+    function windowsViteCli() {
+        return [
+            join(root, "node_modules", "vite", "dist", "vite", "bin", "vite.js"),
+            join(root, "node_modules", "@voidzero-dev", "vite-plus-core", "dist", "vite", "bin", "vite.js"),
+        ].find((file) => existsSync(file));
+    }
+    function daemonCommand(vp) {
+        const planned = serverCommand(launchMode(), serverPaths(vp));
+        if (process.platform !== "win32" || planned.args[0] !== "dev")
+            return planned;
+        const viteJs = windowsViteCli();
+        if (!viteJs)
+            return planned;
+        return { command: process.execPath, args: [viteJs, ...planned.args] };
+    }
+    function daemonEnv() {
+        return {
+            ...childEnv(),
+            NODE_PACKAGE_MANAGER: "vite-plus",
+            JS_RUNTIME_NAME: process.release.name,
+            JS_RUNTIME_VERSION: process.versions.node,
+        };
+    }
+    function startForeground(vp) {
+        const { command, args } = serverCommand(launchMode(), serverPaths(vp));
+        const child = spawnVp(command, args, {
+            cwd: root,
+            stdio: "inherit",
+            env: childEnv(),
+            windowsHide: false,
+        });
+        child.once("error", (error) => {
+            console.error(error instanceof Error ? error.message : error);
+            process.exit(1);
+        });
+        child.on("exit", (code) => {
+            process.exit(code ?? 0);
+        });
+    }
+    function startDaemon(vp) {
+        mkdirSync(dataDir, { recursive: true });
+        const logPath = serverLogPath();
+        const logFd = openLog(logPath);
+        const { command, args } = daemonCommand(vp);
+        // Hidden console: Start Menu uses wscript, but a detached console-subsystem
+        // child still gets a window unless CREATE_NO_WINDOW is set on that process.
+        const child = spawnVp(command, args, {
+            cwd: root,
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            env: { ...daemonEnv(), PROJECTOR_SERVER_LOG: logPath },
+            windowsHide: true,
+        });
+        // Without a listener, spawn ENOENT becomes an uncaught exception and aborts the CLI
+        // after the Start Menu already hid the console — looks like a silent crash.
+        child.once("error", (error) => {
+            try {
+                const message = error instanceof Error ? `${error.stack || error.message}\n` : `${String(error)}\n`;
+                writeSync(logFd, message);
+            }
+            catch {
+                /* log best-effort */
+            }
+        });
+        child.unref();
+        return child.pid;
+    }
+    function vitePlusCliPresent() {
+        const files = [
+            join(root, "node_modules", "@voidzero-dev", "vite-plus-core", "dist", "vite", "bin", "vite.js"),
+            join(root, "node_modules", "vite", "dist", "vite", "bin", "vite.js"),
+        ];
+        if (files.some((file) => existsSync(file)))
+            return true;
+        const store = join(root, "node_modules", ".pnpm");
+        if (!existsSync(store))
+            return false;
+        for (const name of readdirSync(store)) {
+            if (!name.startsWith("@voidzero-dev+vite-plus-cor"))
+                continue;
+            if (existsSync(join(store, name, "node_modules", "@voidzero-dev", "vite-plus-core", "dist", "vite", "bin", "vite.js")))
+                return true;
+        }
+        return false;
+    }
+    function assertDevToolchain(vp) {
+        if (launchMode() !== "dev")
+            return;
+        if (!existsSync(vp) && vp === "vp")
+            throw new Error(`Не найден vp. Выполните pnpm install в ${root}`);
+        // vite-plus requires bin/vite.js even when node/cli.js is still present.
+        if (vitePlusCliPresent())
+            return;
+        const repair = join(root, "scripts", "ensure-vite-plus-core.mjs");
+        if (existsSync(repair)) {
+            const result = spawnSync(process.execPath, [repair], {
+                cwd: root,
+                encoding: "utf8",
+                windowsHide: true,
+                timeout: 120000,
+            });
+            if (result.stdout)
+                console.error(result.stdout.trim());
+            if (result.stderr)
+                console.error(result.stderr.trim());
+            if (vitePlusCliPresent())
+                return;
+        }
+        throw new Error(`Повреждён node_modules (нет vite-plus-core/cli.js). В ${root} выполните: pnpm install`);
+    }
+    return {
+        findVp,
+        ensureBuilt,
+        startForeground,
+        startDaemon,
+        buildFrontend,
+        assertDevToolchain,
+    };
+}

package/packages/core/modules/agent-features/index.js

@@ -0,0 +1,8 @@
+export function createAgentFeatureCatalog() {
+    const items = new Map();
+    return {
+        register: (feature) => void items.set(feature.id, feature),
+        list: () => [...items.values()],
+        get: (id) => items.get(id),
+    };
+}

package/packages/core/modules/agent-judge/index.js

@@ -0,0 +1,73 @@
+export const JUDGE_DEFAULTS = {
+    show: true,
+    auto: true,
+    maxRisk: 1,
+    confidence: "high-medium",
+};
+const LABELS = {
+    1: "безопасно",
+    2: "низкий",
+    3: "умеренный",
+    4: "высокий",
+    5: "критический",
+};
+const TONES = {
+    1: "info",
+    2: "neutral",
+    3: "warning",
+    4: "danger",
+    5: "danger",
+};
+export function judgeScoreLabel(score) {
+    return LABELS[score];
+}
+export function judgeScoreTone(score) {
+    return TONES[score];
+}
+export function isJudgeScore(value) {
+    return value === 1 || value === 2 || value === 3 || value === 4 || value === 5;
+}
+/** The settings a request should use: the chat's override over the global value. */
+export function resolveJudgeSettings(global, override) {
+    return normalizeJudgeSettings(override, global);
+}
+/** Validates a stored or requested value; anything wrong keeps the base value. */
+export function normalizeJudgeSettings(value, base = JUDGE_DEFAULTS) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return { ...base };
+    const row = value;
+    return {
+        show: typeof row.show === "boolean" ? row.show : base.show,
+        auto: typeof row.auto === "boolean" ? row.auto : base.auto,
+        maxRisk: row.maxRisk === 1 || row.maxRisk === 2 || row.maxRisk === 3 ? row.maxRisk : base.maxRisk,
+        confidence: row.confidence === "high" || row.confidence === "high-medium"
+            ? row.confidence
+            : base.confidence,
+    };
+}
+/** Only the fields a chat really overrides, so a reset can drop them. */
+export function normalizeJudgeOverride(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const row = value;
+    const result = {};
+    if (typeof row.show === "boolean")
+        result.show = row.show;
+    if (typeof row.auto === "boolean")
+        result.auto = row.auto;
+    if (row.maxRisk === 1 || row.maxRisk === 2 || row.maxRisk === 3)
+        result.maxRisk = row.maxRisk;
+    if (row.confidence === "high" || row.confidence === "high-medium")
+        result.confidence = row.confidence;
+    return Object.keys(result).length ? result : undefined;
+}
+/** Whether a verdict may be allowed without the user, given the resolved settings. */
+export function judgeAllows(settings, verdict) {
+    if (!settings.auto)
+        return false;
+    if (verdict.score > settings.maxRisk)
+        return false;
+    return settings.confidence === "high-medium"
+        ? verdict.confidence === "high" || verdict.confidence === "medium"
+        : verdict.confidence === "high";
+}

package/packages/core/modules/agent-read/index.js

@@ -0,0 +1,25 @@
+/**
+ * Some agents frame a file read as numbered lines (`1\tconst a = 1;`, `2\t…`). The chat shows the
+ * file body, so the numbers are removed wherever the result is displayed or stored.
+ */
+const NUMBERED = /^(\d+)\t/;
+export function stripReadLineNumbers(text) {
+    let lines = text.split("\n");
+    // A trailing newline is not a numbered file line.
+    if (lines.length > 1 && lines.at(-1) === "")
+        lines = lines.slice(0, -1);
+    const first = NUMBERED.exec(lines[0] ?? "");
+    if (!first)
+        return text;
+    let number = Number(first[1]);
+    const cleaned = [];
+    for (const line of lines) {
+        const prefix = `${number}\t`;
+        // An unexpected shape means this is not a numbered file body: keep it untouched.
+        if (!line.startsWith(prefix))
+            return text;
+        cleaned.push(line.slice(prefix.length));
+        number++;
+    }
+    return cleaned.join("\n");
+}