memorix 1.2.2 → 1.2.4

package/src/rules/adapters/claude-code.ts

@@ -1,99 +1,99 @@
-/**
- * Claude Code Rule Format Adapter
- *
- * Parses and generates rules in Claude Code's formats:
- * - CLAUDE.md / .claude/CLAUDE.md (project-level Markdown)
- * - .claude/rules/*.md (Markdown with optional `paths` frontmatter)
- *
- * Source: Claude Code official documentation.
- */
-
-import matter from 'gray-matter';
-import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
-import { hashContent, generateRuleId } from '../utils.js';
-
-export class ClaudeCodeAdapter implements RuleFormatAdapter {
-  readonly source: RuleSource = 'claude-code';
-
-  readonly filePatterns = [
-    'CLAUDE.md',
-    '.claude/CLAUDE.md',
-    '.claude/rules/*.md',
-  ];
-
-  parse(filePath: string, content: string): UnifiedRule[] {
-    // .claude/rules/*.md may have `paths` frontmatter
-    if (filePath.includes('.claude/rules/')) {
-      return this.parseModularRule(filePath, content);
-    }
-    // CLAUDE.md — project-level
-    return this.parseClaudeMd(filePath, content);
-  }
-
-  generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
-    const projectRules = rules.filter(r => r.scope !== 'path-specific');
-    const pathRules = rules.filter(r => r.scope === 'path-specific');
-
-    const files: { filePath: string; content: string }[] = [];
-
-    if (projectRules.length > 0) {
-      files.push({
-        filePath: 'CLAUDE.md',
-        content: projectRules.map(r => r.content).join('\n\n'),
-      });
-    }
-
-    for (const rule of pathRules) {
-      const fm: Record<string, unknown> = {};
-      if (rule.paths && rule.paths.length > 0) fm.paths = rule.paths;
-
-      const fileName = rule.id
-        .replace(/^claude-code:/, '')
-        .replace(/[^a-zA-Z0-9-_]/g, '-')
-        || 'rule';
-
-      files.push({
-        filePath: `.claude/rules/${fileName}.md`,
-        content: Object.keys(fm).length > 0
-          ? matter.stringify(rule.content, fm)
-          : rule.content,
-      });
-    }
-
-    return files;
-  }
-
-  private parseClaudeMd(filePath: string, content: string): UnifiedRule[] {
-    const trimmed = content.trim();
-    if (!trimmed) return [];
-
-    return [{
-      id: generateRuleId('claude-code', filePath),
-      content: trimmed,
-      source: 'claude-code',
-      scope: 'project',
-      priority: 5,
-      hash: hashContent(trimmed),
-    }];
-  }
-
-  private parseModularRule(filePath: string, content: string): UnifiedRule[] {
-    const { data, content: body } = matter(content);
-    const trimmed = body.trim();
-    if (!trimmed) return [];
-
-    const paths = data.paths as string[] | undefined;
-    const hasPaths = Array.isArray(paths) && paths.length > 0;
-
-    return [{
-      id: generateRuleId('claude-code', filePath),
-      content: trimmed,
-      description: data.description as string | undefined,
-      source: 'claude-code',
-      scope: hasPaths ? 'path-specific' : 'project',
-      paths: hasPaths ? paths : undefined,
-      priority: 5,
-      hash: hashContent(trimmed),
-    }];
-  }
-}
+/**
+ * Claude Code Rule Format Adapter
+ *
+ * Parses and generates rules in Claude Code's formats:
+ * - CLAUDE.md / .claude/CLAUDE.md (project-level Markdown)
+ * - .claude/rules/*.md (Markdown with optional `paths` frontmatter)
+ *
+ * Source: Claude Code official documentation.
+ */
+
+import matter from 'gray-matter';
+import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
+import { hashContent, generateRuleId } from '../utils.js';
+
+export class ClaudeCodeAdapter implements RuleFormatAdapter {
+  readonly source: RuleSource = 'claude-code';
+
+  readonly filePatterns = [
+    'CLAUDE.md',
+    '.claude/CLAUDE.md',
+    '.claude/rules/*.md',
+  ];
+
+  parse(filePath: string, content: string): UnifiedRule[] {
+    // .claude/rules/*.md may have `paths` frontmatter
+    if (filePath.includes('.claude/rules/')) {
+      return this.parseModularRule(filePath, content);
+    }
+    // CLAUDE.md — project-level
+    return this.parseClaudeMd(filePath, content);
+  }
+
+  generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
+    const projectRules = rules.filter(r => r.scope !== 'path-specific');
+    const pathRules = rules.filter(r => r.scope === 'path-specific');
+
+    const files: { filePath: string; content: string }[] = [];
+
+    if (projectRules.length > 0) {
+      files.push({
+        filePath: 'CLAUDE.md',
+        content: projectRules.map(r => r.content).join('\n\n'),
+      });
+    }
+
+    for (const rule of pathRules) {
+      const fm: Record<string, unknown> = {};
+      if (rule.paths && rule.paths.length > 0) fm.paths = rule.paths;
+
+      const fileName = rule.id
+        .replace(/^claude-code:/, '')
+        .replace(/[^a-zA-Z0-9-_]/g, '-')
+        || 'rule';
+
+      files.push({
+        filePath: `.claude/rules/${fileName}.md`,
+        content: Object.keys(fm).length > 0
+          ? matter.stringify(rule.content, fm)
+          : rule.content,
+      });
+    }
+
+    return files;
+  }
+
+  private parseClaudeMd(filePath: string, content: string): UnifiedRule[] {
+    const trimmed = content.trim();
+    if (!trimmed) return [];
+
+    return [{
+      id: generateRuleId('claude-code', filePath),
+      content: trimmed,
+      source: 'claude-code',
+      scope: 'project',
+      priority: 5,
+      hash: hashContent(trimmed),
+    }];
+  }
+
+  private parseModularRule(filePath: string, content: string): UnifiedRule[] {
+    const { data, content: body } = matter(content);
+    const trimmed = body.trim();
+    if (!trimmed) return [];
+
+    const paths = data.paths as string[] | undefined;
+    const hasPaths = Array.isArray(paths) && paths.length > 0;
+
+    return [{
+      id: generateRuleId('claude-code', filePath),
+      content: trimmed,
+      description: data.description as string | undefined,
+      source: 'claude-code',
+      scope: hasPaths ? 'path-specific' : 'project',
+      paths: hasPaths ? paths : undefined,
+      priority: 5,
+      hash: hashContent(trimmed),
+    }];
+  }
+}

