@polymorphism-tech/morph-spec 3.0.0 → 3.1.0

package/src/lib/stack-resolver.js

@@ -0,0 +1,148 @@
+/**
+ * Stack Resolver - Centralized stack path resolution for multi-stack support.
+ *
+ * Detects the active stack and resolves all stack-relative paths.
+ * Resolution order: explicit > config.json > state.json > auto-detect > fallback
+ *
+ * @module stack-resolver
+ */
+
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+const STACK_TYPE_TO_DIR = {
+  'blazor-server': 'blazor-azure',
+  'blazor-azure': 'blazor-azure',
+  'nextjs-supabase': 'nextjs-supabase',
+};
+
+// Module-level override set by CLI --stack flag via setGlobalStack()
+let _globalStackOverride = null;
+
+/**
+ * Set a global stack override (called by CLI --stack flag).
+ * Once set, all resolveStackId() calls use this value unless
+ * an explicit parameter is provided.
+ * @param {string} stackId - Stack identifier
+ */
+export function setGlobalStack(stackId) {
+  _globalStackOverride = stackId;
+}
+
+/**
+ * Detect which stack directory to use.
+ *
+ * Resolution order:
+ *   1. explicitStack parameter (from CLI --stack flag)
+ *   2. .morph/config/config.json → project.type
+ *   3. .morph/state.json → project.type
+ *   4. Auto-detect: scan stacks/ for existing directories
+ *   5. Fallback: 'blazor-azure'
+ *
+ * @param {string} projectPath - Absolute path to project root
+ * @param {string} [explicitStack] - Override from CLI --stack flag
+ * @returns {string} Stack directory name (e.g., 'blazor-azure', 'nextjs-supabase')
+ */
+export function resolveStackId(projectPath, explicitStack) {
+  // 1. Explicit parameter override
+  if (explicitStack) {
+    return STACK_TYPE_TO_DIR[explicitStack] || explicitStack;
+  }
+
+  // 1b. Global CLI --stack override
+  if (_globalStackOverride) {
+    return STACK_TYPE_TO_DIR[_globalStackOverride] || _globalStackOverride;
+  }
+
+  // 2. config.json → project.type
+  try {
+    const configPath = join(projectPath, '.morph/config/config.json');
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, 'utf8'));
+      const projectType = config?.project?.type;
+      if (projectType && STACK_TYPE_TO_DIR[projectType]) {
+        return STACK_TYPE_TO_DIR[projectType];
+      }
+    }
+  } catch { /* continue to next source */ }
+
+  // 3. state.json → project.type
+  try {
+    const statePath = join(projectPath, '.morph/state.json');
+    if (existsSync(statePath)) {
+      const state = JSON.parse(readFileSync(statePath, 'utf8'));
+      const projectType = state?.project?.type;
+      if (projectType && STACK_TYPE_TO_DIR[projectType]) {
+        return STACK_TYPE_TO_DIR[projectType];
+      }
+    }
+  } catch { /* continue to next source */ }
+
+  // 4. Auto-detect: first directory in stacks/
+  try {
+    const stacksDir = join(projectPath, 'stacks');
+    if (existsSync(stacksDir)) {
+      const dirs = readdirSync(stacksDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+      if (dirs.length === 1) {
+        return dirs[0];
+      }
+    }
+  } catch { /* continue to fallback */ }
+
+  // 5. Fallback
+  return 'blazor-azure';
+}
+
+/**
+ * Get absolute path to the active stack's root directory.
+ * @param {string} projectPath
+ * @param {string} [explicitStack]
+ * @returns {string}
+ */
+export function resolveStackPath(projectPath, explicitStack) {
+  return join(projectPath, 'stacks', resolveStackId(projectPath, explicitStack));
+}
+
+/**
+ * Get absolute path to the active stack's agents.json.
+ * @param {string} projectPath
+ * @param {string} [explicitStack]
+ * @returns {string}
+ */
+export function resolveAgentsConfigPath(projectPath, explicitStack) {
+  return join(resolveStackPath(projectPath, explicitStack), '.morph/config/agents.json');
+}
+
+/**
+ * Get absolute path to the active stack's standards directory.
+ * @param {string} projectPath
+ * @param {string} [explicitStack]
+ * @returns {string}
+ */
+export function resolveStandardsDir(projectPath, explicitStack) {
+  return join(resolveStackPath(projectPath, explicitStack), '.morph/standards');
+}
+
+/**
+ * Get absolute path to the active stack's templates directory.
+ * @param {string} projectPath
+ * @param {string} [explicitStack]
+ * @returns {string}
+ */
+export function resolveTemplatesDir(projectPath, explicitStack) {
+  return join(resolveStackPath(projectPath, explicitStack), '.morph/templates');
+}
+
+/**
+ * Get absolute path to the active stack's config directory.
+ * @param {string} projectPath
+ * @param {string} [explicitStack]
+ * @returns {string}
+ */
+export function resolveConfigDir(projectPath, explicitStack) {
+  return join(resolveStackPath(projectPath, explicitStack), '.morph/config');
+}
+
+export { STACK_TYPE_TO_DIR };

