gencode-ai 0.1.1 → 0.1.2

package/src/memory/rules-parser.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Rules Parser Tests
+ */
+
+import { parseRuleFrontmatter, matchesPatterns } from './rules-parser.js';
+
+describe('Rules Parser', () => {
+  describe('parseRuleFrontmatter', () => {
+    it('should parse simple YAML frontmatter with paths', () => {
+      const content = `---
+paths:
+  - "src/**/*.ts"
+  - "lib/**/*.ts"
+---
+
+# Rule Content
+
+This is the rule body.`;
+
+      const result = parseRuleFrontmatter(content);
+
+      expect(result.paths).toEqual(['src/**/*.ts', 'lib/**/*.ts']);
+      expect(result.content).toBe('# Rule Content\n\nThis is the rule body.');
+    });
+
+    it('should return empty paths for content without frontmatter', () => {
+      const content = `# Rule Without Frontmatter
+
+Just regular markdown content.`;
+
+      const result = parseRuleFrontmatter(content);
+
+      expect(result.paths).toEqual([]);
+      expect(result.content).toBe('# Rule Without Frontmatter\n\nJust regular markdown content.');
+    });
+
+    it('should return empty paths when frontmatter has no paths field', () => {
+      const content = `---
+title: Some Rule
+description: A rule without path scoping
+---
+
+# Rule Content`;
+
+      const result = parseRuleFrontmatter(content);
+
+      expect(result.paths).toEqual([]);
+      expect(result.content).toBe('# Rule Content');
+    });
+
+    it('should handle single path as array', () => {
+      const content = `---
+paths:
+  - "src/api/**/*.ts"
+---
+
+# API Rules`;
+
+      const result = parseRuleFrontmatter(content);
+
+      expect(result.paths).toEqual(['src/api/**/*.ts']);
+    });
+
+    it('should filter non-string paths', () => {
+      const content = `---
+paths:
+  - "valid/path/*.ts"
+  - 123
+  - true
+  - "another/valid/*.js"
+---
+
+# Mixed Paths`;
+
+      const result = parseRuleFrontmatter(content);
+
+      expect(result.paths).toEqual(['valid/path/*.ts', 'another/valid/*.js']);
+    });
+
+    it('should handle empty frontmatter', () => {
+      const content = `---
+---
+
+# Empty Frontmatter`;
+
+      const result = parseRuleFrontmatter(content);
+
+      expect(result.paths).toEqual([]);
+      expect(result.content).toBe('# Empty Frontmatter');
+    });
+
+    it('should trim content whitespace', () => {
+      const content = `---
+paths: []
+---
+
+
+# Content with extra whitespace
+
+
+`;
+
+      const result = parseRuleFrontmatter(content);
+
+      expect(result.content).toBe('# Content with extra whitespace');
+    });
+  });
+
+  describe('matchesPatterns', () => {
+    it('should return true when patterns is empty (always active)', () => {
+      expect(matchesPatterns('any/file.ts', [])).toBe(true);
+    });
+
+    it('should match glob patterns', () => {
+      const patterns = ['src/**/*.ts'];
+
+      expect(matchesPatterns('src/components/Button.ts', patterns)).toBe(true);
+      expect(matchesPatterns('src/deep/nested/file.ts', patterns)).toBe(true);
+      expect(matchesPatterns('lib/file.ts', patterns)).toBe(false);
+    });
+
+    it('should match multiple patterns (OR logic)', () => {
+      const patterns = ['src/**/*.ts', 'lib/**/*.ts'];
+
+      expect(matchesPatterns('src/file.ts', patterns)).toBe(true);
+      expect(matchesPatterns('lib/file.ts', patterns)).toBe(true);
+      expect(matchesPatterns('test/file.ts', patterns)).toBe(false);
+    });
+
+    it('should match file extensions', () => {
+      const patterns = ['**/*.test.ts', '**/*.spec.ts'];
+
+      expect(matchesPatterns('src/Button.test.ts', patterns)).toBe(true);
+      expect(matchesPatterns('lib/utils.spec.ts', patterns)).toBe(true);
+      expect(matchesPatterns('src/Button.ts', patterns)).toBe(false);
+    });
+
+    it('should handle matchBase for simple patterns', () => {
+      const patterns = ['*.ts'];
+
+      // With matchBase: true, *.ts should match file.ts anywhere
+      expect(matchesPatterns('file.ts', patterns)).toBe(true);
+    });
+
+    it('should match specific directories', () => {
+      const patterns = ['src/api/**', 'src/routes/**'];
+
+      expect(matchesPatterns('src/api/users.ts', patterns)).toBe(true);
+      expect(matchesPatterns('src/routes/index.ts', patterns)).toBe(true);
+      expect(matchesPatterns('src/components/Button.ts', patterns)).toBe(false);
+    });
+
+    it('should handle dot files when dot option is true', () => {
+      const patterns = ['**/*.md'];
+
+      // Should match hidden directories
+      expect(matchesPatterns('.github/README.md', patterns)).toBe(true);
+    });
+
+    it('should handle negation in paths', () => {
+      // This tests behavior - minimatch handles negation differently
+      const patterns = ['src/**/*.ts'];
+
+      expect(matchesPatterns('src/index.ts', patterns)).toBe(true);
+      expect(matchesPatterns('src/index.js', patterns)).toBe(false);
+    });
+
+    it('should handle complex patterns', () => {
+      const patterns = ['src/{api,routes}/**/*.ts'];
+
+      expect(matchesPatterns('src/api/users.ts', patterns)).toBe(true);
+      expect(matchesPatterns('src/routes/auth.ts', patterns)).toBe(true);
+      expect(matchesPatterns('src/utils/helpers.ts', patterns)).toBe(false);
+    });
+
+    it('should match relative paths', () => {
+      const patterns = ['./src/**/*.ts'];
+
+      expect(matchesPatterns('./src/file.ts', patterns)).toBe(true);
+    });
+  });
+});

