@complior/engine 0.9.0

package/src/domain/scanner/import-graph.ts

@@ -0,0 +1,198 @@
+import type { FileInfo } from '../../ports/scanner.port.js';
+import { AI_PACKAGES } from './data/ai-packages.js';
+import { AST_SUPPORTED_EXTENSIONS } from './constants.js';
+
+export interface ImportGraphNode {
+  readonly file: string;          // relative path
+  readonly imports: readonly string[];  // resolved relative paths
+  readonly isAiRelevant: boolean;       // imports AI SDK (directly or transitively)
+  readonly aiRelevanceDepth: number;    // 0 = direct AI SDK import, 1 = imports file that imports SDK, etc.
+}
+
+export interface ImportGraph {
+  readonly nodes: ReadonlyMap<string, ImportGraphNode>;
+  readonly aiRelevantFiles: ReadonlySet<string>;
+  readonly directAiFiles: ReadonlySet<string>;
+}
+
+// Regex patterns for import/require statements
+const TS_IMPORT_REGEX = /(?:import\s+(?:(?:\{[^}]*\}|[\w*]+)\s+from\s+)?['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+const PYTHON_IMPORT_REGEX = /(?:^import\s+([\w.]+)|^from\s+([\w.]+)\s+import)/gm;
+
+/**
+ * Extract import specifiers from a source file.
+ * Returns raw import strings (not resolved).
+ */
+export const extractImports = (content: string, extension: string): readonly string[] => {
+  const imports: string[] = [];
+
+  if (AST_SUPPORTED_EXTENSIONS.has(extension)) {
+    let match: RegExpExecArray | null;
+    const regex = new RegExp(TS_IMPORT_REGEX.source, 'g');
+    while ((match = regex.exec(content)) !== null) {
+      const spec = match[1] ?? match[2];
+      if (spec) imports.push(spec);
+    }
+  } else if (extension === '.py') {
+    let match: RegExpExecArray | null;
+    const regex = new RegExp(PYTHON_IMPORT_REGEX.source, 'gm');
+    while ((match = regex.exec(content)) !== null) {
+      const spec = match[1] ?? match[2];
+      if (spec) imports.push(spec);
+    }
+  }
+
+  return imports;
+};
+
+/**
+ * Check if an import specifier refers to a known AI SDK package.
+ */
+export const isAiPackageImport = (spec: string): boolean => {
+  // Direct match
+  if (AI_PACKAGES.has(spec)) return true;
+  // Scoped package prefix match (e.g. '@ai-sdk/openai/something')
+  const parts = spec.startsWith('@') ? spec.split('/').slice(0, 2).join('/') : spec.split('/')[0] ?? '';
+  if (AI_PACKAGES.has(parts)) return true;
+  // Python dotted import (e.g. 'openai.chat')
+  const pyRoot = spec.split('.')[0] ?? '';
+  if (AI_PACKAGES.has(pyRoot)) return true;
+  return false;
+};
+
+/**
+ * Resolve a relative import to a file path within the project.
+ * Returns undefined for external packages.
+ */
+const resolveImport = (
+  spec: string,
+  importerPath: string,
+  fileSet: ReadonlySet<string>,
+): string | undefined => {
+  // External packages (not relative)
+  if (!spec.startsWith('.') && !spec.startsWith('/')) return undefined;
+
+  // Resolve relative to importer's directory
+  const importerDir = importerPath.split('/').slice(0, -1).join('/');
+  const parts = spec.split('/');
+  const resolved: string[] = importerDir ? importerDir.split('/') : [];
+
+  for (const part of parts) {
+    if (part === '.') continue;
+    if (part === '..') { resolved.pop(); continue; }
+    resolved.push(part);
+  }
+
+  let resolvedPath = resolved.join('/');
+  // Strip .js/.ts extension from import and try variations
+  resolvedPath = resolvedPath.replace(/\.(js|ts|jsx|tsx|mjs|cjs)$/, '');
+
+  const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs'];
+  for (const ext of extensions) {
+    if (fileSet.has(resolvedPath + ext)) return resolvedPath + ext;
+  }
+  // Try index file
+  for (const ext of extensions) {
+    if (fileSet.has(resolvedPath + '/index' + ext)) return resolvedPath + '/index' + ext;
+  }
+
+  return undefined;
+};
+
+/**
+ * Build an import graph from project files.
+ * Identifies AI-relevant files through transitive import analysis.
+ */
+export const buildImportGraph = (files: readonly FileInfo[]): ImportGraph => {
+  const fileSet = new Set(files.map((f) => f.relativePath));
+  const nodes = new Map<string, ImportGraphNode>();
+
+  // Phase 1: Extract imports and detect direct AI SDK imports
+  const directAiFiles = new Set<string>();
+  const importMap = new Map<string, string[]>(); // file -> resolved local imports
+
+  for (const file of files) {
+    const rawImports = extractImports(file.content, file.extension);
+    const resolvedLocal: string[] = [];
+    let hasDirectAi = false;
+
+    for (const spec of rawImports) {
+      if (isAiPackageImport(spec)) {
+        hasDirectAi = true;
+      }
+      const resolved = resolveImport(spec, file.relativePath, fileSet);
+      if (resolved) {
+        resolvedLocal.push(resolved);
+      }
+    }
+
+    importMap.set(file.relativePath, resolvedLocal);
+    if (hasDirectAi) {
+      directAiFiles.add(file.relativePath);
+    }
+  }
+
+  // Phase 2: Propagate AI-relevance transitively (BFS from direct AI files)
+  const aiRelevantFiles = new Set<string>(directAiFiles);
+  const depthMap = new Map<string, number>();
+
+  for (const f of directAiFiles) {
+    depthMap.set(f, 0);
+  }
+
+  // Build reverse dependency graph (who imports this file?)
+  const reverseImports = new Map<string, string[]>();
+  for (const [file, imports] of importMap) {
+    for (const imp of imports) {
+      const existing = reverseImports.get(imp) ?? [];
+      existing.push(file);
+      reverseImports.set(imp, existing);
+    }
+  }
+
+  // BFS from direct AI files through reverse imports
+  const queue = [...directAiFiles];
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const currentDepth = depthMap.get(current) ?? 0;
+
+    // Also check forward imports: if this file imports an AI file
+    const forwardImports = importMap.get(current) ?? [];
+    for (const imp of forwardImports) {
+      if (aiRelevantFiles.has(imp) && !depthMap.has(current)) {
+        aiRelevantFiles.add(current);
+        depthMap.set(current, (depthMap.get(imp) ?? 0) + 1);
+      }
+    }
+
+    // Propagate to files that import this AI-relevant file
+    const importers = reverseImports.get(current) ?? [];
+    for (const importer of importers) {
+      if (!aiRelevantFiles.has(importer)) {
+        aiRelevantFiles.add(importer);
+        depthMap.set(importer, currentDepth + 1);
+        queue.push(importer);
+      }
+    }
+  }
+
+  // Phase 3: Build final nodes
+  for (const file of files) {
+    const imports = importMap.get(file.relativePath) ?? [];
+    const isRelevant = aiRelevantFiles.has(file.relativePath);
+    const depth = depthMap.get(file.relativePath) ?? -1;
+
+    nodes.set(file.relativePath, {
+      file: file.relativePath,
+      imports,
+      isAiRelevant: isRelevant,
+      aiRelevanceDepth: isRelevant ? depth : -1,
+    });
+  }
+
+  return Object.freeze({
+    nodes,
+    aiRelevantFiles: Object.freeze(aiRelevantFiles),
+    directAiFiles: Object.freeze(directAiFiles),
+  });
+};

