@complior/engine 0.9.0

package/src/domain/fixer/template-engine.ts

@@ -0,0 +1,38 @@
+import { getTemplateMap } from './strategies/index.js';
+import type { TemplateMapping } from './types.js';
+
+export interface TemplateData {
+  readonly companyName: string;
+  readonly organization?: string;
+  readonly aiSystems?: readonly string[];
+  readonly riskLevel?: string;
+  readonly date?: string;
+  readonly version?: string;
+}
+
+const DEFAULT_DATA: TemplateData = {
+  companyName: '[Company Name]',
+  date: new Date().toISOString().slice(0, 10),
+  version: '1.0',
+};
+
+export const fillTemplate = (templateContent: string, data?: Partial<TemplateData>): string => {
+  const d = { ...DEFAULT_DATA, ...data };
+  let filled = templateContent;
+
+  filled = filled.replace(/\[Company Name\]/g, d.companyName);
+  filled = filled.replace(/\[Firmenname\]/g, d.companyName);
+  filled = filled.replace(/\[Date\]/g, d.date ?? '[TO BE SET]');
+  filled = filled.replace(/\[X\.Y\]/g, d.version ?? '1.0');
+  filled = filled.replace(/\[YYYY\]/g, new Date().getFullYear().toString());
+
+  return filled;
+};
+
+export const getTemplateForObligation = (obligationId: string): TemplateMapping | undefined => {
+  return getTemplateMap().find((m) => m.obligationId === obligationId);
+};
+
+export const getAvailableTemplates = (): readonly TemplateMapping[] => {
+  return getTemplateMap();
+};

package/src/domain/fixer/types.ts

@@ -0,0 +1,88 @@
+import type { CheckResultType, Finding } from '../../types/common.types.js';
+
+export type FixType = 'code_injection' | 'template_generation' | 'config_fix' | 'metadata_generation' | 'dependency_fix' | 'ai_enrichment';
+
+export interface FixAction {
+  readonly type: 'create' | 'edit' | 'splice';
+  readonly path: string;
+  readonly content?: string;           // create
+  readonly oldContent?: string;        // edit
+  readonly newContent?: string;        // edit
+  readonly beforeLines?: readonly string[];  // splice: expected lines
+  readonly afterLines?: readonly string[];   // splice: replacement lines
+  readonly startLine?: number;               // splice: 1-based line
+  readonly importLine?: string;              // splice: import to inject
+  readonly description: string;
+}
+
+export interface FixPlan {
+  readonly obligationId: string;
+  readonly checkId: string;
+  readonly article: string;
+  readonly fixType: FixType;
+  readonly framework: string;
+  readonly actions: readonly FixAction[];
+  readonly diff: string;
+  readonly scoreImpact: number;
+  readonly commitMessage: string;
+  readonly description: string;
+  readonly manualFields?: readonly string[];
+}
+
+export interface FixResult {
+  readonly plan: FixPlan;
+  readonly applied: boolean;
+  readonly scoreBefore: number;
+  readonly scoreAfter: number;
+  readonly backedUpFiles: readonly string[];
+  readonly error?: string;
+}
+
+export interface FixContext {
+  readonly projectPath: string;
+  readonly framework: string;
+  readonly existingFiles: readonly string[];
+  readonly useAi?: boolean;
+}
+
+export interface FixValidation {
+  readonly checkId: string;
+  readonly obligationId: string;
+  readonly article: string;
+  readonly before: CheckResultType;
+  readonly after: CheckResultType;
+  readonly scoreDelta: number;
+  readonly totalScore: number;
+}
+
+export interface FixHistoryFile {
+  readonly path: string;
+  readonly action: 'create' | 'edit' | 'splice';
+  readonly backupPath: string;
+}
+
+export interface FixHistoryEntry {
+  readonly id: number;
+  readonly checkId: string;
+  readonly obligationId: string;
+  readonly fixType: FixType;
+  readonly status: 'applied' | 'undone';
+  readonly timestamp: string;
+  readonly files: readonly FixHistoryFile[];
+  readonly scoreBefore: number;
+  readonly scoreAfter: number;
+}
+
+export interface FixHistory {
+  readonly fixes: readonly FixHistoryEntry[];
+}
+
+export type FixStrategy = (finding: Finding, context: FixContext) => FixPlan | null;
+
+export interface TemplateMapping {
+  readonly obligationId: string;
+  readonly article: string;
+  readonly templateFile: string;
+  readonly outputFile: string;
+  readonly description: string;
+}

