@no-k/hermes 0.1.0 → 0.2.0

package/dist/lib/project-config.js

@@ -0,0 +1,171 @@
+import path from "node:path";
+import { valid } from "semver";
+import { UTILITY_SCOPES, isItemName, isModuleSnapshot, isUtilityScope } from "./catalog.js";
+import { appendLiteralEntries, applySourceEdits, parseConfigSource } from "./config-syntax.js";
+import { DEFAULT_INSTALL_DIRECTORIES, } from "./contracts.js";
+import { readDestination } from "./files.js";
+import { isRecord } from "./json.js";
+export const PROJECT_CONFIG_FILENAME = "no-k.config.ts";
+function validDirectory(value) {
+    return typeof value === "string" && value.trim().length > 0 && !value.includes("\0");
+}
+export function resolveInstallDirectory(directory, cwd) {
+    if (!validDirectory(directory))
+        throw new Error("Specify a non-empty installation directory.");
+    return path.resolve(cwd, directory);
+}
+export function validateProjectConfig(value) {
+    if (!isRecord(value) || value.schemaVersion !== 1 || !isRecord(value.directories)) {
+        throw new Error("Invalid no-k.config.ts: expected schemaVersion: 1 and a directories object.");
+    }
+    const directories = {};
+    for (const scope of UTILITY_SCOPES) {
+        const directory = value.directories[scope];
+        if (directory !== undefined) {
+            if (!validDirectory(directory))
+                throw new Error("Invalid no-k.config.ts: directories." + scope);
+            directories[scope] = directory;
+        }
+    }
+    const installedValue = value.installed === undefined ? [] : value.installed;
+    if (!Array.isArray(installedValue))
+        throw new Error("Invalid no-k.config.ts: installed must be an array.");
+    const entries = installedValue;
+    const installed = entries.map((entry, index) => {
+        if (!isRecord(entry) || !isItemName(entry.name) || !isUtilityScope(entry.scope) || !validDirectory(entry.directory))
+            throw new Error("Invalid no-k.config.ts: installed[" + index + "]");
+        const source = entry.source;
+        if (source !== undefined &&
+            (!isRecord(source) ||
+                typeof source.catalogVersion !== "string" ||
+                typeof source.requestedVersion !== "string" ||
+                valid(source.requestedVersion) !== source.requestedVersion ||
+                (source.status !== "verified" && source.status !== "modified") ||
+                !Array.isArray(source.modules) ||
+                !source.modules.length ||
+                !source.modules.every(isModuleSnapshot) ||
+                new Set(source.modules.map((module) => module.packageName)).size !== source.modules.length ||
+                !source.modules.some((module) => module.name === entry.name && module.scope === entry.scope))) {
+            throw new Error("Invalid no-k.config.ts: installed[" + index + "].source");
+        }
+        return {
+            name: entry.name,
+            scope: entry.scope,
+            directory: entry.directory,
+            ...(source !== undefined ? { source: source } : {}),
+        };
+    });
+    return { schemaVersion: 1, directories, installed };
+}
+export function loadProjectConfig(cwd) {
+    const destination = path.resolve(cwd, PROJECT_CONFIG_FILENAME);
+    const content = readDestination(destination);
+    if (content === null)
+        return { status: "missing", destination };
+    const value = validateProjectConfig(parseConfigSource(content).value);
+    return { status: "loaded", destination, content, value };
+}
+export function initialInstallDirectories(config, directory) {
+    if (directory !== undefined) {
+        resolveInstallDirectory(directory, path.dirname(config.destination));
+        return { core: directory, lib: directory };
+    }
+    return { ...DEFAULT_INSTALL_DIRECTORIES, ...(config.status === "loaded" ? config.value.directories : {}) };
+}
+function installationKey(item, cwd) {
+    return JSON.stringify([item.scope, item.name, resolveInstallDirectory(item.directory, cwd)]);
+}
+export function mergeProjectConfig(config, targets) {
+    const current = config.status === "loaded" ? config.value : { schemaVersion: 1, directories: {}, installed: [] };
+    const directories = { ...current.directories };
+    const installed = [...current.installed];
+    const cwd = path.dirname(config.destination);
+    const keys = new Set(installed.map((item) => installationKey(item, cwd)));
+    for (const target of targets) {
+        resolveInstallDirectory(target.directory, cwd);
+        directories[target.scope] = target.directory;
+        for (const name of target.names) {
+            const item = { name, scope: target.scope, directory: target.directory };
+            const key = installationKey(item, cwd);
+            if (!keys.has(key)) {
+                installed.push(item);
+                keys.add(key);
+            }
+        }
+    }
+    return validateProjectConfig({ schemaVersion: 1, directories, installed });
+}
+export function planProjectConfig(config, next) {
+    const value = validateProjectConfig(next);
+    let content;
+    if (config.status === "missing")
+        content = "export default " + JSON.stringify(value, null, 2) + ";\n";
+    else {
+        const root = parseConfigSource(config.content);
+        const current = validateProjectConfig(root.value);
+        const properties = root.properties;
+        const directories = properties?.get("directories");
+        if (!directories?.properties)
+            throw new Error("Cannot update no-k.config.ts directories safely.");
+        const edits = [];
+        const newDirectories = [];
+        for (const scope of UTILITY_SCOPES) {
+            const directory = value.directories[scope];
+            if (directory !== undefined && directory !== current.directories[scope]) {
+                const previous = directories.properties.get(scope);
+                const text = JSON.stringify(directory);
+                if (previous)
+                    edits.push({ start: previous.start, end: previous.end, text });
+                else
+                    newDirectories.push(scope + ": " + text);
+            }
+        }
+        edits.push(...appendLiteralEntries(config.content, directories, newDirectories));
+        if (value.installed.length < current.installed.length)
+            throw new Error("Cannot remove or rewrite existing installation records automatically.");
+        const newItems = value.installed.slice(current.installed.length);
+        const installed = properties?.get("installed");
+        if (installed) {
+            if (!installed.elements)
+                throw new Error("Cannot update no-k.config.ts installed safely.");
+            for (let index = 0; index < current.installed.length; index++) {
+                const previous = current.installed[index];
+                const next = value.installed[index];
+                const literal = installed.elements[index];
+                if (!previous ||
+                    !next ||
+                    !literal?.properties ||
+                    previous.name !== next.name ||
+                    previous.scope !== next.scope ||
+                    previous.directory !== next.directory ||
+                    (previous.source && !next.source)) {
+                    throw new Error("Cannot remove or rewrite existing installation records automatically.");
+                }
+                if (next.source && JSON.stringify(previous.source) !== JSON.stringify(next.source)) {
+                    const source = literal.properties.get("source");
+                    const text = JSON.stringify(next.source);
+                    if (source)
+                        edits.push({ start: source.start, end: source.end, text });
+                    else
+                        edits.push(...appendLiteralEntries(config.content, literal, ["source: " + text]));
+                }
+            }
+            edits.push(...appendLiteralEntries(config.content, installed, newItems.map((item) => JSON.stringify(item))));
+        }
+        else {
+            edits.push(...appendLiteralEntries(config.content, root, ["installed: " + JSON.stringify(value.installed, null, 2)]));
+        }
+        content = applySourceEdits(config.content, edits);
+        if (JSON.stringify(validateProjectConfig(parseConfigSource(content).value)) !== JSON.stringify(value)) {
+            throw new Error("Cannot update no-k.config.ts safely; review directories and installed.");
+        }
+    }
+    const existingContent = config.status === "loaded" ? config.content : null;
+    return {
+        file: PROJECT_CONFIG_FILENAME,
+        destination: config.destination,
+        content,
+        existingContent,
+        action: existingContent === null ? "create" : existingContent === content ? "keep" : "replace",
+    };
+}

