create-esmx 3.0.0-rc.45 → 3.0.0-rc.47

package/dist/utils/project-name.test.mjs

@@ -1,186 +1,332 @@
-import { basename } from "node:path";
 import { describe, expect, it } from "vitest";
 import { formatProjectName } from "./project-name.mjs";
+const isWindows = process.platform === "win32";
+const isUnix = !isWindows;
 describe("project-name utilities", () => {
   describe("formatProjectName", () => {
     it("should handle simple project name", () => {
       const input = "foo";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("foo");
-      expect(result.packageName).toBe("foo");
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\foo");
+      } else {
+        expect(result.root).toBe("/home/user/foo");
+      }
     });
     it("should handle nested path project name", () => {
-      const input = "foo/bar";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("foo/bar");
-      expect(result.packageName).toBe("bar");
+      const input = isWindows ? "foo\\bar" : "foo/bar";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("bar");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\foo\\bar");
+      } else {
+        expect(result.root).toBe("/home/user/foo/bar");
+      }
     });
     it("should handle scoped package name", () => {
       const input = "@scope/foo";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("@scope/foo");
-      expect(result.packageName).toBe("@scope/foo");
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("@scope/foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\@scope\\foo");
+      } else {
+        expect(result.root).toBe("/home/user/@scope/foo");
+      }
     });
     it("should handle relative path project name", () => {
-      const input = "./foo/bar";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("./foo/bar");
-      expect(result.packageName).toBe("bar");
+      const input = isWindows ? ".\\foo\\bar" : "./foo/bar";
+      const cwd = isWindows ? "C:\\workspace\\current" : "/home/user/current";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("bar");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\current\\foo\\bar");
+      } else {
+        expect(result.root).toBe("/home/user/current/foo/bar");
+      }
     });
     it("should handle absolute path project name", () => {
-      const input = "/root/path/to/foo";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("/root/path/to/foo");
-      expect(result.packageName).toBe("foo");
+      const input = isWindows ? "C:\\projects\\my-app" : "/root/path/to/foo";
+      const cwd = isWindows ? "D:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      if (isWindows) {
+        expect(result.name).toBe("my-app");
+        expect(result.root).toBe("C:\\projects\\my-app");
+      } else {
+        expect(result.name).toBe("foo");
+        expect(result.root).toBe("/root/path/to/foo");
+      }
     });
     it("should handle current directory", () => {
       const input = ".";
-      const expectedPackageName = basename(process.cwd());
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe(".");
-      expect(result.packageName).toBe(expectedPackageName);
+      const cwd = isWindows ? "C:\\Users\\Developer\\Projects\\WindowsApp" : "/home/user/projects/my-app";
+      const result = formatProjectName(input, cwd);
+      if (isWindows) {
+        expect(result.name).toBe("WindowsApp");
+        expect(result.root).toBe(
+          "C:\\Users\\Developer\\Projects\\WindowsApp"
+        );
+      } else {
+        expect(result.name).toBe("my-app");
+        expect(result.root).toBe("/home/user/projects/my-app");
+      }
     });
     it("should handle project name with trailing slashes", () => {
-      const input = "foo/bar///";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("foo/bar");
-      expect(result.packageName).toBe("bar");
+      const input = isWindows ? "foo\\" : "foo/";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\foo");
+      } else {
+        expect(result.root).toBe("/home/user/foo");
+      }
     });
     it("should handle project name with multiple trailing slashes", () => {
-      const input = "my-project/////";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("my-project");
-      expect(result.packageName).toBe("my-project");
+      const input = isWindows ? "foo\\\\\\" : "foo///";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\foo");
+      } else {
+        expect(result.root).toBe("/home/user/foo");
+      }
     });
     it("should handle deep nested path", () => {
-      const input = "projects/web/frontend/my-app";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("projects/web/frontend/my-app");
-      expect(result.packageName).toBe("my-app");
+      const input = isWindows ? "path\\to\\nested\\project" : "path/to/nested/project";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("project");
+      if (isWindows) {
+        expect(result.root).toBe(
+          "C:\\workspace\\path\\to\\nested\\project"
+        );
+      } else {
+        expect(result.root).toBe("/home/user/path/to/nested/project");
+      }
     });
     it("should handle scoped package with nested path", () => {
-      const input = "org/@scope/package-name";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("org/@scope/package-name");
-      expect(result.packageName).toBe("package-name");
+      const input = isWindows ? "@company\\ui\\library" : "@company/ui/library";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe(input);
+      if (isWindows) {
+        expect(result.root).toBe(
+          "C:\\workspace\\@company\\ui\\library"
+        );
+      } else {
+        expect(result.root).toBe("/home/user/@company/ui/library");
+      }
     });
     it("should handle scoped package starting with @", () => {
-      const input = "@company/ui-library";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("@company/ui-library");
-      expect(result.packageName).toBe("@company/ui-library");
+      const input = "@my-org/my-package";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("@my-org/my-package");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\@my-org\\my-package");
+      } else {
+        expect(result.root).toBe("/home/user/@my-org/my-package");
+      }
     });
     it("should handle empty path segment", () => {
-      const input = "foo//bar";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("foo//bar");
-      expect(result.packageName).toBe("bar");
+      const input = isWindows ? "path\\\\with\\\\segments" : "path//with//segments";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("segments");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\path\\with\\segments");
+      } else {
+        expect(result.root).toBe("/home/user/path/with/segments");
+      }
     });
     it("should handle single character project name", () => {
       const input = "a";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("a");
-      expect(result.packageName).toBe("a");
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("a");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\a");
+      } else {
+        expect(result.root).toBe("/home/user/a");
+      }
     });
     it("should handle project name with numbers and hyphens", () => {
-      const input = "my-project-v2";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("my-project-v2");
-      expect(result.packageName).toBe("my-project-v2");
+      const input = "my-project-123";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("my-project-123");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\my-project-123");
+      } else {
+        expect(result.root).toBe("/home/user/my-project-123");
+      }
     });
     it("should handle project name ending with slash", () => {
-      const input = "path/to/project/";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("path/to/project");
-      expect(result.packageName).toBe("project");
+      const input = isWindows ? "my-project\\" : "my-project/";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("my-project");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\my-project");
+      } else {
+        expect(result.root).toBe("/home/user/my-project");
+      }
     });
     it("should fall back to default name when path ends with slash and no name", () => {
       const input = "/";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("");
-      expect(result.packageName).toBe("esmx-project");
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.root).toBe("/");
+      expect(result.name).toBe("esmx-project");
     });
