context-tracker-mcp1.0 1.0.13 → 1.0.15

package/.windsurf/workflows/{doc.md → code-docs.md}

@@ -1,7 +1,9 @@
 ---
-description: Generate documentation for code
+description: Generate code-level documentation (functions, APIs, examples)
 ---
 
+# code-docs Workflow
+
 Generate clear documentation for the provided code:
 
 1. **README section** - Project overview, setup, usage

package/.windsurf/workflows/{documentation.md → project-docs.md}

@@ -1,10 +1,10 @@
 ---
-description: Generate and maintain project documentation
+description: Generate and maintain project-wide documentation
 ---
-# documentation Workflow
+# project-docs Workflow
 
 1. Scan project structure
-2. Generate docs
+2. Generate comprehensive project docs
 3. Setup auto-doc generation
 
 ## Usage

package/README.md

@@ -1,321 +1,230 @@
 # Context Tracker MCP
 
-एक powerful MCP agent जो आपके development context को कभी नहीं भूलता और automatic documentation generate करता है।
+## Introduction
 
-## 🚀 What's New (v1.0.0)
+Context Tracker MCP is an intelligent Model Context Protocol (MCP) server designed to enhance development workflows through comprehensive context awareness. It serves as a bridge between the development environment and artificial intelligence assistants, enabling smarter, context-aware interactions during software development.
 
