@djangocfg/ext-base 1.0.2 → 1.0.4

package/dist/index.js

@@ -0,0 +1,3 @@
+export { EXTENSION_CATEGORIES, createExtensionConfig, createExtensionError, createExtensionLogger, extensionConfig, formatErrorMessage, handleExtensionError, isExtensionError } from './chunk-UXTBBEO5.js';
+export { createExtensionAPI, getApiUrl, getSharedAuthStorage, isDevelopment, isProduction, isStaticBuild } from './chunk-VJEGYVBV.js';
+import './chunk-3RG5ZIWI.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djangocfg/ext-base",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Base utilities and common code for DjangoCFG extensions",
   "keywords": [
     "django",
@@ -15,7 +15,7 @@
     "name": "DjangoCFG",
     "url": "https://djangocfg.com"
   },
-  "homepage": "https://djangocfg.com",
+  "homepage": "https://hub.djangocfg.com/extensions/djangocfg-ext-base",
   "repository": {
     "type": "git",
     "url": "https://github.com/markolofsen/django-cfg.git",
@@ -64,8 +64,11 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "check": "tsc --noEmit",
+    "test": "tsx src/cli/index.ts test",
     "cli": "tsx src/cli/index.ts",
     "cli:help": "tsx src/cli/index.ts --help",
+    "cli:create": "tsx src/cli/index.ts create",
+    "cli:test": "tsx src/cli/index.ts test",
     "cli:list": "tsx src/cli/index.ts list",
     "cli:info": "tsx src/cli/index.ts info"
   },

package/src/cli/index.ts

