@zebralabs/context-cli 0.1.2 → 0.1.4

package/src/domain/rule.js

@@ -0,0 +1,71 @@
+/**
+ * Rule value object
+ * Represents a single rule extracted from documentation
+ */
+export class Rule {
+  /**
+   * @param {Object} data
+   * @param {string} data.id - Rule ID (e.g., "doc-structure-001")
+   * @param {string} data.level - Rule level: "must" | "should" | "prefer" | "avoid"
+   * @param {string} data.category - Category extracted from rule ID prefix
+   * @param {string[]} data.appliesTo - What this rule applies to
+   * @param {string} data.rule - The rule statement
+   * @param {string} [data.rationale] - Why this rule exists
+   * @param {Object} data.source - Source information
+   * @param {string} data.source.pack - Pack ID
+   * @param {string} data.source.packVersion - Pack version
+   * @param {string} data.source.file - Source file path
+   * @param {number} data.source.line - Line number where rule starts
+   * @param {number} data.source.precedence - Precedence index (lower = higher priority)
+   */
+  constructor(data) {
+    this.id = data.id;
+    this.level = data.level;
+    this.category = data.category;
+    this.appliesTo = data.appliesTo;
+    this.rule = data.rule;
+    this.rationale = data.rationale;
+    this.source = data.source;
+    this.conflicts = []; // Populated during conflict resolution
+  }
+
+  /**
+   * Extract category from rule ID
+   * @param {string} ruleId - Rule ID (e.g., "doc-structure-001")
+   * @returns {string} Category (e.g., "doc-structure")
+   */
+  static extractCategory(ruleId) {
+    const match = ruleId.match(/^([a-z0-9-]+)-\d+$/);
+    return match ? match[1] : "unknown";
+  }
+
+  /**
+   * Validate rule level
+   * @param {string} level - Level to validate
+   * @returns {boolean} True if valid
+   */
+  static isValidLevel(level) {
+    return ["must", "should", "prefer", "avoid"].includes(level);
+  }
+
+  /**
+   * Validate rule ID format
+   * @param {string} ruleId - Rule ID to validate
+   * @returns {boolean} True if valid
+   */
+  static isValidId(ruleId) {
+    return /^[a-z0-9-]+$/.test(ruleId);
+  }
+
+  /**
+   * Check if this rule applies to the given scope
+   * @param {string|string[]} scope - Scope to check
+   * @returns {boolean} True if rule applies
+   */
+  appliesToScope(scope) {
+    if (this.appliesTo.includes("all")) return true;
+    const scopes = Array.isArray(scope) ? scope : [scope];
+    return scopes.some(s => this.appliesTo.includes(s));
+  }
+}
+

package/src/domain/scope.js

@@ -0,0 +1,30 @@
+/**
+ * Scope value object
+ * Represents what rules/preferences apply to
+ */
+export class Scope {
+  /**
+   * @param {Object} data
+   * @param {string[]} data.appliesTo - What this applies to
+   * @param {string[]} [data.doesNotApplyTo] - What this does not apply to
+   * @param {Object} data.source - Source information
+   * @param {string} data.source.file - Source file path
+   */
+  constructor(data) {
+    this.appliesTo = data.appliesTo || [];
+    this.doesNotApplyTo = data.doesNotApplyTo || [];
+    this.source = data.source;
+  }
+
+  /**
+   * Check if scope applies to the given item
+   * @param {string} item - Item to check
+   * @returns {boolean} True if applies
+   */
+  appliesToItem(item) {
+    if (this.doesNotApplyTo.includes(item)) return false;
+    if (this.appliesTo.includes("all")) return true;
+    return this.appliesTo.includes(item);
+  }
+}
+

package/src/infrastructure/assets/claude/claude-generator.js

@@ -0,0 +1,95 @@
+import { IAssetGenerator } from "../../../application/ports/asset-generator.js";
+import { FileWriter } from "../../file-system/file-writer.js";
+import path from "node:path";
+
+/**
+ * Claude Generator Adapter
+ * Generates CLAUDE.md file from consolidated rules
+ */
+export class ClaudeGenerator extends IAssetGenerator {
+  constructor() {
+    super();
+    this.fileWriter = new FileWriter();
+  }
+
+  getToolName() {
+    return "claude";
+  }
+
+  async generate(compilation, outputPath) {
+    const claudePath = path.join(outputPath, "CLAUDE.md");
+    const content = this.generateClaudeContent(compilation);
+    this.fileWriter.writeFile(claudePath, content);
+
+    return {
+      filesGenerated: ["CLAUDE.md"],
+      outputPath: claudePath
+    };
+  }
+
+  merge(assets) {
+    // For MVP, just return assets as-is
+    return assets;
+  }
+
+  /**
+   * Generate CLAUDE.md content
+   */
+  generateClaudeContent(compilation) {
+    const lines = [];
+    lines.push("# Engineering & Documentation Standards");
+    lines.push("");
+    lines.push("This document contains the consolidated standards and rules for this project.");
+    lines.push("");
+    lines.push("## Overview");
+    lines.push("");
+    lines.push(`- Total Rules: ${compilation.rules.length}`);
+    lines.push(`- Categories: ${compilation.getCategories().join(", ")}`);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+
+    // Include all "must" and "should" rules
+    const mustRules = compilation.getRulesByLevel("must");
+    const shouldRules = compilation.getRulesByLevel("should");
+
+    if (mustRules.length > 0) {
+      lines.push("## Must Rules");
+      lines.push("");
+      for (const rule of mustRules) {
+        lines.push(`### ${rule.id}`);
+        lines.push(`- **Applies to:** ${rule.appliesTo.join(", ")}`);
+        lines.push(`- ${rule.rule}`);
+        if (rule.rationale) {
+          lines.push(`- *Rationale:* ${rule.rationale}`);
+        }
+        lines.push("");
+      }
+    }
+
+    if (shouldRules.length > 0) {
+      lines.push("## Should Rules");
+      lines.push("");
+      for (const rule of shouldRules) {
+        lines.push(`### ${rule.id}`);
+        lines.push(`- **Applies to:** ${rule.appliesTo.join(", ")}`);
+        lines.push(`- ${rule.rule}`);
+        if (rule.rationale) {
+          lines.push(`- *Rationale:* ${rule.rationale}`);
+        }
+        lines.push("");
+      }
+    }
+
+    lines.push("---");
+    lines.push("");
+    lines.push("## References");
+    lines.push("");
+    lines.push("For complete rules including preferences and detailed documentation:");
+    lines.push("- See [CONSOLIDATED-STANDARDS.md](./CONSOLIDATED-STANDARDS.md)");
+    lines.push("- See [RULES-INDEX.md](./RULES-INDEX.md)");
+
+    return lines.join("\n");
+  }
+}
+

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