scm-method 1.0.0

package/tools/installer/custom-handler.js

@@ -0,0 +1,112 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('yaml');
+const prompts = require('./prompts');
+/**
+ * Handler for custom content (custom.yaml)
+ * Discovers custom agents and workflows in the project
+ */
+class CustomHandler {
+  /**
+   * Find all custom.yaml files in the project
+   * @param {string} projectRoot - Project root directory
+   * @returns {Array} List of custom content paths
+   */
+  async findCustomContent(projectRoot) {
+    const customPaths = [];
+
+    // Helper function to recursively scan directories
+    async function scanDirectory(dir, excludePaths = []) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+
+          // Skip hidden directories and common exclusions
+          if (
+            entry.name.startsWith('.') ||
+            entry.name === 'node_modules' ||
+            entry.name === 'dist' ||
+            entry.name === 'build' ||
+            entry.name === '.git' ||
+            entry.name === 'scm'
+          ) {
+            continue;
+          }
+
+          // Skip excluded paths
+          if (excludePaths.some((exclude) => fullPath.startsWith(exclude))) {
+            continue;
+          }
+
+          if (entry.isDirectory()) {
+            // Recursively scan subdirectories
+            await scanDirectory(fullPath, excludePaths);
+          } else if (entry.name === 'custom.yaml') {
+            // Found a custom.yaml file
+            customPaths.push(fullPath);
+          } else if (
+            entry.name === 'module.yaml' && // Check if this is a custom module (in root directory)
+            // Skip if it's in src/modules (those are standard modules)
+            !fullPath.includes(path.join('src', 'modules'))
+          ) {
+            customPaths.push(fullPath);
+          }
+        }
+      } catch {
+        // Ignore errors (e.g., permission denied)
+      }
+    }
+
+    // Scan the entire project, but exclude source directories
+    await scanDirectory(projectRoot, [path.join(projectRoot, 'src'), path.join(projectRoot, 'tools'), path.join(projectRoot, 'test')]);
+
+    return customPaths;
+  }
+
+  /**
+   * Get custom content info from a custom.yaml or module.yaml file
+   * @param {string} configPath - Path to config file
+   * @param {string} projectRoot - Project root directory for calculating relative paths
+   * @returns {Object|null} Custom content info
+   */
+  async getCustomInfo(configPath, projectRoot = null) {
+    try {
+      const configContent = await fs.readFile(configPath, 'utf8');
+
+      // Try to parse YAML with error handling
+      let config;
+      try {
+        config = yaml.parse(configContent);
+      } catch (parseError) {
+        await prompts.log.warn('YAML parse error in ' + configPath + ': ' + parseError.message);
+        return null;
+      }
+
+      // Check if this is an module.yaml (module) or custom.yaml (custom content)
+      const isInstallConfig = configPath.endsWith('module.yaml');
+      const configDir = path.dirname(configPath);
+
+      // Use provided projectRoot or fall back to process.cwd()
+      const basePath = projectRoot || process.cwd();
+      const relativePath = path.relative(basePath, configDir);
+
+      return {
+        id: config.code || 'unknown-code',
+        name: config.name,
+        description: config.description || '',
+        path: configDir,
+        relativePath: relativePath,
+        defaultSelected: config.default_selected === true,
+        config: config,
+        isInstallConfig: isInstallConfig, // Track which type this is
+      };
+    } catch (error) {
+      await prompts.log.warn('Failed to read ' + configPath + ': ' + error.message);
+      return null;
+    }
+  }
+}
+
+module.exports = { CustomHandler };

package/tools/installer/external-official-modules.yaml

@@ -0,0 +1,63 @@
+# This file allows these modules under scm-code-org to also be installed with the scm method installer, while
+# allowing us to keep the source of these projects in separate repos.
+
+modules:
+  scm-builder:
+    url: https://github.com/TON-COMPTE/scm-builder
+    module-definition: skills/module.yaml
+    code: scmb
+    name: "SCM Builder"
+    description: "Créateur d'agents et de workflows personnalisés"
+    defaultSelected: false
+    type: scm-org
+    npmPackage: scm-builder
+
+  scm-finance-suite:
+    url: https://github.com/TON-COMPTE/scm-module-finance
+    module-definition: src/module.yaml
+    code: fin
+    name: "SCM Finance Suite"
+    description: "Agents spécialisés Finance et Comptabilité"
+    defaultSelected: false
+    type: scm-org
+    npmPackage: scm-finance-suite
+
+  scm-education-studio:
+    url: https://github.com/TON-COMPTE/scm-module-education
+    module-definition: src/module.yaml
+    code: edu
+    name: "SCM Education Studio"
+    description: "Agents Création de cours, Évaluation, Syllabus"
+    defaultSelected: false
+    type: scm-org
+    npmPackage: scm-education-studio
+
+  scm-creative-suite:
+    url: https://github.com/TON-COMPTE/scm-module-creative
+    module-definition: src/module.yaml
+    code: cre
+    name: "SCM Creative Suite"
+    description: "Agents créatifs pour copywriting, branding et contenu"
+    defaultSelected: false
+    type: scm-org
+    npmPackage: scm-creative-suite
+
+  scm-game-dev:
+    url: https://github.com/TON-COMPTE/scm-module-gamedev
+    module-definition: src/module.yaml
+    code: gam
+    name: "SCM Game Dev Studio"
+    description: "Agents développement de jeux vidéo"
+    defaultSelected: false
+    type: scm-org
+    npmPackage: scm-game-dev
+
+  scm-test-architect:
+    url: https://github.com/TON-COMPTE/scm-module-qa
+    module-definition: src/module.yaml
+    code: qa
+    name: "SCM Test Architect"
+    description: "Stratégie qualité, automatisation des tests, release gates"
+    defaultSelected: false
+    type: scm-org
+    npmPackage: scm-test-architect

