@postxl/cli 1.5.0 → 1.6.0

package/dist/create-project.command.js

@@ -60,31 +60,36 @@ function register(program) {
         .summary('Creates a new PostXL project.')
         .description(`Creates a new PostXL project.
 
+Usage: pxl create-project [name] [options]
+
+When run interactively (TTY), prompts for any missing values.
+When piped, all required values must be provided via arguments/options.
+
 Installation flow:
-  1. Prompts for project name, slug, path, and schema (if not provided via options)
-  2. Writes initial project files (schema, generate.ts, tsconfig, package.json, .env)
+  1. Writes initial project files (schema, generate.ts, tsconfig, package.json, .env)
      Uses the simple schema for the first pass even if a custom schema is provided
-  3. Runs pnpm install to fetch initial dependencies
-  4. Runs first code generation without formatting (as prettier/eslint not yet installed)
-  5. Runs pnpm install again to fetch devDependencies added by the generated package.json
-  6. Swaps in the custom schema (if provided) before the final generation
-  7. Runs second code generation with full formatting (prettier, eslint)
+  2. Runs pnpm install to fetch initial dependencies
+  3. Runs first code generation without formatting (as prettier/eslint not yet installed)
+  4. Runs pnpm install again to fetch devDependencies added by the generated package.json
+  5. Swaps in the custom schema (if provided) before the final generation
+  6. Runs second code generation with full formatting (prettier, eslint)
+  7. Generates TanStack Router route tree
   8. Generates Prisma client
   9. Initializes a git repository (unless --skip-git)
 
 If --skip-generate is used with a custom schema, the custom schema is written directly.`)
-        .option('-n, --name <name>', 'Project name')
-        .option('-s, --slug <slug>', 'Project slug')
-        .option('-p, --project-path <path>', 'Path where the generated project should be written. If not specified, user will be prompted')
+        .argument('[name]', 'Project name')
+        .option('-s, --slug <slug>', 'Project slug (defaults to slugified project name)')
+        .option('-p, --project-path <path>', 'Path where the generated project should be written (defaults to ../<slug>)')
         .option('-S, --schema <path>', 'Path to an existing postxl-schema.json to use instead of the default simple schema')
-        .option('--skip-git', 'Skip initialing a git repository in the generated project directory')
+        .option('--skip-git', 'Skip initializing a git repository in the generated project directory')
         .option('--skip-generate', 'Skip running the initial project generation')
         .option('-l, --link-postxl', 'Link project to local PostXL monorepo packages (for development purposes)')
-        .action(async (options) => {
+        .action(async (nameArg, options) => {
         try {
             await checkNodeVersion();
             const link = options.linkPostxl === true;
-            const name = await getProjectName(options.name);
+            const name = await getProjectName(nameArg);
             const slug = await getProjectSlug(options.slug, name);
             const customSchema = await loadCustomSchema(options.schema);
             const schema = customSchema ?? getProjectSchema();
@@ -98,7 +103,6 @@ If --skip-generate is used with a custom schema, the custom schema is written di
                 schema: initialSchema,
                 projectPath,
             });
-            // In case it is a workspace project, we install dependencies in the workspace part - else in the project
             await installDependencies({ targetPath: projectPath, link });
             if (!options.skipGenerate) {
                 // We initially only install the PostXL generator - without prettier, eslint and eslint rules. Hence, we run the first generation
@@ -113,16 +117,21 @@ If --skip-generate is used with a custom schema, the custom schema is written di
                 }
                 // The second generation runs with transformations - setting up prettier, eslint, etc.
                 await runGenerate({ projectPath, transform: true });
+                await generateTanStackRouter(projectPath);
                 await generatePrismaClient(projectPath);
-                if (!options.skipInitGit) {
-                    await initializeGitRepository(projectPath);
-                }
             }
             else if (customSchema) {
                 // With --skip-generate, createProjectStructure already wrote the custom schema,
                 // but we still need to apply name/slug/projectType overrides.
                 await writeSchema({ name, slug, schema: customSchema, projectPath });
             }
+            if (!options.skipGit) {
+                await initializeGitRepository(projectPath);
+            }
+            else {
+                // Safety net: remove .git if a subprocess created it despite --skip-git
+                await removeGitDirectory(projectPath);
+            }
             console.log(`\n✓ Project "${name}" created successfully at ${projectPath}`);
             console.log('\nNext steps:');
             console.log(`  cd ${path.relative(process.cwd(), projectPath)}`);
@@ -136,14 +145,32 @@ If --skip-generate is used with a custom schema, the custom schema is written di
         }
     });
 }
