project-structure-lint 1.0.1

package/src/utils/fileScanner.ts

@@ -0,0 +1,162 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import micromatch from 'micromatch';
+
+export interface ScannedFile {
+  path: string;
+  name: string;
+  directory: string;
+  extension: string;
+  isDirectory: boolean;
+}
+
+export class FileScanner {
+  private rootDir: string;
+  private ignorePatterns: string[];
+
+  constructor(rootDir: string, ignorePatterns: string[] = []) {
+    this.rootDir = path.resolve(rootDir);
+    this.ignorePatterns = ignorePatterns;
+  }
+
+  async scanDirectory(dir: string = this.rootDir): Promise<ScannedFile[]> {
+    const files: ScannedFile[] = [];
+    
+    try {
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(this.rootDir, fullPath);
+
+        // Skip ignored paths
+        if (this.shouldIgnore(relativePath)) {
+          continue;
+        }
+
+        const scannedFile: ScannedFile = {
+          path: relativePath,
+          name: entry.name,
+          directory: path.relative(this.rootDir, dir),
+          extension: path.extname(entry.name),
+          isDirectory: entry.isDirectory()
+        };
+
+        files.push(scannedFile);
+
+        // Recursively scan subdirectories
+        if (entry.isDirectory()) {
+          const subFiles = await this.scanDirectory(fullPath);
+          files.push(...subFiles);
+        }
+      }
+    } catch (error) {
+      console.error(`Error scanning directory ${dir}:`, error);
+    }
+
+    return files;
+  }
+
+  async findFiles(pattern: string, baseDir?: string): Promise<string[]> {
+    const searchDir = baseDir ? path.join(this.rootDir, baseDir) : this.rootDir;
+    
+    try {
+      const files = await glob(pattern, {
+        cwd: searchDir,
+        ignore: this.ignorePatterns,
+        nodir: true
+      });
+      
+      return files.map(file => 
+        baseDir ? path.join(baseDir, file) : file
+      );
+    } catch (error) {
+      console.error(`Error finding files with pattern ${pattern}:`, error);
+      return [];
+    }
+  }
+
+  async getDirectoryContents(dir: string): Promise<ScannedFile[]> {
+    const fullPath = path.join(this.rootDir, dir);
+    const files: ScannedFile[] = [];
+
+    try {
+      const entries = await fs.promises.readdir(fullPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const relativePath = path.join(dir, entry.name);
+
+        if (this.shouldIgnore(relativePath)) {
+          continue;
+        }
+
+        files.push({
+          path: relativePath,
+          name: entry.name,
+          directory: dir,
+          extension: path.extname(entry.name),
+          isDirectory: entry.isDirectory()
+        });
+      }
+    } catch (error) {
+      // Directory doesn't exist or can't be read
+      return [];
+    }
+
+    return files;
+  }
+
+  getComponentDirectories(componentDirs: string[]): string[] {
+    const dirs: string[] = [];
+
+    for (const dir of componentDirs) {
+      const fullPath = path.join(this.rootDir, dir);
+      
+      if (!fs.existsSync(fullPath)) {
+        continue;
+      }
+
+      try {
+        const entries = fs.readdirSync(fullPath, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const relativePath = path.join(dir, entry.name);
+            if (!this.shouldIgnore(relativePath)) {
+              dirs.push(relativePath);
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Error reading component directory ${fullPath}:`, error);
+      }
+    }
+
+    return dirs;
+  }
+
+  private shouldIgnore(filePath: string): boolean {
+    if (this.ignorePatterns.length === 0) {
+      return false;
+    }
+
+    return micromatch.isMatch(filePath, this.ignorePatterns);
+  }
+
+  fileExists(filePath: string): boolean {
+    const fullPath = path.join(this.rootDir, filePath);
+    return fs.existsSync(fullPath);
+  }
+
+  isDirectory(filePath: string): boolean {
+    const fullPath = path.join(this.rootDir, filePath);
+    try {
+      return fs.statSync(fullPath).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+}
+
+// Made with 

package/src/utils/naming.ts

@@ -0,0 +1,99 @@
+import { NamingConvention } from '../types';
+
+export function validateNamingConvention(
+  filename: string,
+  convention: NamingConvention
+): boolean {
+  // Remove extension
+  const nameWithoutExt = filename.replace(/\.[^/.]+$/, '');
+  
+  // Remove test/spec/stories suffixes but keep the base name
+  const cleanName = nameWithoutExt
+    .replace(/\.(test|spec|stories|types|d)$/, '');
+
+  switch (convention) {
+    case 'PascalCase':
+      return /^[A-Z][a-zA-Z0-9]*$/.test(cleanName);
+    
+    case 'camelCase':
+      return /^[a-z][a-zA-Z0-9]*$/.test(cleanName);
+    
+    case 'kebab-case':
+      return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(cleanName);
+    
+    case 'snake_case':
+      return /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(cleanName);
+    
+    case 'UPPER_CASE':
+      return /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/.test(cleanName);
+    
+    default:
+      return true;
+  }
+}
+
+export function getExpectedNaming(
+  filename: string,
+  convention: NamingConvention
+): string {
+  const nameWithoutExt = filename.replace(/\.[^/.]+$/, '');
+  const ext = filename.substring(nameWithoutExt.length);
+  
+  let converted = nameWithoutExt;
+  
+  switch (convention) {
+    case 'PascalCase':
+      converted = toPascalCase(nameWithoutExt);
+      break;
+    
+    case 'camelCase':
+      converted = toCamelCase(nameWithoutExt);
+      break;
+    
+    case 'kebab-case':
+      converted = toKebabCase(nameWithoutExt);
+      break;
+    
+    case 'snake_case':
+      converted = toSnakeCase(nameWithoutExt);
+      break;
+    
+    case 'UPPER_CASE':
+      converted = toUpperCase(nameWithoutExt);
+      break;
+  }
+  
+  return converted + ext;
+}
+
+function toPascalCase(str: string): string {
+  return str
+    .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+    .replace(/^(.)/, (c) => c.toUpperCase());
+}
+
+function toCamelCase(str: string): string {
+  return str
+    .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+    .replace(/^(.)/, (c) => c.toLowerCase());
+}
+
+function toKebabCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase();
+}
+
+function toSnakeCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/[\s-]+/g, '_')
+    .toLowerCase();
+}
+
+function toUpperCase(str: string): string {
+  return toSnakeCase(str).toUpperCase();
+}
+
+// Made with 

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020", "DOM"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}