-    it("should handle Windows-style paths", () => {
-      const input = "C:\\projects\\my-app";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("C:\\projects\\my-app");
-      expect(result.packageName).toBe("C:\\projects\\my-app");
+    it.runIf(isWindows)(
+      "should handle Windows-style absolute paths",
+      () => {
+        const input = "C:\\projects\\my-app";
+        const cwd = "D:\\workspace";
+        const result = formatProjectName(input, cwd);
+        expect(result.name).toBe("my-app");
+        expect(result.root).toMatch(/projects[\\\/]my-app/);
+      }
+    );
+    it.runIf(isWindows)("should handle Windows UNC paths", () => {
+      const input = "\\\\server\\share\\project";
+      const cwd = "C:\\workspace";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("project");
+      expect(result.root).toMatch(/project$/);
     });
-    it("should handle mixed path separators", () => {
-      const input = "path\\to/project";
-      const result = formatProjectName(input);
-      expect(result.targetDir).toBe("path\\to/project");
-      expect(result.packageName).toBe("project");
+    it.runIf(isUnix)("should handle mixed path separators on Unix", () => {
+      const input = "path\\to/mixed/separators";
+      const cwd = "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("separators");
+      expect(result.root).toBe("/home/user/path\\to/mixed/separators");
     });
+    it.runIf(isWindows)(
+      "should handle Windows-style relative paths",
+      () => {
+        const input = "foo\\bar";
+        const cwd = "C:\\workspace";
+        const result = formatProjectName(input, cwd);
+        expect(result.name).toBe("bar");
+        expect(result.root).toMatch(/workspace[\\\/]foo[\\\/]bar/);
+      }
+    );
+    it.runIf(isWindows)(
+      "should handle Windows-style trailing backslashes",
+      () => {
+        const input = "foo\\bar\\\\\\";
+        const cwd = "C:\\workspace";
+        const result = formatProjectName(input, cwd);
+        expect(result.name).toBe("bar");
+        expect(result.root).toMatch(/workspace[\\\/]foo[\\\/]bar/);
+      }
+    );
   });
   describe("formatProjectName with cwd parameter", () => {
     it('should use custom cwd when input is "."', () => {
       const input = ".";
-      const customCwd = "/custom/working/directory";
+      const customCwd = isWindows ? "C:\\custom\\path\\to\\project" : "/custom/path/to/project";
       const result = formatProjectName(
         input,
         customCwd
       );
-      expect(result.targetDir).toBe(".");
-      expect(result.packageName).toBe("directory");
+      expect(result.name).toBe("project");
+      expect(result.root).toBe(customCwd);
     });
     it("should fallback to process.cwd() when cwd is not provided", () => {
-      const input = ".";
-      const expectedPackageName = basename(process.cwd());
+      const input = "test-project";
       const result = formatProjectName(input);
-      expect(result.targetDir).toBe(".");
-      expect(result.packageName).toBe(expectedPackageName);
+      expect(result.name).toBe("test-project");
+      expect(result.root).toMatch(/test-project$/);
     });
     it('should ignore cwd parameter when input is not "."', () => {
       const input = "my-project";
-      const customCwd = "/custom/working/directory";
+      const customCwd = isWindows ? "C:\\custom\\path" : "/custom/path";
       const result = formatProjectName(
         input,
         customCwd
       );
-      expect(result.targetDir).toBe("my-project");
-      expect(result.packageName).toBe("my-project");
+      expect(result.name).toBe("my-project");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\custom\\path\\my-project");
+      } else {
+        expect(result.root).toBe("/custom/path/my-project");
+      }
     });
     it("should handle scoped packages with custom cwd", () => {
-      const input = "@scope/package";
-      const customCwd = "/any/directory";
+      const input = "@scope/foo";
+      const customCwd = isWindows ? "C:\\custom\\workspace" : "/custom/workspace";
       const result = formatProjectName(
         input,
         customCwd
       );
-      expect(result.targetDir).toBe("@scope/package");
-      expect(result.packageName).toBe("@scope/package");
+      expect(result.name).toBe("@scope/foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\custom\\workspace\\@scope\\foo");
+      } else {
+        expect(result.root).toBe("/custom/workspace/@scope/foo");
+      }
     });
     it("should handle nested paths with custom cwd", () => {
-      const input = "org/team/project";
-      const customCwd = "/any/directory";
+      const input = isWindows ? "foo\\bar" : "foo/bar";
+      const customCwd = isWindows ? "C:\\custom\\workspace" : "/custom/workspace";
       const result = formatProjectName(
         input,
         customCwd
       );
-      expect(result.targetDir).toBe("org/team/project");
-      expect(result.packageName).toBe("project");
+      expect(result.name).toBe("bar");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\custom\\workspace\\foo\\bar");
+      } else {
+        expect(result.root).toBe("/custom/workspace/foo/bar");
+      }
     });
-    it("should handle Unix-style absolute paths in cwd", () => {
-      const input = ".";
-      const customCwd = "/home/user/projects/my-awesome-app";
-      const result = formatProjectName(
-        input,
-        customCwd
-      );
-      expect(result.targetDir).toBe(".");
-      expect(result.packageName).toBe("my-awesome-app");
-    });
-    it("should handle Windows-style absolute paths in cwd", () => {
-      const input = ".";
-      const customCwd = "C:\\Users\\Developer\\Projects\\WindowsApp";
+    it.runIf(isUnix)(
+      "should handle Unix-style absolute paths in cwd",
+      () => {
+        const input = "/root/path/to/foo";
+        const customCwd = "/this/should/be/ignored";
+        const result = formatProjectName(
+          input,
+          customCwd
+        );
+        expect(result.name).toBe("foo");
+        expect(result.root).toBe("/root/path/to/foo");
+      }
+    );
+    it.runIf(isWindows)(
+      "should handle Windows-style absolute paths in cwd",
+      () => {
+        const input = "C:\\projects\\my-app";
+        const customCwd = "D:\\this\\should\\be\\ignored";
+        const result = formatProjectName(
+          input,
+          customCwd
+        );
+        expect(result.name).toBe("my-app");
+        expect(result.root).toBe("C:\\projects\\my-app");
+      }
+    );
+    it("should handle absolute input paths and ignore cwd", () => {
+      const input = isWindows ? "C:\\projects\\absolute-project" : "/projects/absolute-project";
+      const customCwd = isWindows ? "D:\\ignored" : "/ignored";
       const result = formatProjectName(
         input,
         customCwd
       );
-      expect(result.targetDir).toBe(".");
-      const expectedPackageName = basename(customCwd);
-      expect(result.packageName).toBe(expectedPackageName);
+      expect(result.name).toBe("absolute-project");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\projects\\absolute-project");
+      } else {
+        expect(result.root).toBe("/projects/absolute-project");
+      }
     });
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-esmx",
-    "version": "3.0.0-rc.45",
+    "version": "3.0.0-rc.47",
     "description": "A scaffold tool for creating Esmx projects",
     "type": "module",
     "private": false,
@@ -14,7 +14,8 @@
         "test": "vitest run --pass-with-no-tests",
         "coverage": "vitest run --coverage --pass-with-no-tests",
         "lint:js": "biome check --write --no-errors-on-unmatched",
-        "build": "unbuild"
+        "build": "unbuild",
+        "postbuild": "node build/postbuild.mjs"
     },
     "dependencies": {
         "@clack/prompts": "^0.7.0",
@@ -23,7 +24,7 @@
     },
     "devDependencies": {
         "@biomejs/biome": "1.9.4",
-        "@esmx/lint": "3.0.0-rc.45",
+        "@esmx/lint": "3.0.0-rc.47",
         "@types/minimist": "^1.2.5",
         "@types/node": "^24.0.0",
         "@vitest/coverage-v8": "3.2.4",
@@ -68,5 +69,5 @@
         "url": "https://github.com/esmnext/esmx/issues"
     },
     "homepage": "https://github.com/esmnext/esmx#readme",
-    "gitHead": "c1e2c9bf24c9321b06e63a08e8bfc4953c834aef"
+    "gitHead": "3e55424b9029d259537a802032f3a1f54b6fb1e8"
 }

