kalo-cli 0.1.0

package/generators/main/index.ts

@@ -0,0 +1,429 @@
+import { NodePlopAPI, PlopGeneratorConfig } from 'plop';
+import { djangoAppGenerator } from '../django-app';
+import { wagtailPageGenerator } from '../wagtail-page';
+import { wagtailBlockGenerator } from '../wagtail-block';
+import { djangoViewGenerator } from '../django-view';
+import { djangoFormGenerator } from '../django-form';
+import { wagtailAdminGenerator } from '../wagtail-admin';
+import { djangoChannelGenerator } from '../django-channel';
+import { aiEnhancerGenerator } from '../ai-enhancer';
+import keywordConfig from '../ai-enhancer/keywords.json';
+import { getAppList, getAppFiles } from '../utils/filesystem';
+import { analyzeAppFile, analyzeFile } from '../utils/analysis';
+import { searchChoices } from '../utils/search';
+import { 
+    MAIN_COMPONENT_TYPES, 
+    VIEW_TYPES, 
+    FORM_TYPES, 
+    ADMIN_EXT_TYPES, 
+    CHANNEL_TYPES, 
+    AI_PROVIDER_TYPES, 
+    AI_TEMP_TYPES,
+    EXIT_VALUE 
+} from '../constants';
+
+/**
+ * Main Generator Configuration (Interactive CLI).
+ * Acts as the entry point for the interactive wizard.
+ * Routes user choices to specific sub-generators (App, Page, Block, View, etc.).
+ * Handles creating new apps, adding components, and modifying existing code.
+ *
+ * @type {PlopGeneratorConfig}
+ */
+
+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;
+};
+
+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 mainGenerator: PlopGeneratorConfig = {
+    description: 'CLI Interactif pour créer ou éditer des composants Django/Wagtail',
+    prompts: [
+      // Step 1: Mode Selection
+      {
+        type: 'list',
+        name: 'mode',
+        message: 'Que voulez-vous faire ?',
+        choices: [
+          { name: 'Créer une nouvelle application Django', value: 'create' },
+          { name: 'Ajouter des fichiers/fonctionnalités à une application', value: 'add' },
+          { name: 'Modifier un fichier d\'une application via IA', value: 'modify' },
+          { name: 'Aide / Rechercher des instructions IA', value: 'help' },
+          { name: 'Ouvrir la documentation', value: 'docs' },
+        ],
+      },
+      
+      // Step 2a: Create - App Name
+      {
+        type: 'input',
+        name: 'appName',
+        message: 'Nom de la nouvelle application Django :',
+        when: (answers) => answers.mode === 'create',
+        validate: (value) => (/.+/.test(value) ? true : 'Le nom de l\'application est requis'),
+      },
+
+      // Step 2b: Add/Modify - Select App
+      {
+        type: 'autocomplete',
+        name: 'selectedApp',
+        message: 'Sélectionnez l\'application cible :',
+        when: (answers) => ['add', 'modify'].includes(answers.mode),
+        source: (answers, input) => {
+          const apps = getAppList();
+          if (apps.length === 0) {
+            return Promise.resolve([{ name: 'Aucune application trouvée', value: null }]);
+          }
+          const appChoices = apps.map(app => ({ name: app, value: app }));
+          return searchChoices(input, appChoices);
+        },
+        filter: (input) => {
+            if (!input) return null;
+            // Only analyze default models.py if we are NOT in modify mode (or as fallback)
+            // But for 'add' mode, we might want it. For 'modify', we will select file explicitly.
+            const info = analyzeAppFile(input);
+            return { name: input, info };
+        }
+      },
+
+      // Step 3: Add - Component Type
+      {
+        type: 'autocomplete',
+        name: 'componentType',
+        message: 'Que voulez-vous ajouter ?',
+        when: (answers) => answers.mode === 'add' && answers.selectedApp !== null,
+        source: (answers, input) => {
+            // Filter out 'ai_enhancer' as it is covered by 'modify' mode
+            const choices = MAIN_COMPONENT_TYPES.filter(c => c.value !== 'ai_enhancer');
+            // Add Help option
+            choices.push({ name: 'Aide / Rechercher des instructions IA', value: 'help' });
+            return searchChoices(input, choices);
+        },
+      },
+      
+      // --- SUB-TYPE PROMPTS (Only for 'add' mode) ---
+
+      // View Types
+      {
+          type: 'autocomplete',
+          name: 'viewType',
+          message: 'Quel type de vue voulez-vous créer ?',
+          when: (answers) => answers.mode === 'add' && answers.componentType === 'view',
+          source: (answers, input) => searchChoices(input, VIEW_TYPES),
+      },
+
+      // Form Types
+      {
+          type: 'autocomplete',
+          name: 'formType',
+          message: 'Quel type de formulaire voulez-vous créer ?',
+          when: (answers) => answers.mode === 'add' && answers.componentType === 'form',
+          source: (answers, input) => searchChoices(input, FORM_TYPES),
+      },
+      {
+        type: 'input',
+        name: 'associatedModel',
+        message: 'Nom du Modèle associé (ex: UserProfile) :',
+        when: (answers) => answers.mode === 'add' && answers.componentType === 'form' && answers.formType === 'model_form',
+      },
+
+      // Admin Extension Types
+      {
+          type: 'autocomplete',
+          name: 'adminExtType',
+          message: 'Quel type d\'extension voulez-vous créer ?',
+          when: (answers) => answers.mode === 'add' && answers.componentType === 'admin_ext',
+          source: (answers, input) => searchChoices(input, ADMIN_EXT_TYPES),
+      },
+
+      // Channel Types
+      {
+          type: 'autocomplete',
+          name: 'channelType',
+          message: 'Quel type de consumer ?',
+          when: (answers) => answers.mode === 'add' && answers.componentType === 'channel',
+          source: (answers, input) => searchChoices(input, CHANNEL_TYPES),
+      },
+      {
+        type: 'input',
+        name: 'channelRoute',
+        message: 'Préfixe de la route URL (ex: chat) :',
+        when: (answers) => answers.mode === 'add' && answers.componentType === 'channel',
+        default: 'chat',
+      },
+
+      // --- MODIFY (AI ENHANCER) PROMPTS ---
+      {
+        type: 'autocomplete',
+        name: 'selectedFile',
+        message: 'Sélectionnez le fichier à modifier :',
+        when: (answers) => answers.mode === 'modify' && answers.selectedApp !== null,
+        source: (answers, input) => {
+            const appName = answers.selectedApp.name || answers.selectedApp;
+            const files = getAppFiles(appName);
+            
+            const choices = [];
+            if (files.length > 0) {
+                 choices.push(...files.map(f => ({ name: f, value: f })));
+            } else {
+                 choices.push({ name: 'Aucun fichier modifiable trouvé', value: null });
+            }
+            
+            // Add Help option
+            choices.push({ name: 'Aide / Rechercher des instructions IA', value: 'help' });
+            
+            return searchChoices(input, choices);
+        },
+      },
+      {
+        type: 'autocomplete',
+        name: 'targetClass',
+        message: 'Sélectionnez la classe à modifier :',
+        when: (answers) => answers.mode === 'modify' && answers.selectedFile !== null && answers.selectedFile !== 'help',
+        source: (answers, input) => {
+            const appName = answers.selectedApp.name || answers.selectedApp;
+            const filePath = answers.selectedFile;
+            
+            const info = analyzeFile(appName, filePath);
+            if (!info || !info.classes || info.classes.length === 0) {
+                return Promise.resolve([{ name: 'Aucune classe trouvée (ou fichier vide)', value: null }]);
+            }
+            const classChoices = info.classes.map((cls: string) => ({ name: cls, value: cls }));
+            return searchChoices(input, classChoices);
+        },
+      },
+      {
+        type: 'input',
+        name: 'instruction',
+        message: 'Quelle modification/ajout voulez-vous générer ?',
+        when: (answers) => answers.mode === 'modify' && answers.targetClass !== null && answers.selectedFile !== 'help',
+        validate: (value) => value ? true : 'Instruction requise'
+      },
+      {
+        type: 'list',
+        name: 'aiProvider',
+        message: 'Sélectionnez le fournisseur IA :',
+        when: (answers) => answers.mode === 'modify' && answers.targetClass !== null && answers.selectedFile !== 'help',
+        choices: AI_PROVIDER_TYPES,
+        default: 'Qwen'
+      },
+      {
+        type: 'list',
+        name: 'temperature',
+        message: 'Niveau de créativité :',
+        when: (answers) => answers.mode === 'modify' && answers.targetClass !== null && answers.selectedFile !== 'help',
+        choices: AI_TEMP_TYPES,
+        default: 0.5
+      },
+      {
+        type: 'list',
+        name: 'verbosity',
+        message: 'Niveau de verbosité :',
+        when: (answers) => answers.mode === 'modify' && answers.targetClass !== null && answers.selectedFile !== 'help',
+        choices: [
+            { name: 'Minimal (Code seulement)', value: 'minimal' },
+            { name: 'Standard (Code + commentaires basiques)', value: 'standard' },
+            { name: 'Verbeux (Documentation détaillée)', value: 'verbose' }
+        ],
+        default: 'standard'
+      },
+      {
+        type: 'input',
+        name: 'constraints',
+        message: 'Contraintes (ex: "pas de commentaires", "utiliser snake_case", "docstring en français") :',
+        when: (answers) => answers.mode === 'modify' && answers.targetClass !== null && answers.selectedFile !== 'help',
+        filter: (value) => value ? value.split(',').map((s: string) => s.trim()).filter((s: string) => s.length > 0) : []
+      },
+
+      // Step 4: Component Name (For 'add' mode)
+      {
+        type: 'input',
+        name: 'componentName',
+        message: (answers) => {
+           const type = answers.componentType || 'Composant';
+           return `Nom du ${type.charAt(0).toUpperCase() + type.slice(1)} :`;
+        },
+        when: (answers) => answers.mode === 'add' && answers.selectedApp !== null && answers.componentType !== 'help',
+        validate: (value) => (/.+/.test(value) ? true : 'Le nom est requis'),
+      },
+
+      // --- HELP PROMPT (Reused from helpGenerator) ---
+      {
+        ...helpGenerator.prompts[0],
+        name: 'helpQuery', // Rename to avoid conflict if needed, though 'query' is fine
+        when: (answers) => 
+            answers.mode === 'help' || 
+            answers.componentType === 'help' || 
+            answers.selectedFile === 'help'
+      }
+    ],
+    actions: (data) => {
+      let generatorActions = [];
+
+      // Check for help mode first
+      if (data.mode === 'help' || data.componentType === 'help' || data.selectedFile === 'help') {
+         // Help actions (empty usually, as interaction is in prompt)
+         return []; 
+      }
+
+      if (data.mode === 'docs') {
+         return docsGenerator.actions;
+      }
+
+      if (data.mode === 'create') {
+        // --- 1. Create New App ---
+        data.name = data.appName;
+        const genActions = djangoAppGenerator.actions;
+        generatorActions = typeof genActions === 'function' ? genActions(data) : genActions;
+
+      } else if (data.mode === 'add' && data.selectedApp) {
+        // --- 2. Add Component to Existing App ---
+        data.app = data.selectedApp.name || data.selectedApp;
+        data.name = data.componentName;
+
+        let targetGenerator;
+        
+        if (['page_pair', 'snippet', 'orderable', 'model'].includes(data.componentType)) {
+            targetGenerator = wagtailPageGenerator;
+            data.type = data.componentType; 
+        } else if (data.componentType === 'block') {
+            targetGenerator = wagtailBlockGenerator;
+        } else if (data.componentType === 'view') {
+            targetGenerator = djangoViewGenerator;
+            data.type = data.viewType;
+        } else if (data.componentType === 'form') {
+            targetGenerator = djangoFormGenerator;
+            data.type = data.formType;
+            data.model = data.associatedModel;
+        } else if (data.componentType === 'admin_ext') {
+            targetGenerator = wagtailAdminGenerator;
+            data.type = data.adminExtType;
+        } else if (data.componentType === 'channel') {
+            targetGenerator = djangoChannelGenerator;
+            data.type = data.channelType;
+            data.route = data.channelRoute;
+        }
+
+        if (targetGenerator) {
+             const genActions = targetGenerator.actions;
+             generatorActions = typeof genActions === 'function' ? genActions(data) : genActions;
+        }
+
+      } else if (data.mode === 'modify' && data.selectedApp && data.selectedFile) {
+        // --- 3. Modify Existing App (AI) ---
+        data.app = data.selectedApp.name || data.selectedApp;
+        
+        // Use the selected file path. analyzeFile returns relative path in 'fileName' prompt? No.
+        // getAppFiles returns relative path from app root.
+        // We need full path for the AI generator.
+        const appName = data.app;
+        const relativePath = data.selectedFile;
+        // We need to reconstruct absolute path or use analyzeFile to get it again.
+        // Or simply construct it here.
+        // We need 'filePath' for aiEnhancer.
+        // Let's use analyzeFile logic or just path.join.
+        // Ideally we should have passed the info object in the prompt but inquirer is tricky with dependent values.
+        
+        // Re-analyze or just build path?
+        // Since we are in node environment here, we can use path module.
+        // However, Plop actions run in a context where we might not have 'path' easily unless we import it.
+        // We can use the analyzeFile helper again if needed, or just hardcode construction.
+        // Since we imported analyzeFile, we can use it.
+        const fileInfo = analyzeFile(appName, relativePath);
+        if (fileInfo) {
+            data.filePath = fileInfo.filePath;
+        } else {
+            // Fallback
+            data.filePath = `app/${appName}/${relativePath}`;
+        }
+        
+        const targetGenerator = aiEnhancerGenerator;
+        const genActions = targetGenerator.actions;
+        generatorActions = typeof genActions === 'function' ? genActions(data) : genActions;
+      }
+      
+      return generatorActions;
+    },
+  };
+
+import { docsGenerator } from '../docs';
+
+export default function (plop: NodePlopAPI) {
+    plop.setGenerator('generator', mainGenerator);
+    plop.setGenerator('help', helpGenerator);
+    plop.setGenerator('docs', docsGenerator);
+}

