memorix 1.2.2 → 1.2.4

package/src/rules/adapters/cursor.ts

@@ -1,114 +1,114 @@
-/**
- * Cursor Rule Format Adapter
- *
- * Parses and generates rules in Cursor's formats:
- * - .cursor/rules/*.mdc (Markdown + frontmatter with description, alwaysApply, globs)
- * - .cursorrules (legacy plain text)
- * - AGENTS.md (pure Markdown)
- *
- * Source: Cursor official documentation on Project Rules.
- */
-
-import matter from 'gray-matter';
-import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
-import { hashContent, generateRuleId } from '../utils.js';
-
-export class CursorAdapter implements RuleFormatAdapter {
-  readonly source: RuleSource = 'cursor';
-
-  readonly filePatterns = [
-    '.cursor/rules/*.mdc',
-    '.cursorrules',
-    'AGENTS.md',
-  ];
-
-  parse(filePath: string, content: string): UnifiedRule[] {
-    if (filePath.endsWith('.mdc')) {
-      return this.parseMdc(filePath, content);
-    }
-    if (filePath === '.cursorrules' || filePath.endsWith('/.cursorrules')) {
-      return this.parseLegacy(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 fm: Record<string, unknown> = {};
-      if (rule.description) fm.description = rule.description;
-      if (rule.alwaysApply !== undefined) fm.alwaysApply = rule.alwaysApply;
-      if (rule.paths && rule.paths.length > 0) fm.globs = rule.paths;
-
-      const fileName = rule.id
-        .replace(/^cursor:/, '')
-        .replace(/[^a-zA-Z0-9-_]/g, '-')
-        || `rule-${i}`;
-
-      const body = Object.keys(fm).length > 0
-        ? matter.stringify(rule.content, fm)
-        : rule.content;
-
-      return {
-        filePath: `.cursor/rules/${fileName}.mdc`,
-        content: body,
-      };
-    });
-  }
-
-  private parseMdc(filePath: string, content: string): UnifiedRule[] {
-    const { data, content: body } = matter(content);
-    const trimmed = body.trim();
-    if (!trimmed) return [];
-
-    const globs = data.globs as string[] | undefined;
-    const hasGlobs = Array.isArray(globs) && globs.length > 0;
-    const alwaysApply = data.alwaysApply === true;
-
-    let scope: UnifiedRule['scope'] = 'project';
-    if (alwaysApply) scope = 'global';
-    else if (hasGlobs) scope = 'path-specific';
-
-    return [{
-      id: generateRuleId('cursor', filePath),
-      content: trimmed,
-      description: data.description as string | undefined,
-      source: 'cursor',
-      scope,
-      paths: hasGlobs ? globs : undefined,
-      alwaysApply,
-      priority: alwaysApply ? 10 : 5,
-      hash: hashContent(trimmed),
-    }];
-  }
-
-  private parseLegacy(filePath: string, content: string): UnifiedRule[] {
-    const trimmed = content.trim();
-    if (!trimmed) return [];
-
-    return [{
-      id: generateRuleId('cursor', filePath),
-      content: trimmed,
-      source: 'cursor',
-      scope: 'project',
-      priority: 3,
-      hash: hashContent(trimmed),
-    }];
-  }
-
-  private parseAgentsMd(filePath: string, content: string): UnifiedRule[] {
-    const trimmed = content.trim();
-    if (!trimmed) return [];
-
-    return [{
-      id: generateRuleId('cursor', filePath),
-      content: trimmed,
-      source: 'cursor',
-      scope: 'project',
-      priority: 5,
-      hash: hashContent(trimmed),
-    }];
-  }
-}
+/**
+ * Cursor Rule Format Adapter
+ *
+ * Parses and generates rules in Cursor's formats:
+ * - .cursor/rules/*.mdc (Markdown + frontmatter with description, alwaysApply, globs)
+ * - .cursorrules (legacy plain text)
+ * - AGENTS.md (pure Markdown)
+ *
+ * Source: Cursor official documentation on Project Rules.
+ */
+
+import matter from 'gray-matter';
+import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
+import { hashContent, generateRuleId } from '../utils.js';
+
+export class CursorAdapter implements RuleFormatAdapter {
+  readonly source: RuleSource = 'cursor';
+
+  readonly filePatterns = [
+    '.cursor/rules/*.mdc',
+    '.cursorrules',
+    'AGENTS.md',
+  ];
+
+  parse(filePath: string, content: string): UnifiedRule[] {
+    if (filePath.endsWith('.mdc')) {
+      return this.parseMdc(filePath, content);
+    }
+    if (filePath === '.cursorrules' || filePath.endsWith('/.cursorrules')) {
+      return this.parseLegacy(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 fm: Record<string, unknown> = {};
+      if (rule.description) fm.description = rule.description;
+      if (rule.alwaysApply !== undefined) fm.alwaysApply = rule.alwaysApply;
+      if (rule.paths && rule.paths.length > 0) fm.globs = rule.paths;
+
+      const fileName = rule.id
+        .replace(/^cursor:/, '')
+        .replace(/[^a-zA-Z0-9-_]/g, '-')
+        || `rule-${i}`;
+
+      const body = Object.keys(fm).length > 0
+        ? matter.stringify(rule.content, fm)
+        : rule.content;
+
+      return {
+        filePath: `.cursor/rules/${fileName}.mdc`,
+        content: body,
+      };
+    });
+  }
+
+  private parseMdc(filePath: string, content: string): UnifiedRule[] {
+    const { data, content: body } = matter(content);
+    const trimmed = body.trim();
+    if (!trimmed) return [];
+
+    const globs = data.globs as string[] | undefined;
+    const hasGlobs = Array.isArray(globs) && globs.length > 0;
+    const alwaysApply = data.alwaysApply === true;
+
+    let scope: UnifiedRule['scope'] = 'project';
+    if (alwaysApply) scope = 'global';
+    else if (hasGlobs) scope = 'path-specific';
+
+    return [{
+      id: generateRuleId('cursor', filePath),
+      content: trimmed,
+      description: data.description as string | undefined,
+      source: 'cursor',
+      scope,
+      paths: hasGlobs ? globs : undefined,
+      alwaysApply,
+      priority: alwaysApply ? 10 : 5,
+      hash: hashContent(trimmed),
+    }];
+  }
+
+  private parseLegacy(filePath: string, content: string): UnifiedRule[] {
+    const trimmed = content.trim();
+    if (!trimmed) return [];
+
+    return [{
+      id: generateRuleId('cursor', filePath),
+      content: trimmed,
+      source: 'cursor',
+      scope: 'project',
+      priority: 3,
+      hash: hashContent(trimmed),
+    }];
+  }
+
+  private parseAgentsMd(filePath: string, content: string): UnifiedRule[] {
+    const trimmed = content.trim();
+    if (!trimmed) return [];
+
+    return [{
+      id: generateRuleId('cursor', filePath),
+      content: trimmed,
+      source: 'cursor',
+      scope: 'project',
+      priority: 5,
+      hash: hashContent(trimmed),
+    }];
+  }
+}