package/src/domain/scanner/languages/adapter.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect } from 'vitest';
+import { LANGUAGE_ADAPTERS, getAdapterForExtension, detectProjectLanguages } from './adapter.js';
+
+describe('LanguageAdapters', () => {
+  it('has Go, Rust, and Java adapters', () => {
+    expect(LANGUAGE_ADAPTERS.length).toBe(3);
+    expect(LANGUAGE_ADAPTERS.map((a) => a.id)).toEqual(['go', 'rust', 'java']);
+  });
+
+  it('getAdapterForExtension returns correct adapter', () => {
+    expect(getAdapterForExtension('.go')?.id).toBe('go');
+    expect(getAdapterForExtension('.rs')?.id).toBe('rust');
+    expect(getAdapterForExtension('.java')?.id).toBe('java');
+    expect(getAdapterForExtension('.ts')).toBeUndefined();
+  });
+
+  describe('Go adapter', () => {
+    const go = LANGUAGE_ADAPTERS.find((a) => a.id === 'go')!;
+
+    it('parses go.mod require block', () => {
+      const gomod = `module example.com/myapp\n\ngo 1.21\n\nrequire (\n\tgithub.com/sashabaranov/go-openai v1.20.0\n\tgithub.com/gin-gonic/gin v1.9.1\n)`;
+      const deps = go.detectDeps(gomod);
+      expect(deps.length).toBe(2);
+      expect(deps.find((d) => d.name.includes('go-openai'))?.isAiSdk).toBe(true);
+      expect(deps.find((d) => d.name.includes('gin'))?.isAiSdk).toBe(false);
+    });
+
+    it('extracts Go imports', () => {
+      const code = `import (\n\t"fmt"\n\t"github.com/sashabaranov/go-openai"\n)`;
+      const imports = go.extractImports(code);
+      expect(imports).toContain('fmt');
+      expect(imports).toContain('github.com/sashabaranov/go-openai');
+    });
+  });
+
+  describe('Rust adapter', () => {
+    const rust = LANGUAGE_ADAPTERS.find((a) => a.id === 'rust')!;
+
+    it('parses Cargo.toml dependencies', () => {
+      const toml = `[dependencies]\nasync-openai = "0.18"\ntokio = { version = "1.0", features = ["full"] }`;
+      const deps = rust.detectDeps(toml);
+      expect(deps.length).toBe(2);
+      expect(deps.find((d) => d.name === 'async-openai')?.isAiSdk).toBe(true);
+      expect(deps.find((d) => d.name === 'tokio')?.isAiSdk).toBe(false);
+    });
+
+    it('extracts Rust use statements', () => {
+      const code = `use async_openai::Client;\nuse tokio::runtime::Runtime;`;
+      const imports = rust.extractImports(code);
+      expect(imports).toContain('async_openai::Client');
+      expect(imports).toContain('tokio::runtime::Runtime');
+    });
+  });
+
+  describe('Java adapter', () => {
+    const java = LANGUAGE_ADAPTERS.find((a) => a.id === 'java')!;
+
+    it('parses Maven pom.xml dependencies', () => {
+      const pom = `<dependency>\n  <groupId>dev.langchain4j</groupId>\n  <artifactId>langchain4j</artifactId>\n  <version>0.24.0</version>\n</dependency>`;
+      const deps = java.detectDeps(pom);
+      expect(deps.length).toBe(1);
+      expect(deps[0]?.isAiSdk).toBe(true);
+    });
+
+    it('parses Gradle dependencies', () => {
+      const gradle = `implementation 'dev.langchain4j:langchain4j:0.24.0'\nimplementation 'org.springframework:spring-core:6.0'`;
+      const deps = java.detectDeps(gradle);
+      expect(deps.length).toBe(2);
+      expect(deps.find((d) => d.name.includes('langchain4j'))?.isAiSdk).toBe(true);
+    });
+
+    it('extracts Java imports', () => {
+      const code = `import dev.langchain4j.model.openai.OpenAiChatModel;\nimport java.util.List;`;
+      const imports = java.extractImports(code);
+      expect(imports).toContain('dev.langchain4j.model.openai.OpenAiChatModel');
+      expect(imports).toContain('java.util.List');
+    });
+  });
+
+  describe('detectProjectLanguages', () => {
+    it('detects Go by .go extension', () => {
+      const files = [{ relativePath: 'main.go' }, { relativePath: 'src/utils.ts' }];
+      const adapters = detectProjectLanguages(files);
+      expect(adapters.map((a) => a.id)).toContain('go');
+    });
+
+    it('detects Rust by Cargo.toml', () => {
+      const files = [{ relativePath: 'Cargo.toml' }, { relativePath: 'src/main.rs' }];
+      const adapters = detectProjectLanguages(files);
+      expect(adapters.map((a) => a.id)).toContain('rust');
+    });
+
+    it('detects Java by pom.xml', () => {
+      const files = [{ relativePath: 'pom.xml' }];
+      const adapters = detectProjectLanguages(files);
+      expect(adapters.map((a) => a.id)).toContain('java');
+    });
+
+    it('returns empty for TS-only projects', () => {
+      const files = [{ relativePath: 'src/app.ts' }, { relativePath: 'package.json' }];
+      const adapters = detectProjectLanguages(files);
+      expect(adapters.length).toBe(0);
+    });
+  });
+});

