@complior/engine 0.9.0

package/src/llm/agents/modes.ts

@@ -0,0 +1,68 @@
+import type { AgentMode } from '../tools/types.js';
+import { getDisclaimer } from '../../domain/disclaimer.js';
+
+export interface AgentConfig {
+  readonly mode: AgentMode;
+  readonly label: string;
+  readonly systemPrompt: string;
+  readonly writeEnabled: boolean;
+}
+
+const DISCLAIMER = getDisclaimer('system_prompt');
+
+const AGENT_CONFIGS: Record<AgentMode, AgentConfig> = {
+  build: {
+    mode: 'build',
+    label: 'BUILD',
+    writeEnabled: true,
+    systemPrompt: `${DISCLAIMER}
+
+You are a compliance-first coding assistant. You can write code AND check compliance.
+Available: all 23 tools (15 compliance + 8 coding).
+After every file change, compliance is automatically re-scanned.
+Always suggest compliance-aware code patterns.`,
+  },
+  comply: {
+    mode: 'comply',
+    label: 'COMPLY',
+    writeEnabled: false,
+    systemPrompt: `${DISCLAIMER}
+
+You are a compliance advisor. Analyze code and suggest fixes, but DO NOT apply changes.
+Available: 15 compliance tools + readFile + searchCode.
+Write operations are DISABLED. Use fixIssue to generate diff previews only.
+Focus on explaining what needs to change and why.`,
+  },
+  audit: {
+    mode: 'audit',
+    label: 'AUDIT',
+    writeEnabled: false,
+    systemPrompt: `${DISCLAIMER}
+
+You are a compliance auditor performing a read-only review.
+Available: scan, report, explain, search, status, deadlines.
+NO file modifications. Generate reports and explain findings.
+Suitable for CTO/DPO compliance reviews.`,
+  },
+  learn: {
+    mode: 'learn',
+    label: 'LEARN',
+    writeEnabled: false,
+    systemPrompt: `${DISCLAIMER}
+
+You are an EU AI Act teacher. Explain regulations in plain language without legal jargon.
+Available: explain, search, compare, askUser.
+NO code operations. Focus on education and understanding.
+Use examples relevant to the developer's project when possible.`,
+  },
+};
+
+export const getAgentConfig = (mode: AgentMode): AgentConfig => AGENT_CONFIGS[mode];
+
+export const getAllModes = (): readonly AgentMode[] => ['build', 'comply', 'audit', 'learn'];
+
+export const nextMode = (current: AgentMode): AgentMode => {
+  const modes = getAllModes();
+  const idx = modes.indexOf(current);
+  return modes[(idx + 1) % modes.length];
+};

package/src/llm/routing/cost-routing.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { calculateCost } from './pricing.js';
+import { createCostTracker } from './cost-tracker.js';
+
+describe('Pricing', () => {
+  it('calculates cost for claude-haiku-4', () => {
+    const cost = calculateCost('claude-haiku-4', 1000, 2000);
+    // (1000 * 0.80 + 2000 * 4.0) / 1_000_000 = 0.0088
+    expect(cost).toBeCloseTo(0.0088, 4);
+  });
+
+  it('returns 0 for unknown model', () => {
+    expect(calculateCost('unknown-model', 1000, 1000)).toBe(0);
+  });
+});
+
+describe('Cost Tracker', () => {
+  it('records and aggregates costs', () => {
+    const tracker = createCostTracker();
+    tracker.record('qa', 'claude-haiku-4', 1000, 2000);
+    tracker.record('report', 'claude-opus-4', 2000, 10000);
+
+    const breakdown = tracker.getBreakdown();
+    expect(breakdown.entries).toHaveLength(2);
+    expect(breakdown.totalCost).toBeGreaterThan(0);
+    expect(breakdown.byTaskType['qa']?.calls).toBe(1);
+    expect(breakdown.byTaskType['report']?.calls).toBe(1);
+  });
+
+  it('formats cost line', () => {
+    const tracker = createCostTracker();
+    const entry = tracker.record('qa', 'claude-haiku-4', 1000, 2000);
+    const line = tracker.formatCostLine(entry);
+    expect(line).toContain('$');
+    expect(line).toContain('tokens');
+  });
+});

package/src/llm/routing/cost-tracker.ts