package/src/domain/frameworks/aiuc1-framework.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect } from 'vitest';
+import { createAiuc1Framework, scoreAiuc1 } from './aiuc1-framework.js';
+import type { FoundationMetrics } from '../../types/framework.types.js';
+import type { AgentPassport } from '../../types/passport.types.js';
+import type { ScanResult } from '../../types/common.types.js';
+
+const emptyMetrics: FoundationMetrics = {
+  scanResult: null,
+  passport: null,
+  passportCompleteness: 0,
+  evidenceChainValid: false,
+  evidenceEntryCount: 0,
+  evidenceScanCount: 0,
+  documents: new Set(),
+};
+
+const minimalPassport: AgentPassport = {
+  agent_id: 'test-001',
+  name: 'test-agent',
+  version: '1.0.0',
+  type: 'coding',
+  description: 'A test agent',
+  autonomy_level: 'L3',
+  autonomy_evidence: 'test evidence',
+  framework: 'custom',
+  capabilities: ['code generation'],
+  limitations: ['cannot deploy'],
+  permissions: {
+    tools: ['read', 'write'],
+    denied: [],
+    data_boundaries: ['internal only'],
+    human_approval_required: [],
+  },
+  constraints: {
+    rate_limits: {},
+    budget: { max_cost_per_request: 1 },
+    prohibited_actions: [],
+  },
+  compliance: {
+    eu_ai_act: {
+      risk_class: 'high',
+      applicable_articles: ['Art.6', 'Art.9'],
+      deployer_obligations_met: [],
+      deployer_obligations_pending: [],
+    },
+    complior_score: 50,
+    last_scan: new Date().toISOString(),
+    fria_completed: false,
+  },
+  source: {
+    detected_from: 'manual',
+    config_files: [],
+    created_at: new Date().toISOString(),
+  },
+  signature: undefined,
+} as unknown as AgentPassport;
+
+describe('AIUC-1 Framework', () => {
+  it('creates framework with id aiuc-1', () => {
+    const fw = createAiuc1Framework();
+    expect(fw.id).toBe('aiuc-1');
+    expect(fw.name).toBe('AIUC-1 Readiness');
+    expect(fw.gradeMapping.type).toBe('level');
+  });
+
+  it('has 7 categories matching AIUC1_CATEGORIES', () => {
+    const fw = createAiuc1Framework();
+    expect(fw.categories).toHaveLength(7);
+    const ids = fw.categories.map((c) => c.id);
+    expect(ids).toContain('documentation');
+    expect(ids).toContain('risk_management');
+    expect(ids).toContain('transparency');
+  });
+
+  it('has checks derived from AIUC1_REQUIREMENTS', () => {
+    const fw = createAiuc1Framework();
+    expect(fw.checks.length).toBeGreaterThan(10);
+  });
+
+  it('returns Level 1 with no passport', () => {
+    const fw = createAiuc1Framework();
+    const result = scoreAiuc1(fw, emptyMetrics);
+    expect(result.score).toBe(0);
+    expect(result.grade).toBe('Level 1');
+    expect(result.gradeType).toBe('level');
+  });
+
+  it('computes readiness with passport', () => {
+    const fw = createAiuc1Framework();
+    const metrics: FoundationMetrics = {
+      ...emptyMetrics,
+      passport: minimalPassport,
+      passportCompleteness: 60,
+    };
+    const result = scoreAiuc1(fw, metrics);
+    expect(result.score).toBeGreaterThan(0);
+    expect(result.frameworkId).toBe('aiuc-1');
+  });
+
+  it('returns higher score with scan result and documents', () => {
+    const fw = createAiuc1Framework();
+    const scanResult: ScanResult = {
+      score: {
+        totalScore: 70,
+        zone: 'yellow',
+        categoryScores: [],
+        criticalCapApplied: false,
+        totalChecks: 20,
+        passedChecks: 14,
+        failedChecks: 6,
+        skippedChecks: 0,
+      },
+      findings: [
+        { checkId: 'l1-architecture', type: 'pass', message: 'ok', severity: 'low' },
+        { checkId: 'sdk-disclosure', type: 'pass', message: 'ok', severity: 'low' },
+      ],
+      projectPath: '/test',
+      scannedAt: new Date().toISOString(),
+      duration: 100,
+      filesScanned: 10,
+    };
+
+    const baseMetrics: FoundationMetrics = {
+      ...emptyMetrics,
+      passport: minimalPassport,
+    };
+    const baseResult = scoreAiuc1(fw, baseMetrics);
+
+    const richMetrics: FoundationMetrics = {
+      ...emptyMetrics,
+      passport: minimalPassport,
+      scanResult,
+      documents: new Set(['fria']),
+      evidenceEntryCount: 5,
+      evidenceScanCount: 3,
+      evidenceChainValid: true,
+    };
+    const richResult = scoreAiuc1(fw, richMetrics);
+    expect(richResult.score).toBeGreaterThanOrEqual(baseResult.score);
+  });
+
+  it('returns categories in result', () => {
+    const fw = createAiuc1Framework();
+    const metrics: FoundationMetrics = {
+      ...emptyMetrics,
+      passport: minimalPassport,
+    };
+    const result = scoreAiuc1(fw, metrics);
+    expect(result.categories.length).toBeGreaterThan(0);
+    expect(result.categories[0]).toHaveProperty('categoryId');
+    expect(result.categories[0]).toHaveProperty('score');
+  });
+
+  it('maps to correct grade levels', () => {
+    const fw = createAiuc1Framework();
+    // Level 1 for no passport
+    expect(scoreAiuc1(fw, emptyMetrics).grade).toBe('Level 1');
+  });
+});

