ai-first-cli 1.1.1 → 1.1.2

package/src/core/adapters/community/laravelAdapter.ts

@@ -0,0 +1,56 @@
+/**
+ * Laravel Adapter
+ * 
+ * Community adapter for Laravel/PHP projects
+ */
+
+import { createAdapter, fileSignal, directorySignal, layerRule } from '../sdk.js';
+
+export const laravelAdapter = createAdapter({
+  name: 'laravel',
+  displayName: 'Laravel',
+  
+  detectionSignals: [
+    fileSignal('composer.json'),
+    fileSignal('artisan'),
+    fileSignal('phpunit.xml'),
+    directorySignal('app/Http'),
+    directorySignal('app/Console')
+  ],
+  
+  featureRoots: [
+    'app/Http/Controllers',
+    'app/Services',
+    'app/Models',
+    'app/Jobs',
+    'app/Events',
+    'app/Mail'
+  ],
+  
+  ignoredFolders: [
+    'vendor', 'node_modules', 'storage', 'bootstrap', 'config',
+    'resources', 'routes', 'database', 'tests', '.git'
+  ],
+  
+  entrypointPatterns: [
+    'Controller', 'Request', 'Command', 'Job', 'Event', 'Listener',
+    'Middleware', 'Notification', 'Mail', 'Handler'
+  ],
+  
+  layerRules: [
+    layerRule('api', 1, ['Controller', 'Request', 'Middleware', 'Resource']),
+    layerRule('service', 2, ['Service', 'Job', 'Event', 'Listener', 'Notification']),
+    layerRule('data', 3, ['Model', 'Repository', 'Database']),
+    layerRule('domain', 4, ['Entity', 'ValueObject', 'Rule']),
+    layerRule('util', 5, ['Helper', 'Support', 'Traits'])
+  ],
+  
+  supportedExtensions: ['.php'],
+  
+  flowEntrypointPatterns: ['Controller', 'Command', 'Job', 'Request'],
+  
+  flowExcludePatterns: [
+    'Model', 'Migration', 'Seeder', 'Factory', 'Test',
+    'Middleware', 'Request', 'Rule', 'Config'
+  ]
+});

package/src/core/adapters/community/nestjsAdapter.ts

@@ -0,0 +1,57 @@
+/**
+ * NestJS Adapter
+ * 
+ * Community adapter for NestJS projects
+ */
+
+import { createAdapter, fileSignal, directorySignal, layerRule } from '../sdk.js';
+
+export const nestjsAdapter = createAdapter({
+  name: 'nestjs',
+  displayName: 'NestJS',
+  
+  detectionSignals: [
+    fileSignal('package.json'),
+    fileSignal('nest-cli.json'),
+    fileSignal('tsconfig.json'),
+    directorySignal('src/modules'),
+    directorySignal('src/controllers')
+  ],
+  
+  featureRoots: [
+    'src/modules',
+    'src/controllers',
+    'src/services',
+    'src/providers',
+    'src/guards',
+    'src/filters',
+    'src/interceptors'
+  ],
+  
+  ignoredFolders: [
+    'node_modules', 'dist', 'build', 'coverage', '.git',
+    'test', 'tests', '__fixtures__'
+  ],
+  
+  entrypointPatterns: [
+    'Controller', 'Service', 'Provider', 'Guard',
+    'Interceptor', 'Filter', 'Pipe', 'Module', 'Resolver'
+  ],
+  
+  layerRules: [
+    layerRule('api', 1, ['Controller', 'Resolver', 'Gateway', 'Middleware']),
+    layerRule('service', 2, ['Service', 'Provider', 'UseCase']),
+    layerRule('data', 3, ['Repository', 'Entity', 'Model', 'DAO']),
+    layerRule('domain', 4, ['Entity', 'Domain', 'Aggregate']),
+    layerRule('util', 5, ['Guard', 'Interceptor', 'Filter', 'Pipe', 'Helper'])
+  ],
+  
+  supportedExtensions: ['.ts', '.js'],
+  
+  flowEntrypointPatterns: ['Controller', 'Resolver', 'Gateway', 'Service'],
+  
+  flowExcludePatterns: [
+    'Module', 'Guard', 'Interceptor', 'Filter', 'Pipe',
+    'Entity', 'Model', 'Repository', 'Test', 'spec'
+  ]
+});