+function isInteractive() {
+    return process.stdin.isTTY === true;
+}
+async function prompt(question, defaultValue) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        const promptText = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+        rl.question(promptText, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
 async function getProjectName(providedName) {
     if (providedName) {
         return providedName;
     }
+    if (!isInteractive()) {
+        throw new Error('Project name is required. Usage: pxl create-project <name>');
+    }
     const projectName = await prompt('Project name');
     if (!projectName) {
-        console.error('Project name is required!');
-        process.exit(1);
+        throw new Error('Project name is required!');
     }
     return projectName;
 }
@@ -152,10 +179,12 @@ async function getProjectSlug(providedSlug, projectName) {
         return providedSlug;
     }
     const suggestedSlug = (0, utils_1.slugify)(projectName);
+    if (!isInteractive()) {
+        return suggestedSlug;
+    }
     const projectSlug = await prompt('Project slug', suggestedSlug);
     if (!projectSlug) {
-        console.error('Project slug is required!');
-        process.exit(1);
+        throw new Error('Project slug is required!');
     }
     return projectSlug;
 }
@@ -173,25 +202,21 @@ async function loadCustomSchema(providedPath) {
     }
     catch (error) {
         if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
-            console.error(`Schema file not found: ${resolvedPath}`);
+            throw new Error(`Schema file not found: ${resolvedPath}`);
         }
-        else {
-            console.error(`Failed to read schema file: ${error instanceof Error ? error.message : error}`);
-        }
-        process.exit(1);
+        throw new Error(`Failed to read schema file: ${error instanceof Error ? error.message : error}`);
     }
     let json;
     try {
         json = JSON.parse(content);
     }
     catch {
-        console.error(`Schema file is not valid JSON: ${resolvedPath}`);
-        process.exit(1);
+        throw new Error(`Schema file is not valid JSON: ${resolvedPath}`);
     }
     const result = schema_1.zProjectSchema.safeParse(json);
     if (!result.success) {
         (0, log_schema_error_1.logSchemaValidationError)(result.error);
-        process.exit(1);
+        throw new Error('Schema validation failed');
     }
     return json;
 }