package/dist/lib/report.js

@@ -0,0 +1,89 @@
+import path from "node:path";
+import { resolveInstallDirectory } from "./project-config.js";
+import { sourceHash } from "./versions.js";
+export function formatInstallReview(plan, catalog) {
+    const cwd = path.dirname(plan.config.destination);
+    const actions = { create: "생성", keep: "유지", replace: "교체" };
+    const count = (action) => plan.files.filter((file) => file.action === action).length;
+    const resultingFiles = new Map([...plan.compatibilityGuards, ...plan.files].map((file) => [file.destination, file]));
+    const moduleLabel = (module, directory) => {
+        const verified = Object.entries(module.files).every(([file, hash]) => {
+            const planned = resultingFiles.get(path.join(directory, file));
+            const content = planned?.action === "keep" ? planned.existingContent : planned?.content;
+            return content != null && sourceHash(content) === hash;
+        });
+        return module.name + (verified ? "@" + module.version : " (로컬 수정 · 버전 미확인)");
+    };
+    return [
+        ...plan.compatibilityErrors.flatMap((error) => ["! " + error]),
+        ...(plan.compatibilityErrors.length ? [""] : []),
+        `파일: 생성 ${count("create")} · 유지 ${count("keep")} · 교체 ${count("replace")}`,
+        "",
+        ...plan.targets.flatMap((target) => {
+            const items = catalog.items.filter((item) => target.names.includes(item.name));
+            const directory = resolveInstallDirectory(target.directory, cwd);
+            const records = plan.nextConfig.installed.filter((record) => record.scope === target.scope &&
+                target.names.includes(record.name) &&
+                resolveInstallDirectory(record.directory, cwd) === directory);
+            const modules = records.flatMap((record) => record.source?.modules ?? []);
+            const helpers = new Map(modules
+                .filter((module) => !target.names.includes(module.name))
+                .map((module) => [module.packageName, moduleLabel(module, directory)]));
+            return [
+                `${target.scope === "core" ? "Core" : "라이브러리"} → ${directory}`,
+                ...items.map((item) => {
+                    const requested = `${item.name}@${item.version}`;
+                    const module = modules.find((module) => module.name === item.name);
+                    const resulting = module ? moduleLabel(module, directory) : requested;
+                    return "  " + requested + (requested === resulting ? "" : ` (요청) → ${resulting}`);
+                }),
+                ...(helpers.size ? ["  의존 모듈: " + [...helpers.values()].join(", ")] : []),
+                "",
+            ];
+        }),
+        "파일별 작업",
+        ...plan.files.map((file) => `[${actions[file.action]}] ${file.destination}${file.action === "keep"
+            ? file.existingContent === file.content
+                ? " (내용 동일)"
+                : " (기존 수정 내용 보존)"
+            : ""}`),
+        "",
+        `설정 ${plan.configFile.action === "replace" ? "갱신" : actions[plan.configFile.action]}: ${plan.configFile.destination}`,
+        "선택한 경로와 설치 모듈의 버전·해시를 기록합니다.",
+        "",
+        "npm 의존성: " + (plan.dependencies.join(", ") || "없음"),
+        "개발 의존성: " + (plan.devDependencies.join(", ") || "없음"),
+        ...plan.runtimeRequirements.map((item) => `${item.name}: ${item.runtime === "node" ? "Node.js 필요" : "DOM API와 DOM TypeScript 타입 필요"}`),
+        "npm 패키지는 설치 완료 후 안내되는 명령으로 직접 설치해 주세요.",
+        ...(plan.dryRun ? ["", "DRY RUN: 유틸 파일과 no-k.config.ts를 쓰지 않습니다."] : []),
+    ];
+}
+export function formatFilePlan(file, dryRun) {
+    return ((dryRun ? "[dry-run] " : "") +
+        file.action +
+        " " +
+        file.destination +
+        (file.action === "keep" && file.existingContent !== file.content ? " (kept local contents)" : ""));
+}
+export function formatInstallSummary(plan, names, dryRun) {
+    const lines = [];
+    const modified = plan.files.filter((file) => file.action === "keep" && file.existingContent !== file.content);
+    if (modified.length)
+        lines.push(`\nKept local contents in ${modified.length} file(s). Utility versions below are requested versions.`);
+    if (plan.dependencies.length || plan.devDependencies.length) {
+        lines.push("\nThese utilities need npm packages. Install them in your consuming project:");
+        if (plan.dependencies.length)
+            lines.push("  npm install " + plan.dependencies.map((value) => JSON.stringify(value)).join(" "));
+        if (plan.devDependencies.length) {
+            lines.push("  npm install --save-dev " + plan.devDependencies.map((value) => JSON.stringify(value)).join(" "));
+        }
+    }
+    for (const item of plan.runtimeRequirements) {
+        if (item.runtime === "node")
+            lines.push("\n" + item.name + ": requires Node.js (imports a Node.js builtin).");
+        if (item.runtime === "dom")
+            lines.push("\n" + item.name + ": requires DOM APIs and DOM TypeScript types.");
+    }
+    lines.push("\n" + (dryRun ? "Planned" : "Added") + " " + names.join(", "));
+    return lines.join("\n");
+}