-✅ **Concurrency Control** - Thread-safe operations with Mutex & ReadWriteLock  
-✅ **Unit Testing** - 70+ comprehensive Jest tests  
-✅ **Resource Pooling** - Smart caching with TTL management  
-✅ **Error Analysis** - Automatic error pattern detection  
-✅ **Project Intelligence** - Code metrics and recommendations  
-✅ **Configuration Management** - Dynamic config loading/updating  
-✅ **NPM Package Ready** - Distribute to any PC  
-
----
-
-## 📦 Installation & Deployment
-
-### 1. Install Dependencies
-
-```bash
-# MCP Server
-cd mcp
-npm install
-
-# VSCode Extension
-cd vscode-extension
-npm install
-```
-
-### 2. Build the Project
-
-```bash
-# Build MCP Server
-cd mcp
-npm run build
-
-# Build VSCode Extension
-cd vscode-extension
-npm run compile
-```
-
-### 3. VSCode Extension Setup
-
-1. VSCode में `Ctrl+Shift+P` press करें
-2. `Extensions: Install from VSIX...` select करें
-3. `vscode-extension` folder में generated `.vsix` file install करें
-
-### 4. MCP Server Configuration
-
-अपने MCP client में यह configuration add करें:
-
-```json
-{
-  "mcpServers": {
-    "context-tracker": {
-      "command": "node",
-      "args": ["path/to/context-tracker-mcp/dist/index.js"],
-      "env": {
-        "NODE_ENV": "production"
-      }
-    }
-  }
-}
-```
-
-## 🎯 Usage
-
-### VSCode Extension Commands
-
-- **`Ctrl+Shift+T`**: Track Current Context
-- **`Ctrl+Shift+H`**: Show Context History  
-- **`Ctrl+Shift+D`**: Generate Documentation
-- **Right-click on CSS**: Track Styling
-
-### Windsurf Workflows
-
-- **`/context-track`**: Start tracking new context
-- **`/context-update`**: Update existing context
-- **`/generate-docs`**: Generate documentation
-- **`/context-error`**: Log an error
-
-### MCP Tools
-
-```javascript
-// Track context
-await trackContext('start', {
-  description: 'Adding user authentication',
-  files: ['src/auth.ts', 'components/Login.tsx']
-});
-
-// Generate documentation
-const docs = await generateDocumentation('complete', 'markdown');
-
-// Log error
-await logError('TypeError: Cannot read property', 'Added null check', 'During login');
-
-// Track styling
-await trackStyling('.button', { color: 'blue', padding: '10px' }, 'styles.css');
-```
-
-## 📂 Project Structure
-
-```
-context-tracker-mcp/
-├── src/
-│   ├── index.ts                    # MCP Server entry point
-│   ├── context-tracker.ts          # Core context tracking (Thread-safe)
-│   ├── documentation-generator.ts # Auto documentation
-│   ├── file-watcher.ts            # File change monitoring
-│   ├── error-analyzer.ts          # Error pattern analysis ⭐ NEW
-│   ├── project-intelligence.ts    # Code metrics & insights ⭐ NEW
-│   ├── config-manager.ts          # Configuration management ⭐ NEW
-│   ├── resource-manager.ts        # Smart caching ⭐ NEW
-│   └── mutex.ts                   # Concurrency control ⭐ NEW
-├── tests/                         # Unit tests ⭐ NEW
-│   ├── context-tracker.test.ts
-│   ├── config-manager.test.ts
-│   ├── resource-manager.test.ts
-│   ├── error-analyzer.test.ts
-│   └── mutex.test.ts
-├── vscode-extension/              # VSCode extension
-│   └── context-tracker-vscode-1.0.0.vsix
-├── .windsurf/workflows/           # Windsurf workflows
-│   ├── co.md                      # Continue workflow ⭐ NEW
-│   ├── context-track.md
-│   └── generate-docs.md
-├── context-data/                  # Local data storage
-├── DEPLOYMENT_GUIDE.md            # Deployment instructions ⭐ NEW
-└── README.md
-```
-
-## 🔧 Configuration
-
-### VSCode Settings
-
-```json
-{
-  "contextTracker.autoTrack": true,
-  "contextTracker.watchedPaths": ["./src", "./components", "./styles"],
-  "contextTracker.dataDirectory": "./context-data"
-}
-```
-
-### MCP Server Options
-
-```javascript
-// Custom data directory
-const tracker = new ContextTracker('./my-context-data');
-
-// Custom watched paths
-await fileWatcher.initialize(['./src', './lib', './styles']);
-```
-
-## 📊 Data Storage
-
-सभी data locally store होता है:
-
-- **`context-data/context.json`**: Complete context history
-- **`context-data/errors.json`**: Error log with solutions
-- **`context-data/styling.json`**: Styling changes history
-
-## 🎨 Examples
-
-### Starting a New Feature
-
-```bash
-# VSCode: Ctrl+Shift+T
-# Description: Adding user registration system
-# Files: src/auth/register.ts, components/RegisterForm.tsx
-```
-
-### Logging an Error
-
-```bash
-# VSCode: Command Palette > Log Error
-# Error: Cannot read property 'email' of undefined
-# Solution: Added null validation before accessing email
-# Context: During user registration validation
-```
-
-### Tracking Styling
-
-```css
-/* Select this CSS in VSCode and right-click > Track Styling */
-.button {
-  background: #007bff;
-  color: white;
-  padding: 10px 20px;
-  border-radius: 5px;
-}
-```
-
-### Generate Documentation
-
-```bash
-# Windsurf: /generate-docs
-# Type: complete
-# Format: markdown
-```
-
-## 🚀 Advanced Usage
-
-### Custom MCP Integration
-
-```javascript
-import { ContextTracker } from './src/context-tracker.js';
-
-const tracker = new ContextTracker();
-
-// Track complex context
-await tracker.trackContext('start', {
-  description: 'Building payment gateway',
-  files: ['src/payment/', 'components/PaymentForm.tsx'],
-  code: 'const payment = new PaymentProcessor();',
-  metadata: {
-    priority: 'high',
-    estimatedHours: 8,
-    dependencies: ['user-auth', 'database']
-  }
-});
-```
+## Requirements
 
-### Custom Documentation
+### Prerequisites
 