package/src/rules/adapters/codex.ts

@@ -1,97 +1,97 @@
-/**
- * OpenAI Codex Rule Format Adapter
- *
- * Parses and generates rules in Codex's formats:
- * - .agents/skills/[name]/SKILL.md (Markdown + frontmatter with name, description)
- * - AGENTS.md (pure Markdown)
- *
- * Source: OpenAI Codex Skills documentation.
- */
-
-import matter from 'gray-matter';
-import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
-import { hashContent, generateRuleId } from '../utils.js';
-
-export class CodexAdapter implements RuleFormatAdapter {
-  readonly source: RuleSource = 'codex';
-
-  readonly filePatterns = [
-    '.agents/skills/*/SKILL.md',
-    'AGENTS.md',
-  ];
-
-  parse(filePath: string, content: string): UnifiedRule[] {
-    if (filePath.includes('SKILL.md')) {
-      return this.parseSkillMd(filePath, content);
-    }
-    if (filePath.endsWith('AGENTS.md')) {
-      return this.parseAgentsMd(filePath, content);
-    }
-    return [];
-  }
-
-  generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
-    return rules.map((rule, i) => {
-      const skillName = rule.id
-        .replace(/^codex:/, '')
-        .replace(/[^a-zA-Z0-9-_]/g, '-')
-        || `skill-${i}`;
-
-      const fm: Record<string, unknown> = {
-        name: skillName,
-      };
-
-      // Codex needs description to know WHEN to trigger the skill.
-      // If no description exists, auto-generate from content (first 120 chars).
-      if (rule.description) {
-        fm.description = rule.description;
-      } else {
-        fm.description = this.autoDescription(rule.content);
-      }
-
-      return {
-        filePath: `.agents/skills/${skillName}/SKILL.md`,
-        content: matter.stringify(rule.content, fm),
-      };
-    });
-  }
-
-  /** Extract a short description from rule content for Codex skill triggering */
-  private autoDescription(content: string): string {
-    // Take first meaningful line, strip markdown formatting
-    const lines = content.split('\n').map(l => l.trim()).filter(Boolean);
-    const first = lines[0]?.replace(/^#+\s*/, '').replace(/^[-*]\s*/, '') || 'Project rules';
-    if (first.length <= 120) return first;
-    return first.substring(0, 117) + '...';
-  }
-
-  private parseSkillMd(filePath: string, content: string): UnifiedRule[] {
-    const { data, content: body } = matter(content);
-    const trimmed = body.trim();
-    if (!trimmed) return [];
-
-    return [{
-      id: generateRuleId('codex', filePath),
-      content: trimmed,
-      description: (data.description as string) || undefined,
-      source: 'codex',
-      scope: 'project',
-      priority: 5,
-      hash: hashContent(trimmed),
-    }];
-  }
-
-  private parseAgentsMd(filePath: string, content: string): UnifiedRule[] {
-    const trimmed = content.trim();
-    if (!trimmed) return [];
-
-    return [{
-      id: generateRuleId('codex', filePath),
-      content: trimmed,
-      source: 'codex',
-      scope: 'project',
-      priority: 5,
-      hash: hashContent(trimmed),
-    }];
-  }
-}
+/**
+ * OpenAI Codex Rule Format Adapter
+ *
+ * Parses and generates rules in Codex's formats:
+ * - .agents/skills/[name]/SKILL.md (Markdown + frontmatter with name, description)
+ * - AGENTS.md (pure Markdown)
+ *
+ * Source: OpenAI Codex Skills documentation.
+ */
+
+import matter from 'gray-matter';
+import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
+import { hashContent, generateRuleId } from '../utils.js';
+
+export class CodexAdapter implements RuleFormatAdapter {
+  readonly source: RuleSource = 'codex';
+
+  readonly filePatterns = [
+    '.agents/skills/*/SKILL.md',
+    'AGENTS.md',
+  ];
+
+  parse(filePath: string, content: string): UnifiedRule[] {
+    if (filePath.includes('SKILL.md')) {
+      return this.parseSkillMd(filePath, content);
+    }
+    if (filePath.endsWith('AGENTS.md')) {
+      return this.parseAgentsMd(filePath, content);
+    }
+    return [];
+  }
+
+  generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
+    return rules.map((rule, i) => {
+      const skillName = rule.id
+        .replace(/^codex:/, '')
+        .replace(/[^a-zA-Z0-9-_]/g, '-')
+        || `skill-${i}`;
+
+      const fm: Record<string, unknown> = {
+        name: skillName,
+      };
+
+      // Codex needs description to know WHEN to trigger the skill.
+      // If no description exists, auto-generate from content (first 120 chars).
+      if (rule.description) {
+        fm.description = rule.description;
+      } else {
+        fm.description = this.autoDescription(rule.content);
+      }
+
+      return {
+        filePath: `.agents/skills/${skillName}/SKILL.md`,
+        content: matter.stringify(rule.content, fm),
+      };
+    });
+  }
+
+  /** Extract a short description from rule content for Codex skill triggering */
+  private autoDescription(content: string): string {
+    // Take first meaningful line, strip markdown formatting
+    const lines = content.split('\n').map(l => l.trim()).filter(Boolean);
+    const first = lines[0]?.replace(/^#+\s*/, '').replace(/^[-*]\s*/, '') || 'Project rules';
+    if (first.length <= 120) return first;
+    return first.substring(0, 117) + '...';
+  }
+
+  private parseSkillMd(filePath: string, content: string): UnifiedRule[] {
+    const { data, content: body } = matter(content);
+    const trimmed = body.trim();
+    if (!trimmed) return [];
+
+    return [{
+      id: generateRuleId('codex', filePath),
+      content: trimmed,
+      description: (data.description as string) || undefined,
+      source: 'codex',
+      scope: 'project',
+      priority: 5,
+      hash: hashContent(trimmed),
+    }];
+  }
+
+  private parseAgentsMd(filePath: string, content: string): UnifiedRule[] {
+    const trimmed = content.trim();
+    if (!trimmed) return [];
+
+    return [{
+      id: generateRuleId('codex', filePath),
+      content: trimmed,
+      source: 'codex',
+      scope: 'project',
+      priority: 5,
+      hash: hashContent(trimmed),
+    }];
+  }
+}

