@roomi-fields/grillhouse 0.0.0-stage → 0.23.0

package/cadre/templates/projet/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@your-scope/project-name",
+  "version": "1.0.0",
+  "description": "A brief description of your project",
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "project-name": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "grillhouse tests",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src tests --ext .ts,.js,.mjs",
+    "lint:fix": "eslint src tests --ext .ts,.js,.mjs --fix",
+    "format": "prettier --write \"src/**/*.{ts,js,mjs}\" \"tests/**/*.{ts,js,mjs}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,js,mjs}\" \"tests/**/*.{ts,js,mjs}\"",
+    "prepare": "grillhouse hooks && npm run build",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run verifier && npm run build",
+    "daemon:start": "pm2 start ecosystem.config.cjs",
+    "daemon:stop": "pm2 stop project-name",
+    "daemon:restart": "pm2 restart project-name",
+    "daemon:logs": "pm2 logs project-name",
+    "daemon:status": "pm2 status",
+    "daemon:delete": "pm2 delete project-name",
+    "interfaces": "grillhouse index-interfaces",
+    "grillhouse:gardes": "grillhouse gardes-du-cadre",
+    "frontieres": "grillhouse frontieres",
+    "api": "grillhouse interfaces-contre-code --ecrire",
+    "tableau": "grillhouse tableau --texte",
+    "grillhouse:maj": "grillhouse maj",
+    "code-mort": "grillhouse code-mort",
+    "test:vitest": "vitest run",
+    "test:forcer": "grillhouse tests --force",
+    "verifier": "grillhouse verifier",
+    "grillhouse:dette:inscrire": "turbo run build && GRILLHOUSE_DETTE=inscrire npm run --silent grillhouse:gardes",
+    "grillhouse:dette:elaguer": "turbo run build && GRILLHOUSE_DETTE=elaguer npm run --silent grillhouse:gardes"
+  },
+  "keywords": [
+    "keyword1",
+    "keyword2",
+    "keyword3"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/your-username/project-name.git"
+  },
+  "bugs": {
+    "url": "https://github.com/your-username/project-name/issues"
+  },
+  "homepage": "https://github.com/your-username/project-name#readme",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "docs"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "7.59.2",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "@vitest/coverage-v8": "^2.1.9",
+    "dependency-cruiser": "18.4.0",
+    "eslint": "^8.57.0",
+    "knip": "^6.41.0",
+    "pm2": "^5.4.2",
+    "prettier": "^3.2.0",
+    "tsx": "^4.7.0",
+    "turbo": "2.11.8",
+    "typescript": "^5.3.3",
+    "vitest": "^2.0.0"
+  },
+  "packageManager": "npm@10.9.8"
+}

package/cadre/templates/projet/pitmaster/SUIVI.md

@@ -0,0 +1,22 @@
+# Suivi de la supervision
+
+Tenu par la compétence `pitmaster`. Une question s'écrit ici dès qu'elle naît ; tranchée, elle en
+sort et sa réponse va dans son ticket.
+
+## Dernier tour
+
+- Date : aucun tour encore
+- Agents lancés : aucun
+- À vérifier au prochain tour : rien
+
+## R — à confirmer par le responsable
+
+Chaque point : contexte, exemple, règle, recommandation, question, ticket.
+
+## S — à surveiller
+
+Chaque point : ce qui se surveille, ce qui le fermera.
+
+## F — fermés
+
+Chaque point : ce qui l'a fermé, le ticket.

package/cadre/templates/projet/src/config.ts

@@ -0,0 +1,68 @@
+/**
+ * Application configuration
+ *
+ * Centralizes all configuration from environment variables
+ * with sensible defaults for development.
+ */
+
+import { config as dotenvConfig } from 'dotenv';
+import { z } from 'zod';
+
+// Load environment variables
+dotenvConfig();
+
+/**
+ * Environment configuration schema
+ */
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.string().transform(Number).default('3000'),
+  LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+});
+
+/**
+ * Parse and validate environment variables
+ */
+function parseEnv() {
+  const result = envSchema.safeParse(process.env);
+
+  if (!result.success) {
+    console.error('Invalid environment configuration:');
+    console.error(result.error.format());
+    process.exit(1);
+  }
+
+  return result.data;
+}
+
+const env = parseEnv();
+
+/**
+ * Application configuration object
+ */
+export const config = {
+  /** Application version from package.json */
+  version: '1.0.0',
+
+  /** Current environment */
+  env: env.NODE_ENV,
+
+  /** Is development mode */
+  isDev: env.NODE_ENV === 'development',
+
+  /** Is production mode */
+  isProd: env.NODE_ENV === 'production',
+
+  /** Is test mode */
+  isTest: env.NODE_ENV === 'test',
+
+  /** Server configuration */
+  server: {
+    port: env.PORT,
+  },
+
+  /** Logging configuration */
+  logging: {
+    level: env.LOG_LEVEL,
+  },
+} as const;