package/src/domain/frameworks/aiuc1-framework.ts

@@ -0,0 +1,126 @@
+/**
+ * AIUC-1 Framework Adapter — wraps existing computeReadiness results.
+ * Calls computeReadiness(input) and maps ReadinessResult → FrameworkScoreResult.
+ */
+
+import type {
+  ComplianceFramework,
+  FoundationMetrics,
+  FrameworkCategory,
+  FrameworkCategoryScore,
+  FrameworkCheck,
+  FrameworkScoreResult,
+} from '../../types/framework.types.js';
+import { AIUC1_REQUIREMENTS, AIUC1_CATEGORIES } from '../certification/aiuc1-requirements.js';
+import type { Aiuc1Category } from '../certification/aiuc1-requirements.js';
+import { computeReadiness } from '../certification/aiuc1-readiness.js';
+
+const LEVEL_THRESHOLDS = [
+  { minScore: 90, grade: 'Level 4' },
+  { minScore: 70, grade: 'Level 3' },
+  { minScore: 40, grade: 'Level 2' },
+  { minScore: 0, grade: 'Level 1' },
+] as const;
+
+export const createAiuc1Framework = (): ComplianceFramework => {
+  const categories: FrameworkCategory[] = (
+    Object.entries(AIUC1_CATEGORIES) as [Aiuc1Category, { label: string; weight: number }][]
+  ).map(([id, info]) => ({
+    id,
+    name: info.label,
+    weight: info.weight,
+  }));
+
+  const checks: FrameworkCheck[] = AIUC1_REQUIREMENTS.flatMap((req) =>
+    req.checks.map((check, idx) => ({
+      id: `${req.id}-${idx}`,
+      name: check.description,
+      source: check.type,
+      target: check.target,
+      categoryId: req.category,
+      weight: req.weight / req.checks.length,
+      description: check.description,
+    })),
+  );
+
+  return Object.freeze({
+    id: 'aiuc-1',
+    name: 'AIUC-1 Readiness',
+    version: '1.0',
+    checks,
+    categories,
+    gradeMapping: {
+      type: 'level',
+      thresholds: LEVEL_THRESHOLDS,
+    },
+  });
+};
+
+export const scoreAiuc1 = (
+  fw: ComplianceFramework,
+  metrics: FoundationMetrics,
+): FrameworkScoreResult => {
+  if (!metrics.passport) {
+    return Object.freeze({
+      frameworkId: fw.id,
+      frameworkName: fw.name,
+      score: 0,
+      grade: 'Level 1',
+      gradeType: 'level' as const,
+      gaps: fw.checks.length,
+      totalChecks: fw.checks.length,
+      passedChecks: 0,
+      categories: [],
+    });
+  }
+
+  const readiness = computeReadiness({
+    passport: metrics.passport,
+    scanResult: metrics.scanResult,
+    documents: metrics.documents,
+    evidenceSummary: {
+      totalEntries: metrics.evidenceEntryCount,
+      scanCount: metrics.evidenceScanCount,
+      firstEntry: '',
+      lastEntry: '',
+      chainValid: metrics.evidenceChainValid,
+      uniqueFindings: 0,
+    },
+  });
+
+  const grade =
+    LEVEL_THRESHOLDS.find((t) => readiness.overallScore >= t.minScore)?.grade ?? 'Level 1';
+
+  // Count passed/total from requirement statuses grouped by category
+  const catCounts = new Map<string, { passed: number; total: number }>();
+  for (const req of readiness.requirements) {
+    const entry = catCounts.get(req.category) ?? { passed: 0, total: 0 };
+    entry.total++;
+    if (req.status === 'met') entry.passed++;
+    catCounts.set(req.category, entry);
+  }
+
+  const categories: FrameworkCategoryScore[] = readiness.categories.map((cat) => {
+    const counts = catCounts.get(cat.category) ?? { passed: 0, total: 0 };
+    return {
+      categoryId: cat.category,
+      categoryName: cat.label,
+      score: cat.score,
+      weight: AIUC1_CATEGORIES[cat.category].weight,
+      passedChecks: counts.passed,
+      totalChecks: counts.total,
+    };
+  });
+
+  return Object.freeze({
+    frameworkId: fw.id,
+    frameworkName: fw.name,
+    score: readiness.overallScore,
+    grade,
+    gradeType: 'level' as const,
+    gaps: readiness.gaps.length,
+    totalChecks: readiness.totalRequirements,
+    passedChecks: readiness.metRequirements,
+    categories,
+  });
+};

