@no-k/hermes 0.1.0 → 0.3.0

package/dist/lib/config-syntax.js

@@ -0,0 +1,210 @@
+// 생성된 설정의 데이터 리터럴만 읽는다. 설정 파일의 코드를 실행하지 않는다.
+class ConfigParser {
+    source;
+    offset = 0;
+    constructor(source) {
+        this.source = source;
+    }
+    fail(message) {
+        const lines = this.source.slice(0, this.offset).split("\n");
+        throw new Error("Unsupported no-k.config.ts syntax at " +
+            lines.length +
+            ":" +
+            ((lines.at(-1)?.length ?? 0) + 1) +
+            ": " +
+            message +
+            ". Use an export default object with literal values.");
+    }
+    skip() {
+        while (this.offset < this.source.length) {
+            const rest = this.source.slice(this.offset);
+            const whitespace = /^\s+/.exec(rest);
+            if (whitespace)
+                this.offset += whitespace[0].length;
+            else if (rest.startsWith("//")) {
+                const end = this.source.indexOf("\n", this.offset);
+                this.offset = end < 0 ? this.source.length : end + 1;
+            }
+            else if (rest.startsWith("/*")) {
+                const end = this.source.indexOf("*/", this.offset + 2);
+                if (end < 0)
+                    this.fail("Unclosed comment");
+                this.offset = end + 2;
+            }
+            else
+                return;
+        }
+    }
+    take(token) {
+        this.skip();
+        if (!this.source.startsWith(token, this.offset))
+            return false;
+        if (/^[a-z]+$/.test(token) && /[\w$]/.test(this.source.charAt(this.offset + token.length)))
+            return false;
+        this.offset += token.length;
+        return true;
+    }
+    expect(token) {
+        if (!this.take(token))
+            this.fail("Expected " + token);
+    }
+    string() {
+        const quote = this.source.charAt(this.offset++);
+        let result = "";
+        while (this.offset < this.source.length) {
+            const character = this.source.charAt(this.offset++);
+            if (character === quote)
+                return result;
+            if (character === "\n" || character === "\r")
+                this.fail("Unescaped newline in string");
+            if (character !== "\\")
+                result += character;
+            else {
+                const escaped = this.source.charAt(this.offset++);
+                const simple = {
+                    n: "\n",
+                    r: "\r",
+                    t: "\t",
+                    b: "\b",
+                    f: "\f",
+                    v: "\v",
+                    "\\": "\\",
+                    '"': '"',
+                    "'": "'",
+                    "/": "/",
+                };
+                if (Object.hasOwn(simple, escaped))
+                    result += simple[escaped];
+                else if (escaped === "0" && !/\d/.test(this.source.charAt(this.offset)))
+                    result += "\0";
+                else if (escaped === "u" || escaped === "x") {
+                    const rest = this.source.slice(this.offset);
+                    const match = escaped === "x" ? /^[\da-fA-F]{2}/.exec(rest) : /^(?:[\da-fA-F]{4}|\{[\da-fA-F]{1,6}\})/.exec(rest);
+                    if (!match)
+                        this.fail("Invalid string escape");
+                    const point = Number.parseInt(match[0].replace(/[{}]/g, ""), 16);
+                    if (point > 0x10ffff)
+                        this.fail("Invalid Unicode code point");
+                    result += String.fromCodePoint(point);
+                    this.offset += match[0].length;
+                }
+                else
+                    this.fail("Unsupported string escape");
+            }
+        }
+        return this.fail("Unclosed string");
+    }
+    value(depth) {
+        this.skip();
+        if (depth > 64)
+            this.fail("Configuration is nested too deeply");
+        const start = this.offset;
+        if (this.take("{")) {
+            const value = Object.create(null);
+            const properties = new Map();
+            let trailingComma = false;
+            while (!this.take("}")) {
+                this.skip();
+                let key;
+                if (/['"]/.test(this.source.charAt(this.offset)) && this.offset < this.source.length)
+                    key = this.string();
+                else {
+                    const identifier = /^[a-zA-Z_$][\w$]*/.exec(this.source.slice(this.offset));
+                    if (!identifier)
+                        this.fail("Expected a property name");
+                    key = identifier[0];
+                    this.offset += key.length;
+                }
+                if (properties.has(key))
+                    this.fail("Duplicate property " + key);
+                this.expect(":");
+                const child = this.value(depth + 1);
+                properties.set(key, child);
+                value[key] = child.value;
+                trailingComma = false;
+                if (this.take("}"))
+                    return { start, end: this.offset, value, properties, trailingComma };
+                this.expect(",");
+                trailingComma = true;
+            }
+            return { start, end: this.offset, value, properties, trailingComma };
+        }
+        if (this.take("[")) {
+            const elements = [];
+            let trailingComma = false;
+            while (!this.take("]")) {
+                elements.push(this.value(depth + 1));
+                trailingComma = false;
+                if (this.take("]"))
+                    return { start, end: this.offset, value: elements.map((node) => node.value), elements, trailingComma };
+                this.expect(",");
+                trailingComma = true;
+            }
+            return { start, end: this.offset, value: elements.map((node) => node.value), elements, trailingComma };
+        }
+        const character = this.source.charAt(this.offset);
+        if (character === "'" || character === '"') {
+            const value = this.string();
+            return { start, end: this.offset, value };
+        }
+        for (const [token, value] of [
+            ["true", true],
+            ["false", false],
+            ["null", null],
+        ]) {
+            if (this.take(token))
+                return { start, end: this.offset, value };
+        }
+        const number = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(this.source.slice(this.offset));
+        if (!number || !Number.isFinite(Number(number[0])))
+            this.fail("Expected a literal value");
+        this.offset += number[0].length;
+        return { start, end: this.offset, value: Number(number[0]) };
+    }
+    parse() {
+        this.expect("export");
+        this.expect("default");
+        const root = this.value(0);
+        if (!root.properties)
+            this.fail("Expected an object");
+        if (this.take("as"))
+            this.expect("const");
+        this.take(";");
+        this.skip();
+        if (this.offset !== this.source.length)
+            this.fail("Unexpected expression");
+        return root;
+    }
+}
+export function parseConfigSource(source) {
+    return new ConfigParser(source).parse();
+}
+export function appendLiteralEntries(source, node, entries) {
+    if (!entries.length)
+        return [];
+    const children = node.elements ?? [...(node.properties?.values() ?? [])];
+    const last = children.at(-1);
+    const edits = [];
+    if (last && !node.trailingComma)
+        edits.push({ start: last.end, end: last.end, text: "," });
+    const lineStart = source.lastIndexOf("\n", node.start - 1) + 1;
+    const indent = /^\s*/.exec(source.slice(lineStart, node.start))?.[0] ?? "";
+    const newline = source.includes("\r\n") ? "\r\n" : "\n";
+    const text = newline +
+        entries.map((entry) => indent + "  " + entry.replace(/\n/g, newline + indent + "  ") + ",").join(newline) +
+        newline +
+        indent;
+    edits.push({ start: node.end - 1, end: node.end - 1, text });
+    return edits;
+}
+export function applySourceEdits(source, edits) {
+    let result = source;
+    let boundary = source.length;
+    for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+        if (edit.end > boundary)
+            throw new Error("Overlapping configuration edits.");
+        result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+        boundary = edit.start;
+    }
+    return result;
+}

package/dist/lib/conflict-selection.js

@@ -0,0 +1,89 @@
+import { Picker } from "./picker.js";
+// 공통 앞뒤 문맥을 보존한 단일 hunk다. 큰 파일도 제곱 크기 비교 테이블 없이 검토한다.
+export function formatFileDiff(before, after) {
+    if (before === after)
+        return ["내용 차이 없음"];
+    const oldLines = before.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    const newLines = after.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    let prefix = 0;
+    let suffix = 0;
+    while (prefix < Math.min(oldLines.length, newLines.length) && oldLines[prefix] === newLines[prefix])
+        prefix++;
+    while (suffix < Math.min(oldLines.length, newLines.length) - prefix &&
+        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
+        suffix++;
+    const start = Math.max(0, prefix - 3);
+    const oldEnd = Math.min(oldLines.length, oldLines.length - suffix + 3);
+    const newEnd = Math.min(newLines.length, newLines.length - suffix + 3);
+    const marked = (lines, mark) => lines.flatMap((line) => [
+        mark + line.replace(/\n$/, "").replace(/\r$/, "\\r"),
+        ...(line.endsWith("\n") ? [] : ["\"]),
+    ]);
+    return [
+        "--- 기존 파일",
+        "+++ 생성 후보",
+        `@@ -${oldLines.length ? start + 1 : 0},${oldEnd - start} +${newLines.length ? start + 1 : 0},${newEnd - start} @@`,
+        ...marked(oldLines.slice(start, prefix), " "),
+        ...marked(oldLines.slice(prefix, oldLines.length - suffix), "-"),
+        ...marked(newLines.slice(prefix, newLines.length - suffix), "+"),
+        ...marked(newLines.slice(newLines.length - suffix, newEnd), " "),
+    ];
+}
+export async function selectConflicts(conflicts, terminal, previous = []) {
+    const unique = new Map();
+    for (const conflict of conflicts) {
+        const existing = unique.get(conflict.destination);
+        if (existing && (existing.content !== conflict.content || existing.existingContent !== conflict.existingContent))
+            throw new Error("Conflicting file review: " + conflict.destination);
+        unique.set(conflict.destination, existing
+            ? {
+                ...existing,
+                names: [
+                    existing.names[0],
+                    ...new Set([...existing.names.slice(1), ...conflict.names].filter((name) => name !== existing.names[0])),
+                ],
+            }
+            : conflict);
+    }
+    if (!unique.size)
+        return { status: "selected", decisions: [] };
+    const files = [...unique.values()];
+    const result = await terminal.pick(new Picker({
+        title: "교체할 파일을 선택해 주세요 · 기본값은 유지",
+        stage: "conflict",
+        breadcrumb: ["설치 계획", "파일 변경 검토"],
+        choices: files.map((file) => ({
+            id: file.destination,
+            label: file.file,
+            summary: `${file.names.join(", ")} · ${file.destination}`,
+            details: () => [
+                file.destination,
+                "영향받는 유틸: " + file.names.join(", "),
+                "",
+                ...formatFileDiff(file.existingContent, file.content),
+            ],
+            matches: (query) => query
+                .normalize("NFKC")
+                .toLowerCase()
+                .trim()
+                .split(/\s+/u)
+                .every((term) => `${file.destination} ${file.names.join(" ")}`.normalize("NFKC").toLowerCase().includes(term)),
+        })),
+        selected: files
+            .filter((file) => previous.some((decision) => decision.action === "replace" &&
+            decision.conflict.destination === file.destination &&
+            decision.conflict.existingContent === file.existingContent &&
+            decision.conflict.content === file.content))
+            .map((file) => file.destination),
+        summary: (selected) => `교체 ${selected.length}개 · 유지 ${files.length - selected.length}개 · Tab 차이 보기`,
+    }));
+    if (result.status === "cancelled")
+        return result;
+    return {
+        status: result.status === "next" ? "selected" : "back",
+        decisions: files.map((conflict) => ({
+            conflict,
+            action: result.selected.includes(conflict.destination) ? "replace" : "keep",
+        })),
+    };
+}

package/dist/lib/contracts.js

@@ -0,0 +1,4 @@
+export const DEFAULT_INSTALL_DIRECTORIES = Object.freeze({
+    core: "src/utils/hermes",
+    lib: "libs/hermes",
+});

package/dist/lib/files.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+import { lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { isRecord } from "./json.js";
+export class PlanChangedError extends Error {
+    destination;
+    constructor(destination) {
+        super("File changed after planning; review a new plan: " + destination);
+        this.destination = destination;
+        this.name = "PlanChangedError";
+    }
+}
+export function readDestination(destination) {
+    const absolute = path.resolve(destination);
+    const root = path.parse(absolute).root;
+    const segments = absolute.slice(root.length).split(path.sep).filter(Boolean);
+    let current = root;
+    for (const [index, segment] of segments.entries()) {
+        current = path.join(current, segment);
+        let info;
+        try {
+            info = lstatSync(current);
+        }
+        catch (error) {
+            if (isRecord(error) && error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+        if (info.isSymbolicLink())
+            throw new Error("Refusing to write through a symbolic link: " + current);
+        if (index < segments.length - 1 && !info.isDirectory())
+            throw new Error("Expected a directory: " + current);
+        if (index === segments.length - 1) {
+            if (!info.isFile())
+                throw new Error("Expected a regular file: " + current);
+            return readFileSync(current, "utf8");
+        }
+    }
+    throw new Error("Expected a file path: " + destination);
+}
+export function assertUnchanged(file) {
+    if (readDestination(file.destination) !== file.existingContent)
+        throw new PlanChangedError(file.destination);
+}
+export function validateFilePlans(files) {
+    const destinations = new Set();
+    for (const file of files) {
+        if (!path.isAbsolute(file.destination) || destinations.has(file.destination)) {
+            throw new Error("Invalid or duplicate file destination: " + file.destination);
+        }
+        destinations.add(file.destination);
+        if ((file.action === "create") !== (file.existingContent === null)) {
+            throw new Error("File action does not match its previous state: " + file.destination);
+        }
+        assertUnchanged(file);
+    }
+    for (const destination of destinations) {
+        let parent = path.dirname(destination);
+        while (parent !== path.dirname(parent)) {
+            if (destinations.has(parent))
+                throw new Error("A planned file is also a destination directory: " + parent);
+            parent = path.dirname(parent);
+        }
+    }
+}
+export function writePlannedFile(file) {
+    assertUnchanged(file);
+    if (file.action === "keep")
+        return;
+    mkdirSync(path.dirname(file.destination), { recursive: true });
+    assertUnchanged(file);
+    if (file.action === "create") {
+        writeFileSync(file.destination, file.content, { flag: "wx" });
+        return;
+    }
+    const temporary = path.join(path.dirname(file.destination), ".hermes-" + randomUUID() + ".tmp");
+    try {
+        const mode = lstatSync(file.destination).mode & 0o777;
+        writeFileSync(temporary, file.content, { flag: "wx", mode });
+        assertUnchanged(file);
+        renameSync(temporary, file.destination);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+export function executeFilePlans(files, dryRun, onFile) {
+    validateFilePlans(files);
+    for (const file of files) {
+        if (!dryRun)
+            writePlannedFile(file);
+        onFile?.(file);
+    }
+}

package/dist/lib/install-prompts.js

@@ -0,0 +1,106 @@
+import { resolveInstallDirectory } from "./project-config.js";
+import { removeLastGrapheme, wrapTerminalLines } from "./terminal-text.js";
+function cancellation(key) {
+    if (key.ctrl && key.name === "c")
+        return { status: "cancelled", reason: "interrupt" };
+    if (key.ctrl && key.name === "d")
+        return { status: "cancelled", reason: "eof" };
+    return undefined;
+}
+export class DirectoryPrompt {
+    scope;
+    value;
+    cwd;
+    notice = "";
+    usable = true;
+    constructor(scope, value, cwd) {
+        this.scope = scope;
+        this.value = value;
+        this.cwd = cwd;
+    }
+    key(text, key) {
+        const cancelled = cancellation(key);
+        if (cancelled)
+            return cancelled;
+        if (key.name === "escape")
+            return { status: "back", value: this.value };
+        if (!this.usable)
+            return;
+        if (key.name === "return") {
+            try {
+                resolveInstallDirectory(this.value, this.cwd);
+                return { status: "next", value: this.value };
+            }
+            catch {
+                this.notice = "설치 경로를 입력해 주세요.";
+                return;
+            }
+        }
+        if (key.ctrl && key.name === "u")
+            this.value = "";
+        else if (key.name === "backspace")
+            this.value = removeLastGrapheme(this.value);
+        else if (!key.ctrl && !key.meta && text && !/[\p{Cc}\p{Cs}]/u.test(text))
+            this.value += text;
+        this.notice = "";
+    }
+}
+export class ReviewPrompt {
+    plan;
+    lines;
+    confirmed = false;
+    usable = true;
+    offset = 0;
+    pageSize = 1;
+    width = 0;
+    wrapped = [];
+    constructor(plan, lines) {
+        this.plan = plan;
+        this.lines = lines;
+    }
+    viewport(width, pageSize) {
+        if (this.width !== width) {
+            this.width = width;
+            this.wrapped = wrapTerminalLines(this.lines, width);
+        }
+        this.pageSize = pageSize;
+        this.offset = Math.max(0, Math.min(this.offset, this.wrapped.length - pageSize));
+        return { lines: this.wrapped.slice(this.offset, this.offset + pageSize), total: this.wrapped.length };
+    }
+    key(text, key) {
+        const cancelled = cancellation(key);
+        if (cancelled)
+            return cancelled;
+        if (text === "q" && !key.ctrl && !key.meta)
+            return { status: "cancelled", reason: "cancel" };
+        if (key.name === "escape")
+            return { status: "edit" };
+        if (!this.usable)
+            return;
+        if (key.ctrl || key.meta)
+            return;
+        if (key.name === "up")
+            this.offset--;
+        if (key.name === "down")
+            this.offset++;
+        if (key.name === "pageup")
+            this.offset -= this.pageSize;
+        if (key.name === "pagedown")
+            this.offset += this.pageSize;
+        if (key.name === "home")
+            this.offset = 0;
+        if (key.name === "end")
+            this.offset = this.wrapped.length;
+        this.offset = Math.max(0, Math.min(this.offset, this.wrapped.length - this.pageSize));
+        if (key.name === "tab")
+            this.confirmed = !this.confirmed;
+        if (text.toLowerCase() === "y")
+            this.confirmed = true;
+        if (text.toLowerCase() === "n")
+            this.confirmed = false;
+        if (this.plan.compatibilityErrors.length)
+            this.confirmed = false;
+        if (key.name === "return")
+            return { status: this.confirmed ? "confirmed" : "edit" };
+    }
+}

package/dist/lib/install-view.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import path from "node:path";
+import { Box, Text, useWindowSize } from "ink";
+import { DirectoryPrompt } from "./install-prompts.js";
+import { useTerminalInput } from "./terminal-input.js";
+import { Line, theme } from "./terminal-style.js";
+import { wrapTerminalLines } from "./terminal-text.js";
+export function InstallApp({ prompt, onKey, onPaste, }) {
+    useTerminalInput(onKey, onPaste);
+    const { columns, rows } = useWindowSize();
+    return _jsx(InstallView, { prompt: prompt, columns: columns || 80, rows: rows || 24 });
+}
+function ReviewLine({ text, width }) {
+    const color = text.startsWith("[생성]")
+        ? theme.accent
+        : text.startsWith("[교체]") || text.startsWith("!")
+            ? theme.warning
+            : text.startsWith("[유지]")
+                ? theme.muted
+                : undefined;
+    return _jsx(Line, { text: text, width: width, color: color });
+}
+export function InstallView({ prompt, columns, rows, }) {
+    const width = Math.max(1, columns - 1);
+    const height = Math.max(1, rows - 1);
+    const compact = width < 64 || height < 20;
+    const directory = prompt instanceof DirectoryPrompt;
+    prompt.usable = width >= 20 && height >= 7;
+    if (!prompt.usable)
+        return (_jsxs(Box, { width: width, height: height, flexDirection: "column", children: [_jsx(Text, { color: theme.warning, children: "\uD130\uBBF8\uB110\uC744 \uB113\uD600 \uC8FC\uC138\uC694." }), _jsx(Text, { children: "\uCD5C\uC18C 21\uC5F4 \u00D7 8\uD589" }), _jsx(Text, { dimColor: true, children: "Ctrl+C \uC911\uB2E8" })] }));
+    const bodyHeight = height - (compact ? 5 : 8);
+    const contentWidth = width - (compact ? 0 : 4);
+    const pageSize = Math.max(1, bodyHeight - (compact ? 0 : 2));
+    let body;
+    let footer;
+    if (directory) {
+        const lines = wrapTerminalLines([
+            "실제 위치: " + path.resolve(prompt.cwd, prompt.value || "."),
+            "",
+            "Enter로 현재 경로를 사용합니다.",
+            "Ctrl+U로 지우고 새 경로를 입력할 수 있어요.",
+            "설치 성공 후 no-k.config.ts에 저장합니다.",
+        ], contentWidth);
+        const input = wrapTerminalLines(["❯ " + prompt.value + "▏"], contentWidth).at(-1) ?? "";
+        body = (_jsxs(_Fragment, { children: [lines.slice(0, Math.max(0, pageSize - 2)).map((line, index) => (_jsx(Line, { text: line, width: contentWidth, color: theme.muted }, index))), _jsx(Box, { flexGrow: 1 }), _jsx(Line, { text: input, width: contentWidth, color: theme.accent, bold: true }), _jsx(Line, { text: prompt.notice || " ", width: contentWidth, color: theme.warning })] }));
+        footer = (_jsxs(_Fragment, { children: [_jsx(Line, { text: "Enter \uACBD\uB85C \uD655\uC815 \u00B7 Esc \uC774\uC804", width: width, color: theme.accent }), _jsx(Line, { text: "Ctrl+U \uC9C0\uC6B0\uAE30 \u00B7 Ctrl+C \uC911\uB2E8", width: width, color: theme.muted }), !compact && (_jsx(Line, { text: "\uC0C1\uB300 \uACBD\uB85C\uB294 \uD604\uC7AC \uC2E4\uD589 \uB514\uB809\uD130\uB9AC\uB97C \uAE30\uC900\uC73C\uB85C \uD569\uB2C8\uB2E4.", width: width, color: theme.muted }))] }));
+    }
+    else {
+        const view = prompt.viewport(contentWidth, pageSize);
+        body = view.lines.map((line, index) => _jsx(ReviewLine, { text: line, width: contentWidth }, prompt.offset + index));
+        const yes = width < 40 ? "Yes" : prompt.plan.dryRun ? "Yes · 계획 확인" : "Yes · 설치";
+        footer = (_jsxs(_Fragment, { children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsxs(Text, { color: prompt.confirmed ? theme.accent : theme.muted, bold: prompt.confirmed, children: [prompt.confirmed ? "❯ " : "  ", yes] }), "    ", _jsxs(Text, { color: !prompt.confirmed ? theme.accent : theme.muted, bold: !prompt.confirmed, children: [!prompt.confirmed ? "❯ " : "  ", width < 40 ? "No" : "No · 선택 수정"] })] }), _jsx(Line, { text: width < 40 ? "y/n 선택 · Enter 확정" : "y / n 또는 Tab 선택 · Enter 확정", width: width, color: theme.purple }), !compact && (_jsx(Line, { text: `↑↓ 스크롤 · PgUp/PgDn · Home/End · ${prompt.offset + 1}–${Math.min(view.total, prompt.offset + pageSize)}/${view.total} · Esc 수정 · q 취소`, width: width, color: theme.muted }))] }));
+    }
+    return (_jsxs(Box, { width: width, height: height, flexDirection: "column", children: [_jsx(Box, { height: compact ? 1 : 2, children: _jsxs(Text, { color: theme.accent, bold: true, children: [compact ? "◈ HERMES" : " ◈ H E R M E S", _jsx(Text, { color: theme.purple, children: " / INSTALL" })] }) }), _jsx(Line, { text: directory ? `${prompt.scope === "core" ? "Core" : "라이브러리"} · 설치 경로` : "최종 설치 목록", width: width, bold: true }), _jsx(Line, { text: directory
+                    ? "선택 → 경로 → 파일 검토 → 최종 확인"
+                    : prompt.plan.compatibilityErrors.length
+                        ? "호환성 문제를 먼저 해결해 주세요. No로 선택을 수정할 수 있습니다."
+                        : prompt.plan.dryRun
+                            ? "DRY RUN · 파일과 설정을 쓰지 않습니다."
+                            : "아래 내용으로 설치하시겠어요?", width: width, color: !directory && prompt.plan.compatibilityErrors.length ? theme.warning : theme.muted }), !compact && _jsx(Box, { height: 1 }), _jsx(Box, { width: width, height: bodyHeight, flexDirection: "column", flexShrink: 0, borderStyle: compact ? undefined : "round", borderColor: directory ? theme.accent : theme.border, paddingX: compact ? 0 : 1, overflow: "hidden", children: body }), footer] }));
+}

package/dist/lib/install-wizard.js

@@ -0,0 +1,105 @@
+import { CatalogSelection, selectCatalog } from "./catalog-selection.js";
+import { UTILITY_SCOPES } from "./catalog.js";
+import { selectConflicts } from "./conflict-selection.js";
+import { PlanChangedError } from "./files.js";
+import { DirectoryPrompt, ReviewPrompt } from "./install-prompts.js";
+import { createInstallPlan, executeInstallPlan, planUtilityFiles } from "./install.js";
+import { inspectInstallations } from "./installation-status.js";
+import { initialInstallDirectories, loadProjectConfig, resolveInstallDirectory } from "./project-config.js";
+import { formatInstallReview } from "./report.js";
+export async function runInstallWizard(request, catalog, packageDirectory, cwd, terminal) {
+    const selection = new CatalogSelection(catalog, { names: request.initialNames });
+    let config = loadProjectConfig(cwd);
+    const directories = { ...initialInstallDirectories(config, request.directory) };
+    const decisions = new Map();
+    let firstReview = true;
+    let stage = "selection";
+    let pathIndex = 0;
+    let notice = "";
+    while (true) {
+        const names = selection.selectedNames();
+        const scopes = UTILITY_SCOPES.filter((scope) => catalog.items.some((item) => item.scope === scope && names.includes(item.name)));
+        switch (stage) {
+            case "selection": {
+                const result = await selectCatalog(selection, terminal, inspectInstallations(catalog, config));
+                if (result.status === "cancelled")
+                    return result;
+                stage = "directories";
+                pathIndex = 0;
+                break;
+            }
+            case "directories": {
+                const scope = scopes[pathIndex];
+                if (!scope)
+                    stage = "review";
+                else {
+                    const result = await terminal.directory(new DirectoryPrompt(scope, directories[scope], cwd));
+                    if (result.status === "cancelled")
+                        return result;
+                    directories[scope] = result.value;
+                    if (result.status === "back") {
+                        if (pathIndex === 0)
+                            stage = "selection";
+                        else
+                            pathIndex--;
+                    }
+                    else
+                        pathIndex++;
+                }
+                break;
+            }
+            case "review": {
+                const targets = scopes.flatMap((scope) => {
+                    const [first, ...rest] = names.filter((name) => catalog.items.some((item) => item.name === name && item.scope === scope));
+                    return first ? [{ scope, names: [first, ...rest], directory: directories[scope] }] : [];
+                });
+                const [first, ...rest] = targets;
+                if (!first)
+                    throw new Error("Specify at least one item.");
+                try {
+                    const preview = planUtilityFiles(targets.map((target) => ({
+                        items: catalog.items.filter((item) => target.names.includes(item.name)),
+                        directory: resolveInstallDirectory(target.directory, cwd),
+                    })), packageDirectory);
+                    const previous = firstReview && request.overwrite
+                        ? preview.conflicts.map((conflict) => ({ conflict, action: "replace" }))
+                        : [...decisions.values()];
+                    firstReview = false;
+                    const conflicts = await selectConflicts(preview.conflicts, terminal, previous);
+                    if (conflicts.status === "cancelled")
+                        return conflicts;
+                    for (const decision of conflicts.decisions)
+                        decisions.set(decision.conflict.destination, decision);
+                    if (conflicts.status === "back") {
+                        stage = "directories";
+                        pathIndex = scopes.length - 1;
+                        break;
+                    }
+                    // 충돌 화면을 보고 있는 사이 생긴 변경도 최종 확인 전에 다시 검토한다.
+                    const plan = createInstallPlan({ config, targets: [first, ...rest], dryRun: request.dryRun, fileDecisions: conflicts.decisions }, catalog, packageDirectory);
+                    const changedConflict = plan.conflicts.find((file) => !preview.conflicts.some((before) => before.destination === file.destination &&
+                        before.existingContent === file.existingContent &&
+                        before.content === file.content));
+                    if (changedConflict)
+                        throw new PlanChangedError(changedConflict.destination);
+                    const review = await terminal.review(new ReviewPrompt(plan, [...(notice ? ["! " + notice, ""] : []), ...formatInstallReview(plan, catalog)]));
+                    if (review.status === "cancelled")
+                        return review;
+                    if (review.status === "edit" || plan.compatibilityErrors.length) {
+                        stage = "selection";
+                        break;
+                    }
+                    const result = executeInstallPlan(plan);
+                    return { status: result.status, plan, result };
+                }
+                catch (error) {
+                    if (!(error instanceof PlanChangedError))
+                        throw error;
+                    config = loadProjectConfig(cwd);
+                    notice = "검토 중 파일이 변경되어 설치 계획을 다시 계산했습니다. 새 목록을 확인해 주세요.";
+                }
+                break;
+            }
+        }
+    }
+}