package/src/rules/adapters/kiro.ts

@@ -1,126 +1,126 @@
-/**
- * Kiro Rule Format Adapter
- *
- * Parses and generates rules in Kiro's formats:
- * - .kiro/steering/*.md (Markdown steering rules with optional frontmatter)
- * - AGENTS.md (always included, pure Markdown)
- *
- * Source: Kiro official documentation on Steering Rules.
- * https://kiro.dev/docs/steering/
- *
- * Kiro uses ".kiro/steering/" for project-level rules
- * and "~/.kiro/steering/" for user-level (global) rules.
- *
- * Frontmatter inclusion modes:
- *   - always (default): loaded into every interaction
- *   - fileMatch + fileMatchPattern: conditional on file globs
- *   - manual: on-demand via #name in chat
- *   - auto + name + description: auto-included when relevant
- */
-
-import matter from 'gray-matter';
-import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
-import { hashContent, generateRuleId } from '../utils.js';
-
-/** Kiro inclusion mode values */
-type KiroInclusion = 'always' | 'fileMatch' | 'manual' | 'auto';
-
-export class KiroAdapter implements RuleFormatAdapter {
-    readonly source: RuleSource = 'kiro';
-
-    readonly filePatterns = [
-        '.kiro/steering/*.md',
-        'AGENTS.md',
-    ];
-
-    parse(filePath: string, content: string): UnifiedRule[] {
-        if (filePath.includes('.kiro/steering/')) {
-            return this.parseSteeringRule(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 fm: Record<string, unknown> = {};
-            if (rule.description) fm.description = rule.description;
-
-            // Map unified scope → Kiro inclusion mode
-            if (rule.paths && rule.paths.length > 0) {
-                fm.inclusion = 'fileMatch';
-                fm.fileMatchPattern = rule.paths.length === 1
-                    ? rule.paths[0]
-                    : rule.paths;
-            } else if (rule.alwaysApply) {
-                fm.inclusion = 'always';
-            }
-
-            const fileName = rule.id
-                .replace(/^kiro:/, '')
-                .replace(/[^a-zA-Z0-9-_]/g, '-')
-                || `rule-${i}`;
-
-            const body = Object.keys(fm).length > 0
-                ? matter.stringify(rule.content, fm)
-                : rule.content;
-
-            return {
-                filePath: `.kiro/steering/${fileName}.md`,
-                content: body,
-            };
-        });
-    }
-
-    private parseSteeringRule(filePath: string, content: string): UnifiedRule[] {
-        const { data, content: body } = matter(content);
-        const trimmed = body.trim();
-        if (!trimmed) return [];
-
-        // Kiro uses "inclusion" field: always | fileMatch | manual | auto
-        const inclusion = (data.inclusion as KiroInclusion | undefined) ?? 'always';
-        const alwaysApply = inclusion === 'always' || inclusion === 'auto';
-
-        // fileMatchPattern can be a string or string[]
-        let paths: string[] | undefined;
-        if (inclusion === 'fileMatch' && data.fileMatchPattern) {
-            paths = Array.isArray(data.fileMatchPattern)
-                ? data.fileMatchPattern
-                : [data.fileMatchPattern];
-        }
-
-        let scope: UnifiedRule['scope'] = 'project';
-        if (alwaysApply) scope = 'global';
-        else if (paths && paths.length > 0) scope = 'path-specific';
-
-        return [{
-            id: generateRuleId('kiro', filePath),
-            content: trimmed,
-            description: data.description as string | undefined,
-            source: 'kiro',
-            scope,
-            paths,
-            alwaysApply,
-            priority: alwaysApply ? 10 : 5,
-            hash: hashContent(trimmed),
-        }];
-    }
-
-    private parseAgentsMd(filePath: string, content: string): UnifiedRule[] {
-        const trimmed = content.trim();
-        if (!trimmed) return [];
-
-        return [{
-            id: generateRuleId('kiro', filePath),
-            content: trimmed,
-            source: 'kiro',
-            scope: 'project',
-            alwaysApply: true,
-            priority: 10,
-            hash: hashContent(trimmed),
-        }];
-    }
-}
-
+/**
+ * Kiro Rule Format Adapter
+ *
+ * Parses and generates rules in Kiro's formats:
+ * - .kiro/steering/*.md (Markdown steering rules with optional frontmatter)
+ * - AGENTS.md (always included, pure Markdown)
+ *
+ * Source: Kiro official documentation on Steering Rules.
+ * https://kiro.dev/docs/steering/
+ *
+ * Kiro uses ".kiro/steering/" for project-level rules
+ * and "~/.kiro/steering/" for user-level (global) rules.
+ *
+ * Frontmatter inclusion modes:
+ *   - always (default): loaded into every interaction
+ *   - fileMatch + fileMatchPattern: conditional on file globs
+ *   - manual: on-demand via #name in chat
+ *   - auto + name + description: auto-included when relevant
+ */
+
+import matter from 'gray-matter';
+import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
+import { hashContent, generateRuleId } from '../utils.js';
+
+/** Kiro inclusion mode values */
+type KiroInclusion = 'always' | 'fileMatch' | 'manual' | 'auto';
+
+export class KiroAdapter implements RuleFormatAdapter {
+    readonly source: RuleSource = 'kiro';
+
+    readonly filePatterns = [
+        '.kiro/steering/*.md',
+        'AGENTS.md',
+    ];
+
+    parse(filePath: string, content: string): UnifiedRule[] {
+        if (filePath.includes('.kiro/steering/')) {
+            return this.parseSteeringRule(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 fm: Record<string, unknown> = {};
+            if (rule.description) fm.description = rule.description;
+
+            // Map unified scope → Kiro inclusion mode
+            if (rule.paths && rule.paths.length > 0) {
+                fm.inclusion = 'fileMatch';
+                fm.fileMatchPattern = rule.paths.length === 1
+                    ? rule.paths[0]
+                    : rule.paths;
+            } else if (rule.alwaysApply) {
+                fm.inclusion = 'always';
+            }
+
+            const fileName = rule.id
+                .replace(/^kiro:/, '')
+                .replace(/[^a-zA-Z0-9-_]/g, '-')
+                || `rule-${i}`;
+
+            const body = Object.keys(fm).length > 0
+                ? matter.stringify(rule.content, fm)
+                : rule.content;
+
+            return {
+                filePath: `.kiro/steering/${fileName}.md`,
+                content: body,
+            };
+        });
+    }
+
+    private parseSteeringRule(filePath: string, content: string): UnifiedRule[] {
+        const { data, content: body } = matter(content);
+        const trimmed = body.trim();
+        if (!trimmed) return [];
+
+        // Kiro uses "inclusion" field: always | fileMatch | manual | auto
+        const inclusion = (data.inclusion as KiroInclusion | undefined) ?? 'always';
+        const alwaysApply = inclusion === 'always' || inclusion === 'auto';
+
+        // fileMatchPattern can be a string or string[]
+        let paths: string[] | undefined;
+        if (inclusion === 'fileMatch' && data.fileMatchPattern) {
+            paths = Array.isArray(data.fileMatchPattern)
+                ? data.fileMatchPattern
+                : [data.fileMatchPattern];
+        }
+
+        let scope: UnifiedRule['scope'] = 'project';
+        if (alwaysApply) scope = 'global';
+        else if (paths && paths.length > 0) scope = 'path-specific';
+
+        return [{
+            id: generateRuleId('kiro', filePath),
+            content: trimmed,
+            description: data.description as string | undefined,
+            source: 'kiro',
+            scope,
+            paths,
+            alwaysApply,
+            priority: alwaysApply ? 10 : 5,
+            hash: hashContent(trimmed),
+        }];
+    }
+
+    private parseAgentsMd(filePath: string, content: string): UnifiedRule[] {
+        const trimmed = content.trim();
+        if (!trimmed) return [];
+
+        return [{
+            id: generateRuleId('kiro', filePath),
+            content: trimmed,
+            source: 'kiro',
+            scope: 'project',
+            alwaysApply: true,
+            priority: 10,
+            hash: hashContent(trimmed),
+        }];
+    }
+}
+

