microsoft
diff --git a/‎.github/instructions/memory-bank.instructions.md‎
Lines changed: 81 additions & 0 deletions b/‎.github/instructions/memory-bank.instructions.md‎
Lines changed: 81 additions & 0 deletions
diff --git a/‎memory-bank/activeContext.md‎
Lines changed: 115 additions & 0 deletions b/‎memory-bank/activeContext.md‎
Lines changed: 115 additions & 0 deletions
diff --git a/‎memory-bank/productContext.md‎
Lines changed: 138 additions & 0 deletions b/‎memory-bank/productContext.md‎
Lines changed: 138 additions & 0 deletions
@@ -0,0 +1,81 @@
+# Copilot Memory Bank
+
+I am Copilot, an expert software engineer with a unique characteristic: my memory resets completely between sessions. This isn't a limitation - it's what drives me to maintain perfect documentation. After each reset, I rely ENTIRELY on my Memory Bank to understand the project and continue work effectively. I MUST read ALL memory bank files at the start of EVERY task - this is not optional.
+
+## Memory Bank Structure
+
+The Memory Bank consists of core files and optional context files, all in Markdown format. Files build upon each other in a clear hierarchy:
+
+flowchart TD
+    PB[projectbrief.md] --> PC[productContext.md]
+    PB --> SP[systemPatterns.md]
+    PB --> TC[techContext.md]
+
+    PC --> AC[activeContext.md]
+    SP --> AC
+    TC --> AC
+
+    AC --> P[progress.md]
+
+### Core Files (Required)
+1. projectbrief.md
+2. productContext.md
+3. activeContext.md
+4. systemPatterns.md
+5. techContext.md
+6. progress.md
+
+### Additional Context
+Create additional files/folders within memory-bank/ when they help organize:
+- Complex feature documentation
+- Integration specifications
+- API documentation
+- Testing strategies
+- Deployment procedures
+
+## Core Workflows
+
+### Planning Mode
+flowchart TD
+    Start[Start] --> ReadFiles[Read Memory Bank]
+    ReadFiles --> CheckFiles{Files Complete?}
+
+    CheckFiles -->|No| Plan[Create Plan]
+    Plan --> Document[Document in Chat]
+
+    CheckFiles -->|Yes| Verify[Verify Context]
+    Verify --> Strategy[Develop Strategy]
+    Strategy --> Present[Present Approach]
+
+### Editing Mode
+flowchart TD
+    Start[Start] --> Context[Check Memory Bank]
+    Context --> Update[Update Documentation]
+    Update --> Execute[Execute Task]
+    Execute --> Document[Document Changes]
+
+## Documentation Updates
+
+Memory Bank updates occur when:
+1. Discovering new project patterns
+2. After implementing significant changes
+3. When user requests with **update memory bank** (MUST review ALL files)
+4. When context needs clarification
+
+flowchart TD
+    Start[Update Process]
+
+    subgraph Process
+        P1[Review ALL Files]
+        P2[Document Current State]
+        P3[Clarify Next Steps]
+        P4[Document Insights & Patterns]
+
+        P1 --> P2 --> P3 --> P4
+    end
+
+    Start --> Process
+
+Note: When triggered by **update memory bank**, I MUST review every memory bank file, even if some don't require updates. Focus particularly on activeContext.md and progress.md as they track current state.
+
+REMEMBER: After every memory reset, I begin completely fresh. The Memory Bank is my only link to previous work. It must be maintained with precision and clarity, as my effectiveness depends entirely on its accuracy.
@@ -0,0 +1,115 @@
+# Active Context - Current Project State
+
+## Current Work Focus
+
+### Memory Bank System Implementation
+**Status**: ✅ COMPLETE - Initial Memory Bank structure created
+**Date**: September 25, 2025
+
+**What Was Accomplished**:
+- Created complete Memory Bank directory structure
+- Implemented all 6 core Memory Bank files:
+  - `projectbrief.md` - Foundation document defining project scope
+  - `productContext.md` - User problems and solutions provided
+  - `systemPatterns.md` - Technical architecture and design patterns
+  - `techContext.md` - Technology stack and development environment
+  - `activeContext.md` - This file tracking current state
+  - `progress.md` - Project status and completion tracking
+
+**Memory Bank Purpose**:
+The Memory Bank serves as persistent knowledge system, essential because memory resets completely between sessions. These files must be read at the start of every task to understand project context and continue work effectively.
+
+## Current Project Understanding
+
+### Power Platform Extension Overview
+This is a comprehensive VSCode extension for Power Platform development, serving as the primary IDE integration for:
+- **Power Platform CLI integration** with automatic installation/updates
+- **Power Pages development** with local workflows and real-time preview
+- **PCF component debugging** with full browser automation
+- **Solution management** for Dataverse environments
+- **AI-powered assistance** through Copilot integration
+
+### Key Architecture Insights
+- **Multi-target deployment**: Both desktop (Node.js) and web (browser) environments
+- **Service-oriented design**: Authentication, CLI, language servers as separate services
+- **Event-driven updates**: Organization changes trigger context updates across services
+- **Feature flag system**: ECS integration for gradual rollout and A/B testing
+- **Language Server Protocol**: Custom HTML/YAML servers for Power Pages development
+
+## Recent Changes & Insights
+
+### Documentation Structure
+The Memory Bank follows a hierarchical information architecture:
+```
+projectbrief.md → {productContext.md, systemPatterns.md, techContext.md}
+                ↓
+            activeContext.md
+                ↓
+            progress.md
+```
+
+Each file builds upon the foundation established in `projectbrief.md`, with `activeContext.md` serving as the current state tracker and `progress.md` maintaining the completion status.
+
+### Project Patterns Identified
+1. **Extension Host Pattern**: Single entry point (`src/client/extension.ts`) managing all service lifecycles
+2. **Context Propagation**: Authentication changes flow through Artemis → PAC → ECS → UI updates
+3. **Graceful Degradation**: Extension provides limited functionality when dependencies unavailable
+4. **Security-First Design**: Token management, input validation, and privacy-compliant telemetry
+
+## Active Decisions & Considerations
+
+### Memory Bank Design Decisions
+- **Markdown Format**: Ensures readability and version control compatibility
+- **Hierarchical Structure**: Information flows from general to specific
+- **Comprehensive Coverage**: Captures both technical and product context
+- **Maintenance Strategy**: Regular updates when significant changes occur
+
+### Project Development Patterns
+- **TypeScript-First**: Strong typing throughout the codebase
+- **Multi-Environment Support**: Desktop and web with feature parity where possible
+- **Telemetry Integration**: Privacy-compliant analytics with geographic routing
+- **Testing Strategy**: Unit, integration, and web-specific test coverage
+
+## Next Steps & Priorities
+
+### Immediate Priorities
+1. **Memory Bank Maintenance**: Update files when significant changes occur
+2. **Project Documentation**: Ensure Memory Bank stays current with development
+3. **Context Awareness**: Use Memory Bank for all future task planning
+
+### Development Guidelines
+- Always read all Memory Bank files at session start
+- Update Memory Bank when discovering new patterns or making significant changes
+- Use Memory Bank to guide architectural decisions and maintain consistency
+- Keep `activeContext.md` current with recent work and insights
+
+### Important Patterns to Remember
+- **Authentication Flow**: User → VSCode Auth API → Azure AD → CLI Context
+- **Organization Updates**: Trigger cascading service reinitializations
+- **Feature Flags**: ECS controls which capabilities are available
+- **Multi-Cloud**: Different authentication endpoints for government clouds
+
+## Project Insights & Learnings
+
+### Extension Development Best Practices
+- **Activation Events**: Carefully control when extension activates to minimize resource usage
+- **Disposable Pattern**: Always properly clean up resources to prevent memory leaks
+- **Lazy Loading**: Initialize services only when needed to improve startup performance
+- **Error Boundaries**: Graceful handling of failures with user-friendly error messages
+
+### Power Platform Integration Insights
+- **CLI Centricity**: Power Platform CLI is the primary integration point for all services
+- **Environment Awareness**: Extension behavior changes based on connected environment
+- **Version Management**: Automatic CLI updates ensure compatibility with latest features
+- **Telemetry Importance**: Geographic routing and privacy compliance are critical
+
+### Development Workflow Optimization
+- **Multi-Target Building**: Webpack configurations for both Node.js and browser environments
+- **Language Server Benefits**: Dedicated servers provide rich editing experiences
+- **Debugging Capabilities**: Puppeteer integration enables full PCF debugging experience
+- **Feature Experimentation**: ECS feature flags allow safe rollout of new capabilities
+
+## Current State Summary
+The Memory Bank system is now fully operational and contains comprehensive understanding of the Power Platform VSCode extension project. All core files are created and populated with essential project knowledge that will enable effective continuation of work across memory resets.
+
+The project represents a mature, well-architected VSCode extension that successfully bridges traditional development workflows with Power Platform services, providing a professional development experience for Power Platform developers.
@@ -0,0 +1,138 @@
+# Product Context - Power Platform Extension
+
+## Why This Extension Exists
+
+### Developer Pain Points Addressed
+- **Context Switching**: Developers previously needed multiple tools for Power Platform development
+- **Complex CLI Management**: Power Platform CLI installation and updates were manual and error-prone
+- **Limited Local Development**: Power Pages development lacked proper local development workflows
+- **Debugging Challenges**: PCF controls were difficult to debug without proper tooling
+- **Authentication Complexity**: Managing multiple environments and authentication profiles was cumbersome
+
+### Market Need
+The Power Platform ecosystem has grown rapidly, creating demand for professional development tools that match traditional software development experiences. Developers expect:
+- IDE integration with familiar workflows
+- Local development and testing capabilities
+- Version control integration
+- Debugging and profiling tools
+- AI-assisted development
+
+## Core Problems Solved
+
+### 1. Unified Development Environment
+**Problem**: Fragmented tooling across Power Platform services
+**Solution**: Single VSCode extension handling all Power Platform development needs
+
+### 2. Power Platform CLI Integration
+**Problem**: Manual CLI management and complex command-line workflows
+**Solution**: Automatic CLI installation, updates, and GUI wrappers for common operations
+
+### 3. Power Pages Local Development
+**Problem**: No local development workflow for portal customization
+**Solution**: Complete local development environment with:
+- File system integration
+- Real-time preview
+- Version control support
+- Collaborative editing features
+
+### 4. PCF Component Debugging
+**Problem**: Limited debugging capabilities for custom components
+**Solution**: Full debugging support with:
+- Browser automation
+- Source mapping
+- Breakpoint support
+- Variable inspection
+
+### 5. Authentication & Environment Management
+**Problem**: Complex multi-environment authentication workflows
+**Solution**: Streamlined authentication with:
+- Interactive login flows
+- Multi-cloud support
+- Environment switching
+- Credential management
+
+## How It Should Work
+
+### Ideal User Journey
+
+#### Initial Setup
+1. Install extension from VSCode marketplace
+2. Extension automatically acquires latest Power Platform CLI
+3. Guided authentication setup with preferred cloud environment
+4. Automatic workspace detection for Power Platform projects
+
+#### Daily Development Workflow
+1. **Environment Management**: Quick switching between dev/test/prod environments
+2. **Solution Development**: Create and manage Dataverse solutions locally
+3. **Power Pages Development**: Edit, preview, and deploy portal customizations
+4. **PCF Development**: Debug custom components with full debugging support
+5. **AI Assistance**: Leverage Copilot for code generation and problem-solving
+
+#### Deployment & Testing
+1. **Local Testing**: Preview and test changes before deployment
+2. **Solution Deployment**: Deploy solutions to target environments
+3. **Version Control**: Commit changes with proper version control integration
+4. **Collaboration**: Share work with team members through collaborative features
+
+### User Experience Goals
+
+#### For Power Platform Developers
+- **Familiar Environment**: Leverage existing VSCode knowledge and extensions
+- **Efficient Workflows**: Reduce context switching and repetitive tasks
+- **Professional Tools**: Access to debugging, IntelliSense, and other pro-dev features
+
+#### For Traditional Developers
+- **Easy Onboarding**: Natural transition to Power Platform development
+- **Standard Practices**: Support for Git, debugging, testing workflows
+- **Extension Ecosystem**: Integration with other VSCode extensions
+
+#### for Solution Architects
+- **Project Overview**: Clear visibility into solution structure and dependencies
+- **Environment Management**: Easy switching between multiple environments
+- **Deployment Control**: Managed deployment processes with validation
+
+## Key User Scenarios
+
+### Scenario 1: Power Pages Development
+A developer needs to customize a Power Pages portal:
+1. Open workspace containing portal configuration
+2. Extension automatically detects Power Pages project
+3. Developer edits HTML/CSS/JavaScript files
+4. Real-time preview shows changes immediately
+5. Copilot assists with code generation and troubleshooting
+6. Deploy changes to target environment with single command
+
+### Scenario 2: PCF Component Development
+A developer creates a custom Power Apps component:
+1. Create new PCF project using extension commands
+2. Develop component using TypeScript and modern tooling
+3. Launch debugger to test component behavior
+4. Set breakpoints and inspect component state
+5. Deploy and test in Power Apps environment
+
+### Scenario 3: Solution Management
+A solution architect manages a complex Dataverse solution:
+1. Connect to multiple environments (dev, test, prod)
+2. Export solutions from source environment
+3. Modify solution components locally
+4. Import and test in target environments
+5. Track changes through version control
+
+## Success Indicators
+
+### Developer Productivity
+- Reduced time to set up development environment
+- Faster edit-test-deploy cycles
+- Decreased context switching between tools
+
+### Code Quality
+- Better debugging capabilities leading to fewer bugs
+- AI assistance improving code quality and best practices
+- Version control integration enabling better collaboration
+
+### Adoption Metrics
+- High extension ratings and downloads
+- Strong community engagement and feedback
+- Integration into enterprise development workflows
+
+The extension transforms Power Platform development from a fragmented, tool-heavy process into a streamlined, IDE-integrated experience that matches modern development expectations.