@@ -0,0 +1,74 @@
+import { calculateCost } from './pricing.js';
+
+export type TaskType = 'qa' | 'scan_fix' | 'code_gen' | 'report' | 'whatif' | 'deep_analysis';
+
+export interface CostEntry {
+  readonly taskType: TaskType;
+  readonly model: string;
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+  readonly cost: number;
+  readonly timestamp: number;
+}
+
+export interface CostBreakdown {
+  readonly entries: readonly CostEntry[];
+  readonly totalCost: number;
+  readonly totalTokens: number;
+  readonly byTaskType: Record<string, { calls: number; tokens: number; cost: number }>;
+  readonly sessionDuration: number;
+}
+
+export const createCostTracker = () => {
+  const entries: CostEntry[] = [];
+  const startTime = Date.now();
+
+  const record = (
+    taskType: TaskType,
+    model: string,
+    inputTokens: number,
+    outputTokens: number,
+  ): CostEntry => {
+    const cost = calculateCost(model, inputTokens, outputTokens);
+    const entry: CostEntry = {
+      taskType,
+      model,
+      inputTokens,
+      outputTokens,
+      cost,
+      timestamp: Date.now(),
+    };
+    entries.push(entry);
+    return entry;
+  };
+
+  const getBreakdown = (): CostBreakdown => {
+    const byTaskType: Record<string, { calls: number; tokens: number; cost: number }> = {};
+
+    for (const e of entries) {
+      const existing = byTaskType[e.taskType] ?? { calls: 0, tokens: 0, cost: 0 };
+      byTaskType[e.taskType] = {
+        calls: existing.calls + 1,
+        tokens: existing.tokens + e.inputTokens + e.outputTokens,
+        cost: existing.cost + e.cost,
+      };
+    }
+
+    return {
+      entries,
+      totalCost: entries.reduce((sum, e) => sum + e.cost, 0),
+      totalTokens: entries.reduce((sum, e) => sum + e.inputTokens + e.outputTokens, 0),
+      byTaskType,
+      sessionDuration: Date.now() - startTime,
+    };
+  };
+
+  const formatCostLine = (entry: CostEntry): string => {
+    const tokens = entry.inputTokens + entry.outputTokens;
+    return `~$${entry.cost.toFixed(2)} (${tokens.toLocaleString()} tokens: ${entry.inputTokens.toLocaleString()} in + ${entry.outputTokens.toLocaleString()} out)`;
+  };
+
+  return Object.freeze({ record, getBreakdown, formatCostLine });
+};
+
+export type CostTracker = ReturnType<typeof createCostTracker>;