package/cadre/templates/projet/src/errors.ts

@@ -0,0 +1,102 @@
+/**
+ * Custom error classes
+ *
+ * Define application-specific errors for better error handling.
+ */
+
+/**
+ * Base application error
+ */
+export class AppError extends Error {
+  public readonly code: string;
+  public readonly statusCode: number;
+  public readonly isOperational: boolean;
+
+  constructor(message: string, code = 'INTERNAL_ERROR', statusCode = 500, isOperational = true) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+
+    // Maintains proper stack trace
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Validation error (400)
+ */
+export class ValidationError extends AppError {
+  constructor(message: string) {
+    super(message, 'VALIDATION_ERROR', 400);
+  }
+}
+
+/**
+ * Not found error (404)
+ */
+export class NotFoundError extends AppError {
+  constructor(resource: string) {
+    super(`${resource} not found`, 'NOT_FOUND', 404);
+  }
+}
+
+/**
+ * Authentication error (401)
+ */
+export class AuthenticationError extends AppError {
+  constructor(message = 'Authentication required') {
+    super(message, 'AUTHENTICATION_ERROR', 401);
+  }
+}
+
+/**
+ * Authorization error (403)
+ */
+export class AuthorizationError extends AppError {
+  constructor(message = 'Permission denied') {
+    super(message, 'AUTHORIZATION_ERROR', 403);
+  }
+}
+
+/**
+ * Conflict error (409)
+ */
+export class ConflictError extends AppError {
+  constructor(message: string) {
+    super(message, 'CONFLICT_ERROR', 409);
+  }
+}
+
+/**
+ * Rate limit error (429)
+ */
+export class RateLimitError extends AppError {
+  constructor(message = 'Too many requests') {
+    super(message, 'RATE_LIMIT_ERROR', 429);
+  }
+}
+
+/**
+ * External service error (502)
+ */
+export class ExternalServiceError extends AppError {
+  constructor(service: string, originalError?: Error) {
+    super(
+      `External service error: ${service}${originalError ? ` - ${originalError.message}` : ''}`,
+      'EXTERNAL_SERVICE_ERROR',
+      502
+    );
+  }
+}
+
+/**
+ * Check if error is operational (expected) vs programming error
+ */
+export function isOperationalError(error: unknown): boolean {
+  if (error instanceof AppError) {
+    return error.isOperational;
+  }
+  return false;
+}

package/cadre/templates/projet/src/index.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+/**
+ * Main entry point
+ *
+ * @packageDocumentation
+ */
+
+import { config } from './config.js';
+import { logger } from './utils/logger.js';
+
+/**
+ * Main application function
+ */
+function main(): void {
+  logger.info('Application starting...', { version: config.version });
+
+  try {
+    // Initialize your application here
+    logger.info('Application started successfully');
+
+    // Keep the process running (remove if not needed)
+    // await new Promise(() => {});
+  } catch (error) {
+    logger.error('Application failed to start', { error });
+    process.exit(1);
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  logger.info('Received SIGINT, shutting down...');
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  logger.info('Received SIGTERM, shutting down...');
+  process.exit(0);
+});
+
+// Handle unhandled rejections
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled Rejection', { reason, promise });
+});
+
+// Run main
+main();

package/cadre/templates/projet/src/services/.gitkeep

@@ -0,0 +1,8 @@
+# This file keeps the empty directory in git.
+# Add your service modules here.
+#
+# Example services:
+# - api-client.ts     - External API client
+# - database.ts       - Database connection
+# - cache.ts          - Caching service
+# - queue.ts          - Message queue service

package/cadre/templates/projet/src/types/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Type definitions
+ *
+ * Export all shared types from this module.
+ */
+
+/**
+ * Generic result type for operations that can fail
+ */
+export type Result<T, E = Error> = { success: true; data: T } | { success: false; error: E };
+
+/**
+ * Create a success result
+ */
+export function success<T>(data: T): Result<T, never> {
+  return { success: true, data };
+}
+
+/**
+ * Create a failure result
+ */
+export function failure<E>(error: E): Result<never, E> {
+  return { success: false, error };
+}