package/dist/lib/terminal-input.js

@@ -0,0 +1,61 @@
+import { useInput, usePaste } from "ink";
+import { useReducer, useRef } from "react";
+export function useTerminalInput(onKey, onPaste) {
+    const [, refresh] = useReducer((value) => value + 1, 0);
+    const refreshPending = useRef(false);
+    const refreshSoon = () => {
+        if (refreshPending.current)
+            return;
+        refreshPending.current = true;
+        queueMicrotask(() => {
+            refreshPending.current = false;
+            refresh();
+        });
+    };
+    useInput((input, key) => {
+        if (key.eventType === "release")
+            return;
+        const controls = {
+            up: key.upArrow,
+            down: key.downArrow,
+            left: key.leftArrow,
+            right: key.rightArrow,
+            pageup: key.pageUp,
+            pagedown: key.pageDown,
+            home: key.home,
+            end: key.end,
+            return: key.return,
+            escape: key.escape,
+            tab: key.tab,
+            backspace: key.backspace || key.delete,
+        };
+        const name = Object.entries(controls).find(([, pressed]) => pressed)?.[0] ?? (input === " " ? "space" : input.toLowerCase());
+        if (!key.ctrl && !key.meta && input.length > 1 && !Object.values(controls).some(Boolean)) {
+            // Multiple keystrokes can arrive in one read. Bracketed paste uses usePaste below.
+            for (const character of input) {
+                const control = character.charCodeAt(0);
+                const name = character === "\r" || character === "\n"
+                    ? "return"
+                    : character === "\t"
+                        ? "tab"
+                        : character === " "
+                            ? "space"
+                            : control > 0 && control < 27
+                                ? String.fromCharCode(control + 96)
+                                : character.toLowerCase();
+                onKey(character, {
+                    name,
+                    ctrl: control > 0 && control < 27 && name !== "return" && name !== "tab",
+                    shift: key.shift,
+                });
+            }
+        }
+        else
+            onKey(input, { name, ctrl: key.ctrl, meta: key.meta, shift: key.shift });
+        refreshSoon();
+    });
+    usePaste((text) => {
+        onPaste(text.replace(/[\r\n\t]/g, " "));
+        refreshSoon();
+    });
+}

