fix: recursion and diagram / related modules checks

Author: killerapp

.context.md

@@ -2,7 +2,10 @@
 module-name: Codebase Context Specification
 version: 1.0.0
 description: A specification for providing explicit context information about a codebase
-related-modules: []
+related-modules: 
+  - TypeScript Linter: ./linters/typescript
+  - Codebase Context Editor: ./examples/context-editor
+  - Three: ./invalid
 technologies:
   - Markdown
   - YAML
@@ -16,7 +19,7 @@ directives:
   - Maintain backward compatibility
   - Keep documentation up-to-date
 diagrams:
-  - context-hierarchy.png
+  - Dagram : ./img/codebase-diagram.mermaid
 architecture:
   style: Documentation-driven
   components:

linters/typescript/src/context_linter.ts

@@ -34,7 +34,6 @@ export class ContextLinter {
   public async lintDirectory(directoryPath: string, packageVersion: string): Promise<boolean> {
     try {
       printHeader(packageVersion, directoryPath);
-      console.log(`Linting directory: ${this.normalizePath(directoryPath)}\n`);
       let isValid = true;
 
       // Initialize ignore patterns
@@ -104,31 +103,41 @@ export class ContextLinter {
 
     for (const filePath of contextFiles) {
       if (!this.contextignoreLinter.isIgnored(filePath, directoryPath)) {
-        const fileContent = await fs.promises.readFile(filePath, 'utf-8');
-        const fileExtension = path.extname(filePath);
+        const fullPath = path.join(directoryPath, filePath);
+        const fileContent = await fs.promises.readFile(fullPath, 'utf-8');
+        const fileExtension = path.extname(fullPath);
         let result: ValidationResult;
 
         switch (fileExtension) {
           case '.md':
-            result = await this.lintMarkdownFile(fileContent, filePath);
+            result = await this.lintMarkdownFile(fileContent, fullPath);
             break;
           case '.yaml':
           case '.yml':
-            result = await this.lintYamlFile(fileContent, filePath);
+            result = await this.lintYamlFile(fileContent, fullPath);
             break;
           case '.json':
-            result = await this.lintJsonFile(fileContent, filePath);
+            result = await this.lintJsonFile(fileContent, fullPath);
             break;
           default:
             console.warn(`Unsupported file extension: ${fileExtension}`);
             continue;
         }
 
-        this.printValidationResult(result, filePath);
+        this.printValidationResult(result, fullPath);
         isValid = isValid && result.isValid;
       }
     }
 
+    // Recursively process subdirectories
+    const subdirectories = await fs.promises.readdir(directoryPath, { withFileTypes: true });
+    for (const dirent of subdirectories) {
+      if (dirent.isDirectory() && !this.contextignoreLinter.isIgnored(dirent.name, directoryPath)) {
+        const subdirectoryPath = path.join(directoryPath, dirent.name);
+        isValid = await this.handleContextFilesRecursively(subdirectoryPath) && isValid;
+      }
+    }
+
     return isValid;
   }
 

linters/typescript/src/utils/context_structure.ts

@@ -53,5 +53,6 @@ export const stringTypes: Set<string> = new Set([
 ]);
 
 export const directoryTypes: Set<string> = new Set([
-  'related-modules'
+  'related-modules',
+  'diagrams'
 ]);

linters/typescript/src/utils/validator.ts

@@ -1,3 +1,5 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { kebabToCamelCase } from './string_utils';
 import { allowedTopLevelFields, sectionChecks, listTypes, stringTypes, directoryTypes } from './context_structure';
 
@@ -76,11 +78,45 @@ export class ContextValidator {
       console.error(`  Error: Field '${field}' should be a string.`);
       isValid = false;
     } else if (directoryTypes.has(field)) {
-      // Additional validation for directory types can be added here
+      if (field === 'related-modules' && Array.isArray(value)) {
+        for (const modulePath of value) {
+          if (typeof modulePath === 'string' && !this.isValidRelatedModule(modulePath)) {
+            console.error(`  Error: Related module '${modulePath}' is not a valid directory containing a .context file.`);
+            isValid = false;
+          }
+        }
+      } else if (field === 'diagrams' && Array.isArray(value)) {
+        for (const diagramPath of value) {
+          if (typeof diagramPath === 'string' && !this.isValidDiagram(diagramPath)) {
+            console.error(`  Error: Diagram '${diagramPath}' is not a valid file or URL.`);
+            isValid = false;
+          }
+        }
+      }
     }
     return isValid;
   }
 
+  private isValidRelatedModule(modulePath: string): boolean {
+    if (!fs.existsSync(modulePath) || !fs.statSync(modulePath).isDirectory()) {
+      return false;
+    }
+    const contextFiles = ['.context.md', '.context.json', '.context.yaml', '.context.yml'];
+    return contextFiles.some(file => fs.existsSync(path.join(modulePath, file)));
+  }
+
+  private isValidDiagram(diagramPath: string): boolean {
+    if (diagramPath.startsWith('http://') || diagramPath.startsWith('https://')) {
+      // Assume URLs are valid diagrams
+      return true;
+    }
+    if (!fs.existsSync(diagramPath)) {
+      return false;
+    }
+    const allowedExtensions = ['.mermaid', '.mmd', '.pdf', '.png', '.jpeg', '.jpg'];
+    return allowedExtensions.includes(path.extname(diagramPath).toLowerCase());
+  }
+
   private validateSectionFields(sectionName: string, data: Record<string, unknown>, isJson: boolean): SectionValidationResult {
     const checks = sectionChecks[sectionName];
     const coveredFields = new Set<string>();