bmad-fh 6.0.0-alpha.23 → 6.0.0-alpha.23.e9c0f978

package/.github/workflows/publish-multi-artifact.yaml

@@ -28,10 +28,14 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Get version
+      - name: Set version with commit hash
         id: version
         run: |
-          echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT
+          BASE_VERSION=$(node -p "require('./package.json').version")
+          SHORT_SHA=$(git rev-parse --short HEAD)
+          NEW_VERSION="${BASE_VERSION}.${SHORT_SHA}"
+          npm version "${NEW_VERSION}" --no-git-tag-version
+          echo "version=${NEW_VERSION}" >> $GITHUB_OUTPUT
 
       - name: Publish to NPM
         env:

package/eslint.config.mjs

@@ -81,9 +81,9 @@ export default [
     },
   },
 
-  // CLI scripts under tools/** and test/**
+  // CLI scripts under tools/**, test/**, and src/core/lib/**
   {
-    files: ['tools/**/*.js', 'tools/**/*.mjs', 'test/**/*.js'],
+    files: ['tools/**/*.js', 'tools/**/*.mjs', 'test/**/*.js', 'src/core/lib/**/*.js'],
     rules: {
       // Allow CommonJS patterns for Node CLI scripts
       'unicorn/prefer-module': 'off',

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-fh",
-  "version": "6.0.0-alpha.23",
+  "version": "6.0.0-alpha.23.e9c0f978",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",
@@ -24,7 +24,6 @@
   },
   "scripts": {
     "bmad:install": "node tools/cli/bmad-cli.js install",
-    "publish:multi-artifact": "npm publish --tag multi-artifact",
     "bundle": "node tools/cli/bundlers/bundle-web.js all",
     "docs:build": "node tools/build-docs.js",
     "docs:dev": "astro dev --root website",
@@ -40,6 +39,7 @@
     "lint:fix": "eslint . --ext .js,.cjs,.mjs,.yaml --fix",
     "lint:md": "markdownlint-cli2 \"**/*.md\"",
     "prepare": "husky",
+    "publish:multi-artifact": "npm publish --tag multi-artifact",
     "rebundle": "node tools/cli/bundlers/bundle-web.js rebundle",
     "release:major": "gh workflow run \"Manual Release\" -f version_bump=major",
     "release:minor": "gh workflow run \"Manual Release\" -f version_bump=minor",

package/src/bmm/module.yaml

@@ -34,13 +34,13 @@ user_skill_level:
 scope:
   default: ""
   result: "{value}"
-  runtime: true  # Indicates this is resolved at runtime, not during install
+  runtime: true # Indicates this is resolved at runtime, not during install
 
 # Scope-aware path helper - resolves to output_folder/scope or just output_folder
 scope_path:
   default: "{output_folder}"
   result: "{value}"
-  runtime: true  # Updated at runtime when scope is active
+  runtime: true # Updated at runtime when scope is active
 
 planning_artifacts: # Phase 1-3 artifacts
   prompt: "Where should planning artifacts be stored? (Brainstorming, Briefs, PRDs, UX Designs, Architecture, Epics)"

package/src/core/lib/scope/artifact-resolver.js

@@ -3,15 +3,15 @@ const path = require('node:path');
 /**
  * Resolves and enforces scope-based artifact access
  * Implements read-any/write-own access model
- * 
+ *
  * @class ArtifactResolver
- * 
+ *
  * @example
  * const resolver = new ArtifactResolver({
  *   currentScope: 'auth',
  *   basePath: '/path/to/_bmad-output'
  * });
- * 
+ *
  * if (resolver.canWrite('/path/to/_bmad-output/auth/file.md')) {
  *   // Write operation allowed
  * }
@@ -52,7 +52,7 @@ class ArtifactResolver {
   extractScopeFromPath(filePath) {
     // Normalize path
     const normalizedPath = path.normalize(filePath);
-    
+
     // Find the base path in the file path
     const baseIndex = normalizedPath.indexOf(this.basePath);
     if (baseIndex === -1) {
@@ -61,16 +61,16 @@ class ArtifactResolver {
 
     // Get the relative path from base
     const relativePath = normalizedPath.slice(Math.max(0, baseIndex + this.basePath.length + 1));
-    
+
     // Split to get the first segment (scope name)
     const segments = relativePath.split(path.sep).filter(Boolean);
-    
+
     if (segments.length === 0) {
       return null;
     }
 
     const firstSegment = segments[0];
-    
+
     // Check if it's a reserved path
     if (this.reservedPaths.includes(firstSegment)) {
       return firstSegment; // Return the reserved path name
@@ -109,7 +109,7 @@ class ArtifactResolver {
     // Read is always allowed for all paths
     return {
       allowed: true,
-      reason: 'Read access is always allowed in read-any model'
+      reason: 'Read access is always allowed in read-any model',
     };
   }
 
@@ -124,7 +124,7 @@ class ArtifactResolver {
       return {
         allowed: true,
         reason: 'No scope active, operating in legacy mode',
-        warning: null
+        warning: null,
       };
     }
 
@@ -135,7 +135,7 @@ class ArtifactResolver {
       return {
         allowed: false,
         reason: `Cannot write directly to '${this.sharedPath}'. Use: bmad scope sync-up`,
-        warning: null
+        warning: null,
       };
     }
 
@@ -144,7 +144,7 @@ class ArtifactResolver {
       return {
         allowed: false,
         reason: `Cannot write to reserved path '${targetScope}'`,
-        warning: null
+        warning: null,
       };
     }
 
@@ -153,7 +153,7 @@ class ArtifactResolver {
       return {
         allowed: true,
         reason: `Write allowed to current scope '${this.currentScope}'`,
-        warning: null
+        warning: null,
       };
     }
 
@@ -164,31 +164,31 @@ class ArtifactResolver {
           return {
             allowed: false,
             reason: `Cannot write to scope '${targetScope}' while in scope '${this.currentScope}'`,
-            warning: null
+            warning: null,
           };
         }
-        
+
         case 'warn': {
           return {
             allowed: true,
             reason: 'Write allowed with warning in warn mode',
-            warning: `Warning: Writing to scope '${targetScope}' from scope '${this.currentScope}'`
+            warning: `Warning: Writing to scope '${targetScope}' from scope '${this.currentScope}'`,
           };
         }
-        
+
         case 'permissive': {
           return {
             allowed: true,
             reason: 'Write allowed in permissive mode',
-            warning: null
+            warning: null,
           };
         }
-        
+
         default: {
           return {
             allowed: false,
             reason: 'Unknown isolation mode',
-            warning: null
+            warning: null,
           };
         }
       }
@@ -198,7 +198,7 @@ class ArtifactResolver {
     return {
       allowed: true,
       reason: 'Path is outside scope system',
-      warning: null
+      warning: null,
     };
   }
 
@@ -209,11 +209,11 @@ class ArtifactResolver {
    */
   validateWrite(filePath) {
     const result = this.canWrite(filePath);
-    
+
     if (!result.allowed) {
       throw new Error(result.reason);
     }
-    
+
     if (result.warning) {
       console.warn(result.warning);
     }
@@ -227,7 +227,7 @@ class ArtifactResolver {
    */
   resolveScopePath(relativePath, scopeId = null) {
     const scope = scopeId || this.currentScope;
-    
+
     if (!scope) {
       // No scope - return path relative to base
       return path.join(this.basePath, relativePath);
@@ -254,7 +254,7 @@ class ArtifactResolver {
       currentScope: this.currentScope ? path.join(this.basePath, this.currentScope) : null,
       shared: path.join(this.basePath, this.sharedPath),
       allScopes: `${this.basePath}/*`,
-      description: 'Read access is allowed to all scopes and shared directories'
+      description: 'Read access is allowed to all scopes and shared directories',
     };
   }
 
@@ -266,13 +266,13 @@ class ArtifactResolver {
     if (!this.currentScope) {
       return {
         all: this.basePath,
-        description: 'No scope active - all paths writable (legacy mode)'
+        description: 'No scope active - all paths writable (legacy mode)',
       };
     }
 
     return {
       currentScope: path.join(this.basePath, this.currentScope),
-      description: `Write access limited to scope '${this.currentScope}'`
+      description: `Write access limited to scope '${this.currentScope}'`,
     };
   }
 

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');