kalo-cli 0.1.3 → 0.3.0

package/README.md

@@ -1,68 +1,102 @@
-# Kalo - Générateur Django & Wagtail
+# Kalo CLI - Django/Wagtail Generator
 
-CLI pour générer du code structuré et uniforme pour Django et Wagtail.
+This is a command-line interface tool for generating Django and Wagtail components using Plop.js.
 
-## Prérequis
+## Features
 
-Ce projet est conçu pour fonctionner avec **Bun**. Vous devez avoir [Bun](https://bun.sh) installé sur votre machine.
+- Generate Django models, views, forms, APIs, and more
+- Generate Wagtail pages, snippets, blocks, and other components
+- Smart file appending to avoid duplicate classes
+- Configuration loading from `kalo.config.json`
+- Project root detection
+- Searchable prompts for selecting existing apps
 
-```bash
-# Installation de Bun (Mac, Linux, WSL)
-curl -fsSL https://bun.sh/install | bash
+## Utilities
 
-# Installation de Bun (Windows)
-powershell -c "irm bun.sh/install.ps1 | iex"
-```
+The project includes several utility modules:
 
-## Installation
+### Analysis Utilities (`src/utils/analysis.ts`)
+- Functions to analyze Python files and extract class definitions
+- Used to prevent duplicate class generation
 
-### Via Bun (Recommandé)
+### Code Manipulation Utilities (`src/utils/code-manipulation.ts`)
+- Functions to inject markers in code for AI-assisted generation
+- Apply generated code with imports, replacements, and code injection
 
-```bash
-bun add -d kalo-cli
-# ou globalement
-bun add -g kalo-cli
-```
+### Configuration Utilities (`src/utils/config.ts`)
+- Load configuration from `kalo.config.json` or `kalo.config.js`
+- Support for AI providers, temperature settings, and verbosity levels
 
+### File System Utilities (`src/utils/filesystem.ts`)
+- Find project root directory
+- Resolve application paths
+- Get list of existing Django applications
+- Get files and directories within an application
 
-## Utilisation
+### Naming Conventions (`src/utils/naming-conventions.ts`)
+- Validation functions for model names, app names, and page names
+- Field validation utilities
 
-### Si installé globalement
+### Plop Actions (`src/utils/plop-actions.ts`)
+- `createAppendActions`: Creates pairs of actions to ensure files exist and append content
+- Prevents duplicate class generation by checking existing classes
 
-```bash
-kalo
-```
+### Search Utilities (`src/utils/search.ts`)
+- Fuzzy searching for autocomplete prompts
+- Filter choices based on user input
 
-### Configuration
+### String Formatting (`src/utils/index.ts`)
+- Format strings to slugs, snake_case, or PascalCase
 
-Vous pouvez personnaliser le comportement de Kalo en créant un fichier `kalo.config.json` ou `kalo.config.js` à la racine de votre projet.
+## Usage
 
-Exemple `kalo.config.json` :
+```bash
+bun run plop # List all available generators
+bun run plop model # Generate a new Django model
+bun run plop view # Generate a new Django view
+bun run plop wagtail-page # Generate a new Wagtail page
+```
+
+## Generators
+
+The project includes generators for:
+
+- Django apps
+- Django models
+- Django views
+- Django forms
+- Django APIs
+- Django QuerySets
+- Wagtail pages
+- Wagtail snippets
+- Wagtail blocks
+- Wagtail streamfields
+- Wagtail forms
+- Wagtail tags
+- Wagtail groups
+- Wagtail hooks
+- Wagtail locales
+- Wagtail admin
+- Wagtail commands
+- Wagtail templates
+- Wagtail API v2
+
+## Configuration
+
+Create a `kalo.config.json` file in your project root:
 
 ```json
 {
-  "appDir": "apps",
-  "aiProvider": "Qwen",
-  "temperature": 0.5,
-  "verbosity": "standard"
+  "aiProvider": "openai",
+  "temperature": 0.7,
+  "verbosity": "standard",
+  "appDir": "src"
 }
 ```
 
-Options disponibles :
-- `appDir` : Le dossier où se trouvent vos applications Django (par défaut: `app`).
-- `aiProvider` : Le fournisseur d'IA par défaut (`Qwen`, `Ollama`, `Mistral`, `OpenAI`).
-- `temperature` : La créativité de l'IA (entre 0 et 1).
-- `verbosity` : Le niveau de détail des commentaires générés (`minimal`, `standard`, `verbose`).
-
-### Si installé dans un projet
-
-Utilisez `bun run` ou `bunx` :
-
-```bash
-bun run kalo
-# ou
-bunx kalo
-```
-
-Si vous utilisez `npx`, assurez-vous que l'environnement peut exécuter le script (nécessite un environnement compatible avec le shebang `#!/usr/bin/env bun`, généralement Mac/Linux/WSL). Sur Windows standard, préférez `bunx`.
+## Integration Notes
 
+- The `createAppendActions` utility is now used in ALL generators (model, view, api, form, queryset, wagtail-admin, wagtail-api-v2, wagtail-block, wagtail-command, wagtail-form, wagtail-hook, wagtail-page, wagtail-snippet, wagtail-streamfield, wagtail-tag, wagtail-template) to append to existing files instead of overwriting them
+- The `plopfile.ts` now loads configuration and sets up project root detection
+- Multiple generators now use searchable prompts for app selection (api, form, queryset, wagtail-admin, wagtail-api-v2, wagtail-block, wagtail-command, wagtail-form, wagtail-hook, wagtail-snippet, wagtail-streamfield, wagtail-tag, wagtail-template)
+- File system utilities are used throughout for path resolution and app detection

package/bin/kalo.ts

@@ -4,8 +4,9 @@ import fs from "node:fs";
 import minimist from "minimist";
 import { Plop, run } from "plop";
 import { fileURLToPath } from "node:url";
-import { loadConfig } from "../generators/utils/config";
-import { findProjectRoot } from "../generators/utils/filesystem";
+import { findProjectRoot } from "../src/utils/filesystem";
+import { loadConfig } from "../src/utils/config";
+
 
 const args = process.argv.slice(2);
 const argv = minimist(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kalo-cli",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Générateur de code structuré et uniforme pour Django et Wagtail",
   "bin": {
     "kalo": "./bin/kalo.ts"
@@ -8,7 +8,10 @@
   "type": "module",
   "scripts": {
     "kalo": "bun bin/kalo.ts",
-    "doc": "bun run --port 3333 docs-site/index.html"
+    "dev": "plop --plopfile plopfile.ts",
+    "doc": "serve dist/docs -p 3333",
+    "doc:dev": "bun run --port 3333 docs-site/index.html",
+    "build": "bun scripts/build-docs.ts"
   },
   "keywords": [
     "django",
@@ -23,7 +26,8 @@
     "generators",
     "utils",
     "plopfile.ts",
-    "tsconfig.json"
+    "tsconfig.json",
+    "dist"
   ],
   "devDependencies": {
     "@types/bun": "latest"

package/plopfile.ts

@@ -1,26 +1,183 @@
-import { NodePlopAPI } from 'plop';
-import autocompletePrompt from 'inquirer-autocomplete-prompt';
-import registerGenerators from './generators/main';
-
-/**
- * Primary Plopfile entry point.
- * Registers all generators and helpers.
- *
- * @param {NodePlopAPI} plop - The Plop API instance.
- */
-export default function (plop: NodePlopAPI) {
-  // Register Prompts
-  plop.setPrompt('autocomplete', autocompletePrompt);
-
-  // Global Helpers
-    plop.setHelper('upperCase', (txt) => txt.toUpperCase());
-    plop.setHelper('snakeCase', (txt) => {
-        return txt && txt.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
-            ?.map(x => x.toLowerCase())
-            .join('_');
-    });
-
-  // --- Register Generators ---
-  // The 'main' generator module now handles registering 'main' and 'help' generators.
-  registerGenerators(plop);
-}
+import { NodePlopAPI } from 'plop';
+import { findProjectRoot } from './src/utils/filesystem';
+import { loadConfig } from './src/utils/config';
+
+// Import all generators
+import appGenerator from './src/gen/app/index';
+import modelGenerator from './src/gen/model/index';
+import viewGenerator from './src/gen/view/index';
+import formGenerator from './src/gen/form/index';
+import apiGenerator from './src/gen/api/index';
+import querysetGenerator from './src/gen/queryset/index';
+import wagtailPageGenerator from './src/gen/wagtail-page/index';
+import wagtailSnippetGenerator from './src/gen/wagtail-snippet/index';
+import wagtailBlockGenerator from './src/gen/wagtail-block/index';
+import wagtailStreamfieldGenerator from './src/gen/wagtail-streamfield/index';
+import wagtailFormGenerator from './src/gen/wagtail-form/index';
+import wagtailTagGenerator from './src/gen/wagtail-tag/index';
+import wagtailGroupGenerator from './src/gen/wagtail-group/index';
+import wagtailHookGenerator from './src/gen/wagtail-hook/index';
+import wagtailLocaleGenerator from './src/gen/wagtail-locale/index';
+import wagtailAdminGenerator from './src/gen/wagtail-admin/index';
+import wagtailCommandGenerator from './src/gen/wagtail-command/index';
+import wagtailTemplateGenerator from './src/gen/wagtail-template/index';
+import wagtailApiV2Generator from './src/gen/wagtail-api-v2/index';
+
+export default async function (plop: NodePlopAPI) {
+	// Load configuration
+	const config = await loadConfig();
+
+	// Register custom helpers
+	plop.setHelper('toPascalCase', function(str: string) {
+		if (!str) return str;
+		return str.replace(/(\w)(\w*)/g, (g0, g1, g2) => g1.toUpperCase() + g2.toLowerCase()).replace(/\W/g, '');
+	});
+	// Snake case helper to enforce snake_case filenames
+	plop.setHelper('toSnakeCase', function(str: string) {
+		if (!str) return str;
+		return String(str)
+			.replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+			.replace(/[\s\-]+/g, '_')
+			.toLowerCase();
+	});
+	// Title case for human-facing labels
+	plop.setHelper('titleCase', function(str: string) {
+		if (!str) return str;
+		return String(str)
+			.replace(/[_\-]+/g, ' ')
+			.replace(/\s+/g, ' ')
+			.trim()
+			.split(' ')
+			.map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+			.join(' ');
+	});
+	// Map generic type to Django Model Field
+	plop.setHelper('djangoModelField', function(type: string) {
+		if (!type) return 'CharField';
+		const t = String(type).toLowerCase();
+		const map: Record<string, string> = {
+			char: 'CharField',
+			text: 'TextField',
+			integer: 'IntegerField',
+			small_integer: 'SmallIntegerField',
+			positive_integer: 'PositiveIntegerField',
+			float: 'FloatField',
+			decimal: 'DecimalField',
+			boolean: 'BooleanField',
+			date: 'DateField',
+			datetime: 'DateTimeField',
+			email: 'EmailField',
+			url: 'URLField',
+			file: 'FileField',
+			image: 'ImageField',
+			uuid: 'UUIDField',
+			json: 'JSONField',
+			ip_address: 'GenericIPAddressField',
+			foreign_key: 'ForeignKey',
+			many_to_many: 'ManyToManyField',
+			one_to_one: 'OneToOneField',
+		};
+		return map[t] || (type.endsWith('Field') ? type : 'CharField');
+	});
+	// Map generic type to Django Form Field
+	plop.setHelper('djangoFormField', function(type: string) {
+		if (!type) return 'CharField';
+		const t = String(type).toLowerCase();
+		const map: Record<string, string> = {
+			char: 'CharField',
+			text: 'CharField',
+			integer: 'IntegerField',
+			float: 'FloatField',
+			decimal: 'DecimalField',
+			boolean: 'BooleanField',
+			date: 'DateField',
+			datetime: 'DateTimeField',
+			email: 'EmailField',
+			url: 'URLField',
+			file: 'FileField',
+			image: 'ImageField',
+			uuid: 'UUIDField',
+			json: 'JSONField',
+		};
+		return map[t] || (type.endsWith('Field') ? type : 'CharField');
+	});
+
+	plop.setHelper('trim', (str) => {
+		return str ? String(str).trim() : '';
+	});
+
+	plop.setHelper('eq', (a, b) => {
+		return a == b;
+	});
+
+	plop.setHelper('split', (str, separator) => {
+		return str ? String(str).split(separator) : [];
+	});
+
+	plop.setHelper('replace', (str, find, replace) => {
+		return str ? String(str).split(find).join(replace) : '';
+	});
+
+	plop.setHelper('includes', (arr, value) => {
+		if (Array.isArray(arr)) return arr.includes(value);
+		if (typeof arr === 'string') return arr.includes(value);
+		return false;
+	});
+
+	// Set the project root as a global helper
+	plop.setHelper('projectRoot', function() {
+		return findProjectRoot();
+	});
+
+	// Set configuration as a global helper
+	plop.setHelper('getConfig', function(key: string) {
+		return config[key] || null;
+	});
+
+	// Register the autocomplete prompt
+	try {
+		const autoCompletePrompt = await import('inquirer-autocomplete-prompt');
+		plop.setPrompt('autocomplete', autoCompletePrompt.default);
+	} catch (error) {
+		console.warn('inquirer-autocomplete-prompt not found. Install it to enable autocomplete prompts.');
+	}
+
+	// Register all generators
+	appGenerator(plop);
+	modelGenerator(plop);
+	viewGenerator(plop);
+	formGenerator(plop);
+	apiGenerator(plop);
+	querysetGenerator(plop);
+	wagtailPageGenerator(plop);
+	wagtailSnippetGenerator(plop);
+	wagtailBlockGenerator(plop);
+	wagtailStreamfieldGenerator(plop);
+	wagtailFormGenerator(plop);
+	wagtailTagGenerator(plop);
+	wagtailGroupGenerator(plop);
+	wagtailHookGenerator(plop);
+	wagtailLocaleGenerator(plop);
+	wagtailAdminGenerator(plop);
+	wagtailCommandGenerator(plop);
+	wagtailTemplateGenerator(plop);
+	wagtailApiV2Generator(plop);
+
+	plop.setGenerator('component', {
+		description: 'Create a new component',
+		prompts: [
+			{
+				type: 'input',
+				name: 'name',
+				message: 'Component name:'
+			}
+		],
+		actions: [
+			{
+				type: 'add',
+				path: 'src/components/{{name}}.tsx',
+				template: 'export const {{name}} = () => <div>{{name}}</div>;'
+			}
+		]
+	});
+};

package/generators/ai-enhancer/index.ts

@@ -1,283 +0,0 @@
-
-import { PlopGeneratorConfig } from 'plop';
-import { generateWithModel } from '../utils/ai/common';
-import { injectMarkers, applyGeneratedCode } from '../utils/code-manipulation';
-import { Glob } from "bun";
-import { searchChoices } from '../utils/search';
-import { findProjectRoot } from '../utils/filesystem';
-import { AI_PROVIDER_TYPES, AI_TEMP_TYPES, BACK_VALUE, EXIT_VALUE } from '../constants';
-import keywordConfig from './keywords.json';
-
-const getHelpItems = (input: string | undefined): any[] => {
-    const items: any[] = [];
-    
-    if (input) {
-        const inputLower = input.toLowerCase();
-        let lastMatchIndex = -1;
-        let matchedInstruction = null;
-
-        const keywords = Array.isArray(keywordConfig) ? keywordConfig : (keywordConfig as any).keywords || [];
-
-        for (const entry of keywords) {
-            if (entry.terms && Array.isArray(entry.terms)) {
-                for (const term of entry.terms) {
-                    const index = inputLower.lastIndexOf(term.toLowerCase());
-                    if (index !== -1 && index >= lastMatchIndex) {
-                        lastMatchIndex = index;
-                        matchedInstruction = entry.instruction;
-                    }
-                }
-            }
-        }
-
-        if (matchedInstruction) {
-            // Split instruction into lines of max 80 chars for better visibility
-            const words = matchedInstruction.split(' ');
-            let currentLine = '💡 ';
-            
-            for (const word of words) {
-                if ((currentLine + word).length > 80) {
-                    items.push({ name: currentLine, value: 'INFO', disabled: true });
-                    currentLine = '   ' + word + ' ';
-                } else {
-                    currentLine += word + ' ';
-                }
-            }
-            if (currentLine.trim()) {
-                items.push({ name: currentLine, value: 'INFO', disabled: true });
-            }
-            items.push({ name: '────────────────────────────────────────', value: 'SEP', disabled: true });
-        }
-    }
-    return items;
-};
-
-export const helpGenerator: PlopGeneratorConfig = {
-    description: 'Search for AI instructions and keywords',
-    prompts: [
-        {
-            type: 'autocomplete',
-            name: 'query',
-            message: 'Type a keyword to see associated instructions (e.g. "model", "field"):',
-            suggestOnly: true,
-            source: async (answers, input) => {
-                const choices: any[] = [];
-                
-                const helpItems = getHelpItems(input);
-                if (helpItems.length > 0) {
-                    choices.push(...helpItems);
-                }
-
-                if (!input) {
-                    choices.push({ name: 'Type to search...', value: 'INFO', disabled: true });
-                    choices.push({ name: 'Exit', value: EXIT_VALUE });
-                    return choices;
-                }
-                
-                choices.push({ name: 'Exit', value: EXIT_VALUE });
-                return choices;
-            },
-            validate: (value) => {
-                if (value === EXIT_VALUE || value?.toLowerCase() === 'exit') {
-                    return true;
-                }
-                return true;
-            }
-        }
-    ],
-    actions: []
-};
-
-const handleInput = (value: any) => {
-    if (value === EXIT_VALUE || (typeof value === 'string' && value.toLowerCase() === 'exit')) {
-        return EXIT_VALUE;
-    }
-    return value;
-};
-
-const isBack = (answers: any) => {
-    return Object.values(answers).includes(BACK_VALUE) || Object.values(answers).includes(EXIT_VALUE);
-};
-
-export const aiEnhancerGenerator: PlopGeneratorConfig = {
-    description: 'Enhance existing models with AI generated code',
-    prompts: [
-        {
-            type: 'autocomplete',
-            name: 'filePath',
-            message: 'Select the model file to enhance:',
-            source: async (answers, input) => {
-                const glob = new Glob("**/*.py");
-                const files: string[] = [];
-                const rootDir = findProjectRoot();
-                // Scans the project root
-                for await (const file of glob.scan(rootDir)) {
-                    // Filter for likely python model files or snippets
-                    if (file.endsWith('.py') && (file.includes("models") || file.includes("snippet"))) {
-                         files.push(file);
-                    }
-                }
-                const choices = files.map(f => ({ name: f, value: f }));
-                const results = await searchChoices(input, choices);
-                results.push({ name: 'Exit', value: EXIT_VALUE });
-                return results;
-            },
-            filter: handleInput
-        },
-        {
-            type: 'autocomplete',
-            name: 'instruction',
-            message: 'What modification/addition do you want to generate?',
-            when: (answers) => !isBack(answers),
-            suggestOnly: true,
-            source: async (answers, input) => {
-                // We provide a "Exit" option even for input by using autocomplete with suggestOnly
-                if (!input) return [{ name: 'Exit', value: EXIT_VALUE }];
-                return [{ name: 'Exit', value: EXIT_VALUE }];
-            },
-            validate: (value) => {
-                if (value === EXIT_VALUE || value?.toLowerCase() === 'exit') return true;
-                return value ? true : 'Instruction is required';
-            },
-            filter: handleInput
-        },
-        {
-            type: 'autocomplete',
-            name: 'aiProvider',
-            message: 'Select AI Provider:',
-            default: 'Qwen',
-            when: (answers: any) => !isBack(answers) && !answers.config?.aiProvider,
-            source: async (answers, input) => {
-                const choices = AI_PROVIDER_TYPES.map(p => ({ name: p, value: p }));
-                const results = await searchChoices(input, choices);
-                results.push({ name: 'Exit', value: EXIT_VALUE });
-                return results;
-            },
-            filter: handleInput
-        },
-        {
-            type: 'autocomplete',
-            name: 'temperature',
-            message: 'Select Creativity Level:',
-            default: 0.5,
-            when: (answers: any) => !isBack(answers) && answers.config?.temperature === undefined,
-            source: async (answers, input) => {
-                const results = await searchChoices(input, AI_TEMP_TYPES);
-                results.push({ name: 'Exit', value: EXIT_VALUE });
-                return results;
-            },
-            filter: handleInput
-        },
-        {
-            type: 'autocomplete',
-            name: 'verbosity',
-            message: 'Select Verbosity Level:',
-            default: 'standard',
-            when: (answers: any) => !isBack(answers) && !answers.config?.verbosity,
-            source: async (answers, input) => {
-                const choices = [
-                    { name: 'Minimal (Code only)', value: 'minimal' },
-                    { name: 'Standard (Code + basic comments)', value: 'standard' },
-                    { name: 'Verbose (Detailed docs)', value: 'verbose' }
-                ];
-                const results = await searchChoices(input, choices);
-                results.push({ name: 'Exit', value: EXIT_VALUE });
-                return results;
-            },
-            filter: handleInput
-        },
-        {
-            type: 'input',
-            name: 'constraints',
-            message: 'Terms to listen to / Constraints (comma separated, optional):',
-            when: (answers) => !isBack(answers),
-            filter: (value) => {
-                if (value === EXIT_VALUE || (typeof value === 'string' && value.toLowerCase() === 'exit')) {
-                    return EXIT_VALUE;
-                }
-                return value.split(',').map((s: string) => s.trim()).filter((s: string) => s.length > 0);
-            }
-        }
-    ],
-    actions: (data) => {
-        // Handle "Back" action (Abort generator)
-        if (Object.values(data).includes(BACK_VALUE) || Object.values(data).includes(EXIT_VALUE)) {
-            return [];
-        }
-
-        return [
-        {
-            type: 'modify',
-            path: '{{filePath}}',
-            transform: async (fileContent, data) => {
-                const className = data.targetClass || 'AI_GENERATED';
-                
-                // 1. Inject Markers if missing
-                const contentWithMarkers = injectMarkers(fileContent, className);
-                
-                // Keyword analysis for enhanced context
-                const keywordInstructions: string[] = [];
-                const instructionLower = data.instruction.toLowerCase();
-
-                const keywords = Array.isArray(keywordConfig) ? keywordConfig : (keywordConfig as any).keywords || [];
-                for (const keyword of keywords) {
-                    if (keyword.term && instructionLower.includes(keyword.term)) {
-                        keywordInstructions.push(keyword.instruction);
-                    } else if (keyword.terms) {
-                         if (keyword.terms.some((t: string) => instructionLower.includes(t))) {
-                             keywordInstructions.push(keyword.instruction);
-                         }
-                    }
-                }
-                
-                // Build options object
-                const options = {
-                    temperature: data.temperature,
-                    constraints: [
-                        ...(data.constraints || []),
-                        `Target Class: ${className}`,
-                        "Output Format: JSON with keys: 'imports' (string[]), 'replacements' ({search, replace}[]), 'code' (string).",
-                        "Rules:",
-                        "1. 'imports': New import statements.",
-                        "2. 'replacements': exact 'search' string to find and 'replace' string to overwrite. Use for modifying existing lists/dicts.",
-                        "3. 'code': New methods/logic to be injected into the class.",                        
-                        ...keywordInstructions
-                    ],
-                    verbosity: data.verbosity,
-                    plopContext: data,
-                    responseFormat: 'json'
-                };
-
-                let generatedResponseString = '';
-                
-                try {
-                    const providerName = data.aiProvider || 'Qwen';
-                    const modelCommand = providerName.toLowerCase();
-                    
-                    generatedResponseString = await generateWithModel(
-                        contentWithMarkers, // context
-                        data.instruction, // instruction
-                        modelCommand, 
-                        providerName, 
-                        options as any
-                    );
-                } catch (error) {
-                    console.error('AI Generation Failed:', error);
-                    return fileContent; 
-                }
-
-                let generatedData;
-                try {
-                    generatedData = JSON.parse(generatedResponseString);
-                } catch (e) {
-                    console.error('Failed to parse AI response as JSON.');
-                    return contentWithMarkers;
-                }
-
-                // 2. Apply Changes
-                return applyGeneratedCode(contentWithMarkers, generatedData, className);
-            }
-        }
-    ]
-    }
-};