package/generators/utils/ai/common.ts

@@ -0,0 +1,141 @@
+import { spawn } from 'child_process';
+
+export interface GenerateOptions {
+    temperature?: number;
+    constraints?: string[];
+    plopContext?: Record<string, any>;
+    verbosity?: 'minimal' | 'standard' | 'verbose';
+    responseFormat?: 'text' | 'json';
+}
+
+export const generateWithModel = async (
+    context: string, 
+    instruction: string, 
+    modelCommand: string,
+    modelDisplayName: string,
+    options: GenerateOptions = {}
+) => {
+    const { temperature, constraints, plopContext, verbosity, responseFormat } = options;
+
+    // Determine verbosity rules
+    let verbosityRules: string[] = [];
+    if (verbosity === 'minimal') {
+        verbosityRules = [
+            "Output minimal code. No comments, no docstrings unless strictly required.",
+            "Do NOT repeat existing code or context.",
+            "Return ONLY the specific function/class/snippet requested."
+        ];
+    } else if (verbosity === 'verbose') {
+        verbosityRules = [
+            "Include detailed docstrings and comments explaining complex logic.",
+            "Ensure code is fully documented."
+        ];
+    } else {
+        // Standard
+        verbosityRules = [
+            "Include standard docstrings and necessary comments.",
+            "Do NOT repeat existing code unless necessary for context."
+        ];
+    }
+
+    const isJsonFormat = responseFormat === 'json';
+    const outputRule = isJsonFormat 
+        ? "Output MUST be a valid JSON object. Do NOT wrap in markdown." 
+        : "Output ONLY the raw Python code. Do NOT include markdown formatting (no ```python blocks).";
+
+    // Construct a structured JSON prompt
+    const promptObject = {
+        meta: {
+            task: "Code Generation",
+            language: "Python",
+            mode: "Strict",
+            description: "Generate precise, deterministic Python code based on the provided context and instruction.",
+            rules: [
+                outputRule,
+                "Do NOT include the markers in the output.",
+                "Be strictly deterministic. Avoid creativity unless explicitly requested.",
+                "Follow PEP 8 standards.",
+                ...verbosityRules
+            ]
+        },
+        input: {
+            instruction: instruction,
+            file_context: context,
+            generator_context: plopContext || {},
+            constraints: constraints || []
+        },
+        style: {
+            temperature: temperature ?? 0.1, // Default to strict (low temperature)
+            tone: "Technical, Precise, Concise"
+        }
+    };
+
+    // Override style description based on temperature if provided
+    if (temperature !== undefined) {
+        if (temperature < 0.3) promptObject.style.tone = "Strict, Deterministic, Precise";
+        else if (temperature > 0.7) promptObject.style.tone = "Creative, Exploratory";
+        else promptObject.style.tone = "Balanced, Standard";
+    }
+
+    const promptString = JSON.stringify(promptObject, null, 2);
+    
+    // Wrap the JSON in a clear instruction for the model to parse it
+    const finalPrompt = `You are a strict code generator. Parse the following JSON input and execute the task described in 'input.instruction' using the context provided.
+${isJsonFormat ? "Output MUST be a valid JSON string with no extra text or markdown." : "Output ONLY the generated code string, with no markdown."}
+
+JSON_INPUT:
+${promptString}
+`;
+
+    return new Promise((resolve, reject) => {
+        console.log(`Executing: ${modelCommand} (with JSON structured input)`);
+        
+        const child = spawn(modelCommand, [], { 
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe'] 
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        child.on('error', (error) => {
+            console.error(`Error spawning ${modelDisplayName}:`, error);
+            reject(error);
+        });
+
+        child.on('close', (code) => {
+            if (code === 0) {
+                // Try to clean up any potential markdown if the model ignored instructions
+                let cleanOutput = stdout.trim();
+                if (cleanOutput.startsWith('```json')) {
+                    cleanOutput = cleanOutput.replace(/^```json\s*/, '').replace(/\s*```$/, '');
+                } else if (cleanOutput.startsWith('```python')) {
+                    cleanOutput = cleanOutput.replace(/^```python\s*/, '').replace(/\s*```$/, '');
+                } else if (cleanOutput.startsWith('```')) {
+                    cleanOutput = cleanOutput.replace(/^```\s*/, '').replace(/\s*```$/, '');
+                }
+                resolve(cleanOutput);
+            } else {
+                console.error(`Error in ${modelDisplayName} generation (code ${code}):`, stderr);
+                reject(new Error(`Process exited with code ${code}: ${stderr}`));
+            }
+        });
+
+        // Write prompt to stdin and close it to signal end of input
+        try {
+            child.stdin.write(finalPrompt);
+            child.stdin.end();
+        } catch (error) {
+             console.error(`Error writing to stdin of ${modelDisplayName}:`, error);
+             reject(error);
+        }
+    });
+};

package/generators/utils/ai/index.ts

@@ -0,0 +1,2 @@
+
+export * from './common';

package/generators/utils/analysis.ts

@@ -0,0 +1,82 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+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)
+ * @returns AppFileInfo containing filename, absolute path, and list of class names, or null if not found.
+ */
+export const analyzeAppFile = (appName: string): AppFileInfo | null => {
+    const appDir = path.join(process.cwd(), 'app', appName);
+    
+    // Priority 1: models.py (Standard Django)
+    let targetFile = 'models.py';
+    let targetPath = path.join(appDir, 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
+ * @returns AppFileInfo containing filename, absolute path, and list of class names, or null if not found.
+ */
+export const analyzeFile = (appName: string, relativeFilePath: string): AppFileInfo | null => {
+    const appDir = path.join(process.cwd(), 'app', appName);
+    const targetPath = path.join(appDir, 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[] => {
+    // 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(content)) !== null) {
+        if (match.groups && match.groups.name && match.groups.name !== 'Meta') {
+            classes.push(match.groups.name);
+        }
+    }
+
+    return classes;
+};