pgpm 3.1.0 → 3.2.0

package/README.md

@@ -70,6 +70,8 @@ Here are some useful commands for reference:
 
 - `pgpm init` - Initialize a new module
 - `pgpm init workspace` - Initialize a new workspace
+- `pgpm init --template <path>` - Initialize using a full template path (e.g., `pnpm/module`)
+- `pgpm init -w` - Create a workspace first, then create the module inside it
 
 ### Development Setup
 
@@ -142,7 +144,7 @@ pgpm deploy --createdb
 
 ## 🧰 Templates, Caching, and Updates
 
-- `pgpm init` now scaffolds workspaces/modules from `https://github.com/constructive-io/pgpm-boilerplates.git` using `create-gen-app` with a one-week cache (stored under `~/.pgpm/cache/repos`). Override with `--repo`, `--from-branch`, and `--template-path`, or use a local template path.
+- `pgpm init` now scaffolds workspaces/modules from `https://github.com/constructive-io/pgpm-boilerplates.git` using `create-gen-app` with a one-week cache (stored under `~/.pgpm/cache/repos`). Override with `--repo`, `--from-branch`, and `--template`, or use a local template path.
 - Run `pgpm cache clean` to wipe the cached boilerplates if you need a fresh pull.
 - The CLI performs a lightweight npm version check at most once per week (skipped in CI or when `PGPM_SKIP_UPDATE_CHECK` is set). Use `pgpm update` to upgrade to the latest release.
 

package/commands/init/index.js