package/src/core/adapters/community/phoenixAdapter.ts

@@ -0,0 +1,54 @@
+/**
+ * Phoenix Adapter
+ * 
+ * Community adapter for Elixir Phoenix projects
+ */
+
+import { createAdapter, fileSignal, directorySignal, layerRule } from '../sdk.js';
+
+export const phoenixAdapter = createAdapter({
+  name: 'phoenix',
+  displayName: 'Elixir Phoenix',
+  
+  detectionSignals: [
+    fileSignal('mix.exs'),
+    fileSignal('mix.lock'),
+    directorySignal('lib'),
+    directorySignal('priv')
+  ],
+  
+  featureRoots: [
+    'lib',
+    'lib/*/controllers',
+    'lib/*/views',
+    'lib/*/contexts',
+    'lib/*/schemas'
+  ],
+  
+  ignoredFolders: [
+    'node_modules', '_build', '.git', 'priv',
+    'test', 'deps', 'assets'
+  ],
+  
+  entrypointPatterns: [
+    'Controller', 'View', 'Channel', 'Socket',
+    'Plug', 'Endpoint', 'Context'
+  ],
+  
+  layerRules: [
+    layerRule('api', 1, ['Controller', 'View', 'Channel', 'Socket', 'Plug']),
+    layerRule('service', 2, ['Context', 'Service', 'Worker']),
+    layerRule('data', 3, ['Schema', 'Repo', 'Model']),
+    layerRule('domain', 4, ['Schema', 'Domain', 'Entity']),
+    layerRule('util', 5, ['Helper', 'Util', 'HTML'])
+  ],
+  
+  supportedExtensions: ['.ex', '.exs', '.eex', '.leex'],
+  
+  flowEntrypointPatterns: ['Controller', 'Channel', 'Plug', 'Endpoint'],
+  
+  flowExcludePatterns: [
+    'Schema', 'Repo', 'View', 'HTML', 'Endpoint',
+    'Router', 'Test', 'TestCase'
+  ]
+});

package/src/core/adapters/community/springBootAdapter.ts

@@ -0,0 +1,53 @@
+/**
+ * Spring Boot Adapter
+ * 
+ * Community adapter for Java Spring Boot projects
+ */
+
+import { createAdapter, fileSignal, directorySignal, layerRule } from '../sdk.js';
+
+export const springBootAdapter = createAdapter({
+  name: 'springboot',
+  displayName: 'Spring Boot',
+  
+  detectionSignals: [
+    fileSignal('pom.xml'),
+    fileSignal('build.gradle'),
+    fileSignal('gradlew'),
+    directorySignal('src/main/java'),
+    directorySignal('src/main/kotlin')
+  ],
+  
+  featureRoots: [
+    'src/main/java',
+    'src/main/kotlin',
+    'src/main/resources'
+  ],
+  
+  ignoredFolders: [
+    'node_modules', 'target', 'build', '.git', 'gradle',
+    '.gradle', 'src/test', 'src/test'
+  ],
+  
+  entrypointPatterns: [
+    'Controller', 'RestController', 'Service', 'Repository',
+    'Component', 'Configuration', 'Bean'
+  ],
+  
+  layerRules: [
+    layerRule('api', 1, ['Controller', 'RestController', 'Endpoint', 'Filter']),
+    layerRule('service', 2, ['Service', 'Component', 'Configuration']),
+    layerRule('data', 3, ['Repository', 'Entity', 'DAO', 'JdbcTemplate']),
+    layerRule('domain', 4, ['Entity', 'Domain', 'Model', 'ValueObject']),
+    layerRule('util', 5, ['Util', 'Helper', 'Configuration', 'Properties'])
+  ],
+  
+  supportedExtensions: ['.java', '.kt', '.groovy'],
+  
+  flowEntrypointPatterns: ['Controller', 'RestController', 'Service', 'CommandLineRunner'],
+  
+  flowExcludePatterns: [
+    'Repository', 'Entity', 'Configuration', 'Properties',
+    'Application', 'Test', 'TestCase'
+  ]
+});