package/src/rules/adapters/copilot.ts

@@ -1,124 +1,124 @@
-/**
- * GitHub Copilot Rule Format Adapter
- *
- * Parses and generates rules in Copilot's formats:
- * - .github/copilot-instructions.md  (repository-wide instructions, plain Markdown)
- * - .github/instructions/*.instructions.md (path-specific, YAML frontmatter with `applyTo` glob)
- *
- * Source: https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot
- */
-
-import matter from 'gray-matter';
-import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
-import { hashContent, generateRuleId } from '../utils.js';
-
-export class CopilotAdapter implements RuleFormatAdapter {
-    readonly source: RuleSource = 'copilot';
-
-    readonly filePatterns = [
-        '.github/copilot-instructions.md',
-        '.github/instructions/*.instructions.md',
-    ];
-
-    parse(filePath: string, content: string): UnifiedRule[] {
-        // Path-specific instruction files (.github/instructions/*.instructions.md)
-        if (filePath.includes('.instructions.md') && filePath.includes('.github/instructions')) {
-            return this.parsePathSpecific(filePath, content);
-        }
-        // Repository-wide instructions (.github/copilot-instructions.md)
-        if (filePath.includes('copilot-instructions.md')) {
-            return this.parseRepoWide(filePath, content);
-        }
-        return [];
-    }
-
-    generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
-        // If only one rule with no path-specific globs, output as copilot-instructions.md
-        if (rules.length === 1 && (!rules[0].paths || rules[0].paths.length === 0)) {
-            return [{
-                filePath: '.github/copilot-instructions.md',
-                content: rules[0].content,
-            }];
-        }
-
-        // Multiple rules → output as path-specific instruction files
-        return rules.map((rule, i) => {
-            const fm: Record<string, unknown> = {};
-
-            // Preserve applyTo if available
-            if (rule.paths && rule.paths.length > 0) {
-                fm.applyTo = rule.paths.join(',');
-            }
-            if (rule.description) {
-                fm.description = rule.description;
-            }
-
-            const fileName = rule.id
-                .replace(/^copilot:/, '')
-                .replace(/[^a-zA-Z0-9-_]/g, '-')
-                || `instruction-${i}`;
-
-            const body = Object.keys(fm).length > 0
-                ? matter.stringify(rule.content, fm)
-                : rule.content;
-
-            return {
-                filePath: `.github/instructions/${fileName}.instructions.md`,
-                content: body,
-            };
-        });
-    }
-
-    /**
-     * Parse repository-wide .github/copilot-instructions.md
-     * This is plain Markdown with no frontmatter.
-     */
-    private parseRepoWide(filePath: string, content: string): UnifiedRule[] {
-        const trimmed = content.trim();
-        if (!trimmed) return [];
-
-        return [{
-            id: generateRuleId('copilot', filePath),
-            content: trimmed,
-            description: 'Repository-wide Copilot instructions',
-            source: 'copilot',
-            scope: 'project',
-            priority: 3,
-            hash: hashContent(trimmed),
-        }];
-    }
-
-    /**
-     * Parse path-specific .github/instructions/*.instructions.md
-     * These have YAML frontmatter with `applyTo` glob pattern(s).
-     */
-    private parsePathSpecific(filePath: string, content: string): UnifiedRule[] {
-        const { data, content: body } = matter(content);
-        const trimmed = body.trim();
-        if (!trimmed) return [];
-
-        const applyTo = data.applyTo as string | undefined;
-        const hasApplyTo = !!applyTo;
-
-        const rule: UnifiedRule = {
-            id: generateRuleId('copilot', filePath),
-            content: trimmed,
-            source: 'copilot',
-            scope: hasApplyTo ? 'path-specific' : 'project',
-            priority: 5,
-            hash: hashContent(trimmed),
-        };
-
-        // Extract applyTo glob pattern(s) → store in paths[]
-        if (hasApplyTo) {
-            rule.paths = applyTo!.split(',').map(p => p.trim());
-        }
-
-        // Extract description if present
-        if (data.description) {
-            rule.description = data.description as string;
-        }
-
-        return [rule];
-    }
-}
+/**
+ * GitHub Copilot Rule Format Adapter
+ *
+ * Parses and generates rules in Copilot's formats:
+ * - .github/copilot-instructions.md  (repository-wide instructions, plain Markdown)
+ * - .github/instructions/*.instructions.md (path-specific, YAML frontmatter with `applyTo` glob)
+ *
+ * Source: https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot
+ */
+
+import matter from 'gray-matter';
+import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
+import { hashContent, generateRuleId } from '../utils.js';
+
+export class CopilotAdapter implements RuleFormatAdapter {
+    readonly source: RuleSource = 'copilot';
+
+    readonly filePatterns = [
+        '.github/copilot-instructions.md',
+        '.github/instructions/*.instructions.md',
+    ];
+
+    parse(filePath: string, content: string): UnifiedRule[] {
+        // Path-specific instruction files (.github/instructions/*.instructions.md)
+        if (filePath.includes('.instructions.md') && filePath.includes('.github/instructions')) {
+            return this.parsePathSpecific(filePath, content);
+        }
+        // Repository-wide instructions (.github/copilot-instructions.md)
+        if (filePath.includes('copilot-instructions.md')) {
+            return this.parseRepoWide(filePath, content);
+        }
+        return [];
+    }
+
+    generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
+        // If only one rule with no path-specific globs, output as copilot-instructions.md
+        if (rules.length === 1 && (!rules[0].paths || rules[0].paths.length === 0)) {
+            return [{
+                filePath: '.github/copilot-instructions.md',
+                content: rules[0].content,
+            }];
+        }
+
+        // Multiple rules → output as path-specific instruction files
+        return rules.map((rule, i) => {
+            const fm: Record<string, unknown> = {};
+
+            // Preserve applyTo if available
+            if (rule.paths && rule.paths.length > 0) {
+                fm.applyTo = rule.paths.join(',');
+            }
+            if (rule.description) {
+                fm.description = rule.description;
+            }
+
+            const fileName = rule.id
+                .replace(/^copilot:/, '')
+                .replace(/[^a-zA-Z0-9-_]/g, '-')
+                || `instruction-${i}`;
+
+            const body = Object.keys(fm).length > 0
+                ? matter.stringify(rule.content, fm)
+                : rule.content;
+
+            return {
+                filePath: `.github/instructions/${fileName}.instructions.md`,
+                content: body,
+            };
+        });
+    }
+
+    /**
+     * Parse repository-wide .github/copilot-instructions.md
+     * This is plain Markdown with no frontmatter.
+     */
+    private parseRepoWide(filePath: string, content: string): UnifiedRule[] {
+        const trimmed = content.trim();
+        if (!trimmed) return [];
+
+        return [{
+            id: generateRuleId('copilot', filePath),
+            content: trimmed,
+            description: 'Repository-wide Copilot instructions',
+            source: 'copilot',
+            scope: 'project',
+            priority: 3,
+            hash: hashContent(trimmed),
+        }];
+    }
+
+    /**
+     * Parse path-specific .github/instructions/*.instructions.md
+     * These have YAML frontmatter with `applyTo` glob pattern(s).
+     */
+    private parsePathSpecific(filePath: string, content: string): UnifiedRule[] {
+        const { data, content: body } = matter(content);
+        const trimmed = body.trim();
+        if (!trimmed) return [];
+
+        const applyTo = data.applyTo as string | undefined;
+        const hasApplyTo = !!applyTo;
+
+        const rule: UnifiedRule = {
+            id: generateRuleId('copilot', filePath),
+            content: trimmed,
+            source: 'copilot',
+            scope: hasApplyTo ? 'path-specific' : 'project',
+            priority: 5,
+            hash: hashContent(trimmed),
+        };
+
+        // Extract applyTo glob pattern(s) → store in paths[]
+        if (hasApplyTo) {
+            rule.paths = applyTo!.split(',').map(p => p.trim());
+        }
+
+        // Extract description if present
+        if (data.description) {
+            rule.description = data.description as string;
+        }
+
+        return [rule];
+    }
+}