@@ -32,16 +32,20 @@ Options:
   --repo <repo>           Template repo (default: https://github.com/constructive-io/pgpm-boilerplates.git)
   --from-branch <branch>  Branch/tag to use when cloning repo
   --dir <variant>         Template variant directory (e.g., supabase, drizzle)
+  --template, -t <path>   Full template path (e.g., pnpm/module) - combines dir and fromPath
   --boilerplate           Prompt to select from available boilerplates
+  --create-workspace, -w  Create a workspace first, then create the module inside it
 
 Examples:
   ${binaryName} init                                   Initialize new module (default)
   ${binaryName} init workspace                         Initialize new workspace
   ${binaryName} init module                            Initialize new module explicitly
   ${binaryName} init workspace --dir <variant>         Use variant templates
+  ${binaryName} init --template pnpm/module            Use full template path (dir + type)
   ${binaryName} init --boilerplate                     Select from available boilerplates
   ${binaryName} init --repo owner/repo                 Use templates from GitHub repository
   ${binaryName} init --repo owner/repo --from-branch develop  Use specific branch
+  ${binaryName} init --dir pnpm -w                     Create pnpm workspace + module in one command
 `;
 };
 exports.createInitUsageText = createInitUsageText;
@@ -57,11 +61,28 @@ async function handleInit(argv, prompter) {
     const { cwd = process.cwd() } = argv;
     const templateRepo = argv.repo ?? core_1.DEFAULT_TEMPLATE_REPO;
     const branch = argv.fromBranch;
-    const dir = argv.dir;
     const noTty = Boolean(argv.noTty || argv['no-tty'] || process.env.CI === 'true');
     const useBoilerplatePrompt = Boolean(argv.boilerplate);
+    const createWorkspace = Boolean(argv.createWorkspace || argv['create-workspace'] || argv.w);
     // Get fromPath from first positional arg
     const positionalFromPath = argv._?.[0];
+    // Handle --template flag: parses "dir/fromPath" format and extracts both components
+    // When --template is provided, it takes precedence over --dir and positional fromPath
+    const templateArg = argv.template;
+    let dir = argv.dir;
+    let templateFromPath;
+    if (templateArg) {
+        // Parse template path like "pnpm/module" into dir="pnpm" and fromPath="module"
+        const slashIndex = templateArg.indexOf('/');
+        if (slashIndex > 0) {
+            dir = templateArg.substring(0, slashIndex);
+            templateFromPath = templateArg.substring(slashIndex + 1);
+        }
+        else {
+            // No slash - treat the whole thing as fromPath (e.g., --template workspace)
+            templateFromPath = templateArg;
+        }
+    }
     // Handle --boilerplate flag: separate path from regular init
     if (useBoilerplatePrompt) {
         return handleBoilerplateInit(argv, prompter, {
@@ -73,10 +94,10 @@ async function handleInit(argv, prompter) {
             cwd,
         });
     }
-    // Regular init path: default to 'module' if no fromPath provided
-    const fromPath = positionalFromPath || 'module';
-    // Track if user explicitly requested module (e.g., `pgpm init module`)
-    const wasExplicitModuleRequest = positionalFromPath === 'module';
+    // Regular init path: --template takes precedence, then positional arg, then default to 'module'
+    const fromPath = templateFromPath || positionalFromPath || 'module';
+    // Track if user explicitly requested module (e.g., `pgpm init module` or `--template pnpm/module`)
+    const wasExplicitModuleRequest = positionalFromPath === 'module' || templateFromPath === 'module';
     // Inspect the template to get its type
     const inspection = (0, core_1.inspectTemplate)({
         fromPath,
@@ -107,6 +128,7 @@ async function handleInit(argv, prompter) {
         noTty,
         cwd,
         requiresWorkspace: inspection.config?.requiresWorkspace,
+        createWorkspace,
     }, wasExplicitModuleRequest);
 }
 async function handleBoilerplateInit(argv, prompter, ctx) {
@@ -235,58 +257,130 @@ async function handleWorkspaceInit(argv, prompter, ctx) {
     process.stdout.write(`\n✨ Enjoy!\n\ncd ./${dirName}\n`);
     return { ...argv, ...answers, cwd: targetPath };
 }
+function resolveWorkspaceTemplateRepo(options) {
+    const { templateRepo, branch, dir, workspaceType, cwd } = options;
+    // Determine the dir to use for workspace template
+    // If dir is specified, use it; otherwise use the workspaceType as the dir variant
+    const workspaceDir = dir || workspaceType;
+    // Try to find workspace template in the specified repo
+    try {
+        const inspection = (0, core_1.inspectTemplate)({
+            fromPath: 'workspace',
+            templateRepo,
+            branch,
+            dir: workspaceDir,
+            toolName: core_1.DEFAULT_TEMPLATE_TOOL_NAME,
+            cwd,
+        });
+        // If we found a valid workspace template, use the specified repo
+        if (inspection.config?.type === 'workspace') {
+            return {
+                repo: templateRepo,
+                branch,
+                dir: workspaceDir,
+            };
+        }
+    }
+    catch {
+        // Template not found in specified repo, fall through to default
+    }
+    // Fall back to default template repo
+    // Use the workspaceType as the dir variant (pgpm or pnpm)
+    return {
+        repo: core_1.DEFAULT_TEMPLATE_REPO,
+        branch: undefined, // Use default branch for default repo
+        dir: workspaceType,
+    };
+}
 async function handleModuleInit(argv, prompter, ctx, wasExplicitModuleRequest = false) {
     // Determine workspace requirement (defaults to 'pgpm' for backward compatibility)
     const workspaceType = ctx.requiresWorkspace ?? 'pgpm';
     // Whether this is a pgpm-managed template (creates pgpm.plan, .control files)
     const isPgpmTemplate = workspaceType === 'pgpm';
-    const project = new core_1.PgpmPackage(ctx.cwd);
+    let project = new core_1.PgpmPackage(ctx.cwd);
+    // Track resolved workspace path for both pgpm and non-pgpm workspace types
+    let resolvedWorkspacePath;
+    let workspaceTypeName = '';
     // Check workspace requirement based on type (skip if workspaceType is false)
     if (workspaceType !== false) {
-        let workspacePath;
-        let workspaceTypeName = '';
         if (workspaceType === 'pgpm') {
-            workspacePath = project.workspacePath;
+            resolvedWorkspacePath = project.workspacePath;
             workspaceTypeName = 'PGPM';
         }
         else {
-            workspacePath = (0, env_1.resolveWorkspaceByType)(ctx.cwd, workspaceType);
+            resolvedWorkspacePath = (0, env_1.resolveWorkspaceByType)(ctx.cwd, workspaceType);
             workspaceTypeName = workspaceType.toUpperCase();
         }
-        if (!workspacePath) {
+        if (!resolvedWorkspacePath) {
             const noTty = Boolean(argv.noTty || argv['no-tty'] || process.env.CI === 'true');
-            // If user explicitly requested module init or we're in non-interactive mode,
-            // just show the error with helpful guidance
-            if (wasExplicitModuleRequest || noTty) {
-                process.stderr.write(`Not inside a ${workspaceTypeName} workspace.\n`);
-                throw types_1.errors.NOT_IN_WORKSPACE({});
+            // Handle --create-workspace flag: create workspace first, then module
+            if (ctx.createWorkspace && (workspaceType === 'pgpm' || workspaceType === 'pnpm')) {
+                // Resolve workspace template repo with fallback to default
+                const workspaceTemplateConfig = resolveWorkspaceTemplateRepo({
+                    templateRepo: ctx.templateRepo,
+                    branch: ctx.branch,
+                    dir: ctx.dir,
+                    workspaceType,
+                    cwd: ctx.cwd,
+                });
+                // Create workspace first
+                const workspaceResult = await handleWorkspaceInit(argv, prompter, {
+                    fromPath: 'workspace',
+                    templateRepo: workspaceTemplateConfig.repo,
+                    branch: workspaceTemplateConfig.branch,
+                    dir: workspaceTemplateConfig.dir,
+                    noTty: ctx.noTty,
+                    cwd: ctx.cwd,
+                });
+                // Update context to point to new workspace and continue with module creation
+                const newCwd = workspaceResult.cwd;
+                project = new core_1.PgpmPackage(newCwd);
+                // Re-resolve workspace path with new cwd
+                if (workspaceType === 'pgpm') {
+                    resolvedWorkspacePath = project.workspacePath;
+                }
+                else {
+                    resolvedWorkspacePath = (0, env_1.resolveWorkspaceByType)(newCwd, workspaceType);
+                }
+                // Update ctx for module creation
+                ctx.cwd = newCwd;
+                // Continue to module creation below (don't return here)
             }
-            // Only offer to create a workspace for pgpm templates
-            if (workspaceType === 'pgpm') {
-                const recoveryQuestion = [
-                    {
-                        name: 'workspace',
-                        alias: 'w',
-                        message: `You are not inside a ${workspaceTypeName} workspace. Would you like to create a new workspace instead?`,
-                        type: 'confirm',
-                        required: true,
-                    },
-                ];
-                const { workspace } = await prompter.prompt(argv, recoveryQuestion);
-                if (workspace) {
-                    return handleWorkspaceInit(argv, prompter, {
-                        fromPath: 'workspace',
-                        templateRepo: ctx.templateRepo,
-                        branch: ctx.branch,
-                        dir: ctx.dir,
-                        noTty: ctx.noTty,
-                        cwd: ctx.cwd,
-                    });
+            else {
+                // If user explicitly requested module init or we're in non-interactive mode,
+                // just show the error with helpful guidance
+                if (wasExplicitModuleRequest || noTty) {
+                    process.stderr.write(`Not inside a ${workspaceTypeName} workspace.\n`);
+                    throw types_1.errors.NOT_IN_WORKSPACE({});
+                }
+                // Offer to create a workspace for pgpm templates or when --dir is specified
+                // (when --dir is specified, we know which workspace variant to use)
+                if (workspaceType === 'pgpm' || ctx.dir) {
+                    const recoveryQuestion = [
+                        {
+                            name: 'workspace',
+                            alias: 'W',
+                            message: `You are not inside a ${workspaceTypeName} workspace. Would you like to create a new workspace instead?`,
+                            type: 'confirm',
+                            required: true,
+                        },
+                    ];
+                    const { workspace } = await prompter.prompt(argv, recoveryQuestion);
+                    if (workspace) {
+                        return handleWorkspaceInit(argv, prompter, {
+                            fromPath: 'workspace',
+                            templateRepo: ctx.templateRepo,
+                            branch: ctx.branch,
+                            dir: ctx.dir,
+                            noTty: ctx.noTty,
+                            cwd: ctx.cwd,
+                        });
+                    }
                 }
+                // User declined or non-pgpm workspace type without --dir, show the error
+                process.stderr.write(`Not inside a ${workspaceTypeName} workspace.\n`);
+                throw types_1.errors.NOT_IN_WORKSPACE({});
             }
-            // User declined or non-pgpm workspace type, show the error
-            process.stderr.write(`Not inside a ${workspaceTypeName} workspace.\n`);
-            throw types_1.errors.NOT_IN_WORKSPACE({});
         }
     }
     // Only check workspace directory constraints if we're in a workspace
@@ -334,7 +428,7 @@ async function handleModuleInit(argv, prompter, ctx, wasExplicitModuleRequest =
     // Determine output path based on whether we're in a workspace
     let modulePath;
     if (project.workspacePath) {
-        // Use workspace-aware initModule
+        // PGPM workspace - use workspace-aware initModule
         await project.initModule({
             name: modName,
             description: answers.description || modName,
@@ -354,8 +448,28 @@ async function handleModuleInit(argv, prompter, ctx, wasExplicitModuleRequest =
             ? path_1.default.join(ctx.cwd, 'packages', modName)
             : path_1.default.join(ctx.cwd, modName);
     }
+    else if (resolvedWorkspacePath && workspaceType !== false) {
+        // Non-pgpm workspace (pnpm, lerna, npm) - scaffold to packages/ directory
+        const isRoot = path_1.default.resolve(resolvedWorkspacePath) === path_1.default.resolve(ctx.cwd);
+        modulePath = isRoot
+            ? path_1.default.join(ctx.cwd, 'packages', modName)
+            : path_1.default.join(ctx.cwd, modName);
+        fs_1.default.mkdirSync(modulePath, { recursive: true });
+        await (0, core_1.scaffoldTemplate)({
+            fromPath: ctx.fromPath,
+            outputDir: modulePath,
+            templateRepo: ctx.templateRepo,
+            branch: ctx.branch,
+            dir: ctx.dir,
+            answers: templateAnswers,
+            noTty: ctx.noTty,
+            toolName: core_1.DEFAULT_TEMPLATE_TOOL_NAME,
+            cwd: ctx.cwd,
+            prompter
+        });
+    }
     else {
-        // Not in a workspace - scaffold directly to current directory
+        // Not in any workspace (requiresWorkspace: false) - scaffold to current directory
         modulePath = path_1.default.join(ctx.cwd, modName);
         fs_1.default.mkdirSync(modulePath, { recursive: true });
         await (0, core_1.scaffoldTemplate)({

package/commands/init/workspace.js

@@ -29,15 +29,16 @@ async function runWorkspaceSetup(argv, prompter) {
     // Prevent double-echoed keystrokes by closing our prompter before template prompts.
     prompter.close();
     const templateRepo = argv.repo ?? core_1.DEFAULT_TEMPLATE_REPO;
-    // Don't set default templatePath - let scaffoldTemplate use metadata-driven resolution
-    const templatePath = argv.templatePath;
+    // Don't set default template - let scaffoldTemplate use metadata-driven resolution
+    // Support both --template (new) and --template-path (deprecated) for backward compatibility
+    const template = (argv.template || argv.templatePath);
     // Register workspace.dirname resolver so boilerplate templates can use it via defaultFrom/setFrom
     // This provides the intended workspace directory name before the folder is created
     const dirName = path_1.default.basename(targetPath);
     (0, inquirerer_1.registerDefaultResolver)('workspace.dirname', () => dirName);
     const dir = argv.dir;
     await (0, core_1.scaffoldTemplate)({
-        fromPath: templatePath ?? 'workspace',
+        fromPath: template ?? 'workspace',
         outputDir: targetPath,
         templateRepo,
         branch: argv.fromBranch,

package/esm/commands/init/index.js

@@ -26,16 +26,20 @@ Options:
   --repo <repo>           Template repo (default: https://github.com/constructive-io/pgpm-boilerplates.git)
   --from-branch <branch>  Branch/tag to use when cloning repo
   --dir <variant>         Template variant directory (e.g., supabase, drizzle)
+  --template, -t <path>   Full template path (e.g., pnpm/module) - combines dir and fromPath
   --boilerplate           Prompt to select from available boilerplates
+  --create-workspace, -w  Create a workspace first, then create the module inside it
 
 Examples:
   ${binaryName} init                                   Initialize new module (default)
   ${binaryName} init workspace                         Initialize new workspace
   ${binaryName} init module                            Initialize new module explicitly
   ${binaryName} init workspace --dir <variant>         Use variant templates
+  ${binaryName} init --template pnpm/module            Use full template path (dir + type)
   ${binaryName} init --boilerplate                     Select from available boilerplates
   ${binaryName} init --repo owner/repo                 Use templates from GitHub repository
   ${binaryName} init --repo owner/repo --from-branch develop  Use specific branch
+  ${binaryName} init --dir pnpm -w                     Create pnpm workspace + module in one command
 `;
 };
 export default async (argv, prompter, _options) => {
@@ -50,11 +54,28 @@ async function handleInit(argv, prompter) {
     const { cwd = process.cwd() } = argv;
     const templateRepo = argv.repo ?? DEFAULT_TEMPLATE_REPO;
     const branch = argv.fromBranch;
-    const dir = argv.dir;
     const noTty = Boolean(argv.noTty || argv['no-tty'] || process.env.CI === 'true');
     const useBoilerplatePrompt = Boolean(argv.boilerplate);
+    const createWorkspace = Boolean(argv.createWorkspace || argv['create-workspace'] || argv.w);
     // Get fromPath from first positional arg
     const positionalFromPath = argv._?.[0];
+    // Handle --template flag: parses "dir/fromPath" format and extracts both components
+    // When --template is provided, it takes precedence over --dir and positional fromPath
+    const templateArg = argv.template;
+    let dir = argv.dir;
+    let templateFromPath;
+    if (templateArg) {
+        // Parse template path like "pnpm/module" into dir="pnpm" and fromPath="module"
+        const slashIndex = templateArg.indexOf('/');
+        if (slashIndex > 0) {
+            dir = templateArg.substring(0, slashIndex);
+            templateFromPath = templateArg.substring(slashIndex + 1);
+        }
+        else {
+            // No slash - treat the whole thing as fromPath (e.g., --template workspace)
+            templateFromPath = templateArg;
+        }
+    }
     // Handle --boilerplate flag: separate path from regular init
     if (useBoilerplatePrompt) {
         return handleBoilerplateInit(argv, prompter, {
@@ -66,10 +87,10 @@ async function handleInit(argv, prompter) {
             cwd,
         });
     }
-    // Regular init path: default to 'module' if no fromPath provided
-    const fromPath = positionalFromPath || 'module';
-    // Track if user explicitly requested module (e.g., `pgpm init module`)
-    const wasExplicitModuleRequest = positionalFromPath === 'module';
+    // Regular init path: --template takes precedence, then positional arg, then default to 'module'
+    const fromPath = templateFromPath || positionalFromPath || 'module';
+    // Track if user explicitly requested module (e.g., `pgpm init module` or `--template pnpm/module`)
+    const wasExplicitModuleRequest = positionalFromPath === 'module' || templateFromPath === 'module';
     // Inspect the template to get its type
     const inspection = inspectTemplate({
         fromPath,
@@ -100,6 +121,7 @@ async function handleInit(argv, prompter) {
         noTty,
         cwd,
         requiresWorkspace: inspection.config?.requiresWorkspace,
+        createWorkspace,
     }, wasExplicitModuleRequest);
 }
 async function handleBoilerplateInit(argv, prompter, ctx) {
@@ -228,58 +250,130 @@ async function handleWorkspaceInit(argv, prompter, ctx) {
     process.stdout.write(`\n✨ Enjoy!\n\ncd ./${dirName}\n`);
     return { ...argv, ...answers, cwd: targetPath };
 }
+function resolveWorkspaceTemplateRepo(options) {
+    const { templateRepo, branch, dir, workspaceType, cwd } = options;
+    // Determine the dir to use for workspace template
+    // If dir is specified, use it; otherwise use the workspaceType as the dir variant
+    const workspaceDir = dir || workspaceType;
+    // Try to find workspace template in the specified repo
+    try {
+        const inspection = inspectTemplate({
+            fromPath: 'workspace',
+            templateRepo,
+            branch,
+            dir: workspaceDir,
+            toolName: DEFAULT_TEMPLATE_TOOL_NAME,
+            cwd,
+        });
+        // If we found a valid workspace template, use the specified repo
+        if (inspection.config?.type === 'workspace') {
+            return {
+                repo: templateRepo,
+                branch,
+                dir: workspaceDir,
+            };
+        }
+    }
+    catch {
+        // Template not found in specified repo, fall through to default
+    }
+    // Fall back to default template repo
+    // Use the workspaceType as the dir variant (pgpm or pnpm)
+    return {
+        repo: DEFAULT_TEMPLATE_REPO,
+        branch: undefined, // Use default branch for default repo
+        dir: workspaceType,
+    };
+}
 async function handleModuleInit(argv, prompter, ctx, wasExplicitModuleRequest = false) {
     // Determine workspace requirement (defaults to 'pgpm' for backward compatibility)
     const workspaceType = ctx.requiresWorkspace ?? 'pgpm';
     // Whether this is a pgpm-managed template (creates pgpm.plan, .control files)
     const isPgpmTemplate = workspaceType === 'pgpm';
-    const project = new PgpmPackage(ctx.cwd);
+    let project = new PgpmPackage(ctx.cwd);
+    // Track resolved workspace path for both pgpm and non-pgpm workspace types
+    let resolvedWorkspacePath;
+    let workspaceTypeName = '';
     // Check workspace requirement based on type (skip if workspaceType is false)
     if (workspaceType !== false) {
-        let workspacePath;
-        let workspaceTypeName = '';
         if (workspaceType === 'pgpm') {
-            workspacePath = project.workspacePath;
+            resolvedWorkspacePath = project.workspacePath;
             workspaceTypeName = 'PGPM';
         }
         else {
-            workspacePath = resolveWorkspaceByType(ctx.cwd, workspaceType);
+            resolvedWorkspacePath = resolveWorkspaceByType(ctx.cwd, workspaceType);
             workspaceTypeName = workspaceType.toUpperCase();
         }
-        if (!workspacePath) {
+        if (!resolvedWorkspacePath) {
             const noTty = Boolean(argv.noTty || argv['no-tty'] || process.env.CI === 'true');
-            // If user explicitly requested module init or we're in non-interactive mode,
-            // just show the error with helpful guidance
-            if (wasExplicitModuleRequest || noTty) {
-                process.stderr.write(`Not inside a ${workspaceTypeName} workspace.\n`);
-                throw errors.NOT_IN_WORKSPACE({});
+            // Handle --create-workspace flag: create workspace first, then module
+            if (ctx.createWorkspace && (workspaceType === 'pgpm' || workspaceType === 'pnpm')) {
+                // Resolve workspace template repo with fallback to default
+                const workspaceTemplateConfig = resolveWorkspaceTemplateRepo({
+                    templateRepo: ctx.templateRepo,
+                    branch: ctx.branch,
+                    dir: ctx.dir,
+                    workspaceType,
+                    cwd: ctx.cwd,
+                });
+                // Create workspace first
+                const workspaceResult = await handleWorkspaceInit(argv, prompter, {
+                    fromPath: 'workspace',
+                    templateRepo: workspaceTemplateConfig.repo,
+                    branch: workspaceTemplateConfig.branch,
+                    dir: workspaceTemplateConfig.dir,
+                    noTty: ctx.noTty,
+                    cwd: ctx.cwd,
+                });
+                // Update context to point to new workspace and continue with module creation
+                const newCwd = workspaceResult.cwd;
+                project = new PgpmPackage(newCwd);
+                // Re-resolve workspace path with new cwd
+                if (workspaceType === 'pgpm') {
+                    resolvedWorkspacePath = project.workspacePath;
+                }
+                else {
+                    resolvedWorkspacePath = resolveWorkspaceByType(newCwd, workspaceType);
+                }
+                // Update ctx for module creation
+                ctx.cwd = newCwd;
+                // Continue to module creation below (don't return here)
             }
-            // Only offer to create a workspace for pgpm templates
-            if (workspaceType === 'pgpm') {
-                const recoveryQuestion = [
-                    {
-                        name: 'workspace',
-                        alias: 'w',
-                        message: `You are not inside a ${workspaceTypeName} workspace. Would you like to create a new workspace instead?`,
-                        type: 'confirm',
-                        required: true,
-                    },
-                ];
-                const { workspace } = await prompter.prompt(argv, recoveryQuestion);
-                if (workspace) {
-                    return handleWorkspaceInit(argv, prompter, {
-                        fromPath: 'workspace',
-                        templateRepo: ctx.templateRepo,
-                        branch: ctx.branch,
-                        dir: ctx.dir,
-                        noTty: ctx.noTty,
-                        cwd: ctx.cwd,
-                    });
+            else {
+                // If user explicitly requested module init or we're in non-interactive mode,
+                // just show the error with helpful guidance
+                if (wasExplicitModuleRequest || noTty) {
+                    process.stderr.write(`Not inside a ${workspaceTypeName} workspace.\n`);
+                    throw errors.NOT_IN_WORKSPACE({});
+                }
+                // Offer to create a workspace for pgpm templates or when --dir is specified
+                // (when --dir is specified, we know which workspace variant to use)
+                if (workspaceType === 'pgpm' || ctx.dir) {
+                    const recoveryQuestion = [
+                        {
+                            name: 'workspace',
+                            alias: 'W',
+                            message: `You are not inside a ${workspaceTypeName} workspace. Would you like to create a new workspace instead?`,
+                            type: 'confirm',
+                            required: true,
+                        },
+                    ];
+                    const { workspace } = await prompter.prompt(argv, recoveryQuestion);
+                    if (workspace) {
+                        return handleWorkspaceInit(argv, prompter, {
+                            fromPath: 'workspace',
+                            templateRepo: ctx.templateRepo,
+                            branch: ctx.branch,
+                            dir: ctx.dir,
+                            noTty: ctx.noTty,
+                            cwd: ctx.cwd,
+                        });
+                    }
                 }
+                // User declined or non-pgpm workspace type without --dir, show the error
+                process.stderr.write(`Not inside a ${workspaceTypeName} workspace.\n`);
+                throw errors.NOT_IN_WORKSPACE({});
             }
-            // User declined or non-pgpm workspace type, show the error
-            process.stderr.write(`Not inside a ${workspaceTypeName} workspace.\n`);
-            throw errors.NOT_IN_WORKSPACE({});
         }
     }
     // Only check workspace directory constraints if we're in a workspace
@@ -327,7 +421,7 @@ async function handleModuleInit(argv, prompter, ctx, wasExplicitModuleRequest =
     // Determine output path based on whether we're in a workspace
     let modulePath;
     if (project.workspacePath) {
-        // Use workspace-aware initModule
+        // PGPM workspace - use workspace-aware initModule
         await project.initModule({
             name: modName,
             description: answers.description || modName,
@@ -347,8 +441,28 @@ async function handleModuleInit(argv, prompter, ctx, wasExplicitModuleRequest =
             ? path.join(ctx.cwd, 'packages', modName)
             : path.join(ctx.cwd, modName);
     }
+    else if (resolvedWorkspacePath && workspaceType !== false) {
+        // Non-pgpm workspace (pnpm, lerna, npm) - scaffold to packages/ directory
+        const isRoot = path.resolve(resolvedWorkspacePath) === path.resolve(ctx.cwd);
+        modulePath = isRoot
+            ? path.join(ctx.cwd, 'packages', modName)
+            : path.join(ctx.cwd, modName);
+        fs.mkdirSync(modulePath, { recursive: true });
+        await scaffoldTemplate({
+            fromPath: ctx.fromPath,
+            outputDir: modulePath,
+            templateRepo: ctx.templateRepo,
+            branch: ctx.branch,
+            dir: ctx.dir,
+            answers: templateAnswers,
+            noTty: ctx.noTty,
+            toolName: DEFAULT_TEMPLATE_TOOL_NAME,
+            cwd: ctx.cwd,
+            prompter
+        });
+    }
     else {
-        // Not in a workspace - scaffold directly to current directory
+        // Not in any workspace (requiresWorkspace: false) - scaffold to current directory
         modulePath = path.join(ctx.cwd, modName);
         fs.mkdirSync(modulePath, { recursive: true });
         await scaffoldTemplate({

package/esm/commands/init/workspace.js

@@ -23,15 +23,16 @@ export default async function runWorkspaceSetup(argv, prompter) {
     // Prevent double-echoed keystrokes by closing our prompter before template prompts.
     prompter.close();
     const templateRepo = argv.repo ?? DEFAULT_TEMPLATE_REPO;
-    // Don't set default templatePath - let scaffoldTemplate use metadata-driven resolution
-    const templatePath = argv.templatePath;
+    // Don't set default template - let scaffoldTemplate use metadata-driven resolution
+    // Support both --template (new) and --template-path (deprecated) for backward compatibility
+    const template = (argv.template || argv.templatePath);
     // Register workspace.dirname resolver so boilerplate templates can use it via defaultFrom/setFrom
     // This provides the intended workspace directory name before the folder is created
     const dirName = path.basename(targetPath);
     registerDefaultResolver('workspace.dirname', () => dirName);
     const dir = argv.dir;
     await scaffoldTemplate({
-        fromPath: templatePath ?? 'workspace',
+        fromPath: template ?? 'workspace',
         outputDir: targetPath,
         templateRepo,
         branch: argv.fromBranch,

package/esm/index.js

@@ -32,7 +32,12 @@ export const options = {
             v: 'version',
             h: 'help',
             'from-branch': 'fromBranch',
-            'template-path': 'templatePath'
+            // Support both --template and --template-path (deprecated) for backward compatibility
+            'template-path': 'template',
+            t: 'template',
+            // -w for --create-workspace flag
+            w: 'createWorkspace',
+            'create-workspace': 'createWorkspace'
         }
     }
 };

package/index.js

@@ -75,7 +75,12 @@ exports.options = {
             v: 'version',
             h: 'help',
             'from-branch': 'fromBranch',
-            'template-path': 'templatePath'
+            // Support both --template and --template-path (deprecated) for backward compatibility
+            'template-path': 'template',
+            t: 'template',
+            // -w for --create-workspace flag
+            w: 'createWorkspace',
+            'create-workspace': 'createWorkspace'
         }
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgpm",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PostgreSQL Package Manager - Database migration and package management CLI",
   "main": "index.js",
@@ -74,5 +74,5 @@
     "pg",
     "pgsql"
   ],
-  "gitHead": "20d7e992348542531e73f20c0fd084decec86325"
+  "gitHead": "10d6dc9d8f3846c7347272874537702949422a64"
 }