@zebralabs/context-cli 0.1.3 → 0.1.5

package/src/infrastructure/assets/cursor/cursor-rules-generator.js

@@ -0,0 +1,119 @@
+import { IAssetGenerator } from "../../../application/ports/asset-generator.js";
+import { FileWriter } from "../../file-system/file-writer.js";
+import path from "node:path";
+
+/**
+ * Cursor Rules Generator Adapter
+ * Generates .cursor/rules/*.md files from consolidated rules
+ */
+export class CursorRulesGenerator extends IAssetGenerator {
+  constructor() {
+    super();
+    this.fileWriter = new FileWriter();
+  }
+
+  getToolName() {
+    return "cursor";
+  }
+
+  async generate(compilation, outputPath) {
+    const rulesDir = path.join(outputPath, ".cursor", "rules");
+    this.fileWriter.ensureDir(rulesDir);
+
+    // Generate index.md
+    const indexContent = this.generateIndex(compilation);
+    this.fileWriter.writeFile(path.join(rulesDir, "index.md"), indexContent);
+
+    // Generate one file per category
+    const categories = compilation.getCategories();
+    const allFiles = ["index.md"];
+    for (const category of categories) {
+      const rules = compilation.getRulesByCategory(category);
+      const categoryContent = this.generateCategoryFile(category, rules, compilation);
+      const fileName = `${category}.md`;
+      this.fileWriter.writeFile(path.join(rulesDir, fileName), categoryContent);
+      allFiles.push(fileName);
+    }
+
+    return {
+      filesGenerated: allFiles,
+      outputDir: rulesDir
+    };
+  }
+
+  merge(assets) {
+    // For MVP, just return assets as-is
+    // In Phase 2, implement proper merging logic
+    return assets;
+  }
+
+  /**
+   * Generate index.md for Cursor rules
+   */
+  generateIndex(compilation) {
+    const lines = [];
+    lines.push("# Cursor Rules");
+    lines.push("");
+    lines.push("This directory contains rules extracted from knowledge packs.");
+    lines.push("");
+    lines.push("## Categories");
+    lines.push("");
+
+    const categories = compilation.getCategories();
+    for (const category of categories) {
+      const rules = compilation.getRulesByCategory(category);
+      lines.push(`- [${category}](./${category}.md) (${rules.length} rules)`);
+    }
+
+    lines.push("");
+    lines.push("## Quick Reference");
+    lines.push("");
+    lines.push(`Total Rules: ${compilation.rules.length}`);
+    lines.push("");
+    lines.push("For detailed consolidated standards, see:");
+    lines.push("- [CONSOLIDATED-STANDARDS.md](../CONSOLIDATED-STANDARDS.md)");
+    lines.push("- [RULES-INDEX.md](../RULES-INDEX.md)");
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Generate category file
+   */
+  generateCategoryFile(category, rules, compilation) {
+    const lines = [];
+    lines.push(`# ${category} Rules`);
+    lines.push("");
+    lines.push(`Rules in the ${category} category.`);
+    lines.push("");
+
+    // Sort by level, then ID
+    const levelOrder = { must: 0, should: 1, prefer: 2, avoid: 3 };
+    rules.sort((a, b) => {
+      const levelDiff = levelOrder[a.level] - levelOrder[b.level];
+      if (levelDiff !== 0) return levelDiff;
+      return a.id.localeCompare(b.id);
+    });
+
+    for (const rule of rules) {
+      lines.push(`## ${rule.id}`);
+      lines.push("");
+      lines.push(`**Level:** ${rule.level}`);
+      lines.push(`**Applies to:** ${rule.appliesTo.join(", ")}`);
+      lines.push("");
+      lines.push(rule.rule);
+      lines.push("");
+      if (rule.rationale) {
+        lines.push(`*Rationale:* ${rule.rationale}`);
+        lines.push("");
+      }
+    }
+
+    lines.push("---");
+    lines.push("");
+    lines.push("[Back to Rules Index](./index.md)");
+
+    return lines.join("\n");
+  }
+}
+

package/src/infrastructure/assets/cursor/cursor-skills-generator.js

@@ -0,0 +1,115 @@
+import { IAssetGenerator } from "../../../application/ports/asset-generator.js";
+import { FileWriter } from "../../file-system/file-writer.js";
+import path from "node:path";
+
+/**
+ * Cursor Skills Generator Adapter
+ * Generates .cursor\skills\*\SKILL.md files from skill definitions
+ */
+export class CursorSkillsGenerator extends IAssetGenerator {
+  constructor() {
+    super();
+    this.fileWriter = new FileWriter();
+  }
+
+  getToolName() {
+    return "cursor-skills";
+  }
+
+  async generate(compilation, outputPath, skills) {
+    if (!skills || skills.length === 0) {
+      return { filesGenerated: [], outputDir: null };
+    }
+
+    const skillsDir = path.join(outputPath, ".cursor", "skills");
+    this.fileWriter.ensureDir(skillsDir);
+
+    const generated = [];
+
+    for (const skill of skills) {
+      const skillDir = path.join(skillsDir, skill.name);
+      this.fileWriter.ensureDir(skillDir);
+
+      const skillContent = this.generateSkillFile(skill, compilation);
+      this.fileWriter.writeFile(path.join(skillDir, "SKILL.md"), skillContent);
+
+      generated.push(skill.name);
+    }
+
+    return {
+      filesGenerated: generated.map(s => `${s}/SKILL.md`),
+      outputDir: skillsDir
+    };
+  }
+
+  merge(assets) {
+    // For MVP, just return assets as-is
+    return assets;
+  }
+
+  /**
+   * Generate SKILL.md file for a skill
+   */
+  generateSkillFile(skill, compilation) {
+    const lines = [];
+    
+    // YAML frontmatter
+    lines.push("---");
+    lines.push(`name: ${skill.name}`);
+    lines.push(`description: ${skill.description}`);
+    lines.push("---");
+    lines.push("");
+    lines.push(`# ${skill.name}`);
+    lines.push("");
+    lines.push(skill.description);
+    lines.push("");
+
+    // When to Use section
+    if (skill.whenToUse && skill.whenToUse.length > 0) {
+      lines.push("## When to Use");
+      lines.push("");
+      for (const useCase of skill.whenToUse) {
+        lines.push(`- ${useCase}`);
+      }
+      lines.push("");
+    }
+
+    // Rules section
+    if (skill.rules && skill.rules.length > 0) {
+      lines.push("## Rules");
+      lines.push("");
+      for (const ruleId of skill.rules) {
+        const rule = compilation.rules.find(r => r.id === ruleId);
+        if (rule) {
+          lines.push(`### ${rule.id}`);
+          lines.push(`- **Level:** ${rule.level}`);
+          lines.push(`- **Rule:** ${rule.rule}`);
+          if (rule.rationale) {
+            lines.push(`- **Rationale:** ${rule.rationale}`);
+          }
+          lines.push("");
+        } else {
+          lines.push(`### ${ruleId}`);
+          lines.push(`- *Rule not found in compilation*`);
+          lines.push("");
+        }
+      }
+    }
+
+          // Process reference
+          if (skill.processReference) {
+            lines.push("## Process");
+            lines.push("");
+            // If processReference already includes "See", use as-is; otherwise add it
+            if (skill.processReference.startsWith("See ")) {
+              lines.push(`${skill.processReference}.`);
+            } else {
+              lines.push(`See ${skill.processReference} in the source documentation.`);
+            }
+            lines.push("");
+          }
+
+    return lines.join("\n");
+  }
+}
+

package/src/infrastructure/file-system/file-reader.js

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * File reader adapter
+ * Handles file system operations
+ */
+export class FileReader {
+  /**
+   * Read a file and return its contents
+   * @param {string} filePath - Path to file
+   * @returns {string} File contents
+   */
+  readFile(filePath) {
+    return fs.readFileSync(filePath, "utf8");
+  }
+
+  /**
+   * Check if a file exists
+   * @param {string} filePath - Path to file
+   * @returns {boolean} True if exists
+   */
+  exists(filePath) {
+    return fs.existsSync(filePath);
+  }
+
+  /**
+   * List all markdown files recursively
+   * @param {string} dirPath - Directory to search
+   * @returns {string[]} Array of file paths
+   */
+  listMarkdownFiles(dirPath) {
+    const files = [];
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+
+      // Skip hidden files and common exclusions
+      if (entry.name.startsWith(".")) continue;
+      if (entry.name === "node_modules") continue;
+
+      if (entry.isDirectory()) {
+        files.push(...this.listMarkdownFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Get file metadata
+   * @param {string} filePath - Path to file
+   * @returns {Object} File metadata
+   */
+  getFileMetadata(filePath) {
+    const stats = fs.statSync(filePath);
+    return {
+      path: filePath,
+      size: stats.size,
+      modified: stats.mtime.toISOString()
+    };
+  }
+}
+

package/src/infrastructure/file-system/file-writer.js

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * File writer adapter
+ * Handles file system write operations
+ */
+export class FileWriter {
+  /**
+   * Write content to a file
+   * @param {string} filePath - Path to file
+   * @param {string} content - Content to write
+   */
+  writeFile(filePath, content) {
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+
+  /**
+   * Write JSON to a file
+   * @param {string} filePath - Path to file
+   * @param {Object} data - Data to write as JSON
+   */
+  writeJson(filePath, data) {
+    const content = JSON.stringify(data, null, 2);
+    this.writeFile(filePath, content);
+  }
+
+  /**
+   * Ensure directory exists
+   * @param {string} dirPath - Directory path
+   */
+  ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+

package/src/infrastructure/parsing/markdown-parser.js

@@ -0,0 +1,95 @@
+/**
+ * Markdown parser adapter
+ * Parses markdown files and extracts structured sections
+ */
+export class MarkdownParser {
+  /**
+   * Strip YAML frontmatter from markdown
+   * @param {string} content - Markdown content
+   * @returns {string} Content without frontmatter
+   */
+  stripFrontmatter(content) {
+    if (!content.startsWith("---\n")) return content;
+    const endIndex = content.indexOf("\n---\n", 4);
+    if (endIndex === -1) return content;
+    return content.substring(endIndex + 5);
+  }
+
+  /**
+   * Parse YAML frontmatter
+   * @param {string} content - Markdown content
+   * @returns {Object|null} Parsed frontmatter or null
+   */
+  parseFrontmatter(content) {
+    if (!content.startsWith("---\n")) return null;
+    const endIndex = content.indexOf("\n---\n", 4);
+    if (endIndex === -1) return null;
+    
+    const frontmatter = content.substring(4, endIndex);
+    // Simple YAML parsing (for now, can enhance later)
+    const result = {};
+    for (const line of frontmatter.split("\n")) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        const key = match[1];
+        let value = match[2].trim();
+        // Remove quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Find a section by heading
+   * @param {string} content - Markdown content
+   * @param {string} heading - Heading to find (e.g., "## @context.rules")
+   * @returns {string|null} Section content or null if not found
+   */
+  findSection(content, heading) {
+    const lines = content.split("\n");
+    let startIndex = -1;
+    let endIndex = lines.length;
+
+    // Find start of section
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim() === heading) {
+        startIndex = i + 1;
+        break;
+      }
+    }
+
+    if (startIndex === -1) return null;
+
+    // Find end of section (next ## heading or end of file)
+    for (let i = startIndex; i < lines.length; i++) {
+      if (lines[i].startsWith("## ") && lines[i].trim() !== heading) {
+        endIndex = i;
+        break;
+      }
+    }
+
+    return lines.slice(startIndex, endIndex).join("\n");
+  }
+
+  /**
+   * Get line number where a string appears
+   * @param {string} content - Full content
+   * @param {string} searchString - String to find
+   * @returns {number} Line number (1-indexed) or -1 if not found
+   */
+  getLineNumber(content, searchString) {
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes(searchString)) {
+        return i + 1;
+      }
+    }
+    return -1;
+  }
+}
+

package/src/infrastructure/parsing/rule-extractor.js

@@ -0,0 +1,219 @@
+import { Rule } from "../../domain/rule.js";
+import { Preference } from "../../domain/preference.js";
+import { Scope } from "../../domain/scope.js";
+import { MarkdownParser } from "./markdown-parser.js";
+
+/**
+ * Rule extractor adapter
+ * Extracts rules, preferences, and scope from markdown files
+ */
+export class RuleExtractor {
+  constructor() {
+    this.parser = new MarkdownParser();
+  }
+
+  /**
+   * Extract rules from markdown content
+   * @param {string} content - Markdown content
+   * @param {Object} source - Source information
+   * @returns {Rule[]} Extracted rules
+   */
+  extractRules(content, source) {
+    const rules = [];
+    const rulesSection = this.parser.findSection(content, "## @context.rules");
+    
+    if (!rulesSection) return rules;
+
+    const lines = rulesSection.split("\n");
+    let currentRule = null;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      // Rule header: ### rule-id: Title
+      const ruleHeaderMatch = line.match(/^###\s+([a-z0-9-]+):\s*(.+)$/);
+      if (ruleHeaderMatch) {
+        // Save previous rule if exists
+        if (currentRule) {
+          if (currentRule.rule) {
+            rules.push(this.createRule(currentRule, source, content));
+          }
+        }
+
+        // Start new rule
+        currentRule = {
+          id: ruleHeaderMatch[1],
+          title: ruleHeaderMatch[2],
+          level: null,
+          appliesTo: null,
+          rule: null,
+          rationale: null
+        };
+        continue;
+      }
+
+      if (!currentRule) continue;
+
+      // Parse rule fields
+      const levelMatch = line.match(/^-\s*\*\*Level:\*\*\s*(.+)$/);
+      if (levelMatch) {
+        currentRule.level = levelMatch[1].trim();
+        continue;
+      }
+
+      const appliesToMatch = line.match(/^-\s*\*\*Applies to:\*\*\s*(.+)$/);
+      if (appliesToMatch) {
+        const appliesToStr = appliesToMatch[1].trim();
+        currentRule.appliesTo = appliesToStr === "all" 
+          ? ["all"] 
+          : appliesToStr.split(",").map(s => s.trim());
+        continue;
+      }
+
+      const ruleMatch = line.match(/^-\s*\*\*Rule:\*\*\s*(.+)$/);
+      if (ruleMatch) {
+        currentRule.rule = ruleMatch[1].trim();
+        continue;
+      }
+
+      const rationaleMatch = line.match(/^-\s*\*\*Rationale:\*\*\s*(.+)$/);
+      if (rationaleMatch) {
+        currentRule.rationale = rationaleMatch[1].trim();
+        continue;
+      }
+    }
+
+    // Don't forget the last rule
+    if (currentRule && currentRule.rule) {
+      rules.push(this.createRule(currentRule, source, content));
+    }
+
+    return rules;
+  }
+
+  /**
+   * Create a Rule object from extracted data
+   * @param {Object} data - Extracted rule data
+   * @param {Object} source - Source information
+   * @param {string} content - Full content for line number calculation
+   * @returns {Rule} Rule object
+   */
+  createRule(data, source, content) {
+    // Validate level
+    if (!Rule.isValidLevel(data.level)) {
+      console.warn(`Invalid level "${data.level}" for rule ${data.id}, defaulting to "should"`);
+      data.level = "should";
+    }
+
+    // Validate rule ID
+    if (!Rule.isValidId(data.id)) {
+      throw new Error(`Invalid rule ID format: ${data.id} (must be lowercase, numbers, hyphens only)`);
+    }
+
+    // Get line number
+    const lineNumber = this.parser.getLineNumber(content, `### ${data.id}:`);
+
+    return new Rule({
+      id: data.id,
+      level: data.level,
+      category: Rule.extractCategory(data.id),
+      appliesTo: data.appliesTo || [],
+      rule: data.rule,
+      rationale: data.rationale,
+      source: {
+        pack: source.pack,
+        packVersion: source.packVersion,
+        file: source.file,
+        line: lineNumber,
+        precedence: source.precedence
+      }
+    });
+  }
+
+  /**
+   * Extract preferences from markdown content
+   * @param {string} content - Markdown content
+   * @param {Object} source - Source information
+   * @returns {Preference[]} Extracted preferences
+   */
+  extractPreferences(content, source) {
+    const preferences = [];
+    const prefsSection = this.parser.findSection(content, "## @context.preferences");
+    
+    if (!prefsSection) return preferences;
+
+    const lines = prefsSection.split("\n");
+    for (const line of lines) {
+      const match = line.match(/^-\s*\*\*prefer:\*\*\s*(.+?)(?:\s*-\s*(.+))?$/);
+      if (match) {
+        const name = match[1].trim();
+        const description = match[2] ? match[2].trim() : null;
+        const lineNumber = this.parser.getLineNumber(content, line.trim());
+
+        preferences.push(new Preference({
+          name,
+          description,
+          source: {
+            pack: source.pack,
+            packVersion: source.packVersion,
+            file: source.file,
+            line: lineNumber,
+            precedence: source.precedence
+          }
+        }));
+      }
+    }
+
+    return preferences;
+  }
+
+  /**
+   * Extract scope from markdown content
+   * @param {string} content - Markdown content
+   * @param {Object} source - Source information
+   * @returns {Scope|null} Extracted scope or null
+   */
+  extractScope(content, source) {
+    const scopeSection = this.parser.findSection(content, "## @context.scope");
+    
+    if (!scopeSection) return null;
+
+    const appliesTo = [];
+    const doesNotApplyTo = [];
+    let inAppliesTo = false;
+    let inDoesNotApplyTo = false;
+
+    const lines = scopeSection.split("\n");
+    for (const line of lines) {
+      if (line.includes("**Applies to:**")) {
+        inAppliesTo = true;
+        inDoesNotApplyTo = false;
+        continue;
+      }
+      if (line.includes("**Does not apply to:**")) {
+        inAppliesTo = false;
+        inDoesNotApplyTo = true;
+        continue;
+      }
+
+      const listMatch = line.match(/^-\s*(.+)$/);
+      if (listMatch) {
+        const item = listMatch[1].trim();
+        if (inAppliesTo) {
+          appliesTo.push(item);
+        } else if (inDoesNotApplyTo) {
+          doesNotApplyTo.push(item);
+        }
+      }
+    }
+
+    return new Scope({
+      appliesTo,
+      doesNotApplyTo,
+      source: {
+        file: source.file
+      }
+    });
+  }
+}
+