@@ -10,6 +10,7 @@ import prompts from 'prompts';
 import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
 import { EXTENSION_CATEGORIES } from '../types/context';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -28,6 +29,7 @@ function getVersion(): string {
 // CLI Commands
 const COMMANDS = {
   create: 'Create a new DjangoCFG extension',
+  test: 'Quick create test extension (no prompts)',
   help: 'Show help',
   '--help': 'Show help',
   '-h': 'Show help',
@@ -92,6 +94,80 @@ function printBanner() {
   console.log();
 }
 
+// Check if package exists on npm
+async function checkPackageExists(packageName: string): Promise<boolean> {
+  try {
+    const encodedName = encodeURIComponent(packageName);
+    const response = await fetch(`https://registry.npmjs.org/${encodedName}`);
+    return response.status === 200;
+  } catch {
+    // Network error or other issue - allow creation
+    return false;
+  }
+}
+
+// Check if extension directory already exists (case-insensitive)
+function checkDirectoryExists(packageName: string): { exists: boolean; path?: string } {
+  // Generate directory name from package name
+  const extDirName = packageName.replace('@', '').replace('/', '-');
+
+  // Determine base directory
+  const isInExtBase = process.cwd().endsWith('ext-base');
+  const baseDir = isInExtBase
+    ? join(process.cwd(), '..')
+    : join(process.cwd(), 'extensions');
+
+  const extDir = join(baseDir, extDirName);
+
+  // Check exact match first
+  if (existsSync(extDir)) {
+    return { exists: true, path: extDir };
+  }
+
+  // Check case-insensitive match (important for macOS)
+  try {
+    const files = readdirSync(baseDir);
+    const lowerCaseName = extDirName.toLowerCase();
+
+    for (const file of files) {
+      if (file.toLowerCase() === lowerCaseName) {
+        const fullPath = join(baseDir, file);
+        const stats = statSync(fullPath);
+        if (stats.isDirectory()) {
+          return { exists: true, path: fullPath };
+        }
+      }
+    }
+  } catch {
+    // If we can't read directory, assume it doesn't exist
+    return { exists: false };
+  }
+
+  return { exists: false };
+}
+
+// Detect available package manager
+function detectPackageManager(): string | null {
+  const managers = ['pnpm', 'yarn', 'npm'];
+
+  for (const manager of managers) {
+    try {
+      const result = execSync(`${manager} --version`, {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+      if (result) {
+        return manager;
+      }
+    } catch {
+      // Manager not available, try next
+      continue;
+    }
+  }
+
+  return null;
+}
+
 // Print help
 function printHelp() {
   printBanner();
@@ -118,23 +194,65 @@ async function createExtension() {
   console.log(chalk.yellow('Create a new DjangoCFG extension'));
   console.log();
 
-  const response = await prompts([
-    {
+  // Step 1: Get and validate package name with npm check
+  let packageName = '';
+  let packageNameValid = false;
+
+  while (!packageNameValid) {
+    const nameResponse = await prompts({
       type: 'text',
-      name: 'name',
-      message: 'Extension name (e.g., "leads", "payments"):',
+      name: 'packageName',
+      message: 'Package name (e.g., "@my-org/my-extension" or "my-extension"):',
       validate: (value: string) => {
-        if (!value) return 'Extension name is required';
-        if (!/^[a-z][a-z0-9-]*$/.test(value)) {
-          return 'Extension name must start with a letter and contain only lowercase letters, numbers, and hyphens';
+        if (!value) return 'Package name is required';
+        const normalized = value.toLowerCase();
+        // Allow @scope/name or just name
+        if (!/^(@[a-zA-Z0-9-]+\/)?[a-zA-Z0-9][a-zA-Z0-9-]*$/.test(normalized)) {
+          return 'Invalid package name format. Use @scope/name or name';
         }
         return true;
       },
-    },
+    });
+
+    if (!nameResponse.packageName) {
+      consola.info('Extension creation cancelled');
+      return;
+    }
+
+    // Always normalize to lowercase (npm requirement)
+    packageName = nameResponse.packageName.toLowerCase();
+
+    // Check if extension directory already exists (case-insensitive)
+    const dirCheck = checkDirectoryExists(packageName);
+    if (dirCheck.exists) {
+      consola.error(`Extension directory already exists: ${chalk.red(dirCheck.path)}`);
+      console.log(chalk.gray('Please try a different name.'));
+      console.log();
+      continue; // Ask again
+    }
+
+    // Check if package already exists on npm
+    consola.start(`Checking if ${chalk.cyan(packageName)} is available on npm...`);
+    const packageExists = await checkPackageExists(packageName);
+
+    if (packageExists) {
+      consola.error(`Package ${chalk.red(packageName)} already exists on npm!`);
+      console.log(chalk.gray('Please try a different name.'));
+      console.log();
+      continue; // Ask again
+    }
+
+    consola.success('Package name is available!');
+    console.log();
+    packageNameValid = true;
+  }
+
+  // Step 2: Get remaining details
+  const response = await prompts([
     {
       type: 'text',
       name: 'displayName',
-      message: 'Display name (e.g., "Leads & Forms"):',
+      message: 'Display name (e.g., "My Extension"):',
       validate: (value: string) => value ? true : 'Display name is required',
     },
     {
@@ -143,12 +261,6 @@ async function createExtension() {
       message: 'Description:',
       validate: (value: string) => value ? true : 'Description is required',
     },
-    {
-      type: 'text',
-      name: 'icon',
-      message: 'Lucide icon name (e.g., "Mail", "CreditCard"):',
-      initial: 'Package',
-    },
     {
       type: 'select',
       name: 'category',
@@ -157,42 +269,81 @@ async function createExtension() {
     },
   ]);
 
-  if (!response.name) {
+  if (!response.displayName) {
     consola.info('Extension creation cancelled');
     return;
   }
 
-  const extName = `ext-${response.name}`;
-  const extDir = join(process.cwd(), 'extensions', extName);
-
-  // Check if extension already exists
-  if (existsSync(extDir)) {
-    consola.error(`Extension already exists: ${extDir}`);
-    return;
+  // Create response with all fields
+  const fullResponse = {
+    ...response,
+    packageName,
+  };
+
+  // Check if we're in djangocfg monorepo (early detection for directory naming)
+  const isInDjangoCfgMonorepo = existsSync(join(process.cwd(), '../../pnpm-workspace.yaml')) &&
+    existsSync(join(process.cwd(), '../../packages/api/package.json'));
+
+  // Generate directory name from package name
+  // In djangocfg monorepo: @djangocfg/demo123a -> demo123a
+  // Outside monorepo: @my-org/my-extension -> my-org-my-extension
+  let extDirName: string;
+  if (isInDjangoCfgMonorepo && fullResponse.packageName.startsWith('@djangocfg/')) {
+    // In djangocfg monorepo, just use the part after the slash
+    extDirName = fullResponse.packageName.split('/')[1];
+  } else {
+    // Outside monorepo or different scope, replace @ and / with -
+    extDirName = fullResponse.packageName.replace('@', '').replace('/', '-');
   }
 
+  // Create extension in parent directory if we're in ext-base
+  const isInExtBase = process.cwd().endsWith('ext-base');
+  const extDir = isInExtBase
+    ? join(process.cwd(), '..', extDirName)
+    : join(process.cwd(), 'extensions', extDirName);
+
   console.log();
-  consola.start(`Creating extension: ${chalk.cyan(`@djangocfg/${extName}`)}`);
+  consola.start(`Creating extension: ${chalk.cyan(fullResponse.packageName)}`);
 
   try {
-    const providerName = response.displayName.replace(/[^a-zA-Z]/g, '');
+    // Convert displayName to PascalCase for provider/component naming
+    // "demo" -> "Demo"
+    // "My Extension" -> "MyExtension"
+    // "my-extension" -> "MyExtension"
+    const providerName = fullResponse.displayName
+      .split(/[\s-_]+/) // Split by spaces, hyphens, underscores
+      .map((word: string) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join('');
+
+    // Extract short name from package name (last part after /)
+    const shortName = fullResponse.packageName.split('/').pop() || fullResponse.packageName.replace('@', '');
+
+    // Generate marketplace ID and links for README
+    const marketplaceId = fullResponse.packageName.replace('@', '').replace('/', '-');
+    const marketplaceLink = `**[📦 View in Marketplace](https://hub.djangocfg.com/extensions/${marketplaceId})** • **[📖 Documentation](https://djangocfg.com)** • **[⭐ GitHub](https://github.com/markolofsen/django-cfg)**`;
 
     // Prepare replacements
     const replacements = {
-      '__NAME__': response.name,
-      '__DISPLAY_NAME__': response.displayName,
-      '__DESCRIPTION__': response.description,
-      '__ICON__': response.icon,
-      '__CATEGORY__': response.category,
+      '__NAME__': shortName,
+      '__PACKAGE_NAME__': fullResponse.packageName,
+      '__DISPLAY_NAME__': fullResponse.displayName,
+      '__DESCRIPTION__': fullResponse.description,
+      '__CATEGORY__': fullResponse.category,
       '__PROVIDER_NAME__': providerName,
+      '__MARKETPLACE_ID__': marketplaceId,
+      '__MARKETPLACE_LINK__': marketplaceLink,
     };
 
     // Find template directory
     const templatePaths = [
-      // When installed from npm
+      // When running from built dist/ (installed from npm)
       join(__dirname, '../templates/extension-template'),
-      // Workspace path (for development)
+      // When running from src/ during development (tsx)
+      join(__dirname, '../../templates/extension-template'),
+      // Workspace path (for development from monorepo root)
       join(process.cwd(), 'extensions', 'ext-base', 'templates', 'extension-template'),
+      // When running from ext-base directory
+      join(process.cwd(), 'templates', 'extension-template'),
     ];
 
     let templateDir: string | null = null;
@@ -212,17 +363,90 @@ async function createExtension() {
     copyTemplateRecursive(templateDir, extDir, replacements);
     consola.success('Extension files created');
 
+    // Replace "latest" with "workspace:*" if in djangocfg monorepo
+    if (isInDjangoCfgMonorepo) {
+      consola.info('Detected djangocfg monorepo - using workspace:* for @djangocfg packages');
+      const pkgJsonPath = join(extDir, 'package.json');
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+
+      // Replace "latest" with "workspace:*" for @djangocfg packages
+      const replaceDeps = (deps?: Record<string, string>) => {
+        if (!deps) return;
+        for (const [key, value] of Object.entries(deps)) {
+          if (key.startsWith('@djangocfg/') && value === 'latest') {
+            deps[key] = 'workspace:*';
+          }
+        }
+      };
+
+      replaceDeps(pkgJson.dependencies);
+      replaceDeps(pkgJson.peerDependencies);
+      replaceDeps(pkgJson.devDependencies);
+
+      writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n', 'utf-8');
+    }
+
     console.log();
+
+    // Auto-install dependencies
+    const packageManager = detectPackageManager();
+    if (packageManager) {
+      consola.start(`Installing dependencies with ${chalk.cyan(packageManager)}...`);
+      try {
+        execSync(`${packageManager} install`, {
+          cwd: extDir,
+          stdio: 'inherit',
+        });
+        consola.success('Dependencies installed successfully');
+        console.log();
+
+        // Install playground dependencies
+        const playgroundDir = join(extDir, 'playground');
+        if (existsSync(playgroundDir)) {
+          consola.start(`Installing playground dependencies with ${chalk.cyan(packageManager)}...`);
+          try {
+            execSync(`${packageManager} install`, {
+              cwd: playgroundDir,
+              stdio: 'inherit',
+            });
+            consola.success('Playground dependencies installed successfully');
+            console.log();
+          } catch (error) {
+            consola.warn(`Failed to install playground dependencies. Please run: ${chalk.cyan(`cd ${extDirName}/playground && ${packageManager} install`)}`);
+            console.log();
+          }
+        }
+
+        // Run type check
+        consola.start('Running type check...');
+        try {
+          execSync(`${packageManager} run check`, {
+            cwd: extDir,
+            stdio: 'inherit',
+          });
+          consola.success('Type check passed');
+        } catch (error) {
+          consola.warn('Type check failed. Please review and fix type errors.');
+        }
+      } catch (error) {
+        consola.warn(`Failed to install dependencies automatically. Please run: ${chalk.cyan(`cd ${extDirName} && ${packageManager} install`)}`);
+      }
+      console.log();
+    } else {
+      consola.warn('No package manager found (pnpm, yarn, or npm). Please install dependencies manually.');
+      console.log();
+    }
+
     consola.success(`Extension created successfully: ${chalk.cyan(extDir)}`);
     console.log();
 
     console.log(chalk.yellow.bold('Next steps:'));
     console.log();
-    console.log(chalk.gray('1. Install dependencies:'));
-    console.log(chalk.cyan(`   cd ${extDir} && pnpm install`));
+    console.log(chalk.gray('1. Navigate to extension directory:'));
+    console.log(chalk.cyan(`   cd ${extDirName}`));
     console.log();
     console.log(chalk.gray('2. Build the extension:'));
-    console.log(chalk.cyan(`   pnpm build`));
+    console.log(chalk.cyan(`   ${packageManager || 'pnpm'} build`));
     console.log();
     console.log(chalk.gray('3. Add your features and customize:'));
     console.log(chalk.cyan(`   - Edit src/config.ts to add features`));
@@ -237,6 +461,213 @@ async function createExtension() {
   }
 }
 
+// Create test extension (no prompts)
+async function createTestExtension() {
+  printBanner();
+
+  // Clean up old test extensions first
+  const isInExtBase = process.cwd().endsWith('ext-base');
+  const baseDir = isInExtBase
+    ? join(process.cwd(), '..')
+    : join(process.cwd(), 'extensions');
+
+  if (existsSync(baseDir)) {
+    const files = readdirSync(baseDir);
+    const testExtensions = files.filter(f => f.startsWith('test-'));
+
+    if (testExtensions.length > 0) {
+      consola.info(`Cleaning up ${testExtensions.length} old test extension(s)...`);
+      for (const testExt of testExtensions) {
+        const testPath = join(baseDir, testExt);
+        try {
+          execSync(`rm -rf "${testPath}"`, { stdio: 'ignore' });
+          consola.success(`Removed ${testExt}`);
+        } catch (error) {
+          consola.warn(`Failed to remove ${testExt}`);
+        }
+      }
+      console.log();
+    }
+  }
+
+  // Generate unique test name
+  const timestamp = Date.now().toString(36);
+  const packageName = `@djangocfg/test-${timestamp}`;
+  const displayName = `Test ${timestamp}`;
+  const description = 'Test extension created for development';
+  const category = 'utilities';
+
+  console.log(chalk.yellow('Quick Test Extension Creation'));
+  console.log();
+  console.log(chalk.cyan(`Package: ${packageName}`));
+  console.log(chalk.cyan(`Name: ${displayName}`));
+  console.log();
+
+  // Check if we're in djangocfg monorepo
+  const isInDjangoCfgMonorepo = existsSync(join(process.cwd(), '../../pnpm-workspace.yaml')) &&
+    existsSync(join(process.cwd(), '../../packages/api/package.json'));
+
+  // Generate directory name from package name
+  const extDirName = packageName.split('/')[1]; // test-xyz
+
+  // Create extension in parent directory if we're in ext-base (reuse from above)
+  const extDir = isInExtBase
+    ? join(process.cwd(), '..', extDirName)
+    : join(process.cwd(), 'extensions', extDirName);
+
+  // Check if already exists
+  if (existsSync(extDir)) {
+    consola.error(`Extension directory already exists: ${chalk.red(extDir)}`);
+    process.exit(1);
+  }
+
+  consola.start(`Creating test extension: ${chalk.cyan(packageName)}`);
+
+  try {
+    // Convert displayName to PascalCase for provider/component naming
+    const providerName = displayName
+      .split(/[\s-_]+/)
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join('');
+
+    // Extract short name from package name
+    const shortName = packageName.split('/').pop() || packageName.replace('@', '');
+
+    // Generate marketplace ID and links for README
+    const marketplaceId = packageName.replace('@', '').replace('/', '-');
+    const marketplaceLink = `**[📦 View in Marketplace](https://hub.djangocfg.com/extensions/${marketplaceId})** • **[📖 Documentation](https://djangocfg.com)** • **[⭐ GitHub](https://github.com/markolofsen/django-cfg)**`;
+
+    // Prepare replacements
+    const replacements = {
+      '__NAME__': shortName,
+      '__PACKAGE_NAME__': packageName,
+      '__DISPLAY_NAME__': displayName,
+      '__DESCRIPTION__': description,
+      '__CATEGORY__': category,
+      '__PROVIDER_NAME__': providerName,
+      '__MARKETPLACE_ID__': marketplaceId,
+      '__MARKETPLACE_LINK__': marketplaceLink,
+    };
+
+    // Find template directory
+    const templatePaths = [
+      join(__dirname, '../templates/extension-template'),
+      join(__dirname, '../../templates/extension-template'),
+      join(process.cwd(), 'extensions', 'ext-base', 'templates', 'extension-template'),
+      join(process.cwd(), 'templates', 'extension-template'),
+    ];
+
+    let templateDir: string | null = null;
+    for (const path of templatePaths) {
+      if (existsSync(path)) {
+        templateDir = path;
+        break;
+      }
+    }
+
+    if (!templateDir) {
+      throw new Error('Extension template not found');
+    }
+
+    // Copy template with replacements
+    consola.start('Copying template files...');
+    copyTemplateRecursive(templateDir, extDir, replacements);
+    consola.success('Extension files created');
+
+    // Replace "latest" with "workspace:*" if in djangocfg monorepo
+    if (isInDjangoCfgMonorepo) {
+      consola.info('Detected djangocfg monorepo - using workspace:* for @djangocfg packages');
+      const pkgJsonPath = join(extDir, 'package.json');
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+
+      const replaceDeps = (deps?: Record<string, string>) => {
+        if (!deps) return;
+        for (const [key, value] of Object.entries(deps)) {
+          if (key.startsWith('@djangocfg/') && value === 'latest') {
+            deps[key] = 'workspace:*';
+          }
+        }
+      };
+
+      replaceDeps(pkgJson.dependencies);
+      replaceDeps(pkgJson.peerDependencies);
+      replaceDeps(pkgJson.devDependencies);
+
+      // Also update playground package.json
+      const playgroundPkgPath = join(extDir, 'playground', 'package.json');
+      if (existsSync(playgroundPkgPath)) {
+        const playgroundPkg = JSON.parse(readFileSync(playgroundPkgPath, 'utf-8'));
+        replaceDeps(playgroundPkg.dependencies);
+        replaceDeps(playgroundPkg.devDependencies);
+        writeFileSync(playgroundPkgPath, JSON.stringify(playgroundPkg, null, 2) + '\n', 'utf-8');
+      }
+
+      writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n', 'utf-8');
+    }
+
+    console.log();
+
+    // Auto-install dependencies
+    const packageManager = detectPackageManager();
+    if (packageManager) {
+      consola.start(`Installing dependencies with ${chalk.cyan(packageManager)}...`);
+      try {
+        execSync(`${packageManager} install`, {
+          cwd: extDir,
+          stdio: 'inherit',
+        });
+        consola.success('Dependencies installed successfully');
+        console.log();
+
+        // Install playground dependencies
+        const playgroundDir = join(extDir, 'playground');
+        if (existsSync(playgroundDir)) {
+          consola.start(`Installing playground dependencies with ${chalk.cyan(packageManager)}...`);
+          try {
+            execSync(`${packageManager} install`, {
+              cwd: playgroundDir,
+              stdio: 'inherit',
+            });
+            consola.success('Playground dependencies installed successfully');
+            console.log();
+          } catch (error) {
+            consola.warn(`Failed to install playground dependencies.`);
+            console.log();
+          }
+        }
+
+        // Run type check
+        consola.start('Running type check...');
+        try {
+          execSync(`${packageManager} run check`, {
+            cwd: extDir,
+            stdio: 'inherit',
+          });
+          consola.success('Type check passed');
+        } catch (error) {
+          consola.warn('Type check failed. Please review and fix type errors.');
+        }
+      } catch (error) {
+        consola.warn(`Failed to install dependencies automatically.`);
+      }
+      console.log();
+    }
+
+    consola.success(`Test extension created: ${chalk.cyan(extDir)}`);
+    console.log();
+
+    console.log(chalk.yellow.bold('Quick commands:'));
+    console.log();
+    console.log(chalk.cyan(`  cd ${extDirName}`));
+    console.log(chalk.cyan(`  pnpm build`));
+    console.log(chalk.cyan(`  pnpm dev:playground`));
+    console.log();
+  } catch (error) {
+    consola.error('Failed to create test extension:', error);
+    process.exit(1);
+  }
+}
+
 // Main CLI
 async function main() {
   const args = process.argv.slice(2);
@@ -254,6 +685,10 @@ async function main() {
       await createExtension();
       break;
 
+    case 'test':
+      await createTestExtension();
+      break;
+
     case 'help':
     case '--help':
     case '-h':