@polymorphism-tech/morph-spec 2.4.0 → 3.0.0

package/src/lib/troubleshoot-grep.js

@@ -1,194 +1,194 @@
-/**
- * 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';
+
+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
+};

package/src/lib/troubleshoot-index.js

@@ -1,144 +1,144 @@
-/**
- * Troubleshoot Index Search
- * Searches the troubleshooting-index.json for matching problems
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-/**
- * Load the troubleshooting index
- * @returns {Object} The index object or null if not found
- */
-export function loadIndex() {
-  const indexPath = join(__dirname, '../../framework/index/troubleshooting-index.json');
-
-  if (!existsSync(indexPath)) {
-    return null;
-  }
-
-  try {
-    const content = readFileSync(indexPath, 'utf-8');
-    return JSON.parse(content);
-  } catch (error) {
-    console.error('Error loading troubleshooting index:', error.message);
-    return null;
-  }
-}
-
-/**
- * Calculate relevance score for a problem based on keywords
- * @param {Object} problem - The problem object from index
- * @param {string[]} searchTerms - Search terms from user
- * @returns {number} Relevance score (higher is better)
- */
-function calculateScore(problem, searchTerms) {
-  let score = 0;
-  const searchLower = searchTerms.map(t => t.toLowerCase());
-
-  // Check keywords
-  for (const keyword of problem.keywords) {
-    const keywordLower = keyword.toLowerCase();
-    for (const term of searchLower) {
-      if (keywordLower.includes(term) || term.includes(keywordLower)) {
-        score += 10;
-      }
-    }
-  }
-
-  // Check title
-  const titleLower = problem.title.toLowerCase();
-  for (const term of searchLower) {
-    if (titleLower.includes(term)) {
-      score += 5;
-    }
-  }
-
-  // Check error pattern (regex match on search string)
-  if (problem.errorPattern) {
-    try {
-      const regex = new RegExp(problem.errorPattern, 'i');
-      const searchString = searchTerms.join(' ');
-      if (regex.test(searchString)) {
-        score += 20; // High score for error pattern match
-      }
-    } catch (e) {
-      // Invalid regex, skip
-    }
-  }
-
-  // Boost critical severity
-  if (problem.severity === 'critical') {
-    score *= 1.2;
-  }
-
-  return score;
-}
-
-/**
- * Search the index for problems matching the keywords
- * @param {string[]} keywords - Search keywords
- * @param {Object} options - Search options
- * @param {string} options.category - Filter by category
- * @returns {Object[]} Array of matching problems with scores
- */
-export function searchIndex(keywords, options = {}) {
-  const index = loadIndex();
-
-  if (!index || !index.problems) {
-    return [];
-  }
-
-  let problems = index.problems;
-
-  // Filter by category if specified
-  if (options.category) {
-    problems = problems.filter(p => p.category === options.category);
-  }
-
-  // Score and filter problems
-  const results = problems
-    .map(problem => ({
-      ...problem,
-      score: calculateScore(problem, keywords)
-    }))
-    .filter(p => p.score > 0)
-    .sort((a, b) => b.score - a.score);
-
-  return results;
-}
-
-/**
- * Get all categories from the index
- * @returns {Object} Categories object
- */
-export function getCategories() {
-  const index = loadIndex();
-  return index?.categories || {};
-}
-
-/**
- * Get a specific problem by ID
- * @param {string} id - Problem ID
- * @returns {Object|null} Problem object or null
- */
-export function getProblemById(id) {
-  const index = loadIndex();
-
-  if (!index || !index.problems) {
-    return null;
-  }
-
-  return index.problems.find(p => p.id === id) || null;
-}
-
-export default {
-  loadIndex,
-  searchIndex,
-  getCategories,
-  getProblemById
-};
+/**
+ * Troubleshoot Index Search
+ * Searches the troubleshooting-index.json for matching problems
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Load the troubleshooting index
+ * @returns {Object} The index object or null if not found
+ */
+export function loadIndex() {
+  const indexPath = join(__dirname, '../../framework/index/troubleshooting-index.json');
+
+  if (!existsSync(indexPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(indexPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error('Error loading troubleshooting index:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Calculate relevance score for a problem based on keywords
+ * @param {Object} problem - The problem object from index
+ * @param {string[]} searchTerms - Search terms from user
+ * @returns {number} Relevance score (higher is better)
+ */
+function calculateScore(problem, searchTerms) {
+  let score = 0;
+  const searchLower = searchTerms.map(t => t.toLowerCase());
+
+  // Check keywords
+  for (const keyword of problem.keywords) {
+    const keywordLower = keyword.toLowerCase();
+    for (const term of searchLower) {
+      if (keywordLower.includes(term) || term.includes(keywordLower)) {
+        score += 10;
+      }
+    }
+  }
+
+  // Check title
+  const titleLower = problem.title.toLowerCase();
+  for (const term of searchLower) {
+    if (titleLower.includes(term)) {
+      score += 5;
+    }
+  }
+
+  // Check error pattern (regex match on search string)
+  if (problem.errorPattern) {
+    try {
+      const regex = new RegExp(problem.errorPattern, 'i');
+      const searchString = searchTerms.join(' ');
+      if (regex.test(searchString)) {
+        score += 20; // High score for error pattern match
+      }
+    } catch (e) {
+      // Invalid regex, skip
+    }
+  }
+
+  // Boost critical severity
+  if (problem.severity === 'critical') {
+    score *= 1.2;
+  }
+
+  return score;
+}
+
+/**
+ * Search the index for problems matching the keywords
+ * @param {string[]} keywords - Search keywords
+ * @param {Object} options - Search options
+ * @param {string} options.category - Filter by category
+ * @returns {Object[]} Array of matching problems with scores
+ */
+export function searchIndex(keywords, options = {}) {
+  const index = loadIndex();
+
+  if (!index || !index.problems) {
+    return [];
+  }
+
+  let problems = index.problems;
+
+  // Filter by category if specified
+  if (options.category) {
+    problems = problems.filter(p => p.category === options.category);
+  }
+
+  // Score and filter problems
+  const results = problems
+    .map(problem => ({
+      ...problem,
+      score: calculateScore(problem, keywords)
+    }))
+    .filter(p => p.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  return results;
+}
+
+/**
+ * Get all categories from the index
+ * @returns {Object} Categories object
+ */
+export function getCategories() {
+  const index = loadIndex();
+  return index?.categories || {};
+}
+
+/**
+ * Get a specific problem by ID
+ * @param {string} id - Problem ID
+ * @returns {Object|null} Problem object or null
+ */
+export function getProblemById(id) {
+  const index = loadIndex();
+
+  if (!index || !index.problems) {
+    return null;
+  }
+
+  return index.problems.find(p => p.id === id) || null;
+}
+
+export default {
+  loadIndex,
+  searchIndex,
+  getCategories,
+  getProblemById
+};