rulesync 0.1.0

package/dist/index.mjs

@@ -0,0 +1,681 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/generators/cline.ts
+import { join } from "path";
+async function generateClineConfig(rules, config) {
+  const sortedRules = rules.sort((a, b) => {
+    if (a.frontmatter.priority !== b.frontmatter.priority) {
+      return a.frontmatter.priority === "high" ? -1 : 1;
+    }
+    return a.filename.localeCompare(b.filename);
+  });
+  const content = generateClineMarkdown(sortedRules);
+  const filepath = join(config.outputPaths.cline, "01-ai-rules.md");
+  return {
+    tool: "cline",
+    filepath,
+    content
+  };
+}
+function generateClineMarkdown(rules) {
+  const lines = [];
+  lines.push("# Cline AI Assistant Rules");
+  lines.push("");
+  lines.push("Configuration rules for Cline AI Assistant. Generated from ai-rules configuration.");
+  lines.push("");
+  lines.push("These rules provide project-specific guidance for AI-assisted development.");
+  lines.push("");
+  const highPriorityRules = rules.filter((r) => r.frontmatter.priority === "high");
+  const lowPriorityRules = rules.filter((r) => r.frontmatter.priority === "low");
+  if (highPriorityRules.length > 0) {
+    lines.push("## High Priority Guidelines");
+    lines.push("");
+    lines.push("These are critical rules that should always be followed:");
+    lines.push("");
+    for (const rule of highPriorityRules) {
+      lines.push(...formatRuleForCline(rule));
+    }
+  }
+  if (lowPriorityRules.length > 0) {
+    lines.push("## Standard Guidelines");
+    lines.push("");
+    lines.push("These are recommended practices for this project:");
+    lines.push("");
+    for (const rule of lowPriorityRules) {
+      lines.push(...formatRuleForCline(rule));
+    }
+  }
+  return lines.join("\n");
+}
+function formatRuleForCline(rule) {
+  const lines = [];
+  lines.push(`### ${rule.filename}`);
+  lines.push("");
+  lines.push(`**Description:** ${rule.frontmatter.description}`);
+  lines.push("");
+  if (rule.frontmatter.globs.length > 0) {
+    lines.push(`**Applies to files:** ${rule.frontmatter.globs.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("**Guidelines:**");
+  lines.push("");
+  lines.push(rule.content);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  return lines;
+}
+
+// src/generators/copilot.ts
+import { join as join2 } from "path";
+async function generateCopilotConfig(rules, config) {
+  const sortedRules = rules.sort((a, b) => {
+    if (a.frontmatter.priority !== b.frontmatter.priority) {
+      return a.frontmatter.priority === "high" ? -1 : 1;
+    }
+    return a.filename.localeCompare(b.filename);
+  });
+  const content = generateCopilotMarkdown(sortedRules);
+  const filepath = join2(config.outputPaths.copilot, "ai-rules.instructions.md");
+  return {
+    tool: "copilot",
+    filepath,
+    content
+  };
+}
+function generateCopilotMarkdown(rules) {
+  const lines = [];
+  lines.push("---");
+  lines.push('description: "AI rules configuration for GitHub Copilot"');
+  lines.push('applyTo: "**"');
+  lines.push("---");
+  lines.push("");
+  lines.push("# GitHub Copilot Instructions");
+  lines.push("");
+  lines.push(
+    "Generated from ai-rules configuration. These instructions guide GitHub Copilot's code suggestions."
+  );
+  lines.push("");
+  const highPriorityRules = rules.filter((r) => r.frontmatter.priority === "high");
+  const lowPriorityRules = rules.filter((r) => r.frontmatter.priority === "low");
+  if (highPriorityRules.length > 0) {
+    lines.push("## High Priority Rules");
+    lines.push("");
+    for (const rule of highPriorityRules) {
+      lines.push(...formatRuleForCopilot(rule));
+    }
+  }
+  if (lowPriorityRules.length > 0) {
+    lines.push("## Standard Rules");
+    lines.push("");
+    for (const rule of lowPriorityRules) {
+      lines.push(...formatRuleForCopilot(rule));
+    }
+  }
+  return lines.join("\n");
+}
+function formatRuleForCopilot(rule) {
+  const lines = [];
+  lines.push(`### ${rule.filename}`);
+  lines.push("");
+  lines.push(`**Description:** ${rule.frontmatter.description}`);
+  lines.push("");
+  if (rule.frontmatter.globs.length > 0) {
+    lines.push(`**Applies to:** ${rule.frontmatter.globs.join(", ")}`);
+    lines.push("");
+  }
+  lines.push(rule.content);
+  lines.push("");
+  return lines;
+}
+
+// src/generators/cursor.ts
+import { join as join3 } from "path";
+async function generateCursorConfig(rules, config) {
+  const sortedRules = rules.sort((a, b) => {
+    if (a.frontmatter.priority !== b.frontmatter.priority) {
+      return a.frontmatter.priority === "high" ? -1 : 1;
+    }
+    return a.filename.localeCompare(b.filename);
+  });
+  const content = generateCursorMarkdown(sortedRules);
+  const filepath = join3(config.outputPaths.cursor, "ai-rules.md");
+  return {
+    tool: "cursor",
+    filepath,
+    content
+  };
+}
+function generateCursorMarkdown(rules) {
+  const lines = [];
+  lines.push("---");
+  lines.push("description: AI rules configuration for Cursor IDE");
+  lines.push("alwaysApply: true");
+  lines.push("---");
+  lines.push("");
+  lines.push("# Cursor IDE Rules");
+  lines.push("");
+  lines.push("These rules configure Cursor IDE's AI assistant behavior.");
+  lines.push("");
+  for (const rule of rules) {
+    lines.push(...formatRuleForCursor(rule));
+  }
+  return lines.join("\n");
+}
+function formatRuleForCursor(rule) {
+  const lines = [];
+  const priorityBadge = rule.frontmatter.priority === "high" ? "\u{1F534} HIGH" : "\u{1F7E1} STANDARD";
+  lines.push("---");
+  lines.push(`description: ${rule.frontmatter.description}`);
+  if (rule.frontmatter.globs.length > 0) {
+    lines.push(`globs: [${rule.frontmatter.globs.map((g) => `"${g}"`).join(", ")}]`);
+  }
+  lines.push(`alwaysApply: ${rule.frontmatter.priority === "high"}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`## ${rule.filename} ${priorityBadge}`);
+  lines.push("");
+  lines.push(`**Priority:** ${rule.frontmatter.priority.toUpperCase()}`);
+  lines.push("");
+  if (rule.frontmatter.globs.length > 0) {
+    lines.push("**File Patterns:**");
+    for (const glob of rule.frontmatter.globs) {
+      lines.push(`- \`${glob}\``);
+    }
+    lines.push("");
+  }
+  lines.push("**Rule:**");
+  lines.push(rule.content);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  return lines;
+}
+
+// src/utils/config.ts
+function getDefaultConfig() {
+  return {
+    aiRulesDir: ".rulesync",
+    outputPaths: {
+      copilot: ".github/instructions",
+      cursor: ".cursor/rules",
+      cline: ".clinerules"
+    },
+    watchEnabled: false,
+    defaultTargets: ["copilot", "cursor", "cline"]
+  };
+}
+function resolveTargets(targets, config) {
+  if (targets.includes("*")) {
+    return config.defaultTargets;
+  }
+  return targets;
+}
+
+// src/utils/file.ts
+import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
+import { dirname, join as join4 } from "path";
+async function ensureDir(dirPath) {
+  try {
+    await stat(dirPath);
+  } catch {
+    await mkdir(dirPath, { recursive: true });
+  }
+}
+async function readFileContent(filepath) {
+  return readFile(filepath, "utf-8");
+}
+async function writeFileContent(filepath, content) {
+  await ensureDir(dirname(filepath));
+  await writeFile(filepath, content, "utf-8");
+}
+async function findFiles(dir, extension = ".md") {
+  try {
+    const files = await readdir(dir);
+    return files.filter((file) => file.endsWith(extension)).map((file) => join4(dir, file));
+  } catch {
+    return [];
+  }
+}
+async function fileExists(filepath) {
+  try {
+    await stat(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/generator.ts
+async function generateConfigurations(rules, config, targetTools) {
+  const outputs = [];
+  const toolsToGenerate = targetTools || config.defaultTargets;
+  for (const tool of toolsToGenerate) {
+    const relevantRules = filterRulesForTool(rules, tool, config);
+    if (relevantRules.length === 0) {
+      console.warn(`No rules found for tool: ${tool}`);
+      continue;
+    }
+    const output = await generateForTool(tool, relevantRules, config);
+    if (output) {
+      outputs.push(output);
+    }
+  }
+  return outputs;
+}
+function filterRulesForTool(rules, tool, config) {
+  return rules.filter((rule) => {
+    const targets = resolveTargets(rule.frontmatter.targets, config);
+    return targets.includes(tool);
+  });
+}
+async function generateForTool(tool, rules, config) {
+  switch (tool) {
+    case "copilot":
+      return generateCopilotConfig(rules, config);
+    case "cursor":
+      return generateCursorConfig(rules, config);
+    case "cline":
+      return generateClineConfig(rules, config);
+    default:
+      console.warn(`Unknown tool: ${tool}`);
+      return null;
+  }
+}
+
+// src/core/parser.ts
+import { basename } from "path";
+import matter from "gray-matter";
+async function parseRulesFromDirectory(aiRulesDir) {
+  const ruleFiles = await findFiles(aiRulesDir);
+  const rules = [];
+  for (const filepath of ruleFiles) {
+    try {
+      const rule = await parseRuleFile(filepath);
+      rules.push(rule);
+    } catch (error) {
+      console.warn(`Failed to parse rule file ${filepath}:`, error);
+    }
+  }
+  return rules;
+}
+async function parseRuleFile(filepath) {
+  const content = await readFileContent(filepath);
+  const parsed = matter(content);
+  validateFrontmatter(parsed.data, filepath);
+  const frontmatter = parsed.data;
+  const filename = basename(filepath, ".md");
+  return {
+    frontmatter,
+    content: parsed.content,
+    filename,
+    filepath
+  };
+}
+function validateFrontmatter(data, filepath) {
+  if (!data || typeof data !== "object") {
+    throw new Error(`Invalid frontmatter in ${filepath}: must be an object`);
+  }
+  const obj = data;
+  if (!obj.priority || !["high", "low"].includes(obj.priority)) {
+    throw new Error(`Invalid priority in ${filepath}: must be "high" or "low"`);
+  }
+  if (!Array.isArray(obj.targets)) {
+    throw new Error(`Invalid targets in ${filepath}: must be an array`);
+  }
+  const validTargets = ["copilot", "cursor", "cline", "*"];
+  for (const target of obj.targets) {
+    if (typeof target !== "string" || !validTargets.includes(target)) {
+      throw new Error(
+        `Invalid target "${target}" in ${filepath}: must be one of ${validTargets.join(", ")}`
+      );
+    }
+  }
+  if (!obj.description || typeof obj.description !== "string") {
+    throw new Error(`Invalid description in ${filepath}: must be a non-empty string`);
+  }
+  if (!Array.isArray(obj.globs)) {
+    throw new Error(`Invalid globs in ${filepath}: must be an array`);
+  }
+  for (const glob of obj.globs) {
+    if (typeof glob !== "string") {
+      throw new Error(`Invalid glob in ${filepath}: all globs must be strings`);
+    }
+  }
+}
+
+// src/core/validator.ts
+async function validateRules(rules) {
+  const errors = [];
+  const warnings = [];
+  const filenames = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (filenames.has(rule.filename)) {
+      errors.push(`Duplicate rule filename: ${rule.filename}`);
+    }
+    filenames.add(rule.filename);
+  }
+  for (const rule of rules) {
+    const ruleValidation = await validateRule(rule);
+    errors.push(...ruleValidation.errors);
+    warnings.push(...ruleValidation.warnings);
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function validateRule(rule) {
+  const errors = [];
+  const warnings = [];
+  if (!rule.content.trim()) {
+    warnings.push(`Rule ${rule.filename} has empty content`);
+  }
+  if (rule.frontmatter.description.length < 10) {
+    warnings.push(`Rule ${rule.filename} has a very short description`);
+  }
+  if (rule.frontmatter.globs.length === 0) {
+    warnings.push(`Rule ${rule.filename} has no glob patterns specified`);
+  }
+  if (!await fileExists(rule.filepath)) {
+    errors.push(`Rule file ${rule.filepath} does not exist`);
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+// src/cli/commands/generate.ts
+async function generateCommand(options = {}) {
+  const config = getDefaultConfig();
+  console.log("Generating configuration files...");
+  if (!await fileExists(config.aiRulesDir)) {
+    console.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
+    process.exit(1);
+  }
+  try {
+    if (options.verbose) {
+      console.log(`Parsing rules from ${config.aiRulesDir}...`);
+    }
+    const rules = await parseRulesFromDirectory(config.aiRulesDir);
+    if (rules.length === 0) {
+      console.warn("\u26A0\uFE0F  No rules found in .rulesync directory");
+      return;
+    }
+    if (options.verbose) {
+      console.log(`Found ${rules.length} rule(s)`);
+    }
+    const outputs = await generateConfigurations(rules, config, options.tools);
+    if (outputs.length === 0) {
+      console.warn("\u26A0\uFE0F  No configurations generated");
+      return;
+    }
+    for (const output of outputs) {
+      await writeFileContent(output.filepath, output.content);
+      console.log(`\u2705 Generated ${output.tool} configuration: ${output.filepath}`);
+    }
+    console.log(`
+\u{1F389} Successfully generated ${outputs.length} configuration file(s)!`);
+  } catch (error) {
+    console.error("\u274C Failed to generate configurations:", error);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/init.ts
+import { join as join5 } from "path";
+async function initCommand() {
+  const aiRulesDir = ".rulesync";
+  console.log("Initializing ai-rules...");
+  await ensureDir(aiRulesDir);
+  await createSampleFiles(aiRulesDir);
+  console.log("\u2705 ai-rules initialized successfully!");
+  console.log("\nNext steps:");
+  console.log("1. Edit rule files in .rulesync/");
+  console.log("2. Run 'ai-rules generate' to create configuration files");
+}
+async function createSampleFiles(aiRulesDir) {
+  const sampleFiles = [
+    {
+      filename: "coding-rules.md",
+      content: `---
+priority: high
+targets: ["*"]
+description: "General coding standards and best practices"
+globs: ["**/*.ts", "**/*.js", "**/*.tsx", "**/*.jsx"]
+---
+
+# Coding Rules
+
+## General Guidelines
+
+- Use TypeScript for all new code
+- Follow consistent naming conventions
+- Write self-documenting code with clear variable and function names
+- Prefer composition over inheritance
+- Use meaningful comments for complex business logic
+
+## Code Style
+
+- Use 2 spaces for indentation
+- Use semicolons
+- Use double quotes for strings
+- Use trailing commas in multi-line objects and arrays
+`
+    },
+    {
+      filename: "naming-conventions.md",
+      content: `---
+priority: high
+targets: ["*"]
+description: "Naming conventions for variables, functions, and files"
+globs: ["**/*.ts", "**/*.js"]
+---
+
+# Naming Conventions
+
+## Variables and Functions
+- Use camelCase for variables and functions
+- Use descriptive names that explain the purpose
+- Avoid abbreviations unless they are well-known
+
+## Files and Directories
+- Use kebab-case for file names
+- Use PascalCase for component files
+- Use lowercase for directory names
+
+## Constants
+- Use SCREAMING_SNAKE_CASE for constants
+- Group related constants in enums or const objects
+`
+    },
+    {
+      filename: "architecture.md",
+      content: `---
+priority: low
+targets: [copilot, cursor]
+description: "Architectural patterns and project structure guidelines"
+globs: ["src/**/*.ts"]
+---
+
+# Architecture Guidelines
+
+## Project Structure
+- Organize code by feature, not by file type
+- Keep related files close together
+- Use index files for clean imports
+
+## Design Patterns
+- Use dependency injection for better testability
+- Implement proper error handling
+- Follow single responsibility principle
+`
+    }
+  ];
+  for (const file of sampleFiles) {
+    const filepath = join5(aiRulesDir, file.filename);
+    if (!await fileExists(filepath)) {
+      await writeFileContent(filepath, file.content);
+      console.log(`Created ${filepath}`);
+    } else {
+      console.log(`Skipped ${filepath} (already exists)`);
+    }
+  }
+}
+
+// src/cli/commands/status.ts
+async function statusCommand() {
+  const config = getDefaultConfig();
+  console.log("rulesync Status");
+  console.log("===============");
+  const aiRulesExists = await fileExists(config.aiRulesDir);
+  console.log(`
+\u{1F4C1} .rulesync directory: ${aiRulesExists ? "\u2705 Found" : "\u274C Not found"}`);
+  if (!aiRulesExists) {
+    console.log("\n\u{1F4A1} Run 'rulesync init' to get started");
+    return;
+  }
+  try {
+    const rules = await parseRulesFromDirectory(config.aiRulesDir);
+    console.log(`
+\u{1F4CB} Rules: ${rules.length} total`);
+    if (rules.length > 0) {
+      const highPriority = rules.filter((r) => r.frontmatter.priority === "high").length;
+      const lowPriority = rules.filter((r) => r.frontmatter.priority === "low").length;
+      console.log(`   - High priority: ${highPriority}`);
+      console.log(`   - Low priority: ${lowPriority}`);
+      const targetCounts = { copilot: 0, cursor: 0, cline: 0 };
+      for (const rule of rules) {
+        const targets = rule.frontmatter.targets.includes("*") ? config.defaultTargets : rule.frontmatter.targets;
+        for (const target of targets) {
+          if (target in targetCounts) {
+            targetCounts[target]++;
+          }
+        }
+      }
+      console.log("\n\u{1F3AF} Target tool coverage:");
+      console.log(`   - Copilot: ${targetCounts.copilot} rules`);
+      console.log(`   - Cursor: ${targetCounts.cursor} rules`);
+      console.log(`   - Cline: ${targetCounts.cline} rules`);
+    }
+    console.log("\n\u{1F4E4} Generated files:");
+    for (const [tool, outputPath] of Object.entries(config.outputPaths)) {
+      const outputExists = await fileExists(outputPath);
+      console.log(`   - ${tool}: ${outputExists ? "\u2705 Generated" : "\u274C Not found"}`);
+    }
+    if (rules.length > 0) {
+      console.log("\n\u{1F4A1} Run 'rulesync generate' to update configuration files");
+    }
+  } catch (error) {
+    console.error("\n\u274C Failed to get status:", error);
+  }
+}
+
+// src/cli/commands/validate.ts
+async function validateCommand() {
+  const config = getDefaultConfig();
+  console.log("Validating ai-rules configuration...");
+  if (!await fileExists(config.aiRulesDir)) {
+    console.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
+    process.exit(1);
+  }
+  try {
+    const rules = await parseRulesFromDirectory(config.aiRulesDir);
+    if (rules.length === 0) {
+      console.warn("\u26A0\uFE0F  No rules found in .ai-rules directory");
+      return;
+    }
+    console.log(`Found ${rules.length} rule(s), validating...`);
+    const validation = await validateRules(rules);
+    if (validation.warnings.length > 0) {
+      console.log("\n\u26A0\uFE0F  Warnings:");
+      for (const warning of validation.warnings) {
+        console.log(`  - ${warning}`);
+      }
+    }
+    if (validation.errors.length > 0) {
+      console.log("\n\u274C Errors:");
+      for (const error of validation.errors) {
+        console.log(`  - ${error}`);
+      }
+    }
+    if (validation.isValid) {
+      console.log("\n\u2705 All rules are valid!");
+    } else {
+      console.log(`
+\u274C Validation failed with ${validation.errors.length} error(s)`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("\u274C Failed to validate rules:", error);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/watch.ts
+import chokidar from "chokidar";
+async function watchCommand() {
+  const config = getDefaultConfig();
+  console.log("\u{1F440} Watching for changes in .rulesync directory...");
+  console.log("Press Ctrl+C to stop watching");
+  await generateCommand({ verbose: false });
+  const watcher = chokidar.watch(`${config.aiRulesDir}/**/*.md`, {
+    ignoreInitial: true,
+    persistent: true
+  });
+  let isGenerating = false;
+  const handleChange = async (path) => {
+    if (isGenerating) return;
+    isGenerating = true;
+    console.log(`
+\u{1F4DD} Detected change in ${path}`);
+    try {
+      await generateCommand({ verbose: false });
+      console.log("\u2705 Regenerated configuration files");
+    } catch (error) {
+      console.error("\u274C Failed to regenerate:", error);
+    } finally {
+      isGenerating = false;
+    }
+  };
+  watcher.on("change", handleChange).on("add", handleChange).on("unlink", (path) => {
+    console.log(`
+\u{1F5D1}\uFE0F  Removed ${path}`);
+    handleChange(path);
+  }).on("error", (error) => {
+    console.error("\u274C Watcher error:", error);
+  });
+  process.on("SIGINT", () => {
+    console.log("\n\n\u{1F44B} Stopping watcher...");
+    watcher.close();
+    process.exit(0);
+  });
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("ai-rules").description("Unified AI rules management CLI tool").version("0.1.0");
+program.command("init").description("Initialize ai-rules in current directory").action(initCommand);
+program.command("generate").description("Generate configuration files for AI tools").option("--copilot", "Generate only for GitHub Copilot").option("--cursor", "Generate only for Cursor").option("--cline", "Generate only for Cline").option("-v, --verbose", "Verbose output").action(async (options) => {
+  const tools = [];
+  if (options.copilot) tools.push("copilot");
+  if (options.cursor) tools.push("cursor");
+  if (options.cline) tools.push("cline");
+  const generateOptions = {
+    verbose: options.verbose
+  };
+  if (tools.length > 0) {
+    generateOptions.tools = tools;
+  }
+  await generateCommand(generateOptions);
+});
+program.command("validate").description("Validate ai-rules configuration").action(validateCommand);
+program.command("status").description("Show current status of ai-rules").action(statusCommand);
+program.command("watch").description("Watch for changes and auto-generate configurations").action(watchCommand);
+program.parse();