@abhinav2-3/core 0.1.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@abhinav2-3/core",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "ejs": "^3.1.9",
+    "fs-extra": "^11.1.1"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.2",
+    "@types/fs-extra": "^11.0.2",
+    "execa": "^5.0.0",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --watch --dts",
+    "lint": "eslint src/**/*.ts"
+  }
+}

package/src/constants/paths.ts

@@ -0,0 +1,55 @@
+import path from 'path';
+import fs from 'fs-extra';
+
+/**
+ * Resolves the root directory for assets (templates and features).
+ * It looks for these directories in various locations to support both
+ * development (monorepo) and production (installed package).
+ */
+export const getAssetsRoot = (): string => {
+  // 1. Check if environment variable is set
+  if (process.env.MONSTACK_ASSETS_PATH) {
+    return process.env.MONSTACK_ASSETS_PATH;
+  }
+
+  // 2. Try to find relative to __dirname (handles different build outputs)
+  // In dev: packages/core/src/constants -> ../../.. (monorepo root)
+  // In dist: packages/core/dist/constants -> ../../.. (packages/core)
+  
+  const possiblePaths = [
+    // Monorepo root (dev)
+    path.resolve(__dirname, '../../../../'),
+    // Core package root (dist)
+    path.resolve(__dirname, '../../../'),
+    // Current working directory
+    process.cwd(),
+  ];
+
+  for (const root of possiblePaths) {
+    const templatesExists = fs.pathExistsSync(path.join(root, 'templates'));
+    const featuresExists = fs.pathExistsSync(path.join(root, 'features'));
+    
+    // If we are in the monorepo root, templates/features are under packages/
+    const pkgTemplatesExists = fs.pathExistsSync(path.join(root, 'packages/templates'));
+    const pkgFeaturesExists = fs.pathExistsSync(path.join(root, 'packages/features'));
+
+    if (templatesExists && featuresExists) {
+      return root;
+    }
+    
+    if (pkgTemplatesExists && pkgFeaturesExists) {
+      return path.join(root, 'packages');
+    }
+  }
+
+  // Fallback to monorepo dev structure
+  return path.resolve(__dirname, '../../../../packages');
+};
+
+export const getTemplatesPath = (): string => {
+  return path.join(getAssetsRoot(), 'templates');
+};
+
+export const getFeaturesPath = (): string => {
+  return path.join(getAssetsRoot(), 'features');
+};

package/src/environment/index.ts

@@ -0,0 +1,16 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const setupEnvironmentFiles = async (
+  projectPath: string,
+): Promise<void> => {
+  const examplePath = path.join(projectPath, '.env.example');
+  const envPath = path.join(projectPath, '.env');
+
+  if (await fs.pathExists(examplePath)) {
+    console.log(chalk.cyan('📝 Creating .env file...'));
+    await fs.copy(examplePath, envPath);
+    console.log(chalk.green('✅ .env file created.'));
+  }
+};

package/src/features/apply-features.ts

