dhurandhar 1.0.0

package/tools/lib/config-manager.js

@@ -0,0 +1,170 @@
+/**
+ * Configuration Manager
+ * Handles loading, saving, and managing YAML-based configuration
+ */
+
+import { join, dirname } from 'path';
+import { existsSync } from 'fs';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import yaml from 'yaml';
+
+export class ConfigManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.configDir = join(projectRoot, '.dhurandhar');
+    this.configPath = join(this.configDir, 'config.yaml');
+  }
+  
+  /**
+   * Check if configuration exists
+   */
+  exists() {
+    return existsSync(this.configPath);
+  }
+  
+  /**
+   * Initialize configuration with user values
+   */
+  async initialize(config) {
+    // Create config directory if it doesn't exist
+    if (!existsSync(this.configDir)) {
+      await mkdir(this.configDir, { recursive: true });
+    }
+    
+    const defaultConfig = {
+      version: '0.1.0',
+      projectName: config.projectName || 'dhurandhar-project',
+      userName: config.userName || 'User',
+      outputFolder: config.outputFolder || '_dhurandhar-output',
+      modules: [],
+      settings: {
+        created: new Date().toISOString(),
+        lastModified: new Date().toISOString(),
+      },
+      variables: {
+        projectRoot: this.projectRoot,
+        configDir: this.configDir,
+      },
+    };
+    
+    await this.save(defaultConfig);
+    return defaultConfig;
+  }
+  
+  /**
+   * Load configuration from file
+   */
+  async load() {
+    if (!this.exists()) {
+      throw new Error('Configuration file not found. Run "dhurandhar install" first.');
+    }
+    
+    const content = await readFile(this.configPath, 'utf-8');
+    const config = yaml.parse(content);
+    
+    // Perform variable substitution
+    return this.substituteVariables(config);
+  }
+  
+  /**
+   * Save configuration to file
+   */
+  async save(config) {
+    const content = yaml.stringify(config, {
+      indent: 2,
+      lineWidth: 0,
+    });
+    
+    await writeFile(this.configPath, content, 'utf-8');
+  }
+  
+  /**
+   * Update configuration
+   */
+  async update(updates) {
+    const config = await this.load();
+    const merged = {
+      ...config,
+      ...updates,
+      settings: {
+        ...config.settings,
+        lastModified: new Date().toISOString(),
+      },
+    };
+    
+    await this.save(merged);
+    return merged;
+  }
+  
+  /**
+   * Reset configuration to defaults
+   */
+  async reset() {
+    return this.initialize({});
+  }
+  
+  /**
+   * Get a configuration value with dot notation
+   * Example: get('settings.created')
+   */
+  async get(path) {
+    const config = await this.load();
+    return this.getNestedValue(config, path);
+  }
+  
+  /**
+   * Set a configuration value with dot notation
+   */
+  async set(path, value) {
+    const config = await this.load();
+    this.setNestedValue(config, path, value);
+    await this.save(config);
+  }
+  
+  /**
+   * Substitute variables in configuration
+   * Supports {variable} syntax
+   */
+  substituteVariables(obj) {
+    if (typeof obj === 'string') {
+      return obj.replace(/\{([^}]+)\}/g, (match, key) => {
+        const value = this.getNestedValue(obj, key);
+        return value !== undefined ? value : match;
+      });
+    }
+    
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.substituteVariables(item));
+    }
+    
+    if (obj !== null && typeof obj === 'object') {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        result[key] = this.substituteVariables(value);
+      }
+      return result;
+    }
+    
+    return obj;
+  }
+  
+  /**
+   * Get nested value from object using dot notation
+   */
+  getNestedValue(obj, path) {
+    return path.split('.').reduce((current, key) => current?.[key], obj);
+  }
+  
+  /**
+   * Set nested value in object using dot notation
+   */
+  setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    const target = keys.reduce((current, key) => {
+      if (!current[key]) current[key] = {};
+      return current[key];
+    }, obj);
+    target[lastKey] = value;
+  }
+}

package/tools/lib/filesystem.js