package/src/lib/standards-context-injector.js

@@ -9,6 +9,7 @@
 
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
+import { resolveStandardsDir } from './stack-resolver.js';
 
 /**
  * Agent → Standards mapping
@@ -191,8 +192,8 @@ function loadStandard(standardName, projectPath) {
   const locations = [
     // 1. Project override
     join(projectPath, '.morph/project/standards', `${standardName}.md`),
-    // 2. Content standards (AI/Agent Framework, Azure, etc.)
-    join(projectPath, 'content/.morph/standards', `${standardName}.md`),
+    // 2. Stack standards (resolved dynamically based on project type)
+    join(resolveStandardsDir(projectPath), `${standardName}.md`),
     // 3. Framework standards (Blazor, CSS, .NET)
     join(projectPath, 'framework/standards', `${standardName}.md`)
   ];
@@ -273,7 +274,7 @@ export function getStandardsListForAgent(agentId) {
 export function checkStandardExists(standardName, projectPath = '.') {
   const locations = [
     { type: 'project', path: join(projectPath, '.morph/project/standards', `${standardName}.md`) },
-    { type: 'content', path: join(projectPath, 'content/.morph/standards', `${standardName}.md`) },
+    { type: 'stack', path: join(resolveStandardsDir(projectPath), `${standardName}.md`) },
     { type: 'framework', path: join(projectPath, 'framework/standards', `${standardName}.md`) }
   ];
 

package/src/lib/state-manager.js

@@ -291,6 +291,21 @@ export function removeAgent(featureName, agentId) {
   return false;
 }
 
+/**
+ * Normalize output type from kebab-case to camelCase for UI types (BUG #12 fix)
+ * @param {string} type - Output type (e.g., 'ui-design-system' or 'uiDesignSystem')
+ * @returns {string} Normalized type in camelCase
+ */
+function normalizeOutputType(type) {
+  const kebabMap = {
+    'ui-design-system': 'uiDesignSystem',
+    'ui-mockups': 'uiMockups',
+    'ui-components': 'uiComponents',
+    'ui-flows': 'uiFlows'
+  };
+  return kebabMap[type] || type;
+}
+
 /**
  * Mark output as created
  * @param {string} featureName - Feature name
@@ -300,15 +315,17 @@ export function markOutput(featureName, outputType) {
   ensureFeature(featureName);
   const state = loadState();
 
-  if (!state.features[featureName].outputs[outputType]) {
-    throw new Error(`Output type '${outputType}' not valid. Valid types: proposal, spec, contracts, tasks, uiDesignSystem, uiMockups, uiComponents, uiFlows, decisions, recap`);
+  const normalized = normalizeOutputType(outputType);
+
+  if (!state.features[featureName].outputs[normalized]) {
+    throw new Error(`Output type '${outputType}' not valid. Valid types: proposal, spec, contracts, tasks, uiDesignSystem (or ui-design-system), uiMockups (or ui-mockups), uiComponents (or ui-components), uiFlows (or ui-flows), decisions, recap`);
   }
 
-  state.features[featureName].outputs[outputType].created = true;
+  state.features[featureName].outputs[normalized].created = true;
   state.features[featureName].updatedAt = new Date().toISOString();
 
   // If marking tasks output, try to sync task count from state tasks array
-  if (outputType === 'tasks') {
+  if (normalized === 'tasks') {
     syncTasksCount(state.features[featureName]);
   }
 

package/src/lib/team-orchestrator.js

@@ -13,6 +13,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { resolveAgentsConfigPath } from './stack-resolver.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -23,7 +24,7 @@ const __dirname = path.dirname(__filename);
  * @returns {Promise<Object>} Parsed agents configuration
  */
 async function loadAgentsConfig(projectPath) {
-  const agentsPath = path.join(projectPath, 'content/.morph/config/agents.json');
+  const agentsPath = resolveAgentsConfigPath(projectPath);
   const content = await fs.readFile(agentsPath, 'utf8');
   return JSON.parse(content);
 }

