bmad-fh 6.0.0-alpha.23 → 6.0.0-alpha.23.3b00cb36

package/src/core/lib/scope/event-logger.js

@@ -6,12 +6,12 @@ const { StateLock } = require('./state-lock');
 /**
  * Logs and tracks events across scopes
  * Handles event logging and subscription notifications
- * 
+ *
  * @class EventLogger
  * @requires fs-extra
  * @requires yaml
  * @requires StateLock
- * 
+ *
  * @example
  * const logger = new EventLogger({ projectRoot: '/path/to/project' });
  * await logger.logEvent('artifact_created', 'auth', { artifact: 'prd.md' });
@@ -47,19 +47,19 @@ class EventLogger {
     await fs.ensureDir(this.eventsPath);
 
     // Create event-log.yaml if not exists
-    if (!await fs.pathExists(this.eventLogPath)) {
+    if (!(await fs.pathExists(this.eventLogPath))) {
       const eventLog = {
         version: 1,
-        events: []
+        events: [],
       };
       await fs.writeFile(this.eventLogPath, yaml.stringify(eventLog), 'utf8');
     }
 
     // Create subscriptions.yaml if not exists
-    if (!await fs.pathExists(this.subscriptionsPath)) {
+    if (!(await fs.pathExists(this.subscriptionsPath))) {
       const subscriptions = {
         version: 1,
-        subscriptions: {}
+        subscriptions: {},
       };
       await fs.writeFile(this.subscriptionsPath, yaml.stringify(subscriptions), 'utf8');
     }
@@ -88,7 +88,7 @@ class EventLogger {
       type,
       scope: scopeId,
       timestamp: new Date().toISOString(),
-      data
+      data,
     };
 
     return this.stateLock.withLock(this.eventLogPath, async () => {
@@ -123,23 +123,23 @@ class EventLogger {
 
       // Filter by scope
       if (scopeId) {
-        events = events.filter(e => e.scope === scopeId);
+        events = events.filter((e) => e.scope === scopeId);
       }
 
       // Filter by type
       if (options.type) {
-        events = events.filter(e => e.type === options.type);
+        events = events.filter((e) => e.type === options.type);
       }
 
       // Filter by time range
       if (options.since) {
         const sinceDate = new Date(options.since);
-        events = events.filter(e => new Date(e.timestamp) >= sinceDate);
+        events = events.filter((e) => new Date(e.timestamp) >= sinceDate);
       }
 
       if (options.until) {
         const untilDate = new Date(options.until);
-        events = events.filter(e => new Date(e.timestamp) <= untilDate);
+        events = events.filter((e) => new Date(e.timestamp) <= untilDate);
       }
 
       // Limit results
@@ -169,21 +169,19 @@ class EventLogger {
       if (!subs.subscriptions[subscriberScope]) {
         subs.subscriptions[subscriberScope] = {
           watch: [],
-          notify: true
+          notify: true,
         };
       }
 
       // Add or update watch entry
-      const existingWatch = subs.subscriptions[subscriberScope].watch.find(
-        w => w.scope === watchScope
-      );
+      const existingWatch = subs.subscriptions[subscriberScope].watch.find((w) => w.scope === watchScope);
 
       if (existingWatch) {
         existingWatch.patterns = patterns;
       } else {
         subs.subscriptions[subscriberScope].watch.push({
           scope: watchScope,
-          patterns
+          patterns,
         });
       }
 
@@ -206,8 +204,7 @@ class EventLogger {
       const subs = yaml.parse(content);
 
       if (subs.subscriptions[subscriberScope]) {
-        subs.subscriptions[subscriberScope].watch = 
-          subs.subscriptions[subscriberScope].watch.filter(w => w.scope !== watchScope);
+        subs.subscriptions[subscriberScope].watch = subs.subscriptions[subscriberScope].watch.filter((w) => w.scope !== watchScope);
       }
 
       await fs.writeFile(this.subscriptionsPath, yaml.stringify(subs), 'utf8');
@@ -239,38 +236,34 @@ class EventLogger {
   async getPendingNotifications(scopeId, since = null) {
     try {
       const subs = await this.getSubscriptions(scopeId);
-      
+
       if (!subs.notify || subs.watch.length === 0) {
         return [];
       }
 
       const notifications = [];
-      
+
       for (const watch of subs.watch) {
         const events = await this.getEvents(watch.scope, {
-          since: since || new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString() // Last 24h default
+          since: since || new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(), // Last 24h default
         });
 
         for (const event of events) {
           // Check if event matches any pattern
-          const matches = watch.patterns.some(pattern => 
-            this.matchesPattern(event.data?.artifact, pattern)
-          );
+          const matches = watch.patterns.some((pattern) => this.matchesPattern(event.data?.artifact, pattern));
 
           if (matches || watch.patterns.includes('*')) {
             notifications.push({
               ...event,
               watchedBy: scopeId,
-              pattern: watch.patterns
+              pattern: watch.patterns,
             });
           }
         }
       }
 
       // Sort by timestamp
-      notifications.sort((a, b) => 
-        new Date(a.timestamp) - new Date(b.timestamp)
-      );
+      notifications.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
 
       return notifications;
     } catch {
@@ -287,10 +280,8 @@ class EventLogger {
   matchesPattern(artifact, pattern) {
     if (!artifact) return false;
     if (pattern === '*') return true;
-    
-    const regexPattern = pattern
-      .replaceAll('.', String.raw`\.`)
-      .replaceAll('*', '.*');
+
+    const regexPattern = pattern.replaceAll('.', String.raw`\.`).replaceAll('*', '.*');
     const regex = new RegExp(regexPattern);
     return regex.test(artifact);
   }
@@ -309,7 +300,7 @@ class EventLogger {
     SYNC_UP: 'sync_up',
     SYNC_DOWN: 'sync_down',
     WORKFLOW_STARTED: 'workflow_started',
-    WORKFLOW_COMPLETED: 'workflow_completed'
+    WORKFLOW_COMPLETED: 'workflow_completed',
   };
 
   /**
@@ -321,7 +312,7 @@ class EventLogger {
   async logArtifactCreated(scopeId, artifact, metadata = {}) {
     return this.logEvent(EventLogger.EventTypes.ARTIFACT_CREATED, scopeId, {
       artifact,
-      ...metadata
+      ...metadata,
     });
   }
 
@@ -334,7 +325,7 @@ class EventLogger {
   async logArtifactUpdated(scopeId, artifact, metadata = {}) {
     return this.logEvent(EventLogger.EventTypes.ARTIFACT_UPDATED, scopeId, {
       artifact,
-      ...metadata
+      ...metadata,
     });
   }
 
@@ -347,7 +338,7 @@ class EventLogger {
   async logArtifactPromoted(scopeId, artifact, sharedPath) {
     return this.logEvent(EventLogger.EventTypes.ARTIFACT_PROMOTED, scopeId, {
       artifact,
-      shared_path: sharedPath
+      shared_path: sharedPath,
     });
   }
 
@@ -358,14 +349,12 @@ class EventLogger {
    * @param {object} result - Sync result
    */
   async logSync(type, scopeId, result) {
-    const eventType = type === 'up' 
-      ? EventLogger.EventTypes.SYNC_UP 
-      : EventLogger.EventTypes.SYNC_DOWN;
-    
+    const eventType = type === 'up' ? EventLogger.EventTypes.SYNC_UP : EventLogger.EventTypes.SYNC_DOWN;
+
     return this.logEvent(eventType, scopeId, {
       files_count: result.promoted?.length || result.pulled?.length || 0,
       conflicts_count: result.conflicts?.length || 0,
-      errors_count: result.errors?.length || 0
+      errors_count: result.errors?.length || 0,
     });
   }
 
