@udx/mq 0.1.1

package/lib/operations/index.js

@@ -0,0 +1,151 @@
+/**
+ * Operations index for Markdown Query
+ * 
+ * Entry point for all query and transform operations
+ */
+
+import { visit } from 'unist-util-visit';
+import { toMarkdown } from 'mdast-util-to-markdown';
+import _ from 'lodash';
+
+// Import all operations
+import { 
+  extractHeadings, 
+  extractCodeBlocks, 
+  extractLinks, 
+  generateToc,
+  extractSections 
+} from './extractors.js';
+
+import { 
+  analyzeDocument, 
+  showDocumentStructure, 
+  countDocumentElements 
+} from './analysis.js';
+
+import {
+  makeCodeBlocksCollapsible,
+  makeDescriptiveToc,
+  addCrossLinks,
+  fixHeadingHierarchy,
+  moveSection,
+  updateTOCNumbers,
+  insertTOC,
+  convertHTMLToMarkdown
+} from './transformers.js';
+
+/**
+ * Query operations map
+ * 
+ * Maps operation names to their implementing functions
+ */
+const queryOperations = {
+  headings: extractHeadings,
+  codeblocks: extractCodeBlocks,
+  links: extractLinks,
+  toc: generateToc,
+  sections: extractSections,
+  structure: showDocumentStructure,
+  analyze: analyzeDocument,
+  count: countDocumentElements
+};
+
+/**
+ * Transform operations map
+ * 
+ * Maps transform operation names to their implementing functions
+ */
+const transformOperations = {
+  'collapsible-code': makeCodeBlocksCollapsible,
+  'descriptive-toc': makeDescriptiveToc,
+  'add-cross-links': addCrossLinks,
+  'fix-headings': fixHeadingHierarchy,
+  'move-section': moveSection,
+  'update-toc-numbers': updateTOCNumbers,
+  'insert-toc': insertTOC,
+  'html-to-md': convertHTMLToMarkdown
+};
+
+/**
+ * Get operation by name
+ * 
+ * Retrieves a query or transform operation by its name
+ * 
+ * @param {string} name - Operation name
+ * @param {string} type - Operation type (query or transform)
+ * @returns {Function} Operation function
+ */
+function getOperation(name, type = 'query') {
+  const operations = type === 'query' ? queryOperations : transformOperations;
+  return operations[name];
+}
+
+/**
+ * Register new operation
+ * 
+ * Adds a new operation to the operations map
+ * 
+ * @param {string} name - Operation name
+ * @param {Function} fn - Operation implementation
+ * @param {string} type - Operation type (query or transform)
+ */
+function registerOperation(name, fn, type = 'query') {
+  if (type === 'query') {
+    queryOperations[name] = fn;
+  } else {
+    transformOperations[name] = fn;
+  }
+}
+
+/**
+ * List all available operations
+ * 
+ * @param {string} type - Operation type (query, transform, or all)
+ * @returns {Object} Map of operation names to descriptions
+ */
+function listOperations(type = 'all') {
+  const operations = {};
+  
+  if (type === 'query' || type === 'all') {
+    Object.keys(queryOperations).forEach(name => {
+      operations[name] = `Query operation: ${name}`;
+    });
+  }
+  
+  if (type === 'transform' || type === 'all') {
+    Object.keys(transformOperations).forEach(name => {
+      operations[name] = `Transform operation: ${name}`;
+    });
+  }
+  
+  return operations;
+}
+
+/**
+ * Execute operation by name
+ * 
+ * @param {string} name - Operation name
+ * @param {Object} ast - Markdown AST
+ * @param {string} selector - Query selector
+ * @param {Array} args - Additional arguments for the operation
+ * @param {string} type - Operation type (query or transform)
+ * @returns {*} Operation result
+ */
+function executeOperation(name, ast, selector, args = [], type = 'query') {
+  const operation = getOperation(name, type);
+  
+  if (!operation) {
+    throw new Error(`Operation "${name}" not found`);
+  }
+  
+  return operation(ast, selector, ...args);
+}
+
+export {
+  queryOperations,
+  transformOperations,
+  getOperation,
+  registerOperation,
+  listOperations,
+  executeOperation
+};

package/lib/operations/transformers.js