package/src/domain/scanner/languages/adapter.ts

@@ -0,0 +1,239 @@
+/**
+ * LanguageAdapter interface for multi-language scanner support.
+ * Each adapter provides language-specific dependency detection, import parsing, and patterns.
+ */
+
+export interface DepInfo {
+  readonly name: string;
+  readonly version: string;
+  readonly isAiSdk: boolean;
+  readonly isBanned: boolean;
+  readonly bannedReason?: string;
+}
+
+export interface LanguageAdapter {
+  readonly id: string;
+  readonly name: string;
+  readonly extensions: readonly string[];
+  readonly depFiles: readonly string[];
+
+  /** Parse dependency file and return detected deps */
+  readonly detectDeps: (content: string) => readonly DepInfo[];
+
+  /** Extract import statements from a source file */
+  readonly extractImports: (content: string) => readonly string[];
+
+  /** Get AI SDK package names for this language */
+  readonly aiPackages: ReadonlySet<string>;
+}
+
+import {
+  GO_AI_PACKAGES,
+  RUST_AI_PACKAGES,
+  JAVA_AI_PACKAGES,
+} from '../data/ai-packages.js';
+
+// --- Go Adapter ---
+
+const GO_IMPORT_REGEX = /import\s+(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/g;
+const GO_SINGLE_IMPORT = /"([^"]+)"/g;
+
+const goAdapter: LanguageAdapter = Object.freeze({
+  id: 'go',
+  name: 'Go',
+  extensions: ['.go'],
+  depFiles: ['go.mod', 'go.sum'],
+
+  detectDeps: (content: string): readonly DepInfo[] => {
+    const deps: DepInfo[] = [];
+    // Parse go.mod require block
+    const requireMatch = content.match(/require\s*\(([\s\S]*?)\)/);
+    if (requireMatch) {
+      const lines = requireMatch[1].split('\n').filter((l) => l.trim().length > 0);
+      for (const line of lines) {
+        const match = line.trim().match(/^(\S+)\s+(\S+)/);
+        if (match) {
+          const [, name = '', version = ''] = match;
+          deps.push({
+            name,
+            version: version.replace(/^v/, ''),
+            isAiSdk: GO_AI_PACKAGES.has(name),
+            isBanned: false,
+          });
+        }
+      }
+    }
+    // Single-line require (not followed by opening paren — those are block requires)
+    const singleReqs = content.matchAll(/require\s+(?!\()(\S+)\s+(\S+)/g);
+    for (const m of singleReqs) {
+      const name = m[1] ?? '';
+      deps.push({
+        name,
+        version: (m[2] ?? '').replace(/^v/, ''),
+        isAiSdk: GO_AI_PACKAGES.has(name),
+        isBanned: false,
+      });
+    }
+    return deps;
+  },
+
+  extractImports: (content: string): readonly string[] => {
+    const imports: string[] = [];
+    let match: RegExpExecArray | null;
+    const regex = new RegExp(GO_IMPORT_REGEX.source, 'g');
+    while ((match = regex.exec(content)) !== null) {
+      if (match[1]) {
+        // Multi-line import block
+        const innerRegex = new RegExp(GO_SINGLE_IMPORT.source, 'g');
+        let inner: RegExpExecArray | null;
+        while ((inner = innerRegex.exec(match[1])) !== null) {
+          if (inner[1]) imports.push(inner[1]);
+        }
+      } else if (match[2]) {
+        imports.push(match[2]);
+      }
+    }
+    return imports;
+  },
+
+  aiPackages: GO_AI_PACKAGES,
+});
+
+// --- Rust Adapter ---
+
+const RUST_USE_REGEX = /use\s+([\w:]+(?:::\{[^}]+\})?)/g;
+
+const rustAdapter: LanguageAdapter = Object.freeze({
+  id: 'rust',
+  name: 'Rust',
+  extensions: ['.rs'],
+  depFiles: ['Cargo.toml', 'Cargo.lock'],
+
+  detectDeps: (content: string): readonly DepInfo[] => {
+    const deps: DepInfo[] = [];
+    // Parse [dependencies] section in Cargo.toml
+    const depSection = content.match(/\[dependencies\]([\s\S]*?)(?:\[|$)/);
+    if (depSection) {
+      const lines = depSection[1].split('\n');
+      for (const line of lines) {
+        const match = line.match(/^(\S+)\s*=\s*(?:"([^"]+)"|{[^}]*version\s*=\s*"([^"]+)")/);
+        if (match) {
+          const name = match[1] ?? '';
+          const version = match[2] ?? match[3] ?? '';
+          deps.push({
+            name,
+            version,
+            isAiSdk: RUST_AI_PACKAGES.has(name),
+            isBanned: false,
+          });
+        }
+      }
+    }
+    return deps;
+  },
+
+  extractImports: (content: string): readonly string[] => {
+    const imports: string[] = [];
+    const regex = new RegExp(RUST_USE_REGEX.source, 'g');
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(content)) !== null) {
+      if (match[1]) imports.push(match[1]);
+    }
+    return imports;
+  },
+
+  aiPackages: RUST_AI_PACKAGES,
+});
+
+// --- Java Adapter ---
+
+const JAVA_IMPORT_REGEX = /import\s+([\w.]+(?:\.\*)?)\s*;/g;
+
+const javaAdapter: LanguageAdapter = Object.freeze({
+  id: 'java',
+  name: 'Java',
+  extensions: ['.java'],
+  depFiles: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+
+  detectDeps: (content: string): readonly DepInfo[] => {
+    const deps: DepInfo[] = [];
+    // Parse Maven pom.xml <dependency> blocks
+    const depRegex = /<dependency>\s*<groupId>([^<]+)<\/groupId>\s*<artifactId>([^<]+)<\/artifactId>(?:\s*<version>([^<]+)<\/version>)?/g;
+    let match: RegExpExecArray | null;
+    while ((match = depRegex.exec(content)) !== null) {
+      const groupId = match[1] ?? '';
+      const artifactId = match[2] ?? '';
+      const version = match[3] ?? '';
+      const name = `${groupId}:${artifactId}`;
+      deps.push({
+        name,
+        version,
+        isAiSdk: JAVA_AI_PACKAGES.has(groupId),
+        isBanned: false,
+      });
+    }
+    // Parse Gradle dependencies
+    const gradleRegex = /(?:implementation|api|compile)\s+['"]([^'"]+)['"]/g;
+    while ((match = gradleRegex.exec(content)) !== null) {
+      const coord = match[1] ?? '';
+      const parts = coord.split(':');
+      const groupId = parts[0] ?? '';
+      deps.push({
+        name: coord,
+        version: parts[2] ?? '',
+        isAiSdk: JAVA_AI_PACKAGES.has(groupId),
+        isBanned: false,
+      });
+    }
+    return deps;
+  },
+
+  extractImports: (content: string): readonly string[] => {
+    const imports: string[] = [];
+    const regex = new RegExp(JAVA_IMPORT_REGEX.source, 'g');
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(content)) !== null) {
+      if (match[1]) imports.push(match[1]);
+    }
+    return imports;
+  },
+
+  aiPackages: JAVA_AI_PACKAGES,
+});
+
+// --- Registry ---
+
+export const LANGUAGE_ADAPTERS: readonly LanguageAdapter[] = Object.freeze([goAdapter, rustAdapter, javaAdapter]);
+
+export const getAdapterForExtension = (ext: string): LanguageAdapter | undefined =>
+  LANGUAGE_ADAPTERS.find((a) => a.extensions.includes(ext));
+
+export const getAdapterById = (id: string): LanguageAdapter | undefined =>
+  LANGUAGE_ADAPTERS.find((a) => a.id === id);
+
+export const detectProjectLanguages = (
+  files: readonly { relativePath: string }[],
+): readonly LanguageAdapter[] => {
+  const found = new Set<string>();
+  const adapters: LanguageAdapter[] = [];
+
+  for (const file of files) {
+    const ext = '.' + (file.relativePath.split('.').pop() ?? '');
+    for (const adapter of LANGUAGE_ADAPTERS) {
+      if (!found.has(adapter.id) && adapter.extensions.includes(ext)) {
+        found.add(adapter.id);
+        adapters.push(adapter);
+      }
+    }
+    // Also check for dep files
+    const filename = file.relativePath.split('/').pop() ?? '';
+    for (const adapter of LANGUAGE_ADAPTERS) {
+      if (!found.has(adapter.id) && adapter.depFiles.includes(filename)) {
+        found.add(adapter.id);
+        adapters.push(adapter);
+      }
+    }
+  }
+
+  return adapters;
+};

