@postxl/cli 0.0.9

package/LICENSE

@@ -0,0 +1,50 @@
+PostXL Non-Commercial License
+
+Copyright (c) 2025 PostXL GmbH
+
+NON-COMMERCIAL USE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, and distribute the Software for non-commercial purposes only,
+subject to the following conditions:
+
+1. The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+2. The Software may not be used for commercial purposes without obtaining a
+   commercial license from PostXL GmbH.
+
+DEFINITION OF NON-COMMERCIAL USE
+
+"Non-commercial use" means personal, educational, research, or evaluation use
+where the primary purpose is not to generate revenue or commercial advantage.
+
+Non-commercial use includes:
+
+- Personal projects and learning
+- Academic research and education
+- Open source projects that are not commercially monetized
+- Evaluation and testing of the Software
+
+COMMERCIAL USE
+
+For commercial use of this Software, including but not limited to:
+
+- Use in products or services sold or licensed to third parties
+- Use in internal business operations that generate revenue
+- Use by for-profit organizations in production environments
+
+You must obtain a commercial license from PostXL GmbH.
+
+Contact: licensing@postxl.com
+
+DISCLAIMER
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# PXL CLI
+
+Small command line tool that helps with the development of PXL projects.
+
+Currently, the CLI provides the following commands:
+
+- `pxl generate`: Generate code for a PXL project
+- `pxl create-project` (alias: `pxl new`): Create a new PostXL project
+
+## `pxl generate`
+
+The `pxl generate` command generates code for a PXL project.
+
+### Usage
+
+In the project root, ensure that a `project-schema.json` and a `generate.ts` file exist. See the [template project](../../projects/template) for an example.
+
+```bash
+cd /projects/my-project
+pxl generate <project-name>
+```
+
+See `pxl generate --help` for more information.
+
+## `pxl create-project` / `pxl new`
+
+The `pxl create-project` command creates a new PostXL project with a selected schema template. It scaffolds the project structure, installs dependencies, runs the initial code generation, and generates the Prisma client.
+
+### Usage
+
+Run the command from the PostXL repository root:
+
+```bash
+pxl create-project
+# or
+pxl new
+```
+
+The CLI will interactively prompt you for:
+
+1. **Project name**: The display name for your project
+2. **Project slug**: A URL-friendly identifier (auto-suggested from the name)
+3. **Schema template**: Choose from available starter schemas (la, mca, ring, simple, subex, uspmsm)
+4. **Project location**: Either a standalone project (outside the workspace) or a workspace project (in the `projects/` folder)
+
+### Options
+
+| Option                      | Description                                                   |
+| --------------------------- | ------------------------------------------------------------- |
+| `-n, --name <name>`         | Project name (skip interactive prompt)                        |
+| `-s, --slug <slug>`         | Project slug (skip interactive prompt)                        |
+| `--schema <schema>`         | Schema template to use (la, mca, ring, simple, subex, uspmsm) |
+| `-p, --project-path <path>` | Custom path for the generated project                         |
+| `--skip-git`                | Skip initializing a git repository                            |
+| `--skip-generate`           | Skip running the initial project generation                   |
+
+### Examples
+
+```bash
+# Interactive mode
+pxl new
+
+# Non-interactive with all options
+pxl new --name "My App" --slug my-app --schema simple
+
+# Create at a specific path
+pxl new --name "My App" -p /path/to/my-app
+```
+
+See `pxl create-project --help` for more information.

package/dist/create-project/create-project.generator.d.ts

@@ -0,0 +1,17 @@
+import { ProjectSchemaName, ProjectSlug } from '@postxl/schema';
+import { ProjectPath } from '../create-project.command';
+export type CreateProjectOptions = {
+    name: ProjectSchemaName;
+    slug: ProjectSlug;
+    schema: object & {
+        projectType?: {
+            kind: string;
+        };
+    };
+    projectPath: ProjectPath;
+};
+/**
+ * Creates a new PostXL project with the specified options.
+ * This function is used by the create-project CLI command.
+ */
+export declare function createProject(options: CreateProjectOptions): Promise<void>;

