kalo-cli 0.2.27 → 0.3.0

package/generators/utils/analysis.ts

@@ -1,88 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { resolveAppPaths } from './filesystem.ts';
-
-export interface AppFileInfo {
-    fileName: string;
-    filePath: string;
-    classes: string[];
-}
-
-/**
- * Analyzes the selected application to find the main file (models.py) and extract class definitions.
- * @param appName The name of the application (directory name)
- * @param config Configuration object
- * @returns AppFileInfo containing filename, absolute path, and list of class names, or null if not found.
- */
-export const analyzeAppFile = (appName: string, config?: any): AppFileInfo | null => {
-    const { appPath } = resolveAppPaths(config, appName);
-    
-    // Priority 1: models.py (Standard Django)
-    let targetFile = 'models.py';
-    let targetPath = path.join(appPath!, targetFile);
-
-    // Check if file exists
-    if (!fs.existsSync(targetPath)) {
-        return null;
-    }
-
-    const content = fs.readFileSync(targetPath, 'utf-8');
-    const classes = extractClassNames(content);
-
-    return {
-        fileName: targetFile,
-        filePath: targetPath,
-        classes: classes
-    };
-};
-
-/**
- * Analyzes a specific file within an application.
- * @param appName The name of the application
- * @param relativeFilePath The relative path of the file from the app root
- * @param config Configuration object
- * @returns AppFileInfo containing filename, absolute path, and list of class names, or null if not found.
- */
-export const analyzeFile = (appName: string, relativeFilePath: string, config?: any): AppFileInfo | null => {
-    const { appPath } = resolveAppPaths(config, appName);
-    const targetPath = path.join(appPath!, relativeFilePath);
-
-    if (!fs.existsSync(targetPath)) {
-        return null;
-    }
-
-    const content = fs.readFileSync(targetPath, 'utf-8');
-    const classes = extractClassNames(content);
-
-    return {
-        fileName: path.basename(relativeFilePath),
-        filePath: targetPath,
-        classes: classes
-    };
-};
-
-/**
- * Extracts class names from Python file content using Regex.
- * Ignores comments and handles basic indentation (though top-level is preferred).
- * @param content File content
- */
-export const extractClassNames = (content: string): string[] => {
-    // Nettoyer les commentaires pour éviter les faux positifs
-    const cleanContent = content.replace(/#.*$/gm, '');
-    
-    // Regex to match "class ClassName"
-    // ^\s*class\s+ -> start of line, optional whitespace, "class" keyword, whitespace
-    // (?<name>\w+) -> capture group for name
-    // .*?: -> match rest of line until colon (inheritance etc)
-    const classRegex = /^\s*class\s+(?<name>\w+)/gm;
-    const classes: string[] = [];
-    let match;
-
-    while ((match = classRegex.exec(cleanContent)) !== null) {
-        if (match.groups && match.groups.name && match.groups.name !== 'Meta') {
-            classes.push(match.groups.name);
-        }
-    }
-
-    return classes;
-};

package/generators/utils/code-manipulation.ts

@@ -1,229 +0,0 @@
-
-export const getMarkerStart = (className: string, context: string = 'AI_GENERATED') => `# <!-- CLASS = ${className} START ${context} -->`;
-export const getMarkerEnd = (className: string, context: string = 'AI_GENERATED') => `# <!-- CLASS = ${className} END ${context} -->`;
-
-/**
- * Injects markers into the file content to guide AI code generation.
- * Tries to place markers inside the specified class, preferably before 'class Meta' or at the top of the class.
- */
-export const injectMarkers = (fileContent: string, className: string, context?: string): string => {
-    const markerStart = getMarkerStart(className, context);
-    const markerEnd = getMarkerEnd(className, context);
-
-    // Check if markers exist
-    if (fileContent.includes(markerStart) || fileContent.includes(markerEnd)) {
-        return fileContent;
-    }
-
-    console.log(`Markers for class ${className} not found, attempting to inject...`);
-
-    // More robust regex to find class definition - handles both spaces and tabs
-    const classRegex = new RegExp(`^(\\s*)class\\s+${className}\\s*(\\(|:|$)`, 'm');
-    const classMatch = fileContent.match(classRegex);
-
-    if (classMatch) {
-        const classIndentation = classMatch[1] || '';
-        // Determine indentation based on the class definition - could be spaces or tabs
-        const nextCharAfterColon = fileContent.substr(classMatch.index! + classMatch[0].length, 1);
-        let classBodyStartIndex = classMatch.index! + classMatch[0].length;
-
-        // Skip whitespace after the colon to find the actual class body start
-        if (nextCharAfterColon === ':') {
-            classBodyStartIndex++;
-            // Skip any whitespace/newlines until the first actual content
-            while (classBodyStartIndex < fileContent.length && /\s/.test(fileContent[classBodyStartIndex])) {
-                classBodyStartIndex++;
-                if (fileContent[classBodyStartIndex] === '\n') {
-                    classBodyStartIndex++;
-                    break;
-                }
-            }
-        }
-
-        // Look for the first non-empty line after the class definition to determine indentation
-        let nextLineStart = classBodyStartIndex;
-        let nextLineEnd = fileContent.indexOf('\n', nextLineStart);
-        if (nextLineEnd === -1) nextLineEnd = fileContent.length;
-
-        let nextLine = fileContent.substring(nextLineStart, nextLineEnd);
-        let detectedIndentation = nextLine.match(/^\s*/)?.[0] || classIndentation + '    '; // Default to 4 spaces if none detected
-
-        // If the next line is empty or just whitespace, look for the first actual content line
-        if (nextLine.trim() === '') {
-            let searchIndex = nextLineEnd;
-            while (searchIndex < fileContent.length) {
-                const lineStart = searchIndex;
-                const lineEnd = fileContent.indexOf('\n', lineStart);
-
-                if (lineEnd === -1) break; // End of file
-
-                const line = fileContent.substring(lineStart, lineEnd);
-                const trimmedLine = line.trim();
-
-                if (trimmedLine !== '') {
-                    // Found a non-empty line, determine its indentation
-                    detectedIndentation = line.match(/^\s*/)?.[0] || classIndentation + '    ';
-                    break;
-                }
-
-                searchIndex = lineEnd + 1;
-            }
-        }
-
-        // Search for 'class Meta' indented relative to our class
-        const escapedIndentation = detectedIndentation ? detectedIndentation.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') : '';
-        const metaRegex = new RegExp(`^${escapedIndentation}class\\s+Meta\\s*(:|\\()`, 'm');
-        const contentAfterClassStart = fileContent.substring(classBodyStartIndex);
-        const metaMatch = contentAfterClassStart.match(metaRegex);
-
-        if (metaMatch) {
-            // Inject before class Meta
-            const absoluteMetaIndex = classBodyStartIndex + metaMatch.index!;
-            const beforeMeta = fileContent.substring(0, absoluteMetaIndex);
-            const afterMeta = fileContent.substring(absoluteMetaIndex);
-
-            return `${beforeMeta}${detectedIndentation}${markerStart}\n${detectedIndentation}${markerEnd}\n\n${afterMeta}`;
-        } else {
-            // Inject at the top of the class body
-            const injection = `\n${detectedIndentation}${markerStart}\n${detectedIndentation}${markerEnd}\n`;
-            const beforeClassBody = fileContent.substring(0, classBodyStartIndex);
-            const afterClassBody = fileContent.substring(classBodyStartIndex);
-
-            return beforeClassBody + injection + afterClassBody;
-        }
-    } else {
-        console.warn(`Class "${className}" not found in file. Appending markers to end of file.`);
-        return fileContent + `\n\n${markerStart}\n${markerEnd}\n`;
-    }
-};
-
-/**
- * Applies the AI-generated JSON response to the content.
- * Handles imports, replacements, and code injection between markers.
- */
-export const applyGeneratedCode = (contentWithMarkers: string, generatedData: any, className: string, context?: string): string => {
-    const markerStart = getMarkerStart(className, context);
-    const markerEnd = getMarkerEnd(className, context);
-
-    let newContent = contentWithMarkers;
-    const { imports = [], replacements = [], code = '' } = generatedData;
-
-    // 1. Handle Imports
-    if (imports.length > 0) {
-        const newImports = imports.filter((imp: string) => !newContent.includes(imp.trim()));
-        if (newImports.length > 0) {
-            // Find the end of existing imports section to insert new imports
-            const importSectionEnd = findImportSectionEnd(newContent);
-            if (importSectionEnd !== -1) {
-                const beforeImports = newContent.substring(0, importSectionEnd);
-                const afterImports = newContent.substring(importSectionEnd);
-                newContent = beforeImports + newImports.join('\n') + '\n' + afterImports;
-            } else {
-                // If no import section found, prepend to file
-                newContent = newImports.join('\n') + '\n' + newContent;
-            }
-        }
-    }
-
-    // 2. Handle Replacements - Use more robust replacement logic
-    if (replacements.length > 0) {
-        for (const rep of replacements) {
-            if (rep && rep.search && rep.replace !== undefined) {
-                // Use global replacement to handle multiple occurrences if needed
-                const searchPattern = new RegExp(escapeRegExp(rep.search), 'g');
-
-                if (searchPattern.test(newContent)) {
-                    newContent = newContent.replace(searchPattern, rep.replace);
-                } else {
-                    // If exact string not found, try fuzzy matching
-                    const fuzzyMatch = findFuzzyMatch(newContent, rep.search);
-                    if (fuzzyMatch) {
-                        newContent = newContent.substring(0, fuzzyMatch.start) +
-                                   rep.replace +
-                                   newContent.substring(fuzzyMatch.end);
-                    } else {
-                        console.warn(`Replacement pattern not found: "${rep.search.substring(0, 40)}..."`);
-                    }
-                }
-            }
-        }
-    }
-
-    // 3. Handle Code Injection
-    let newCode = code;
-    if (Array.isArray(newCode)) newCode = newCode.join('\n');
-
-    if (typeof newCode === 'string' && newCode.trim().length > 0) {
-        const startIdx = newContent.indexOf(markerStart);
-        const endIdx = newContent.indexOf(markerEnd);
-
-        if (startIdx !== -1 && endIdx !== -1) {
-            const prefix = newContent.substring(0, startIdx + markerStart.length);
-            const suffix = newContent.substring(endIdx);
-
-            // Detect indentation from the line before start marker
-            const lastNewLine = newContent.lastIndexOf('\n', startIdx);
-            const indentation = (lastNewLine !== -1)
-                ? newContent.substring(lastNewLine + 1, startIdx)
-                : '    ';
-
-            // Indent new code to match marker indentation
-            const indentedCode = newCode.split('\n')
-                .map(line => line.trim() ? indentation + line : line)
-                .join('\n');
-
-            return `${prefix}\n${indentedCode}\n${suffix}`;
-        }
-    }
-
-    return newContent;
-};
-
-// Helper function to find the end of import section
-function findImportSectionEnd(content: string): number {
-    // Find the end of consecutive import statements
-    const lines = content.split('\n');
-    let lastImportLine = -1;
-
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        if (line.startsWith('import ') || line.startsWith('from ')) {
-            lastImportLine = i;
-        } else if (line !== '' && !line.startsWith('#')) {
-            // Stop at first non-import, non-empty, non-comment line
-            break;
-        }
-    }
-
-    if (lastImportLine !== -1) {
-        // Return position after the last import line and any blank lines
-        for (let i = lastImportLine + 1; i < lines.length; i++) {
-            if (lines[i].trim() !== '') {
-                return content.indexOf(lines[i], content.split('\n').slice(0, i).join('\n').length + i);
-            }
-        }
-        // If import section goes to end of file, return length
-        return content.length;
-    }
-
-    return -1;
-}
-
-// Helper function for fuzzy matching
-function findFuzzyMatch(content: string, searchStr: string): { start: number; end: number } | null {
-    // Simple fuzzy matching - look for substring with some tolerance for whitespace differences
-    const normalizedSearch = searchStr.replace(/\s+/g, '\\s+');
-    const fuzzyRegex = new RegExp(normalizedSearch, 'g');
-    const match = fuzzyRegex.exec(content);
-
-    if (match) {
-        return { start: match.index, end: match.index + match[0].length };
-    }
-
-    return null;
-}
-
-// Helper function to escape special regex characters
-function escapeRegExp(string: string): string {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/generators/utils/config.ts

@@ -1,43 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { findProjectRoot } from './filesystem';
-
-export interface KaloConfig {
-  aiProvider?: string;
-  temperature?: number;
-  verbosity?: 'minimal' | 'standard' | 'verbose';
-  appDir?: string;
-  [key: string]: any;
-}
-
-/**
- * Charge la configuration à partir de kalo.config.json ou kalo.config.js
- */
-export async function loadConfig(): Promise<KaloConfig> {
-  const rootDir = findProjectRoot();
-  const jsonPath = path.join(rootDir, 'kalo.config.json');
-  const jsPath = path.join(rootDir, 'kalo.config.js');
-
-  if (fs.existsSync(jsonPath)) {
-    try {
-      const content = fs.readFileSync(jsonPath, 'utf8');
-      return JSON.parse(content);
-    } catch (e) {
-      console.error(`Erreur lors de la lecture de ${jsonPath}:`, e);
-    }
-  }
-
-  if (fs.existsSync(jsPath)) {
-    try {
-      // Utilisation de import dynamique pour le fichier .js
-      // Note: On utilise un timestamp pour éviter le cache de module si nécessaire en dev,
-      // mais ici un import simple devrait suffire.
-      const module = await import(jsPath);
-      return module.default || module;
-    } catch (e) {
-      console.error(`Erreur lors du chargement de ${jsPath}:`, e);
-    }
-  }
-
-  return {};
-}

package/generators/utils/filesystem.ts

@@ -1,131 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-/**
- * Recherche le répertoire racine du projet en remontant à partir d'un dossier donné.
- * Cherche la présence d'un fichier package.json valide (avec name et version).
- * Vérifie également les permissions d'écriture.
- *
- * @param startDir - Le dossier de départ pour la recherche.
- * @returns Le chemin absolu vers la racine du projet.
- */
-export const findProjectRoot = (startDir: string = process.cwd()): string => {
-  let currentDir = startDir;
-
-  while (currentDir !== path.parse(currentDir).root) {
-    const packageJsonPath = path.join(currentDir, 'package.json');
-    if (fs.existsSync(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        
-        // Validation basique du package.json
-        if (!pkg.name || !pkg.version) {
-            // Package.json invalide, on continue
-            currentDir = path.dirname(currentDir);
-            continue;
-        }
-
-        // Si on trouve un package.json qui n'est pas celui de kalo-cli, c'est probablement la racine du projet utilisateur
-        // Ou si on est dans un projet qui n'a pas encore de kalo-cli installé mais qui a un package.json
-        if (pkg.name !== 'kalo-cli' || currentDir.includes('node_modules')) {
-            // Si on est dans node_modules, on doit continuer à monter car on a trouvé le package.json de kalo-cli
-            if (currentDir.includes('node_modules')) {
-                 currentDir = path.dirname(currentDir);
-                 continue;
-            }
-            return currentDir;
-        }
-      } catch (e) {
-        // Erreur de lecture, on continue
-      }
-    }
-    currentDir = path.dirname(currentDir);
-  }
-  
-  // Fallback: si on ne trouve rien, on retourne le dossier courant
-  return startDir;
-};
-
-/**
- * Résout les chemins liés à l'application.
- * 
- * @param config Configuration contenant potentiellement appDir
- * @param appName Nom de l'application (optionnel)
- * @returns Objet contenant les chemins résolus
- */
-export const resolveAppPaths = (config?: any, appName?: string) => {
-    const rootDir = findProjectRoot();
-    const appDirName = config?.appDir || 'app';
-    const appDir = path.join(rootDir, appDirName);
-    const appPath = appName ? path.join(appDir, appName) : undefined;
-
-    return { rootDir, appDirName, appDir, appPath };
-};
-
-/**
- * Retrieves the list of existing Django applications in the project.
- * Scans the 'app' directory in the project root.
- *
- * @returns {string[]} An array of application names (directory names).
- * @throws {Error} If filesystem access fails (though basic read errors might propagate).
- */
-export const getAppList = (config?: any): string[] => {
-  const rootDir = findProjectRoot();
-  const appDirName = config?.appDir || 'app';
-  const appDir = path.join(rootDir, appDirName);
-  if (!fs.existsSync(appDir)) {
-    return [];
-  }
-  return fs.readdirSync(appDir, { withFileTypes: true })
-    .filter(dirent => dirent.isDirectory())
-    .map(dirent => dirent.name);
-};
-
-/**
- * Recursively lists files in an application directory with filtering.
- * Excludes test files, __init__.py, and specific directories.
- *
- * @param {string} appName - The name of the application.
- * @param {any} config - Configuration object.
- * @returns {string[]} List of relative file paths from the app root.
- */
-export const getAppFiles = (appName: string, config?: any): string[] => {
-    const rootDir = findProjectRoot();
-    const appDirName = config?.appDir || 'app';
-    const appDir = path.join(rootDir, appDirName, appName);
-    if (!fs.existsSync(appDir)) {
-        return [];
-    }
-
-    const files: string[] = [];
-    
-    const walk = (dir: string, relativePath: string) => {
-        const list = fs.readdirSync(dir, { withFileTypes: true });
-        
-        for (const dirent of list) {
-            const currentRelPath = path.join(relativePath, dirent.name);
-            const currentAbsPath = path.join(dir, dirent.name);
-
-            if (dirent.isDirectory()) {
-                // Exclude test directories and cache
-                if (!['__tests__', 'test', 'tests', '__pycache__', 'migrations'].includes(dirent.name)) {
-                    walk(currentAbsPath, currentRelPath);
-                }
-            } else {
-                // Exclude test files and __init__.py
-                if (
-                    dirent.name !== '__init__.py' &&
-                    !dirent.name.includes('__pycache__') &&
-                    !dirent.name.includes('.test.') &&
-                    !dirent.name.includes('.spec.') &&
-                    dirent.name.endsWith('.py') // Assume we only care about Python files for now based on context
-                ) {
-                    files.push(currentRelPath);
-                }
-            }
-        }
-    };
-
-    walk(appDir, '');
-    return files;
-};

package/generators/utils/index.ts

@@ -1,35 +0,0 @@
-/**
- * Utility functions for file path resolution and naming conventions.
- * Pure functions only.
- */
-
-/**
- * Formats a string into a URL-friendly slug.
- * Converts to lowercase, replaces spaces with hyphens, and removes non-word characters.
- *
- * @param {string} text - The input string to format.
- * @returns {string} The formatted slug string.
- */
-export const formatSlug = (text: string): string => 
-  text.toLowerCase().replace(/ /g, '-').replace(/[^\w-]+/g, '');
-
-/**
- * Formats a string into snake_case.
- * Converts PascalCase or camelCase to snake_case.
- *
- * @param {string} text - The input string to format.
- * @returns {string} The string in snake_case.
- */
-export const formatSnakeCase = (text: string): string =>
-  text.replace(/\.?([A-Z])/g, (x, y) => "_" + y.toLowerCase()).replace(/^_/, "");
-
-/**
- * Formats a string into PascalCase.
- * Capitalizes the first letter of each word and removes non-alphanumeric characters.
- *
- * @param {string} text - The input string to format.
- * @returns {string} The string in PascalCase.
- */
-export const formatPascalCase = (text: string): string =>
-  text.replace(/(\w)(\w*)/g, (g0, g1, g2) => g1.toUpperCase() + g2.toLowerCase()).replace(/\W/g, "");
-

package/generators/utils/plop-actions.ts

@@ -1,104 +0,0 @@
-import { ActionType } from 'plop';
-import { extractClassNames } from './analysis.ts';
-
-/**
- * Ensures a suffix is present on a name.
- *
- * @param {string} name - The name to check.
- * @param {string} suffix - The suffix to ensure.
- * @returns {string} The name with the suffix.
- */
-export const ensureSuffix = (name: string, suffix: string): string => {
-    if (name.endsWith(suffix)) return name;
-    return `${name}${suffix}`;
-};
-
-interface CreateAppendOptions {
-    path: string;
-    templateFile: string;
-    dumbData?: any;
-    appendData?: any;
-    dumbTemplateFile?: string;
-    dumbTemplate?: string;
-}
-
-/**
- * Creates a pair of actions: one to ensure the file exists (using a "dumb" template rendering or specific init template),
- * and one to append the actual content.
- *
- * @param {CreateAppendOptions} options - Configuration options.
- * @returns {ActionType[]} An array containing the add and append actions.
- */
-export const createAppendActions = ({
-    path,
-    templateFile,
-    dumbData = { name: 'Dumb' },
-    appendData,
-    dumbTemplateFile,
-    dumbTemplate
-}: CreateAppendOptions): ActionType[] => {
-    const addAction: any = {
-        type: 'add',
-        path,
-        skipIfExists: true,
-        data: dumbData,
-    };
-    
-    if (dumbTemplate) {
-        addAction.template = dumbTemplate;
-    } else {
-        addAction.templateFile = dumbTemplateFile || templateFile;
-    }
-
-    return [
-        addAction,
-        {
-            type: 'modify',
-            path,
-            transform: (content, data) => {
-                const className = data.name || data.baseName;
-                if (className) {
-                    const existingClasses = extractClassNames(content);
-                    // Check for exact class name or suffixed versions if relevant
-                    if (existingClasses.includes(className)) {
-                        console.log(`\n[SKIP] Class ${className} already exists in ${path}`);
-                        return content;
-                    }
-                    
-                    // Special case for page_pair which might have multiple classes
-                    if (data.type === 'page_pair' && data.baseName) {
-                        const indexClass = `${data.baseName}IndexPage`;
-                        const detailClass = `${data.baseName}Page`;
-                        if (existingClasses.includes(indexClass) || existingClasses.includes(detailClass)) {
-                             console.log(`\n[SKIP] Wagtail Pages for ${data.baseName} already exist in ${path}`);
-                             return content;
-                        }
-                    }
-                }
-
-                // If not skipping, we append the template
-                // Plop's modify transform doesn't automatically render templates,
-                // but since we are in a generator action, we can use the data.
-                // However, 'append' is better for just adding at the end.
-                // To keep it simple, we use a regex to append at the end of file.
-                // We use projectRoot as base for resolve if path is relative
-                const fs = require('fs');
-                const pathLib = require('path');
-                
-                // We need to find the project root or use a reliable base.
-                // In plop, the configPath usually points to the plopfile.
-                const baseDir = data.plop.getPlopfilePath() ? pathLib.dirname(data.plop.getPlopfilePath()) : process.cwd();
-
-                const fullTemplatePath = pathLib.isAbsolute(templateFile) 
-                    ? templateFile 
-                    : pathLib.resolve(baseDir, templateFile);
-                
-                const template = fs.readFileSync(fullTemplatePath, 'utf8');
-                return content.trimEnd() + '\n\n' + data.plop.renderString(
-                    template,
-                    { ...data, ...appendData }
-                );
-            }
-        }
-    ];
-};

package/generators/utils/search.ts

@@ -1,24 +0,0 @@
-/**
- * Utility for fuzzy searching/filtering choices in autocomplete prompts.
- */
-
-/**
- * Filters a list of choices based on the input string.
- * Uses simple case-insensitive substring matching.
- *
- * @param {string | null} input - The search input from the user.
- * @param {Array<{ name: string; value: any }>} choices - The list of choices to filter.
- * @returns {Promise<Array<{ name: string; value: any }>>} The filtered list of choices.
- */
-export const searchChoices = (input: string | null, choices: Array<{ name: string; value: any }>) => {
-    if (!input) {
-        return Promise.resolve(choices);
-    }
-
-    const lowerInput = input.toLowerCase();
-    const filtered = choices.filter((choice) =>
-        choice.name.toLowerCase().includes(lowerInput)
-    );
-
-    return Promise.resolve(filtered);
-};

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}