package/src/domain/scanner/layers/index.ts

@@ -0,0 +1,24 @@
+export { L1_CHECKS } from './layer1-files.js';
+export { loadValidators, validateDocument, runLayer2, layer2ToCheckResults } from './layer2-docs.js';
+export { measureSectionDepth, measureSemanticDepth } from './layer2-parsing.js';
+export { AI_REVIEW_MARKER_REGEX, hasAiReviewMarker, extractReviewDate } from './layer2-parsing.js';
+export { parseMarkdownHeadings, normalize, headingMatches, extractSectionContents } from './layer2-parsing.js';
+export type { ValidatorSection, DocumentValidator, L2CheckResult } from './layer2-docs.js';
+export type { L2Status } from './layer2-docs.js';
+export type { SectionDepth, SemanticDepth } from './layer2-parsing.js';
+export { runLayer3, layer3ToCheckResults } from './layer3-config.js';
+export type { L3FindingType, L3CheckResult } from './layer3-config.js';
+export { parsePackageJson, parseRequirementsTxt, parseCargoToml, parseGoMod } from './layer3-parsers.js';
+export type { ParsedDependency } from './layer3-parsers.js';
+export { runLayer4, layer4ToCheckResults } from './layer4-patterns.js';
+export type { L4CheckResult } from './layer4-patterns.js';
+export { DOCUMENT_CHECKLISTS, buildDocValidationPrompt, docValidationToFindings } from './layer5-docs.js';
+export { parseDocValidationResponse, getChecklist, detectDocType } from './layer5-docs.js';
+export type { DocumentChecklist, ChecklistElement, DocValidationResult } from './layer5-docs.js';
+export { selectPromptType, buildL5Prompt, extractSnippets, createLayer5 } from './layer5-llm.js';
+export type { PromptType, CodeSnippet, L5Result, L5AnalyzerDeps, Layer5Analyzer } from './layer5-llm.js';
+export { selectUncertainFindings, buildTargetedPrompts, applyTargetedResults, estimateTargetedCost } from './layer5-targeted.js';
+export type { TargetedL5Config, TargetedL5Prompt, TargetedL5Result } from './layer5-targeted.js';
+export { parsePackageLockJson, parseYarnLock, parsePnpmLockYaml } from './lockfile-parsers.js';
+export { parseCargoLock, parseGoSum, parsePipfileLock, parseLockfiles } from './lockfile-parsers.js';
+export type { LockfileDependency } from './lockfile-parsers.js';

