@wp-typia/create 0.1.0

package/dist/runtime/cli-core.js

@@ -0,0 +1,222 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+import { collectScaffoldAnswers, resolvePackageManagerId, resolveTemplateId, scaffoldProject, } from "./scaffold.js";
+import { PACKAGE_MANAGER_IDS, formatInstallCommand, formatRunScript, } from "./package-managers.js";
+import { TEMPLATE_IDS, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
+export function createReadlinePrompt() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return {
+        async text(message, defaultValue, validate) {
+            const suffix = defaultValue ? ` (${defaultValue})` : "";
+            const answer = await new Promise((resolve) => {
+                rl.question(`${message}${suffix}: `, resolve);
+            });
+            const value = String(answer).trim() || defaultValue;
+            if (validate) {
+                const result = validate(value);
+                if (result !== true) {
+                    console.error(`❌ ${typeof result === "string" ? result : "Invalid input"}`);
+                    return this.text(message, defaultValue, validate);
+                }
+            }
+            return value;
+        },
+        async select(message, options, defaultValue = 1) {
+            console.log(message);
+            options.forEach((option, index) => {
+                const hint = option.hint ? ` - ${option.hint}` : "";
+                console.log(`  ${index + 1}. ${option.label}${hint}`);
+            });
+            const answer = await this.text("Choice", String(defaultValue));
+            const numericChoice = Number(answer);
+            if (!Number.isNaN(numericChoice) && options[numericChoice - 1]) {
+                return options[numericChoice - 1].value;
+            }
+            const directChoice = options.find((option) => option.value === answer);
+            if (directChoice) {
+                return directChoice.value;
+            }
+            console.error(`❌ Invalid selection: ${answer}`);
+            return this.select(message, options, defaultValue);
+        },
+        close() {
+            rl.close();
+        },
+    };
+}
+export function formatHelpText() {
+    return `Usage:
+  wp-typia <project-dir> [--template <id>] [--yes] [--no-install] [--package-manager <id>]
+  wp-typia templates list
+  wp-typia templates inspect <id>
+  wp-typia migrations <init|snapshot|diff|scaffold|verify> [...]
+  wp-typia doctor
+
+Templates: ${TEMPLATE_IDS.join(", ")}
+Package managers: ${PACKAGE_MANAGER_IDS.join(", ")}`;
+}
+export function formatTemplateSummary(template) {
+    return `${template.id.padEnd(14)} ${template.description}`;
+}
+export function formatTemplateFeatures(template) {
+    return `  ${template.features.join(" • ")}`;
+}
+export function formatTemplateDetails(template) {
+    return [
+        template.id,
+        template.description,
+        `Category: ${template.defaultCategory}`,
+        `Path: ${template.templateDir}`,
+        `Features: ${template.features.join(", ")}`,
+    ].join("\n");
+}
+function readCommandVersion(command, args = ["--version"]) {
+    try {
+        return execFileSync(command, args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function compareMajorVersion(actualVersion, minimumMajor) {
+    const parsed = Number.parseInt(actualVersion.replace(/^v/, "").split(".")[0] ?? "", 10);
+    return Number.isFinite(parsed) && parsed >= minimumMajor;
+}
+async function checkWritableDirectory(directory) {
+    try {
+        await access(directory, fsConstants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkTempDirectory() {
+    const tempFile = path.join(os.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+    try {
+        await writeFile(tempFile, "ok", "utf8");
+        await rm(tempFile, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getDoctorChecks(cwd) {
+    const checks = [];
+    const bunVersion = readCommandVersion("bun");
+    const nodeVersion = readCommandVersion("node");
+    const gitVersion = readCommandVersion("git");
+    const cwdWritable = await checkWritableDirectory(cwd);
+    const tempWritable = await checkTempDirectory();
+    checks.push({
+        status: bunVersion && compareMajorVersion(bunVersion, 1) ? "pass" : "fail",
+        label: "Bun",
+        detail: bunVersion ? `Detected ${bunVersion}` : "Not available",
+    });
+    checks.push({
+        status: nodeVersion && compareMajorVersion(nodeVersion, 16) ? "pass" : "fail",
+        label: "Node",
+        detail: nodeVersion ? `Detected ${nodeVersion}` : "Not available",
+    });
+    checks.push({
+        status: gitVersion ? "pass" : "fail",
+        label: "git",
+        detail: gitVersion ?? "Not available",
+    });
+    checks.push({
+        status: cwdWritable ? "pass" : "fail",
+        label: "Current directory",
+        detail: cwdWritable ? "Writable" : "Not writable",
+    });
+    checks.push({
+        status: tempWritable ? "pass" : "fail",
+        label: "Temp directory",
+        detail: tempWritable ? "Writable" : "Not writable",
+    });
+    for (const template of listTemplates()) {
+        const hasAssets = fs.existsSync(template.templateDir) &&
+            fs.existsSync(path.join(template.templateDir, "package.json.mustache"));
+        checks.push({
+            status: hasAssets ? "pass" : "fail",
+            label: `Template ${template.id}`,
+            detail: hasAssets ? template.templateDir : "Missing core template assets",
+        });
+    }
+    return checks;
+}
+export async function runDoctor(cwd, { renderLine = (check) => console.log(`${check.status.toUpperCase()} ${check.label}: ${check.detail}`) } = {}) {
+    const checks = await getDoctorChecks(cwd);
+    for (const check of checks) {
+        renderLine(check);
+    }
+    if (checks.some((check) => check.status === "fail")) {
+        throw new Error("Doctor found one or more failing checks.");
+    }
+    return checks;
+}
+export function getNextSteps({ projectInput, projectDir, packageManager, noInstall, }) {
+    const steps = [`cd ${path.isAbsolute(projectInput) ? projectDir : projectInput}`];
+    if (noInstall) {
+        steps.push(formatInstallCommand(packageManager));
+    }
+    steps.push(formatRunScript(packageManager, "start"));
+    return steps;
+}
+export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templateId, packageManager, yes = false, noInstall = false, isInteractive = false, allowExistingDir = false, selectTemplate, selectPackageManager, promptText, installDependencies = undefined, }) {
+    if (!projectInput) {
+        throw new Error("Project directory is required. Usage: wp-typia <project-dir>");
+    }
+    const resolvedTemplateId = await resolveTemplateId({
+        templateId,
+        yes,
+        isInteractive,
+        selectTemplate,
+    });
+    const resolvedPackageManager = await resolvePackageManagerId({
+        packageManager,
+        yes,
+        isInteractive,
+        selectPackageManager,
+    });
+    const projectDir = path.resolve(cwd, projectInput);
+    const projectName = path.basename(projectDir);
+    const answers = await collectScaffoldAnswers({
+        projectName,
+        templateId: resolvedTemplateId,
+        yes,
+        promptText,
+    });
+    const result = await scaffoldProject({
+        answers,
+        allowExistingDir,
+        installDependencies,
+        noInstall,
+        packageManager: resolvedPackageManager,
+        projectDir,
+        templateId: resolvedTemplateId,
+    });
+    return {
+        projectDir,
+        projectInput,
+        packageManager: resolvedPackageManager,
+        result,
+        nextSteps: getNextSteps({
+            projectInput,
+            projectDir,
+            packageManager: resolvedPackageManager,
+            noInstall,
+        }),
+    };
+}
+export { getTemplateById, getTemplateSelectOptions, listTemplates };

package/dist/runtime/index.js

@@ -0,0 +1,4 @@
+export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
+export { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand, } from "./migrations.js";
+export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
+export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";

package/dist/runtime/migration-constants.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+export const ROOT_BLOCK_JSON = "block.json";
+export const ROOT_MANIFEST = "typia.manifest.json";
+export const ROOT_PHP_MIGRATION_REGISTRY = "typia-migration-registry.php";
+export const ROOT_SAVE_FILE = path.join("src", "save.tsx");
+export const ROOT_TYPES_FILE = path.join("src", "types.ts");
+export const MIGRATIONS_DIR = path.join("src", "migrations");
+export const CONFIG_FILE = path.join(MIGRATIONS_DIR, "config.ts");
+export const GENERATED_DIR = path.join(MIGRATIONS_DIR, "generated");
+export const FIXTURES_DIR = path.join(MIGRATIONS_DIR, "fixtures");
+export const RULES_DIR = path.join(MIGRATIONS_DIR, "rules");
+export const SNAPSHOT_DIR = path.join(MIGRATIONS_DIR, "versions");
+export const SUPPORTED_PROJECT_FILES = ["package.json", ROOT_BLOCK_JSON, ROOT_SAVE_FILE, ROOT_TYPES_FILE];
+export const MIGRATION_TODO_PREFIX = "TODO MIGRATION:";