package/src/core/adapters/dotnetAdapter.ts

@@ -0,0 +1,104 @@
+import { AnalysisAdapter } from './baseAdapter.js';
+
+/**
+ * .NET Adapter
+ * 
+ * Supports:
+ * - ASP.NET Core
+ * - .NET Framework
+ * - Blazor
+ * - Xamarin
+ */
+export const dotnetAdapter: AnalysisAdapter = {
+  name: 'dotnet',
+  displayName: '.NET',
+  
+  detectionSignals: [
+    { type: 'file', pattern: '*.csproj' },
+    { type: 'file', pattern: '*.sln' },
+    { type: 'file', pattern: '*.fsproj' },
+    { type: 'file', pattern: 'Program.cs' },
+    { type: 'file', pattern: 'Startup.cs' },
+    { type: 'file', pattern: 'appsettings.json' }
+  ],
+  
+  featureRoots: ['src', 'app', 'Services', 'Controllers', 'Models', 'ViewModels', 'Components'],
+  
+  ignoredFolders: [
+    'bin', 'obj', 'Properties', 'wwwroot', 'Test', 'Tests',
+    'node_modules', '.git', 'packages', '.vs', '.idea'
+  ],
+  
+  entrypointPatterns: [
+    'Controller', 'ApiController', 'Endpoint', 'Handler',
+    'Service', 'Command', 'Query', 'Middleware', 'Component'
+  ],
+  
+  layerRules: [
+    { name: 'api', priority: 1, patterns: ['Controller', 'ApiController', 'Endpoint', 'Handler', 'Middleware', 'Filter'] },
+    { name: 'service', priority: 2, patterns: ['Service', 'Services', 'Command', 'Query', 'Handler', 'Mediator'] },
+    { name: 'data', priority: 3, patterns: ['Repository', 'Repo', 'DbContext', 'Data', 'Entity'] },
+    { name: 'domain', priority: 4, patterns: ['Model', 'Entity', 'Domain', 'ValueObject', 'Aggregate'] },
+    { name: 'util', priority: 5, patterns: ['Helper', 'Util', 'Common', 'Extensions'] }
+  ],
+  
+  supportedExtensions: ['.cs', '.fs', '.vb', '.razor', '.cshtml', '.xaml'],
+  
+  flowEntrypointPatterns: ['Controller', 'ApiController', 'Endpoint', 'Handler', 'Command', 'Page'],
+  
+  flowExcludePatterns: [
+    'Repository', 'Service', 'Model', 'Entity', 'Dto',
+    'ViewModel', 'Mapping', 'Configuration', 'Middleware',
+    'Test', 'Tests', 'Helper', 'Util', 'Extensions'
+  ]
+};
+
+/**
+ * ASP.NET Core specific
+ */
+export const aspnetCoreAdapter: AnalysisAdapter = {
+  ...dotnetAdapter,
+  name: 'aspnetcore',
+  displayName: 'ASP.NET Core',
+  
+  detectionSignals: [
+    { type: 'file', pattern: '*.csproj' },
+    { type: 'content', pattern: 'Microsoft.AspNetCore', contentPattern: '' },
+    { type: 'file', pattern: 'Program.cs' },
+    { type: 'file', pattern: 'Startup.cs' }
+  ],
+  
+  featureRoots: ['Controllers', 'Services', 'Models', 'Views', 'Pages', 'Components', 'Areas'],
+  
+  entrypointPatterns: [
+    'Controller', 'ApiController', 'Endpoint', 'MinimalApi',
+    'Middleware', 'Filter', 'Service'
+  ]
+};
+
+/**
+ * Blazor specific
+ */
+export const blazorAdapter: AnalysisAdapter = {
+  ...dotnetAdapter,
+  name: 'blazor',
+  displayName: 'Blazor',
+  
+  detectionSignals: [
+    { type: 'file', pattern: '*.csproj' },
+    { type: 'file', pattern: '_Imports.razor' },
+    { type: 'content', pattern: '@page', contentPattern: '' }
+  ],
+  
+  featureRoots: ['Components', 'Pages', 'Shared', 'Services'],
+  
+  entrypointPatterns: ['Component', 'Page', 'Layout', 'Service', 'Controller'],
+  
+  layerRules: [
+    { name: 'ui', priority: 1, patterns: ['Component', 'Page', 'Layout', 'Razor'] },
+    { name: 'service', priority: 2, patterns: ['Service', 'Services', 'State', 'Store'] },
+    { name: 'data', priority: 3, patterns: ['Repository', 'DbContext', 'Model', 'Entity'] },
+    { name: 'domain', priority: 4, patterns: ['Entity', 'Domain', 'Model'] },
+    { name: 'util', priority: 5, patterns: ['Helper', 'Util', 'Extensions'] }
+  ]
+};

