@zebralabs/context-cli 0.1.2 → 0.1.4

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
+      }
+    });
+  }
+}
+

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

@@ -0,0 +1,74 @@
+import { MarkdownParser } from "./markdown-parser.js";
+
+/**
+ * Skill extractor adapter
+ * Extracts skill definitions from @context.skills sections
+ */
+export class SkillExtractor {
+  constructor() {
+    this.parser = new MarkdownParser();
+  }
+
+  /**
+   * Extracts skill definitions from markdown content.
+   * @param {string} markdown - The markdown content.
+   * @param {Object} sourceMetadata - Metadata about the source file (packId, file, etc.).
+   * @returns {Object[]} Extracted skill definitions.
+   */
+  extractSkills(markdown, sourceMetadata) {
+    const skills = [];
+    const skillsSection = this.parser.findSection(markdown, "## @context.skills");
+    
+    if (!skillsSection) return skills;
+
+    const skillBlocks = skillsSection.split(/\r?\n### /).filter(Boolean);
+    for (const skillText of skillBlocks) {
+      try {
+        const skill = this._parseSkill(skillText, sourceMetadata);
+        if (skill) skills.push(skill);
+      } catch (e) {
+        console.warn(`Warning: Malformed skill in ${sourceMetadata.file}: ${e.message}`);
+      }
+    }
+    return skills;
+  }
+
+  _parseSkill(skillText, sourceMetadata) {
+    const lines = skillText.split(/\r?\n/);
+    // Handle first line - might have "### " prefix or not
+    const firstLine = lines[0].trim();
+    const nameMatch = firstLine.match(/^(?:###\s+)?skill-([a-z0-9-]+)$/i);
+    if (!nameMatch) throw new Error(`Invalid skill ID format: ${firstLine}`);
+
+    const id = nameMatch[1].toLowerCase();
+    const skill = {
+      id: id,
+      name: id, // Default name to id, can be overridden by explicit 'Name' field
+      description: '',
+      rules: [],
+      whenToUse: [],
+      processReference: '',
+      source: sourceMetadata
+    };
+
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith('- **Name:**')) {
+        skill.name = line.replace('- **Name:**', '').trim();
+      } else if (line.startsWith('- **Description:**')) {
+        skill.description = line.replace('- **Description:**', '').trim();
+      } else if (line.startsWith('- **Rules:**')) {
+        skill.rules = line.replace('- **Rules:**', '').split(',').map(s => s.trim()).filter(Boolean);
+      } else if (line.startsWith('- **When to use:**')) {
+        skill.whenToUse = line.replace('- **When to use:**', '').split(',').map(s => s.trim()).filter(Boolean);
+      } else if (line.startsWith('- **Process reference:**')) {
+        skill.processReference = line.replace('- **Process reference:**', '').trim();
+      }
+    }
+
+    if (!skill.description) throw new Error(`Skill '${skill.id}' is missing a description.`);
+
+    return skill;
+  }
+}
+