@principal-ai/codebase-composition 0.1.0

package/src/modules/FileTypeLayerModule.ts

@@ -0,0 +1,199 @@
+import { FileTree } from '@principal-ai/repository-abstraction';
+import { BaseLayer, FileSet } from '../types/layer-types';
+
+export interface FileTypeInfo {
+  extension: string;
+  name: string;
+  count: number;
+  files: string[];
+  color: string;
+  icon: string;
+  category?: string;
+}
+
+// File type definitions with colors and lucide icon names
+const FILE_TYPE_CONFIG: Record<
+  string,
+  { name: string; color: string; icon: string; category: string }
+> = {
+  '.ts': { name: 'TypeScript', color: '#3178c6', icon: 'file-code', category: 'source' },
+  '.tsx': { name: 'TypeScript React', color: '#61dafb', icon: 'file-code-2', category: 'source' },
+  '.js': { name: 'JavaScript', color: '#f7df1e', icon: 'file-text', category: 'source' },
+  '.jsx': { name: 'JavaScript React', color: '#61dafb', icon: 'file-code-2', category: 'source' },
+  '.py': { name: 'Python', color: '#3776ab', icon: 'file-code', category: 'source' },
+  '.java': { name: 'Java', color: '#007396', icon: 'coffee', category: 'source' },
+  '.go': { name: 'Go', color: '#00add8', icon: 'file-code', category: 'source' },
+  '.rs': { name: 'Rust', color: '#dea584', icon: 'file-code', category: 'source' },
+  '.cpp': { name: 'C++', color: '#00599c', icon: 'cpu', category: 'source' },
+  '.c': { name: 'C', color: '#555555', icon: 'cpu', category: 'source' },
+  '.cs': { name: 'C#', color: '#239120', icon: 'file-code', category: 'source' },
+  '.php': { name: 'PHP', color: '#777bb4', icon: 'file-code', category: 'source' },
+  '.rb': { name: 'Ruby', color: '#cc342d', icon: 'gem', category: 'source' },
+  '.swift': { name: 'Swift', color: '#fa7343', icon: 'zap', category: 'source' },
+  '.kt': { name: 'Kotlin', color: '#7f52ff', icon: 'file-code', category: 'source' },
+  '.vue': { name: 'Vue', color: '#4fc08d', icon: 'triangle', category: 'source' },
+  '.svelte': { name: 'Svelte', color: '#ff3e00', icon: 'flame', category: 'source' },
+
+  // Config files
+  '.json': { name: 'JSON', color: '#90a4ae', icon: 'file-json', category: 'config' },
+  '.yaml': { name: 'YAML', color: '#cb171e', icon: 'file-text', category: 'config' },
+  '.yml': { name: 'YAML', color: '#cb171e', icon: 'file-text', category: 'config' },
+  '.toml': { name: 'TOML', color: '#9c4121', icon: 'settings', category: 'config' },
+  '.xml': { name: 'XML', color: '#0060ac', icon: 'code', category: 'config' },
+
+  // Documentation
+  '.md': { name: 'Markdown', color: '#083fa1', icon: 'file-text', category: 'docs' },
+  '.mdx': { name: 'MDX', color: '#fcb32c', icon: 'file-text', category: 'docs' },
+  '.txt': { name: 'Text', color: '#666666', icon: 'file-text', category: 'docs' },
+
+  // Styles
+  '.css': { name: 'CSS', color: '#1572b6', icon: 'palette', category: 'styles' },
+  '.scss': { name: 'SCSS', color: '#cc6699', icon: 'palette', category: 'styles' },
+  '.sass': { name: 'Sass', color: '#cc6699', icon: 'palette', category: 'styles' },
+  '.less': { name: 'Less', color: '#1d365d', icon: 'palette', category: 'styles' },
+
+  // Other
+  '.html': { name: 'HTML', color: '#e34c26', icon: 'globe', category: 'markup' },
+  '.svg': { name: 'SVG', color: '#ffb13b', icon: 'image', category: 'assets' },
+  '.png': { name: 'PNG', color: '#00bcd4', icon: 'image', category: 'assets' },
+  '.jpg': { name: 'JPEG', color: '#00bcd4', icon: 'image', category: 'assets' },
+  '.jpeg': { name: 'JPEG', color: '#00bcd4', icon: 'image', category: 'assets' },
+  '.gif': { name: 'GIF', color: '#00bcd4', icon: 'image', category: 'assets' },
+  '.sh': { name: 'Shell', color: '#4eaa25', icon: 'terminal', category: 'scripts' },
+  '.bat': { name: 'Batch', color: '#4d4d4d', icon: 'terminal', category: 'scripts' },
+  '.ps1': { name: 'PowerShell', color: '#012456', icon: 'terminal', category: 'scripts' },
+};
+
+// Default config for unknown file types
+const DEFAULT_FILE_TYPE = {
+  color: '#9e9e9e',
+  icon: 'file',
+  category: 'other',
+};
+
+export class FileTypeLayerModule {
+  /**
+   * Extract file type information from the file tree
+   */
+  extractFileTypes(fileTree: FileTree): FileTypeInfo[] {
+    const fileTypeMap = new Map<string, FileTypeInfo>();
+
+    if (!fileTree.allFiles) {
+      return [];
+    }
+
+    // Group files by extension
+    for (const file of fileTree.allFiles) {
+      const extension = this.getFileExtension(file.name);
+      if (!extension) continue;
+
+      const filePath = file.relativePath || file.path;
+
+      // Skip common ignored paths
+      if (this.shouldIgnorePath(filePath)) continue;
+
+      if (!fileTypeMap.has(extension)) {
+        const config = FILE_TYPE_CONFIG[extension] || {
+          name: extension.toUpperCase().replace('.', ''),
+          ...DEFAULT_FILE_TYPE,
+        };
+
+        fileTypeMap.set(extension, {
+          extension,
+          name: config.name,
+          count: 0,
+          files: [],
+          color: config.color,
+          icon: config.icon,
+          category: config.category,
+        });
+      }
+
+      const typeInfo = fileTypeMap.get(extension)!;
+      typeInfo.count++;
+      typeInfo.files.push(filePath);
+    }
+
+    // Convert to array and sort by count
+    return Array.from(fileTypeMap.values()).sort((a, b) => b.count - a.count);
+  }
+
+  /**
+   * Create BaseLayer objects from file type information
+   */
+  createFileTypeLayers(fileTypes: FileTypeInfo[]): BaseLayer[] {
+    return fileTypes.map(fileType => {
+      const fileSet: FileSet = {
+        id: `files-${fileType.extension}`,
+        name: `${fileType.name} files`,
+        patterns: [
+          {
+            type: 'glob',
+            pattern: `**/*${fileType.extension}`,
+            description: `All ${fileType.extension} files`,
+          },
+        ],
+        matchedFiles: fileType.files,
+        fileCount: fileType.count,
+      };
+
+      const layer: BaseLayer = {
+        id: `file-type-${fileType.extension}`,
+        name: fileType.name,
+        type: 'file-type',
+        enabled: false,
+        derivedFrom: {
+          fileSets: [fileSet],
+          derivationType: 'presence',
+          description: `Files with ${fileType.extension} extension`,
+        },
+        color: fileType.color,
+        icon: fileType.icon,
+        pillar: 'viewLayers',
+      };
+
+      return layer;
+    });
+  }
+
+  /**
+   * Get file extension from filename
+   */
+  private getFileExtension(filename: string): string {
+    const lastDot = filename.lastIndexOf('.');
+    if (lastDot === -1 || lastDot === filename.length - 1) {
+      return '';
+    }
+    return filename.slice(lastDot).toLowerCase();
+  }
+
+  /**
+   * Check if a path should be ignored
+   */
+  private shouldIgnorePath(path: string): boolean {
+    const ignoredPaths = [
+      'node_modules',
+      '.git',
+      'dist',
+      'build',
+      'coverage',
+      '.next',
+      '.nuxt',
+      'target',
+      '__pycache__',
+      '.pytest_cache',
+      '.vscode',
+      '.idea',
+    ];
+
+    return ignoredPaths.some(ignored => path.includes(ignored));
+  }
+
+  /**
+   * Create file type layers from a file tree
+   */
+  async processFileTree(fileTree: FileTree): Promise<BaseLayer[]> {
+    const fileTypes = this.extractFileTypes(fileTree);
+    return this.createFileTypeLayers(fileTypes);
+  }
+}