package/src/domain/frameworks/collect-foundation-metrics.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import { collectFoundationMetrics } from './collect-foundation-metrics.js';
+import type { FoundationMetricsDeps } from './collect-foundation-metrics.js';
+import type { ScanResult } from '../../types/common.types.js';
+
+const mockScan: ScanResult = {
+  score: {
+    totalScore: 70,
+    zone: 'yellow',
+    categoryScores: [],
+    criticalCapApplied: false,
+    totalChecks: 20,
+    passedChecks: 14,
+    failedChecks: 6,
+    skippedChecks: 0,
+  },
+  findings: [],
+  projectPath: '/test',
+  scannedAt: new Date().toISOString(),
+  duration: 100,
+  filesScanned: 10,
+};
+
+const defaultDeps: FoundationMetricsDeps = {
+  getLastScanResult: () => mockScan,
+  getPassport: async () => null,
+  getPassportCompleteness: async () => 42,
+  getEvidenceSummary: async () => ({
+    totalEntries: 5,
+    scanCount: 3,
+    firstEntry: '2026-01-01',
+    lastEntry: '2026-03-01',
+    chainValid: true,
+    uniqueFindings: 10,
+  }),
+  getDocuments: async () => new Set(['fria']),
+};
+
+describe('collectFoundationMetrics', () => {
+  it('collects all fields', async () => {
+    const result = await collectFoundationMetrics(defaultDeps);
+    expect(result.scanResult).toBe(mockScan);
+    expect(result.passport).toBeNull();
+    expect(result.passportCompleteness).toBe(42);
+    expect(result.evidenceChainValid).toBe(true);
+    expect(result.evidenceEntryCount).toBe(5);
+    expect(result.evidenceScanCount).toBe(3);
+    expect(result.documents.has('fria')).toBe(true);
+  });
+
+  it('handles null scan result', async () => {
+    const deps = { ...defaultDeps, getLastScanResult: () => null };
+    const result = await collectFoundationMetrics(deps);
+    expect(result.scanResult).toBeNull();
+  });
+
+  it('runs deps in parallel', async () => {
+    let callOrder: string[] = [];
+    const deps: FoundationMetricsDeps = {
+      getLastScanResult: () => { callOrder.push('scan'); return mockScan; },
+      getPassport: async () => { callOrder.push('passport'); return null; },
+      getPassportCompleteness: async () => { callOrder.push('completeness'); return 50; },
+      getEvidenceSummary: async () => {
+        callOrder.push('evidence');
+        return { totalEntries: 0, scanCount: 0, firstEntry: '', lastEntry: '', chainValid: false, uniqueFindings: 0 };
+      },
+      getDocuments: async () => { callOrder.push('documents'); return new Set<string>(); },
+    };
+    await collectFoundationMetrics(deps);
+    expect(callOrder).toContain('passport');
+    expect(callOrder).toContain('evidence');
+  });
+
+  it('propagates evidence summary fields correctly', async () => {
+    const deps = {
+      ...defaultDeps,
+      getEvidenceSummary: async () => ({
+        totalEntries: 0,
+        scanCount: 0,
+        firstEntry: '',
+        lastEntry: '',
+        chainValid: false,
+        uniqueFindings: 0,
+      }),
+    };
+    const result = await collectFoundationMetrics(deps);
+    expect(result.evidenceChainValid).toBe(false);
+    expect(result.evidenceEntryCount).toBe(0);
+    expect(result.evidenceScanCount).toBe(0);
+  });
+
+  it('returns frozen object', async () => {
+    const result = await collectFoundationMetrics(defaultDeps);
+    expect(Object.isFrozen(result)).toBe(true);
+  });
+});

