@rigour-labs/cli 2.9.4 → 2.11.0

package/src/commands/init.ts

@@ -4,6 +4,24 @@ import chalk from 'chalk';
 import yaml from 'yaml';
 import { DiscoveryService } from '@rigour-labs/core';
 import { CODE_QUALITY_RULES, DEBUGGING_RULES, COLLABORATION_RULES, AGNOSTIC_AI_INSTRUCTIONS } from './constants.js';
+import { randomUUID } from 'crypto';
+
+// Helper to log events for Rigour Studio
+async function logStudioEvent(cwd: string, event: any) {
+    try {
+        const rigourDir = path.join(cwd, ".rigour");
+        await fs.ensureDir(rigourDir);
+        const eventsPath = path.join(rigourDir, "events.jsonl");
+        const logEntry = JSON.stringify({
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            ...event
+        }) + "\n";
+        await fs.appendFile(eventsPath, logEntry);
+    } catch {
+        // Silent fail
+    }
+}
 
 export interface InitOptions {
     preset?: string;
@@ -140,6 +158,14 @@ export async function initCommand(cwd: string, options: InitOptions = {}) {
     }
 
     console.log(chalk.bold.blue('\n🔍 Rigour Auto-Discovery:'));
+
+    const requestId = randomUUID();
+    await logStudioEvent(cwd, {
+        type: "tool_call",
+        requestId,
+        tool: "rigour_init",
+        arguments: options
+    });
     if (recommendedConfig.preset) {
         console.log(chalk.cyan(`   Role: `) + chalk.bold(recommendedConfig.preset.toUpperCase()));
     }
@@ -162,6 +188,7 @@ export async function initCommand(cwd: string, options: InitOptions = {}) {
     for (const file of requireddocs) {
         const filePath = path.join(cwd, file);
         if (!(await fs.pathExists(filePath))) {
+            await fs.ensureDir(path.dirname(filePath)); // Ensure parent directory exists
             await fs.ensureFile(filePath);
             console.log(chalk.dim(`  - Created ${file}`));
         }
@@ -172,32 +199,27 @@ export async function initCommand(cwd: string, options: InitOptions = {}) {
     await fs.ensureDir(rigourDocsDir);
     const instructionsPath = path.join(rigourDocsDir, 'AGENT_INSTRUCTIONS.md');
 
-    const ruleContent = `# 🛡️ Rigour: Engineering Excellence Protocol
+    const ruleContent = `# 🛡️ Rigour: Mandatory Engineering Governance Protocol
 
-You are an Elite Software Engineer. You do not just write code that "works"; you write code that is **modular, maintainable, and rigorously verified.**
+**You are an AI Engineering Agent governed by Rigour.** 
 
-## 🚦 The Rigour Loop (Mandatory)
-Before claiming "Done" for any task, you MUST follow this loop:
+Your access to this codebase is conditional upon your strict adherence to the **Rigour Governance Protocol**. This is an automated requirement for every engineering task.
 
-1.  **Check**: Run \`npx @rigour-labs/cli check\` to verify compliance.
-2.  **Analyze**: If it fails, read \`rigour-fix-packet.json\` (V2 High-Fidelity) for exact failure points and constraints.
-3.  **Refactor**: Apply **SOLID** and **DRY** principles to resolve the violations according to constraints.
-4.  **Repeat**: Continue until \`npx @rigour-labs/cli check\` returns **PASS**.
+## 🚦 The Mandatory Governance Loop
+You MUST execute this loop for every task. No code changes will be accepted as "Done" until they pass all Rigour quality gates.
 
-## 🛠️ Commands
-\`\`\`bash
-# Verify current state
-npx @rigour-labs/cli check
+1.  **Context Loading**: Call \`rigour_recall\` (MCP) to align with project-specific engineering memory.
+2.  **Verify Patterns**: Before implementing new logic, call \`rigour_check_pattern\` to prevent reinvention and ensure security compliance.
+3.  **Audit Enforcement**: Before finishing, you MUST call \`npx @rigour-labs/cli check\`.
+4.  **Failure Remediation**: If the check returns **FAIL**, you MUST implement all required engineering refinements.
+5.  **PASS or REJECT**: You may only declare a task complete when the check returns **PASS**.
 
-# Self-healing agent loop
-npx @rigour-labs/cli run -- <agent-command>
-\`\`\`
+## ⚖️ Transparency & Accountability
+**Every action, tool call, and logic shift you perform is automatically logged to the project's local audit trail.** This data is visible in real-time in the human-monitored **Rigour Studio**.
 
 ${AGNOSTIC_AI_INSTRUCTIONS}
 ${CODE_QUALITY_RULES}
-
 ${DEBUGGING_RULES}
-
 ${COLLABORATION_RULES}
 `;
 
@@ -360,7 +382,32 @@ ${ruleContent}`;
     }
 
     console.log(chalk.blue('\nRigour is ready. Run `npx @rigour-labs/cli check` to verify your project.'));
+    console.log(chalk.cyan('Next Step: ') + chalk.bold('rigour index') + chalk.dim(' (Populate the Pattern Index)'));
+
+    // Bootstrap initial memory for the Studio
+    const rigourDir = path.join(cwd, ".rigour");
+    await fs.ensureDir(rigourDir);
+    const memPath = path.join(rigourDir, "memory.json");
+    if (!(await fs.pathExists(memPath))) {
+        await fs.writeJson(memPath, {
+            memories: {
+                "project_boot": {
+                    value: `Governance initiated via '${options.preset || 'api'}' preset. This project is now monitored by Rigour Studio.`,
+                    timestamp: new Date().toISOString()
+                }
+            }
+        }, { spaces: 2 });
+    }
+
     console.log(chalk.dim('\n💡 Tip: Planning to use a framework like Next.js?'));
     console.log(chalk.dim('   Run its scaffolding tool (e.g., npx create-next-app) BEFORE rigour init,'));
     console.log(chalk.dim('   or move rigour.yml and docs/ aside temporarily to satisfy empty-directory checks.'));
+
+    await logStudioEvent(cwd, {
+        type: "tool_response",
+        requestId,
+        tool: "rigour_init",
+        status: "success",
+        content: [{ type: "text", text: `Rigour Governance Initialized` }]
+    });
 }

package/src/commands/studio.ts

@@ -0,0 +1,273 @@
+import { Command } from 'commander';
+import path from 'path';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import http from 'http';
+import { randomUUID } from 'crypto';
+
+export const studioCommand = new Command('studio')
+    .description('Launch Rigour Studio (Local-First Governance UI)')
+    .option('-p, --port <number>', 'Port to run the studio on', '3000')
+    .option('--dev', 'Run in development mode', true)
+    .action(async (options) => {
+        const cwd = process.cwd();
+        // Calculate the workspace root where the studio package lives
+        // This file is in packages/rigour-cli/src/commands/studio.ts (or dist/commands/studio.js)
+        const workspaceRoot = path.join(path.dirname(new URL(import.meta.url).pathname), '../../../../');
+
+        console.log(chalk.bold.cyan('\n🛡️ Launching Rigour Studio...'));
+        console.log(chalk.gray(`Project Root: ${cwd}`));
+        console.log(chalk.gray(`Shadowing interactions in ${path.join(cwd, '.rigour/events.jsonl')}\n`));
+
+        // For Phase 1, we start the studio in dev mode via pnpm
+        // This ensures the user has a live, hot-reloading governance dashboard
+        try {
+            // Start the Studio dev server in the workspace root
+            const studioProcess = execa('pnpm', ['--filter', '@rigour-labs/studio', 'dev', '--port', options.port], {
+                stdio: 'inherit',
+                shell: true,
+                cwd: workspaceRoot
+            });
+
+            // Start a small API server for events on port + 1
+            const apiPort = parseInt(options.port) + 1;
+            const eventsPath = path.join(cwd, '.rigour/events.jsonl');
+
+            const apiServer = http.createServer(async (req, res) => {
+                const url = new URL(req.url || '', `http://${req.headers.host || 'localhost'}`);
+
+                // Set global CORS headers
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+
+                if (url.pathname === '/api/events') {
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        'Connection': 'keep-alive'
+                    });
+
+                    // Send existing events first
+                    if (await fs.pathExists(eventsPath)) {
+                        const content = await fs.readFile(eventsPath, 'utf8');
+                        const lines = content.split('\n').filter(l => l.trim());
+                        for (const line of lines) {
+                            res.write(`data: ${line}\n\n`);
+                        }
+                    }
+
+                    // Watch for new events
+                    await fs.ensureDir(path.dirname(eventsPath));
+                    const watcher = fs.watch(path.dirname(eventsPath), (eventType, filename) => {
+                        if (filename === 'events.jsonl') {
+                            fs.readFile(eventsPath, 'utf8').then(content => {
+                                const lines = content.split('\n').filter(l => l.trim());
+                                const lastLine = lines[lines.length - 1];
+                                if (lastLine) {
+                                    res.write(`data: ${lastLine}\n\n`);
+                                }
+                            }).catch(() => { });
+                        }
+                    });
+
+                    req.on('close', () => watcher.close());
+                } else if (url.pathname === '/api/file') {
+                    const filePath = url.searchParams.get('path');
+                    if (!filePath) {
+                        res.writeHead(400);
+                        res.end('Missing path parameter');
+                        return;
+                    }
+
+                    const absolutePath = path.resolve(cwd, filePath);
+                    if (!absolutePath.startsWith(cwd)) {
+                        res.writeHead(403);
+                        res.end('Forbidden: Path outside project root');
+                        return;
+                    }
+
+                    try {
+                        const stats = await fs.stat(absolutePath);
+                        if (!stats.isFile()) {
+                            res.writeHead(400);
+                            res.end('Path is not a file');
+                            return;
+                        }
+
+                        const content = await fs.readFile(absolutePath, 'utf8');
+                        res.writeHead(200, { 'Content-Type': 'text/plain' });
+                        res.end(content);
+                    } catch (e: any) {
+                        res.writeHead(404);
+                        res.end(`File not found: ${e.message}`);
+                    }
+                } else if (url.pathname === '/api/tree') {
+                    try {
+                        const getTree = async (dir: string): Promise<string[]> => {
+                            const entries = await fs.readdir(dir, { withFileTypes: true });
+                            let files: string[] = [];
+                            const exclude = [
+                                'node_modules', '.git', '.rigour', '.github', '.vscode', '.cursor',
+                                'venv', '.venv', 'dist', 'build', 'out', 'target', '__pycache__'
+                            ];
+                            for (const entry of entries) {
+                                if (exclude.includes(entry.name) || entry.name.startsWith('.')) {
+                                    if (entry.name !== '.cursorrules' && entry.name !== '.cursor') {
+                                        continue;
+                                    }
+                                }
+                                const fullPath = path.join(dir, entry.name);
+                                if (entry.isDirectory()) {
+                                    files = [...files, ...(await getTree(fullPath))];
+                                } else {
+                                    files.push(path.relative(cwd, fullPath));
+                                }
+                            }
+                            return files;
+                        };
+                        const tree = await getTree(cwd);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(tree));
+                    } catch (e: any) {
+                        res.writeHead(500);
+                        res.end(e.message);
+                    }
+                } else if (url.pathname === '/api/config') {
+                    try {
+                        const configPath = path.join(cwd, 'rigour.yml');
+                        if (await fs.pathExists(configPath)) {
+                            const content = await fs.readFile(configPath, 'utf8');
+                            res.writeHead(200, { 'Content-Type': 'text/plain' });
+                            res.end(content);
+                        } else {
+                            res.writeHead(404);
+                            res.end('rigour.yml not found');
+                        }
+                    } catch (e: any) {
+                        res.writeHead(500);
+                        res.end(e.message);
+                    }
+                } else if (url.pathname === '/api/memory') {
+                    try {
+                        const memoryPath = path.join(cwd, '.rigour/memory.json');
+                        if (await fs.pathExists(memoryPath)) {
+                            const content = await fs.readFile(memoryPath, 'utf8');
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(content);
+                        } else {
+                            res.end(JSON.stringify({}));
+                        }
+                    } catch (e: any) {
+                        res.writeHead(500);
+                        res.end(e.message);
+                    }
+                } else if (url.pathname === '/api/index-stats') {
+                    try {
+                        const indexPath = path.join(cwd, '.rigour/patterns.json'); // Corrected path
+                        if (await fs.pathExists(indexPath)) {
+                            const content = await fs.readJson(indexPath);
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(content));
+                        } else {
+                            res.end(JSON.stringify({ patterns: [], stats: { totalPatterns: 0, totalFiles: 0, byType: {} } }));
+                        }
+                    } catch (e: any) {
+                        res.writeHead(500);
+                        res.end(e.message);
+                    }
+                } else if (url.pathname === '/api/index-search') {
+                    const query = url.searchParams.get('q');
+                    if (!query) {
+                        res.writeHead(400);
+                        res.end('Missing query parameter');
+                        return;
+                    }
+
+                    try {
+                        const { generateEmbedding, semanticSearch } = await import('@rigour-labs/core/pattern-index');
+                        const indexPath = path.join(cwd, '.rigour/patterns.json');
+
+                        if (!(await fs.pathExists(indexPath))) {
+                            res.writeHead(404);
+                            res.end('Index not found');
+                            return;
+                        }
+
+                        const indexData = await fs.readJson(indexPath);
+                        const queryVector = await generateEmbedding(query);
+                        const similarities = semanticSearch(queryVector, indexData.patterns);
+
+                        // Attach similarity to patterns and sort
+                        const results = indexData.patterns.map((p: any, i: number) => ({
+                            ...p,
+                            similarity: similarities[i]
+                        }))
+                            .filter((p: any) => p.similarity > 0.3) // Threshold
+                            .sort((a: any, b: any) => b.similarity - a.similarity)
+                            .slice(0, 20);
+
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(results));
+                    } catch (e: any) {
+                        res.writeHead(500);
+                        res.end(e.message);
+                    }
+                } else if (url.pathname === '/api/arbitrate' && req.method === 'POST') {
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', async () => {
+                        try {
+                            const decision = JSON.parse(body);
+                            const logEntry = JSON.stringify({
+                                id: randomUUID(),
+                                timestamp: new Date().toISOString(),
+                                tool: 'human_arbitration',
+                                requestId: decision.requestId,
+                                decision: decision.decision,
+                                status: decision.decision === 'approve' ? 'success' : 'error',
+                                arbitrated: true
+                            }) + "\n";
+                            await fs.appendFile(eventsPath, logEntry);
+                            res.writeHead(200);
+                            res.end(JSON.stringify({ success: true }));
+                        } catch (e: any) {
+                            res.writeHead(500);
+                            res.end(e.message);
+                        }
+                    });
+                    return;
+                } else {
+                    res.writeHead(404);
+                    res.end();
+                }
+            });
+
+            apiServer.listen(apiPort, () => {
+                console.log(chalk.gray(`API Streamer active on port ${apiPort}`));
+            });
+
+            // Open browser
+            setTimeout(async () => {
+                const url = `http://localhost:${options.port}`;
+                console.log(chalk.green(`\n✅ Rigour Studio is live at ${chalk.bold(url)}`));
+                try {
+                    await execa('open', [url]);
+                } catch {
+                }
+            }, 2000);
+
+            await studioProcess;
+        } catch (error: any) {
+            console.error(chalk.red(`\n❌ Failed to launch Rigour Studio: ${error.message}`));
+            console.log(chalk.yellow('Make sure to run "pnpm install" in the root directory.\n'));
+            process.exit(1);
+        }
+    });