package/dist/create-project/create-project.generator.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProject = createProject;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const Generator = __importStar(require("@postxl/generator"));
+const generator_1 = require("@postxl/generator");
+const baseDevDependencies = [
+    { packageName: Generator.toPostXlPackageName('@postxl/generator') },
+    { packageName: Generator.toPostXlPackageName('@postxl/generators') },
+    { packageName: Generator.toPostXlPackageName('@postxl/schema') },
+    { packageName: '@typescript-eslint/eslint-plugin', version: '8.46.3' },
+    { packageName: '@typescript-eslint/parser', version: '8.46.3' },
+    { packageName: 'commander', version: '12.1.0' },
+];
+const workspaceDevDependencies = [
+    { packageName: '@prisma/client', version: '6.19.0' },
+    { packageName: 'chokidar-cli', version: '3.0.0' },
+    { packageName: 'eslint', version: '9.39.1' },
+    { packageName: 'eslint-plugin-simple-import-sort', version: '12.1.1' },
+    { packageName: 'jest', version: '29.7.0' },
+    { packageName: 'prettier', version: '3.4.2' },
+    { packageName: 'prisma', version: '6.19.0' },
+    { packageName: 'rimraf', version: '6.1.0' },
+];
+const baseScripts = [
+    { name: 'prettier:check', command: 'prettier --check "**/*.{ts,tsx}" --config ../../prettier.config.js' },
+    { name: 'pxl', command: 'node ../../packages/cli/dist/index.js' },
+];
+const getWorkspaceScripts = (slug) => [
+    { name: 'docker', command: './scripts/docker.sh' },
+    { name: 'generate', command: 'pnpm run generate:project && pnpm run generate:prisma' },
+    { name: 'generate:prisma', command: 'prisma generate' },
+    { name: 'generate:project', command: 'pnpm run generate:project:pxl && pnpm run generate:project:tsr' },
+    { name: 'generate:project:pxl', command: 'node ../../packages/cli/dist/index.js generate' },
+    { name: 'generate:project:tsr', command: `pnpm --filter @postxl/${slug}-frontend exec tsr generate` },
+    {
+        name: 'generate:watch',
+        command: "chokidar '../../packages/**/dist/**' '../../generators/**/dist/**' '../../generators/**/template/**' './generate.ts' './postxl-schema.json' -c 'pnpm run generate:project:pxl -f -i && pnpm run generate:project:tsr'",
+    },
+    { name: 'setup', command: './scripts/setup.sh' },
+];
+// TODO: Adjust this for standalone projects once full standalone generation is implemented!
+const standaloneScripts = [
+    { name: 'generate', command: 'node ../../packages/cli/dist/index.js generate' },
+];
+const tsConfig = {
+    compilerOptions: {
+        forceConsistentCasingInFileNames: true,
+        esModuleInterop: true,
+        incremental: true,
+        isolatedModules: true,
+        resolveJsonModule: true,
+        skipLibCheck: true,
+        strict: true,
+    },
+    exclude: ['node_modules'],
+};
+const generators = [
+    'backendActionsGenerator',
+    'backendAuthenticationGenerator',
+    'backendDataManagementGenerator',
+    'backendE2eGenerator',
+    'backendGenerator',
+    'backendImportGenerator',
+    'backendModuleXlPortGenerator',
+    'backendRepositoriesGenerator',
+    'backendRestApiGenerator',
+    'backendS3Generator',
+    'backendSeedGenerator',
+    'backendTrpcRouterGenerator',
+    'backendUpdateGenerator',
+    'backendViewGenerator',
+    'baseGenerator',
+    {
+        imports: 'configureDevopsGenerator',
+        code: 'configureDevopsGenerator({ useDatabase: true, keycloakComponents: [], useBitbucket: true, useS3: true })',
+    },
+    'databasePrismaGenerator',
+    'decodersGenerator',
+    'e2eGenerator',
+    'frontendAdminGenerator',
+    { imports: 'Frontend', code: 'Frontend.configureFrontendGenerator(Frontend.all)' },
+    'frontendFormsGenerator',
+    'frontendTablesGenerator',
+    'frontendTrpcClientGenerator',
+    'mockDataGenerator',
+    'seedDataGenerator',
+    'typesGenerator',
+];
+/**
+ * Creates a new PostXL project with the specified options.
+ * This function is used by the create-project CLI command.
+ */
+async function createProject(options) {
+    const { projectPath, name, slug, schema } = options;
+    const targetPath = projectPath.kind === 'standalone' ? projectPath.workspaceProjectPath : projectPath.projectGenerationPath;
+    // Create target directory if it doesn't exist
+    await fs.mkdir(targetPath, { recursive: true });
+    // Update schema with new name and slug
+    // Use the source field which contains the original JSON input
+    const updatedSchema = {
+        ...schema,
+        name,
+        slug,
+        projectType: {
+            kind: projectPath.kind,
+            projectDirectory: projectPath.projectGenerationPath,
+        },
+    };
+    // Write source files directly to disk (not tracked as generated files)
+    // These are the files that define the project, not generated output
+    await fs.writeFile(path.join(targetPath, 'postxl-schema.json'), JSON.stringify(updatedSchema, null, 2) + '\n');
+    await fs.writeFile(path.join(targetPath, 'generate.ts'), await (0, generator_1.format)({ path: 'generate.ts', content: generateGenerateTs() }));
+    await fs.writeFile(path.join(targetPath, 'tsconfig.json'), await (0, generator_1.format)({ path: 'tsconfig.json', content: generateTsConfig() }));
+    // Generate package.json using the helper
+    const packageJsonConfig = {
+        name: Generator.toPostXlPackageName(`@postxl/${slug}`),
+        description: `A PostXL project for ${name}.`,
+        dependencies: [],
+        devDependencies: { ...baseDevDependencies, ...(projectPath.kind === 'workspace' ? workspaceDevDependencies : {}) },
+        scripts: [...baseScripts, ...(projectPath.kind === 'workspace' ? getWorkspaceScripts(slug) : standaloneScripts)],
+    };
+    await fs.writeFile(path.join(targetPath, 'package.json'), await (0, generator_1.format)({ path: 'package.json', content: Generator.generatePackageJson(packageJsonConfig) }));
+    // Generate .env and .env.example with database connection and target generation path
+    const relativeGenerationPath = path.relative(targetPath, projectPath.projectGenerationPath) || '.';
+    const envContent = `DATABASE_CONNECTION=postgresql://postgres:postgres@localhost:5432/${slug}\n` +
+        `PXL_PROJECT_PATH=${relativeGenerationPath}\n`;
+    await fs.writeFile(path.join(targetPath, '.env.example'), envContent);
+    await fs.writeFile(path.join(targetPath, '.env'), envContent);
+}
+function generateTsConfig() {
+    return JSON.stringify(tsConfig, null, 2) + '\n';
+}
+function generateGenerateTs() {
+    return `
+import * as Generator from '@postxl/generator'
+import {
+  ${generators.map((g) => (typeof g === 'string' ? g : `${g.imports}`)).join(',\n  ')}
+} from '@postxl/generators'
+
+export default function generate(): Generator.GeneratorInterface[] {
+  return [
+    ${generators.map((g) => (typeof g === 'string' ? g : g.code)).join(',\n    ')}
+  ]
+}`;
+}