@@ -0,0 +1,411 @@
+/**
+ * Transformer operations for Markdown Query
+ * 
+ * Functions for transforming markdown content in various ways
+ */
+
+import { toString } from 'mdast-util-to-string';
+import { visit } from 'unist-util-visit';
+import { toMarkdown } from 'mdast-util-to-markdown';
+import _ from 'lodash';
+import { extractHeadings, extractSections } from './extractors.js';
+
+/**
+ * Make code blocks collapsible
+ * 
+ * Transforms code blocks in markdown to use HTML details/summary tags for collapsible sections
+ * 
+ * @param {Object} ast - Markdown AST
+ * @param {string} selector - Optional selector (not used in this function)
+ * @returns {string} Transformed markdown with collapsible code blocks
+ */
+function makeCodeBlocksCollapsible(ast, selector) {
+  let markdown = toMarkdown(ast);
+  
+  // Find code blocks with regex
+  const codeBlockRegex = /```([a-zA-Z]*)\n([\s\S]*?)```/g;
+  
+  // Replace each code block with a collapsible version
+  markdown = markdown.replace(codeBlockRegex, (match, language, code) => {
+    // Create a summary based on the language
+    const summary = language ? `${language} code` : 'Code block';
+    
+    // Create the collapsible HTML
+    return `<details>
+<summary>${summary}</summary>
+
+\`\`\`${language}
+${code}
+\`\`\`
+</details>`;
+  });
+  
+  return markdown;
+}
+
+/**
+ * Make TOC descriptive
+ * 
+ * Enhances the table of contents by adding descriptions from the first sentence
+ * of paragraphs following each heading
+ * 
+ * @param {Object} ast - Markdown AST
+ * @param {string} selector - Optional selector (not used in this function)
+ * @returns {Object} Modified AST with heading descriptions
+ */
+function makeDescriptiveToc(ast, selector) {
+  visit(ast, 'heading', (node) => {
+    // Find the next paragraph for description
+    const headingIndex = ast.children.indexOf(node);
+    if (headingIndex >= 0 && headingIndex < ast.children.length - 1) {
+      const nextNode = ast.children[headingIndex + 1];
+      if (nextNode.type === 'paragraph') {
+        // Add description to heading data
+        node.data = node.data || {};
+        node.data.description = toString(nextNode).split('.')[0]; // First sentence
+      }
+    }
+  });
+  
+  return ast;
+}
+
+/**
+ * Add cross-links section
+ * 
+ * Adds a "Related Documents" section with links to other markdown documents
+ * after the table of contents section
+ * 
+ * @param {Object} ast - Markdown AST
+ * @param {string} selector - Optional selector (not used in this function)
+ * @param {Array} args - Array of document paths to link to
+ * @returns {Object} Modified AST with cross-links section
+ */
+function addCrossLinks(ast, selector, args) {
+  const docs = args || [];
+  
+  // Find the TOC section to add after
+  let tocIndex = -1;
+  visit(ast, 'heading', (node, index) => {
+    if (toString(node).toLowerCase() === 'table of contents') {
+      tocIndex = index;
+    }
+  });
+  
+  if (tocIndex >= 0) {
+    // Find the next heading after TOC
+    let nextHeadingIndex = ast.children.length;
+    for (let i = tocIndex + 1; i < ast.children.length; i++) {
+      if (ast.children[i].type === 'heading') {
+        nextHeadingIndex = i;
+        break;
+      }
+    }
+    
+    // Create cross-links section
+    const crossLinksHeading = {
+      type: 'heading',
+      depth: 3,
+      children: [{ type: 'text', value: 'Related Documents' }]
+    };
+    
+    const crossLinksList = {
+      type: 'list',
+      ordered: false,
+      children: docs.map(doc => ({
+        type: 'listItem',
+        children: [{
+          type: 'paragraph',
+          children: [{
+            type: 'link',
+            url: doc,
+            children: [{
+              type: 'text',
+              value: doc.replace('.md', '').split('-').map(
+                word => word.charAt(0).toUpperCase() + word.slice(1)
+              ).join(' ')
+            }]
+          }]
+        }]
+      }))
+    };
+    
+    // Insert the cross-links section
+    ast.children.splice(nextHeadingIndex, 0, crossLinksHeading, crossLinksList);
+  }
+  
+  return ast;
+}
+
+/**
+ * Fix heading hierarchy
+ * 
+ * Ensures that heading levels in a document follow a proper hierarchy without skipping levels
+ * 
+ * @param {Object} ast - Markdown AST
+ * @param {string} selector - Optional selector (not used in this function)
+ * @returns {Object} Modified AST with corrected heading hierarchy
+ */
+function fixHeadingHierarchy(ast, selector) {
+  let lastLevel = 0;
+  visit(ast, 'heading', (node) => {
+    if (node.depth > lastLevel + 1 && lastLevel > 0) {
+      node.depth = lastLevel + 1;
+    }
+    lastLevel = node.depth;
+  });
+  
+  return ast;
+}
+
+/**
+ * Move a section from one position to another
+ * 
+ * Moves a section identified by its title to a new position in the document
+ * 
+ * @param {Object} ast - Markdown AST
+ * @param {string} fromTitle - Title of the section to move
+ * @param {number} toPosition - Position to move the section to
+ * @returns {Object} New AST with the section moved
+ */
+function moveSection(ast, fromTitle, toPosition) {
+  const sections = extractSections(ast);
+  const fromIndex = sections.findIndex(section => section.title === fromTitle);
+  
+  if (fromIndex === -1) {
+    throw new Error(`Section "${fromTitle}" not found`);
+  }
+  
+  const section = sections.splice(fromIndex, 1)[0];
+  sections.splice(toPosition, 0, section);
+  
+  // Rebuild AST from sections
+  const newAst = {
+    type: 'root',
+    children: []
+  };
+  
+  sections.forEach(section => {
+    newAst.children.push(...section.content);
+  });
+  
+  return newAst;
+}
+
+/**
+ * Update TOC numbers
+ * 
+ * Updates the table of contents with section numbers for better navigation
+ * 
+ * @param {Object} ast - Markdown AST
+ * @param {string} selector - Optional selector (not used in this function)
+ * @returns {Object} Modified AST with numbered TOC
+ */
+function updateTOCNumbers(ast, selector) {
+  // Find the TOC section
+  let tocIndex = -1;
+  visit(ast, 'heading', (node, index) => {
+    if (toString(node).toLowerCase() === 'table of contents') {
+      tocIndex = index;
+    }
+  });
+  
+  if (tocIndex >= 0) {
+    // Find the list that follows the TOC heading
+    let listIndex = -1;
+    for (let i = tocIndex + 1; i < ast.children.length; i++) {
+      if (ast.children[i].type === 'list') {
+        listIndex = i;
+        break;
+      }
+    }
+    
+    if (listIndex >= 0) {
+      // Update the list items with numbers
+      const list = ast.children[listIndex];
+      let currentNumber = 1;
+      
+      visit(list, 'listItem', (node) => {
+        // Add number to the first paragraph in the list item
+        if (node.children && node.children.length > 0 && node.children[0].type === 'paragraph') {
+          const paragraph = node.children[0];
+          const firstChild = paragraph.children[0];
+          
+          if (firstChild.type === 'text') {
+            firstChild.value = `${currentNumber}. ${firstChild.value}`;
+            currentNumber++;
+          } else if (firstChild.type === 'link') {
+            // Insert a text node with the number before the link
+            paragraph.children.unshift({
+              type: 'text',
+              value: `${currentNumber}. `
+            });
+            currentNumber++;
+          }
+        }
+      });
+    }
+  }
+  
+  return ast;
+}
+
+/**
+ * Insert TOC at the beginning of document
+ * 
+ * Automatically generates and inserts a table of contents at the beginning
+ * of the document, after the title heading
+ * 
+ * @param {Object} ast - Markdown AST
+ * @param {string} selector - Optional selector (not used in this function)
+ * @param {Object} options - Options for TOC generation
+ * @returns {Object} Modified AST with TOC inserted
+ */
+function insertTOC(ast, selector, options = {}) {
+  // Generate TOC content
+  const headings = [];
+  visit(ast, 'heading', (node) => {
+    // Skip level 1 headings (title) and TOC heading itself
+    if (node.depth > 1 && toString(node).toLowerCase() !== 'table of contents') {
+      headings.push({
+        level: node.depth,
+        text: toString(node),
+        anchor: toString(node).toLowerCase().replace(/[^\w]+/g, '-')
+      });
+    }
+  });
+  
+  // Create TOC heading
+  const tocHeading = {
+    type: 'heading',
+    depth: 2,
+    children: [{ type: 'text', value: 'Table of Contents' }]
+  };
+  
+  // Create TOC list
+  const tocItems = headings.map(heading => {
+    const indent = '  '.repeat(heading.level - 2);
+    return {
+      type: 'listItem',
+      children: [{
+        type: 'paragraph',
+        children: [{
+          type: 'link',
+          url: `#${heading.anchor}`,
+          children: [{ type: 'text', value: heading.text }]
+        }]
+      }]
+    };
+  });
+  
+  const tocList = {
+    type: 'list',
+    ordered: options.ordered || false,
+    children: tocItems
+  };
+  
+  // Find position to insert TOC (after title)
+  let insertPosition = 0;
+  if (ast.children.length > 0 && ast.children[0].type === 'heading' && ast.children[0].depth === 1) {
+    insertPosition = 1;
+  }
+  
+  // Insert TOC
+  ast.children.splice(insertPosition, 0, tocHeading, tocList);
+  
+  return ast;
+}
+
+/**
+ * Convert HTML to Markdown
+ * 
+ * Transforms HTML content to markdown format
+ * 
+ * @param {Object} ast - Markdown AST (not used in this function)
+ * @param {string} selector - Optional selector (not used in this function)
+ * @param {string} html - HTML content to convert
+ * @returns {string} Converted markdown content
+ */
+function convertHTMLToMarkdown(ast, selector, html) {
+  if (!html) {
+    return '';
+  }
+  
+  // Simple HTML to markdown conversion
+  let markdown = html;
+  
+  // We'll handle HTML entities separately to prevent them from being treated as tags
+  const containsEntities = /&lt;|&gt;|&amp;|&quot;|&apos;/.test(markdown);
+  
+  // Convert headings
+  markdown = markdown.replace(/<h1[^>]*>(.*?)<\/h1>/gi, '# $1\n\n');
+  markdown = markdown.replace(/<h2[^>]*>(.*?)<\/h2>/gi, '## $1\n\n');
+  markdown = markdown.replace(/<h3[^>]*>(.*?)<\/h3>/gi, '### $1\n\n');
+  markdown = markdown.replace(/<h4[^>]*>(.*?)<\/h4>/gi, '#### $1\n\n');
+  markdown = markdown.replace(/<h5[^>]*>(.*?)<\/h5>/gi, '##### $1\n\n');
+  markdown = markdown.replace(/<h6[^>]*>(.*?)<\/h6>/gi, '###### $1\n\n');
+  
+  // Convert paragraphs
+  markdown = markdown.replace(/<p[^>]*>(.*?)<\/p>/gi, '$1\n\n');
+  
+  // Convert links
+  markdown = markdown.replace(/<a[^>]*href="(.*?)"[^>]*>(.*?)<\/a>/gi, '[$2]($1)');
+  
+  // Convert strong/bold
+  markdown = markdown.replace(/<(strong|b)[^>]*>(.*?)<\/(strong|b)>/gi, '**$2**');
+  
+  // Convert emphasis/italic
+  markdown = markdown.replace(/<(em|i)[^>]*>(.*?)<\/(em|i)>/gi, '*$2*');
+  
+  // Convert unordered lists
+  markdown = markdown.replace(/<ul[^>]*>(.*?)<\/ul>/gis, (match, content) => {
+    return content.replace(/<li[^>]*>(.*?)<\/li>/gi, '- $1\n');
+  });
+  
+  // Convert ordered lists
+  markdown = markdown.replace(/<ol[^>]*>(.*?)<\/ol>/gis, (match, content) => {
+    let index = 1;
+    return content.replace(/<li[^>]*>(.*?)<\/li>/gi, (match, item) => {
+      return `${index++}. ${item}\n`;
+    });
+  });
+  
+  // Convert code blocks
+  markdown = markdown.replace(/<pre[^>]*><code[^>]*>(.*?)<\/code><\/pre>/gis, '```\n$1\n```\n\n');
+  
+  // Convert inline code
+  markdown = markdown.replace(/<code[^>]*>(.*?)<\/code>/gi, '`$1`');
+  
+  // Convert blockquotes
+  markdown = markdown.replace(/<blockquote[^>]*>(.*?)<\/blockquote>/gis, '> $1\n\n');
+  
+  // Convert horizontal rules
+  markdown = markdown.replace(/<hr[^>]*>/gi, '---\n\n');
+  
+  // Remove remaining HTML tags
+  markdown = markdown.replace(/<[^>]*>/g, '');
+  
+  // Decode HTML entities after tags are removed
+  markdown = markdown
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, '\'');
+  
+  // Fix extra newlines
+  markdown = markdown.replace(/\n{3,}/g, '\n\n');
+  
+  return markdown.trim();
+}
+
+export {
+  makeCodeBlocksCollapsible,
+  makeDescriptiveToc,
+  addCrossLinks,
+  fixHeadingHierarchy,
+  moveSection,
+  updateTOCNumbers,
+  insertTOC,
+  convertHTMLToMarkdown
+};