package/src/llm/routing/model-routing.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { routeModelForProvider, envKeyForTaskType } from './model-routing.js';
+
+describe('envKeyForTaskType', () => {
+  it('converts simple task type', () => {
+    expect(envKeyForTaskType('classify')).toBe('COMPLIOR_MODEL_CLASSIFY');
+  });
+
+  it('converts hyphenated task type', () => {
+    expect(envKeyForTaskType('document-generation')).toBe('COMPLIOR_MODEL_DOCUMENT_GENERATION');
+  });
+
+  it('converts all task types', () => {
+    expect(envKeyForTaskType('qa')).toBe('COMPLIOR_MODEL_QA');
+    expect(envKeyForTaskType('code')).toBe('COMPLIOR_MODEL_CODE');
+    expect(envKeyForTaskType('report')).toBe('COMPLIOR_MODEL_REPORT');
+    expect(envKeyForTaskType('chat')).toBe('COMPLIOR_MODEL_CHAT');
+  });
+});
+
+describe('routeModelForProvider — env overrides', () => {
+  const envKeys = [
+    'COMPLIOR_MODEL_CLASSIFY',
+    'COMPLIOR_MODEL_DOCUMENT_GENERATION',
+    'COMPLIOR_MODEL_CHAT',
+    'COMPLIOR_MODEL_CODE',
+    'COMPLIOR_MODEL_REPORT',
+    'COMPLIOR_MODEL_QA',
+  ];
+
+  afterEach(() => {
+    for (const key of envKeys) {
+      delete process.env[key];
+    }
+  });
+
+  it('returns default model when no env override set', () => {
+    const result = routeModelForProvider('classify', 'openrouter');
+    expect(result.modelId).toBe('anthropic/claude-haiku-4.5');
+    expect(result.reason).not.toContain('Custom model');
+  });
+
+  it('uses COMPLIOR_MODEL_CLASSIFY env override', () => {
+    process.env['COMPLIOR_MODEL_CLASSIFY'] = 'google/gemini-2.0-flash';
+    const result = routeModelForProvider('classify', 'openrouter');
+    expect(result.modelId).toBe('google/gemini-2.0-flash');
+    expect(result.reason).toBe('Custom model (COMPLIOR_MODEL_CLASSIFY)');
+    expect(result.provider).toBe('openrouter');
+  });
+
+  it('uses COMPLIOR_MODEL_DOCUMENT_GENERATION env override', () => {
+    process.env['COMPLIOR_MODEL_DOCUMENT_GENERATION'] = 'my-custom-model';
+    const result = routeModelForProvider('document-generation', 'anthropic');
+    expect(result.modelId).toBe('my-custom-model');
+    expect(result.reason).toContain('COMPLIOR_MODEL_DOCUMENT_GENERATION');
+  });
+
+  it('falls back to default when env var is empty string', () => {
+    process.env['COMPLIOR_MODEL_CHAT'] = '';
+    const result = routeModelForProvider('chat', 'openai');
+    expect(result.modelId).toBe('gpt-4o');
+    expect(result.reason).not.toContain('Custom model');
+  });
+
+  it('falls back to chat for invalid task type', () => {
+    process.env['COMPLIOR_MODEL_CHAT'] = 'override-chat-model';
+    const result = routeModelForProvider('nonexistent', 'openrouter');
+    expect(result.modelId).toBe('override-chat-model');
+  });
+
+  it('env override works for all providers', () => {
+    process.env['COMPLIOR_MODEL_QA'] = 'custom-qa-model';
+    for (const provider of ['openai', 'anthropic', 'openrouter'] as const) {
+      const result = routeModelForProvider('qa', provider);
+      expect(result.modelId).toBe('custom-qa-model');
+      expect(result.provider).toBe(provider);
+    }
+  });
+});

package/src/llm/routing/model-routing.ts

@@ -0,0 +1,38 @@
+/**
+ * Model routing — maps task types to model selections per provider.
+ * Business logic extracted from infra/llm-adapter.ts to keep
+ * infrastructure layer as a pure adapter.
+ */
+import type { ProviderName, ModelSelection } from '../../ports/llm.port.js';
+import routingData from '../../../data/llm/model-routing.json' with { type: 'json' };
+
+export type TaskType = 'qa' | 'code' | 'report' | 'classify' | 'chat' | 'document-generation';
+
+const MODEL_MAP = routingData.model_map as Readonly<Record<ProviderName, Readonly<Record<TaskType, string>>>>;
+
+const TASK_REASONS = routingData.task_reasons as Readonly<Record<TaskType, string>>;
+
+const isTaskType = (s: string): s is TaskType => s in TASK_REASONS;
+
+/** Build the env-variable name for a given task type: COMPLIOR_MODEL_{TASK_TYPE}. */
+export const envKeyForTaskType = (taskType: TaskType): string =>
+  `COMPLIOR_MODEL_${taskType.toUpperCase().replace(/-/g, '_')}`;
+
+/** Route a task type to a concrete model selection for a given provider. */
+export const routeModelForProvider = (taskType: string, provider: ProviderName): ModelSelection => {
+  const validType = isTaskType(taskType) ? taskType : 'chat';
+
+  // Env override: COMPLIOR_MODEL_CLASSIFY, COMPLIOR_MODEL_DOCUMENT_GENERATION, etc.
+  const envKey = envKeyForTaskType(validType);
+  const envModel = process.env[envKey];
+
+  const modelId = envModel || MODEL_MAP[provider][validType];
+
+  return {
+    provider,
+    modelId,
+    reason: envModel
+      ? `Custom model (${envKey})`
+      : TASK_REASONS[validType],
+  };
+};

package/src/llm/routing/pricing.ts