package/src/cli.integration.test.ts

@@ -133,7 +133,7 @@ describe('create-esmx CLI integration tests', () => {
         const projectPath = join(tmpDir, 'test-project');
 
         await cli({
-            argv: ['test-project', '--template', 'vue2'],
+            argv: ['test-project', '--template', 'vue2-csr'],
             cwd: tmpDir,
             userAgent: 'npm/test'
         });
@@ -141,7 +141,7 @@ describe('create-esmx CLI integration tests', () => {
         expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
 
         await cli({
-            argv: ['test-project', '--template', 'vue2', '--force'],
+            argv: ['test-project', '--template', 'vue2-csr', '--force'],
             cwd: tmpDir,
             userAgent: 'npm/test'
         });
@@ -202,7 +202,11 @@ describe('create-esmx CLI integration tests', () => {
         const projectPath = join(tmpDir, 'non-existent-parent', 'test-project');
 
         await cli({
-            argv: ['non-existent-parent/test-project', '--template', 'vue2'],
+            argv: [
+                'non-existent-parent/test-project',
+                '--template',
+                'vue2-csr'
+            ],
             cwd: tmpDir,
             userAgent: 'npm/test'
         });
@@ -222,7 +226,7 @@ describe('create-esmx CLI integration tests', () => {
         );
 
         await cli({
-            argv: ['test-project', '--template', 'vue2', '--force'],
+            argv: ['test-project', '--template', 'vue2-csr', '--force'],
             cwd: tmpDir,
             userAgent: 'npm/test'
         });
@@ -236,7 +240,7 @@ describe('create-esmx CLI integration tests', () => {
         await writeFile(testFile, 'existing content');
 
         await cli({
-            argv: ['.', '--template', 'vue2', '--force'],
+            argv: ['.', '--template', 'vue2-csr', '--force'],
             cwd: tmpDir,
             userAgent: 'npm/test'
         });
@@ -248,7 +252,7 @@ describe('create-esmx CLI integration tests', () => {
 
     it('should create project in current directory when target is "."', async () => {
         await cli({
-            argv: ['.', '--template', 'vue2'],
+            argv: ['.', '--template', 'vue2-csr'],
             cwd: tmpDir,
             userAgent: 'npm/test'
         });
@@ -269,7 +273,7 @@ describe('create-esmx CLI integration tests', () => {
             const projectPath = join(tmpDir, projectName);
 
             await cli({
-                argv: [projectName, '--template', 'vue2'],
+                argv: [projectName, '--template', 'vue2-csr'],
                 cwd: tmpDir,
                 userAgent: 'npm/test'
             });

package/src/cli.ts

@@ -28,7 +28,7 @@ ${color.bold('Usage:')}
   ${createCmd} [project-name] [options]
 
 ${color.bold('Options:')}
-  -t, --template <template>    Template to use (default: vue2)
+  -t, --template <template>    Template to use (default: vue2-csr)
   -n, --name <name>            Project name or path
   -f, --force                  Force overwrite existing directory
   -h, --help                   Show help information
@@ -36,9 +36,9 @@ ${color.bold('Options:')}
 
 ${color.bold('Examples:')}
   ${createCmd} my-project
-  ${createCmd} my-project -t vue2
+  ${createCmd} my-project -t vue2-csr
   ${createCmd} my-project --force
-  ${createCmd} . -f -t vue2
+  ${createCmd} . -f -t vue2-csr
 
 ${color.bold('Available Templates:')}
 ${getAvailableTemplates()
@@ -80,7 +80,7 @@ async function getProjectName(
 /**
  * Get template type from arguments or prompt user
  */
-async function getTemplateType(argTemplate?: string): Promise<string | symbol> {
+async function getTemplateType(argTemplate?: string): Promise<string> {
     const availableTemplates = getAvailableTemplates();
 
     if (
@@ -101,14 +101,14 @@ async function getTemplateType(argTemplate?: string): Promise<string | symbol> {
         options: options
     });
 
-    return template as string | symbol;
+    return String(template);
 }
 
 /**
  * Main function to create a project
  */
 export async function cli(options: CliOptions = {}): Promise<void> {
-    const { argv, cwd, userAgent } = options;
+    const { argv, cwd, userAgent, version } = options;
     const commandLineArgs = argv || process.argv.slice(2);
     const workingDir = cwd || process.cwd();
 
@@ -150,10 +150,7 @@ export async function cli(options: CliOptions = {}): Promise<void> {
         return;
     }
 
-    const { packageName, targetDir } = formatProjectName(
-        projectNameInput,
-        workingDir
-    );
+    const { name, root } = formatProjectName(projectNameInput, workingDir);
 
     const templateType = await getTemplateType(parsedArgs.template);
     if (isCancel(templateType)) {
@@ -169,13 +166,13 @@ export async function cli(options: CliOptions = {}): Promise<void> {
     const lintTypeCommand = getCommand('lint:type', userAgent);
 
     await createProjectFromTemplate(
-        targetDir,
+        root,
         templateType,
         workingDir,
         parsedArgs.force,
         {
-            projectName: packageName,
-            esmxVersion: getEsmxVersion(),
+            projectName: name,
+            esmxVersion: version || getEsmxVersion(),
             installCommand,
             devCommand,
             buildCommand,
@@ -187,12 +184,19 @@ export async function cli(options: CliOptions = {}): Promise<void> {
     const installCmd = installCommand;
     const devCmd = devCommand;
 
-    const nextSteps = [
-        color.reset(`1. ${color.cyan(`cd ${targetDir}`)}`),
-        color.reset(`2. ${color.cyan(installCmd)}`),
-        color.reset(`3. ${color.cyan('git init')} ${color.gray('(optional)')}`),
-        color.reset(`4. ${color.cyan(devCmd)}`)
-    ];
+    const targetDirForDisplay =
+        projectNameInput === '.' ? '.' : projectNameInput;
+
+    const steps = [
+        projectNameInput !== '.' ? `cd ${targetDirForDisplay}` : null,
+        installCmd,
+        `git init ${color.gray('(optional)')}`,
+        devCmd
+    ].filter(Boolean);
+
+    const nextSteps = steps.map((step, index) => {
+        return color.reset(`${index + 1}. ${color.cyan(step)}`);
+    });
 
     note(nextSteps.join('\n'), 'Next steps');
 

package/src/index.ts

@@ -1 +1,3 @@
 export { cli } from './cli';
+export { getAvailableTemplates } from './template';
+export type { TemplateInfo } from './types';