package/dist/lib/terminal-style.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+import { fitTerminalLine } from "./terminal-text.js";
+export const theme = {
+    accent: "#75e2d0",
+    purple: "#ad98f5",
+    muted: "#8c96ad",
+    border: "#526078",
+    focus: "#253d54",
+    bright: "#d9faff",
+    warning: "#ffc47e",
+};
+export function Line({ text, width, color, bold = false, }) {
+    return (_jsx(Text, { color: color, bold: bold, wrap: "truncate-end", children: fitTerminalLine(text, width) }));
+}

package/dist/lib/terminal-text.js

@@ -0,0 +1,75 @@
+const segments = new Intl.Segmenter("und", { granularity: "grapheme" });
+export function terminalText(value) {
+    // 파일 내용의 제어문자도 검토할 수 있도록 실행하거나 지우지 않고 표기한다.
+    return value.replace(/\t/g, "    ").replace(/[\p{Cc}\p{Cs}\u202A-\u202E\u2066-\u2069]/gu, (character) => {
+        const point = character.codePointAt(0) ?? 0;
+        return point <= 0xff ? "\\x" + point.toString(16).padStart(2, "0") : "\\u" + point.toString(16).padStart(4, "0");
+    });
+}
+function cellWidth(grapheme) {
+    if (/^[\p{Mark}\p{Cf}]+$/u.test(grapheme))
+        return 0;
+    if (/\p{Emoji_Presentation}|\uFE0F|\u20E3/u.test(grapheme))
+        return 2;
+    const point = grapheme.codePointAt(0) ?? 0;
+    return point >= 0x1100 &&
+        (point <= 0x115f ||
+            point === 0x2329 ||
+            point === 0x232a ||
+            (point >= 0x2e80 && point <= 0xa4cf && point !== 0x303f) ||
+            (point >= 0xac00 && point <= 0xd7a3) ||
+            (point >= 0xf900 && point <= 0xfaff) ||
+            (point >= 0xfe10 && point <= 0xfe19) ||
+            (point >= 0xfe30 && point <= 0xfe6f) ||
+            (point >= 0xff01 && point <= 0xff60) ||
+            (point >= 0xffe0 && point <= 0xffe6) ||
+            (point >= 0x20000 && point <= 0x3fffd))
+        ? 2
+        : 1;
+}
+export function terminalWidth(value) {
+    return [...segments.segment(terminalText(value))].reduce((width, { segment }) => width + cellWidth(segment), 0);
+}
+export function fitTerminalLine(value, columns) {
+    if (columns < 1)
+        return "";
+    const text = terminalText(value);
+    if (terminalWidth(text) <= columns)
+        return text;
+    let result = "";
+    let width = 0;
+    for (const { segment } of segments.segment(text)) {
+        const next = cellWidth(segment);
+        if (width + next > columns - 1)
+            break;
+        result += segment;
+        width += next;
+    }
+    return result + "…";
+}
+export function wrapTerminalLines(lines, columns) {
+    const width = Math.max(1, columns);
+    return lines.flatMap((line) => line.split(/\r?\n/u).flatMap((part) => {
+        const wrapped = [];
+        let current = "";
+        let used = 0;
+        for (const { segment } of segments.segment(terminalText(part))) {
+            const next = cellWidth(segment);
+            if (used + next > width && current) {
+                wrapped.push(current);
+                current = "";
+                used = 0;
+            }
+            current += next > width ? "?" : segment;
+            used += Math.min(next, width);
+        }
+        wrapped.push(current);
+        return wrapped;
+    }));
+}
+export function removeLastGrapheme(value) {
+    return [...segments.segment(value)]
+        .slice(0, -1)
+        .map(({ segment }) => segment)
+        .join("");
+}