package/src/lib/troubleshoot-grep.js

@@ -6,17 +6,27 @@
 import { readFileSync, readdirSync, existsSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
+import { resolveStandardsDir } from './stack-resolver.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const frameworkRoot = join(__dirname, '..', '..');
 
-// Directories to search
+// Directories to search (stack standards resolved dynamically)
 const SEARCH_PATHS = [
   'framework/standards',
-  'content/.morph/standards',
   '.wiki'
 ];
 
+function getSearchPaths(basePath) {
+  const paths = [...SEARCH_PATHS];
+  // Insert resolved stack standards path
+  const stackStandards = resolveStandardsDir(basePath || frameworkRoot);
+  const relativePath = stackStandards.replace(basePath || frameworkRoot, '').replace(/^[\\/]/, '');
+  paths.splice(1, 0, relativePath);
+  return paths;
+}
+
 /**
  * Get all markdown files from search paths
  * @param {string} basePath - Base path of the project
@@ -25,7 +35,7 @@ const SEARCH_PATHS = [
 function getMarkdownFiles(basePath) {
   const files = [];
 
-  for (const searchPath of SEARCH_PATHS) {
+  for (const searchPath of getSearchPaths(basePath)) {
     const fullPath = join(basePath, searchPath);
 
     if (!existsSync(fullPath)) {

package/src/lib/validation-runner.js

@@ -12,6 +12,7 @@ import { join } from 'path';
 import chalk from 'chalk';
 import { loadState } from './state-manager.js';
 import { loadConstraints } from './decision-constraint-loader.js';
+import { resolveAgentsConfigPath } from './stack-resolver.js';
 
 /**
  * Load agent → validators map from agents.json (data-driven)
@@ -20,7 +21,7 @@ import { loadConstraints } from './decision-constraint-loader.js';
  */
 function loadAgentValidatorMap(projectPath) {
   try {
-    const agentsPath = join(projectPath, 'content/.morph/config/agents.json');
+    const agentsPath = resolveAgentsConfigPath(projectPath);
     const agentsConfig = JSON.parse(readFileSync(agentsPath, 'utf8'));
 
     const map = {};

package/src/utils/file-copier.js

@@ -1,15 +1,17 @@
 import fs from 'fs-extra';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import { resolveStackPath } from '../lib/stack-resolver.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const frameworkRoot = join(__dirname, '..', '..');
 
 function isSamePath(a, b) {
   return resolve(a) === resolve(b);
 }
 
 export function getContentDir() {
-  return join(__dirname, '..', '..', 'content');
+  return resolveStackPath(frameworkRoot);
 }
 
 export async function copyDirectory(src, dest, options = {}) {