scene-capability-engine 3.0.0

package/lib/repo/repo-manager.js

@@ -0,0 +1,514 @@
+const fs = require('fs').promises;
+const path = require('path');
+const GitOperations = require('./git-operations');
+const PathResolver = require('./path-resolver');
+const RepoError = require('./errors/repo-error');
+
+/**
+ * RepoManager - Orchestrates operations across multiple repositories
+ * 
+ * Provides high-level operations for repository discovery, status checking,
+ * command execution, and health diagnostics across multiple Git repositories.
+ */
+class RepoManager {
+  /**
+   * Create a new RepoManager
+   * @param {string} projectRoot - The project root directory
+   */
+  constructor(projectRoot) {
+    if (!projectRoot) {
+      throw new Error('Project root is required');
+    }
+    this.projectRoot = projectRoot;
+    this.gitOps = new GitOperations();
+    this.pathResolver = new PathResolver();
+  }
+
+  /**
+   * Scan directory for Git repositories
+   * @param {string} rootPath - Root path to scan
+   * @param {Object} options - Scan options
+   * @param {number} options.maxDepth - Maximum depth to scan (default: 3)
+   * @param {string[]} options.exclude - Directories to exclude (default: ['.kiro'])
+   * @param {boolean} options.nested - Enable nested repository scanning (default: true)
+   * @returns {Promise<Array<{path: string, name: string, remote: string|null, branch: string, hasRemote: boolean, parent: string|null}>>}
+   */
+  async discoverRepositories(rootPath, options = {}) {
+    const maxDepth = options.maxDepth || 3;
+    const exclude = options.exclude || ['.kiro'];
+    const nested = options.nested !== false; // Default to true
+    
+    const discovered = [];
+    const visitedPaths = new Set();
+    
+    try {
+      await this._scanDirectory(rootPath, rootPath, 0, maxDepth, exclude, discovered, nested, null, visitedPaths);
+    } catch (error) {
+      throw new RepoError(
+        `Failed to scan directory: ${error.message}`,
+        null,
+        { rootPath, error: error.message }
+      );
+    }
+    
+    return discovered;
+  }
+
+  /**
+   * Check if directory should be skipped during scanning
+   * @private
+   * @param {string} dirName - Directory name
+   * @param {string[]} exclude - User-specified exclusions
+   * @returns {boolean} True if directory should be skipped
+   */
+  _shouldSkipDirectory(dirName, exclude) {
+    // Common non-repository directories to skip
+    const commonExclusions = [
+      'node_modules',
+      '.git',
+      'build',
+      'dist',
+      'target',
+      'out',
+      '.next',
+      '.nuxt',
+      'vendor',
+      '.idea',
+      '.vscode',
+      '__pycache__',
+      '.pytest_cache',
+      'coverage'
+    ];
+    
+    // Skip if in common exclusions
+    if (commonExclusions.includes(dirName)) {
+      return true;
+    }
+    
+    // Skip if in user-specified exclusions
+    if (exclude.includes(dirName)) {
+      return true;
+    }
+    
+    return false;
+  }
+
+  /**
+   * Recursively scan directory for Git repositories
+   * @private
+   * @param {string} currentPath - Current directory path
+   * @param {string} rootPath - Root path for relative path calculation
+   * @param {number} depth - Current depth
+   * @param {number} maxDepth - Maximum depth
+   * @param {string[]} exclude - Directories to exclude
+   * @param {Array} discovered - Array to store discovered repositories
+   * @param {boolean} nested - Enable nested repository scanning
+   * @param {string|null} parentPath - Parent repository path (for nested repos)
+   * @param {Set<string>} visitedPaths - Set of visited paths (for symlink detection)
+   */
+  async _scanDirectory(currentPath, rootPath, depth, maxDepth, exclude, discovered, nested, parentPath, visitedPaths) {
+    // Check depth limit
+    if (depth > maxDepth) {
+      return;
+    }
+
+    // Resolve symlinks and check for circular references
+    try {
+      const realPath = await fs.realpath(currentPath);
+      if (visitedPaths.has(realPath)) {
+        // Skip circular symlink
+        return;
+      }
+      visitedPaths.add(realPath);
+    } catch (error) {
+      // If realpath fails (e.g., in tests with mock fs), use currentPath
+      if (visitedPaths.has(currentPath)) {
+        return;
+      }
+      visitedPaths.add(currentPath);
+    }
+
+    // Check if current directory should be excluded
+    const dirName = path.basename(currentPath);
+    if (this._shouldSkipDirectory(dirName, exclude)) {
+      return;
+    }
+
+    // Check if current directory is a Git repository
+    const isRepo = await this.gitOps.isGitRepo(currentPath);
+    
+    if (isRepo) {
+      // Extract repository information
+      try {
+        const branch = await this.gitOps.getCurrentBranch(currentPath);
+        const remotes = await this.gitOps.getRemotes(currentPath);
+        
+        // Select remote: prefer 'origin', otherwise use first available
+        let remoteUrl = null;
+        let hasRemote = false;
+        
+        if (remotes.length > 0) {
+          hasRemote = true;
+          const originRemote = remotes.find(r => r.name === 'origin');
+          if (originRemote) {
+            remoteUrl = originRemote.refs.fetch;
+          } else {
+            remoteUrl = remotes[0].refs.fetch;
+          }
+        }
+        
+        // Generate repository name from path
+        const relativePath = this.pathResolver.toRelative(currentPath, rootPath);
+        // Handle empty path (root directory) or '.' (current directory)
+        const normalizedPath = (!relativePath || relativePath === '.') ? '.' : relativePath;
+        const repoName = normalizedPath === '.' ? path.basename(rootPath) : normalizedPath.replace(/\//g, '-');
+        
+        discovered.push({
+          path: normalizedPath,
+          name: repoName,
+          remote: remoteUrl,
+          branch: branch,
+          hasRemote: hasRemote,
+          parent: parentPath // Track parent repository
+        });
+        
+        // If nested scanning is disabled, don't scan subdirectories
+        if (!nested) {
+          return;
+        }
+        
+        // If nested scanning is enabled, continue scanning subdirectories
+        // Update parentPath to current repository for nested repos
+        parentPath = relativePath;
+      } catch (error) {
+        // If we can't get repo info, skip this directory
+        return;
+      }
+    }
+
+    // Scan subdirectories
+    try {
+      const entries = await fs.readdir(currentPath, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const subPath = path.join(currentPath, entry.name);
+          await this._scanDirectory(subPath, rootPath, depth + 1, maxDepth, exclude, discovered, nested, parentPath, visitedPaths);
+        }
+      }
+    } catch (error) {
+      // If we can't read the directory, skip it
+      return;
+    }
+  }
+
+  /**
+   * Get status for a single repository
+   * @param {Object} repo - Repository configuration
+   * @param {string} repo.name - Repository name
+   * @param {string} repo.path - Repository path
+   * @returns {Promise<Object>} Repository status
+   */
+  async getRepoStatus(repo) {
+    const repoPath = this.pathResolver.resolvePath(repo.path, this.projectRoot);
+    
+    try {
+      // Check if path exists
+      try {
+        await fs.access(repoPath);
+      } catch (error) {
+        return {
+          name: repo.name,
+          path: repo.path,
+          branch: null,
+          isClean: false,
+          modified: 0,
+          added: 0,
+          deleted: 0,
+          ahead: 0,
+          behind: 0,
+          error: 'Path not found or inaccessible'
+        };
+      }
+
+      // Check if it's a Git repository
+      const isRepo = await this.gitOps.isGitRepo(repoPath);
+      if (!isRepo) {
+        return {
+          name: repo.name,
+          path: repo.path,
+          branch: null,
+          isClean: false,
+          modified: 0,
+          added: 0,
+          deleted: 0,
+          ahead: 0,
+          behind: 0,
+          error: 'Not a Git repository'
+        };
+      }
+
+      // Get status
+      const status = await this.gitOps.getStatus(repoPath);
+      
+      return {
+        name: repo.name,
+        path: repo.path,
+        branch: status.current,
+        isClean: status.isClean(),
+        modified: status.modified.length,
+        added: status.created.length,
+        deleted: status.deleted.length,
+        ahead: status.ahead,
+        behind: status.behind,
+        error: null
+      };
+    } catch (error) {
+      return {
+        name: repo.name,
+        path: repo.path,
+        branch: null,
+        isClean: false,
+        modified: 0,
+        added: 0,
+        deleted: 0,
+        ahead: 0,
+        behind: 0,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get status for all repositories
+   * @param {Array<Object>} repos - Array of repository configurations
+   * @returns {Promise<Array<Object>>} Array of repository statuses
+   */
+  async getAllRepoStatuses(repos) {
+    const statuses = [];
+    
+    for (const repo of repos) {
+      const status = await this.getRepoStatus(repo);
+      statuses.push(status);
+    }
+    
+    return statuses;
+  }
+
+  /**
+   * Execute command in a repository
+   * @param {Object} repo - Repository configuration
+   * @param {string} command - Git command to execute (without 'git' prefix)
+   * @returns {Promise<Object>} Execution result
+   */
+  async execInRepo(repo, command) {
+    const repoPath = this.pathResolver.resolvePath(repo.path, this.projectRoot);
+    
+    try {
+      // Check if path exists and is a Git repository
+      try {
+        await fs.access(repoPath);
+      } catch (error) {
+        return {
+          name: repo.name,
+          path: repo.path,
+          command: command,
+          success: false,
+          output: '',
+          error: 'Path not found or inaccessible',
+          exitCode: 1
+        };
+      }
+
+      const isRepo = await this.gitOps.isGitRepo(repoPath);
+      if (!isRepo) {
+        return {
+          name: repo.name,
+          path: repo.path,
+          command: command,
+          success: false,
+          output: '',
+          error: 'Not a Git repository',
+          exitCode: 1
+        };
+      }
+
+      // Parse command into arguments
+      // Check if command already starts with "git" to avoid duplication
+      const trimmedCommand = command.trim();
+      const args = trimmedCommand.startsWith('git ')
+        ? trimmedCommand.substring(4).trim().split(/\s+/)
+        : trimmedCommand.split(/\s+/);
+      
+      // Execute command
+      const output = await this.gitOps.execRaw(repoPath, args);
+      
+      return {
+        name: repo.name,
+        path: repo.path,
+        command: command,
+        success: true,
+        output: output.trim(),
+        error: null,
+        exitCode: 0
+      };
+    } catch (error) {
+      return {
+        name: repo.name,
+        path: repo.path,
+        command: command,
+        success: false,
+        output: '',
+        error: error.message,
+        exitCode: error.exitCode || 1
+      };
+    }
+  }
+
+  /**
+   * Execute command in all repositories
+   * @param {Array<Object>} repos - Array of repository configurations
+   * @param {string} command - Git command to execute
+   * @returns {Promise<Array<Object>>} Array of execution results
+   */
+  async execInAllRepos(repos, command) {
+    const results = [];
+    
+    for (const repo of repos) {
+      const result = await this.execInRepo(repo, command);
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Perform health check on a repository
+   * @param {Object} repo - Repository configuration
+   * @param {string} repo.name - Repository name
+   * @param {string} repo.path - Repository path
+   * @param {string} [repo.remote] - Remote URL
+   * @param {string} [repo.defaultBranch] - Default branch name
+   * @returns {Promise<Object>} Health check result
+   */
+  async checkRepoHealth(repo) {
+    const repoPath = this.pathResolver.resolvePath(repo.path, this.projectRoot);
+    const checks = {
+      pathExists: false,
+      isGitRepo: false,
+      remoteReachable: null,
+      branchExists: null
+    };
+    const errors = [];
+    const warnings = [];
+
+    // Check 1: Path exists
+    try {
+      await fs.access(repoPath);
+      checks.pathExists = true;
+    } catch (error) {
+      errors.push(`Path does not exist or is not accessible: ${repo.path}`);
+      return {
+        name: repo.name,
+        path: repo.path,
+        checks,
+        errors,
+        warnings,
+        healthy: false
+      };
+    }
+
+    // Check 2: Is Git repository
+    try {
+      checks.isGitRepo = await this.gitOps.isGitRepo(repoPath);
+      if (!checks.isGitRepo) {
+        errors.push(`Path is not a valid Git repository: ${repo.path}`);
+        return {
+          name: repo.name,
+          path: repo.path,
+          checks,
+          errors,
+          warnings,
+          healthy: false
+        };
+      }
+    } catch (error) {
+      errors.push(`Failed to verify Git repository: ${error.message}`);
+      return {
+        name: repo.name,
+        path: repo.path,
+        checks,
+        errors,
+        warnings,
+        healthy: false
+      };
+    }
+
+    // Check 3: Remote reachable (if remote is configured)
+    if (repo.remote) {
+      try {
+        const remotes = await this.gitOps.getRemotes(repoPath);
+        const hasOrigin = remotes.some(r => r.name === 'origin');
+        
+        if (hasOrigin) {
+          checks.remoteReachable = await this.gitOps.isRemoteReachable(repoPath, 'origin');
+          if (!checks.remoteReachable) {
+            warnings.push('Remote "origin" is not reachable (network issue or invalid URL)');
+          }
+        } else {
+          checks.remoteReachable = false;
+          warnings.push('Remote "origin" is not configured');
+        }
+      } catch (error) {
+        checks.remoteReachable = false;
+        warnings.push(`Failed to check remote: ${error.message}`);
+      }
+    }
+
+    // Check 4: Default branch exists (if configured)
+    if (repo.defaultBranch) {
+      try {
+        const currentBranch = await this.gitOps.getCurrentBranch(repoPath);
+        checks.branchExists = currentBranch === repo.defaultBranch;
+        
+        if (!checks.branchExists) {
+          warnings.push(
+            `Current branch "${currentBranch}" differs from configured default branch "${repo.defaultBranch}"`
+          );
+        }
+      } catch (error) {
+        checks.branchExists = false;
+        warnings.push(`Failed to check branch: ${error.message}`);
+      }
+    }
+
+    const healthy = errors.length === 0;
+
+    return {
+      name: repo.name,
+      path: repo.path,
+      checks,
+      errors,
+      warnings,
+      healthy
+    };
+  }
+
+  /**
+   * Perform health check on all repositories
+   * @param {Array<Object>} repos - Array of repository configurations
+   * @returns {Promise<Array<Object>>} Array of health check results
+   */
+  async checkAllReposHealth(repos) {
+    const results = [];
+    
+    for (const repo of repos) {
+      const result = await this.checkRepoHealth(repo);
+      results.push(result);
+    }
+    
+    return results;
+  }
+}
+
+module.exports = RepoManager;

package/lib/scene-runtime/audit-emitter.js

@@ -0,0 +1,59 @@
+const fs = require('fs-extra');
+const path = require('path');
+const crypto = require('crypto');
+
+function createId(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+class AuditEmitter {
+  constructor(projectRoot = process.cwd(), options = {}) {
+    this.projectRoot = projectRoot;
+    this.auditFile = options.auditFile || path.join(projectRoot, '.kiro', 'audit', 'scene-runtime-events.jsonl');
+  }
+
+  async emit(eventType, payload = {}) {
+    const event = {
+      event_id: createId('srevt'),
+      event_type: eventType,
+      timestamp: new Date().toISOString(),
+      trace_id: payload.trace_id || payload.traceId || createId('trace'),
+      scene_ref: payload.scene_ref || payload.sceneRef || null,
+      scene_version: payload.scene_version || payload.sceneVersion || null,
+      run_mode: payload.run_mode || payload.runMode || null,
+      actor: payload.actor || 'kse.scene-runtime',
+      payload: payload.payload || payload
+    };
+
+    event.checksum = this.calculateChecksum(event);
+
+    await fs.ensureDir(path.dirname(this.auditFile));
+    await fs.appendFile(this.auditFile, `${JSON.stringify(event)}\n`, 'utf8');
+
+    return event;
+  }
+
+  calculateChecksum(event) {
+    const { checksum, ...rest } = event;
+    return crypto.createHash('sha256').update(JSON.stringify(rest)).digest('hex');
+  }
+
+  verifyEvent(event) {
+    return this.calculateChecksum(event) === event.checksum;
+  }
+
+  async readAll() {
+    if (!await fs.pathExists(this.auditFile)) {
+      return [];
+    }
+
+    const content = await fs.readFile(this.auditFile, 'utf8');
+    return content
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  }
+}
+
+module.exports = AuditEmitter;