package/src/domain/frameworks/collect-foundation-metrics.ts

@@ -0,0 +1,34 @@
+import type { ScanResult } from '../../types/common.types.js';
+import type { AgentPassport } from '../../types/passport.types.js';
+import type { EvidenceChainSummary } from '../scanner/evidence-store.js';
+import type { FoundationMetrics } from '../../types/framework.types.js';
+
+export interface FoundationMetricsDeps {
+  readonly getLastScanResult: () => ScanResult | null;
+  readonly getPassport: () => Promise<AgentPassport | null>;
+  readonly getPassportCompleteness: () => Promise<number>;
+  readonly getEvidenceSummary: () => Promise<EvidenceChainSummary>;
+  readonly getDocuments: () => Promise<ReadonlySet<string>>;
+}
+
+export const collectFoundationMetrics = async (
+  deps: FoundationMetricsDeps,
+): Promise<FoundationMetrics> => {
+  const [passport, passportCompleteness, evidenceSummary, documents] =
+    await Promise.all([
+      deps.getPassport(),
+      deps.getPassportCompleteness(),
+      deps.getEvidenceSummary(),
+      deps.getDocuments(),
+    ]);
+
+  return Object.freeze({
+    scanResult: deps.getLastScanResult(),
+    passport,
+    passportCompleteness,
+    evidenceChainValid: evidenceSummary.chainValid,
+    evidenceEntryCount: evidenceSummary.totalEntries,
+    evidenceScanCount: evidenceSummary.scanCount,
+    documents,
+  });
+};