package/src/memory/rules-parser.ts

@@ -0,0 +1,82 @@
+/**
+ * Rules Parser - Parse frontmatter from rules files
+ *
+ * Uses gray-matter for YAML frontmatter parsing.
+ * Supports 'paths:' frontmatter for glob-based rule scoping.
+ *
+ * Example rule file:
+ * ---
+ * paths:
+ *   - "src/api/**\/*.ts"
+ *   - "src/routes/**\/*.ts"
+ * ---
+ *
+ * # API Development Rules
+ * - Use async/await consistently
+ */
+
+import matter from 'gray-matter';
+import { minimatch } from 'minimatch';
+import type { MemoryRule } from './types.js';
+
+export interface ParsedRule {
+  paths: string[];
+  content: string;
+}
+
+/**
+ * Parse frontmatter from a rule file
+ */
+export function parseRuleFrontmatter(fileContent: string): ParsedRule {
+  try {
+    const { data, content } = matter(fileContent);
+
+    // Extract paths from frontmatter
+    let paths: string[] = [];
+    if (data.paths) {
+      if (Array.isArray(data.paths)) {
+        paths = data.paths.filter((p: unknown) => typeof p === 'string');
+      } else if (typeof data.paths === 'string') {
+        paths = [data.paths];
+      }
+    }
+
+    return { paths, content: content.trim() };
+  } catch {
+    // If frontmatter parsing fails, return full content with no paths
+    return { paths: [], content: fileContent };
+  }
+}
+
+/**
+ * Check if a file path matches any of the glob patterns
+ */
+export function matchesPatterns(filePath: string, patterns: string[]): boolean {
+  if (patterns.length === 0) {
+    return true; // No patterns = always active
+  }
+
+  return patterns.some((pattern) =>
+    minimatch(filePath, pattern, {
+      matchBase: true,
+      dot: true,
+    })
+  );
+}
+
+/**
+ * Activate rules based on current file context
+ */
+export function activateRules(rules: MemoryRule[], currentFile?: string): MemoryRule[] {
+  return rules.map((rule) => ({
+    ...rule,
+    isActive: currentFile ? matchesPatterns(currentFile, rule.patterns) : rule.patterns.length === 0,
+  }));
+}
+
+/**
+ * Get only active rules
+ */
+export function getActiveRules(rules: MemoryRule[]): MemoryRule[] {
+  return rules.filter((rule) => rule.isActive);
+}

package/src/memory/test-utils.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared test utilities for memory tests
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface TestProject {
+  tempDir: string;
+  projectDir: string;
+  cleanup: () => Promise<void>;
+}
+
+/**
+ * Create a test project with temp directory and git marker
+ */
+export async function createTestProject(prefix = 'gencode-test-'): Promise<TestProject> {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+  const projectDir = path.join(tempDir, 'project');
+
+  await fs.mkdir(projectDir, { recursive: true });
+  await fs.mkdir(path.join(projectDir, '.git'));
+
+  return {
+    tempDir,
+    projectDir,
+    cleanup: async () => {
+      await fs.rm(tempDir, { recursive: true, force: true });
+      delete process.env.GENCODE_CONFIG_DIRS;
+    },
+  };
+}
+
+/**
+ * Write memory file to a directory
+ */
+export async function writeMemory(
+  projectDir: string,
+  namespace: 'claude' | 'gencode',
+  content: string,
+  options: { local?: boolean; inDir?: boolean } = {}
+): Promise<string> {
+  const { local = false, inDir = true } = options;
+  const filename = namespace === 'claude'
+    ? (local ? 'CLAUDE.local.md' : 'CLAUDE.md')
+    : (local ? 'AGENT.local.md' : 'AGENT.md');
+
+  let filePath: string;
+  if (inDir) {
+    const dir = path.join(projectDir, namespace === 'claude' ? '.claude' : '.gencode');
+    await fs.mkdir(dir, { recursive: true });
+    filePath = path.join(dir, filename);
+  } else {
+    filePath = path.join(projectDir, filename);
+  }
+
+  await fs.writeFile(filePath, content);
+  return filePath;
+}

