@djangocfg/ext-base 1.0.1 → 1.0.3

package/src/cli/index.ts

@@ -7,9 +7,11 @@
 import { consola } from 'consola';
 import chalk from 'chalk';
 import prompts from 'prompts';
-import { readFileSync } from 'fs';
+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));
 
@@ -26,43 +28,62 @@ function getVersion(): string {
 
 // CLI Commands
 const COMMANDS = {
-  install: 'Install an extension',
-  list: 'List available extensions',
-  info: 'Show extension info',
-  init: 'Initialize extension in your project',
+  create: 'Create a new DjangoCFG extension',
   help: 'Show help',
+  '--help': 'Show help',
+  '-h': 'Show help',
 } as const;
 
 type Command = keyof typeof COMMANDS;
 
-// Available extensions
-const EXTENSIONS = {
-  'ext-leads': {
-    name: '@djangocfg/ext-leads',
-    description: 'Lead management and contact forms',
-    features: ['Contact forms', 'Lead tracking', 'Email integration'],
-  },
-  'ext-payments': {
-    name: '@djangocfg/ext-payments',
-    description: 'Payment processing with multiple providers',
-    features: ['NowPayments', 'Crypto payments', 'Payment tracking'],
-  },
-  'ext-newsletter': {
-    name: '@djangocfg/ext-newsletter',
-    description: 'Newsletter and email campaigns',
-    features: ['Subscription management', 'Email templates', 'Campaign tracking'],
-  },
-  'ext-support': {
-    name: '@djangocfg/ext-support',
-    description: 'Customer support and ticketing',
-    features: ['Ticket system', 'Chat support', 'Knowledge base'],
-  },
-  'ext-knowbase': {
-    name: '@djangocfg/ext-knowbase',
-    description: 'Knowledge base and documentation',
-    features: ['Articles', 'Categories', 'Search', 'Markdown support'],
-  },
-} as const;
+// Template helpers
+function replacePlaceholders(content: string, replacements: Record<string, string>): string {
+  let result = content;
+  for (const [key, value] of Object.entries(replacements)) {
+    result = result.replaceAll(key, value);
+  }
+  return result;
+}
+
+function copyTemplateRecursive(src: string, dest: string, replacements: Record<string, string>) {
+  if (!existsSync(src)) {
+    throw new Error(`Template not found: ${src}`);
+  }
+
+  const stats = statSync(src);
+
+  if (stats.isDirectory()) {
+    // Create destination directory
+    if (!existsSync(dest)) {
+      mkdirSync(dest, { recursive: true });
+    }
+
+    // Copy all files recursively
+    const files = readdirSync(src);
+    for (const file of files) {
+      const srcPath = join(src, file);
+      let destFile = file;
+
+      // Replace __PROVIDER_NAME__ in filenames
+      if (file.includes('__PROVIDER_NAME__')) {
+        destFile = file.replaceAll('__PROVIDER_NAME__', replacements['__PROVIDER_NAME__']);
+      }
+
+      // Remove .template extension
+      if (destFile.endsWith('.template')) {
+        destFile = destFile.slice(0, -9); // Remove '.template'
+      }
+
+      const destPath = join(dest, destFile);
+      copyTemplateRecursive(srcPath, destPath, replacements);
+    }
+  } else {
+    // Copy file with placeholder replacement
+    const content = readFileSync(src, 'utf-8');
+    const replaced = replacePlaceholders(content, replacements);
+    writeFileSync(dest, replaced, 'utf-8');
+  }
+}
 
 // Print banner
 function printBanner() {
@@ -72,6 +93,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();
@@ -87,139 +182,228 @@ function printHelp() {
   console.log();
 
   console.log(chalk.yellow.bold('Examples:'));
-  console.log(`  ${chalk.gray('$')} ${chalk.cyan('djangocfg-ext install')}`);
-  console.log(`  ${chalk.gray('$')} ${chalk.cyan('djangocfg-ext list')}`);
-  console.log(`  ${chalk.gray('$')} ${chalk.cyan('djangocfg-ext info ext-leads')}`);
+  console.log(`  ${chalk.gray('$')} ${chalk.cyan('djangocfg-ext create')}`);
   console.log();
 }
 
-// List extensions
-function listExtensions() {
+// Create new extension
+async function createExtension() {
   printBanner();
-  console.log(chalk.yellow.bold('Available Extensions:'));
-  console.log();
 
-  Object.entries(EXTENSIONS).forEach(([key, ext]) => {
-    console.log(chalk.cyan.bold(`  📦 ${ext.name}`));
-    console.log(chalk.gray(`     ${ext.description}`));
-    console.log(chalk.gray(`     Features: ${ext.features.join(', ')}`));
-    console.log();
-  });
-}
+  console.log(chalk.yellow('Create a new DjangoCFG extension'));
+  console.log();
 
-// Show extension info
-function showInfo(extensionKey: string) {
-  const ext = EXTENSIONS[extensionKey as keyof typeof EXTENSIONS];
+  // Step 1: Get and validate package name with npm check
+  let packageName = '';
+  let packageNameValid = false;
+
+  while (!packageNameValid) {
+    const nameResponse = await prompts({
+      type: 'text',
+      name: 'packageName',
+      message: 'Package name (e.g., "@my-org/my-extension" or "my-extension"):',
+      validate: (value: string) => {
+        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
+    }
 
-  if (!ext) {
-    consola.error(`Extension not found: ${extensionKey}`);
-    consola.info('Run `djangocfg-ext list` to see available extensions');
-    return;
-  }
+    // Check if package already exists on npm
+    consola.start(`Checking if ${chalk.cyan(packageName)} is available on npm...`);
+    const packageExists = await checkPackageExists(packageName);
 
-  printBanner();
-  console.log(chalk.cyan.bold(`📦 ${ext.name}`));
-  console.log();
-  console.log(chalk.white(ext.description));
-  console.log();
-  console.log(chalk.yellow.bold('Features:'));
-  ext.features.forEach(feature => {
-    console.log(chalk.gray(`  • ${feature}`));
-  });
-  console.log();
-  console.log(chalk.yellow.bold('Installation:'));
-  console.log(chalk.gray(`  pnpm add ${ext.name}`));
-  console.log();
-}
+    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
+    }
 
-// Install extension
-async function installExtension() {
-  printBanner();
+    consola.success('Package name is available!');
+    console.log();
+    packageNameValid = true;
+  }
 
-  const response = await prompts({
-    type: 'select',
-    name: 'extension',
-    message: 'Which extension would you like to install?',
-    choices: Object.entries(EXTENSIONS).map(([key, ext]) => ({
-      title: ext.name,
-      description: ext.description,
-      value: key,
-    })),
-  });
+  // Step 2: Get remaining details
+  const response = await prompts([
+    {
+      type: 'text',
+      name: 'displayName',
+      message: 'Display name (e.g., "My Extension"):',
+      validate: (value: string) => value ? true : 'Display name is required',
+    },
+    {
+      type: 'text',
+      name: 'description',
+      message: 'Description:',
+      validate: (value: string) => value ? true : 'Description is required',
+    },
+    {
+      type: 'select',
+      name: 'category',
+      message: 'Category:',
+      choices: EXTENSION_CATEGORIES,
+    },
+  ]);
 
-  if (!response.extension) {
-    consola.info('Installation cancelled');
+  if (!response.displayName) {
+    consola.info('Extension creation cancelled');
     return;
   }
 
-  const ext = EXTENSIONS[response.extension as keyof typeof EXTENSIONS];
+  // Add packageName to response
+  response.packageName = packageName;
 
-  console.log();
-  consola.info(`Installing ${chalk.cyan(ext.name)}...`);
-  console.log();
+  // Generate directory name from package name (replace @ and / with -)
+  // @my-org/my-extension -> my-org-my-extension
+  // my-extension -> my-extension
+  const extDirName = response.packageName.replace('@', '').replace('/', '-');
 
-  // Show installation command
-  console.log(chalk.yellow.bold('Run this command:'));
-  console.log(chalk.cyan(`  pnpm add ${ext.name}`));
-  console.log();
+  // 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(chalk.yellow.bold('Then import in your app:'));
-  console.log(chalk.gray(`  import { ExtensionProvider } from '${ext.name}';`));
   console.log();
+  consola.start(`Creating extension: ${chalk.cyan(response.packageName)}`);
 
-  consola.success('See documentation at https://djangocfg.com/docs');
-}
+  try {
+    // Convert displayName to PascalCase for provider/component naming
+    // "demo" -> "Demo"
+    // "My Extension" -> "MyExtension"
+    // "my-extension" -> "MyExtension"
+    const providerName = response.displayName
+      .split(/[\s-_]+/) // Split by spaces, hyphens, underscores
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join('');
+
+    // Extract short name from package name (last part after /)
+    const shortName = response.packageName.split('/').pop() || response.packageName.replace('@', '');
+
+    // Generate marketplace ID and links for README
+    const marketplaceId = response.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__': response.packageName,
+      '__DISPLAY_NAME__': response.displayName,
+      '__DESCRIPTION__': response.description,
+      '__CATEGORY__': response.category,
+      '__PROVIDER_NAME__': providerName,
+      '__MARKETPLACE_ID__': marketplaceId,
+      '__MARKETPLACE_LINK__': marketplaceLink,
+    };
+
+    // Find template directory
+    const templatePaths = [
+      // When running from built dist/ (installed from npm)
+      join(__dirname, '../templates/extension-template'),
+      // 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;
+    for (const path of templatePaths) {
+      if (existsSync(path)) {
+        templateDir = path;
+        break;
+      }
+    }
 
-// Init extension in project
-async function initExtension() {
-  printBanner();
+    if (!templateDir) {
+      throw new Error('Extension template not found');
+    }
 
-  console.log(chalk.yellow('This will create extension configuration in your project'));
-  console.log();
+    // Copy template with replacements
+    consola.start('Copying template files...');
+    copyTemplateRecursive(templateDir, extDir, replacements);
+    consola.success('Extension files created');
 
-  const response = await prompts([
-    {
-      type: 'select',
-      name: 'extension',
-      message: 'Which extension do you want to configure?',
-      choices: Object.entries(EXTENSIONS).map(([key, ext]) => ({
-        title: ext.name,
-        description: ext.description,
-        value: key,
-      })),
-    },
-    {
-      type: 'confirm',
-      name: 'confirm',
-      message: 'Generate extension configuration?',
-      initial: true,
-    },
-  ]);
-
-  if (!response.confirm) {
-    consola.info('Initialization cancelled');
-    return;
-  }
+    console.log();
 
-  const ext = EXTENSIONS[response.extension as keyof typeof EXTENSIONS];
+    // 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();
+
+        // 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();
+    }
 
-  console.log();
-  consola.info(`Initializing ${chalk.cyan(ext.name)}...`);
-  console.log();
+    consola.success(`Extension created successfully: ${chalk.cyan(extDir)}`);
+    console.log();
 
-  // Show what to do next
-  console.log(chalk.yellow.bold('Next steps:'));
-  console.log(chalk.gray('  1. Install the extension: ') + chalk.cyan(`pnpm add ${ext.name}`));
-  console.log(chalk.gray('  2. Add provider to your layout:'));
-  console.log();
-  console.log(chalk.gray('     ') + chalk.white('import { ExtensionProvider } from \'' + ext.name + '\';'));
-  console.log();
-  console.log(chalk.gray('     ') + chalk.white('<ExtensionProvider>'));
-  console.log(chalk.gray('       ') + chalk.white('{children}'));
-  console.log(chalk.gray('     ') + chalk.white('</ExtensionProvider>'));
-  console.log();
+    console.log(chalk.yellow.bold('Next steps:'));
+    console.log();
+    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(`   ${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`));
+    console.log(chalk.cyan(`   - Add components, hooks, and utilities`));
+    console.log(chalk.cyan(`   - Update README.md with usage examples`));
+    console.log();
 
-  consola.success('Initialization complete!');
+    consola.info('Documentation: https://djangocfg.com/docs');
+  } catch (error) {
+    consola.error('Failed to create extension:', error);
+    process.exit(1);
+  }
 }
 
 // Main CLI
@@ -235,26 +419,8 @@ async function main() {
 
   // Handle commands
   switch (command) {
-    case 'list':
-      listExtensions();
-      break;
-
-    case 'info':
-      const extKey = args[1];
-      if (!extKey) {
-        consola.error('Please specify an extension');
-        consola.info('Example: djangocfg-ext info ext-leads');
-        return;
-      }
-      showInfo(extKey);
-      break;
-
-    case 'install':
-      await installExtension();
-      break;
-
-    case 'init':
-      await initExtension();
+    case 'create':
+      await createExtension();
       break;
 
     case 'help':

package/src/config.ts

@@ -0,0 +1,17 @@
+/**
+ * Extension configuration and environment utilities
+ */
+
+export const isDevelopment = process.env.NODE_ENV === 'development';
+export const isProduction = process.env.NODE_ENV === 'production';
+export const isStaticBuild = process.env.STATIC_BUILD === 'true';
+
+/**
+ * Get API URL from environment or default
+ */
+export function getApiUrl(): string {
+  return process.env.NEXT_PUBLIC_API_URL || '/api';
+}
+
+// Re-export metadata
+export * from './metadata';

package/src/extensionConfig.ts

@@ -0,0 +1,65 @@
+/**
+ * Base extension configuration
+ */
+
+import { createExtensionConfig } from './utils/createExtensionConfig';
+import packageJson from '../package.json';
+
+export const extensionConfig = createExtensionConfig(packageJson, {
+  name: 'base',
+  displayName: 'Extension Base',
+  category: 'utilities',
+  features: [
+    'CLI for creating extensions',
+    'Base utilities and helpers',
+    'Extension context system',
+    'API client utilities',
+    'Logging system',
+    'TypeScript types',
+  ],
+  minVersion: '2.0.0',
+  examples: [
+    {
+      title: 'Create New Extension',
+      description: 'Use CLI to scaffold a new extension',
+      code: `# Install ext-base globally or use via pnpm
+pnpm dlx @djangocfg/ext-base create my-extension
+
+# Choose category, features, and start building`,
+      language: 'bash',
+    },
+    {
+      title: 'Use Extension Context',
+      description: 'Create a context provider for your extension',
+      code: `import { createExtensionContext } from '@djangocfg/ext-base';
+
+export const { ExtensionProvider, useExtension } = createExtensionContext({
+  name: 'my-extension',
+  version: '1.0.0',
+  apiUrl: '/api/my-extension',
+});
+
+// In your app
+export default function App({ children }) {
+  return (
+    <ExtensionProvider>
+      {children}
+    </ExtensionProvider>
+  );
+}`,
+      language: 'tsx',
+    },
+    {
+      title: 'API Client',
+      description: 'Use the API client utilities',
+      code: `import { ApiClient } from '@djangocfg/ext-base';
+
+const client = new ApiClient('/api');
+
+// Make requests
+const data = await client.get('/users');
+const user = await client.post('/users', { name: 'John' });`,
+      language: 'tsx',
+    },
+  ],
+});

package/src/index.ts

@@ -5,8 +5,12 @@
  * Server-safe entry point - can be used in both server and client components.
  */
 
-// Types
+// Types & Constants
 export type * from './types';
+export { EXTENSION_CATEGORIES } from './types/context';
+
+// Extension Config
+export { extensionConfig } from './extensionConfig';
 
 // Config
 export * from './config';