@@ -0,0 +1,19 @@
+import pricingData from '../../../data/llm/model-pricing.json' with { type: 'json' };
+
+// Pricing per 1M tokens (USD)
+export interface ModelPricing {
+  readonly input: number;
+  readonly output: number;
+}
+
+export const PRICING: Record<string, ModelPricing> = pricingData.models;
+
+export const calculateCost = (
+  model: string,
+  inputTokens: number,
+  outputTokens: number,
+): number => {
+  const pricing = PRICING[model];
+  if (!pricing) return 0;
+  return (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000;
+};

package/src/llm/sse-protocol.ts

@@ -0,0 +1,77 @@
+export interface SseEventPayload {
+  event: string;
+  data: string;
+}
+
+export const sseThinking = (content: string): SseEventPayload => ({
+  event: 'thinking',
+  data: JSON.stringify({ content }),
+});
+
+export const sseText = (content: string): SseEventPayload => ({
+  event: 'text',
+  data: JSON.stringify({ content }),
+});
+
+export const sseToolCall = (toolCallId: string, toolName: string, args: object): SseEventPayload => ({
+  event: 'tool_call',
+  data: JSON.stringify({ toolCallId, toolName, args }),
+});
+
+export const sseToolResult = (toolCallId: string, toolName: string, result: string, isError: boolean): SseEventPayload => ({
+  event: 'tool_result',
+  data: JSON.stringify({ toolCallId, toolName, result, isError }),
+});
+
+export const sseUsage = (promptTokens: number, completionTokens: number): SseEventPayload => ({
+  event: 'usage',
+  data: JSON.stringify({ promptTokens, completionTokens }),
+});
+
+export const sseDone = (): SseEventPayload => ({
+  event: 'done',
+  data: '{}',
+});
+
+export const sseError = (message: string): SseEventPayload => ({
+  event: 'error',
+  data: JSON.stringify({ message }),
+});
+
+// ── Eval SSE events ──────────────────────────────────────────────
+
+export const sseEvalStart = (target: string, model: string | undefined, mode: string, judgeModel?: string): SseEventPayload => ({
+  event: 'eval:start',
+  data: JSON.stringify({ target, model: model ?? 'default', mode, ...(judgeModel ? { judgeModel } : {}) }),
+});
+
+export const sseEvalHealth = (ok: boolean): SseEventPayload => ({
+  event: 'eval:health',
+  data: JSON.stringify({ ok }),
+});
+
+export const sseEvalTest = (payload: {
+  testId: string;
+  name: string;
+  category: string;
+  method: string;
+  verdict: string;
+  score: number;
+  latencyMs: number;
+  phase: string;
+  completed: number;
+  total: number;
+  owaspCategory?: string;
+  severity?: string;
+  probe?: string;
+  response?: string;
+  reasoning?: string;
+}): SseEventPayload => ({
+  event: 'eval:test',
+  data: JSON.stringify(payload),
+});
+
+export const sseEvalDone = (result: unknown): SseEventPayload => ({
+  event: 'eval:done',
+  data: JSON.stringify(result),
+});

package/src/llm/tool-definitions.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { tool } from 'ai';
+import { createToolExecutors, type ToolExecutor, type ToolExecutorDeps } from './tool-executors.js';
+
+export const createCodingTools = (projectPath: string, deps: ToolExecutorDeps) => {
+  const executors = createToolExecutors(projectPath, deps);
+
+  const safeExec = (executor: ToolExecutor) =>
+    async (args: Record<string, unknown>): Promise<string> => {
+      try {
+        return await executor(args);
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        return JSON.stringify({ error: true, message });
+      }
+    };
+
+  return {
+    scan_project: tool({
+      description: 'Scan a project directory for EU AI Act compliance issues',
+      inputSchema: z.object({
+        path: z.string().describe('Project directory path to scan'),
+      }),
+      execute: async (args) => safeExec(executors.scan_project!)(args),
+    }),
+    create_file: tool({
+      description: 'Create a new file with the given content',
+      inputSchema: z.object({
+        path: z.string().describe('File path to create'),
+        content: z.string().describe('File content'),
+      }),
+      execute: async (args) => safeExec(executors.create_file!)(args),
+    }),
+    edit_file: tool({
+      description: 'Edit an existing file by replacing content',
+      inputSchema: z.object({
+        path: z.string().describe('File path to edit'),
+        oldContent: z.string().describe('Content to find and replace'),
+        newContent: z.string().describe('Replacement content'),
+      }),
+      execute: async (args) => safeExec(executors.edit_file!)(args),
+    }),
+    read_file: tool({
+      description: 'Read the contents of a file',
+      inputSchema: z.object({
+        path: z.string().describe('File path to read'),
+      }),
+      execute: async (args) => safeExec(executors.read_file!)(args),
+    }),
+    list_files: tool({
+      description: 'List files in a directory',
+      inputSchema: z.object({
+        path: z.string().describe('Directory path to list'),
+        pattern: z.string().optional().describe('Optional filename pattern filter'),
+      }),
+      execute: async (args) => safeExec(executors.list_files!)(args),
+    }),
+    search_code: tool({
+      description: 'Search for a pattern in project files using ripgrep',
+      inputSchema: z.object({
+        pattern: z.string().describe('Search pattern (regex supported)'),
+        path: z.string().describe('Directory to search in'),
+      }),
+      execute: async (args) => safeExec(executors.search_code!)(args),
+    }),
+    run_command: tool({
+      description: 'Run a shell command in the project directory',
+      inputSchema: z.object({
+        command: z.string().describe('Shell command to run'),
+        cwd: z.string().optional().describe('Working directory'),
+      }),
+      execute: async (args) => safeExec(executors.run_command!)(args),
+    }),
+    git_operation: tool({
+      description: 'Perform a git operation',
+      inputSchema: z.object({
+        action: z.enum(['status', 'diff', 'log', 'add', 'commit', 'branch']).describe('Git action'),
+        args: z.record(z.unknown()).optional().describe('Action-specific arguments'),
+      }),
+      execute: async (args) => safeExec(executors.git_operation!)(args),
+    }),
+  };
+};

package/src/llm/tool-executors.ts

@@ -0,0 +1,80 @@
+import { resolve } from 'node:path';
+import { z } from 'zod';
+import { createFile, editFile, readFile, listFiles } from '../infra/file-ops-adapter.js';
+import { search } from '../infra/search-adapter.js';
+import { runCommand } from '../infra/shell-adapter.js';
+import { gitOperation } from '../infra/git-adapter.js';
+import { collectFiles } from '../infra/file-collector.js';
+import { createScanner } from '../domain/scanner/create-scanner.js';
+import type { ScanResult } from '../types/common.types.js';
+import type { ScoringData } from '../data/schemas/schemas.js';
+
+export type ToolExecutor = (args: Record<string, unknown>) => Promise<string>;
+
+export interface ToolExecutorDeps {
+  readonly getScoringData: () => ScoringData | undefined;
+  readonly setLastScanResult: (result: ScanResult) => void;
+}
+
+const ScanArgs = z.object({ path: z.string().default('.') });
+const FileArgs = z.object({ path: z.string(), content: z.string() });
+const EditArgs = z.object({ path: z.string(), oldContent: z.string(), newContent: z.string() });
+const PathArgs = z.object({ path: z.string() });
+const ListArgs = z.object({ path: z.string(), pattern: z.string().optional() });
+const SearchArgs = z.object({ pattern: z.string(), path: z.string().default('.') });
+const CmdArgs = z.object({ command: z.string(), cwd: z.string().optional() });
+const GitArgs = z.object({ action: z.string(), args: z.record(z.unknown()).optional() });
+
+export const createToolExecutors = (projectPath: string, deps: ToolExecutorDeps): Record<string, ToolExecutor> => ({
+  scan_project: async (raw) => {
+    const args = ScanArgs.parse(raw);
+    const scanPath = resolve(projectPath, args.path);
+    const scoringData = deps.getScoringData();
+    const scanContext = await collectFiles(scanPath);
+    const scanner = createScanner(scoringData);
+    const result = scanner.scan(scanContext);
+    deps.setLastScanResult(result);
+    return JSON.stringify({ score: result.score.totalScore, zone: result.score.zone, findings: result.findings.length, filesScanned: result.filesScanned });
+  },
+  create_file: async (raw) => {
+    const args = FileArgs.parse(raw);
+    const filePath = resolve(projectPath, args.path);
+    await createFile(filePath, args.content);
+    return JSON.stringify({ success: true, path: filePath });
+  },
+  edit_file: async (raw) => {
+    const args = EditArgs.parse(raw);
+    const filePath = resolve(projectPath, args.path);
+    await editFile(filePath, args.oldContent, args.newContent);
+    return JSON.stringify({ success: true, path: filePath });
+  },
+  read_file: async (raw) => {
+    const args = PathArgs.parse(raw);
+    const filePath = resolve(projectPath, args.path);
+    const content = await readFile(filePath);
+    return JSON.stringify({ content, path: filePath });
+  },
+  list_files: async (raw) => {
+    const args = ListArgs.parse(raw);
+    const dirPath = resolve(projectPath, args.path);
+    const files = await listFiles(dirPath, args.pattern);
+    return JSON.stringify({ files, count: files.length });
+  },
+  search_code: async (raw) => {
+    const args = SearchArgs.parse(raw);
+    const searchPath = resolve(projectPath, args.path);
+    const results = await search(args.pattern, searchPath);
+    return JSON.stringify({ results, count: results.length });
+  },
+  run_command: async (raw) => {
+    const args = CmdArgs.parse(raw);
+    const cwd = args.cwd ? resolve(projectPath, args.cwd) : projectPath;
+    const result = await runCommand(args.command, cwd);
+    return JSON.stringify(result);
+  },
+  git_operation: async (raw) => {
+    const args = GitArgs.parse(raw);
+    const result = await gitOperation(args.action, args.args, projectPath);
+    return JSON.stringify(result);
+  },
+});

package/src/llm/tools/types.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod';
+
+export type ToolCategory = 'compliance' | 'coding';
+
+export interface ToolDefinition {
+  readonly name: string;
+  readonly description: string;
+  readonly category: ToolCategory;
+  readonly parameters: z.ZodType;
+  readonly execute: (args: Record<string, unknown>) => Promise<string>;
+}
+
+export type AgentMode = 'build' | 'comply' | 'audit' | 'learn';

package/src/mcp/create-mcp-stack.ts

@@ -0,0 +1,82 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { ScanResult } from '../types/common.types.js';
+import type { RegulationData } from '../data/regulation/regulation-loader.js';
+import { createEventBus } from '../infra/event-bus.js';
+import { createScanner } from '../domain/scanner/create-scanner.js';
+import { collectFiles } from '../infra/file-collector.js';
+import { createFixer } from '../domain/fixer/create-fixer.js';
+import { createScanService } from '../services/scan-service.js';
+import { createFixService } from '../services/fix-service.js';
+import { createMcpHandlers } from './handlers.js';
+import { createMcpServer } from './server.js';
+
+export interface McpStackDeps {
+  readonly regulationData: RegulationData;
+  readonly projectPath: string;
+  readonly getLastScanResult: () => ScanResult | null;
+  readonly setLastScanResult: (r: ScanResult | null) => void;
+  readonly version: string;
+}
+
+export const createMcpStack = async (deps: McpStackDeps) => {
+  const { regulationData, projectPath, version } = deps;
+
+  const events = createEventBus();
+  const scanner = createScanner(regulationData.scoring?.scoring);
+
+  const fixer = createFixer({
+    getFramework: () => {
+      const lastScan = deps.getLastScanResult();
+      if (!lastScan) return 'generic';
+      const text = lastScan.findings.map((f) => f.message).join(' ');
+      if (text.includes('Next.js') || text.includes('next')) return 'Next.js';
+      if (text.includes('Express')) return 'Express';
+      if (text.includes('React')) return 'React';
+      return 'generic';
+    },
+    getProjectPath: () => projectPath,
+    getExistingFiles: () =>
+      deps.getLastScanResult()?.findings
+        .filter((f): f is typeof f & { file: string } => typeof f.file === 'string')
+        .map((f) => f.file) ?? [],
+  });
+
+  const scanService = createScanService({
+    scanner,
+    collectFiles,
+    events,
+    getLastScanResult: deps.getLastScanResult,
+    setLastScanResult: deps.setLastScanResult,
+  });
+
+  const templatesDir = resolve(
+    fileURLToPath(import.meta.url), '..', '..', '..', 'data', 'templates', 'eu-ai-act',
+  );
+  const loadTemplate = async (templateFile: string): Promise<string> => {
+    return readFile(resolve(templatesDir, templateFile), 'utf-8');
+  };
+
+  const fixService = createFixService({
+    fixer,
+    scanService,
+    events,
+    getProjectPath: () => projectPath,
+    getLastScanResult: deps.getLastScanResult,
+    loadTemplate,
+  });
+
+  const handlers = createMcpHandlers({
+    scanService,
+    fixService,
+    getProjectPath: () => projectPath,
+    getLastScanResult: deps.getLastScanResult,
+    getRegulationData: () => regulationData,
+    version,
+  });
+
+  const mcpServer = createMcpServer({ handlers, version });
+
+  return Object.freeze({ mcpServer, scanService, fixService });
+};