fix: add contextignore recursively

Author: killerapp

linters/typescript/README.md

@@ -58,9 +58,37 @@ Replace `<directory_to_lint>` with the path to the directory containing your Cod
 - 🔍 Validates the structure and content of `.context.md`, `.context.yaml`, and `.context.json` files
 - ✅ Checks for required fields and sections
 - 📄 Verifies the format of `.contextdocs.md` files
-- 🚫 Validates ignore patterns in `.contextignore` files
+- 🚫 Supports and validates `.contextignore` files for excluding specific files or directories
 - 💬 Provides detailed error messages and warnings
 
+## 📁 .contextignore Files
+
+`.contextignore` files allow you to specify patterns for files and directories that should be ignored by the Codebase Context Lint. This is useful for excluding generated files, dependencies, or any other content that doesn't need context documentation.
+
+### How to use .contextignore
+
+1. Create a file named `.contextignore` in any directory of your project.
+2. Add patterns to the file, one per line. These patterns follow the same rules as `.gitignore` files.
+3. The linter will respect these ignore patterns when processing files in that directory and its subdirectories.
+
+Example `.contextignore` file:
+
+```
+# Ignore node_modules directory
+node_modules/
+
+# Ignore all .log files
+*.log
+
+# Ignore a specific file
+path/to/specific/file.js
+
+# Ignore all files in a specific directory
+path/to/ignore/*
+```
+
+The linter will validate the syntax of your `.contextignore` files and warn about any problematic patterns, such as attempting to ignore critical context files.
+
 ## 🤖 Using with AI Assistants
 
 While this linter provides automated validation of CCS files, you can also use the Codebase Context Specification with AI assistants without any specific tooling. The [CODING-ASSISTANT-PROMPT.md](https://github.com/Agentic-Insights/codebase-context-spec/blob/main/CODING-ASSISTANT-PROMPT.md) file in the main repository provides guidelines for AI assistants to understand and use the Codebase Context Specification.
@@ -71,7 +99,7 @@ To use the Codebase Context Specification with an AI assistant:
 2. Ask the AI to analyze your project's context files based on these guidelines.
 3. The AI will be able to provide more accurate and context-aware responses by following the instructions in the prompt.
 
-Note that while this approach allows for immediate use of the specification, some features like .contextignore should eventually be applied by tooling (such as this linter) for more robust implementation.
+Note that while this approach allows for immediate use of the specification, some features like .contextignore are best implemented by tooling (such as this linter) for more robust and consistent application.
 
 ## 🛠️ Development
 
@@ -104,11 +132,11 @@ To contribute to this project:
 7. Push to the branch (`git push origin feature/AmazingFeature`)
 8. Open a Pull Request
 
-## � Learn More
+## 📖 Learn More
 
 For a deeper dive into the Codebase Context Specification, check out this [SubStack article by Vaskin](https://agenticinsights.substack.com/p/codebase-context-specification-rfc), the author of the specification.
 
-## �📄 License
+## 📄 License
 
 This project is licensed under the MIT License.
 

linters/typescript/package.json

@@ -37,16 +37,17 @@
     "@types/jest": "^29.5.12",
     "@types/js-yaml": "^4.0.9",
     "@types/markdown-it": "^14.1.2",
-    "@types/node": "^22.5.1",
+    "@types/node": "^20.11.19",
     "jest": "^29.7.0",
-    "semantic-release": "^22.0.12",
+    "semantic-release": "^23.0.2",
     "ts-jest": "^29.1.2",
-    "typescript": "^5.5.4"
+    "typescript": "^5.3.3"
   },
   "dependencies": {
     "gray-matter": "^4.0.3",
+    "ignore": "^5.3.1",
     "js-yaml": "^4.1.0",
-    "markdown-it": "^14.1.0"
+    "markdown-it": "^14.0.0"
   },
   "engines": {
     "node": ">=20.0.0"

linters/typescript/src/__tests__/context_linter.test.ts

@@ -0,0 +1,92 @@
+import { ContextLinter } from '../context_linter';
+import { ContextignoreLinter } from '../contextignore_linter';
+import * as fs from 'fs';
+import * as path from 'path';
+
+jest.mock('fs', () => ({
+  promises: {
+    readdir: jest.fn(),
+    readFile: jest.fn(),
+  },
+}));
+
+jest.mock('../contextignore_linter');
+
+describe('ContextLinter', () => {
+  let linter: ContextLinter;
+  let mockContextignoreLinter: jest.Mocked<ContextignoreLinter>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockContextignoreLinter = new ContextignoreLinter() as jest.Mocked<ContextignoreLinter>;
+    linter = new ContextLinter();
+    (linter as any).contextignoreLinter = mockContextignoreLinter;
+  });
+
+  describe('lintDirectory', () => {
+    it('should lint a directory successfully', async () => {
+      const mockFiles = [
+        { name: '.contextignore', isDirectory: () => false },
+        { name: '.context.md', isDirectory: () => false },
+        { name: 'subdir', isDirectory: () => true },
+      ];
+
+      (fs.promises.readdir as jest.Mock).mockResolvedValue(mockFiles);
+      (fs.promises.readFile as jest.Mock).mockResolvedValue('# Mock content');
+      mockContextignoreLinter.lintContextignoreFile.mockResolvedValue(true);
+      mockContextignoreLinter.isIgnored.mockReturnValue(false);
+
+      const result = await linter.lintDirectory('/mock/path', '1.0.0');
+
+      expect(result).toBe(true);
+      expect(mockContextignoreLinter.lintContextignoreFile).toHaveBeenCalled();
+      expect(mockContextignoreLinter.isIgnored).toHaveBeenCalled();
+    });
+
+    it('should respect .contextignore rules', async () => {
+      const mockFiles = [
+        { name: '.contextignore', isDirectory: () => false },
+        { name: 'ignored.md', isDirectory: () => false },
+        { name: 'not_ignored.md', isDirectory: () => false },
+      ];
+
+      (fs.promises.readdir as jest.Mock).mockResolvedValue(mockFiles);
+      (fs.promises.readFile as jest.Mock).mockResolvedValue('# Mock content');
+      mockContextignoreLinter.lintContextignoreFile.mockResolvedValue(true);
+      mockContextignoreLinter.isIgnored
+        .mockReturnValueOnce(false) // .contextignore
+        .mockReturnValueOnce(true)  // ignored.md
+        .mockReturnValueOnce(false); // not_ignored.md
+
+      await linter.lintDirectory('/mock/path', '1.0.0');
+
+      expect(mockContextignoreLinter.isIgnored).toHaveBeenCalledTimes(3);
+      // Ensure that lintContextFile is not called for ignored.md
+      expect((linter as any).lintContextFile).not.toHaveBeenCalledWith(expect.stringContaining('ignored.md'));
+    });
+  });
+
+  describe('handleContextignoreRecursively', () => {
+    it('should process .contextignore files in nested directories', async () => {
+      const mockStructure = [
+        { name: '.contextignore', isDirectory: () => false },
+        { name: 'subdir', isDirectory: () => true },
+      ];
+      const mockSubdirStructure = [
+        { name: '.contextignore', isDirectory: () => false },
+      ];
+
+      (fs.promises.readdir as jest.Mock)
+        .mockResolvedValueOnce(mockStructure)
+        .mockResolvedValueOnce(mockSubdirStructure);
+      (fs.promises.readFile as jest.Mock).mockResolvedValue('# Mock content');
+      mockContextignoreLinter.lintContextignoreFile.mockResolvedValue(true);
+
+      await (linter as any).handleContextignoreRecursively('/mock/path');
+
+      expect(mockContextignoreLinter.lintContextignoreFile).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  // Add more tests for other methods as needed
+});

linters/typescript/src/__tests__/contextignore_linter.test.ts

@@ -0,0 +1,99 @@
+import { ContextignoreLinter } from '../contextignore_linter';
+import * as path from 'path';
+
+describe('ContextignoreLinter', () => {
+  let linter: ContextignoreLinter;
+
+  beforeEach(() => {
+    linter = new ContextignoreLinter();
+  });
+
+  describe('lintContextignoreFile', () => {
+    it('should validate a correct .contextignore file', async () => {
+      const content = `
+        # This is a comment
+        node_modules/
+        *.log
+        /build
+      `;
+      const result = await linter.lintContextignoreFile(content, 'test/.contextignore');
+      expect(result).toBe(true);
+    });
+
+    it('should detect invalid patterns', async () => {
+      const content = `
+        node_modules/
+        *.log
+        /build
+        invalid**pattern
+      `;
+      const result = await linter.lintContextignoreFile(content, 'test/.contextignore');
+      expect(result).toBe(false);
+    });
+
+    it('should detect attempts to ignore critical files', async () => {
+      const content = `
+        node_modules/
+        *.log
+        .context.md
+      `;
+      const result = await linter.lintContextignoreFile(content, 'test/.contextignore');
+      expect(result).toBe(false);
+    });
+
+    it('should detect conflicting patterns', async () => {
+      const content = `
+        node_modules/
+        !node_modules/important/
+        node_modules/important/
+      `;
+      const result = await linter.lintContextignoreFile(content, 'test/.contextignore');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('isIgnored', () => {
+    beforeEach(async () => {
+      const content = `
+        node_modules/
+        *.log
+        /build
+      `;
+      await linter.lintContextignoreFile(content, '/project/.contextignore');
+    });
+
+    it('should correctly identify ignored files', () => {
+      expect(linter.isIgnored('/project/node_modules/package/index.js', '/project')).toBe(true);
+      expect(linter.isIgnored('/project/app.log', '/project')).toBe(true);
+      expect(linter.isIgnored('/project/build/main.js', '/project')).toBe(true);
+    });
+
+    it('should correctly identify non-ignored files', () => {
+      expect(linter.isIgnored('/project/src/index.js', '/project')).toBe(false);
+      expect(linter.isIgnored('/project/README.md', '/project')).toBe(false);
+    });
+
+    it('should not ignore critical files', () => {
+      expect(linter.isIgnored('/project/.context.md', '/project')).toBe(false);
+      expect(linter.isIgnored('/project/subdir/.context.yaml', '/project')).toBe(false);
+      expect(linter.isIgnored('/project/.contextignore', '/project')).toBe(false);
+    });
+  });
+
+  describe('getIgnoredFiles', () => {
+    beforeEach(async () => {
+      const content = `
+        *.log
+        /build
+      `;
+      await linter.lintContextignoreFile(content, '/project/.contextignore');
+    });
+
+    it('should return a list of ignored files', () => {
+      const ignoredFiles = linter.getIgnoredFiles('/project');
+      expect(ignoredFiles).toContain('app.log');
+      expect(ignoredFiles).toContain('build/main.js');
+      expect(ignoredFiles).not.toContain('src/index.js');
+    });
+  });
+});