kalo-cli 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# Kalo - Générateur Django & Wagtail
+
+CLI pour générer du code structuré et uniforme pour Django et Wagtail.
+
+## Prérequis
+
+Ce projet est conçu pour fonctionner avec **Bun**. Vous devez avoir [Bun](https://bun.sh) installé sur votre machine.
+
+```bash
+# Installation de Bun (Mac, Linux, WSL)
+curl -fsSL https://bun.sh/install | bash
+
+# Installation de Bun (Windows)
+powershell -c "irm bun.sh/install.ps1 | iex"
+```
+
+## Installation
+
+### Via Bun (Recommandé)
+
+```bash
+bun add -d kalo-cli
+# ou globalement
+bun add -g kalo-cli
+```
+
+
+## Utilisation
+
+### Si installé globalement
+
+```bash
+kalo
+```
+
+### 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`.
+

package/bin/kalo.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import minimist from "minimist";
+import { Plop, run } from "plop";
+import { fileURLToPath } from "node:url";
+
+const args = process.argv.slice(2);
+const argv = minimist(args);
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+Plop.prepare({
+  cwd: argv.cwd,
+  configPath: path.join(__dirname, '../plopfile.ts'),
+  preload: argv.require || [],
+  completion: argv.completion
+}, env => Plop.execute(env, (env) => run(env, undefined, true)));

package/generators/ai-enhancer/index.ts

@@ -0,0 +1,281 @@
+
+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 { 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[] = [];
+                // Scans the current directory
+                for await (const file of glob.scan(".")) {
+                    // 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) => !isBack(answers),
+            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) => !isBack(answers),
+            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) => !isBack(answers),
+            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);
+            }
+        }
+    ]
+    }
+};