package/tools/installer/file-ops.js

@@ -0,0 +1,204 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+/**
+ * File operations utility class
+ */
+class FileOps {
+  /**
+   * Copy a directory recursively
+   * @param {string} source - Source directory
+   * @param {string} dest - Destination directory
+   * @param {Object} options - Copy options
+   */
+  async copyDirectory(source, dest, options = {}) {
+    const defaultOptions = {
+      overwrite: true,
+      errorOnExist: false,
+      filter: (src) => !this.shouldIgnore(src),
+    };
+
+    const copyOptions = { ...defaultOptions, ...options };
+    await fs.copy(source, dest, copyOptions);
+  }
+
+  /**
+   * Sync directory (selective copy preserving modifications)
+   * @param {string} source - Source directory
+   * @param {string} dest - Destination directory
+   */
+  async syncDirectory(source, dest) {
+    const sourceFiles = await this.getFileList(source);
+
+    for (const file of sourceFiles) {
+      const sourceFile = path.join(source, file);
+      const destFile = path.join(dest, file);
+
+      // Check if destination file exists
+      if (await fs.pathExists(destFile)) {
+        // Compare checksums to see if file has been modified
+        const sourceHash = await this.getFileHash(sourceFile);
+        const destHash = await this.getFileHash(destFile);
+
+        if (sourceHash === destHash) {
+          // Files are identical, safe to update
+          await fs.copy(sourceFile, destFile, { overwrite: true });
+        } else {
+          // File has been modified, check timestamps
+          const sourceStats = await fs.stat(sourceFile);
+          const destStats = await fs.stat(destFile);
+
+          if (sourceStats.mtime > destStats.mtime) {
+            // Source is newer, update
+            await fs.copy(sourceFile, destFile, { overwrite: true });
+          }
+          // Otherwise, preserve user modifications
+        }
+      } else {
+        // New file, copy it
+        await fs.ensureDir(path.dirname(destFile));
+        await fs.copy(sourceFile, destFile);
+      }
+    }
+
+    // Remove files that no longer exist in source
+    const destFiles = await this.getFileList(dest);
+    for (const file of destFiles) {
+      const sourceFile = path.join(source, file);
+      const destFile = path.join(dest, file);
+
+      if (!(await fs.pathExists(sourceFile))) {
+        await fs.remove(destFile);
+      }
+    }
+  }
+
+  /**
+   * Get list of all files in a directory
+   * @param {string} dir - Directory path
+   * @returns {Array} List of relative file paths
+   */
+  async getFileList(dir) {
+    const files = [];
+
+    if (!(await fs.pathExists(dir))) {
+      return files;
+    }
+
+    const walk = async (currentDir, baseDir) => {
+      const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+
+        if (entry.isDirectory() && !this.shouldIgnore(fullPath)) {
+          await walk(fullPath, baseDir);
+        } else if (entry.isFile() && !this.shouldIgnore(fullPath)) {
+          files.push(path.relative(baseDir, fullPath));
+        }
+      }
+    };
+
+    await walk(dir, dir);
+    return files;
+  }
+
+  /**
+   * Get file hash for comparison
+   * @param {string} filePath - File path
+   * @returns {string} File hash
+   */
+  async getFileHash(filePath) {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+
+    return new Promise((resolve, reject) => {
+      stream.on('data', (data) => hash.update(data));
+      stream.on('end', () => resolve(hash.digest('hex')));
+      stream.on('error', reject);
+    });
+  }
+
+  /**
+   * Check if a path should be ignored
+   * @param {string} filePath - Path to check
+   * @returns {boolean} True if should be ignored
+   */
+  shouldIgnore(filePath) {
+    const ignoredPatterns = ['.git', '.DS_Store', 'node_modules', '*.swp', '*.tmp', '.idea', '.vscode', '__pycache__', '*.pyc'];
+
+    const basename = path.basename(filePath);
+
+    for (const pattern of ignoredPatterns) {
+      if (pattern.includes('*')) {
+        // Simple glob pattern matching
+        const regex = new RegExp(pattern.replace('*', '.*'));
+        if (regex.test(basename)) {
+          return true;
+        }
+      } else if (basename === pattern) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Ensure directory exists
+   * @param {string} dir - Directory path
+   */
+  async ensureDir(dir) {
+    await fs.ensureDir(dir);
+  }
+
+  /**
+   * Remove directory or file
+   * @param {string} targetPath - Path to remove
+   */
+  async remove(targetPath) {
+    if (await fs.pathExists(targetPath)) {
+      await fs.remove(targetPath);
+    }
+  }
+
+  /**
+   * Read file content
+   * @param {string} filePath - File path
+   * @returns {string} File content
+   */
+  async readFile(filePath) {
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  /**
+   * Write file content
+   * @param {string} filePath - File path
+   * @param {string} content - File content
+   */
+  async writeFile(filePath, content) {
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  /**
+   * Check if path exists
+   * @param {string} targetPath - Path to check
+   * @returns {boolean} True if exists
+   */
+  async exists(targetPath) {
+    return await fs.pathExists(targetPath);
+  }
+
+  /**
+   * Get file or directory stats
+   * @param {string} targetPath - Path to check
+   * @returns {Object} File stats
+   */
+  async stat(targetPath) {
+    return await fs.stat(targetPath);
+  }
+}
+
+module.exports = { FileOps };