package/dist/lib/terminal.js

@@ -0,0 +1,133 @@
+import { render } from "ink";
+import { createElement } from "react";
+import { InstallApp } from "./install-view.js";
+import { PickerApp } from "./picker-view.js";
+export async function withSelectionTerminal(run, { input, output } = { input: process.stdin, output: process.stdout }) {
+    if (!input.isTTY || !output.isTTY || !input.setRawMode || !input.ref || !input.unref)
+        throw new Error("선택 화면은 입력과 출력이 모두 연결된 대화형 터미널에서 실행해 주세요.");
+    const wasRaw = input.isRaw ?? false;
+    const wasFlowing = input.readableFlowing === true;
+    let app;
+    let exited;
+    let active;
+    let stopped = input.readableEnded || input.destroyed ? { status: "cancelled", reason: "eof" } : undefined;
+    let failure;
+    const queue = [];
+    const cancel = (result) => {
+        const previous = active;
+        active = undefined;
+        previous?.cancel(result);
+    };
+    const fail = (error) => {
+        failure = error;
+        active?.reject(error);
+        active = undefined;
+    };
+    const dispatch = (text, key) => {
+        if (!active) {
+            queue.push({ text, key });
+            return;
+        }
+        try {
+            if (key || active.acceptsPaste())
+                active.key(text, key ?? {});
+        }
+        catch (error) {
+            fail(error instanceof Error ? error : new Error(String(error)));
+        }
+    };
+    const onKey = (text, key) => dispatch(text, key);
+    const onPaste = (text) => dispatch(text);
+    const eof = () => {
+        stopped = { status: "cancelled", reason: "eof" };
+        cancel(stopped);
+    };
+    const interrupt = () => {
+        stopped = { status: "cancelled", reason: "interrupt" };
+        cancel(stopped);
+    };
+    input.on("end", eof);
+    input.on("close", eof);
+    input.on("error", fail);
+    output.on("error", fail);
+    process.on("SIGINT", interrupt);
+    process.on("SIGTERM", interrupt);
+    function show(key, view, acceptsPaste) {
+        if (failure)
+            return Promise.reject(failure);
+        if (stopped)
+            return Promise.resolve(stopped);
+        if (active)
+            return Promise.reject(new Error("A terminal screen is already active."));
+        return new Promise((resolve, reject) => {
+            active = {
+                key(text, event) {
+                    const result = key(text, event);
+                    if (result !== undefined) {
+                        active = undefined;
+                        resolve(result);
+                    }
+                },
+                acceptsPaste,
+                cancel: resolve,
+                reject,
+            };
+            if (app)
+                app.rerender(view);
+            else {
+                // Subscribe to exit before rendering a screen that could fail synchronously.
+                app = render(null, {
+                    stdin: input,
+                    stdout: output,
+                    stderr: output,
+                    exitOnCtrlC: false,
+                    patchConsole: false,
+                    interactive: true,
+                    alternateScreen: true,
+                    incrementalRendering: true,
+                    maxFps: 60,
+                });
+                exited = app.waitUntilExit();
+                void exited.catch(fail);
+                app.rerender(view);
+            }
+            while (active && queue.length) {
+                const event = queue.shift();
+                if (event)
+                    dispatch(event.text, event.key);
+            }
+        });
+    }
+    try {
+        return await run({
+            pick(picker) {
+                return show((text, key) => picker.key(text, key), createElement(PickerApp, { picker, onKey, onPaste }), () => picker.searching);
+            },
+            directory(prompt) {
+                return show((text, key) => prompt.key(text, key), createElement(InstallApp, { prompt, onKey, onPaste }), () => true);
+            },
+            review(prompt) {
+                return show((text, key) => prompt.key(text, key), createElement(InstallApp, { prompt, onKey, onPaste }), () => false);
+            },
+        });
+    }
+    finally {
+        try {
+            app?.cleanup();
+            await exited;
+        }
+        finally {
+            input.off("end", eof);
+            input.off("close", eof);
+            input.off("error", fail);
+            output.off("error", fail);
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", interrupt);
+            input.setRawMode(wasRaw);
+            if (wasFlowing)
+                input.resume();
+            else
+                input.pause();
+        }
+    }
+}