package/dist/create-project.command.d.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+export declare function register(program: Command): void;
+export type ProjectPath = ProjectPath_Standalone | ProjectPath_Workspace;
+type ProjectPath_Standalone = {
+    kind: 'standalone';
+    workspaceProjectPath: string;
+    projectGenerationPath: string;
+};
+type ProjectPath_Workspace = {
+    kind: 'workspace';
+    projectGenerationPath: string;
+};
+export {};

package/dist/create-project.command.js

@@ -0,0 +1,345 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const readline = __importStar(require("node:readline"));
+const node_util_1 = require("node:util");
+const schema_1 = require("@postxl/schema");
+const utils_1 = require("@postxl/utils");
+const create_project_generator_1 = require("./create-project/create-project.generator");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+function register(program) {
+    program
+        .command('create-project')
+        .alias('new')
+        .summary('Creates a new PostXL project.')
+        .description('Creates a new PostXL project with a selected schema template.')
+        .option('-n, --name <name>', 'Project name')
+        .option('-s, --slug <slug>', 'Project slug')
+        .option('--schema <schema>', 'Schema to use (la, mca, ring, simple, subex, uspmsm)')
+        .option('-p, --project-path <path>', 'Path where the generated project should be written. If not specified, a workspace project will be created in the projects folder')
+        .option('--skip-git', 'Skip initialing a git repository in the generated project directory')
+        .option('--skip-generate', 'Skip running the initial project generation')
+        .action(async (options) => {
+        try {
+            await checkNodeVersion();
+            const name = await getProjectName(options.name);
+            const slug = await getProjectSlug(options.slug, name);
+            const schema = await getProjectSchema(options.schema);
+            const projectPath = await resolveProjectPath({ slug, projectPath: options.projectPath });
+            await createProjectStructure({
+                name,
+                slug,
+                schema,
+                projectPath,
+            });
+            // In case it is a workspace project, we install dependencies in the workspace part - else in the project
+            await installDependencies(projectPath.kind === 'workspace' ? projectPath.projectGenerationPath : projectPath.workspaceProjectPath);
+            if (!options.skipGenerate) {
+                await runGenerate(projectPath);
+                await installDependencies(projectPath.projectGenerationPath);
+                await generatePrismaClient(projectPath.projectGenerationPath);
+                if (!options.skipInitGit && projectPath.kind === 'standalone') {
+                    await initializeGitRepository(projectPath.projectGenerationPath);
+                }
+            }
+            console.log(`\n✓ Project "${name}" created successfully at ${projectPath.projectGenerationPath}`);
+            console.log('\nNext steps:');
+            console.log(`  cd ${path.relative(process.cwd(), projectPath.projectGenerationPath)}`);
+            console.log('  pnpm run generate  # generates the project to your configured path');
+            console.log('  pnpm run dev  # in backend/');
+            console.log('  pnpm run dev  # in frontend/');
+        }
+        catch (error) {
+            console.error('Error creating project:', error);
+            process.exit(1);
+        }
+    });
+}
+async function getProjectName(providedName) {
+    if (providedName) {
+        return providedName;
+    }
+    const projectName = await prompt('Project name');
+    if (!projectName) {
+        console.error('Project name is required!');
+        process.exit(1);
+    }
+    return projectName;
+}
+async function getProjectSlug(providedSlug, projectName) {
+    if (providedSlug) {
+        return providedSlug;
+    }
+    const suggestedSlug = (0, utils_1.slugify)(projectName);
+    const projectSlug = await prompt('Project slug', suggestedSlug);
+    if (!projectSlug) {
+        console.error('Project slug is required!');
+        process.exit(1);
+    }
+    return projectSlug;
+}
+async function getProjectSchema(providedSchema) {
+    const schemaChoices = Object.keys(schema_1.sampleSchemas);
+    let selectedSchemaKey = providedSchema;
+    if (!selectedSchemaKey || !schemaChoices.includes(selectedSchemaKey)) {
+        const selectedSchemaIndex = await select('Which schema would you like to use as a starter?', schemaChoices, 3);
+        selectedSchemaKey = schemaChoices[selectedSchemaIndex];
+    }
+    const schema = schema_1.sampleSchemas[selectedSchemaKey];
+    if (!schema) {
+        console.error(`Schema "${selectedSchemaKey}" not found!`);
+        process.exit(1);
+    }
+    return schema;
+}
+/**
+ * If projectPath is provided:
+ *   - if it is local within projects, check if it exists, if yes, throw error. if not, create it and return workspace project
+ *   - if it is outside of the cwd (regardless of local or absolute), check if exists. if so, throw error, if not create and return standalone project
+ * If projectPath is not provided:
+ *   - Ask user if it should be standalone (in ../{slug}) or workspace (in ./projects/{slug}). Default is standalone.
+ *    - Create the folder and return the appropriate project path
+ */
+async function resolveProjectPath({ slug, projectPath, }) {
+    const repositoryRoot = process.cwd();
+    const projectsFolder = path.join(repositoryRoot, 'projects');
+    const defaultStandalonePath = path.resolve(repositoryRoot, '..', slug);
+    const workspaceProjectPath = path.join(projectsFolder, slug);
+    if (projectPath) {
+        const projectGenerationPath = path.isAbsolute(projectPath) ? projectPath : path.resolve(process.cwd(), projectPath);
+        await createFolderOrThrow(projectGenerationPath);
+        const isInProjectsFolder = projectGenerationPath.startsWith(projectsFolder + path.sep);
+        if (isInProjectsFolder) {
+            return { kind: 'workspace', projectGenerationPath };
+        }
+        else {
+            await createFolderOrThrow(workspaceProjectPath);
+            return {
+                kind: 'standalone',
+                workspaceProjectPath,
+                projectGenerationPath,
+            };
+        }
+    }
+    // No projectPath provided, ask user
+    const selectedOption = await select('Where should the project be created?', [`Standalone project at ${defaultStandalonePath}`, `Workspace project at ${workspaceProjectPath}`], 0);
+    const useWorkspace = selectedOption === 1;
+    if (useWorkspace) {
+        await createFolderOrThrow(workspaceProjectPath);
+        return {
+            kind: 'workspace',
+            projectGenerationPath: workspaceProjectPath,
+        };
+    }
+    else {
+        await createFolderOrThrow(workspaceProjectPath);
+        await createFolderOrThrow(defaultStandalonePath);
+        return {
+            kind: 'standalone',
+            workspaceProjectPath,
+            projectGenerationPath: defaultStandalonePath,
+        };
+    }
+}
+async function createFolderOrThrow(targetPath) {
+    try {
+        await fs.access(targetPath);
+        console.error(`Target path "${targetPath}" already exists! Please choose a different path.`);
+        process.exit(1);
+    }
+    catch {
+        // Path does not exist, create it
+        await fs.mkdir(targetPath, { recursive: true });
+    }
+}
+async function createProjectStructure({ name, slug, schema, projectPath, }) {
+    console.log(`\nCreating project "${name}" at ${projectPath.projectGenerationPath}...`);
+    await (0, create_project_generator_1.createProject)({
+        name: (0, schema_1.toProjectSchemaName)(name),
+        slug: (0, schema_1.toProjectSlug)(slug),
+        schema: schema,
+        projectPath,
+    });
+    console.log('Project files created successfully!');
+}
+async function installDependencies(path) {
+    console.log('\nInstalling dependencies...');
+    try {
+        const { stdout, stderr } = await execAsync('pnpm install', { cwd: path });
+        if (stdout) {
+            console.log(stdout);
+        }
+        if (stderr) {
+            console.error(stderr);
+        }
+        console.log('Dependencies installed successfully!');
+    }
+    catch (error) {
+        console.error('Failed to install dependencies:', error);
+        console.log('You can manually run "pnpm install" in the project directory.');
+    }
+}
+async function runGenerate(projectPath) {
+    console.log('\nGenerating project code...');
+    try {
+        const path = projectPath.kind === 'standalone' ? projectPath.workspaceProjectPath : projectPath.projectGenerationPath;
+        const { stdout, stderr } = await execAsync('pnpm run generate:project -f', {
+            cwd: path,
+            env: { ...process.env, PXL_PROJECT_PATH: projectPath.projectGenerationPath },
+        });
+        if (stdout) {
+            console.log(stdout);
+        }
+        if (stderr) {
+            console.error(stderr);
+        }
+        console.log('Project code generated successfully!');
+    }
+    catch (error) {
+        console.error('Failed to generate project code:', error);
+        console.log('You can manually run "pnpm run generate" in the project directory.');
+    }
+}
+async function generatePrismaClient(path) {
+    // 9. Generate Prisma
+    console.log('\nGenerating Prisma client...');
+    try {
+        const { stdout, stderr } = await execAsync('pnpm run generate:prisma', { cwd: path });
+        if (stdout) {
+            console.log(stdout);
+        }
+        if (stderr) {
+            console.error(stderr);
+        }
+        console.log('Prisma client generated successfully!');
+    }
+    catch (error) {
+        console.error('Failed to generate Prisma client:', error);
+        console.log('You can manually run "pnpm run generate:prisma" in the project directory.');
+    }
+}
+async function initializeGitRepository(path) {
+    console.log('\nInitializing git repository...');
+    try {
+        await execAsync('git init -b main', { cwd: path });
+        console.log('Git repository initialized successfully!');
+    }
+    catch (error) {
+        console.error('Failed to initialize git repository:', error);
+    }
+}
+/**
+ * Throws if is less than what .nvmrc requires
+ */
+async function checkNodeVersion() {
+    try {
+        const repositoryRoot = process.cwd();
+        const nvmrcPath = path.join(repositoryRoot, '.nvmrc');
+        // Read the required version from .nvmrc
+        const nvmrcContent = await fs.readFile(nvmrcPath, 'utf-8');
+        const requiredVersion = nvmrcContent.trim().replace(/^v/, '');
+        // Get current Node.js version
+        const currentVersion = process.version.replace(/^v/, '');
+        // Compare major versions
+        const [requiredMajor] = requiredVersion.split('.').map(Number);
+        const [currentMajor] = currentVersion.split('.').map(Number);
+        if (currentMajor < requiredMajor) {
+            throw new Error(`Node.js version ${requiredVersion} or higher is required. Current version: ${currentVersion}`);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            // .nvmrc file not found, skip check
+            return;
+        }
+        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 || '');
+        });
+    });
+}
+// Helper to select from a list
+async function select(question, choices, defaultIndex = 0) {
+    if (choices.length === 0) {
+        throw new Error('No choices available');
+    }
+    if (defaultIndex < 0 || defaultIndex >= choices.length) {
+        defaultIndex = 0;
+    }
+    console.log(`\n${question}`);
+    for (const [index, choice] of choices.entries()) {
+        const num = index + 1;
+        const marker = index === defaultIndex ? ' (default)' : '';
+        console.log(`  ${num}. ${choice}${marker}`);
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        const promptText = `\nEnter your choice (number) [default ${defaultIndex + 1}]: `;
+        rl.question(promptText, (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed) {
+                resolve(defaultIndex);
+                return;
+            }
+            const index = Number.parseInt(trimmed, 10) - 1;
+            if (index >= 0 && index < choices.length) {
+                resolve(index);
+            }
+            else {
+                console.log('Invalid choice, using default option.');
+                resolve(defaultIndex);
+            }
+        });
+    });
+}