@@ -376,13 +365,13 @@ class EventLogger {
    */
   async getStats(scopeId = null) {
     const events = await this.getEvents(scopeId);
-    
+
     const stats = {
       total: events.length,
       byType: {},
       byScope: {},
       last24h: 0,
-      lastEvent: null
+      lastEvent: null,
     };
 
     const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
@@ -390,10 +379,10 @@ class EventLogger {
     for (const event of events) {
       // Count by type
       stats.byType[event.type] = (stats.byType[event.type] || 0) + 1;
-      
+
       // Count by scope
       stats.byScope[event.scope] = (stats.byScope[event.scope] || 0) + 1;
-      
+
       // Count recent
       if (new Date(event.timestamp) >= oneDayAgo) {
         stats.last24h++;

package/src/core/lib/scope/index.js

@@ -1,9 +1,9 @@
 /**
  * Scope Management Module
- * 
+ *
  * Provides multi-scope parallel artifact system functionality
  * for isolated development workflows.
- * 
+ *
  * @module scope
  */
 
@@ -26,5 +26,5 @@ module.exports = {
   ArtifactResolver,
   StateLock,
   ScopeSync,
-  EventLogger
+  EventLogger,
 };

package/src/core/lib/scope/scope-context.js

@@ -5,11 +5,11 @@ const yaml = require('yaml');
 /**
  * Manages session-sticky scope context
  * Tracks the current active scope for workflows and agents
- * 
+ *
  * @class ScopeContext
  * @requires fs-extra
  * @requires yaml
- * 
+ *
  * @example
  * const context = new ScopeContext({ projectRoot: '/path/to/project' });
  * await context.setScope('auth');
@@ -40,13 +40,13 @@ class ScopeContext {
    */
   async getCurrentScope() {
     try {
-      if (!await fs.pathExists(this.contextFilePath)) {
+      if (!(await fs.pathExists(this.contextFilePath))) {
         return null;
       }
 
       const content = await fs.readFile(this.contextFilePath, 'utf8');
       const context = yaml.parse(content);
-      
+
       return context?.active_scope || null;
     } catch {
       return null;
@@ -63,7 +63,7 @@ class ScopeContext {
       const context = {
         active_scope: scopeId,
         set_at: new Date().toISOString(),
-        set_by: process.env.USER || 'unknown'
+        set_by: process.env.USER || 'unknown',
       };
 
       await fs.writeFile(this.contextFilePath, yaml.stringify(context), 'utf8');
@@ -94,7 +94,7 @@ class ScopeContext {
    */
   async getContext() {
     try {
-      if (!await fs.pathExists(this.contextFilePath)) {
+      if (!(await fs.pathExists(this.contextFilePath))) {
         return null;
       }
 
@@ -121,11 +121,11 @@ class ScopeContext {
    * @returns {Promise<object>} Merged context object
    */
   async loadProjectContext(scopeId = null) {
-    const scope = scopeId || await this.getCurrentScope();
+    const scope = scopeId || (await this.getCurrentScope());
     const context = {
       global: null,
       scope: null,
-      merged: ''
+      merged: '',
     };
 
     try {
@@ -137,12 +137,7 @@ class ScopeContext {
 
       // Load scope-specific context if scope is set
       if (scope) {
-        const scopeContextPath = path.join(
-          this.projectRoot,
-          this.outputBase,
-          scope,
-          'project-context.md'
-        );
+        const scopeContextPath = path.join(this.projectRoot, this.outputBase, scope, 'project-context.md');
         if (await fs.pathExists(scopeContextPath)) {
           context.scope = await fs.readFile(scopeContextPath, 'utf8');
         }
@@ -156,7 +151,6 @@ class ScopeContext {
       } else if (context.scope) {
         context.merged = context.scope;
       }
-
     } catch (error) {
       throw new Error(`Failed to load project context: ${error.message}`);
     }
@@ -204,26 +198,26 @@ class ScopeContext {
    * @returns {Promise<object>} Variables object
    */
   async getScopeVariables(scopeId) {
-    const scope = scopeId || await this.getCurrentScope();
-    
+    const scope = scopeId || (await this.getCurrentScope());
+
     if (!scope) {
       return {
         scope: '',
         scope_path: '',
         scope_planning: '',
         scope_implementation: '',
-        scope_tests: ''
+        scope_tests: '',
       };
     }
 
     const basePath = path.join(this.outputBase, scope);
-    
+
     return {
       scope: scope,
       scope_path: basePath,
       scope_planning: path.join(basePath, 'planning-artifacts'),
       scope_implementation: path.join(basePath, 'implementation-artifacts'),
-      scope_tests: path.join(basePath, 'tests')
+      scope_tests: path.join(basePath, 'tests'),
     };
   }
 
@@ -234,8 +228,8 @@ class ScopeContext {
    * @returns {Promise<string>} Context snippet
    */
   async createContextSnippet(scopeId) {
-    const scope = scopeId || await this.getCurrentScope();
-    
+    const scope = scopeId || (await this.getCurrentScope());
+
     if (!scope) {
       return '<!-- No scope context active -->';
     }
@@ -264,14 +258,14 @@ ${context.merged || 'No project context loaded.'}
    * @returns {Promise<string>} Shell export statements
    */
   async exportForShell(scopeId) {
-    const scope = scopeId || await this.getCurrentScope();
-    
+    const scope = scopeId || (await this.getCurrentScope());
+
     if (!scope) {
       return '# No scope set';
     }
 
     const vars = await this.getScopeVariables(scope);
-    
+
     return `
 export BMAD_SCOPE="${vars.scope}"
 export BMAD_SCOPE_PATH="${vars.scope_path}"
@@ -288,12 +282,12 @@ export BMAD_SCOPE_TESTS="${vars.scope_tests}"
    */
   async updateMetadata(metadata) {
     try {
-      const context = await this.getContext() || {};
-      
+      const context = (await this.getContext()) || {};
+
       const updated = {
         ...context,
         ...metadata,
-        updated_at: new Date().toISOString()
+        updated_at: new Date().toISOString(),
       };
 
       await fs.writeFile(this.contextFilePath, yaml.stringify(updated), 'utf8');

package/src/core/lib/scope/scope-initializer.js

@@ -5,11 +5,11 @@ const yaml = require('yaml');
 /**
  * Initializes directory structure for scopes
  * Creates scope directories, shared layer, and event system
- * 
+ *
  * @class ScopeInitializer
  * @requires fs-extra
  * @requires yaml
- * 
+ *
  * @example
  * const initializer = new ScopeInitializer({ projectRoot: '/path/to/project' });
  * await initializer.initializeScope('auth');
@@ -70,14 +70,14 @@ class ScopeInitializer {
 
       // Create README in shared directory
       const sharedReadmePath = path.join(this.sharedPath, 'README.md');
-      if (!await fs.pathExists(sharedReadmePath)) {
+      if (!(await fs.pathExists(sharedReadmePath))) {
         const readmeContent = this.generateSharedReadme();
         await fs.writeFile(sharedReadmePath, readmeContent, 'utf8');
       }
 
       // Create global project-context.md template
       const contextPath = path.join(this.sharedPath, 'project-context.md');
-      if (!await fs.pathExists(contextPath)) {
+      if (!(await fs.pathExists(contextPath))) {
         const contextContent = this.generateGlobalContextTemplate();
         await fs.writeFile(contextPath, contextContent, 'utf8');
       }
@@ -100,20 +100,20 @@ class ScopeInitializer {
 
       // Create event-log.yaml
       const eventLogPath = path.join(this.eventsPath, 'event-log.yaml');
-      if (!await fs.pathExists(eventLogPath)) {
+      if (!(await fs.pathExists(eventLogPath))) {
         const eventLog = {
           version: 1,
-          events: []
+          events: [],
         };
         await fs.writeFile(eventLogPath, yaml.stringify(eventLog), 'utf8');
       }
 
       // Create subscriptions.yaml
       const subscriptionsPath = path.join(this.eventsPath, 'subscriptions.yaml');
-      if (!await fs.pathExists(subscriptionsPath)) {
+      if (!(await fs.pathExists(subscriptionsPath))) {
         const subscriptions = {
           version: 1,
-          subscriptions: {}
+          subscriptions: {},
         };
         await fs.writeFile(subscriptionsPath, yaml.stringify(subscriptions), 'utf8');
       }
@@ -135,10 +135,8 @@ class ScopeInitializer {
       const scopePath = path.join(this.outputPath, scopeId);
 
       // Check if scope directory already exists
-      if (await fs.pathExists(scopePath)) {
-        if (!options.force) {
-          throw new Error(`Scope directory '${scopeId}' already exists. Use force option to recreate.`);
-        }
+      if ((await fs.pathExists(scopePath)) && !options.force) {
+        throw new Error(`Scope directory '${scopeId}' already exists. Use force option to recreate.`);
       }
 
       // Create scope directory structure
@@ -147,7 +145,7 @@ class ScopeInitializer {
         planning: path.join(scopePath, 'planning-artifacts'),
         implementation: path.join(scopePath, 'implementation-artifacts'),
         tests: path.join(scopePath, 'tests'),
-        meta: path.join(scopePath, '.scope-meta.yaml')
+        meta: path.join(scopePath, '.scope-meta.yaml'),
       };
 
       // Create directories
@@ -163,14 +161,14 @@ class ScopeInitializer {
         structure: {
           planning_artifacts: 'planning-artifacts/',
           implementation_artifacts: 'implementation-artifacts/',
-          tests: 'tests/'
-        }
+          tests: 'tests/',
+        },
       };
       await fs.writeFile(paths.meta, yaml.stringify(metadata), 'utf8');
 
       // Create README in scope directory
       const readmePath = path.join(scopePath, 'README.md');
-      if (!await fs.pathExists(readmePath)) {
+      if (!(await fs.pathExists(readmePath))) {
         const readmeContent = this.generateScopeReadme(scopeId, options);
         await fs.writeFile(readmePath, readmeContent, 'utf8');
       }
@@ -199,7 +197,7 @@ class ScopeInitializer {
       const scopePath = path.join(this.outputPath, scopeId);
 
       // Check if scope exists
-      if (!await fs.pathExists(scopePath)) {
+      if (!(await fs.pathExists(scopePath))) {
         throw new Error(`Scope directory '${scopeId}' does not exist`);
       }
 
@@ -251,7 +249,7 @@ class ScopeInitializer {
       implementation: path.join(scopePath, 'implementation-artifacts'),
       tests: path.join(scopePath, 'tests'),
       meta: path.join(scopePath, '.scope-meta.yaml'),
-      context: path.join(scopePath, 'project-context.md')
+      context: path.join(scopePath, 'project-context.md'),
     };
   }
 
@@ -281,9 +279,9 @@ The shared layer enables:
 
 ## Usage
 
-1. **Reading**: All scopes can read from \\`_shared/\\`
-2. **Writing**: Use \\`bmad scope sync-up <scope>\\` to promote artifacts
-3. **Syncing**: Use \\`bmad scope sync-down <scope>\\` to pull updates
+1. **Reading**: All scopes can read from \`_shared/\`
+2. **Writing**: Use \`bmad scope sync-up <scope>\` to promote artifacts
+3. **Syncing**: Use \`bmad scope sync-down <scope>\` to pull updates
 
 ## Best Practices
 
@@ -368,16 +366,14 @@ ${description}
 
 ## Scope Information
 
-- **ID:** \\`${scopeId}\\`
+- **ID:** ${scopeId}
 - **Name:** ${scopeName}
 - **Status:** ${options.status || 'active'}
 - **Created:** ${new Date().toISOString().split('T')[0]}
 
 ## Dependencies
 
-${options.dependencies && options.dependencies.length > 0
-    ? options.dependencies.map(dep => `- \\`${dep}\\``).join('\n')
-    : 'No dependencies'}
+${options.dependencies && options.dependencies.length > 0 ? options.dependencies.map((dep) => `- ${dep}`).join('\n') : 'No dependencies'}
 
 ## Usage
 
@@ -403,8 +399,8 @@ bmad scope sync-down ${scopeId}
 
 ## Related Documentation
 
-- Global context: \\`../_shared/project-context.md\\`
-- Contracts: \\`../_shared/contracts/\\`
+- Global context: ../_shared/project-context.md
+- Contracts: ../_shared/contracts/
 `;
   }
 
@@ -419,7 +415,7 @@ bmad scope sync-down ${scopeId}
 
     return `# Scope Context: ${scopeName}
 
-> This context extends the global project context in \\`../_shared/project-context.md\\`
+> This context extends the global project context in ../_shared/project-context.md
 
 ## Scope Purpose
 
@@ -436,9 +432,11 @@ bmad scope sync-down ${scopeId}
 ## Integration Points
 
 ### Dependencies
-${options.dependencies && options.dependencies.length > 0
-    ? options.dependencies.map(dep => `- **${dep}**: [Describe dependency relationship]`).join('\n')
-    : 'No dependencies'}
+${
+  options.dependencies && options.dependencies.length > 0
+    ? options.dependencies.map((dep) => `- **${dep}**: [Describe dependency relationship]`).join('\n')
+    : 'No dependencies'
+}
 
 ### Provides
 [What this scope provides to other scopes]