package/src/init-rules.test.ts

@@ -1,8 +1,14 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { initCommand } from './commands/init.js';
+
+
 import fs from 'fs-extra';
 import path from 'path';
 
+async function getInitCommand() {
+    const { initCommand } = await import('./commands/init.js');
+    return initCommand;
+}
+
 describe('Init Command Rules Verification', () => {
     const testDir = path.join(process.cwd(), 'temp-init-rules-test');
 
@@ -15,6 +21,7 @@ describe('Init Command Rules Verification', () => {
     });
 
     it('should create instructions with agnostic rules and cursor rules on init', async () => {
+        const initCommand = await getInitCommand();
         // Run init in test directory with all IDEs to verify rules in both locations
         await initCommand(testDir, { ide: 'all' });
 
@@ -32,7 +39,7 @@ describe('Init Command Rules Verification', () => {
         expect(instructionsContent).toContain('VERIFICATION PROOF REQUIRED');
 
         // Check for key sections in universal instructions
-        expect(instructionsContent).toContain('# 🛡️ Rigour: Engineering Excellence Protocol');
+        expect(instructionsContent).toContain('# 🛡️ Rigour: Mandatory Engineering Governance Protocol');
         expect(instructionsContent).toContain('# Code Quality Standards');
 
         // Check that MDC includes agnostic rules
@@ -40,6 +47,7 @@ describe('Init Command Rules Verification', () => {
     });
 
     it('should create .clinerules when ide is cline or all', async () => {
+        const initCommand = await getInitCommand();
         await initCommand(testDir, { ide: 'cline' });
         const clineRulesPath = path.join(testDir, '.clinerules');
         expect(await fs.pathExists(clineRulesPath)).toBe(true);

package/src/smoke.test.ts

@@ -1,8 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { checkCommand } from './commands/check.js';
+
 import fs from 'fs-extra';
 import path from 'path';
 
+async function getCheckCommand() {
+    const { checkCommand } = await import('./commands/check.js');
+    return checkCommand;
+}
+
 describe('CLI Smoke Test', () => {
     const testDir = path.join(process.cwd(), 'temp-smoke-test');
 
@@ -40,6 +45,7 @@ gates:
             // But checkCommand calls process.exit(1) on failure.
 
             // Re-importing checkCommand to ensure it uses the latest core
+            const checkCommand = await getCheckCommand();
             await expect(checkCommand(testDir, [], { ci: true })).resolves.not.toThrow();
         } finally {
             await fs.chmod(restrictedDir, 0o777);
@@ -57,12 +63,14 @@ gates:
 `);
 
         // If we check ONLY good.js, it should PASS (exit PASS)
+        const checkCommand = await getCheckCommand();
         await checkCommand(testDir, [path.join(testDir, 'good.js')], { ci: true });
         expect(process.exit).toHaveBeenCalledWith(0);
 
         // If we check bad.js, it should FAIL (exit FAIL)
         vi.clearAllMocks();
-        await checkCommand(testDir, [path.join(testDir, 'bad.js')], { ci: true });
+        const checkCommandFail = await getCheckCommand();
+        await checkCommandFail(testDir, [path.join(testDir, 'bad.js')], { ci: true });
         expect(process.exit).toHaveBeenCalledWith(1);
     });
 });

package/src/templates/handshake.mdc

@@ -1,39 +1,36 @@
 ---
-description: Engineering Rigour Protocol - Enforces high software standards (SOLID, DRY, Patterns) via automated quality gates.
+description: Mandatory Rigour Governance Protocol - Automated engineering enforcement (SOLID, DRY, Patterns).
 globs: **/*
 ---
 
-# 🛡️ Rigour: Engineering Excellence Protocol
+# 🛡️ Rigour: Mandatory Engineering Governance
 
-You are an Elite Software Engineer. You do not just write code that "works"; you write code that is **modular, maintainable, and rigorously verified.**
+**You are an AI Engineering Agent governed by Rigour.** 
 
-## 🚦 The Rigour Loop (Mandatory)
-Before claiming "Done" for any task, you MUST follow this loop:
+Your access to this codebase is conditional upon your strict adherence to the **Rigour Governance Protocol**. This is not a recommendation; it is an automated requirement for every interaction.
 
-1.  **Check**: Run `rigour_check_status` (via MCP) or `rigour check` (via CLI).
-2.  **Analyze**: If it fails, run `rigour_get_fix_packet` to understand the engineering violations.
-3.  **Refactor**: Apply **SOLID** and **DRY** principles to resolve the violations.
-4.  **Repeat**: Continue until `rigour_check_status` returns **PASS**.
+## 🚦 The Mandatory Governance Loop
+You MUST execute this loop for every engineering task. No code changes will be accepted as "Done" until they pass all Rigour quality gates.
 
-## 🧩 Engineering Standards
-Your code will be judged against these gates:
+1.  **Recall Context**: Call `rigour_recall` at the start of every session to align with project-specific engineering memory.
+2.  **Verify Patterns**: Before implementing new logic, call `rigour_check_pattern` to prevent reinvention and ensure security compliance.
+3.  **Audit Enforcement**: Before finishing, you MUST call `rigour_check`.
+4.  **Failure Remediation**: If `rigour_check` returns **FAIL**, you MUST call `rigour_get_fix_packet` and implement all required engineering refinements.
+5.  **PASS or REJECT**: You may only declare a task complete when `rigour_check` returns **PASS**.
 
-### 1. SOLID Principles
-- **Single Responsibility**: Keep files small and focused.
-- **Open/Closed**: Design for extension, not modification.
-- **Interface Segregation**: Don't force dependencies on unused methods.
+## 🧩 Governance Standards
+Your logic is automatically audited against these core engineering gates:
 
-### 2. DRY (Don't Repeat Yourself)
-- Extract common logic into utilities or shared services.
-- If Rigour detects duplication, you must refactor immediately.
+### 1. Architectural Integrity (SOLID)
+- **SRP**: Every component must have one reason to change.
+- **DIP**: Depend on abstractions, not concretions.
 
-### 3. "Done is Done"
-- No `TODO` or `FIXME` comments are allowed in the final state.
-- Every placeholder is a failure of rigour.
+### 2. Efficiency & Security (DRY + CVE)
+- **No Reinvention**: Reuse existing patterns identified by Rigour.
+- **Safety**: No vulnerable libraries or deprecated patterns allowed.
 
-## 🛠️ Tools at your disposal
-- `rigour_check_status`: Get the current PASS/FAIL state.
-- `rigour_get_fix_packet`: Get actionable instructions for failures.
-- `rigour run "<command>"`: Use this CLI command to run yourself in a loop until you pass (Experimental).
+## ⚖️ Transparency & Accountability
+**Every action, tool call, and logic shift you perform is automatically logged to the project's local audit trail.** This data is visible in real-time to the human governor in **Rigour Studio**. Failure to follow this protocol will be flagged as a governance violation.
 
-**Remember:** Rigour is not just a tool; it is your engineering conscience. Hold yourself to the highest standard.
+**GOVERNANCE STATUS: ACTIVE**
+**ENFORCEMENT: MANDATORY**

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        setupFiles: ['./vitest.setup.ts'],
+        deps: {
+            external: ['@xenova/transformers', 'sharp'],
+        },
+    },
+});

package/vitest.setup.ts

@@ -0,0 +1,30 @@
+import { vi } from 'vitest';
+
+// Mock Transformers.js to avoid native binary dependency issues and speed up tests
+vi.mock('@xenova/transformers', () => ({
+    pipeline: async () => {
+        // Return a mock extractor that produces deterministic "embeddings"
+        return async (text: string) => {
+            // Create a fake vector based on the text length or hash
+            const vector = new Array(384).fill(0);
+            for (let i = 0; i < Math.min(text.length, 384); i++) {
+                vector[i] = text.charCodeAt(i) / 255;
+            }
+            return { data: new Float32Array(vector) };
+        };
+    },
+    env: {
+        allowImageProcessors: false,
+    },
+}));
+
+// Also mock sharp just in case something else pulls it in
+vi.mock('sharp', () => ({
+    default: () => ({
+        resize: () => ({
+            toFormat: () => ({
+                toBuffer: async () => Buffer.from([]),
+            }),
+        }),
+    }),
+}));