package/src/domain/scanner/layers/layer1-files.ts

@@ -0,0 +1,54 @@
+import type { CheckFunction } from '../../../ports/scanner.port.js';
+import { checkAiDisclosure } from '../checks/ai-disclosure.js';
+import { checkContentMarking } from '../checks/content-marking.js';
+import { checkInteractionLogging } from '../checks/interaction-logging.js';
+import { checkAiLiteracy } from '../checks/ai-literacy.js';
+import { checkGpaiTransparency } from '../checks/gpai-transparency.js';
+import { checkGpaiSystemicRisk } from '../checks/gpai-systemic-risk.js';
+import { checkComplianceMetadata } from '../checks/compliance-metadata.js';
+import { checkDocumentation } from '../checks/documentation.js';
+import { checkPassportPresence } from '../checks/passport-presence.js';
+import { checkPassportCompleteness } from '../checks/passport-completeness.js';
+import { checkPermissions } from '../checks/permission-scanner.js';
+import { checkBehavioralConstraints } from '../checks/behavioral-constraints.js';
+import { checkIndustryPatterns } from '../checks/industry/index.js';
+import {
+  checkFriaPresence,
+  checkArt5ScreeningPresence,
+  checkTechnicalDocumentationPresence,
+  checkIncidentReportPresence,
+  checkDeclarationOfConformityPresence,
+  checkMonitoringPolicyPresence,
+  checkWorkerNotificationPresence,
+  checkRiskManagementPresence,
+  checkDataGovernancePresence,
+  checkQmsPresence,
+  checkInstructionsForUsePresence,
+} from '../checks/presence-check-factory.js';
+
+export const L1_CHECKS: readonly CheckFunction[] = [
+  checkAiDisclosure,
+  checkContentMarking,
+  checkInteractionLogging,
+  checkAiLiteracy,
+  checkGpaiTransparency,
+  checkGpaiSystemicRisk,
+  checkComplianceMetadata,
+  checkDocumentation,
+  checkPassportPresence,
+  checkPassportCompleteness,
+  checkPermissions,
+  checkBehavioralConstraints,
+  checkIndustryPatterns,
+  checkFriaPresence,
+  checkArt5ScreeningPresence,
+  checkTechnicalDocumentationPresence,
+  checkIncidentReportPresence,
+  checkDeclarationOfConformityPresence,
+  checkMonitoringPolicyPresence,
+  checkWorkerNotificationPresence,
+  checkRiskManagementPresence,
+  checkDataGovernancePresence,
+  checkQmsPresence,
+  checkInstructionsForUsePresence,
+];