package/src/rules/adapters/trae.ts

@@ -1,56 +1,56 @@
-/**
- * Trae IDE Rule Format Adapter
- *
- * Parses and generates rules in Trae's format:
- * - .trae/rules/project_rules.md (project-level rules, plain Markdown)
- *
- * Trae also supports user-level rules (user_rules.md) created via the UI,
- * but those are managed by Trae itself and not project-scoped.
- *
- * Rules are plain Markdown — no frontmatter, no special syntax.
- * Project rules override personal rules when there are conflicts.
- *
- * Source: https://docs.trae.ai/ide/rules
- */
-
-import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
-import { hashContent, generateRuleId } from '../utils.js';
-
-export class TraeAdapter implements RuleFormatAdapter {
-    readonly source: RuleSource = 'trae';
-
-    readonly filePatterns = [
-        '.trae/rules/project_rules.md',
-        '.trae/rules/*.md',
-    ];
-
-    parse(filePath: string, content: string): UnifiedRule[] {
-        const trimmed = content.trim();
-        if (!trimmed) return [];
-
-        const isProjectRules = filePath.includes('project_rules.md');
-
-        return [{
-            id: generateRuleId('trae', filePath),
-            content: trimmed,
-            description: isProjectRules ? 'Trae project rules' : undefined,
-            source: 'trae',
-            scope: 'project',
-            alwaysApply: true,
-            priority: isProjectRules ? 10 : 5,
-            hash: hashContent(trimmed),
-        }];
-    }
-
-    generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
-        if (rules.length === 0) return [];
-
-        // Trae uses a single project_rules.md file — merge all rules into one
-        const combined = rules.map(r => r.content).join('\n\n---\n\n');
-
-        return [{
-            filePath: '.trae/rules/project_rules.md',
-            content: combined,
-        }];
-    }
-}
+/**
+ * Trae IDE Rule Format Adapter
+ *
+ * Parses and generates rules in Trae's format:
+ * - .trae/rules/project_rules.md (project-level rules, plain Markdown)
+ *
+ * Trae also supports user-level rules (user_rules.md) created via the UI,
+ * but those are managed by Trae itself and not project-scoped.
+ *
+ * Rules are plain Markdown — no frontmatter, no special syntax.
+ * Project rules override personal rules when there are conflicts.
+ *
+ * Source: https://docs.trae.ai/ide/rules
+ */
+
+import type { RuleFormatAdapter, UnifiedRule, RuleSource } from '../../types.js';
+import { hashContent, generateRuleId } from '../utils.js';
+
+export class TraeAdapter implements RuleFormatAdapter {
+    readonly source: RuleSource = 'trae';
+
+    readonly filePatterns = [
+        '.trae/rules/project_rules.md',
+        '.trae/rules/*.md',
+    ];
+
+    parse(filePath: string, content: string): UnifiedRule[] {
+        const trimmed = content.trim();
+        if (!trimmed) return [];
+
+        const isProjectRules = filePath.includes('project_rules.md');
+
+        return [{
+            id: generateRuleId('trae', filePath),
+            content: trimmed,
+            description: isProjectRules ? 'Trae project rules' : undefined,
+            source: 'trae',
+            scope: 'project',
+            alwaysApply: true,
+            priority: isProjectRules ? 10 : 5,
+            hash: hashContent(trimmed),
+        }];
+    }
+
+    generate(rules: UnifiedRule[]): { filePath: string; content: string }[] {
+        if (rules.length === 0) return [];
+
+        // Trae uses a single project_rules.md file — merge all rules into one
+        const combined = rules.map(r => r.content).join('\n\n---\n\n');
+
+        return [{
+            filePath: '.trae/rules/project_rules.md',
+            content: combined,
+        }];
+    }
+}