musubi-sdd 5.1.0 → 5.6.1

package/src/converters/parsers/musubi-parser.js

@@ -1,6 +1,6 @@
 /**
  * MUSUBI Parser
- * 
+ *
  * Parses MUSUBI project structure into Intermediate Representation (IR)
  */
 
@@ -9,7 +9,11 @@
 const fs = require('fs-extra');
 const path = require('path');
 const yaml = require('js-yaml');
-const { createEmptyProjectIR, createEmptyFeatureIR, createRequirementFromEARS } = require('../ir/types');
+const {
+  createEmptyProjectIR,
+  createEmptyFeatureIR,
+  createRequirementFromEARS,
+} = require('../ir/types');
 
 /**
  * Parse a MUSUBI project into IR
@@ -18,34 +22,34 @@ const { createEmptyProjectIR, createEmptyFeatureIR, createRequirementFromEARS }
  */
 async function parseMusubiProject(projectPath) {
   const ir = createEmptyProjectIR();
-  
+
   // Parse project metadata
   ir.metadata = await parseProjectMetadata(projectPath);
-  
+
   // Parse constitution
   ir.constitution = await parseConstitution(projectPath);
-  
+
   // Parse features
   ir.features = await parseFeatures(projectPath);
-  
+
   // Parse templates
   ir.templates = await parseTemplates(projectPath);
-  
+
   // Parse memories
   ir.memories = await parseMemories(projectPath);
-  
+
   return ir;
 }
 
 /**
  * Parse project metadata from project.yml
- * @param {string} projectPath 
+ * @param {string} projectPath
  * @returns {Promise<import('../ir/types').ProjectMetadata>}
  */
 async function parseProjectMetadata(projectPath) {
   const projectYmlPath = path.join(projectPath, 'steering', 'project.yml');
   const productMdPath = path.join(projectPath, 'steering', 'product.md');
-  
+
   const metadata = {
     name: '',
     version: '1.0.0',
@@ -54,13 +58,13 @@ async function parseProjectMetadata(projectPath) {
     convertedAt: new Date(),
     preservedFields: {},
   };
-  
+
   // Try to load project.yml
   if (await fs.pathExists(projectYmlPath)) {
     try {
       const content = await fs.readFile(projectYmlPath, 'utf-8');
       const projectYml = yaml.load(content);
-      
+
       metadata.name = projectYml.project?.name || '';
       metadata.version = projectYml.project?.version || '1.0.0';
       metadata.preservedFields.projectYml = projectYml;
@@ -68,9 +72,9 @@ async function parseProjectMetadata(projectPath) {
       console.warn(`Warning: Failed to parse project.yml: ${error.message}`);
     }
   }
-  
+
   // Try to extract name from product.md if not found
-  if (!metadata.name && await fs.pathExists(productMdPath)) {
+  if (!metadata.name && (await fs.pathExists(productMdPath))) {
     try {
       const content = await fs.readFile(productMdPath, 'utf-8');
       const titleMatch = content.match(/^#\s+(.+)$/m);
@@ -81,18 +85,18 @@ async function parseProjectMetadata(projectPath) {
       console.warn(`Warning: Failed to parse product.md: ${error.message}`);
     }
   }
-  
+
   return metadata;
 }
 
 /**
  * Parse constitution from steering/rules/constitution.md
- * @param {string} projectPath 
+ * @param {string} projectPath
  * @returns {Promise<import('../ir/types').ConstitutionIR>}
  */
 async function parseConstitution(projectPath) {
   const constitutionPath = path.join(projectPath, 'steering', 'rules', 'constitution.md');
-  
+
   const constitution = {
     articles: [],
     corePrinciples: [],
@@ -101,31 +105,31 @@ async function parseConstitution(projectPath) {
       rules: [],
     },
   };
-  
-  if (!await fs.pathExists(constitutionPath)) {
+
+  if (!(await fs.pathExists(constitutionPath))) {
     return constitution;
   }
-  
+
   try {
     const content = await fs.readFile(constitutionPath, 'utf-8');
     constitution.rawContent = content;
-    
+
     // Parse articles
     const articleRegex = /##\s+Article\s+(\d+)[:\s]+(.+?)(?=\n##|\n$|$)/gs;
     let match;
-    
+
     while ((match = articleRegex.exec(content)) !== null) {
       const articleNumber = parseInt(match[1], 10);
       const articleContent = match[2].trim();
-      
+
       // Extract article name from first line
       const lines = articleContent.split('\n');
       const name = lines[0].trim();
-      
+
       // Extract description (everything after name until rules)
       let description = '';
       let rulesStart = -1;
-      
+
       for (let i = 1; i < lines.length; i++) {
         if (lines[i].match(/^[-*]\s+/)) {
           rulesStart = i;
@@ -133,7 +137,7 @@ async function parseConstitution(projectPath) {
         }
         description += lines[i] + '\n';
       }
-      
+
       // Extract rules (bullet points)
       const rules = [];
       if (rulesStart !== -1) {
@@ -144,7 +148,7 @@ async function parseConstitution(projectPath) {
           }
         }
       }
-      
+
       constitution.articles.push({
         number: articleNumber,
         name,
@@ -152,7 +156,7 @@ async function parseConstitution(projectPath) {
         rules,
       });
     }
-    
+
     // Parse governance section if present
     const governanceMatch = content.match(/##\s+Governance\s*\n([\s\S]+?)(?=\n##|$)/);
     if (governanceMatch) {
@@ -161,7 +165,7 @@ async function parseConstitution(projectPath) {
       if (versionMatch) {
         constitution.governance.version = versionMatch[1];
       }
-      
+
       // Extract governance rules
       const ruleLines = governanceContent.match(/^[-*]\s+(.+)/gm);
       if (ruleLines) {
@@ -171,26 +175,26 @@ async function parseConstitution(projectPath) {
   } catch (error) {
     console.warn(`Warning: Failed to parse constitution: ${error.message}`);
   }
-  
+
   return constitution;
 }
 
 /**
  * Parse features from storage/specs/
- * @param {string} projectPath 
+ * @param {string} projectPath
  * @returns {Promise<import('../ir/types').FeatureIR[]>}
  */
 async function parseFeatures(projectPath) {
   const specsPath = path.join(projectPath, 'storage', 'specs');
   const features = [];
-  
-  if (!await fs.pathExists(specsPath)) {
+
+  if (!(await fs.pathExists(specsPath))) {
     return features;
   }
-  
+
   try {
     const entries = await fs.readdir(specsPath, { withFileTypes: true });
-    
+
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const featurePath = path.join(specsPath, entry.name);
@@ -203,66 +207,66 @@ async function parseFeatures(projectPath) {
   } catch (error) {
     console.warn(`Warning: Failed to parse features: ${error.message}`);
   }
-  
+
   return features;
 }
 
 /**
  * Parse a single feature
- * @param {string} featurePath 
- * @param {string} featureId 
+ * @param {string} featurePath
+ * @param {string} featureId
  * @returns {Promise<import('../ir/types').FeatureIR|null>}
  */
 async function parseFeature(featurePath, featureId) {
   const feature = createEmptyFeatureIR(featureId, featureId);
-  
+
   // Parse spec.md
   const specPath = path.join(featurePath, 'spec.md');
   if (await fs.pathExists(specPath)) {
     feature.specification = await parseSpecification(specPath);
   }
-  
+
   // Parse plan.md
   const planPath = path.join(featurePath, 'plan.md');
   if (await fs.pathExists(planPath)) {
     feature.plan = await parsePlan(planPath);
   }
-  
+
   // Parse tasks.md
   const tasksPath = path.join(featurePath, 'tasks.md');
   if (await fs.pathExists(tasksPath)) {
     feature.tasks = await parseTasks(tasksPath);
   }
-  
+
   // Parse research.md
   const researchPath = path.join(featurePath, 'research.md');
   if (await fs.pathExists(researchPath)) {
     feature.research = await parseResearch(researchPath);
   }
-  
+
   // Parse data-model.md
   const dataModelPath = path.join(featurePath, 'data-model.md');
   if (await fs.pathExists(dataModelPath)) {
     feature.dataModel = await parseDataModel(dataModelPath);
   }
-  
+
   // Parse contracts directory
   const contractsPath = path.join(featurePath, 'contracts');
   if (await fs.pathExists(contractsPath)) {
     feature.contracts = await parseContracts(contractsPath);
   }
-  
+
   return feature;
 }
 
 /**
  * Parse specification file
- * @param {string} specPath 
+ * @param {string} specPath
  * @returns {Promise<import('../ir/types').SpecificationIR>}
  */
 async function parseSpecification(specPath) {
   const content = await fs.readFile(specPath, 'utf-8');
-  
+
   const specification = {
     title: '',
     description: '',
@@ -271,33 +275,33 @@ async function parseSpecification(specPath) {
     successCriteria: [],
     rawContent: content,
   };
-  
+
   // Extract title from first heading
   const titleMatch = content.match(/^#\s+(.+)$/m);
   if (titleMatch) {
     specification.title = titleMatch[1].trim();
   }
-  
+
   // Extract description (content before first ## heading)
   const descMatch = content.match(/^#\s+.+\n([\s\S]+?)(?=\n##|$)/);
   if (descMatch) {
     specification.description = descMatch[1].trim();
   }
-  
+
   // Parse EARS requirements
   const requirementsSection = content.match(/##\s+Requirements?\s*\n([\s\S]+?)(?=\n##[^#]|$)/i);
   if (requirementsSection) {
     const reqContent = requirementsSection[1];
-    
+
     // Match requirement patterns like REQ-001, REQ-P0-001, etc.
     // Use greedy match until next ### or ## (non-###) heading
     const reqRegex = /###?\s+(REQ[-\w]+)[:\s]+([^#]+?)(?=\n###?\s+REQ|\n##[^#]|$)/gs;
     let match;
-    
+
     while ((match = reqRegex.exec(reqContent)) !== null) {
       const reqId = match[1];
       const reqBody = match[2].trim();
-      
+
       // Extract EARS statement
       const earsMatch = reqBody.match(/((?:WHEN|WHILE|WHERE|IF)[\s\S]+?SHALL[\s\S]+?\.)/i);
       if (earsMatch) {
@@ -316,7 +320,7 @@ async function parseSpecification(specPath) {
       }
     }
   }
-  
+
   // Parse success criteria
   const successSection = content.match(/##\s+Success\s+Criteria\s*\n([\s\S]+?)(?=\n##|$)/i);
   if (successSection) {
@@ -326,13 +330,13 @@ async function parseSpecification(specPath) {
       specification.successCriteria = criteria.map(c => c.replace(/^[-*]\s+/, ''));
     }
   }
-  
+
   return specification;
 }
 
 /**
  * Extract priority from requirement ID
- * @param {string} reqId 
+ * @param {string} reqId
  * @returns {import('../ir/types').Priority}
  */
 function extractPriority(reqId) {
@@ -345,12 +349,12 @@ function extractPriority(reqId) {
 
 /**
  * Parse plan file
- * @param {string} planPath 
+ * @param {string} planPath
  * @returns {Promise<import('../ir/types').PlanIR>}
  */
 async function parsePlan(planPath) {
   const content = await fs.readFile(planPath, 'utf-8');
-  
+
   const plan = {
     summary: '',
     technicalContext: {
@@ -369,47 +373,47 @@ async function parsePlan(planPath) {
     phases: [],
     rawContent: content,
   };
-  
+
   // Extract summary from first paragraph
   const summaryMatch = content.match(/^#\s+.+\n([\s\S]+?)(?=\n##|$)/);
   if (summaryMatch) {
     plan.summary = summaryMatch[1].trim();
   }
-  
+
   // Parse technical context
   const techSection = content.match(/##\s+Technical\s+Context\s*\n([\s\S]+?)(?=\n##|$)/i);
   if (techSection) {
     const techContent = techSection[1];
-    
+
     // Extract key-value pairs
     const langMatch = techContent.match(/language[:\s]+(.+)/i);
     if (langMatch) plan.technicalContext.language = langMatch[1].trim();
-    
+
     const versionMatch = techContent.match(/version[:\s]+(.+)/i);
     if (versionMatch) plan.technicalContext.version = versionMatch[1].trim();
-    
+
     const frameworkMatch = techContent.match(/framework[:\s]+(.+)/i);
     if (frameworkMatch) plan.technicalContext.framework = frameworkMatch[1].trim();
-    
+
     const testingMatch = techContent.match(/testing[:\s]+(.+)/i);
     if (testingMatch) plan.technicalContext.testing = testingMatch[1].trim();
-    
+
     const platformMatch = techContent.match(/platform[:\s]+(.+)/i);
     if (platformMatch) plan.technicalContext.targetPlatform = platformMatch[1].trim();
   }
-  
+
   // Parse phases
   const phasesSection = content.match(/##\s+Phases?\s*\n([\s\S]+?)(?=\n##|$)/i);
   if (phasesSection) {
     const phasesContent = phasesSection[1];
     const phaseRegex = /###\s+Phase\s+(\d+)[:\s]+(.+?)(?=\n###|\n##|$)/gs;
     let match;
-    
+
     while ((match = phaseRegex.exec(phasesContent)) !== null) {
       const phaseNumber = parseInt(match[1], 10);
       const phaseContent = match[2].trim();
       const lines = phaseContent.split('\n');
-      
+
       plan.phases.push({
         number: phaseNumber,
         name: lines[0].trim(),
@@ -419,28 +423,28 @@ async function parsePlan(planPath) {
       });
     }
   }
-  
+
   return plan;
 }
 
 /**
  * Parse tasks file
- * @param {string} tasksPath 
+ * @param {string} tasksPath
  * @returns {Promise<import('../ir/types').TaskIR[]>}
  */
 async function parseTasks(tasksPath) {
   const content = await fs.readFile(tasksPath, 'utf-8');
   const tasks = [];
-  
+
   // Match task lines like: - [ ] T001: Description
   const taskRegex = /^[-*]\s+\[([xX ])\]\s+(T\d+)[:\s]+(.+)$/gm;
   let match;
-  
+
   while ((match = taskRegex.exec(content)) !== null) {
     const completed = match[1].toLowerCase() === 'x';
     const taskId = match[2];
     const description = match[3].trim();
-    
+
     // Extract phase from context
     let phase = 1;
     const phaseMatch = content.slice(0, match.index).match(/##\s+Phase\s+(\d+)/gi);
@@ -451,18 +455,18 @@ async function parseTasks(tasksPath) {
         phase = parseInt(phaseNum[1], 10);
       }
     }
-    
+
     // Check for parallel marker [P]
     const parallel = description.includes('[P]');
-    
+
     // Extract file path if present
     const filePathMatch = description.match(/(?:at|in|path:)\s+([^\s]+)/i);
     const filePath = filePathMatch ? filePathMatch[1] : undefined;
-    
+
     // Extract user story reference
     const storyMatch = description.match(/\[US\d+\]/);
-    const userStory = storyMatch ? storyMatch[0].replace(/[\[\]]/g, '') : undefined;
-    
+    const userStory = storyMatch ? storyMatch[0].replace(/[[\]]/g, '') : undefined;
+
     tasks.push({
       id: taskId,
       description: description.replace(/\[P\]|\[US\d+\]/g, '').trim(),
@@ -473,38 +477,38 @@ async function parseTasks(tasksPath) {
       completed,
     });
   }
-  
+
   return tasks;
 }
 
 /**
  * Parse research file
- * @param {string} researchPath 
+ * @param {string} researchPath
  * @returns {Promise<import('../ir/types').ResearchIR>}
  */
 async function parseResearch(researchPath) {
   const content = await fs.readFile(researchPath, 'utf-8');
-  
+
   const research = {
     decisions: [],
     alternatives: [],
     rawContent: content,
   };
-  
+
   // Parse decisions section
   const decisionsSection = content.match(/##\s+Decisions?\s*\n([\s\S]+?)(?=\n##|$)/i);
   if (decisionsSection) {
     const decisionContent = decisionsSection[1];
     const decisionRegex = /###\s+(.+?)\n([\s\S]+?)(?=\n###|$)/g;
     let match;
-    
+
     while ((match = decisionRegex.exec(decisionContent)) !== null) {
       const topic = match[1].trim();
       const body = match[2].trim();
-      
+
       const decisionMatch = body.match(/decision[:\s]+(.+)/i);
       const rationaleMatch = body.match(/rationale[:\s]+(.+)/i);
-      
+
       research.decisions.push({
         topic,
         decision: decisionMatch ? decisionMatch[1].trim() : body.split('\n')[0],
@@ -512,31 +516,31 @@ async function parseResearch(researchPath) {
       });
     }
   }
-  
+
   // Parse alternatives section
   const alternativesSection = content.match(/##\s+Alternatives?\s*\n([\s\S]+?)(?=\n##|$)/i);
   if (alternativesSection) {
     const altContent = alternativesSection[1];
     const altRegex = /###\s+(.+?)\n([\s\S]+?)(?=\n###|$)/g;
     let match;
-    
+
     while ((match = altRegex.exec(altContent)) !== null) {
       const name = match[1].trim();
       const body = match[2].trim();
-      
+
       // Extract pros and cons
       const prosMatch = body.match(/pros?[:\s]*([\s\S]+?)(?=cons?|rejected|$)/i);
       const consMatch = body.match(/cons?[:\s]*([\s\S]+?)(?=pros?|rejected|$)/i);
       const rejectedMatch = body.match(/rejected[:\s]*(yes|no|true|false)/i);
       const reasonMatch = body.match(/reason[:\s]+(.+)/i);
-      
-      const pros = prosMatch 
+
+      const pros = prosMatch
         ? (prosMatch[1].match(/^[-*]\s+(.+)/gm) || []).map(p => p.replace(/^[-*]\s+/, ''))
         : [];
-      const cons = consMatch 
+      const cons = consMatch
         ? (consMatch[1].match(/^[-*]\s+(.+)/gm) || []).map(c => c.replace(/^[-*]\s+/, ''))
         : [];
-      
+
       research.alternatives.push({
         name,
         pros,
@@ -546,37 +550,37 @@ async function parseResearch(researchPath) {
       });
     }
   }
-  
+
   return research;
 }
 
 /**
  * Parse data model file
- * @param {string} dataModelPath 
+ * @param {string} dataModelPath
  * @returns {Promise<import('../ir/types').DataModelIR>}
  */
 async function parseDataModel(dataModelPath) {
   const content = await fs.readFile(dataModelPath, 'utf-8');
-  
+
   const dataModel = {
     entities: [],
     relationships: [],
     rawContent: content,
   };
-  
+
   // Parse entities (look for ### Entity: Name or ### Name patterns)
   const entityRegex = /###\s+(?:Entity:?\s+)?(\w+)\s*\n([\s\S]+?)(?=\n###|$)/gi;
   let match;
-  
+
   while ((match = entityRegex.exec(content)) !== null) {
     const name = match[1];
     const body = match[2].trim();
-    
+
     // Extract fields from table or list
     const fields = [];
     const fieldRegex = /[-*]\s+(\w+):\s+(.+)/g;
     let fieldMatch;
-    
+
     while ((fieldMatch = fieldRegex.exec(body)) !== null) {
       fields.push({
         name: fieldMatch[1],
@@ -585,21 +589,21 @@ async function parseDataModel(dataModelPath) {
         unique: false,
       });
     }
-    
+
     dataModel.entities.push({
       name,
       description: '',
       fields,
     });
   }
-  
+
   // Parse relationships
   const relationshipSection = content.match(/##\s+Relationships?\s*\n([\s\S]+?)(?=\n##|$)/i);
   if (relationshipSection) {
     const relContent = relationshipSection[1];
     const relRegex = /(\w+)\s*(?:→|->|has many|has one|belongs to)\s*(\w+)/gi;
     let relMatch;
-    
+
     while ((relMatch = relRegex.exec(relContent)) !== null) {
       dataModel.relationships.push({
         from: relMatch[1],
@@ -608,38 +612,42 @@ async function parseDataModel(dataModelPath) {
       });
     }
   }
-  
+
   return dataModel;
 }
 
 /**
  * Parse contracts directory
- * @param {string} contractsPath 
+ * @param {string} contractsPath
  * @returns {Promise<import('../ir/types').ContractIR[]>}
  */
 async function parseContracts(contractsPath) {
   const contracts = [];
-  
+
   try {
     const entries = await fs.readdir(contractsPath, { withFileTypes: true });
-    
+
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith('.md')) {
         const contractFile = path.join(contractsPath, entry.name);
         const content = await fs.readFile(contractFile, 'utf-8');
-        
+
         // Determine contract type
         let type = 'other';
         if (content.includes('REST') || content.includes('GET') || content.includes('POST')) {
           type = 'rest';
-        } else if (content.includes('GraphQL') || content.includes('query') || content.includes('mutation')) {
+        } else if (
+          content.includes('GraphQL') ||
+          content.includes('query') ||
+          content.includes('mutation')
+        ) {
           type = 'graphql';
         } else if (content.includes('gRPC')) {
           type = 'grpc';
         } else if (content.includes('WebSocket')) {
           type = 'websocket';
         }
-        
+
         contracts.push({
           type,
           name: entry.name.replace('.md', ''),
@@ -651,31 +659,31 @@ async function parseContracts(contractsPath) {
   } catch (error) {
     console.warn(`Warning: Failed to parse contracts: ${error.message}`);
   }
-  
+
   return contracts;
 }
 
 /**
  * Parse templates from steering/templates/
- * @param {string} projectPath 
+ * @param {string} projectPath
  * @returns {Promise<import('../ir/types').TemplateIR[]>}
  */
 async function parseTemplates(projectPath) {
   const templatesPath = path.join(projectPath, 'steering', 'templates');
   const templates = [];
-  
-  if (!await fs.pathExists(templatesPath)) {
+
+  if (!(await fs.pathExists(templatesPath))) {
     return templates;
   }
-  
+
   try {
     const entries = await fs.readdir(templatesPath, { withFileTypes: true });
-    
+
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith('.md')) {
         const templateFile = path.join(templatesPath, entry.name);
         const content = await fs.readFile(templateFile, 'utf-8');
-        
+
         // Determine template type
         let type = 'other';
         if (entry.name.includes('spec')) {
@@ -685,7 +693,7 @@ async function parseTemplates(projectPath) {
         } else if (entry.name.includes('task')) {
           type = 'tasks';
         }
-        
+
         templates.push({
           name: entry.name.replace('.md', ''),
           type,
@@ -696,31 +704,31 @@ async function parseTemplates(projectPath) {
   } catch (error) {
     console.warn(`Warning: Failed to parse templates: ${error.message}`);
   }
-  
+
   return templates;
 }
 
 /**
  * Parse memories from steering/memories/
- * @param {string} projectPath 
+ * @param {string} projectPath
  * @returns {Promise<import('../ir/types').MemoryIR[]>}
  */
 async function parseMemories(projectPath) {
   const memoriesPath = path.join(projectPath, 'steering', 'memories');
   const memories = [];
-  
-  if (!await fs.pathExists(memoriesPath)) {
+
+  if (!(await fs.pathExists(memoriesPath))) {
     return memories;
   }
-  
+
   try {
     const entries = await fs.readdir(memoriesPath, { withFileTypes: true });
-    
+
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith('.md')) {
         const memoryFile = path.join(memoriesPath, entry.name);
         const content = await fs.readFile(memoryFile, 'utf-8');
-        
+
         // Determine memory type
         let type = 'context';
         if (entry.name.includes('decision')) {
@@ -728,7 +736,7 @@ async function parseMemories(projectPath) {
         } else if (entry.name.includes('learning')) {
           type = 'learning';
         }
-        
+
         memories.push({
           category: type,
           entries: [{ content, source: entry.name }],
@@ -738,7 +746,7 @@ async function parseMemories(projectPath) {
   } catch (error) {
     console.warn(`Warning: Failed to parse memories: ${error.message}`);
   }
-  
+
   return memories;
 }