create-qauri 0.2.0

package/dist/index.mjs

@@ -0,0 +1,744 @@
+#!/usr/bin/env node
+
+// src/commands/create.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { resolve as resolve4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+
+// src/validator.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var PROJECT_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+function validateProjectName(name) {
+  if (!name) {
+    return { valid: false, message: "Project name cannot be empty" };
+  }
+  if (!PROJECT_NAME_RE.test(name)) {
+    return {
+      valid: false,
+      message: "Project name must start with a letter and contain only letters, numbers, hyphens, and underscores"
+    };
+  }
+  return { valid: true };
+}
+
+// src/utils/config.ts
+import { readFile } from "fs/promises";
+import { resolve as resolve2 } from "path";
+function buildConfig(selections) {
+  const features = selections.features ?? [];
+  const hasFeature = (f) => features.includes(f);
+  const config = {
+    project: {
+      name: selections.projectName,
+      version: "0.1.0",
+      type: selections.language
+    },
+    window: {
+      title: selections.projectName,
+      width: 800,
+      height: 600,
+      resizable: true,
+      center: true
+    },
+    dev: {
+      serverUrl: `http://localhost:${selections.devPort}`,
+      autoStart: true
+    },
+    prod: {
+      distDir: "../dist",
+      entry: "index.html"
+    },
+    debug: {
+      enableF12: hasFeature("devtools"),
+      enableF5: hasFeature("reload")
+    },
+    newWindow: {
+      behavior: selections.newWindowBehavior ?? "block"
+    },
+    ipc: {
+      enableWhitelist: hasFeature("whitelist"),
+      ...hasFeature("examples") ? { allowedCommands: ["greet", "getSystemInfo", "readFile"] } : {}
+    }
+  };
+  if (selections.language === "python") {
+    config.python = {
+      ...selections.pythonVersion ? { version: selections.pythonVersion } : {},
+      ...selections.pythonPath ? { path: selections.pythonPath } : {},
+      ...selections.pythonEnvTool ? { packageManager: selections.pythonEnvTool } : {}
+    };
+  } else {
+    config.cpp = {};
+  }
+  if (selections.qtVersion || selections.qtPath) {
+    config.qt = {
+      ...selections.qtVersion ? { version: selections.qtVersion } : {},
+      ...selections.qtPath ? { path: selections.qtPath } : {}
+    };
+  }
+  return config;
+}
+function serializeConfig(config) {
+  return JSON.stringify(config, null, 2) + "\n";
+}
+
+// src/config.ts
+var FRAMEWORK_META = {
+  vanilla: { displayName: "Vanilla", devServerUrl: "http://localhost:5173", devServerPort: 5173, distDir: "../dist" },
+  "vanilla-ts": { displayName: "Vanilla (TypeScript)", devServerUrl: "http://localhost:5173", devServerPort: 5173, distDir: "../dist" },
+  react: { displayName: "React", devServerUrl: "http://localhost:5173", devServerPort: 5173, distDir: "../dist" },
+  "react-ts": { displayName: "React (TypeScript)", devServerUrl: "http://localhost:5173", devServerPort: 5173, distDir: "../dist" },
+  vue: { displayName: "Vue", devServerUrl: "http://localhost:5173", devServerPort: 5173, distDir: "../dist" },
+  "vue-ts": { displayName: "Vue (TypeScript)", devServerUrl: "http://localhost:5173", devServerPort: 5173, distDir: "../dist" },
+  svelte: { displayName: "Svelte", devServerUrl: "http://localhost:5173", devServerPort: 5173, distDir: "../dist" },
+  "svelte-ts": { displayName: "Svelte (TypeScript)", devServerUrl: "http://localhost:5173", devServerPort: 5173, distDir: "../dist" }
+};
+
+// src/generator.ts
+import { join, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readdirSync, statSync } from "fs";
+
+// src/template.ts
+import { readFileSync } from "fs";
+var VAR_RE = /\{\{(\w+)\}\}/g;
+var TemplateError = class extends Error {
+  constructor(variable, templateFile) {
+    const loc = templateFile ? ` in ${templateFile}` : "";
+    super(`Undefined template variable "{{${variable}}}"${loc}`);
+    this.variable = variable;
+    this.templateFile = templateFile;
+    this.name = "TemplateError";
+  }
+};
+function renderTemplate(content, context) {
+  return content.replace(VAR_RE, (_match, key) => {
+    if (!(key in context)) {
+      throw new TemplateError(key);
+    }
+    return String(context[key]);
+  });
+}
+function findUnresolvedVariables(content) {
+  const vars = [];
+  let m;
+  const re = new RegExp(VAR_RE.source, "g");
+  while ((m = re.exec(content)) !== null) {
+    vars.push(m[1]);
+  }
+  return vars;
+}
+
+// src/writer.ts
+import { mkdir, writeFile as fsWriteFile, copyFile as fsCopyFile, rm } from "fs/promises";
+import { dirname } from "path";
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function writeFile(path, content) {
+  try {
+    await ensureDir(dirname(path));
+    await fsWriteFile(path, content, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to write ${path}: ${msg}`);
+  }
+}
+async function copyFile(src, dest) {
+  try {
+    await ensureDir(dirname(dest));
+    await fsCopyFile(src, dest);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to copy ${src} \u2192 ${dest}: ${msg}`);
+  }
+}
+async function removeDir(dir) {
+  await rm(dir, { recursive: true, force: true });
+}
+
+// src/generator.ts
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+function templatesRoot() {
+  const fromDist = resolve3(__dirname, "..", "templates");
+  if (existsSync2(fromDist)) return fromDist;
+  const fromSrc = resolve3(__dirname, "..", "..", "templates");
+  if (existsSync2(fromSrc)) return fromSrc;
+  throw new Error("Templates directory not found");
+}
+function buildTemplateContext(config) {
+  const backendMap = { webview2: "webview2", cef: "cef", both: "auto" };
+  return {
+    projectName: config.projectName,
+    language: config.language,
+    backend: config.backend,
+    backendType: backendMap[config.backend],
+    frontendFramework: config.frontendFramework,
+    devServerUrl: config.devServerUrl,
+    devServerPort: config.devServerPort,
+    devPort: config.devServerPort,
+    distDir: config.distDir,
+    pythonEnvTool: config.pythonEnvTool ?? "",
+    buildSystem: config.buildSystem ?? "",
+    features: (config.features ?? []).join(","),
+    newWindowBehavior: config.newWindowBehavior ?? "block",
+    pythonVersion: config.pythonVersion ?? "",
+    pythonPath: config.pythonPath ?? "",
+    qtVersion: config.qtVersion ?? "",
+    qtPath: config.qtPath ?? ""
+  };
+}
+function listFiles(dir, base = dir) {
+  const results = [];
+  if (!existsSync2(dir)) return results;
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      results.push(...listFiles(full, base));
+    } else {
+      results.push(full.slice(base.length + 1).replace(/\\/g, "/"));
+    }
+  }
+  return results;
+}
+function resolveFileList(config) {
+  const root = templatesRoot();
+  const entries = [];
+  const baseDir = join(root, "base");
+  for (const rel of listFiles(baseDir)) {
+    const isTmpl = rel.endsWith(".tmpl");
+    const targetName = isTmpl ? rel.slice(0, -5) : rel;
+    const target = targetName === "gitignore" ? ".gitignore" : targetName;
+    entries.push({ targetPath: target, templatePath: join(baseDir, rel), isTemplate: isTmpl });
+  }
+  const configTmpl = join(root, "config", "qauri.config.json.tmpl");
+  if (existsSync2(configTmpl)) {
+    entries.push({ targetPath: "src-qauri/qauri.config.json", templatePath: configTmpl, isTemplate: true });
+  }
+  const nativeDir = join(root, "native", config.language);
+  for (const rel of listFiles(nativeDir)) {
+    const isTmpl = rel.endsWith(".tmpl");
+    const targetName = isTmpl ? rel.slice(0, -5) : rel;
+    entries.push({ targetPath: `src-qauri/${targetName}`, templatePath: join(nativeDir, rel), isTemplate: isTmpl });
+  }
+  const fwDir = join(root, "frontend", config.frontendFramework);
+  for (const rel of listFiles(fwDir)) {
+    const isTmpl = rel.endsWith(".tmpl");
+    const targetName = isTmpl ? rel.slice(0, -5) : rel;
+    entries.push({ targetPath: targetName, templatePath: join(fwDir, rel), isTemplate: isTmpl });
+  }
+  return entries;
+}
+async function generateProject(targetDir, config) {
+  const ctx = buildTemplateContext(config);
+  const files = resolveFileList(config);
+  const selections = {
+    projectName: config.projectName,
+    language: config.language,
+    pythonEnvTool: config.pythonEnvTool,
+    backend: config.backend,
+    frontendFramework: config.frontendFramework,
+    features: config.features ?? [],
+    newWindowBehavior: config.newWindowBehavior ?? "block",
+    installDeps: false,
+    pythonVersion: config.pythonVersion,
+    pythonPath: config.pythonPath,
+    qtVersion: config.qtVersion,
+    qtPath: config.qtPath,
+    devPort: config.devServerPort
+  };
+  const qauriConfig = buildConfig(selections);
+  const qauriConfigContent = serializeConfig(qauriConfig);
+  try {
+    await ensureDir(targetDir);
+    for (const entry of files) {
+      const dest = join(targetDir, entry.targetPath);
+      if (entry.targetPath === "src-qauri/qauri.config.json") {
+        await writeFile(dest, qauriConfigContent);
+        continue;
+      }
+      if (entry.isTemplate) {
+        const raw = readFileSync2(entry.templatePath, "utf-8");
+        const rendered = renderTemplate(raw, ctx);
+        const unresolved = findUnresolvedVariables(rendered);
+        if (unresolved.length > 0) {
+          throw new TemplateError(unresolved[0], entry.templatePath);
+        }
+        await writeFile(dest, rendered);
+      } else {
+        await copyFile(entry.templatePath, dest);
+      }
+    }
+  } catch (err) {
+    await removeDir(targetDir).catch(() => {
+    });
+    throw err;
+  }
+}
+
+// src/utils/npm.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+async function installDependencies(projectPath) {
+  if (!existsSync3(join2(projectPath, "package.json"))) {
+    throw new Error("package.json not found in project directory");
+  }
+  return new Promise((resolve5, reject) => {
+    const proc = spawn("npm", ["install"], {
+      cwd: projectPath,
+      stdio: "inherit",
+      shell: true
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve5();
+      } else {
+        reject(new Error(`npm install failed with code ${code}`));
+      }
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to start npm: ${err.message}`));
+    });
+  });
+}
+
+// src/utils/port.ts
+import net from "net";
+function isPortInUse(port) {
+  return new Promise((resolve5) => {
+    const socket = new net.Socket();
+    socket.setTimeout(1e3);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve5(true);
+    });
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve5(false);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve5(false);
+    });
+    socket.connect(port, "127.0.0.1");
+  });
+}
+async function isPortAvailable(port) {
+  if (port < 1 || port > 65535) {
+    return false;
+  }
+  const inUse = await isPortInUse(port);
+  if (inUse) {
+    return false;
+  }
+  return new Promise((resolve5) => {
+    const server = net.createServer();
+    server.once("error", () => {
+      resolve5(false);
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve5(true);
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+async function findAvailablePort(startPort = 5173, maxAttempts = 100) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (port > 65535) break;
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  return startPort;
+}
+
+// src/utils/environment.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
+var SUPPORTED_VERSIONS = {
+  python: ["3.11"],
+  qt: ["6.5.3", "6.9.2"]
+};
+function detectPython(version) {
+  const versionNum = version.replace(".", "");
+  const possiblePaths = [
+    `C:/Application/Python${versionNum}/python.exe`,
+    `C:/Python${versionNum}/python.exe`,
+    `C:/Program Files/Python${versionNum}/python.exe`,
+    `C:/Program Files (x86)/Python${versionNum}/python.exe`,
+    `${process.env.LOCALAPPDATA}/Programs/Python/Python${versionNum}/python.exe`,
+    `${process.env.USERPROFILE}/Python${versionNum}/python.exe`,
+    `${process.env.USERPROFILE}/AppData/Local/Programs/Python/Python${versionNum}/python.exe`,
+    `${process.env.USERPROFILE}/anaconda3/python.exe`,
+    `${process.env.USERPROFILE}/miniconda3/python.exe`,
+    `C:/ProgramData/anaconda3/python.exe`,
+    `C:/ProgramData/miniconda3/python.exe`
+  ];
+  for (const p2 of possiblePaths) {
+    if (p2 && existsSync4(p2)) {
+      try {
+        const output = execSync(`"${p2}" --version`, { encoding: "utf-8" });
+        if (output.includes(version)) {
+          return p2;
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const result = execSync("where python", { encoding: "utf-8" });
+    const paths = result.split("\n").map((l) => l.trim()).filter(Boolean);
+    for (const pythonPath of paths) {
+      if (existsSync4(pythonPath)) {
+        try {
+          const output = execSync(`"${pythonPath}" --version`, { encoding: "utf-8" });
+          if (output.includes(version)) {
+            return pythonPath;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function detectQt(version) {
+  const msvcSuffix = version.startsWith("6.9") ? "msvc2022_64" : "msvc2019_64";
+  const possiblePaths = [
+    `D:/Tools/Qt/${version}/${msvcSuffix}`,
+    `D:/Qt/${version}/${msvcSuffix}`,
+    `C:/Qt/${version}/${msvcSuffix}`,
+    `C:/Tools/Qt/${version}/${msvcSuffix}`,
+    `C:/Program Files/Qt/${version}/${msvcSuffix}`,
+    `${process.env.USERPROFILE}/Qt/${version}/${msvcSuffix}`,
+    `E:/Qt/${version}/${msvcSuffix}`,
+    `F:/Qt/${version}/${msvcSuffix}`
+  ];
+  for (const p2 of possiblePaths) {
+    if (p2 && existsSync4(join3(p2, "bin", "Qt6Core.dll"))) {
+      return p2;
+    }
+  }
+  if (process.env.QTDIR) {
+    const qtDir = process.env.QTDIR;
+    if (existsSync4(join3(qtDir, "bin", "Qt6Core.dll"))) {
+      return qtDir;
+    }
+  }
+  const qtRoots = [
+    "C:/Qt",
+    "D:/Qt",
+    "D:/Tools/Qt",
+    `${process.env.USERPROFILE}/Qt`
+  ];
+  for (const root of qtRoots) {
+    if (root && existsSync4(root)) {
+      const versionDir = join3(root, version, msvcSuffix);
+      if (existsSync4(join3(versionDir, "bin", "Qt6Core.dll"))) {
+        return versionDir;
+      }
+    }
+  }
+  return null;
+}
+function detectUv() {
+  try {
+    execSync("uv --version", { encoding: "utf-8", stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validatePythonPath(path) {
+  return /python\.exe$/i.test(path);
+}
+function validateQtPath(path) {
+  return existsSync4(path) && existsSync4(join3(path, "bin", "Qt6Core.dll"));
+}
+
+// src/commands/create.ts
+function selectionsToProjectConfig(selections) {
+  const meta = FRAMEWORK_META[selections.frontendFramework];
+  return {
+    projectName: selections.projectName,
+    language: selections.language,
+    backend: selections.backend,
+    frontendFramework: selections.frontendFramework,
+    pythonEnvTool: selections.pythonEnvTool,
+    buildSystem: "cmake",
+    devServerUrl: `http://localhost:${selections.devPort}`,
+    devServerPort: selections.devPort,
+    distDir: meta.distDir,
+    features: selections.features,
+    newWindowBehavior: selections.newWindowBehavior,
+    pythonVersion: selections.pythonVersion,
+    pythonPath: selections.pythonPath,
+    qtVersion: selections.qtVersion,
+    qtPath: selections.qtPath
+  };
+}
+async function createCommand(name) {
+  p.intro(pc.bgCyan(pc.black(" create-qauri-app ")));
+  const projectName2 = await p.text({
+    message: "What is your project name?",
+    placeholder: "my-qauri-app",
+    initialValue: name,
+    defaultValue: "my-qauri-app",
+    validate: (value) => {
+      const result = validateProjectName(value);
+      if (!result.valid) return result.message;
+      return void 0;
+    }
+  });
+  if (p.isCancel(projectName2)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const language = await p.select({
+    message: "Select native language.",
+    options: [
+      { value: "cpp", label: "C++", hint: "Pure C++ backend" },
+      { value: "python", label: "Python", hint: "Python backend with PySide6" }
+    ]
+  });
+  if (p.isCancel(language)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  let pythonEnvTool;
+  let pythonVersion = "3.11";
+  let pythonPath = "";
+  if (language === "python") {
+    const pmChoice = await p.select({
+      message: "Select Python package manager.",
+      options: [
+        { value: "pip", label: "pip", hint: "Standard package manager" },
+        { value: "uv", label: "uv", hint: "Fast package manager (recommended)" }
+      ]
+    });
+    if (p.isCancel(pmChoice)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    pythonEnvTool = pmChoice;
+    if (pmChoice === "uv" && !detectUv()) {
+      p.cancel(
+        "uv is not installed. Please install it first:\n  pip install uv\n  or visit: https://docs.astral.sh/uv/"
+      );
+      process.exit(1);
+    }
+    pythonVersion = await p.select({
+      message: "Select Python version.",
+      options: SUPPORTED_VERSIONS.python.map((v) => ({
+        value: v,
+        label: `Python ${v}`,
+        hint: v === "3.11" ? "recommended" : void 0
+      }))
+    });
+    if (p.isCancel(pythonVersion)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    pythonPath = detectPython(pythonVersion) || "";
+    if (pythonPath) {
+      p.log.info(`Python detected: ${pythonPath}`);
+    } else {
+      const manualPython = await p.text({
+        message: `Python ${pythonVersion} not found. Please enter the path to python.exe:`,
+        placeholder: "C:/Python311/python.exe",
+        validate: (value) => {
+          if (!value) return "Please enter a path.";
+          if (!validatePythonPath(value)) return "Path must end with python.exe";
+          if (!existsSync5(value)) return "File not found.";
+          return void 0;
+        }
+      });
+      if (p.isCancel(manualPython)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      pythonPath = manualPython;
+      p.log.info(`Using Python: ${pythonPath}`);
+    }
+  }
+  const qtVersion = await p.select({
+    message: "Select Qt version.",
+    options: SUPPORTED_VERSIONS.qt.map((v) => ({
+      value: v,
+      label: `Qt ${v}`,
+      hint: v === "6.5.3" ? "recommended" : void 0
+    }))
+  });
+  if (p.isCancel(qtVersion)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  let qtPath = detectQt(qtVersion);
+  if (qtPath) {
+    p.log.info(`Qt detected: ${qtPath}`);
+  } else {
+    const manualQt = await p.text({
+      message: `Qt ${qtVersion} not found. Please enter the Qt MSVC directory:`,
+      placeholder: "C:/Qt/6.5.3/msvc2019_64",
+      validate: (value) => {
+        if (!value) return "Please enter a path.";
+        if (!validateQtPath(value)) return "Qt6Core.dll not found in bin directory.";
+        return void 0;
+      }
+    });
+    if (p.isCancel(manualQt)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    qtPath = manualQt;
+    p.log.info(`Using Qt: ${qtPath}`);
+  }
+  const backend = await p.select({
+    message: "Select web backend.",
+    options: [
+      { value: "webview2", label: "WebView2", hint: "Windows native (recommended)" },
+      { value: "cef", label: "CEF", hint: "Chromium Embedded Framework" },
+      { value: "both", label: "Both", hint: "Dual backend support" }
+    ]
+  });
+  if (p.isCancel(backend)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const frameworkOptions = Object.entries(FRAMEWORK_META).map(([value, meta]) => ({ value, label: meta.displayName }));
+  const frontendFramework = await p.select({
+    message: "Select a frontend framework.",
+    options: frameworkOptions
+  });
+  if (p.isCancel(frontendFramework)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const features = await p.multiselect({
+    message: "Select features.",
+    options: [
+      { value: "devtools", label: "DevTools (F12)", hint: "recommended" },
+      { value: "reload", label: "Reload (F5)", hint: "recommended" },
+      { value: "whitelist", label: "Command Whitelist" },
+      { value: "examples", label: "Include Examples" }
+    ],
+    initialValues: ["devtools", "reload", "examples"],
+    required: false
+  });
+  if (p.isCancel(features)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const newWindowBehavior = await p.select({
+    message: "New window behavior?",
+    options: [
+      { value: "block", label: "Block", hint: "Prevent new windows" },
+      { value: "browser", label: "Browser", hint: "Open in default browser" },
+      { value: "new-window", label: "New Window", hint: "Create new Qauri window" }
+    ]
+  });
+  if (p.isCancel(newWindowBehavior)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const installDeps = await p.confirm({
+    message: "Install npm dependencies?",
+    initialValue: true
+  });
+  if (p.isCancel(installDeps)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const projectPath = resolve4(process.cwd(), projectName2);
+  if (existsSync5(projectPath)) {
+    const overwrite = await p.confirm({
+      message: `Directory "${projectName2}" already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p.isCancel(overwrite) || !overwrite) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    await removeDir(projectPath);
+  }
+  const s = p.spinner();
+  try {
+    s.start("Finding available port...");
+    const devPort = await findAvailablePort(5173);
+    s.stop(`Using port ${devPort}`);
+    s.start("Creating project structure...");
+    const selections = {
+      projectName: projectName2,
+      language,
+      pythonEnvTool,
+      backend,
+      frontendFramework,
+      features,
+      newWindowBehavior,
+      installDeps,
+      pythonVersion,
+      pythonPath,
+      qtVersion,
+      qtPath,
+      devPort
+    };
+    const config = selectionsToProjectConfig(selections);
+    await generateProject(projectPath, config);
+    s.stop("Project structure created");
+    if (installDeps) {
+      s.start("Installing npm dependencies...");
+      await installDependencies(projectPath);
+      s.stop("Dependencies installed");
+    }
+    let nextSteps = `cd ${projectName2}`;
+    if (!installDeps) {
+      nextSteps += "\nnpm install";
+    }
+    nextSteps += "\nqauri dev";
+    p.note(nextSteps, "Next steps");
+    p.outro(
+      pc.green("\u2713") + " Project created successfully!\n" + pc.dim('  Run "qauri dev" to start development')
+    );
+  } catch (error) {
+    s.stop("Failed");
+    p.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+Usage: create-qauri [project-name]
+
+Create a new Qauri project with interactive prompts.
+
+Arguments:
+  project-name    Optional project name (will prompt if not provided)
+
+Options:
+  -h, --help      Display this help message
+  -v, --version   Display version number
+
+Examples:
+  $ npm create qauri@latest
+  $ npm create qauri@latest my-app
+  $ pnpm create qauri
+  `);
+  process.exit(0);
+}
+if (args.includes("--version") || args.includes("-v")) {
+  console.log("0.2.0");
+  process.exit(0);
+}
+var projectName = args.find((arg) => !arg.startsWith("-"));
+await createCommand(projectName);
+//# sourceMappingURL=index.mjs.map