package/src/core/adapters/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Analysis Adapters
+ * 
+ * Language and framework-specific adapters for customizing
+ * feature and flow detection.
+ */
+
+export { AnalysisAdapter, DetectionSignal, LayerRule, DEFAULT_ADAPTER } from './baseAdapter.js';
+export { javascriptAdapter } from './javascriptAdapter.js';
+export { pythonAdapter, djangoAdapter, flaskAdapter } from './pythonAdapter.js';
+export { railsAdapter, rubyAdapter } from './railsAdapter.js';
+export { salesforceAdapter, sfdxAdapter } from './salesforceAdapter.js';
+export { dotnetAdapter, aspnetCoreAdapter, blazorAdapter } from './dotnetAdapter.js';
+
+// SDK exports
+export { createAdapter, validateAdapter, fileSignal, directorySignal, contentSignal, layerRule } from './sdk.js';
+export type { AdapterConfig } from './sdk.js';
+
+// Community adapters
+export { laravelAdapter, nestjsAdapter, springBootAdapter, phoenixAdapter, fastapiAdapter } from './community/index.js';
+
+// Registry
+export { detectAdapter, detectAllAdapters, getAdapter, listAdapters, ADAPTERS } from './adapterRegistry.js';
+export type { AdapterDetectionResult } from './adapterRegistry.js';

package/src/core/adapters/javascriptAdapter.ts

@@ -0,0 +1,56 @@
+import { AnalysisAdapter, DetectionSignal, LayerRule } from './baseAdapter.js';
+
+/**
+ * JavaScript/TypeScript Adapter
+ * 
+ * Supports:
+ * - Node.js projects
+ * - React/Vue/Angular apps
+ * - TypeScript projects
+ */
+export const javascriptAdapter: AnalysisAdapter = {
+  name: 'javascript',
+  displayName: 'JavaScript / TypeScript',
+  
+  detectionSignals: [
+    { type: 'file', pattern: 'package.json' },
+    { type: 'file', pattern: 'tsconfig.json' },
+    { type: 'file', pattern: 'jest.config.js' },
+    { type: 'file', pattern: 'vite.config.ts' },
+    { type: 'file', pattern: 'webpack.config.js' },
+    { type: 'file', pattern: 'next.config.js' },
+    { type: 'file', pattern: 'angular.json' }
+  ],
+  
+  featureRoots: ['src', 'app', 'packages', 'services', 'modules', 'features', 'pages', 'components'],
+  
+  ignoredFolders: [
+    'utils', 'helpers', 'types', 'interfaces', 'constants', 'config',
+    'dto', 'models', 'common', 'shared', 'node_modules', '.git',
+    'dist', 'build', 'coverage', '__tests__', 'test', 'tests',
+    '.next', '.nuxt', '.vite'
+  ],
+  
+  entrypointPatterns: [
+    'controller', 'route', 'router', 'handler', 'command',
+    'service', 'middleware', 'endpoint', 'api'
+  ],
+  
+  layerRules: [
+    { name: 'api', priority: 1, patterns: ['controller', 'handler', 'route', 'router', 'api', 'endpoint', 'middleware'] },
+    { name: 'service', priority: 2, patterns: ['service', 'services', 'usecase', 'interactor', 'business'] },
+    { name: 'data', priority: 3, patterns: ['repository', 'repo', 'dal', 'dao', 'data', 'persistence', 'db'] },
+    { name: 'domain', priority: 4, patterns: ['model', 'entity', 'schema', 'domain', 'type'] },
+    { name: 'util', priority: 5, patterns: ['util', 'helper', 'lib', 'common', 'static'] }
+  ],
+  
+  supportedExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.svelte'],
+  
+  flowEntrypointPatterns: ['controller', 'route', 'handler', 'command', 'router', 'api'],
+  
+  flowExcludePatterns: [
+    'repository', 'repo', 'utils', 'helper', 'model', 'entity',
+    'dto', 'type', 'interface', 'constant', 'config', 'schema',
+    'middleware', 'util', 'lib', 'test', 'spec'
+  ]
+};

