create-sonamu 0.0.1 → 0.0.3

package/index.js

@@ -0,0 +1,632 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import minimist from "minimist";
+import ora from "ora";
+import prompts from "prompts";
+// 생성된 파일/디렉토리 전역에서 추적하기 위한 변수
+var createdTargetRoot = null;
+var isCleaningUp = false;
+// Helper: package.json에서 catalog 패키지 추출
+function extractCatalogPackages(packageJsonPath) {
+    var packages = new Set();
+    if (!fs.existsSync(packageJsonPath))
+        return packages;
+    var pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    var allDeps = __assign(__assign({}, pkg.dependencies), pkg.devDependencies);
+    for (var _i = 0, _a = Object.entries(allDeps); _i < _a.length; _i++) {
+        var _b = _a[_i], name_1 = _b[0], version = _b[1];
+        if (version === "catalog:") {
+            packages.add(name_1);
+        }
+    }
+    return packages;
+}
+// Helper: pnpm-workspace.yaml에서 catalog 파싱
+function parseCatalogFromWorkspace(workspacePath) {
+    if (!fs.existsSync(workspacePath))
+        return {};
+    var content = fs.readFileSync(workspacePath, "utf-8");
+    var catalog = {};
+    var lines = content.split("\n");
+    var inCatalog = false;
+    for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+        var line = lines_1[_i];
+        if (line.trim() === "catalog:") {
+            inCatalog = true;
+            continue;
+        }
+        if (inCatalog) {
+            // catalog 섹션이 끝나면 중단
+            if (line && !line.startsWith(" ") && !line.startsWith("\t")) {
+                break;
+            }
+            // 패키지 파싱: "  package-name: version"
+            var match = line.match(/^\s+["']?([^"':]+)["']?:\s*(.+)$/);
+            if (match) {
+                var name_2 = match[1], version = match[2];
+                catalog[name_2.trim()] = version.trim();
+            }
+        }
+    }
+    return catalog;
+}
+// Helper: workspace 패키지의 실제 버전 가져오기
+function getWorkspacePackageVersion(packageName, workspaceRoot) {
+    var packagePath = path.join(workspaceRoot, "modules", packageName, "package.json");
+    if (fs.existsSync(packagePath)) {
+        var pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+        return "^".concat(pkg.version);
+    }
+    return "workspace:^"; // fallback
+}
+function init() {
+    return __awaiter(this, void 0, void 0, function () {
+        var shutdownHandler, argv, argProjectName, useDefaults, parseYesNo, result, e_1, targetDir, targetRoot, overwrite, result_1, templateRoot, copy, write, files, _i, _a, file, workspaceRoot, parentWorkspacePath, apiPkgPath, webPkgPath, apiPackages, webPackages, allCatalogPackages, parentCatalog, catalogEntries, _b, _c, pkgName, version, workspaceContent, isPnpm, pnpmOption, result_2, error_1, isDatabase, dockerOption, result_3, useDbDefaults, answers, error_2, env, initSqlPath, initSql;
+        var _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    shutdownHandler = function () {
+                        cleanup();
+                        process.exit(1);
+                    };
+                    process.on("SIGINT", shutdownHandler);
+                    process.on("SIGTERM", shutdownHandler);
+                    argv = minimist(process.argv.slice(2), {
+                        boolean: ["yes", "y", "skip-pnpm", "skip-docker"],
+                        string: [
+                            "db-user",
+                            "db-password",
+                            "db-name",
+                            "container-name",
+                            "docker-project",
+                            "pnpm",
+                            "docker",
+                        ],
+                        alias: {
+                            y: "yes",
+                            "docker-pj-name": "docker-project", // --docker-pj-name은 --docker-project의 alias
+                        },
+                    });
+                    argProjectName = argv._[0];
+                    useDefaults = argv.yes || argv.y;
+                    parseYesNo = function (value) {
+                        if (value === undefined)
+                            return undefined;
+                        var lower = value.toLowerCase();
+                        if (["y", "yes", "true", "1"].includes(lower))
+                            return true;
+                        if (["n", "no", "false", "0"].includes(lower))
+                            return false;
+                        return undefined;
+                    };
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 5, , 6]);
+                    if (!argProjectName) return [3 /*break*/, 2];
+                    result = { targetDir: argProjectName };
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, prompts([
+                        {
+                            type: "text",
+                            name: "targetDir",
+                            message: "Project name:",
+                            initial: "my_sonamu_app",
+                            validate: function (value) {
+                                if (!value) {
+                                    return "Project name is required";
+                                }
+                                if (value.includes(" ")) {
+                                    return "Project name cannot contain spaces";
+                                }
+                                if (value.includes("-")) {
+                                    return "Project name cannot contain hyphens";
+                                }
+                                return true;
+                            },
+                        },
+                    ], {
+                        onCancel: createCancelHandler(),
+                    })];
+                case 3:
+                    result = _e.sent();
+                    _e.label = 4;
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    e_1 = _e.sent();
+                    cleanup();
+                    console.error(e_1);
+                    process.exit(1);
+                    return [3 /*break*/, 6];
+                case 6:
+                    targetDir = result.targetDir;
+                    targetRoot = path.join(process.cwd(), targetDir);
+                    if (!fs.existsSync(targetRoot)) return [3 /*break*/, 9];
+                    overwrite = useDefaults;
+                    if (!!useDefaults) return [3 /*break*/, 8];
+                    return [4 /*yield*/, prompts({
+                            type: "confirm",
+                            name: "overwrite",
+                            message: "Directory ".concat(targetRoot, " already exists. Overwrite?"),
+                            initial: true,
+                        }, {
+                            onCancel: createCancelHandler(),
+                        })];
+                case 7:
+                    result_1 = _e.sent();
+                    overwrite = result_1.overwrite;
+                    _e.label = 8;
+                case 8:
+                    if (!overwrite) {
+                        console.log(chalk.yellow("Operation cancelled."));
+                        process.exit(0);
+                    }
+                    // 기존 디렉토리 삭제
+                    console.log(chalk.yellow("Removing existing directory: ".concat(targetRoot)));
+                    removeDirectory(targetRoot);
+                    _e.label = 9;
+                case 9:
+                    createdTargetRoot = targetRoot; // 생성된 디렉토리 추적 시작
+                    templateRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "template", "src");
+                    // 복사 시작 전에 타겟 프로젝트 폴더 생성
+                    if (!fs.existsSync(targetRoot)) {
+                        fs.mkdirSync(targetRoot, { recursive: true });
+                    }
+                    copy = function (src, dest) {
+                        var stat = fs.statSync(src);
+                        var basename = path.basename(src);
+                        // 제외할 디렉토리/파일 목록
+                        var excludeList = ["dist", ".git", ".gitkeep", "node_modules", "pnpm-lock.yaml"];
+                        if (excludeList.includes(basename)) {
+                            if (basename === ".gitkeep") {
+                                console.log("".concat(chalk.green("CREATE"), " ").concat(dest.split(".gitkeep")[0]));
+                            }
+                            return;
+                        }
+                        if (stat.isDirectory()) {
+                            // 디렉토리는 생성
+                            if (!fs.existsSync(dest)) {
+                                fs.mkdirSync(dest, { recursive: true });
+                            }
+                            for (var _i = 0, _a = fs.readdirSync(src); _i < _a.length; _i++) {
+                                var file = _a[_i];
+                                var srcFile = path.resolve(src, file);
+                                var destFile = path.resolve(dest, file);
+                                copy(srcFile, destFile);
+                            }
+                        }
+                        else {
+                            // 파일은 복사
+                            fs.copyFileSync(src, dest);
+                            console.log("".concat(chalk.green("CREATE"), " ").concat(dest));
+                        }
+                    };
+                    write = function (file) {
+                        var src = path.join(templateRoot, file);
+                        var dest = path.join(targetRoot, file);
+                        copy(src, dest);
+                    };
+                    files = fs.readdirSync(templateRoot);
+                    for (_i = 0, _a = files.filter(function (f) { return f !== "package.json"; }); _i < _a.length; _i++) {
+                        file = _a[_i];
+                        write(file);
+                    }
+                    workspaceRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+                    ["packages/api", "packages/web"].forEach(function (dir) {
+                        var pkgPath = path.join(templateRoot, dir, "package.json");
+                        if (fs.existsSync(pkgPath)) {
+                            var pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                            // Extract just "api" or "web" from "packages/api"
+                            var pkgType = dir.split("/")[1];
+                            pkg.name = "".concat(targetDir, "-").concat(pkgType);
+                            // Replace workspace:^ with actual versions
+                            var replaceDeps = function (deps) {
+                                if (!deps)
+                                    return;
+                                for (var _i = 0, _a = Object.entries(deps); _i < _a.length; _i++) {
+                                    var _b = _a[_i], name_3 = _b[0], version = _b[1];
+                                    if (version === "workspace:^") {
+                                        // Extract package name from scoped package (e.g., @sonamu-kit/react-sui -> react-sui)
+                                        var pkgName = name_3.includes("/") ? name_3.split("/")[1] : name_3;
+                                        deps[name_3] = getWorkspacePackageVersion(pkgName, workspaceRoot);
+                                    }
+                                }
+                            };
+                            replaceDeps(pkg.dependencies);
+                            replaceDeps(pkg.devDependencies);
+                            fs.writeFileSync(path.join(targetRoot, dir, "package.json"), JSON.stringify(pkg, null, 2));
+                        }
+                    });
+                    parentWorkspacePath = path.join(workspaceRoot, "pnpm-workspace.yaml");
+                    apiPkgPath = path.join(templateRoot, "packages", "api", "package.json");
+                    webPkgPath = path.join(templateRoot, "packages", "web", "package.json");
+                    apiPackages = extractCatalogPackages(apiPkgPath);
+                    webPackages = extractCatalogPackages(webPkgPath);
+                    allCatalogPackages = new Set(__spreadArray(__spreadArray([], Array.from(apiPackages), true), Array.from(webPackages), true));
+                    parentCatalog = parseCatalogFromWorkspace(parentWorkspacePath);
+                    catalogEntries = [];
+                    for (_b = 0, _c = Array.from(allCatalogPackages).sort(); _b < _c.length; _b++) {
+                        pkgName = _c[_b];
+                        version = parentCatalog[pkgName];
+                        if (version) {
+                            catalogEntries.push("  \"".concat(pkgName, "\": ").concat(version));
+                        }
+                    }
+                    workspaceContent = "packages:\n  - packages/api\n  - packages/web\n\ncatalog:\n".concat(catalogEntries.join("\n"), "\n\nonlyBuiltDependencies:\n  - \"@parcel/watcher\"\n  - \"@swc/core\"\n  - bcrypt\n  - esbuild\n  - libpq\n  - sharp\n  - sodium-native\n  - unrs-resolver\n\noverrides:\n  axios@<0.30.0: \">=0.30.0\"\n  axios@<0.30.2: \">=0.30.2\"\n  axios@>=0.8.1 <0.28.0: \">=0.28.0\"\n  mdast-util-to-hast@>=13.0.0 <13.2.1: \">=13.2.1\"\n  prismjs@<1.30.0: \">=1.30.0\"\n");
+                    fs.writeFileSync(path.join(targetRoot, "pnpm-workspace.yaml"), workspaceContent);
+                    console.log("".concat(chalk.green("CREATE"), " ").concat(path.join(targetRoot, "pnpm-workspace.yaml")));
+                    console.log("\n\uD83C\uDF32 Created project in ".concat(targetRoot, "\n"));
+                    isPnpm = true;
+                    pnpmOption = parseYesNo(argv.pnpm);
+                    if (!(argv["skip-pnpm"] || pnpmOption === false)) return [3 /*break*/, 10];
+                    // --skip-pnpm 또는 --pnpm n 옵션으로 스킵
+                    isPnpm = false;
+                    return [3 /*break*/, 13];
+                case 10:
+                    if (!(pnpmOption === true || useDefaults)) return [3 /*break*/, 11];
+                    // --pnpm y 또는 --yes 옵션이면 자동 진행
+                    isPnpm = true;
+                    return [3 /*break*/, 13];
+                case 11: return [4 /*yield*/, prompts({
+                        type: "confirm",
+                        name: "isPnpm",
+                        message: "Would you like to set up pnpm?",
+                        initial: true,
+                    }, {
+                        onCancel: createCancelHandler(),
+                    })];
+                case 12:
+                    result_2 = _e.sent();
+                    isPnpm = result_2.isPnpm;
+                    _e.label = 13;
+                case 13:
+                    if (!isPnpm) return [3 /*break*/, 18];
+                    _e.label = 14;
+                case 14:
+                    _e.trys.push([14, 16, , 17]);
+                    // Install dependencies from the root directory (workspace)
+                    return [4 /*yield*/, setupPnpm(targetRoot)];
+                case 15:
+                    // Install dependencies from the root directory (workspace)
+                    _e.sent();
+                    return [3 /*break*/, 17];
+                case 16:
+                    error_1 = _e.sent();
+                    cleanup();
+                    throw error_1;
+                case 17: return [3 /*break*/, 19];
+                case 18:
+                    console.log("\nTo set up pnpm, run the following commands:\n");
+                    console.log(chalk.gray("  $ cd ".concat(targetRoot)));
+                    console.log(chalk.gray("  $ pnpm install"));
+                    _e.label = 19;
+                case 19:
+                    isDatabase = true;
+                    dockerOption = parseYesNo(argv.docker);
+                    if (!(argv["skip-docker"] || dockerOption === false)) return [3 /*break*/, 20];
+                    // --skip-docker 또는 --docker n 옵션으로 스킵
+                    isDatabase = false;
+                    return [3 /*break*/, 23];
+                case 20:
+                    if (!(dockerOption === true || useDefaults)) return [3 /*break*/, 21];
+                    // --docker y 또는 --yes 옵션이면 자동 진행
+                    isDatabase = true;
+                    return [3 /*break*/, 23];
+                case 21: return [4 /*yield*/, prompts({
+                        type: "confirm",
+                        name: "isDatabase",
+                        message: "Would you like to set up a database using Docker?",
+                        initial: true,
+                    }, {
+                        onCancel: createCancelHandler(),
+                    })];
+                case 22:
+                    result_3 = _e.sent();
+                    isDatabase = result_3.isDatabase;
+                    _e.label = 23;
+                case 23:
+                    if (!isDatabase) return [3 /*break*/, 28];
+                    console.log("\nSetting up a database using Docker...");
+                    useDbDefaults = useDefaults || dockerOption === true;
+                    answers = void 0;
+                    _e.label = 24;
+                case 24:
+                    _e.trys.push([24, 26, , 27]);
+                    return [4 /*yield*/, promptDatabase(targetDir, argv, useDbDefaults)];
+                case 25:
+                    answers = _e.sent();
+                    return [3 /*break*/, 27];
+                case 26:
+                    error_2 = _e.sent();
+                    cleanup();
+                    throw error_2;
+                case 27:
+                    env = "# Database Configuration\nDB_HOST=0.0.0.0\nDB_PORT=5432\nDB_USER=".concat((_d = answers.DB_USER) !== null && _d !== void 0 ? _d : "postgres", "\nDB_PASSWORD=").concat(answers.DB_PASSWORD, "\nCONTAINER_NAME=").concat(answers.CONTAINER_NAME, "\nDATABASE_NAME=").concat(answers.DATABASE_NAME, "\nPROJECT_NAME=").concat(targetDir, "\n");
+                    fs.writeFileSync(path.join(targetRoot, "packages", "api", ".env"), env);
+                    initSqlPath = path.join(targetRoot, "packages", "api", "database", "fixtures", "init.sql");
+                    if (fs.existsSync(initSqlPath)) {
+                        initSql = fs.readFileSync(initSqlPath, "utf-8");
+                        initSql = initSql.replace(/\$\{DATABASE_NAME\}/g, answers.DATABASE_NAME);
+                        fs.writeFileSync(initSqlPath, initSql);
+                    }
+                    return [3 /*break*/, 29];
+                case 28:
+                    console.log("\nTo set up a database using Docker, run the following commands:\n");
+                    console.log(chalk.gray("  $ cd ".concat(targetRoot, "/packages/api/database")));
+                    console.log(chalk.gray("  $ docker compose -p ".concat(targetDir, " up -d")));
+                    console.log("\nOr use your preferred database management tool.");
+                    _e.label = 29;
+                case 29:
+                    // 성공적으로 완료되면 cleanup 방지
+                    createdTargetRoot = null;
+                    return [2 /*return*/, targetRoot];
+            }
+        });
+    });
+}
+function executeCommand(command_1, args_1, cwd_1) {
+    return __awaiter(this, arguments, void 0, function (command, args, cwd, options) {
+        var _a, showOutput, child, spinner, startTime, success, output, errorOutput;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_b) {
+            _a = options.showOutput, showOutput = _a === void 0 ? false : _a;
+            child = spawn(command, args, {
+                cwd: cwd,
+                stdio: ["inherit", "pipe", "pipe"], // stdin은 상속, stdout/stderr는 pipe로 처리
+                env: __assign({}, process.env), // 환경변수 상속
+            });
+            spinner = ora("Running ".concat(command, " ").concat(args.join(" ")));
+            success = true;
+            output = "";
+            errorOutput = "";
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    var _a, _b;
+                    child.on("spawn", function () {
+                        spinner.start();
+                        startTime = Date.now();
+                    });
+                    (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on("data", function (data) {
+                        output += data.toString();
+                    });
+                    (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on("data", function (data) {
+                        errorOutput += data.toString();
+                    });
+                    child.on("error", function (error) {
+                        success = false;
+                        spinner.fail("".concat(command, " ").concat(args.join(" ")));
+                        console.error(chalk.red("\uD83D\uDEA8 Error: ".concat(command)));
+                        console.error(error);
+                        reject(error);
+                    });
+                    child.on("close", function (code) {
+                        if (!success || code !== 0) {
+                            if (code !== 0) {
+                                spinner.fail("".concat(command, " ").concat(args.join(" ")));
+                                console.error(chalk.red("Command failed with exit code ".concat(code, ": ").concat(command, " ").concat(args.join(" "))));
+                                if (errorOutput) {
+                                    console.error(errorOutput);
+                                }
+                                reject(new Error("Command failed with exit code ".concat(code)));
+                            }
+                            return;
+                        }
+                        var durationS = ((Date.now() - startTime) / 1000).toFixed(2);
+                        if (showOutput && output.trim()) {
+                            spinner.succeed("".concat(command, " ").concat(args.join(" "), " ").concat(chalk.dim("".concat(durationS, "s"))));
+                            console.log(chalk.cyan(output.trim()));
+                        }
+                        else {
+                            spinner.succeed("".concat(command, " ").concat(args.join(" "), " ").concat(chalk.dim("".concat(durationS, "s"))));
+                        }
+                        resolve("");
+                    });
+                })];
+        });
+    });
+}
+function setupPnpm(projectName, dir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var cwd, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    cwd = dir ? path.resolve(projectName, dir) : path.resolve(projectName);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    console.log(chalk.blue("Setting up pnpm in ".concat(cwd, "...")));
+                    return [4 /*yield*/, executeCommand("pnpm", ["install"], cwd)];
+                case 2:
+                    _a.sent();
+                    console.log(chalk.green("\u2705 pnpm has been set up in ".concat(cwd, "\n")));
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_3 = _a.sent();
+                    console.error(chalk.red("\u274C Failed to set up pnpm in ".concat(cwd)));
+                    console.error(error_3);
+                    throw error_3;
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function promptDatabase(projectName, argv, useDefaults) {
+    return __awaiter(this, void 0, void 0, function () {
+        var dockerProject, dbUser, containerName, databaseName, dbPassword, answers;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dockerProject = argv["docker-project"];
+                    dbUser = argv["db-user"];
+                    containerName = argv["container-name"];
+                    databaseName = argv["db-name"];
+                    dbPassword = argv["db-password"];
+                    // 모든 값이 제공되었으면 프롬프트 스킵
+                    if (dockerProject && dbUser && containerName && databaseName && dbPassword) {
+                        return [2 /*return*/, {
+                                DOCKER_PROJECT_NAME: dockerProject,
+                                DB_USER: dbUser,
+                                CONTAINER_NAME: containerName,
+                                DATABASE_NAME: databaseName,
+                                DB_PASSWORD: dbPassword,
+                            }];
+                    }
+                    // --yes 옵션이면 기본값 사용
+                    if (useDefaults) {
+                        return [2 /*return*/, {
+                                DOCKER_PROJECT_NAME: dockerProject || "".concat(projectName, "-docker"),
+                                DB_USER: dbUser || "postgres",
+                                CONTAINER_NAME: containerName || "".concat(projectName, "-container"),
+                                DATABASE_NAME: databaseName || projectName,
+                                DB_PASSWORD: dbPassword || "1234",
+                            }];
+                    }
+                    return [4 /*yield*/, prompts([
+                            {
+                                type: dockerProject ? null : "text",
+                                name: "DOCKER_PROJECT_NAME",
+                                message: "Enter the Docker project name:",
+                                initial: dockerProject || "".concat(projectName, "-docker"),
+                            },
+                            {
+                                type: dbUser ? null : "text",
+                                name: "DB_USER",
+                                message: "Enter the database user: ",
+                                initial: dbUser || "postgres",
+                            },
+                            {
+                                type: containerName ? null : "text",
+                                name: "CONTAINER_NAME",
+                                message: "Enter the container name: ",
+                                initial: containerName || "".concat(projectName, "-container"),
+                            },
+                            {
+                                type: databaseName ? null : "text",
+                                name: "DATABASE_NAME",
+                                message: "Enter the database name: ",
+                                initial: databaseName || projectName,
+                            },
+                            {
+                                type: dbPassword ? null : "password",
+                                name: "DB_PASSWORD",
+                                message: "Enter the database password: ",
+                                initial: dbPassword || "",
+                            },
+                        ], {
+                            onCancel: createCancelHandler(),
+                        })];
+                case 1:
+                    answers = _a.sent();
+                    return [2 /*return*/, {
+                            DOCKER_PROJECT_NAME: dockerProject || answers.DOCKER_PROJECT_NAME,
+                            DB_USER: dbUser || answers.DB_USER,
+                            CONTAINER_NAME: containerName || answers.CONTAINER_NAME,
+                            DATABASE_NAME: databaseName || answers.DATABASE_NAME,
+                            DB_PASSWORD: dbPassword || answers.DB_PASSWORD,
+                        }];
+            }
+        });
+    });
+}
+function createCancelHandler() {
+    return function () {
+        cleanup();
+        throw new Error("Operation cancelled.");
+    };
+}
+function removeDirectory(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return;
+    }
+    try {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+    catch (_error) {
+        console.error(chalk.yellow("Warning: Failed to remove ".concat(dirPath)));
+    }
+}
+function cleanup() {
+    if (isCleaningUp || !createdTargetRoot) {
+        return;
+    }
+    isCleaningUp = true;
+    console.log(chalk.yellow("\n\n Operation cancelled. Cleaning up created files...\n"));
+    try {
+        if (fs.existsSync(createdTargetRoot)) {
+            removeDirectory(createdTargetRoot);
+            console.log(chalk.green("Cleaned up ".concat(createdTargetRoot, "\n")));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red("Failed to clean up: ".concat(error)));
+    }
+}
+init()
+    .then(function (createdTarget) {
+    console.log(chalk.green("\nProject created successfully!\n"));
+    console.log(chalk.green("project was created in ".concat(chalk.blue(createdTarget), "\n")));
+})
+    .catch(function (e) {
+    cleanup();
+    console.error(e);
+    process.exit(1);
+});