package/src/memory/types.ts

@@ -0,0 +1,119 @@
+/**
+ * Memory System Types
+ *
+ * Hierarchical memory loading compatible with Claude Code:
+ * At each level, both .gencode and .claude are loaded and merged (gencode has higher priority).
+ *
+ * Levels:
+ * - Enterprise: System-wide managed memory (enforced)
+ * - User: ~/.gencode/ + ~/.claude/ (both loaded, gencode content appears later)
+ * - User Rules: ~/.gencode/rules/ + ~/.claude/rules/
+ * - Extra: GENCODE_CONFIG_DIRS directories
+ * - Project: ./AGENT.md, .gencode/, ./CLAUDE.md, .claude/ (recursive upward search)
+ * - Project Rules: .gencode/rules/ + .claude/rules/
+ * - Local: *.local.md files (gitignored)
+ */
+
+export type MemoryLevel =
+  | 'enterprise'
+  | 'user'
+  | 'user-rules'
+  | 'extra'
+  | 'project'
+  | 'project-rules'
+  | 'local';
+
+export type MemoryNamespace = 'gencode' | 'claude' | 'extra';
+
+export interface MemoryFile {
+  path: string;
+  content: string;
+  level: MemoryLevel;
+  namespace: MemoryNamespace;
+  loadedAt: Date;
+  resolvedImports: string[];
+  enforced?: boolean; // For enterprise level
+}
+
+export interface MemoryRule {
+  path: string;
+  content: string;
+  patterns: string[]; // Glob patterns from 'paths:' frontmatter
+  isActive: boolean; // Whether current file context matches
+  level: 'user-rules' | 'project-rules';
+  namespace: MemoryNamespace;
+}
+
+export interface MemoryConfig {
+  // GenCode file names (higher priority)
+  gencodeFilename: string;
+  gencodeLocalFilename: string;
+  gencodeDir: string;
+
+  // Claude file names (lower priority, loaded first)
+  claudeFilename: string;
+  claudeLocalFilename: string;
+  claudeDir: string;
+
+  // Common settings
+  rulesDir: string;
+  maxFileSize: number;
+  maxTotalSize: number;
+  maxImportDepth: number;
+}
+
+export const DEFAULT_MEMORY_CONFIG: MemoryConfig = {
+  // GenCode
+  gencodeFilename: 'AGENT.md',
+  gencodeLocalFilename: 'AGENT.local.md',
+  gencodeDir: '.gencode',
+
+  // Claude
+  claudeFilename: 'CLAUDE.md',
+  claudeLocalFilename: 'CLAUDE.local.md',
+  claudeDir: '.claude',
+
+  // Common
+  rulesDir: 'rules',
+  maxFileSize: 100 * 1024, // 100KB
+  maxTotalSize: 500 * 1024, // 500KB
+  maxImportDepth: 5,
+};
+
+// Legacy compatibility
+export const LEGACY_MEMORY_CONFIG = {
+  primaryFilename: 'AGENT.md',
+  fallbackFilename: 'CLAUDE.md',
+  localFilename: 'AGENT.local.md',
+  localFallbackFilename: 'CLAUDE.local.md',
+  primaryUserDir: '.gencode',
+  fallbackUserDir: '.claude',
+  primaryLocalDir: '.gencode',
+  fallbackLocalDir: '.claude',
+  rulesDir: 'rules',
+  maxFileSize: 100 * 1024,
+  maxTotalSize: 500 * 1024,
+  maxImportDepth: 5,
+};
+
+export interface LoadedMemory {
+  files: MemoryFile[];
+  rules: MemoryRule[];
+  totalSize: number;
+  context: string;
+  errors: string[];
+  sources: MemorySource[]; // For debugging
+}
+
+export interface MemorySource {
+  level: MemoryLevel;
+  namespace: MemoryNamespace;
+  path: string;
+  type: 'file' | 'rule';
+  size: number;
+}
+
+export interface MemoryLoadOptions {
+  cwd: string;
+  currentFile?: string; // For activating path-scoped rules
+}