package/src/core/adapters/pythonAdapter.ts

@@ -0,0 +1,118 @@
+import { AnalysisAdapter } from './baseAdapter.js';
+
+/**
+ * Python Adapter
+ * 
+ * Supports:
+ * - Django projects
+ * - Flask projects
+ * - FastAPI projects
+ * - Generic Python packages
+ */
+export const pythonAdapter: AnalysisAdapter = {
+  name: 'python',
+  displayName: 'Python',
+  
+  detectionSignals: [
+    { type: 'file', pattern: 'pyproject.toml' },
+    { type: 'file', pattern: 'requirements.txt' },
+    { type: 'file', pattern: 'Pipfile' },
+    { type: 'file', pattern: 'setup.py' },
+    { type: 'file', pattern: 'setup.cfg' },
+    { type: 'directory', pattern: 'venv' },
+    { type: 'directory', pattern: '.venv' },
+    { type: 'file', pattern: 'manage.py' }
+  ],
+  
+  featureRoots: ['src', 'app', 'apps', 'modules', 'services', 'api', 'core'],
+  
+  ignoredFolders: [
+    'utils', 'helpers', 'types', 'constants', 'config',
+    'migrations', '__pycache__', '.git', 'venv', '.venv',
+    'tests', 'test', '.pytest_cache', 'docs', 'scripts'
+  ],
+  
+  entrypointPatterns: [
+    'view', 'views', 'controller', 'endpoint', 'api',
+    'service', 'task', 'celery', 'command', 'management'
+  ],
+  
+  layerRules: [
+    { name: 'api', priority: 1, patterns: ['view', 'views', 'controller', 'endpoint', 'api', 'route', 'resource'] },
+    { name: 'service', priority: 2, patterns: ['service', 'services', 'usecase', 'interactor', 'business', 'logic'] },
+    { name: 'data', priority: 3, patterns: ['repository', 'repo', 'model', 'dao', 'data', 'persistence', 'db'] },
+    { name: 'domain', priority: 4, patterns: ['entity', 'schema', 'domain', 'core'] },
+    { name: 'util', priority: 5, patterns: ['util', 'helper', 'lib', 'common'] }
+  ],
+  
+  supportedExtensions: ['.py'],
+  
+  flowEntrypointPatterns: ['view', 'controller', 'endpoint', 'api', 'command', 'task'],
+  
+  flowExcludePatterns: [
+    'model', 'entity', 'utils', 'helper', 'migration',
+    'test', 'tests', '__pycache__', 'conftest', 'schema'
+  ]
+};
+
+/**
+ * Django-specific adapter
+ */
+export const djangoAdapter: AnalysisAdapter = {
+  ...pythonAdapter,
+  name: 'django',
+  displayName: 'Django',
+  
+  detectionSignals: [
+    { type: 'file', pattern: 'manage.py' },
+    { type: 'file', pattern: 'settings.py' },
+    { type: 'file', pattern: 'wsgi.py' },
+    { type: 'content', pattern: 'DJANGO_SETTINGS_MODULE', contentPattern: '' }
+  ],
+  
+  featureRoots: ['apps', 'modules', 'api', 'core'],
+  
+  entrypointPatterns: [
+    'view', 'views', 'api_view', 'controller', 'endpoint',
+    'serializer', 'service', 'task', 'management'
+  ],
+  
+  layerRules: [
+    { name: 'api', priority: 1, patterns: ['view', 'views', 'api_view', 'controller', 'endpoint', 'resource', 'serializer'] },
+    { name: 'service', priority: 2, patterns: ['service', 'services', 'usecase', 'business', 'logic'] },
+    { name: 'data', priority: 3, patterns: ['model', 'models', 'repository', 'dao', 'manager'] },
+    { name: 'domain', priority: 4, patterns: ['entity', 'schema', 'domain', 'signals'] },
+    { name: 'util', priority: 5, patterns: ['util', 'helpers', 'lib', 'common', 'middleware'] }
+  ]
+};
+
+/**
+ * Flask/FastAPI adapter
+ */
+export const flaskAdapter: AnalysisAdapter = {
+  ...pythonAdapter,
+  name: 'flask',
+  displayName: 'Flask / FastAPI',
+  
+  detectionSignals: [
+    { type: 'file', pattern: 'app.py' },
+    { type: 'file', pattern: 'main.py' },
+    { type: 'content', pattern: 'from flask import', contentPattern: '' },
+    { type: 'content', pattern: 'from fastapi import', contentPattern: '' }
+  ],
+  
+  featureRoots: ['src', 'app', 'api', 'routes', 'services', 'models'],
+  
+  entrypointPatterns: [
+    'route', 'routes', 'endpoint', 'api', 'view',
+    'service', 'command', 'blueprint'
+  ],
+  
+  layerRules: [
+    { name: 'api', priority: 1, patterns: ['route', 'routes', 'endpoint', 'api', 'blueprint', 'view'] },
+    { name: 'service', priority: 2, patterns: ['service', 'services', 'usecase', 'business'] },
+    { name: 'data', priority: 3, patterns: ['model', 'models', 'repository', 'dao'] },
+    { name: 'domain', priority: 4, patterns: ['entity', 'schema', 'domain'] },
+    { name: 'util', priority: 5, patterns: ['util', 'helpers', 'lib'] }
+  ]
+};