@@ -205,21 +230,16 @@ async function writeSchema({ name, slug, schema, projectPath, }) {
     await fs.writeFile(path.join(projectPath, 'postxl-schema.json'), JSON.stringify(updatedSchema, null, 2) + '\n');
 }
 /**
- * If projectPath is not provided:
- *   - Prompt user for path if it should be standalone (in ../{slug}) or workspace (in ./projects/{slug}). Default is standalone.
- * With projectPath:
- *   - if it is local within projects, throw error as we do not support workspace project anymore.
- *   - if it is outside of the cwd (regardless of local or absolute), check if exists. if so, throw error, if not create and return-
+ * Resolves the project output path. Defaults to `../{slug}` (standalone).
+ * Prompts interactively if no path is given and stdin is a TTY.
+ * Rejects paths inside `./projects/` (workspace projects are no longer supported).
+ * Creates the directory if it doesn't exist; throws if it exists and is non-empty.
  */
 async function resolveProjectPath({ slug, projectPath, }) {
     const repositoryRoot = process.cwd();
     const defaultStandalonePath = path.resolve(repositoryRoot, '..', slug);
     if (!projectPath) {
-        projectPath = await prompt('Project path', defaultStandalonePath);
-    }
-    if (!projectPath) {
-        console.error('Project path is required!');
-        process.exit(1);
+        projectPath = isInteractive() ? await prompt('Project path', defaultStandalonePath) : defaultStandalonePath;
     }
     const projectGenerationPath = path.isAbsolute(projectPath) ? projectPath : path.resolve(repositoryRoot, projectPath);
     const projectsFolder = path.join(repositoryRoot, 'projects');
@@ -240,25 +260,24 @@ async function createFolderOrThrow(targetPath) {
             await fs.mkdir(targetPath, { recursive: true });
             return;
         }
-        console.error(`Cannot access target path "${targetPath}": ${error instanceof Error ? error.message : error}`);
-        process.exit(1);
+        throw new Error(`Cannot access target path "${targetPath}": ${error instanceof Error ? error.message : error}`);
     }
     if (!stat.isDirectory()) {
-        console.error(`Target path "${targetPath}" already exists and is not a directory! Please choose a different path.`);
-        process.exit(1);
+        throw new Error(`Target path "${targetPath}" already exists and is not a directory! Please choose a different path.`);
     }
     try {
         const entries = await fs.readdir(targetPath);
         if (entries.length > 0) {
             const hasOnlyHidden = entries.every((entry) => entry.startsWith('.'));
             const hint = hasOnlyHidden ? ' (it contains hidden files/folders)' : '';
-            console.error(`Target path "${targetPath}" already exists and is not empty${hint}! Please choose a different path.`);
-            process.exit(1);
+            throw new Error(`Target path "${targetPath}" already exists and is not empty${hint}! Please choose a different path.`);
         }
     }
     catch (error) {
-        console.error(`Cannot read target path "${targetPath}": ${error instanceof Error ? error.message : error}`);
-        process.exit(1);
+        if (error instanceof Error && error.message.includes('already exists')) {
+            throw error;
+        }
+        throw new Error(`Cannot read target path "${targetPath}": ${error instanceof Error ? error.message : error}`);
     }
 }
 async function createProjectStructure({ name, slug, schema, projectPath, }) {
@@ -380,6 +399,18 @@ async function runGenerate({ projectPath, transform, }) {
         console.log('You can manually run "pnpm run generate" in the project directory.');
     }
 }
+async function generateTanStackRouter(targetPath) {
+    const frontendPath = path.join(targetPath, 'frontend');
+    console.log('\nGenerating TanStack Router route tree...');
+    try {
+        await run('pnpm exec tsr generate', { cwd: frontendPath });
+        console.log('TanStack Router route tree generated successfully!');
+    }
+    catch (error) {
+        console.error('Failed to generate TanStack Router route tree:', error);
+        console.log('You can manually run "pnpm exec tsr generate" in the frontend directory.');
+    }
+}
 async function generatePrismaClient(targetPath) {
     console.log('\nGenerating Prisma client...');
     try {
@@ -402,8 +433,15 @@ async function initializeGitRepository(targetPath) {
     }
 }
 /**
- * Throws if Node.js version is less than what package.json devEngines.runtime requires
+ * Removes a .git directory if it exists. This handles the case where
+ * a subprocess (e.g., pnpm install, code generation) inadvertently
+ * created a .git directory even though --skip-git was requested.
+ * fs.rm with force:true already ignores ENOENT (missing path).
  */
+async function removeGitDirectory(targetPath) {
+    const gitDir = path.join(targetPath, '.git');
+    await fs.rm(gitDir, { recursive: true, force: true });
+}
 async function checkNodeVersion() {
     try {
         const repositoryRoot = process.cwd();
@@ -433,17 +471,3 @@ async function checkNodeVersion() {
         throw error;
     }
 }
-// Helper to prompt user for input
-async function prompt(question, defaultValue) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        const promptText = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
-        rl.question(promptText, (answer) => {
-            rl.close();
-            resolve(answer.trim() || defaultValue || '');
-        });
-    });
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/cli",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Command-line interface for PostXL code generation framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -45,7 +45,7 @@
     "dotenv": "17.3.1",
     "zod-validation-error": "5.0.0",
     "@postxl/generator": "^1.3.7",
-    "@postxl/generators": "^1.23.0",
+    "@postxl/generators": "^1.23.1",
     "@postxl/schema": "^1.8.2",
     "@postxl/utils": "^1.4.0"
   },