@@ -0,0 +1,171 @@
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { GeneratorConfig, FeatureDependencies } from '../types';
+import { getAllFiles, copyFile } from '../filesystem';
+import {
+  renderTemplate,
+  isTemplateFile,
+  getTargetFileName,
+} from '../template-engine';
+import { resolveFeatures } from './resolver';
+import { getFeatureRegistry } from './registry';
+import { createRequire } from 'module';
+
+// Use a custom require to safely load hooks in both CJS and ESM environments.
+const customRequire =
+  typeof require !== 'undefined'
+    ? require
+    : createRequire(eval('import.meta.url'));
+
+/**
+ * Applies all selected features to the generated project.
+ */
+export const applyFeatures = async (
+  projectPath: string,
+  config: GeneratorConfig,
+  options: {
+    renderData?: Record<string, any>;
+    assetsRoot?: string;
+  } = {},
+): Promise<void> => {
+  const selectedFeatures = resolveFeatures(config);
+
+  if (selectedFeatures.length === 0) return;
+
+  const registry = await getFeatureRegistry();
+  const validation = registry.validateFeatures(
+    selectedFeatures,
+    config.framework,
+    config.architecture,
+    config.database,
+  );
+
+  if (!validation.valid) {
+    console.error(chalk.red('\n❌ Feature validation failed:'));
+    validation.errors.forEach((err) => console.error(chalk.red(`  - ${err}`)));
+    throw new Error('Feature validation failed');
+  }
+
+  console.log(chalk.cyan('\n🧩 Applying features...'));
+
+  for (const featureName of selectedFeatures) {
+    const feature = registry.getFeature(featureName)!;
+    await applySingleFeature(
+      featureName,
+      feature.path,
+      projectPath,
+      config,
+      options.renderData,
+    );
+  }
+};
+
+/**
+ * Applies a single feature to the project.
+ */
+const applySingleFeature = async (
+  featureName: string,
+  featureDir: string,
+  projectPath: string,
+  config: GeneratorConfig,
+  renderData?: Record<string, any>,
+): Promise<void> => {
+  console.log(chalk.blue(`  - Applying ${featureName}...`));
+
+  // 1. Copy Files with EJS rendering support
+  const filesDir = path.join(featureDir, 'files');
+  if (await fs.pathExists(filesDir)) {
+    const files = await getAllFiles(filesDir);
+    for (const file of files) {
+      const relativePath = path.relative(filesDir, file);
+      const targetPath = path.join(
+        projectPath,
+        isTemplateFile(relativePath)
+          ? getTargetFileName(relativePath)
+          : relativePath,
+      );
+
+      // If it's an EJS template, render it
+      if (isTemplateFile(file)) {
+        const templateData = renderData || {};
+        const renderedContent = await renderTemplate(file, templateData);
+        await fs.ensureDir(path.dirname(targetPath));
+        await fs.writeFile(targetPath, renderedContent, 'utf-8');
+      } else {
+        await copyFile(file, targetPath);
+      }
+    }
+  }
+
+  // 2. Merge Dependencies
+  const depFile = path.join(featureDir, 'dependencies.json');
+  if (await fs.pathExists(depFile)) {
+    const deps: FeatureDependencies = await fs.readJson(depFile);
+    await mergeDependencies(projectPath, deps);
+  }
+
+  // 3. Run Post-Apply Hooks
+  // Note: Using a safer way to load hooks for production might be needed later
+  const hookFile = path.join(featureDir, 'index.ts');
+  const hookFileJs = path.join(featureDir, 'index.js');
+
+  let hookModule: any = null;
+
+  if (await fs.pathExists(hookFile)) {
+    try {
+      // In development, use ts-node
+      customRequire('ts-node').register({
+        transpileOnly: true,
+        compilerOptions: {
+          module: 'CommonJS',
+        },
+      });
+      hookModule = customRequire(hookFile);
+    } catch (error) {
+      // Fallback or ignore if ts-node fails
+    }
+  } else if (await fs.pathExists(hookFileJs)) {
+    hookModule = customRequire(hookFileJs);
+  }
+
+  if (hookModule && hookModule.postApply) {
+    try {
+      await hookModule.postApply(projectPath, config);
+    } catch (error) {
+      console.error(
+        chalk.red(`  - Error running postApply hook for ${featureName}:`),
+        error,
+      );
+    }
+  }
+};
+
+/**
+ * Merges feature dependencies into the project's package.json
+ */
+const mergeDependencies = async (
+  projectPath: string,
+  featureDeps: FeatureDependencies,
+): Promise<void> => {
+  const pkgPath = path.join(projectPath, 'package.json');
+  if (!(await fs.pathExists(pkgPath))) return;
+
+  const pkg = await fs.readJson(pkgPath);
+
+  if (featureDeps.dependencies) {
+    pkg.dependencies = {
+      ...(pkg.dependencies || {}),
+      ...featureDeps.dependencies,
+    };
+  }
+
+  if (featureDeps.devDependencies) {
+    pkg.devDependencies = {
+      ...(pkg.devDependencies || {}),
+      ...featureDeps.devDependencies,
+    };
+  }
+
+  await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+};

