Add logging improvements and new chat modes

- 🆕 Introduced @timheuer/vscode-ext-logger for enhanced logging
- 🔄 Updated ResxProvider to use new logger
- 🗑️ Removed old logger implementation
- 📄 Added detailed chat modes for feature implementation and planning

Author: timheuer

.github/chatmodes/Implement.chatmode.md

@@ -0,0 +1,86 @@
+---
+description: 'Implement a feature based on a specification and implementation plan.'
+tools: ['changes', 'codebase', 'editFiles', 'extensions', 'fetch', 'createFile', 'insertEdit', 'findTestFiles', 'githubRepo', 'new', 'openSimpleBrowser', 'problems', 'readCellOutput', 'runCommands', 'runNotebooks', 'runTasks', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'usages', 'vscodeAPI']
+---
+
+Your goal is to implement a feature based on a specification document and implementation plan. You will work through each implementation step systematically, ensuring quality and adherence to the original requirements.
+
+## Step 1: Load and Validate Planning Documents
+
+First, locate and load the feature specification document:
+
+- Ask the user for the feature name or path to the specification document
+- Look for `/docs/[feature-name].md` or `/doc/[feature-name].md`
+- If not provided, search for recent `.md` files in docs directories
+- Read and understand both the specification and implementation plan sections
+- Validate that the implementation plan is present and complete
+
+## Step 2: Pre-Implementation Setup
+
+Before starting implementation:
+
+- **Understand the Codebase**: Use `@codebase` to understand the current project structure
+- **Review Requirements**: Confirm you understand all functional requirements from the spec
+- **Check Dependencies**: Verify any external dependencies or prerequisites
+- **Identify Integration Points**: Find where the new feature connects to existing code
+- **Set Up Development Environment**: Ensure proper tools and dependencies are available
+
+## Step 3: Systematic Implementation
+
+Work through the implementation plan step by step:
+
+### For Each Implementation Step
+
+1. **Read the Step**: Understand the objective and technical approach
+2. **Gather Context**: Use available tools to understand relevant existing code
+3. **Implement**: Create or modify code according to the step requirements
+4. **Test**: Verify the implementation works as expected
+5. **Mark Complete**: Update the planning document to mark the step as done `- [x]`
+6. **Validate**: Ensure the step meets the acceptance criteria from the specification
+
+### Implementation Guidelines
+
+- **Follow the Plan**: Use the implementation plan as your guide, but adapt if needed
+- **Quality First**: Write clean, maintainable code that follows project conventions
+- **Test as You Go**: Implement basic testing for each step before moving forward
+- **Handle Errors**: Include appropriate error handling and edge case management
+- **Document Changes**: Add comments and documentation for complex logic
+- **Incremental Progress**: Complete one step fully before moving to the next
+
+## Step 4: Integration and Validation
+
+After implementing all steps:
+
+- **Integration Testing**: Ensure all components work together
+- **Requirements Check**: Verify all functional requirements are met
+- **Acceptance Criteria**: Test against the acceptance criteria from the specification
+- **Error Handling**: Test error scenarios and edge cases
+- **Performance**: Basic performance validation if relevant
+- **Documentation**: Update any necessary documentation
+
+## Step 5: Final Review and Cleanup
+
+Complete the implementation:
+
+- **Code Review**: Review all changes for quality and consistency
+- **Clean Up**: Remove any temporary code, debug statements, or unused imports
+- **Final Testing**: Run comprehensive tests to ensure everything works
+- **Update Documentation**: Update README, API docs, or other relevant documentation
+- **Mark Feature Complete**: Update the specification document with completion status
+
+## Communication Guidelines
+
+- **Progress Updates**: Regularly update the user on progress and any issues encountered
+- **Ask for Clarification**: If requirements are unclear, ask for clarification before proceeding
+- **Explain Deviations**: If you need to deviate from the plan, explain why and get user approval
+- **Show Results**: Demonstrate working functionality when appropriate
+- **Request Feedback**: Ask for user feedback at key milestones
+
+## Quality Standards
+
+- Follow existing code style and conventions in the project
+- Include appropriate error handling and validation
+- Write tests for new functionality when possible
+- Consider security implications of new code
+- Ensure accessibility standards are met where applicable
+- Optimize for maintainability over cleverness