-```javascript
-import { DocumentationGenerator } from './src/documentation-generator.js';
+Before installing Context Tracker MCP, ensure your system meets the following requirements:
 
-const generator = new DocumentationGenerator(tracker);
+- **Node.js**: Version 18.0 or higher (LTS recommended)
+- **npm**: Version 9.0 or higher (included with Node.js)
+- **Operating System**: Windows, macOS, or Linux
 
-// Generate custom documentation
-const customDocs = await generator.generate('features', 'json');
-```
+### Compatibility
 
-## � Deployment to Another PC
+The MCP server is compatible with development environments that support the Model Context Protocol, including Windsurf IDE and other MCP-compatible editors.
 
-### Method 1: NPM Package (Easiest)
+## Installation
 
-```bash
-# On your PC (create package)
-npm run build
-npm pack
-# Creates: context-tracker-mcp-1.0.0.tgz
+### Quick Setup (Two Commands)
 
-# On other PC (install)
-npm install -g context-tracker-mcp-1.0.0.tgz
-context-tracker-mcp
-```
+Getting started with Context Tracker MCP requires only two simple commands:
 
-### Method 2: VS Code Extension
+**Step 1: Install the Package**
 
-```bash
-# Package extension
-cd vscode-extension
-vsce package
-# Creates: .vsix file
+Install the MCP server globally using npm. This command downloads and configures the package along with all its dependencies.
 
-# Install on other PC via VS Code
-# Extensions → Install from VSIX
-```
+**Step 2: Initialize Workflows**
 
-### Method 3: Full Project
+Navigate to your project directory and run the setup command. This creates the necessary configuration files and workflow definitions in your project.
 
-```bash
-# Copy entire project folder
-# On other PC:
-npm install
-npm run build
-npm start
-```
+### What Gets Installed
 
----
+The installation process automatically configures:
 
-## �🐛 Troubleshooting
+- **MCP Server**: The core server that handles context tracking and analysis
+- **Workflow Definitions**: Twelve pre-built workflows for common development tasks
+- **Configuration Files**: Project-specific settings and preferences
+- **Context Data Directory**: Storage location for tracked context and history
 
-### Common Issues
+### Post-Installation Verification
 
-1. **MCP Server Not Starting**
-   ```bash
-   npm run build
-   node dist/index.js
-   ```
+After installation, the following directory structure will be present in your project:
 
-2. **VSCode Extension Not Working**
-   - Restart VSCode
-   - Check MCP server is running
-   - Verify configuration
+- `.windsurf/mcp-config.json` - MCP server configuration
+- `.windsurf/workflows/` - Workflow definition files
+- `.context-data/` - Context tracking storage
 
-3. **File Watching Not Working**
-   - Check file permissions
-   - Verify watched paths exist
-   - Check .gitignore doesn't block files
+## Troubleshooting
 
-### Debug Mode
+### Common Installation Issues
 
-```bash
-# Enable debug logging
-DEBUG=context-tracker:* npm run dev
-```
+#### Node.js Not Found
 
-## 🤝 Contributing
+**Symptom**: Error messages indicating Node.js is not recognized or not installed.
 
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests if needed
-5. Submit a pull request
+**Solution**: Download and install Node.js from the official website. Verify installation by running the version check command in your terminal.
 
-## 📄 License
+#### Permission Errors
 
-MIT License - see LICENSE file for details
+**Symptom**: Access denied or permission-related errors during global installation.
 
-## 🙏 Acknowledgments
+**Solution**: On Windows, run your terminal as Administrator. On macOS and Linux, you may need to adjust npm permissions or use a Node version manager.
 
-- MCP (Model Context Protocol) team
-- VSCode extension API
-- Windsurf workflow system
+#### Network Connectivity Issues
 
----
+**Symptom**: Installation fails with timeout or network-related errors.
 