package/dist/generate.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function register(program: Command): void;

package/dist/generate.command.js

@@ -0,0 +1,256 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const util_1 = require("util");
+const dotenv_1 = __importDefault(require("dotenv"));
+const path = __importStar(require("node:path"));
+const zod_validation_error_1 = require("zod-validation-error");
+const generator_1 = require("@postxl/generator");
+const schema_1 = require("@postxl/schema");
+const utils_1 = require("@postxl/utils");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function register(program) {
+    program
+        .command('generate', { isDefault: true })
+        .argument('[path]', 'The path to the project to generate. Default is current directory', process.cwd())
+        .argument('[target]', 'The target path to generate the project to. Default is [path]')
+        .summary('Generates the project.')
+        .description(`Generates the project.
+      
+This reads the schema from ${(0, utils_1.yellow)('schema.json')} and runs the generators specified in ${(0, utils_1.yellow)('generate.ts')}.`)
+        .option('-d, --diff', 'shows diff between ejected and generated files')
+        .option('-e, --ejected', 'lists ejected files')
+        .option('-f, --force', 'overwrites ejected files')
+        .option('-i, --ignore-errors', 'ignores errors during generation')
+        .option('-n, --no-fix', 'does not attempt to fix linting errors')
+        .option('-p, --pattern <glob>', 'filters files by glob pattern (e.g., "**/*.ts" or "backend/libs/**")')
+        .option('-q, --quiet', 'does not print errors')
+        .option('-s, --skip-lint', 'skips linting')
+        .option('-v, --verbose', 'shows verbose linting messages')
+        .action(async (projectPath, targetPath, options) => {
+        if (projectPath.startsWith('.')) {
+            projectPath = path.join(process.cwd(), projectPath);
+        }
+        try {
+            await fs.access(projectPath);
+        }
+        catch {
+            program.error(`Cannot find project path ${projectPath}!`);
+        }
+        const envConfig = dotenv_1.default.config({ path: path.join(projectPath, '.env') });
+        const localGenerators = await getLocalGenerators({ program, projectPath });
+        const schema = await getSchema({ program, projectPath });
+        targetPath = resolveTargetPath({
+            projectPath,
+            targetPath,
+            envTargetPath: process.env.PXL_PROJECT_PATH ?? envConfig.parsed?.PXL_PROJECT_PATH,
+            schemaSlug: schema.slug,
+            projectType: schema.projectType,
+        });
+        await fs.mkdir(targetPath, { recursive: true });
+        console.log(`Generating project from ${projectPath} to ${targetPath}`);
+        if (options.force) {
+            console.log((0, utils_1.yellow)('Warning: Forcing generation of ejected files!'));
+        }
+        if (options.pattern) {
+            console.log(`Filtering files by pattern: ${options.pattern}`);
+        }
+        const manager = new generator_1.GeneratorManager(localGenerators);
+        const baseContext = (0, generator_1.prepareBaseContext)(schema, {
+            ...options,
+            ...(options.pattern ? { filePattern: options.pattern } : {}),
+        });
+        const generatedContext = await manager.generate(baseContext);
+        return (new generator_1.Generator(generatedContext)
+            // Not sure why we need this - but without the next line fails 💥
+            .generate((g) => g)
+            //
+            .then(async (g) => {
+            const lintResult = await (0, generator_1.lint)(g.context.vfs, options);
+            if (!options.quiet) {
+                (0, generator_1.logLintResults)(lintResult, options);
+            }
+            await g.context.vfs.transform(generator_1.format, {
+                onError: ({ path, error }) => {
+                    if (options.ignoreErrors) {
+                        console.error(`Error formatting ${path}:`, error);
+                    }
+                    else {
+                        throw error;
+                    }
+                },
+            });
+            const result = await (0, generator_1.sync)({
+                vfs: g.context.vfs,
+                lockFilePath: path.join(targetPath, 'postxl-lock.json'),
+                diskFilePath: targetPath,
+                force: options.force ?? false,
+            });
+            (0, generator_1.logSyncResult)(result, {
+                showEjectedStats: options.ejected ?? false,
+                showEjectedDiff: options.diff ?? false,
+            });
+            return g;
+        })
+            .then((g) => {
+            if (g.context.options.errors.length > 0 && !options.quiet) {
+                console.error('Generation completed with errors:\n', g.context.options.errors.join('\n'));
+            }
+        }));
+    });
+}
+/**
+ * This function compiles the generate.ts file into a JS file and then imports and returns it
+ * via dynamic import.
+ */
+async function getLocalGenerators(params) {
+    const { projectPath } = params;
+    const generateTsPath = path.join(projectPath, 'generate.ts');
+    const tsconfigPath = path.join(projectPath, 'tsconfig.generate.json');
+    const outDir = path.join(projectPath, 'dist');
+    const generateJsPath = path.join(outDir, 'generate.js');
+    // Check if `generate.ts` exists
+    try {
+        await fs.access(generateTsPath);
+    }
+    catch {
+        params.program.error(`Cannot find file "generate.ts" found at ${generateTsPath}`);
+    }
+    //write a tsconfig.json file that extends the base tsconfig.json but limits the file to generate.ts
+    const tsconfigJson = `{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "outDir": "./dist"
+  },
+  "include": ["generate.ts"]
+}`;
+    await fs.writeFile(tsconfigPath, tsconfigJson);
+    // Run tsc to compile `generate.ts` into `dist/generate.js`
+    try {
+        await execAsync(`tsc -b tsconfig.generate.json`);
+    }
+    catch (err) {
+        if (err.stdout) {
+            console.log(err.stdout);
+        }
+        else if (err.stderr) {
+            console.log(err.stderr);
+        }
+        else {
+            console.log(JSON.stringify(err, null, 2));
+        }
+        params.program.error(`Failed to compile ${generateTsPath}:`, err);
+    }
+    // Check if `dist/generate.js` exists
+    try {
+        await fs.access(generateJsPath);
+    }
+    catch {
+        params.program.error(`No dist/generate.js found at ${generateJsPath}, skipping local generation.`);
+    }
+    // Load the transpiled `generate.js` from the `dist` folder
+    let localGenerate;
+    try {
+        const localGenerateFile = await import(`file://${generateJsPath}`);
+        if (localGenerateFile.default?.default) {
+            localGenerate = localGenerateFile.default.default;
+        }
+        else if (localGenerateFile.default?.generate) {
+            localGenerate = localGenerateFile.default.generate;
+        }
+        else if (typeof localGenerateFile.default === 'function') {
+            localGenerate = localGenerateFile.default;
+        }
+        else if (typeof localGenerateFile.generate === 'function') {
+            localGenerate = localGenerateFile.generate;
+        }
+        else {
+            params.program.error(`${generateTsPath} does not export a default or generate function!`);
+        }
+    }
+    catch (e) {
+        console.error(e);
+        params.program.error(`Error importing local generate.js at ${generateJsPath}`, e);
+    }
+    // Delete the tsconfig.generate.json file
+    try {
+        await fs.rm(tsconfigPath, { force: true });
+    }
+    catch {
+        /* empty */
+    }
+    return localGenerate();
+}
+async function getSchema(params) {
+    const { projectPath } = params;
+    const schemaPath = path.join(projectPath, 'postxl-schema.json');
+    try {
+        await fs.access(schemaPath);
+    }
+    catch {
+        params.program.error(`Cannot find file "postxl-schema.json" found at ${schemaPath}`);
+    }
+    const jsonSchema = JSON.parse((await fs.readFile(schemaPath)).toString());
+    const schema = schema_1.zProjectSchema.safeParse(jsonSchema);
+    if (!schema.success) {
+        params.program.error(`Error parsing postxl-schema.json: \n${(0, zod_validation_error_1.fromZodError)(schema.error)
+            .details.map((e) => e.message)
+            .join('\n')}`);
+    }
+    return schema.data;
+}
+function resolveTargetPath({ projectPath, targetPath, envTargetPath, schemaSlug, projectType, }) {
+    let resolved = targetPath ?? envTargetPath;
+    if (!resolved) {
+        if (projectType.kind === 'workspace') {
+            resolved = projectPath;
+        }
+        else {
+            const repositoryRoot = path.join(projectPath, '..', '..');
+            resolved = path.resolve(repositoryRoot, '..', schemaSlug);
+        }
+    }
+    if (resolved.startsWith('.') || !path.isAbsolute(resolved)) {
+        resolved = path.resolve(projectPath, resolved);
+    }
+    return resolved;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const create_project_command_1 = require("./create-project.command");
+const generate_command_1 = require("./generate.command");
+const program = new commander_1.Command();
+program
+    //
+    .name('pxl')
+    .description('CLI for PostXL')
+    .version('0.1.0');
+// Adding all the commands
+(0, generate_command_1.register)(program);
+(0, create_project_command_1.register)(program);
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@postxl/cli",
+  "version": "0.0.9",
+  "description": "Command-line interface for PostXL code generation framework",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "pxl": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "PostXL GmbH",
+  "keywords": [
+    "postxl",
+    "pxl",
+    "cli",
+    "code-generation",
+    "typescript",
+    "nestjs",
+    "react"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "lint": "eslint .",
+    "prettier:check": "prettier --check \"**/*.{ts,tsx}\" --config ../../prettier.config.js --ignore-path ../../.prettierignore",
+    "test:types": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/postxl/pxl",
+    "directory": "packages/cli"
+  },
+  "dependencies": {
+    "@postxl/generator": "workspace:*",
+    "@postxl/generators": "workspace:*",
+    "@postxl/schema": "workspace:*",
+    "commander": "12.1.0",
+    "dotenv": "16.4.7",
+    "zod-validation-error": "3.4.0"
+  },
+  "devDependencies": {},
+  "wallaby": {
+    "env": {
+      "type": "node",
+      "params": {
+        "runner": "--experimental-vm-modules"
+      }
+    }
+  }
+}