@@ -0,0 +1,126 @@
+/**
+ * FileSystem Utilities
+ * Helper functions for file system operations
+ */
+
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { mkdir, readdir, stat, readFile, writeFile, rm } from 'fs/promises';
+import { glob } from 'glob';
+
+export class FileSystem {
+  /**
+   * Ensure required directories exist
+   */
+  static async ensureDirectories(projectRoot) {
+    const dirs = [
+      '.dhurandhar',
+      '.dhurandhar/modules',
+      '.dhurandhar/cache',
+      '_dhurandhar-output',
+    ];
+    
+    for (const dir of dirs) {
+      const fullPath = join(projectRoot, dir);
+      if (!existsSync(fullPath)) {
+        await mkdir(fullPath, { recursive: true });
+      }
+    }
+  }
+  
+  /**
+   * Copy directory recursively
+   */
+  static async copyDir(src, dest) {
+    await mkdir(dest, { recursive: true });
+    
+    const entries = await readdir(src, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const srcPath = join(src, entry.name);
+      const destPath = join(dest, entry.name);
+      
+      if (entry.isDirectory()) {
+        await FileSystem.copyDir(srcPath, destPath);
+      } else {
+        const content = await readFile(srcPath);
+        await writeFile(destPath, content);
+      }
+    }
+  }
+  
+  /**
+   * Remove directory recursively
+   */
+  static async removeDir(path) {
+    if (existsSync(path)) {
+      await rm(path, { recursive: true, force: true });
+    }
+  }
+  
+  /**
+   * Find files matching pattern
+   */
+  static async findFiles(pattern, options = {}) {
+    return glob(pattern, {
+      cwd: options.cwd || process.cwd(),
+      ignore: options.ignore || ['node_modules/**', '.git/**'],
+      absolute: options.absolute !== false,
+    });
+  }
+  
+  /**
+   * Read JSON file
+   */
+  static async readJSON(path) {
+    const content = await readFile(path, 'utf-8');
+    return JSON.parse(content);
+  }
+  
+  /**
+   * Write JSON file
+   */
+  static async writeJSON(path, data, options = {}) {
+    const content = JSON.stringify(data, null, options.indent || 2);
+    await writeFile(path, content + '\n', 'utf-8');
+  }
+  
+  /**
+   * Check if path is a directory
+   */
+  static async isDirectory(path) {
+    try {
+      const stats = await stat(path);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  
+  /**
+   * Check if path is a file
+   */
+  static async isFile(path) {
+    try {
+      const stats = await stat(path);
+      return stats.isFile();
+    } catch {
+      return false;
+    }
+  }
+  
+  /**
+   * Get file size
+   */
+  static async getSize(path) {
+    const stats = await stat(path);
+    return stats.size;
+  }
+  
+  /**
+   * Check if file exists
+   */
+  static exists(path) {
+    return existsSync(path);
+  }
+}

package/tools/lib/module-installer.js

@@ -0,0 +1,61 @@
+/**
+ * Module Installer
+ * Handles bulk module installation during framework setup
+ */
+
+import { ModuleManager } from './module-manager.js';
+
+export class ModuleInstaller {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.moduleManager = new ModuleManager(projectRoot);
+  }
+  
+  /**
+   * Install multiple modules
+   */
+  async installModules(moduleCodes) {
+    const results = {
+      installed: [],
+      failed: [],
+    };
+    
+    for (const moduleCode of moduleCodes) {
+      try {
+        await this.moduleManager.install(moduleCode);
+        results.installed.push(moduleCode);
+      } catch (error) {
+        results.failed.push({
+          module: moduleCode,
+          error: error.message,
+        });
+      }
+    }
+    
+    return results;
+  }
+  
+  /**
+   * Uninstall multiple modules
+   */
+  async uninstallModules(moduleCodes) {
+    const results = {
+      uninstalled: [],
+      failed: [],
+    };
+    
+    for (const moduleCode of moduleCodes) {
+      try {
+        await this.moduleManager.uninstall(moduleCode);
+        results.uninstalled.push(moduleCode);
+      } catch (error) {
+        results.failed.push({
+          module: moduleCode,
+          error: error.message,
+        });
+      }
+    }
+    
+    return results;
+  }
+}

package/tools/lib/module-manager.js

@@ -0,0 +1,149 @@
+/**
+ * Module Manager
+ * Handles module discovery, installation, and management
+ */
+
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import yaml from 'yaml';
+import { FileSystem } from './filesystem.js';
+import { ConfigManager } from './config-manager.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export class ModuleManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.configManager = new ConfigManager(projectRoot);
+    this.modulesSourceDir = join(__dirname, '../../src/modules');
+    this.modulesInstallDir = join(projectRoot, '.dhurandhar/modules');
+  }
+  
+  /**
+   * List available modules from source
+   */
+  async listAvailable() {
+    const moduleDirs = await FileSystem.findFiles('*/module.yaml', {
+      cwd: this.modulesSourceDir,
+      absolute: false,
+    });
+    
+    const modules = [];
+    
+    for (const modulePath of moduleDirs) {
+      const moduleDir = dirname(modulePath);
+      const fullPath = join(this.modulesSourceDir, modulePath);
+      
+      try {
+        const content = await readFile(fullPath, 'utf-8');
+        const metadata = yaml.parse(content);
+        
+        modules.push({
+          code: metadata.code || moduleDir,
+          name: metadata.name || moduleDir,
+          description: metadata.description || 'No description available',
+          version: metadata.version || '1.0.0',
+          dependencies: metadata.dependencies || [],
+          path: moduleDir,
+        });
+      } catch (error) {
+        console.warn(`Warning: Could not load module ${moduleDir}:`, error.message);
+      }
+    }
+    
+    return modules;
+  }
+  
+  /**
+   * List installed modules
+   */
+  async listInstalled() {
+    if (!existsSync(this.modulesInstallDir)) {
+      return [];
+    }
+    
+    const moduleDirs = await FileSystem.findFiles('*/module.yaml', {
+      cwd: this.modulesInstallDir,
+      absolute: false,
+    });
+    
+    return moduleDirs.map(path => dirname(path));
+  }
+  
+  /**
+   * Get module information
+   */
+  async getInfo(moduleCode) {
+    const available = await this.listAvailable();
+    return available.find(m => m.code === moduleCode);
+  }
+  
+  /**
+   * Install a module
+   */
+  async install(moduleCode) {
+    const moduleInfo = await this.getInfo(moduleCode);
+    
+    if (!moduleInfo) {
+      throw new Error(`Module "${moduleCode}" not found`);
+    }
+    
+    // Check and install dependencies
+    if (moduleInfo.dependencies && moduleInfo.dependencies.length > 0) {
+      for (const dep of moduleInfo.dependencies) {
+        const isInstalled = (await this.listInstalled()).includes(dep);
+        if (!isInstalled) {
+          await this.install(dep);
+        }
+      }
+    }
+    
+    // Copy module files
+    const sourcePath = join(this.modulesSourceDir, moduleInfo.path);
+    const destPath = join(this.modulesInstallDir, moduleInfo.code);
+    
+    await FileSystem.copyDir(sourcePath, destPath);
+    
+    // Update configuration
+    const config = await this.configManager.load();
+    if (!config.modules.includes(moduleCode)) {
+      config.modules.push(moduleCode);
+      await this.configManager.save(config);
+    }
+  }
+  
+  /**
+   * Uninstall a module
+   */
+  async uninstall(moduleCode) {
+    const destPath = join(this.modulesInstallDir, moduleCode);
+    
+    if (!existsSync(destPath)) {
+      throw new Error(`Module "${moduleCode}" is not installed`);
+    }
+    
+    // Check if other modules depend on this
+    const installed = await this.listInstalled();
+    for (const installedModule of installed) {
+      if (installedModule === moduleCode) continue;
+      
+      const info = await this.getInfo(installedModule);
+      if (info && info.dependencies && info.dependencies.includes(moduleCode)) {
+        throw new Error(
+          `Cannot uninstall "${moduleCode}" because "${installedModule}" depends on it`
+        );
+      }
+    }
+    
+    // Remove module files
+    await FileSystem.removeDir(destPath);
+    
+    // Update configuration
+    const config = await this.configManager.load();
+    config.modules = config.modules.filter(m => m !== moduleCode);
+    await this.configManager.save(config);
+  }
+}