package/cadre/templates/projet/src/utils/logger.ts

@@ -0,0 +1,106 @@
+/**
+ * Logger utility
+ *
+ * Simple structured logging with levels and context.
+ */
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+interface LogContext {
+  [key: string]: unknown;
+}
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+/**
+ * Get current log level from environment
+ */
+function getCurrentLevel(): LogLevel {
+  const level = process.env.LOG_LEVEL?.toLowerCase() as LogLevel;
+  return LOG_LEVELS[level] !== undefined ? level : 'info';
+}
+
+/**
+ * Format log message with timestamp and context
+ */
+function formatMessage(level: LogLevel, message: string, context?: LogContext): string {
+  const timestamp = new Date().toISOString();
+  const levelStr = level.toUpperCase().padEnd(5);
+
+  let output = `[${timestamp}] ${levelStr} ${message}`;
+
+  if (context && Object.keys(context).length > 0) {
+    output += ` ${JSON.stringify(context)}`;
+  }
+
+  return output;
+}
+
+/**
+ * Check if log level should be output
+ */
+function shouldLog(level: LogLevel): boolean {
+  return LOG_LEVELS[level] >= LOG_LEVELS[getCurrentLevel()];
+}
+
+/**
+ * Logger instance
+ */
+export const logger = {
+  /**
+   * Log debug message
+   */
+  debug(message: string, context?: LogContext): void {
+    if (shouldLog('debug')) {
+      console.debug(formatMessage('debug', message, context));
+    }
+  },
+
+  /**
+   * Log info message
+   */
+  info(message: string, context?: LogContext): void {
+    if (shouldLog('info')) {
+      console.info(formatMessage('info', message, context));
+    }
+  },
+
+  /**
+   * Log warning message
+   */
+  warn(message: string, context?: LogContext): void {
+    if (shouldLog('warn')) {
+      console.warn(formatMessage('warn', message, context));
+    }
+  },
+
+  /**
+   * Log error message
+   */
+  error(message: string, context?: LogContext): void {
+    if (shouldLog('error')) {
+      console.error(formatMessage('error', message, context));
+    }
+  },
+
+  /**
+   * Create a child logger with preset context
+   */
+  child(baseContext: LogContext) {
+    return {
+      debug: (message: string, context?: LogContext) =>
+        logger.debug(message, { ...baseContext, ...context }),
+      info: (message: string, context?: LogContext) =>
+        logger.info(message, { ...baseContext, ...context }),
+      warn: (message: string, context?: LogContext) =>
+        logger.warn(message, { ...baseContext, ...context }),
+      error: (message: string, context?: LogContext) =>
+        logger.error(message, { ...baseContext, ...context }),
+    };
+  },
+};

package/cadre/templates/projet/tests/integration/.gitkeep

@@ -0,0 +1,7 @@
+# This file keeps the empty directory in git.
+# Add your integration tests here.
+#
+# Example integration tests:
+# - api.spec.ts        - API endpoint tests
+# - database.spec.ts   - Database integration tests
+# - external.spec.ts   - External service tests

package/cadre/templates/projet/tests/unit/config.spec.ts