package/src/core/adapters/railsAdapter.ts

@@ -0,0 +1,65 @@
+import { AnalysisAdapter } from './baseAdapter.js';
+
+/**
+ * Ruby on Rails Adapter
+ */
+export const railsAdapter: AnalysisAdapter = {
+  name: 'rails',
+  displayName: 'Ruby on Rails',
+  
+  detectionSignals: [
+    { type: 'file', pattern: 'Gemfile' },
+    { type: 'file', pattern: 'config.ru' },
+    { type: 'file', pattern: 'Rakefile' },
+    { type: 'directory', pattern: 'app/controllers' },
+    { type: 'directory', pattern: 'app/models' }
+  ],
+  
+  featureRoots: ['app', 'modules', 'lib', 'engines'],
+  
+  ignoredFolders: [
+    'assets', 'javascripts', 'stylesheets', 'images', 'fonts',
+    'helpers', 'views', 'mailers', 'jobs', 'channels',
+    'node_modules', '.git', 'log', 'tmp', 'coverage', 'spec', 'test'
+  ],
+  
+  entrypointPatterns: [
+    'controller', 'endpoint', 'api', 'service', 'job',
+    'channel', 'mailer', 'serializer'
+  ],
+  
+  layerRules: [
+    { name: 'api', priority: 1, patterns: ['controller', 'endpoint', 'api', 'channel', 'mailer'] },
+    { name: 'service', priority: 2, patterns: ['service', 'services', 'usecase', 'interactor', 'operation'] },
+    { name: 'data', priority: 3, patterns: ['model', 'repository', 'record', 'concern'] },
+    { name: 'domain', priority: 4, patterns: ['entity', 'domain', 'value_object'] },
+    { name: 'util', priority: 5, patterns: ['helper', 'lib', 'concern', 'middleware'] }
+  ],
+  
+  supportedExtensions: ['.rb', '.erb', '.rake'],
+  
+  flowEntrypointPatterns: ['controller', 'endpoint', 'api', 'job', 'channel'],
+  
+  flowExcludePatterns: [
+    'model', 'helper', 'view', 'mailer', 'channel',
+    'serializer', 'concern', 'lib', 'config', 'spec', 'test'
+  ]
+};
+
+/**
+ * Ruby Gem adapter
+ */
+export const rubyAdapter: AnalysisAdapter = {
+  ...railsAdapter,
+  name: 'ruby',
+  displayName: 'Ruby',
+  
+  detectionSignals: [
+    { type: 'file', pattern: '*.gemspec' },
+    { type: 'file', pattern: 'Gemfile' }
+  ],
+  
+  featureRoots: ['lib', 'app'],
+  
+  ignoredFolders: ['spec', 'test', 'examples', 'node_modules', '.git']
+};

