@polymorphism-tech/morph-spec 3.0.1 → 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/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

@@ -1,194 +1,204 @@
-/**
- * Troubleshoot Grep Fallback
- * Searches markdown files for matching content when index doesn't find results
- */
-
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import { join, dirname, basename } from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Directories to search
-const SEARCH_PATHS = [
-  'framework/standards',
-  'content/.morph/standards',
-  '.wiki'
-];
-
-/**
- * Get all markdown files from search paths
- * @param {string} basePath - Base path of the project
- * @returns {string[]} Array of file paths
- */
-function getMarkdownFiles(basePath) {
-  const files = [];
-
-  for (const searchPath of SEARCH_PATHS) {
-    const fullPath = join(basePath, searchPath);
-
-    if (!existsSync(fullPath)) {
-      continue;
-    }
-
-    try {
-      const entries = readdirSync(fullPath, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith('.md')) {
-          files.push(join(fullPath, entry.name));
-        }
-      }
-    } catch (error) {
-      // Skip directories we can't read
-    }
-  }
-
-  return files;
-}
-
-/**
- * Extract section containing the match
- * @param {string} content - File content
- * @param {number} matchIndex - Index of the match
- * @returns {Object} Section object with title and content
- */
-function extractSection(content, matchIndex) {
-  const lines = content.split('\n');
-  let charCount = 0;
-  let matchLineIndex = 0;
-
-  // Find the line containing the match
-  for (let i = 0; i < lines.length; i++) {
-    charCount += lines[i].length + 1; // +1 for newline
-    if (charCount > matchIndex) {
-      matchLineIndex = i;
-      break;
-    }
-  }
-
-  // Find the section header (## heading) above the match
-  let sectionTitle = 'Unknown Section';
-  let sectionStart = 0;
-
-  for (let i = matchLineIndex; i >= 0; i--) {
-    if (lines[i].startsWith('## ')) {
-      sectionTitle = lines[i].replace('## ', '').trim();
-      sectionStart = i;
-      break;
-    }
-  }
-
-  // Find the end of the section (next ## or end of file)
-  let sectionEnd = lines.length;
-  for (let i = sectionStart + 1; i < lines.length; i++) {
-    if (lines[i].startsWith('## ')) {
-      sectionEnd = i;
-      break;
-    }
-  }
-
-  // Extract section content (limit to ~20 lines around match)
-  const contextStart = Math.max(sectionStart, matchLineIndex - 10);
-  const contextEnd = Math.min(sectionEnd, matchLineIndex + 10);
-  const sectionContent = lines.slice(contextStart, contextEnd).join('\n');
-
-  return {
-    title: sectionTitle,
-    content: sectionContent,
-    lineNumber: matchLineIndex + 1
-  };
-}
-
-/**
- * Search a file for keywords
- * @param {string} filePath - Path to the file
- * @param {string[]} keywords - Keywords to search for
- * @returns {Object[]} Array of matches
- */
-function searchFile(filePath, keywords) {
-  const matches = [];
-
-  try {
-    const content = readFileSync(filePath, 'utf-8');
-    const contentLower = content.toLowerCase();
-
-    for (const keyword of keywords) {
-      const keywordLower = keyword.toLowerCase();
-      let index = contentLower.indexOf(keywordLower);
-
-      while (index !== -1) {
-        const section = extractSection(content, index);
-
-        // Check if we already have a match for this section
-        const existingMatch = matches.find(m => m.section === section.title);
-
-        if (existingMatch) {
-          existingMatch.matchCount++;
-          existingMatch.keywords.add(keyword);
-        } else {
-          matches.push({
-            file: filePath,
-            fileName: basename(filePath),
-            section: section.title,
-            content: section.content,
-            lineNumber: section.lineNumber,
-            matchCount: 1,
-            keywords: new Set([keyword])
-          });
-        }
-
-        index = contentLower.indexOf(keywordLower, index + 1);
-      }
-    }
-  } catch (error) {
-    // Skip files we can't read
-  }
-
-  return matches;
-}
-
-/**
- * Search all markdown files for keywords
- * @param {string[]} keywords - Keywords to search for
- * @param {Object} options - Search options
- * @returns {Object[]} Array of matches sorted by relevance
- */
-export function searchGrep(keywords, options = {}) {
-  // Determine base path
-  const basePath = options.basePath || join(__dirname, '../..');
-
-  const files = getMarkdownFiles(basePath);
-  let allMatches = [];
-
-  for (const file of files) {
-    const matches = searchFile(file, keywords);
-    allMatches = allMatches.concat(matches);
-  }
-
-  // Convert keywords Set to Array and calculate score
-  const results = allMatches.map(match => ({
-    ...match,
-    keywords: Array.from(match.keywords),
-    score: match.matchCount * 5 + match.keywords.size * 3,
-    source: 'grep'
-  }));
-
-  // Sort by score (higher is better) and deduplicate
-  const seen = new Set();
-  const uniqueResults = results
-    .sort((a, b) => b.score - a.score)
-    .filter(r => {
-      const key = `${r.file}:${r.section}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-
-  return uniqueResults.slice(0, 10); // Limit to top 10
-}
-
-export default {
-  searchGrep
-};
+/**
+ * Troubleshoot Grep Fallback
+ * Searches markdown files for matching content when index doesn't find results
+ */
+
+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 (stack standards resolved dynamically)
+const SEARCH_PATHS = [
+  'framework/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
+ * @returns {string[]} Array of file paths
+ */
+function getMarkdownFiles(basePath) {
+  const files = [];
+
+  for (const searchPath of getSearchPaths(basePath)) {
+    const fullPath = join(basePath, searchPath);
+
+    if (!existsSync(fullPath)) {
+      continue;
+    }
+
+    try {
+      const entries = readdirSync(fullPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.md')) {
+          files.push(join(fullPath, entry.name));
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Extract section containing the match
+ * @param {string} content - File content
+ * @param {number} matchIndex - Index of the match
+ * @returns {Object} Section object with title and content
+ */
+function extractSection(content, matchIndex) {
+  const lines = content.split('\n');
+  let charCount = 0;
+  let matchLineIndex = 0;
+
+  // Find the line containing the match
+  for (let i = 0; i < lines.length; i++) {
+    charCount += lines[i].length + 1; // +1 for newline
+    if (charCount > matchIndex) {
+      matchLineIndex = i;
+      break;
+    }
+  }
+
+  // Find the section header (## heading) above the match
+  let sectionTitle = 'Unknown Section';
+  let sectionStart = 0;
+
+  for (let i = matchLineIndex; i >= 0; i--) {
+    if (lines[i].startsWith('## ')) {
+      sectionTitle = lines[i].replace('## ', '').trim();
+      sectionStart = i;
+      break;
+    }
+  }
+
+  // Find the end of the section (next ## or end of file)
+  let sectionEnd = lines.length;
+  for (let i = sectionStart + 1; i < lines.length; i++) {
+    if (lines[i].startsWith('## ')) {
+      sectionEnd = i;
+      break;
+    }
+  }
+
+  // Extract section content (limit to ~20 lines around match)
+  const contextStart = Math.max(sectionStart, matchLineIndex - 10);
+  const contextEnd = Math.min(sectionEnd, matchLineIndex + 10);
+  const sectionContent = lines.slice(contextStart, contextEnd).join('\n');
+
+  return {
+    title: sectionTitle,
+    content: sectionContent,
+    lineNumber: matchLineIndex + 1
+  };
+}
+
+/**
+ * Search a file for keywords
+ * @param {string} filePath - Path to the file
+ * @param {string[]} keywords - Keywords to search for
+ * @returns {Object[]} Array of matches
+ */
+function searchFile(filePath, keywords) {
+  const matches = [];
+
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const contentLower = content.toLowerCase();
+
+    for (const keyword of keywords) {
+      const keywordLower = keyword.toLowerCase();
+      let index = contentLower.indexOf(keywordLower);
+
+      while (index !== -1) {
+        const section = extractSection(content, index);
+
+        // Check if we already have a match for this section
+        const existingMatch = matches.find(m => m.section === section.title);
+
+        if (existingMatch) {
+          existingMatch.matchCount++;
+          existingMatch.keywords.add(keyword);
+        } else {
+          matches.push({
+            file: filePath,
+            fileName: basename(filePath),
+            section: section.title,
+            content: section.content,
+            lineNumber: section.lineNumber,
+            matchCount: 1,
+            keywords: new Set([keyword])
+          });
+        }
+
+        index = contentLower.indexOf(keywordLower, index + 1);
+      }
+    }
+  } catch (error) {
+    // Skip files we can't read
+  }
+
+  return matches;
+}
+
+/**
+ * Search all markdown files for keywords
+ * @param {string[]} keywords - Keywords to search for
+ * @param {Object} options - Search options
+ * @returns {Object[]} Array of matches sorted by relevance
+ */
+export function searchGrep(keywords, options = {}) {
+  // Determine base path
+  const basePath = options.basePath || join(__dirname, '../..');
+
+  const files = getMarkdownFiles(basePath);
+  let allMatches = [];
+
+  for (const file of files) {
+    const matches = searchFile(file, keywords);
+    allMatches = allMatches.concat(matches);
+  }
+
+  // Convert keywords Set to Array and calculate score
+  const results = allMatches.map(match => ({
+    ...match,
+    keywords: Array.from(match.keywords),
+    score: match.matchCount * 5 + match.keywords.size * 3,
+    source: 'grep'
+  }));
+
+  // Sort by score (higher is better) and deduplicate
+  const seen = new Set();
+  const uniqueResults = results
+    .sort((a, b) => b.score - a.score)
+    .filter(r => {
+      const key = `${r.file}:${r.section}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+
+  return uniqueResults.slice(0, 10); // Limit to top 10
+}
+
+export default {
+  searchGrep
+};