@@ -0,0 +1,68 @@
+/**
+ * Config module tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+describe('Config', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    // Reset modules to get fresh config
+    vi.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('environment detection', () => {
+    it('should default to development', async () => {
+      delete process.env.NODE_ENV;
+      const { config } = await import('../../src/config.js');
+      expect(config.isDev).toBe(true);
+    });
+
+    it('should detect production environment', async () => {
+      process.env.NODE_ENV = 'production';
+      const { config } = await import('../../src/config.js');
+      expect(config.isProd).toBe(true);
+      expect(config.isDev).toBe(false);
+    });
+
+    it('should detect test environment', async () => {
+      process.env.NODE_ENV = 'test';
+      const { config } = await import('../../src/config.js');
+      expect(config.isTest).toBe(true);
+    });
+  });
+
+  describe('server configuration', () => {
+    it('should use default port', async () => {
+      delete process.env.PORT;
+      const { config } = await import('../../src/config.js');
+      expect(config.server.port).toBe(3000);
+    });
+
+    it('should use custom port from environment', async () => {
+      process.env.PORT = '8080';
+      const { config } = await import('../../src/config.js');
+      expect(config.server.port).toBe(8080);
+    });
+  });
+
+  describe('logging configuration', () => {
+    it('should default to info log level', async () => {
+      delete process.env.LOG_LEVEL;
+      const { config } = await import('../../src/config.js');
+      expect(config.logging.level).toBe('info');
+    });
+
+    it('should use custom log level', async () => {
+      process.env.LOG_LEVEL = 'debug';
+      const { config } = await import('../../src/config.js');
+      expect(config.logging.level).toBe('debug');
+    });
+  });
+});

package/cadre/templates/projet/tests/unit/errors.spec.ts

@@ -0,0 +1,132 @@
+/**
+ * Error classes tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  AppError,
+  ValidationError,
+  NotFoundError,
+  AuthenticationError,
+  AuthorizationError,
+  ConflictError,
+  RateLimitError,
+  ExternalServiceError,
+  isOperationalError,
+} from '../../src/errors.js';
+
+describe('Error Classes', () => {
+  describe('AppError', () => {
+    it('should create error with default values', () => {
+      const error = new AppError('Test error');
+      expect(error.message).toBe('Test error');
+      expect(error.code).toBe('INTERNAL_ERROR');
+      expect(error.statusCode).toBe(500);
+      expect(error.isOperational).toBe(true);
+    });
+
+    it('should create error with custom values', () => {
+      const error = new AppError('Custom error', 'CUSTOM_CODE', 418, false);
+      expect(error.message).toBe('Custom error');
+      expect(error.code).toBe('CUSTOM_CODE');
+      expect(error.statusCode).toBe(418);
+      expect(error.isOperational).toBe(false);
+    });
+
+    it('should have proper stack trace', () => {
+      const error = new AppError('Test');
+      expect(error.stack).toBeDefined();
+      expect(error.stack).toContain('AppError');
+    });
+  });
+
+  describe('ValidationError', () => {
+    it('should create validation error', () => {
+      const error = new ValidationError('Invalid input');
+      expect(error.message).toBe('Invalid input');
+      expect(error.code).toBe('VALIDATION_ERROR');
+      expect(error.statusCode).toBe(400);
+    });
+  });
+
+  describe('NotFoundError', () => {
+    it('should create not found error', () => {
+      const error = new NotFoundError('User');
+      expect(error.message).toBe('User not found');
+      expect(error.code).toBe('NOT_FOUND');
+      expect(error.statusCode).toBe(404);
+    });
+  });
+
+  describe('AuthenticationError', () => {
+    it('should create authentication error with default message', () => {
+      const error = new AuthenticationError();
+      expect(error.message).toBe('Authentication required');
+      expect(error.statusCode).toBe(401);
+    });
+
+    it('should create authentication error with custom message', () => {
+      const error = new AuthenticationError('Invalid token');
+      expect(error.message).toBe('Invalid token');
+    });
+  });
+
+  describe('AuthorizationError', () => {
+    it('should create authorization error', () => {
+      const error = new AuthorizationError();
+      expect(error.message).toBe('Permission denied');
+      expect(error.statusCode).toBe(403);
+    });
+  });
+
+  describe('ConflictError', () => {
+    it('should create conflict error', () => {
+      const error = new ConflictError('Resource already exists');
+      expect(error.statusCode).toBe(409);
+    });
+  });
+
+  describe('RateLimitError', () => {
+    it('should create rate limit error', () => {
+      const error = new RateLimitError();
+      expect(error.statusCode).toBe(429);
+    });
+  });
+
+  describe('ExternalServiceError', () => {
+    it('should create external service error', () => {
+      const error = new ExternalServiceError('PaymentAPI');
+      expect(error.message).toBe('External service error: PaymentAPI');
+      expect(error.statusCode).toBe(502);
+    });
+
+    it('should include original error message', () => {
+      const original = new Error('Connection timeout');
+      const error = new ExternalServiceError('PaymentAPI', original);
+      expect(error.message).toBe('External service error: PaymentAPI - Connection timeout');
+    });
+  });
+
+  describe('isOperationalError', () => {
+    it('should return true for operational errors', () => {
+      const error = new AppError('Test', 'TEST', 400, true);
+      expect(isOperationalError(error)).toBe(true);
+    });
+
+    it('should return false for non-operational errors', () => {
+      const error = new AppError('Test', 'TEST', 500, false);
+      expect(isOperationalError(error)).toBe(false);
+    });
+
+    it('should return false for standard errors', () => {
+      const error = new Error('Standard error');
+      expect(isOperationalError(error)).toBe(false);
+    });
+
+    it('should return false for non-error values', () => {
+      expect(isOperationalError(null)).toBe(false);
+      expect(isOperationalError(undefined)).toBe(false);
+      expect(isOperationalError('string')).toBe(false);
+    });
+  });
+});