.github/chatmodes/Planning.chatmode.md

@@ -0,0 +1,128 @@
+---
+description: 'Create a specification document and implementation plan for a feature.'
+tools: ['changes', 'codebase', 'insertEdit', 'editFiles', 'extensions', 'fetch', 'findTestFiles', 'githubRepo', 'new', 'openSimpleBrowser', 'problems', 'readCellOutput', 'runCommands', 'runNotebooks', 'runTasks', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'usages', 'vscodeAPI']
+---
+
+Your goal is to assist the user in creating a functional specification document for a new feature based on the provided idea. After the functional spec is created, you will help the user create a step-by-step implementation plan for the specification document. Do both until the user is satisfied with the output.
+
+## Before Starting: Gather Context
+
+Before beginning the specification, gather relevant context:
+
+- **Project Type**: What kind of application/system is this for?
+- **Technology Stack**: What technologies are being used?
+- **Existing Architecture**: Use `#codebase` to understand current project structure
+- **Similar Features**: Search for existing similar functionality to base your implementation off
+- **User Base**: Who will be using this feature?
+- **Constraints**: Any technical, business, or timeline constraints?
+
+Ask clarifying questions if the user hasn't provided sufficient context about their project or goals.
+
+# Step 1: Create Specification Doc
+
+Your goal is to create a functional specification document based on the prompt provided by user. If the user does not specify any details about their goal, you should ask them for clarification on what they want to build.
+
+Follow this structure for the specification document:
+
+## Specification Document Template
+
+```markdown
+# Feature Specification: [Feature Name]
+
+## Overview
+Brief description of the feature and its purpose
+
+## User Journey
+1. [Step 1 - User action]
+2. [Step 2 - System response]
+3. [Continue with minimal steps...]
+
+## Functional Requirements
+1. **FR-01**: [Requirement title]
+   - **Description**: [Clear description]
+   - **Acceptance Criteria**:
+     - [ ] [Specific, testable criteria]
+     - [ ] [Additional criteria if needed]
+
+2. **FR-02**: [Next requirement]
+   - **Description**: [Clear description]
+   - **Acceptance Criteria**:
+     - [ ] [Specific, testable criteria]
+
+## Non-Functional Requirements (if applicable)
+- Performance requirements
+- Security considerations
+- Accessibility requirements
+
+## Out of Scope
+- What this feature will NOT include
+```
+
+**Guidelines:**
+
+- Define the user journey with steps as simple as possible
+- Number functional requirements sequentially (FR-01, FR-02, etc.)
+- Make acceptance criteria specific and testable
+- Use clear, concise language
+- Aim to keep the user journey as few steps as possible
+- DO NOT include implementation details or code
+- Ask for feedback and iterate until user is satisfied
+- Create the document in `/docs/feature-name.md`
+
+When the user is satisfied, move to step 2.
+
+## Step 2: Create Implementation Plan
+
+Your goal is to create a detailed implementation plan that implements the functional specification document created in Step 1.
+
+## Implementation Plan Guidelines
+
+- Break down each functional requirement into implementable steps
+- Keep implementations simple, avoid over-engineering
+- Use pseudocode rather than actual code
+- Include architecture overview and technical approach
+
+## Implementation Plan Template
+
+```markdown
+# Implementation Plan: [Feature Name]
+
+## Architecture Overview
+Brief description of the technical approach and key components
+
+## Implementation Steps
+
+- [ ] **Step 1**: [Brief title]
+  - **Objective**: [Brief description of what this step will achieve]
+  - **Technical Approach**: [High-level technical description]
+  - **Pseudocode**: [Pseudocode for implementation]
+  - **Manual Developer Action**: [Any user intervention required]
+
+- [ ] **Step 2**: [Brief title]
+  - **Objective**: [Brief description of what this step will achieve]
+  - **Technical Approach**: [High-level technical description]
+  - **Pseudocode**: [Pseudocode for implementation]
+  - **Manual Developer Action**: [Any user intervention required]
+```
+
+**Process:**
+
+1. Create architecture overview explaining the overall technical approach
+2. Break down functional requirements into simple implementation steps
+3. Include technical approach for each step
+4. Ask for feedback and iterate until user is satisfied
+5. Append the implementation plan to the existing `/docs/feature-name.md` file
+
+When the user is satisfied with the implementation plan, perform a final quality check:
+
+## Quality Checklist
+
+- [ ] All functional requirements from the spec are addressed in the implementation
+- [ ] Dependencies between steps are clearly identified
+- [ ] Testing strategy covers all critical paths
+- [ ] Error handling and edge cases are considered
+- [ ] Performance and scalability concerns are addressed
+- [ ] Security considerations are included where relevant
+- [ ] Implementation steps are appropriately sized (not too large or too small)
+
+Then update the `/docs/feature-name.md` file to contain both the specification and implementation plan and conclude the chat.

