Natuurlijk! Hier is een gedetailleerde gids om een aangepaste Cursor-extensie te ontwikkelen die automatisch logstatements invoegt na elke functiedefinitie in Python, waarmee je je programmeerproductiviteit verbetert. **1. Overzicht en doelstelling** De extensie moet automatisch detecteren wanneer een functie wordt gedefinieerd en vervolgens een logstatement toevoegen direct na de functiedefinitie. Bijvoorbeeld: na `def mijn_functie():` wordt automatisch `print("Functie mijn_functie is aangeroepen")` toegevoegd. **2. Ontwerp en workflow** - **Triggerpunt:** - Detecteer het einde van een functiedefinitie. - Dit kan door te luisteren naar gebeurtenissen zoals het opslaan van een bestand of door een commando, afhankelijk van de Cursor-omgeving. - **Parsing:** - Gebruik een Python parser (bijvoorbeeld `ast` module) om de code te analyseren en functiedefinities te identificeren. - Alternatief: eenvoudige reguliere expressies kunnen werken, maar minder robuust. - **Automatische invoeging:** - Na het identificeren van een functiedefinitie, voeg je de gewenste logstatement toe direct onder de functiedefinitie, op de juiste inspringing. **3. Stappenplan voor implementatie** a. **Maak een Cursor-extensie aan:** - Volg de documentatie van Cursor om een nieuwe extensie te starten. Dit kan meestal via een basis template of een voorbeeld. b. **Code parsing en detectie:** - Implementeer een functie die de huidige buffer analyseert en alle functiedefinities vindt. - Gebruik bijvoorbeeld de `ast` module: ```python import ast def find_functions(code): tree = ast.parse(code) return [(node.name, node.lineno) for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)] ``` c. **Invoegen van logstatements:** - Voor elke gevonden functie, bepaal de regel na de functiedefinitie (`node.lineno`). - Voeg op die regel de logstatement toe met de juiste inspringing. - Bijvoorbeeld: ```python log_line = ' ' * (indent_level) + 'print("Functie {} is aangeroepen")'.format(function_name) ``` d. **Automatisering triggeren:** - Koppel deze functionaliteit aan een commando of event, zoals het opslaan van het bestand of een sneltoets. e. **Voorbeeldworkflow:** - Bij het opslaan van een Python-bestand: 1. De extensie scant de code op functies. 2. Voegt logstatements toe onder elke functie. 3. Slaat het bestand op met de nieuwe code. **4. Integratie en optimalisatie** - **Prestaties:** - Cache resultaten of beperk de analyse tot gewijzigde delen voor grote bestanden. - **Configuratie:** - Voeg opties toe voor de naam van de logstatement of het type (bijvoorbeeld met `logging` in plaats van `print`). - **Veiligheid:** - Zorg dat de extensie niet per ongeluk bestaande code overschrijft zonder bevestiging. - **Testen:** - Maak testbestanden met verschillende functies om te controleren of de logstatements correct worden toegevoegd. **5. Voorbeeld code snippet voor invoeging** Hier is een basisvoorbeeld van het toevoegen van een logstatement onder een functiedefinitie: ```python import ast def process_code(code): tree = ast.parse(code) lines = code.splitlines() new_lines = lines[:] for node in ast.walk(tree): if isinstance(node, ast.FunctionDef): lineno = node.lineno # Bepaal inspringing indent = len(lines[lineno - 1]) - len(lines[lineno - 1].lstrip()) # Maak logstatement log_stmt = ' ' * indent + 'print("Functie {} is aangeroepen")'.format(node.name) # Voeg toe onder de functiedefinitie new_lines.insert(lineno, log_stmt) return '\n'.join(new_lines) ``` **6. Documentatie en gebruik** - Documenteer hoe je de extensie installeert en activeert. - Bied opties voor het aanpassen van de logberichten. --- Met deze aanpak ontwikkel je een krachtige Cursor-extensie die je workflow automatiseert en je programmeerproductiviteit verhoogt door automatisch logstatements toe te voegen na elke Python-functie.