package/src/features/index.ts

@@ -0,0 +1,3 @@
+export * from './registry';
+export * from './resolver';
+export * from './apply-features';

package/src/features/registry.ts

@@ -0,0 +1,222 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { FeatureMetadata } from '../types';
+import { getFeaturesPath } from '../constants/paths';
+
+export interface RegisteredFeature {
+  name: string;
+  metadata: FeatureMetadata;
+  path: string;
+}
+
+export class FeatureRegistry {
+  private features: Map<string, RegisteredFeature> = new Map();
+  private readonly featuresBaseDir: string;
+
+  constructor() {
+    this.featuresBaseDir = getFeaturesPath();
+  }
+
+  /**
+   * Load and register all available features from the features directory
+   */
+  async discoverFeatures(): Promise<void> {
+    const featuresDir = this.featuresBaseDir;
+
+    if (!(await fs.pathExists(featuresDir))) {
+      console.warn(`Features directory not found at ${featuresDir}`);
+      return;
+    }
+
+    const entries = await fs.readdir(featuresDir);
+
+    for (const entry of entries) {
+      const featurePath = path.join(featuresDir, entry);
+      const stat = await fs.stat(featurePath);
+
+      if (!stat.isDirectory() || entry === 'src') continue;
+
+      await this.registerFeature(entry, featurePath);
+    }
+  }
+
+  /**
+   * Register a single feature by loading its metadata
+   */
+  private async registerFeature(
+    name: string,
+    featurePath: string,
+  ): Promise<void> {
+    const metadataPath = path.join(featurePath, 'metadata.json');
+
+    if (!(await fs.pathExists(metadataPath))) {
+      console.warn(`Metadata not found for feature: ${name}`);
+      return;
+    }
+
+    try {
+      const metadata: FeatureMetadata = await fs.readJson(metadataPath);
+      this.features.set(name, {
+        name,
+        metadata,
+        path: featurePath,
+      });
+    } catch (error) {
+      console.error(`Failed to load metadata for feature ${name}:`, error);
+    }
+  }
+
+  /**
+   * Get a registered feature by name
+   */
+  getFeature(name: string): RegisteredFeature | undefined {
+    return this.features.get(name);
+  }
+
+  /**
+   * Get metadata for a feature
+   */
+  getFeatureMetadata(name: string): FeatureMetadata | undefined {
+    return this.features.get(name)?.metadata;
+  }
+
+  /**
+   * Get path to a feature directory
+   */
+  getFeaturePath(name: string): string | undefined {
+    return this.features.get(name)?.path;
+  }
+
+  /**
+   * Get all registered features
+   */
+  getAllFeatures(): RegisteredFeature[] {
+    return Array.from(this.features.values());
+  }
+
+  /**
+   * Check if a feature is registered
+   */
+  hasFeature(name: string): boolean {
+    return this.features.has(name);
+  }
+
+  /**
+   * Get features that support a specific framework
+   */
+  getFeaturesByFramework(framework: string): RegisteredFeature[] {
+    return Array.from(this.features.values()).filter(
+      (f) =>
+        !f.metadata.frameworks ||
+        f.metadata.frameworks.includes(framework as any),
+    );
+  }
+
+  /**
+   * Get features that support a specific architecture
+   */
+  getFeaturesByArchitecture(architecture: string): RegisteredFeature[] {
+    return Array.from(this.features.values()).filter(
+      (f) =>
+        !f.metadata.architectures ||
+        f.metadata.architectures.includes(architecture as any),
+    );
+  }
+
+  /**
+   * Get features that support a specific database
+   */
+  getFeaturesByDatabase(database: string): RegisteredFeature[] {
+    return Array.from(this.features.values()).filter(
+      (f) =>
+        !f.metadata.databases || f.metadata.databases.includes(database as any),
+    );
+  }
+
+  /**
+   * Get all features compatible with given config
+   */
+  getCompatibleFeatures(
+    framework: string,
+    architecture: string,
+    database: string,
+  ): RegisteredFeature[] {
+    return Array.from(this.features.values()).filter(
+      (f) =>
+        (!f.metadata.frameworks ||
+          f.metadata.frameworks.includes(framework as any)) &&
+        (!f.metadata.architectures ||
+          f.metadata.architectures.includes(architecture as any)) &&
+        (!f.metadata.databases ||
+          f.metadata.databases.includes(database as any)),
+    );
+  }
+
+  /**
+   * Validate that requested features are available and compatible
+   */
+  validateFeatures(
+    featureNames: string[],
+    framework: string,
+    architecture: string,
+    database: string,
+  ): {
+    valid: boolean;
+    errors: string[];
+  } {
+    const errors: string[] = [];
+
+    for (const featureName of featureNames) {
+      const feature = this.getFeature(featureName);
+
+      if (!feature) {
+        errors.push(`Feature "${featureName}" not found in registry`);
+        continue;
+      }
+
+      const { metadata } = feature;
+
+      if (
+        metadata.frameworks &&
+        !metadata.frameworks.includes(framework as any)
+      ) {
+        errors.push(
+          `Feature "${featureName}" does not support framework "${framework}"`,
+        );
+      }
+
+      if (
+        metadata.architectures &&
+        !metadata.architectures.includes(architecture as any)
+      ) {
+        errors.push(
+          `Feature "${featureName}" does not support architecture "${architecture}"`,
+        );
+      }
+
+      if (metadata.databases && !metadata.databases.includes(database as any)) {
+        errors.push(
+          `Feature "${featureName}" does not support database "${database}"`,
+        );
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+}
+
+/**
+ * Create and return a singleton instance of the feature registry
+ */
+let registryInstance: FeatureRegistry | null = null;
+
+export async function getFeatureRegistry(): Promise<FeatureRegistry> {
+  if (!registryInstance) {
+    registryInstance = new FeatureRegistry();
+    await registryInstance.discoverFeatures();
+  }
+  return registryInstance;
+}

package/src/features/resolver.ts

@@ -0,0 +1,19 @@
+import { GeneratorConfig } from '../types';
+
+/**
+ * Resolves selected feature names from the generator configuration.
+ * Currently, it simply returns the features selected by the user.
+ * In the future, this can handle dependencies between features.
+ */
+export const resolveFeatures = (config: GeneratorConfig): string[] => {
+  if (!config.features || config.features.length === 0) {
+    return [];
+  }
+
+  // Filter out 'none' if present
+  const selectedFeatures = config.features.filter(
+    (feature) => feature !== 'none',
+  );
+
+  return [...new Set(selectedFeatures)];
+};

package/src/filesystem/index.ts

@@ -0,0 +1,45 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export const copyFile = async (src: string, dest: string): Promise<void> => {
+  await fs.ensureDir(path.dirname(dest));
+  await fs.copy(src, dest);
+};
+
+export const writeRenderedFile = async (
+  dest: string,
+  content: string,
+): Promise<void> => {
+  await fs.ensureDir(path.dirname(dest));
+  await fs.writeFile(dest, content, 'utf-8');
+};
+
+export const getAllFiles = async (dirPath: string): Promise<string[]> => {
+  const files: string[] = [];
+  const items = await fs.readdir(dirPath, { withFileTypes: true });
+
+  for (const item of items) {
+    const fullPath = path.join(dirPath, item.name);
+    if (item.isDirectory()) {
+      files.push(...(await getAllFiles(fullPath)));
+    } else {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+};
+
+export const exists = async (path: string): Promise<boolean> => {
+  return fs.pathExists(path);
+};
+
+export const replaceInFile = async (
+  filePath: string,
+  searchValue: string | RegExp,
+  replaceValue: string,
+): Promise<void> => {
+  const content = await fs.readFile(filePath, 'utf-8');
+  const updatedContent = content.replace(searchValue, replaceValue);
+  await fs.writeFile(filePath, updatedContent, 'utf-8');
+};

package/src/generator/generateProject.ts

@@ -0,0 +1,91 @@
+import path from 'path';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import { GeneratorConfig } from '../types';
+import { resolveTemplatePath } from '../resolvers/templateResolver';
+import { getAllFiles, writeRenderedFile, copyFile } from '../filesystem';
+import {
+  renderTemplate,
+  isTemplateFile,
+  getTargetFileName,
+} from '../template-engine';
+import { resolveInstaller } from '../installers';
+import { initializeGit } from '../git';
+import { setupEnvironmentFiles } from '../environment';
+import { applyFeatures } from '../features/apply-features';
+
+export interface GeneratorOptions {
+  assetsRoot?: string;
+}
+
+export const generateProject = async (
+  config: GeneratorConfig,
+  options: GeneratorOptions = {},
+): Promise<void> => {
+  const targetDir = path.join(process.cwd(), config.projectName);
+
+  if (await fs.pathExists(targetDir)) {
+    throw new Error(`Target directory ${config.projectName} already exists.`);
+  }
+
+  console.log(chalk.cyan(`\n🏗️ Generating project: ${config.projectName}...`));
+
+  const templatePath = await resolveTemplatePath(config, options.assetsRoot);
+  const files = await getAllFiles(templatePath);
+
+  // Prepare rendering data (UPPERCASE_SNAKE_CASE as per Phase 2)
+  const renderData = {
+    PROJECT_NAME: config.projectName,
+    PORT: 3000, // Default port for now
+    PACKAGE_MANAGER: config.packageManager,
+    NODE_ENV: 'development',
+    DATABASE: config.database,
+    ORM: config.orm,
+  };
+
+  // 1. Generate Files
+  for (const file of files) {
+    const relativePath = path.relative(templatePath, file);
+
+    if (
+      relativePath.includes('node_modules') ||
+      relativePath.includes('dist')
+    ) {
+      continue;
+    }
+
+    const targetFilePath = path.join(
+      targetDir,
+      getTargetFileName(relativePath),
+    );
+
+    if (isTemplateFile(file)) {
+      const renderedContent = await renderTemplate(file, renderData);
+      await writeRenderedFile(targetFilePath, renderedContent);
+    } else {
+      await copyFile(file, targetFilePath);
+    }
+  }
+
+  // 2. Setup Environment Files (.env)
+  await setupEnvironmentFiles(targetDir);
+
+  // 3. Apply Modular Features
+  await applyFeatures(targetDir, config, {
+    renderData,
+    assetsRoot: options.assetsRoot,
+  });
+
+  // 4. Install Dependencies
+  const installer = resolveInstaller(config.packageManager);
+  await installer.install(targetDir);
+
+  // 5. Initialize Git
+  await initializeGit(targetDir);
+
+  console.log(
+    chalk.green(
+      `\n✅ Project ${config.projectName} generated successfully at ${targetDir}`,
+    ),
+  );
+};

package/src/git/index.ts

@@ -0,0 +1,22 @@
+import execa from 'execa';
+import chalk from 'chalk';
+
+export const initializeGit = async (projectPath: string): Promise<void> => {
+  console.log(chalk.cyan('\ngit Initializing git repository...'));
+
+  try {
+    await execa('git', ['init'], { cwd: projectPath });
+    await execa('git', ['add', '.'], { cwd: projectPath });
+    await execa('git', ['commit', '-m', 'Initial commit from MonStack CLI'], {
+      cwd: projectPath,
+    });
+    console.log(chalk.green('✅ Git initialized successfully.'));
+  } catch (error) {
+    console.log(
+      chalk.yellow(
+        '⚠️ Failed to initialize git repository. This is non-blocking.',
+      ),
+    );
+    // Non-blocking as per requirements
+  }
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './generator/generateProject';
+export * from './features';