@doswiftly/cli 0.1.1

package/dist/commands/init.js

@@ -0,0 +1,1028 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import ora from "ora";
+import { existsSync, writeFileSync, mkdirSync, readFileSync, readdirSync, statSync, } from "fs";
+import { join, dirname, basename } from "path";
+import { fileURLToPath } from "url";
+import { execSync, execFileSync } from "child_process";
+import { detectPackageManager, getPackageManagerInfo, installDependencies, } from "../lib/package-manager.js";
+import { getStoredToken } from "./auth.js";
+import { hasProfiles, addProfile } from "../lib/env-storage.js";
+import { getApiUrl } from "../lib/api-url.js";
+import { WizardEngine, selectWithBack, isBack, isCancel, next, back, cancel, clearScreen, } from "../lib/wizard-engine.js";
+import { t, initI18n } from "../lib/i18n.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Initialize i18n
+initI18n();
+// ============================================================================
+// API Functions
+// ============================================================================
+/**
+ * Fetch user's teams from CLI API
+ */
+async function fetchTeams(apiUrl, token) {
+    try {
+        const response = await fetch(`${apiUrl}/cli/teams`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = (await response.json());
+        return data.teams || [];
+    }
+    catch (error) {
+        p.log.warn(t().failedFetchTeams(error.message));
+        return [];
+    }
+}
+/**
+ * Fetch user's projects from CLI API
+ */
+async function fetchProjects(apiUrl, token) {
+    try {
+        const response = await fetch(`${apiUrl}/cli/projects`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = (await response.json());
+        return data.projects || [];
+    }
+    catch (error) {
+        p.log.warn(t().failedFetchProjects(error.message));
+        return [];
+    }
+}
+/**
+ * Fetch templates from the remote registry API.
+ */
+async function fetchRemoteTemplates(apiUrl, token) {
+    try {
+        const response = await fetch(`${apiUrl}/cli/templates`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = (await response.json());
+        return data.filter((tpl) => tpl.status === "PUBLISHED");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Download a remote template using degit.
+ */
+async function downloadTemplate(repoUrl, targetDir) {
+    // Validate the repo URL to prevent path traversal and restrict to trusted hosts
+    const allowedHosts = ['github.com', 'gitlab.com', 'bitbucket.org'];
+    try {
+        const parsed = new URL(repoUrl.startsWith('http') ? repoUrl : `https://github.com/${repoUrl}`);
+        if (!allowedHosts.includes(parsed.hostname)) {
+            throw new Error(`Untrusted repository host: ${parsed.hostname}. Allowed: ${allowedHosts.join(', ')}`);
+        }
+        if (parsed.pathname.includes('..')) {
+            throw new Error('Path traversal detected in repository URL');
+        }
+    }
+    catch (e) {
+        if (e instanceof Error && (e.message.includes('Untrusted') || e.message.includes('traversal')))
+            throw e;
+        // degit supports shorthand like "user/repo" — validate format
+        if (!/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+(?:#[a-zA-Z0-9_.-]+)?$/.test(repoUrl)) {
+            throw new Error(`Invalid repository URL format: ${repoUrl}`);
+        }
+    }
+    const { default: degit } = await import("degit");
+    const emitter = degit(repoUrl, { cache: false, force: true });
+    await emitter.clone(targetDir);
+}
+// ============================================================================
+// Template Utilities
+// ============================================================================
+/**
+ * Apply placeholder replacements to all files in a directory.
+ */
+function applyReplacementsToDirectory(dir, replacements) {
+    const textExtensions = new Set([
+        ".ts",
+        ".tsx",
+        ".js",
+        ".jsx",
+        ".json",
+        ".yaml",
+        ".yml",
+        ".md",
+        ".mdx",
+        ".html",
+        ".css",
+        ".env",
+        ".env.example",
+        ".env.local",
+        ".toml",
+        ".cfg",
+    ]);
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            if (entry === "node_modules" || entry === ".git")
+                continue;
+            applyReplacementsToDirectory(fullPath, replacements);
+        }
+        else {
+            const ext = entry.includes(".") ? "." + entry.split(".").pop() : "";
+            const isTextFile = textExtensions.has(ext) || entry.startsWith(".env");
+            if (!isTextFile)
+                continue;
+            try {
+                let content = readFileSync(fullPath, "utf-8");
+                let changed = false;
+                for (const [placeholder, value] of Object.entries(replacements)) {
+                    const regex = new RegExp(placeholder, "g");
+                    const newContent = content.replace(regex, value);
+                    if (newContent !== content) {
+                        content = newContent;
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    writeFileSync(fullPath, content);
+                }
+            }
+            catch {
+                // Skip binary files or files that can't be read as text
+            }
+        }
+    }
+}
+/**
+ * Recursively copy directory with placeholder replacement.
+ */
+function copyTemplateDir(src, dest, replacements) {
+    mkdirSync(dest, { recursive: true });
+    const entries = readdirSync(src);
+    for (const entry of entries) {
+        const srcPath = join(src, entry);
+        const destPath = join(dest, entry);
+        const stat = statSync(srcPath);
+        if (stat.isDirectory()) {
+            copyTemplateDir(srcPath, destPath, replacements);
+        }
+        else {
+            let content = readFileSync(srcPath, "utf-8");
+            for (const [placeholder, value] of Object.entries(replacements)) {
+                content = content.replace(new RegExp(placeholder, "g"), value);
+            }
+            writeFileSync(destPath, content);
+        }
+    }
+}
+/**
+ * Initialize a git repository in the scaffolded project.
+ */
+async function initGitRepository(projectPath, templateName) {
+    try {
+        // Check if git is available
+        try {
+            execSync("git --version", { stdio: "pipe" });
+        }
+        catch {
+            return;
+        }
+        // Skip if already in a git repo
+        try {
+            execSync("git rev-parse --git-dir", { stdio: "pipe", cwd: projectPath });
+            return;
+        }
+        catch {
+            // Not in a git repo - proceed
+        }
+        execFileSync("git", ["init"], { stdio: "pipe", cwd: projectPath });
+        execFileSync("git", ["add", "-A"], { stdio: "pipe", cwd: projectPath });
+        execFileSync("git", ["commit", "-m", `chore: scaffold ${templateName} with DoSwiftly CLI`], {
+            stdio: "pipe",
+            cwd: projectPath,
+        });
+        p.log.info(pc.dim("Git repository initialized with initial commit."));
+    }
+    catch {
+        // Non-fatal
+    }
+}
+// ============================================================================
+// File Creation Utilities
+// ============================================================================
+/**
+ * Create .env.local file
+ */
+function createEnvLocal(targetDir, shopSlug, apiUrl, projectName) {
+    const envContent = [
+        "# Generated by DoSwiftly CLI",
+        `# Project: ${projectName}`,
+        "",
+        `NEXT_PUBLIC_API_URL=${apiUrl}`,
+        `NEXT_PUBLIC_SHOP_SLUG=${shopSlug}`,
+        "",
+        "# Site Configuration",
+        "NEXT_PUBLIC_SITE_URL=http://localhost:3000",
+        `NEXT_PUBLIC_SITE_NAME=${projectName}`,
+        "",
+    ].join("\n");
+    writeFileSync(join(targetDir, ".env.local"), envContent);
+}
+/**
+ * Create doswiftly.config.ts file
+ */
+function createDoswiftlyConfig(targetDir, shopSlug, apiUrl, projectName) {
+    const configContent = [
+        "// Storefront configuration",
+        "// This file is used by both CLI and runtime code",
+        "",
+        "export interface DoswiftlyConfig {",
+        "  shop: {",
+        "    slug: string;",
+        "  };",
+        "  project: {",
+        "    name: string;",
+        "  };",
+        "  api: {",
+        "    url: string;",
+        "  };",
+        "  dev?: {",
+        "    port?: number;",
+        "    openBrowser?: boolean;",
+        "  };",
+        "}",
+        "",
+        "const config: DoswiftlyConfig = {",
+        "  shop: {",
+        `    slug: '${shopSlug}',`,
+        "  },",
+        "  project: {",
+        `    name: '${projectName}',`,
+        "  },",
+        "  api: {",
+        `    url: '${apiUrl}',`,
+        "  },",
+        "  dev: {",
+        "    port: 3000,",
+        "    openBrowser: true,",
+        "  },",
+        "};",
+        "",
+        "export default config;",
+        "",
+    ].join("\n");
+    writeFileSync(join(targetDir, "doswiftly.config.ts"), configContent);
+}
+// ============================================================================
+// Wizard Steps
+// ============================================================================
+/**
+ * Step 1: Target directory selection
+ */
+const stepDirectory = {
+    id: "directory",
+    title: () => t().targetDirectory,
+    stateKeys: ["targetDir", "projectName"],
+    canGoBack: false, // First step, can't go back
+    async execute(state, ctx) {
+        // Use a loop to handle validation errors without losing context
+        while (true) {
+            const choice = await p.select({
+                message: t().targetDirectory,
+                options: [
+                    {
+                        value: "current",
+                        label: t().currentDirectory(basename(process.cwd())),
+                    },
+                    { value: "new", label: t().newDirectory },
+                ],
+            });
+            if (p.isCancel(choice))
+                return cancel();
+            if (choice === "current") {
+                const cwd = process.cwd();
+                const projectName = basename(cwd);
+                // Validate: directory should be empty or contain only hidden files
+                const entries = readdirSync(cwd).filter((e) => !e.startsWith("."));
+                if (entries.length > 0) {
+                    // Clear screen and show error with option to retry
+                    clearScreen();
+                    p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+                    const current = ctx.stepIndex + 1;
+                    const total = ctx.totalSteps;
+                    const filled = pc.green('●'.repeat(current));
+                    const empty = pc.dim('○'.repeat(total - current));
+                    p.log.step(pc.cyan(`${t().stepOf(current, total)}: ${t().targetDirectory}`));
+                    p.log.message(`${filled}${empty}`, { symbol: '' });
+                    p.log.error(t().directoryNotEmpty);
+                    p.log.info(pc.dim(t().chooseNewDirectory));
+                    const retry = await p.confirm({
+                        message: t().tryAgain,
+                        initialValue: true,
+                    });
+                    if (p.isCancel(retry))
+                        return cancel();
+                    if (!retry)
+                        return cancel();
+                    // Clear screen and redraw for retry
+                    clearScreen();
+                    p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+                    p.log.step(pc.cyan(`${t().stepOf(current, total)}: ${t().targetDirectory}`));
+                    p.log.message(`${filled}${empty}`, { symbol: '' });
+                    continue; // Loop back to selection
+                }
+                // Check if already initialized
+                if (existsSync(join(cwd, "doswiftly.config.ts")) ||
+                    existsSync(join(cwd, "doswiftly.config.js"))) {
+                    // Clear screen and show error
+                    clearScreen();
+                    p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+                    const current = ctx.stepIndex + 1;
+                    const total = ctx.totalSteps;
+                    const filled = pc.green('●'.repeat(current));
+                    const empty = pc.dim('○'.repeat(total - current));
+                    p.log.step(pc.cyan(`${t().stepOf(current, total)}: ${t().targetDirectory}`));
+                    p.log.message(`${filled}${empty}`, { symbol: '' });
+                    p.log.error(t().alreadyInitialized);
+                    p.log.info(pc.dim(t().useDeploy));
+                    const retry = await p.confirm({
+                        message: t().tryAgain,
+                        initialValue: true,
+                    });
+                    if (p.isCancel(retry))
+                        return cancel();
+                    if (!retry)
+                        return cancel();
+                    // Clear screen and redraw for retry
+                    clearScreen();
+                    p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+                    p.log.step(pc.cyan(`${t().stepOf(current, total)}: ${t().targetDirectory}`));
+                    p.log.message(`${filled}${empty}`, { symbol: '' });
+                    continue; // Loop back to selection
+                }
+                return next({ targetDir: cwd, projectName });
+            }
+            // "new" was selected, break out of loop
+            break;
+        }
+        // New directory flow
+        const projectName = await p.text({
+            message: t().directoryName,
+            validate: (v) => {
+                if (!v)
+                    return t().nameRequired;
+                if (!/^[a-z0-9-]+$/.test(v))
+                    return t().invalidName;
+                if (existsSync(join(process.cwd(), v)))
+                    return t().directoryExists;
+                return undefined;
+            },
+        });
+        if (p.isCancel(projectName))
+            return cancel();
+        return next({
+            targetDir: join(process.cwd(), projectName),
+            projectName: projectName,
+        });
+    },
+};
+/**
+ * Step 2: Team selection
+ */
+const stepTeam = {
+    id: "team",
+    title: () => t().selectTeam,
+    stateKeys: ["team"],
+    canGoBack: true,
+    async execute(state, ctx) {
+        const teams = state.__teams;
+        // Single team: ask for confirmation instead of auto-selecting
+        if (teams.length === 1) {
+            const proceed = await p.confirm({
+                message: t().useTeam(teams[0].name),
+                initialValue: true,
+            });
+            if (p.isCancel(proceed))
+                return cancel();
+            if (!proceed)
+                return back();
+            return next({ team: teams[0] });
+        }
+        // Multiple teams: show select with back navigation
+        const teamId = await selectWithBack({
+            message: t().selectTeam,
+            options: teams.map((team) => ({
+                value: team.id,
+                label: team.name,
+                hint: t().teamProjects(team.projectCount),
+            })),
+            canGoBack: ctx.canGoBack,
+        });
+        if (isCancel(teamId))
+            return cancel();
+        if (isBack(teamId))
+            return back();
+        const selectedTeam = teams.find((team) => team.id === teamId);
+        return next({ team: selectedTeam });
+    },
+};
+/**
+ * Step 3: Project selection
+ */
+const stepProject = {
+    id: "project",
+    title: () => t().selectProject,
+    stateKeys: ["project", "shopSlug"],
+    canGoBack: true,
+    async execute(state, ctx) {
+        const teamProjects = state.__projects.filter((p) => p.teamId === state.team.id);
+        if (teamProjects.length === 0) {
+            // Clear screen and redraw header for consistent UI
+            clearScreen();
+            p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+            // Show progress
+            const current = ctx.stepIndex + 1;
+            const total = ctx.totalSteps;
+            const filled = pc.green('●'.repeat(current));
+            const empty = pc.dim('○'.repeat(total - current));
+            p.log.step(pc.cyan(`${t().stepOf(current, total)}: ${t().selectProject}`));
+            p.log.message(`${filled}${empty}`, { symbol: '' });
+            p.log.error(t().noProjects);
+            p.log.info(pc.cyan(t().createProjectHint));
+            // Allow going back to select different team
+            const goBack = await p.confirm({
+                message: t().goBackToTeam,
+                initialValue: true,
+            });
+            if (p.isCancel(goBack))
+                return cancel();
+            if (goBack)
+                return back();
+            // User chose not to go back
+            return cancel();
+        }
+        const projectId = await selectWithBack({
+            message: t().selectProject,
+            options: teamProjects.map((proj) => ({
+                value: proj.id,
+                label: proj.name,
+                hint: proj.hasShop ? t().shopLabel(proj.shop.slug) : t().noShop,
+            })),
+            canGoBack: ctx.canGoBack,
+        });
+        if (isCancel(projectId))
+            return cancel();
+        if (isBack(projectId))
+            return back();
+        const selectedProject = teamProjects.find((p) => p.id === projectId);
+        // Validate shop exists
+        if (!selectedProject?.hasShop || !selectedProject.shop) {
+            // Clear screen and redraw header for consistent UI
+            clearScreen();
+            p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+            // Show progress
+            const current = ctx.stepIndex + 1;
+            const total = ctx.totalSteps;
+            const filled = pc.green('●'.repeat(current));
+            const empty = pc.dim('○'.repeat(total - current));
+            p.log.step(pc.cyan(`${t().stepOf(current, total)}: ${t().selectProject}`));
+            p.log.message(`${filled}${empty}`, { symbol: '' });
+            p.log.error(t().projectNoShop);
+            p.log.info(pc.cyan(t().createShopHint(selectedProject.id)));
+            // Allow going back instead of exiting
+            const retry = await p.confirm({
+                message: t().selectAnother,
+                initialValue: true,
+            });
+            if (p.isCancel(retry))
+                return cancel();
+            if (retry)
+                return back();
+            // User chose not to retry
+            return cancel();
+        }
+        return next({
+            project: selectedProject,
+            shopSlug: selectedProject.shop.slug,
+        });
+    },
+};
+/**
+ * Step 4: Code source selection
+ *
+ * This step handles both the source type selection AND template selection
+ * in a single wizard step. Uses internal loop for proper back navigation:
+ * - Back from template list → returns to "Empty/Template" prompt (same step)
+ * - Back from "Empty/Template" → returns to previous wizard step (Project)
+ */
+const stepCodeSource = {
+    id: "codeSource",
+    title: () => t().codeSource,
+    stateKeys: ["codeSource"],
+    canGoBack: true,
+    async execute(state, ctx) {
+        // Loop to handle internal back navigation within this step
+        while (true) {
+            // First prompt: choose source type
+            const choice = await selectWithBack({
+                message: t().codeSource,
+                options: [
+                    { value: "empty", label: t().emptyProject },
+                    { value: "template", label: t().templateRegistry },
+                ],
+                canGoBack: ctx.canGoBack,
+            });
+            if (isCancel(choice))
+                return cancel();
+            if (isBack(choice))
+                return back(); // Goes to previous wizard step (Project)
+            if (choice === "empty") {
+                return next({ codeSource: { type: "empty" } });
+            }
+            // User chose template - fetch and show template list
+            const spinner = ora(t().fetchingTemplates).start();
+            const templates = await fetchRemoteTemplates(state.__apiUrl, state.__token);
+            spinner.stop();
+            if (!templates || templates.length === 0) {
+                p.log.warn(t().noTemplates);
+                return next({ codeSource: { type: "empty" } });
+            }
+            // Clear screen for clean template selection UI
+            clearScreen();
+            p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+            // Show progress - template path adds +1 step (5/6 instead of 4/5)
+            const templateCurrent = ctx.stepIndex + 2; // 5
+            const templateTotal = ctx.totalSteps + 1; // 6
+            const filledTemplate = pc.green('●'.repeat(templateCurrent));
+            const emptyTemplate = pc.dim('○'.repeat(templateTotal - templateCurrent));
+            p.log.step(pc.cyan(`${t().stepOf(templateCurrent, templateTotal)}: ${t().selectTemplate}`));
+            p.log.message(`${filledTemplate}${emptyTemplate}`, { symbol: '' });
+            // Second prompt: select specific template
+            const templateId = await selectWithBack({
+                message: t().selectTemplate,
+                options: templates.map((tpl) => ({
+                    value: tpl.id,
+                    label: `${tpl.name}${tpl.uiLibrary ? ` (${tpl.uiLibrary})` : ""}`,
+                    hint: tpl.description || undefined,
+                })),
+                canGoBack: true,
+            });
+            if (isCancel(templateId))
+                return cancel();
+            if (isBack(templateId)) {
+                // Back from template list → loop back to first prompt (Empty/Template)
+                // Clear screen and redraw the step header before looping
+                // Show 4/5 (default total) since user hasn't chosen path yet
+                const backCurrent = ctx.stepIndex + 1; // 4
+                const backTotal = ctx.totalSteps; // 5 (base)
+                const filledBack = pc.green('●'.repeat(backCurrent));
+                const emptyBack = pc.dim('○'.repeat(backTotal - backCurrent));
+                clearScreen();
+                p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+                p.log.step(pc.cyan(`${t().stepOf(backCurrent, backTotal)}: ${t().codeSource}`));
+                p.log.message(`${filledBack}${emptyBack}`, { symbol: '' });
+                continue; // Go back to start of loop (first prompt)
+            }
+            const selectedTemplate = templates.find((tpl) => tpl.id === templateId);
+            if (!selectedTemplate?.repoUrl) {
+                p.log.warn(t().templateNoRepo);
+                return next({ codeSource: { type: "empty" } });
+            }
+            return next({
+                codeSource: {
+                    type: "template",
+                    templateRepoUrl: selectedTemplate.repoUrl,
+                    templateName: selectedTemplate.name,
+                },
+            });
+        }
+    },
+};
+/**
+ * Step 5 (or 6 for template path): Confirmation and dependencies
+ */
+const stepConfirm = {
+    id: "confirm",
+    title: () => t().summary,
+    stateKeys: ["shouldInstall"],
+    canGoBack: true,
+    // Dynamic progress: 5/5 for empty path, 6/6 for template path
+    getProgress(state, defaultProgress) {
+        if (state.codeSource?.type === "template") {
+            return {
+                current: defaultProgress.current + 1, // 6
+                total: defaultProgress.total + 1, // 6
+            };
+        }
+        return defaultProgress; // 5/5 for empty
+    },
+    async execute(state, ctx) {
+        // Display summary with consistent alignment
+        const templateName = state.codeSource.type === "empty"
+            ? "Minimal"
+            : state.codeSource.templateName || "Template";
+        const summaryLines = [
+            `  ${pc.dim("Directory:")} ${state.targetDir}`,
+            `  ${pc.dim("Team:")}      ${state.team.name}`,
+            `  ${pc.dim("Project:")}   ${state.project.name}`,
+            `  ${pc.dim("Shop:")}      ${state.shopSlug}`,
+            `  ${pc.dim("Template:")}  ${templateName}`,
+        ];
+        console.log(); // Empty line before summary
+        console.log(pc.bold(t().summary + ":"));
+        summaryLines.forEach(line => console.log(line));
+        console.log(); // Empty line after summary
+        const confirmChoice = await selectWithBack({
+            message: t().continue,
+            options: [
+                { value: "yes", label: t().yes },
+                { value: "no", label: t().cancel },
+            ],
+            canGoBack: ctx.canGoBack,
+        });
+        if (isCancel(confirmChoice))
+            return cancel();
+        if (isBack(confirmChoice))
+            return back();
+        if (confirmChoice === "no") {
+            p.cancel(t().cancelled);
+            process.exit(0);
+        }
+        // Ask about installing dependencies
+        const installChoice = await p.select({
+            message: t().installDeps,
+            options: [
+                { value: "yes", label: t().yesInstall(state.__pmInfo.name) },
+                { value: "no", label: t().noInstallLater },
+            ],
+        });
+        if (p.isCancel(installChoice))
+            return cancel();
+        return next({ shouldInstall: installChoice === "yes" });
+    },
+};
+// ============================================================================
+// Template Creation Flow (for SaaS developers)
+// ============================================================================
+/**
+ * Create a new template project for the registry (SaaS developer flow).
+ */
+async function initTemplateProject(options) {
+    p.intro(pc.bgCyan(pc.black(" DoSwiftly CLI - Create Template ")));
+    const { getAuthStateSilent } = await import("./auth.js");
+    const { isSaasDeveloper } = getAuthStateSilent();
+    if (!isSaasDeveloper) {
+        p.log.warn("Warning: You don't appear to be a SaaS developer.");
+        p.log.info(pc.dim("Template creation works locally, but you'll need the SaaS developer role to register."));
+    }
+    // Template name
+    const templateName = options.name ||
+        (await p.text({
+            message: "Template name:",
+            validate: (v) => {
+                if (!v)
+                    return "Name is required";
+                if (!/^[a-z0-9-]+$/.test(v))
+                    return "Use lowercase letters, numbers, and hyphens only";
+                if (v.length < 3)
+                    return "At least 3 characters";
+                return undefined;
+            },
+        }));
+    if (p.isCancel(templateName)) {
+        p.cancel(t().cancelled);
+        process.exit(0);
+    }
+    // Template description
+    const description = await p.text({
+        message: "Template description (optional):",
+        placeholder: `DoSwiftly storefront template: ${templateName}`,
+    });
+    if (p.isCancel(description)) {
+        p.cancel(t().cancelled);
+        process.exit(0);
+    }
+    // Base template selection
+    const baseTemplate = await p.select({
+        message: "Base template to start from:",
+        options: [
+            {
+                value: "storefront-nextjs-shadcn",
+                label: "shadcn/ui (Recommended)",
+                hint: "Next.js + shadcn/ui + Tailwind CSS",
+            },
+            {
+                value: "storefront-minimal",
+                label: "Minimal (Next.js only)",
+                hint: "Minimal Next.js starter",
+            },
+        ],
+    });
+    if (p.isCancel(baseTemplate)) {
+        p.cancel(t().cancelled);
+        process.exit(0);
+    }
+    // UI Library label
+    const uiLibraryMap = {
+        "storefront-nextjs-shadcn": "shadcn/ui",
+        "storefront-minimal": "none",
+    };
+    const uiLibrary = uiLibraryMap[baseTemplate] || "none";
+    // Create directory
+    const targetDir = templateName;
+    if (existsSync(targetDir)) {
+        p.log.error(`Directory "${targetDir}" already exists.`);
+        process.exit(1);
+    }
+    const spinner = ora("Creating template project...").start();
+    try {
+        const templateDir = join(__dirname, "..", "..", "templates", baseTemplate);
+        if (!existsSync(templateDir)) {
+            throw new Error(`Base template not found: ${baseTemplate}`);
+        }
+        // Copy template files (with generic placeholders)
+        const replacements = {
+            "\\{\\{PROJECT_NAME\\}\\}": templateName,
+            "\\{\\{SHOP_SLUG\\}\\}": "{{SHOP_SLUG}}",
+            "\\{\\{API_URL\\}\\}": "{{API_URL}}",
+            "\\{\\{SDK_VERSION\\}\\}": "^1.0.0",
+            "\\{\\{COMMERCE_SDK_VERSION\\}\\}": "^1.0.0",
+            "\\{\\{STOREFRONT_OPS_VERSION\\}\\}": "^1.0.0",
+        };
+        copyTemplateDir(templateDir, targetDir, replacements);
+        // Create doswiftly-template.json manifest
+        const manifest = {
+            name: templateName,
+            description: description || `DoSwiftly storefront template: ${templateName}`,
+            uiLibrary,
+            features: [],
+            version: "0.1.0",
+        };
+        writeFileSync(join(targetDir, "doswiftly-template.json"), JSON.stringify(manifest, null, 2) + "\n");
+        // Initialize git
+        spinner.text = "Initializing git repository...";
+        try {
+            execSync("git init", { stdio: "pipe", cwd: targetDir });
+            execSync("git add -A", { stdio: "pipe", cwd: targetDir });
+            execSync(`git commit -m "chore: initialize ${templateName} template"`, {
+                stdio: "pipe",
+                cwd: targetDir,
+            });
+        }
+        catch {
+            // Non-fatal
+        }
+        spinner.succeed(pc.green("Template project created!"));
+        p.outro(pc.green("Success!"));
+        p.log.info(pc.dim(`Created template project in: ${pc.cyan(targetDir)}/`));
+        p.log.message("");
+        p.log.message(pc.bold("Next steps:"));
+        p.log.message(pc.cyan(`  cd ${templateName}`));
+        p.log.message(pc.dim("  # Customize the template to your needs"));
+        p.log.message(pc.cyan("  git remote add origin <your-github-repo-url>"));
+        p.log.message(pc.cyan("  git push -u origin main"));
+        p.log.message(pc.cyan("  doswiftly template register"));
+        p.log.message("");
+    }
+    catch (error) {
+        spinner.fail(pc.red("Failed to create template project"));
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Project Creation
+// ============================================================================
+/**
+ * Execute project creation after wizard completes
+ */
+async function createProject(state) {
+    const { targetDir, projectName, shopSlug, codeSource, shouldInstall, __apiUrl: apiUrl, __pmInfo: pmInfo, } = state;
+    // Clear screen for clean project creation output
+    clearScreen();
+    p.intro(pc.bgCyan(pc.black(` ${t().wizardTitle} `)));
+    const createSpinner = ora(t().creatingProject).start();
+    try {
+        // Create target directory if it doesn't exist
+        if (!existsSync(targetDir)) {
+            mkdirSync(targetDir, { recursive: true });
+        }
+        // Define placeholder replacements
+        const replacements = {
+            "\\{\\{PROJECT_NAME\\}\\}": projectName,
+            "\\{\\{SHOP_SLUG\\}\\}": shopSlug,
+            "\\{\\{API_URL\\}\\}": apiUrl,
+            "\\{\\{SDK_VERSION\\}\\}": "^1.0.0",
+            "\\{\\{COMMERCE_SDK_VERSION\\}\\}": "^1.0.0",
+            "\\{\\{STOREFRONT_OPS_VERSION\\}\\}": "^1.0.0",
+        };
+        let templateName = "storefront-minimal";
+        if (codeSource.type === "template" && codeSource.templateRepoUrl) {
+            // Download remote template
+            createSpinner.text = t().downloadingTemplate;
+            await downloadTemplate(codeSource.templateRepoUrl, targetDir);
+            createSpinner.text = t().configuringProject;
+            applyReplacementsToDirectory(targetDir, replacements);
+            templateName = codeSource.templateName || "remote-template";
+        }
+        else {
+            // Copy minimal template
+            createSpinner.text = t().copyingTemplate;
+            const minimalTemplate = join(__dirname, "..", "..", "templates", "storefront-minimal");
+            if (!existsSync(minimalTemplate)) {
+                throw new Error("Minimal template not found. Please reinstall @doswiftly/cli.");
+            }
+            copyTemplateDir(minimalTemplate, targetDir, replacements);
+        }
+        // Create .env.local
+        createSpinner.text = t().creatingEnvLocal;
+        createEnvLocal(targetDir, shopSlug, apiUrl, projectName);
+        // Create doswiftly.config.ts
+        createSpinner.text = t().creatingConfig;
+        createDoswiftlyConfig(targetDir, shopSlug, apiUrl, projectName);
+        // Create .doswiftly directory for cache
+        mkdirSync(join(targetDir, ".doswiftly"), { recursive: true });
+        writeFileSync(join(targetDir, ".doswiftly", ".gitignore"), "*\n");
+        // Create .gitignore if it doesn't exist (npm strips .gitignore from packages)
+        const gitignorePath = join(targetDir, ".gitignore");
+        if (!existsSync(gitignorePath)) {
+            const gitignoreContent = `# Dependencies
+node_modules/
+.pnpm-store/
+
+# Next.js
+.next/
+out/
+
+# Build
+dist/
+build/
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# Debug logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# DoSwiftly cache
+.doswiftly/
+
+# TypeScript
+*.tsbuildinfo
+
+# Testing
+coverage/
+`;
+            writeFileSync(gitignorePath, gitignoreContent);
+        }
+        // Auto-create a default profile if none exists
+        if (!hasProfiles()) {
+            try {
+                addProfile({
+                    name: "default",
+                    apiUrl: apiUrl,
+                    description: `Auto-created by doswiftly init for ${projectName}`,
+                });
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        createSpinner.succeed(t().projectCreated);
+        // Install dependencies if requested
+        if (shouldInstall) {
+            const installSpinner = ora(t().installingDeps).start();
+            try {
+                await installDependencies(pmInfo.name, [], {
+                    stdio: "pipe",
+                    cwd: targetDir,
+                });
+                installSpinner.succeed(t().depsInstalled);
+            }
+            catch (installError) {
+                installSpinner.fail(t().installFailed);
+                const errorMessage = installError instanceof Error
+                    ? installError.message
+                    : String(installError);
+                if (errorMessage) {
+                    p.log.info(pc.dim(errorMessage.split("\n")[0]));
+                }
+                p.log.warn(t().runManually(projectName, pmInfo.name));
+            }
+        }
+        // Initialize git repository
+        await initGitRepository(targetDir, templateName);
+        // Success message
+        p.log.message("");
+        p.log.success(pc.green(t().projectReady));
+        p.log.message("");
+        p.log.message(pc.dim(t().nextSteps));
+        if (targetDir !== process.cwd()) {
+            p.log.message(pc.cyan(`  cd ${projectName}`));
+        }
+        if (!shouldInstall) {
+            p.log.message(pc.cyan(`  ${pmInfo.name} install`));
+        }
+        p.log.message(pc.cyan("  doswiftly dev"));
+        p.log.message("");
+        p.log.message(pc.dim(t().documentation));
+        p.log.message("");
+    }
+    catch (error) {
+        createSpinner.fail(pc.red(t().failedCreateProject));
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Main Init Command
+// ============================================================================
+export async function initCommand(options = {}) {
+    // Branch to template creation flow if --create-template is specified
+    if (options.createTemplate) {
+        return initTemplateProject(options);
+    }
+    // Check authentication first
+    const token = getStoredToken();
+    if (!token) {
+        p.intro(pc.bgRed(pc.white(" Error ")));
+        p.log.error(t().notLoggedIn);
+        p.log.info(pc.cyan(t().runAuthLogin));
+        process.exit(1);
+    }
+    const apiUrl = getApiUrl();
+    // Fetch data upfront
+    const spinner = ora(t().fetchingData).start();
+    const teams = await fetchTeams(apiUrl, token);
+    const projects = await fetchProjects(apiUrl, token);
+    spinner.stop();
+    // Check teams exist
+    if (teams.length === 0) {
+        p.intro(pc.bgRed(pc.white(" Error ")));
+        p.log.error(t().noTeams);
+        p.log.info(pc.cyan(t().createTeamHint));
+        process.exit(1);
+    }
+    // Detect package manager
+    const pmInfo = options.pm
+        ? await getPackageManagerInfo(options.pm)
+        : await detectPackageManager();
+    // Define wizard steps
+    const steps = [
+        stepDirectory,
+        stepTeam,
+        stepProject,
+        stepCodeSource,
+        stepConfirm,
+    ];
+    // Initial state with internal data
+    const initialState = {
+        __teams: teams,
+        __projects: projects,
+        __apiUrl: apiUrl,
+        __token: token,
+        __pmInfo: pmInfo,
+    };
+    // Run wizard
+    const engine = new WizardEngine(steps, initialState, {
+        title: t().wizardTitle,
+        cancelMessage: t().cancelled,
+    });
+    const result = await engine.run();
+    if (!result) {
+        // Wizard was cancelled
+        process.exit(0);
+    }
+    // Execute project creation with final state
+    await createProject(result);
+}
+//# sourceMappingURL=init.js.map