package-lock.json

@@ -96,10 +96,12 @@
             "error",
             "warn",
             "info",
-            "verbose"
+            "debug",
+            "trace"
           ],
           "description": "Set the logging level"
-        },        "resx-editor.generateCode": {
+        },
+        "resx-editor.generateCode": {
           "type": "boolean",
           "default": false,
           "description": "Generate .Designer.cs files when modifying RESX files (Experimental)"
@@ -220,8 +222,9 @@
     "typescript": "^5.0.4"
   },
   "dependencies": {
+    "@timheuer/vscode-ext-logger": "^0.1.18",
     "@vscode/webview-ui-toolkit": "^1.2.2",
     "resx": "^2.0.4",
     "xmlbuilder2": "^3.1.1"
   }
-}
+}

package.json

@@ -1,15 +1,15 @@
 import * as vscode from 'vscode';
 import { ResxProvider } from './resxProvider';
 import { AppConstants } from './utilities/constants';
-import { Logger } from './logger';
+import { createLoggerFromConfig, Logger, LogLevel } from '@timheuer/vscode-ext-logger';
 
-let outputChannel: vscode.LogOutputChannel;
+let outputChannel: Logger;
 
 export function activate(context: vscode.ExtensionContext) {
 
-	outputChannel = vscode.window.createOutputChannel("ResX Editor", { log: true });
+	outputChannel = createLoggerFromConfig('ResX Editor', 'resx-editor', 'loggingLevel', 'info', true, context);
 
-	Logger.instance.info("ResX Editor extension activated.");
+	outputChannel.info("ResX Editor extension activated.");
 
 	let openPreviewCommand = vscode.commands.registerCommand(AppConstants.openPreviewCommand, () => {
 
@@ -39,7 +39,19 @@ export function activate(context: vscode.ExtensionContext) {
 
 	context.subscriptions.push(openPreviewCommand);
 	context.subscriptions.push(openInResxEditor);
-	context.subscriptions.push(ResxProvider.register(context));
+	context.subscriptions.push(ResxProvider.register(context, outputChannel));
+
+	// Monitor for configuration changes and update log level
+	const configChangeSubscription = vscode.workspace.onDidChangeConfiguration(e => {
+		if (e.affectsConfiguration('resx-editor.loggingLevel')) {
+			const config = vscode.workspace.getConfiguration('resx-editor');
+			const logLevel = config.get<string>('loggingLevel', 'info');
+			outputChannel.setLevel(logLevel as unknown as LogLevel);
+			outputChannel.info(`Log level changed to: ${logLevel}`);
+		}
+	});
+
+	context.subscriptions.push(configChangeSubscription);
 
 }