kalo-cli 0.1.2 → 0.2.27

package/generators/{ai-enhancer → ia/ai-enhancer}/index.ts

@@ -1,281 +1,319 @@
-
-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: 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);
-            }
-        }
-    ]
-    }
-};
+
+import { PlopGeneratorConfig } from 'plop';
+import { generateWithModel } from '../../utils/ai/common.ts';
+import { injectMarkers, applyGeneratedCode } from '../../utils/code-manipulation.ts';
+import { Glob } from "bun";
+import { searchChoices } from '../../utils/search.ts';
+import { findProjectRoot } from '../../utils/filesystem.ts';
+import { AI_PROVIDER_TYPES, AI_TEMP_TYPES, BACK_VALUE, EXIT_VALUE } from '../../constants.ts';
+import keywordConfig from '../docs/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) => {
+                // Extract the class name from the file path or use a default
+                const className = data.targetClass || extractClassNameFromFile(fileContent, data.filePath || '') || '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. Only include imports that are actually needed for the new code.",
+                        "2. 'replacements': exact 'search' string to find and 'replace' string to overwrite. Use for modifying existing lists/dicts. The 'search' string must match exactly as it appears in the file, including all whitespace and formatting.",
+                        "3. 'code': New methods/logic to be injected between the AI markers. Maintain the same indentation level as the surrounding code.",
+                        "4. When modifying existing code, provide the smallest possible change that accomplishes the task.",
+                        "5. Preserve existing comments and code structure unless specifically instructed to change them.",
+                        "6. Follow Python PEP 8 style guidelines.",
+                        "7. Make sure all code is syntactically correct and properly indented.",
+                        ...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: any;
+                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);
+            }
+        }
+    ]
+    }
+};
+
+// Helper function to extract class name from Python file
+function extractClassNameFromFile(fileContent: string, filePath: string): string | null {
+    // Try to extract class name from the file path first
+    const pathParts = filePath.split('/');
+    const fileName = pathParts[pathParts.length - 1]?.split('\\').pop(); // Handle both separators
+    if (fileName) {
+        const nameWithoutExt = fileName.replace('.py', '');
+        // Convert snake_case to PascalCase if needed
+        const pascalCaseName = nameWithoutExt
+            .split('_')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('');
+
+        // Check if this class exists in the file
+        const classRegex = new RegExp(`^\\s*class\\s+(${pascalCaseName})\\b`, 'm');
+        const match = fileContent.match(classRegex);
+        if (match) {
+            return match[1];
+        }
+    }
+
+    // If not found by filename, try to find any class in the file
+    const classRegex = /^(\s*)class\s+(\w+)\s*(\(|:)/m;
+    const match = fileContent.match(classRegex);
+    if (match) {
+        return match[2];
+    }
+
+    return null;
+}

package/generators/{help → ia/help}/index.ts

@@ -1,7 +1,7 @@
 
 import { PlopGeneratorConfig } from 'plop';
-import keywordConfig from '../ai-enhancer/keywords.json';
-import { EXIT_VALUE } from '../constants';
+import keywordConfig from '../docs/keywords.json';
+import { EXIT_VALUE } from '../../constants.ts';
 
 const getHelpItems = (input: string | undefined): any[] => {
     const items: any[] = [];
@@ -74,7 +74,8 @@ export const helpGenerator: PlopGeneratorConfig = {
             },
             validate: (value) => {
                 if (value === EXIT_VALUE || value?.toLowerCase() === 'exit') {
-                    process.exit(0);
+                    // process.exit(0); // Avoiding process.exit in library code, returning true to let plop handle it
+                    return true;
                 }
                 return true;
             }