package/src/core/adapters/salesforceAdapter.ts

@@ -0,0 +1,76 @@
+import { AnalysisAdapter } from './baseAdapter.js';
+
+/**
+ * Salesforce Adapter
+ * 
+ * Supports:
+ * - Salesforce DX projects
+ * - Aura components
+ * - Lightning Web Components (LWC)
+ * - Apex classes
+ */
+export const salesforceAdapter: AnalysisAdapter = {
+  name: 'salesforce',
+  displayName: 'Salesforce',
+  
+  detectionSignals: [
+    { type: 'file', pattern: 'sfdx-project.json' },
+    { type: 'file', pattern: 'project-scratch-def.json' },
+    { type: 'directory', pattern: 'force-app' },
+    { type: 'directory', pattern: 'src/classes' },
+    { type: 'file', pattern: 'package.xml' }
+  ],
+  
+  featureRoots: [
+    'force-app/main/default',
+    'src',
+    'src/classes',
+    'src/objects',
+    'src/triggers'
+  ],
+  
+  ignoredFolders: [
+    'node_modules', '.git', 'dist', 'build', 'coverage',
+    'test', 'tests', 'mdapi', 'deploy', 'package.xml'
+  ],
+  
+  entrypointPatterns: [
+    'Controller', 'Trigger', 'Batch', 'Queueable', 'Schedulable',
+    'AuraEnabled', 'RestResource', 'FlowAction', 'FlowConnector',
+    'LWC', 'Component', 'App', 'Event', 'Interface'
+  ],
+  
+  layerRules: [
+    { name: 'api', priority: 1, patterns: ['Controller', 'Trigger', 'RestResource', 'AuraEnabled', 'FlowAction'] },
+    { name: 'service', priority: 2, patterns: ['Service', 'Selector', 'Domain', 'UnitOfWork'] },
+    { name: 'data', priority: 3, patterns: ['Repository', 'DAO', 'Selector', 'Model'] },
+    { name: 'domain', priority: 4, patterns: ['Entity', 'SObject', 'Schema', 'Object'] },
+    { name: 'util', priority: 5, patterns: ['Util', 'Helper', 'Constants', 'Exception'] }
+  ],
+  
+  supportedExtensions: ['.cls', '.trigger', '.apex', '.js', '.html', '.css', '.xml', '.meta.xml'],
+  
+  flowEntrypointPatterns: ['Controller', 'Trigger', 'Batch', 'Queueable', 'RestResource', 'AuraEnabled', 'LWC'],
+  
+  flowExcludePatterns: [
+    'Test', 'TestSuite', 'Settings', 'PermissionSet', 'Profile',
+    'SharingRule', 'ValidationRule', 'Workflow', 'Flow', 'ProcessBuilder'
+  ]
+};
+
+/**
+ * Salesforce DX specific
+ */
+export const sfdxAdapter: AnalysisAdapter = {
+  ...salesforceAdapter,
+  name: 'sfdx',
+  displayName: 'Salesforce DX',
+  
+  detectionSignals: [
+    { type: 'file', pattern: 'sfdx-project.json' },
+    { type: 'file', pattern: 'project-scratch-def.json' },
+    { type: 'file', pattern: '.forceignore' }
+  ],
+  
+  featureRoots: ['force-app', 'src', 'unpackaged', 'mdapi']
+};