package/src/domain/frameworks/eu-ai-act-framework.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest';
+import { createEuAiActFramework, scoreEuAiAct } from './eu-ai-act-framework.js';
+import type { FoundationMetrics } from '../../types/framework.types.js';
+import type { ScanResult, ScoreBreakdown } from '../../types/common.types.js';
+
+const mockBreakdown = (score: number, categories: ScoreBreakdown['categoryScores'] = []): ScoreBreakdown => ({
+  totalScore: score,
+  zone: score >= 80 ? 'green' : score >= 50 ? 'yellow' : 'red',
+  categoryScores: categories,
+  criticalCapApplied: false,
+  totalChecks: 20,
+  passedChecks: Math.round(score / 5),
+  failedChecks: 20 - Math.round(score / 5),
+  skippedChecks: 0,
+});
+
+const mockScanResult = (score: number): ScanResult => ({
+  score: mockBreakdown(score),
+  findings: [],
+  projectPath: '/test',
+  scannedAt: new Date().toISOString(),
+  duration: 100,
+  filesScanned: 10,
+});
+
+const emptyMetrics: FoundationMetrics = {
+  scanResult: null,
+  passport: null,
+  passportCompleteness: 0,
+  evidenceChainValid: false,
+  evidenceEntryCount: 0,
+  evidenceScanCount: 0,
+  documents: new Set(),
+};
+
+describe('EU AI Act Framework', () => {
+  it('creates framework with id eu-ai-act', () => {
+    const fw = createEuAiActFramework(undefined);
+    expect(fw.id).toBe('eu-ai-act');
+    expect(fw.name).toBe('EU AI Act');
+    expect(fw.deadline).toBe('2026-08-02');
+    expect(fw.gradeMapping.type).toBe('letter');
+  });
+
+  it('creates framework with scoring data categories', () => {
+    const scoringData = {
+      regulation_id: 'eu-ai-act',
+      total_obligations: 10,
+      critical_obligations: 2,
+      critical_obligation_ids: ['obl-1'],
+      critical_obligations_note: '',
+      weighted_categories: [
+        { category: 'transparency', weight: 0.3, weight_reasoning: '', obligations_in_category: ['t1', 't2'] },
+        { category: 'documentation', weight: 0.7, weight_reasoning: '', obligations_in_category: ['d1'] },
+      ],
+      score_formula: '',
+      score_interpretation: {},
+      thresholds: { red: { range: '', label: '' }, yellow: { range: '', label: '' }, green: { range: '', label: '' } },
+      minimum_for_certificate: 90,
+      certificate_additional_requirements: [],
+      domain_specific_categories: [],
+    };
+    const fw = createEuAiActFramework(scoringData);
+    expect(fw.categories).toHaveLength(2);
+    expect(fw.checks).toHaveLength(3); // t1, t2, d1
+  });
+
+  it('returns F grade with no scan result', () => {
+    const fw = createEuAiActFramework(undefined);
+    const result = scoreEuAiAct(fw, emptyMetrics);
+    expect(result.score).toBe(0);
+    expect(result.grade).toBe('F');
+    expect(result.gradeType).toBe('letter');
+  });
+
+  it('maps scan score to grade A', () => {
+    const fw = createEuAiActFramework(undefined);
+    const metrics = { ...emptyMetrics, scanResult: mockScanResult(95) };
+    const result = scoreEuAiAct(fw, metrics);
+    expect(result.score).toBe(95);
+    expect(result.grade).toBe('A');
+  });
+
+  it('maps scan score to grade B', () => {
+    const fw = createEuAiActFramework(undefined);
+    const metrics = { ...emptyMetrics, scanResult: mockScanResult(80) };
+    const result = scoreEuAiAct(fw, metrics);
+    expect(result.grade).toBe('B');
+  });
+
+  it('maps scan score to grade C', () => {
+    const fw = createEuAiActFramework(undefined);
+    const metrics = { ...emptyMetrics, scanResult: mockScanResult(65) };
+    const result = scoreEuAiAct(fw, metrics);
+    expect(result.grade).toBe('C');
+  });
+
+  it('maps scan score to grade D', () => {
+    const fw = createEuAiActFramework(undefined);
+    const metrics = { ...emptyMetrics, scanResult: mockScanResult(45) };
+    const result = scoreEuAiAct(fw, metrics);
+    expect(result.grade).toBe('D');
+  });
+
+  it('maps category scores from scan breakdown', () => {
+    const fw = createEuAiActFramework(undefined);
+    const scan = mockScanResult(80);
+    (scan.score as { categoryScores: ScoreBreakdown['categoryScores'] }).categoryScores = [
+      { category: 'transparency', weight: 0.3, score: 90, obligationCount: 5, passedCount: 4 },
+    ];
+    const metrics = { ...emptyMetrics, scanResult: scan };
+    const result = scoreEuAiAct(fw, metrics);
+    expect(result.categories).toHaveLength(1);
+    expect(result.categories[0].categoryName).toBe('transparency');
+    expect(result.categories[0].score).toBe(90);
+  });
+});