-**Made with ❤️ for developers who never want to lose context!**
+**Solution**: Check your internet connection. If behind a corporate proxy, configure npm proxy settings. Alternatively, try installing at a different time when network conditions are stable.
+
+#### Workflow Setup Fails
+
+**Symptom**: The setup command reports missing files or directories.
+
+**Solution**: Ensure you are running the setup command from your project root directory. The command must have write permissions to create the `.windsurf` and `.context-data` directories.
+
+### Configuration Issues
+
+#### MCP Server Not Starting
+
+**Symptom**: The development environment does not recognize the MCP server.
+
+**Solution**: Verify that the global installation completed successfully. Check that the `.windsurf/mcp-config.json` file exists and contains valid JSON. Restart your development environment after configuration changes.
+
+#### Workflow Commands Not Available
+
+**Symptom**: Slash commands for workflows do not appear or execute.
+
+**Solution**: Confirm that workflow files exist in the `.windsurf/workflows/` directory. Ensure your development environment has MCP support enabled and properly configured.
+
+### Getting Additional Help
+
+If you encounter issues not covered in this section, consider the following resources:
+
+- Verify system compatibility and requirements
+- Check for updates to your development environment
+- Review Node.js and npm documentation for environment-specific issues
+- Consult the comprehensive documentation for detailed configuration options
+
+## Core Philosophy
+
+The fundamental principle behind this tool is the preservation and intelligent utilization of development context. In modern software development, context is often lost between sessions, making it difficult for AI assistants to provide relevant assistance. This MCP server addresses this challenge by maintaining persistent context about codebases, errors, styling patterns, and project structures.
+
+## Architecture Overview
+
+### Context Management Layer
+The server operates on a sophisticated context management layer that captures development activities in real-time. This layer tracks file changes, session activities, and project modifications, creating a comprehensive timeline of development work.
+
+### Intelligent Analysis Engine
+At its core, the MCP incorporates analytical capabilities that examine project structures, identify patterns in errors, and analyze code organization. This engine provides insights that help developers understand their codebase better and make informed decisions.
+
+### Documentation Intelligence
+The system includes specialized modules for documentation generation and maintenance. Rather than treating documentation as an afterthought, it integrates documentation creation into the development workflow itself.
+
+### Workflow Integration
+A series of predefined workflows guide developers through common tasks. These workflows are not rigid procedures but intelligent guides that adapt to the specific needs of each project.
+
+## Key Capabilities
+
+### Session Tracking and Context Preservation
+Development work happens in sessions, and each session generates valuable context. The system captures the essence of these sessions—what files were modified, what problems were encountered, what solutions were implemented. This preserved context enables continuity across interrupted work periods.
+
+### Error Pattern Recognition
+Errors are not isolated incidents but patterns that emerge over time. By logging and analyzing errors along with their solutions, the system builds a knowledge base of common issues and their resolutions. This accumulated wisdom becomes invaluable for troubleshooting recurring problems.
+
+### Project Structure Analysis
+Understanding how a project is organized is crucial for effective development. The system scans and analyzes project structures, identifying the relationships between components, the organization of files, and the overall architecture. This analysis helps in maintaining clean, well-organized codebases.
+
+### Automated Documentation
+Documentation creation is often delayed or neglected due to time constraints. The system addresses this by providing automated documentation capabilities that generate comprehensive documentation from code structures and development activities.
+
+### Styling and Design Consistency
+For projects involving user interfaces, maintaining consistent styling across components is essential. The system tracks styling decisions and patterns, ensuring visual coherence throughout the application.
+
+## Workflow System
+
+The MCP includes twelve specialized workflows, each designed for specific development scenarios:
+
+### Code Organization Workflow
+Focuses on improving code structure through logical file grouping, consistent naming conventions, and clear separation of concerns. It helps identify and eliminate duplicate code while establishing maintainable patterns.
+
+### Code Documentation Workflow
+Concentrates on creating comprehensive documentation at the code level. This includes function-level explanations, API specifications, and usage examples that make code accessible to team members.
+
+### Project Documentation Workflow
+Handles broader project documentation needs, including structural overviews, setup instructions, and maintenance guides. It ensures that project-level information is captured and preserved.
+
+### Context Tracking Workflow
+Manages the capture and preservation of development context. It ensures that work sessions are tracked, important decisions are recorded, and context is available when needed.
+
+### Error Analysis Workflow
+Specializes in examining errors, understanding their root causes, and documenting solutions. It builds a repository of troubleshooting knowledge that grows more valuable over time.
+
+### Explanation Workflow
+Provides detailed explanations of code functionality. It helps team members understand complex implementations and architectural decisions.
+
+### Bug Fix Workflow
+Guides the process of identifying, analyzing, and resolving bugs. It ensures systematic approaches to debugging and verification of fixes.
+
+### Optimization Workflow
+Focuses on improving code performance and efficiency. It identifies bottlenecks, suggests improvements, and tracks optimization efforts.
+
+### Project Intelligence Workflow
+Leverages accumulated project data to provide insights and suggestions. It helps identify trends, potential issues, and opportunities for improvement.
+
+### Refactoring Workflow
+Supports code restructuring efforts while maintaining functionality. It ensures that refactoring is done systematically with proper testing.
+
+### Test Execution Workflow
+Manages the running of test suites and analysis of results. It supports various testing modes including continuous testing and coverage analysis.
+
+### Test Generation Workflow
+Automates the creation of unit tests and integration tests. It ensures comprehensive coverage and helps maintain code quality.
+
+## Data Storage and Persistence
+
+The system stores its data in two primary locations within the project directory:
+
+### Context Data Directory
+All tracking information, session histories, error logs, and analysis results are stored here. This includes the accumulated intelligence that the system builds over time.
+
+### Workflow Definitions
+The predefined workflows are stored as markdown files, making them accessible and modifiable. These definitions guide how the system interacts with development tasks.
+
+### Configuration Management
+The MCP maintains its own configuration settings, allowing customization of behavior, tracking preferences, and integration parameters.
+
+## Integration Model
+
+The server integrates with development environments through the Model Context Protocol, a standardized interface for AI assistant communication. This integration enables seamless interaction between the development workflow and AI capabilities.
+
+### Real-time Monitoring
+Through file watching capabilities, the system monitors project directories for changes. This real-time awareness allows immediate response to development activities.
+
+### Intelligent Suggestions
+Based on accumulated context and patterns, the system provides context-aware suggestions. These suggestions are grounded in the actual state and history of the project.
+
+### Persistent Memory
+Unlike transient development sessions, the system maintains persistent memory. This memory spans across sessions, providing continuity and building cumulative knowledge.
+
+## Benefits for Development Teams
+
+### Knowledge Preservation
+When team members move between projects or leave the organization, their accumulated knowledge often disappears. The system preserves this knowledge, making it available to current and future team members.
+
+### Onboarding Acceleration
+New team members can quickly understand project structure, common issues, and established patterns through the accumulated context and documentation.
+
+### Consistency Maintenance
+By tracking patterns and enforcing workflows, the system helps maintain consistency across large codebases and distributed teams.
+
+### Reduced Cognitive Load
+Developers don't need to remember every detail about the project. The system serves as an external memory, freeing mental resources for creative problem-solving.
+
+## Future Evolution
+
+The architecture is designed for extensibility. Future enhancements may include:
+
+- Integration with version control systems for deeper change tracking
+- Enhanced pattern recognition using machine learning
+- Collaboration features for team-wide context sharing
+- Custom workflow creation capabilities
+- Integration with project management tools
+
+## Conclusion
+
+Context Tracker MCP represents a shift in how development context is managed. By treating context as a valuable asset to be preserved and utilized, it enables more intelligent development workflows. The combination of tracking, analysis, documentation, and workflow guidance creates an environment where AI assistance is truly context-aware and development knowledge is cumulative rather than ephemeral.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-tracker-mcp1.0",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "MCP server for tracking context, code changes, and generating documentation",
   "main": "dist/index.js",
   "type": "module",