Hier is een gedetailleerde handleiding voor het ontwikkelen van een Cursor-extensie voor automatische logstatement-invoeging in Python: ## Architectuur en Ontwerp ### 1. Extensie Structuur ```json // package.json { "name": "python-auto-logger", "version": "1.0.0", "engines": {"vscode": "^1.60.0"}, "activationEvents": ["onLanguage:python"], "main": "./out/extension.js", "contributes": { "commands": [{ "command": "python-auto-logger.insertLog", "title": "Voeg log statement toe" }] } } ``` ### 2. Kernfunctionaliteit ```typescript // src/extension.ts import * as vscode from 'vscode'; export function activate(context: vscode.ExtensionContext) { const provider = new PythonLoggingProvider(); vscode.languages.registerCodeActionsProvider('python', provider); } class PythonLoggingProvider implements vscode.CodeActionProvider { provideCodeActions(document: vscode.TextDocument, range: vscode.Range): vscode.CodeAction[] { const actions: vscode.CodeAction[] = []; // Detecteer functiedefinities const functionPattern = /def\s+(\w+)\s*\([^)]*\)\s*:/g; const text = document.getText(); let match; while ((match = functionPattern.exec(text)) !== null) { const action = this.createLogAction(document, match[1], match.index); if (action) actions.push(action); } return actions; } private createLogAction(document: vscode.TextDocument, functionName: string, position: number): vscode.CodeAction | null { const action = new vscode.CodeAction( `Log toevoegen aan ${functionName}`, vscode.CodeActionKind.QuickFix ); action.edit = new vscode.WorkspaceEdit(); const line = document.positionAt(position).line; const insertPosition = new vscode.Position(line + 1, 0); const logStatement = ` logging.info(f"Functie ${functionName} aangeroepen")\n`; action.edit.insert(document.uri, insertPosition, logStatement); return action; } } ``` ## Integratie in Cursor ### 3. Configuratie-instellingen ```json // .cursor/rules/auto-logger.json { "name": "Auto Logger Regels", "description": "Automatische log injectie voor Python", "rules": [ { "trigger": "function_definition", "language": "python", "pattern": "def \\w+\\s*\\([^)]*\\)\\s*:", "action": "insert_after", "template": " logging.info(f\"Functie {function_name} aangeroepen\")" } ] } ``` ### 4. Snippet Definitie ```json // .vscode/snippets/python.json { "Auto Log Function": { "prefix": "deflog", "body": [ "def ${1:function_name}($2):", " logging.info(f\"Functie ${1} aangeroepen\")", " $0" ], "description": "Functie met automatische logging" } } ``` ## Geavanceerde Functionaliteit ### 5. Slimme Log Generatie ```typescript // src/smart-logger.ts class SmartLogGenerator { generateLogStatement(functionDef: string, parameters: string[]): string { const functionName = this.extractFunctionName(functionDef); if (parameters.length === 0) { return ` logging.debug("${functionName} aangeroepen zonder parameters")`; } const paramLogs = parameters.map(param => `f"${param}={${param}}"` ).join(', '); return ` logging.info(f"${functionName} aangeroepen met ${paramLogs}")`; } private extractFunctionName(functionDef: string): string { const match = functionDef.match(/def\s+(\w+)/); return match ? match[1] : 'onbekende_functie'; } } ``` ### 6. Configuratie Management ```typescript // src/config-manager.ts export class ConfigManager { private getLogLevel(): string { return vscode.workspace.getConfiguration('pythonAutoLogger') .get('defaultLogLevel', 'info'); } private getLogTemplate(): string { return vscode.workspace.getConfiguration('pythonAutoLogger') .get('logTemplate', 'Functie {function_name} aangeroepen'); } private shouldSkipFunction(functionName: string): boolean { const skipPatterns = vscode.workspace.getConfiguration('pythonAutoLogger') .get('skipPatterns', ['test_', '_test']); return skipPatterns.some(pattern => functionName.includes(pattern)); } } ``` ## Optimalisatie Tips ### 7. Performance Optimalisaties ```typescript // src/performance-optimizer.ts export class PerformanceOptimizer { private cachedFunctions = new Map<string, string>(); optimizeLogInsertion(document: vscode.TextDocument): vscode.TextEdit[] { const edits: vscode.TextEdit[] = []; const text = document.getText(); // Gebruik efficiënte regex voor grote bestanden const functionRegex = /^def\s+(\w+)\s*\([^)]*\)\s*:/gm; let match; while ((match = functionRegex.exec(text)) !== null) { const functionName = match[1]; if (this.shouldAddLogging(functionName)) { const position = document.positionAt(match.index + match[0].length); const logStatement = this.generateOptimizedLog(functionName); edits.push(vscode.TextEdit.insert(position, `\n${logStatement}`)); } } return edits; } private shouldAddLogging(functionName: string): boolean { // Skip kleine hulpfuncties return functionName.length > 2 && !functionName.startsWith('_') && !this.cachedFunctions.has(functionName); } } ``` ### 8. Context-aware Logging ```typescript // src/context-aware-logger.ts export class ContextAwareLogger { analyzeContext(document: vscode.TextDocument, functionPosition: vscode.Position): LogContext { const context: LogContext = { hasReturn: this.hasReturnStatement(document, functionPosition), hasParameters: this.hasParameters(document, functionPosition), isAsync: this.isAsyncFunction(document, functionPosition), className: this.getClassName(document, functionPosition) }; return context; } generateContextualLog(context: LogContext, functionName: string): string { if (context.className) { return ` logging.info(f"Method ${context.className}.${functionName} aangeroepen")`; } if (context.isAsync) { return ` logging.debug(f"Async functie ${functionName} gestart")`; } return ` logging.info(f"Functie ${functionName} uitgevoerd")`; } } ``` ## Implementatie Stappen ### 9. Installatie en Setup 1. **Project initialisatie:** ```bash npm init -y npm install @types/vscode typescript ``` 2. **TypeScript configuratie:** ```json // tsconfig.json { "compilerOptions": { "target": "ES2020", "lib": ["ES2020"], "module": "commonjs", "outDir": "./out", "rootDir": "./src" } } ``` 3. **Build script:** ```json // package.json "scripts": { "compile": "tsc -p ./", "watch": "tsc -watch -p ./" } ``` ### 10. Gebruik in Cursor 1. **Extensie activeren:** De extensie wordt automatisch geactiveerd bij Python-bestanden 2. **Snelkoppeling toevoegen:** ```json // keybindings.json { "key": "ctrl+shift+l", "command": "python-auto-logger.insertLog", "when": "editorLangId == python" } ``` 3. **Configuratie aanpassen:** ```json // settings.json { "pythonAutoLogger.defaultLogLevel": "debug", "pythonAutoLogger.autoInsert": true, "pythonAutoLogger.skipPatterns": ["test_", "__"] } ``` ## Best Practices ### 11. Code Kwaliteit - Gebruik consistent logging format - Voeg import statement voor logging module toe indien nodig - Respecteer bestaande code stijl - Test extensie met verschillende Python project structuren ### 12. Onderhoud - Houd extensie compatibel met Cursor updates - Documenteer alle configuratie-opties - Voorzie fallback mechanismen voor edge cases - Monitor performance in grote projecten Deze extensie zal je Python ontwikkelworkflow significant verbeteren door consistente, automatische logging toe te voegen aan al je functies, wat debugging en monitoring veel eenvoudiger maakt.