package/src/modules/FrameworkLayerModule.ts

@@ -0,0 +1,437 @@
+import { FrameworkLayer, PackageLayer, FileSet } from '../types/layer-types';
+
+interface FrameworkDefinition {
+  name: string;
+  category: 'ui' | 'backend' | 'testing' | 'build' | 'styling';
+  deps: string[];
+  color: string;
+  icon: string; // Lucide icon name
+}
+
+// Framework definitions with their identifying dependencies
+const FRAMEWORK_DEFINITIONS: Record<string, FrameworkDefinition> = {
+  // UI Frameworks
+  react: {
+    name: 'React',
+    category: 'ui',
+    deps: ['react', 'react-dom'],
+    color: '#61DAFB',
+    icon: 'atom',
+  },
+  vue: {
+    name: 'Vue',
+    category: 'ui',
+    deps: ['vue'],
+    color: '#4FC08D',
+    icon: 'triangle',
+  },
+  angular: {
+    name: 'Angular',
+    category: 'ui',
+    deps: ['@angular/core'],
+    color: '#DD0031',
+    icon: 'hexagon',
+  },
+  svelte: {
+    name: 'Svelte',
+    category: 'ui',
+    deps: ['svelte'],
+    color: '#FF3E00',
+    icon: 'flame',
+  },
+  solid: {
+    name: 'Solid',
+    category: 'ui',
+    deps: ['solid-js'],
+    color: '#2C4F7C',
+    icon: 'box',
+  },
+  preact: {
+    name: 'Preact',
+    category: 'ui',
+    deps: ['preact'],
+    color: '#673AB8',
+    icon: 'feather',
+  },
+
+  // Backend Frameworks
+  express: {
+    name: 'Express',
+    category: 'backend',
+    deps: ['express'],
+    color: '#000000',
+    icon: 'train',
+  },
+  fastify: {
+    name: 'Fastify',
+    category: 'backend',
+    deps: ['fastify'],
+    color: '#000000',
+    icon: 'zap',
+  },
+  nestjs: {
+    name: 'NestJS',
+    category: 'backend',
+    deps: ['@nestjs/core'],
+    color: '#E0234E',
+    icon: 'cat',
+  },
+  koa: {
+    name: 'Koa',
+    category: 'backend',
+    deps: ['koa'],
+    color: '#33333D',
+    icon: 'cloud',
+  },
+  hapi: {
+    name: 'Hapi',
+    category: 'backend',
+    deps: ['@hapi/hapi', 'hapi'],
+    color: '#F07100',
+    icon: 'shield',
+  },
+
+  // Python Backend Frameworks
+  django: {
+    name: 'Django',
+    category: 'backend',
+    deps: ['django'],
+    color: '#092E20',
+    icon: 'layers',
+  },
+  flask: {
+    name: 'Flask',
+    category: 'backend',
+    deps: ['flask'],
+    color: '#000000',
+    icon: 'flask-conical',
+  },
+  fastapi: {
+    name: 'FastAPI',
+    category: 'backend',
+    deps: ['fastapi'],
+    color: '#009688',
+    icon: 'zap',
+  },
+
+  // Testing Frameworks
+  jest: {
+    name: 'Jest',
+    category: 'testing',
+    deps: ['jest'],
+    color: '#C21325',
+    icon: 'test-tube',
+  },
+  mocha: {
+    name: 'Mocha',
+    category: 'testing',
+    deps: ['mocha'],
+    color: '#8D6748',
+    icon: 'coffee',
+  },
+  vitest: {
+    name: 'Vitest',
+    category: 'testing',
+    deps: ['vitest'],
+    color: '#729B1B',
+    icon: 'flask-round',
+  },
+  cypress: {
+    name: 'Cypress',
+    category: 'testing',
+    deps: ['cypress'],
+    color: '#17202C',
+    icon: 'eye',
+  },
+  playwright: {
+    name: 'Playwright',
+    category: 'testing',
+    deps: ['@playwright/test', 'playwright'],
+    color: '#2EAD33',
+    icon: 'play',
+  },
+  pytest: {
+    name: 'Pytest',
+    category: 'testing',
+    deps: ['pytest'],
+    color: '#0A9EDC',
+    icon: 'check-circle',
+  },
+
+  // Build Tools
+  webpack: {
+    name: 'Webpack',
+    category: 'build',
+    deps: ['webpack'],
+    color: '#8DD6F9',
+    icon: 'package',
+  },
+  vite: {
+    name: 'Vite',
+    category: 'build',
+    deps: ['vite'],
+    color: '#646CFF',
+    icon: 'zap',
+  },
+  rollup: {
+    name: 'Rollup',
+    category: 'build',
+    deps: ['rollup'],
+    color: '#FF6533',
+    icon: 'package-2',
+  },
+  parcel: {
+    name: 'Parcel',
+    category: 'build',
+    deps: ['parcel'],
+    color: '#E7BF7E',
+    icon: 'package',
+  },
+  esbuild: {
+    name: 'ESBuild',
+    category: 'build',
+    deps: ['esbuild'],
+    color: '#FFCF00',
+    icon: 'cpu',
+  },
+
+  // Styling
+  tailwind: {
+    name: 'Tailwind CSS',
+    category: 'styling',
+    deps: ['tailwindcss'],
+    color: '#06B6D4',
+    icon: 'wind',
+  },
+  styledComponents: {
+    name: 'Styled Components',
+    category: 'styling',
+    deps: ['styled-components'],
+    color: '#DB7093',
+    icon: 'palette',
+  },
+  emotion: {
+    name: 'Emotion',
+    category: 'styling',
+    deps: ['@emotion/react', '@emotion/styled'],
+    color: '#D36AC7',
+    icon: 'heart',
+  },
+  sass: {
+    name: 'Sass/SCSS',
+    category: 'styling',
+    deps: ['sass', 'node-sass'],
+    color: '#CC6699',
+    icon: 'palette',
+  },
+};
+
+// Common Python frameworks that might not be in package.json format
+const PYTHON_FRAMEWORKS = new Set([
+  'django',
+  'flask',
+  'fastapi',
+  'pyramid',
+  'tornado',
+  'aiohttp',
+  'bottle',
+  'cherrypy',
+  'falcon',
+  'sanic',
+]);
+
+export class FrameworkLayerModule {
+  /**
+   * Detect frameworks from package layers
+   */
+  detectFrameworks(packageLayers: PackageLayer[]): FrameworkLayer[] {
+    const frameworkMap = new Map<
+      string,
+      {
+        definition: FrameworkDefinition;
+        usedBy: Set<string>;
+        packagePaths: Set<string>;
+      }
+    >();
+
+    // Check each package for framework dependencies
+    packageLayers.forEach(packageLayer => {
+      const allDeps = {
+        ...packageLayer.packageData.dependencies,
+        ...packageLayer.packageData.devDependencies,
+        ...packageLayer.packageData.peerDependencies,
+      };
+
+      // Check each framework definition
+      Object.entries(FRAMEWORK_DEFINITIONS).forEach(([key, framework]) => {
+        const hasFramework = framework.deps.some(dep => dep in allDeps);
+
+        if (hasFramework) {
+          if (!frameworkMap.has(key)) {
+            frameworkMap.set(key, {
+              definition: framework,
+              usedBy: new Set(),
+              packagePaths: new Set(),
+            });
+          }
+
+          const entry = frameworkMap.get(key)!;
+          entry.usedBy.add(packageLayer.packageData.name);
+          entry.packagePaths.add(packageLayer.packageData.path);
+        }
+      });
+
+      // Check for Python frameworks in dependencies
+      if (packageLayer.type === 'python') {
+        Object.keys(allDeps).forEach(dep => {
+          const depLower = dep.toLowerCase();
+          if (PYTHON_FRAMEWORKS.has(depLower)) {
+            // Find if we have a definition for this
+            const definitionEntry = Object.entries(FRAMEWORK_DEFINITIONS).find(
+              ([_, def]) => def.name.toLowerCase() === depLower,
+            );
+
+            if (definitionEntry) {
+              const [key, definition] = definitionEntry;
+              if (!frameworkMap.has(key)) {
+                frameworkMap.set(key, {
+                  definition,
+                  usedBy: new Set(),
+                  packagePaths: new Set(),
+                });
+              }
+
+              const entry = frameworkMap.get(key)!;
+              entry.usedBy.add(packageLayer.packageData.name);
+              entry.packagePaths.add(packageLayer.packageData.path);
+            }
+          }
+        });
+      }
+    });
+
+    // Convert to FrameworkLayer array
+    return Array.from(frameworkMap.entries()).map(([key, entry]) => {
+      const { definition, usedBy, packagePaths } = entry;
+
+      // Create file sets for framework detection
+      const depFileSets: FileSet[] =
+        packagePaths.size > 0
+          ? [
+              {
+                id: `framework-deps-${key}`,
+                name: `${definition.name} dependencies`,
+                patterns: Array.from(packagePaths).map(path => ({
+                  type: 'exact' as const,
+                  pattern: path === '.' ? 'package.json' : `${path}/package.json`,
+                  description: `Package manifest containing ${definition.name} dependencies`,
+                })),
+                matchedFiles: Array.from(packagePaths).map(path =>
+                  path === '.' ? 'package.json' : `${path}/package.json`,
+                ),
+                fileCount: packagePaths.size,
+              },
+            ]
+          : [];
+
+      const layer: FrameworkLayer = {
+        id: `framework-${key}`,
+        name: definition.name,
+        type: 'framework',
+        enabled: true,
+        derivedFrom: {
+          fileSets: depFileSets,
+          derivationType: 'content',
+          description: `${definition.name} framework detected from package dependencies`,
+          contentExtraction: {
+            method: 'parse',
+            parser: {
+              format: 'json',
+              paths: definition.deps
+                .map(dep => `dependencies.${dep}`)
+                .concat(definition.deps.map(dep => `devDependencies.${dep}`))
+                .concat(definition.deps.map(dep => `peerDependencies.${dep}`)),
+            },
+          },
+        },
+        frameworkData: {
+          name: definition.name,
+          category: definition.category,
+          usedBy: Array.from(usedBy),
+        },
+        color: definition.color,
+        icon: definition.icon,
+        pillar:
+          definition.category === 'testing'
+            ? 'validation'
+            : definition.category === 'build'
+              ? 'foundationHealth'
+              : 'viewLayers',
+      };
+
+      return layer;
+    });
+  }
+
+  /**
+   * Get framework compatibility information
+   */
+  analyzeCompatibility(frameworks: FrameworkLayer[]): {
+    conflicts: Array<{ framework1: string; framework2: string; reason: string }>;
+    recommendations: Array<{ message: string; severity: 'info' | 'warning' }>;
+  } {
+    const compatibility = {
+      conflicts: [] as Array<{ framework1: string; framework2: string; reason: string }>,
+      recommendations: [] as Array<{ message: string; severity: 'info' | 'warning' }>,
+    };
+
+    // Check for multiple UI frameworks
+    const uiFrameworks = frameworks.filter(f => f.frameworkData.category === 'ui');
+    if (uiFrameworks.length > 1) {
+      // Check if they're used in the same packages
+      for (let i = 0; i < uiFrameworks.length - 1; i++) {
+        for (let j = i + 1; j < uiFrameworks.length; j++) {
+          const sharedPackages = uiFrameworks[i].frameworkData.usedBy.filter((pkg: string) =>
+            uiFrameworks[j].frameworkData.usedBy.includes(pkg),
+          );
+
+          if (sharedPackages.length > 0) {
+            compatibility.conflicts.push({
+              framework1: uiFrameworks[i].name,
+              framework2: uiFrameworks[j].name,
+              reason: `Both UI frameworks found in: ${sharedPackages.join(', ')}`,
+            });
+          }
+        }
+      }
+
+      if (uiFrameworks.length > 2) {
+        compatibility.recommendations.push({
+          message: `${uiFrameworks.length} UI frameworks detected. Consider consolidating to reduce complexity.`,
+          severity: 'warning',
+        });
+      }
+    }
+
+    // Check for multiple backend frameworks
+    const backendFrameworks = frameworks.filter(f => f.frameworkData.category === 'backend');
+    if (backendFrameworks.length > 2) {
+      compatibility.recommendations.push({
+        message: `Multiple backend frameworks detected: ${backendFrameworks.map(f => f.name).join(', ')}`,
+        severity: 'info',
+      });
+    }
+
+    // Check for missing testing frameworks
+    const hasTestingFramework = frameworks.some(f => f.frameworkData.category === 'testing');
+    if (!hasTestingFramework && frameworks.length > 0) {
+      compatibility.recommendations.push({
+        message:
+          'No testing framework detected. Consider adding Jest, Vitest, or another testing solution.',
+        severity: 'info',
+      });
+    }
+
+    return compatibility;
+  }
+}