context-tracker-mcp1.0 1.0.9 → 1.0.11

package/.windsurf/mcp-config.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "context-tracker": {
+      "command": "npx",
+      "args": [
+        "context-tracker-mcp1.0"
+      ],
+      "transportType": "stdio",
+      "enabled": true
+    }
+  }
+}

package/.windsurf/workflows/context-tracking.md

@@ -0,0 +1,12 @@
+---
+description: Track development context and code changes
+---
+# context-tracking Workflow
+
+1. Initialize file watcher
+2. Setup context tracking
+3. Enable auto-tracking
+
+## Usage
+
+This workflow is automatically managed by the Context Tracker MCP.

package/.windsurf/workflows/doc.md

@@ -0,0 +1,13 @@
+---
+description: Generate documentation for code
+---
+
+Generate clear documentation for the provided code:
+
+1. **README section** - Project overview, setup, usage
+2. **Function documentation** - JSDoc/docstring comments
+3. **API documentation** - Input/output specifications
+4. **Examples** - Code samples showing how to use
+5. **Changelog notes** - What's new/changed
+
+Make documentation beginner-friendly with examples.

package/.windsurf/workflows/documentation.md

@@ -0,0 +1,12 @@
+---
+description: Generate and maintain project documentation
+---
+# documentation Workflow
+
+1. Scan project structure
+2. Generate docs
+3. Setup auto-doc generation
+
+## Usage
+
+This workflow is automatically managed by the Context Tracker MCP.

package/.windsurf/workflows/error-analysis.md

@@ -0,0 +1,12 @@
+---
+description: Analyze and track errors across sessions
+---
+# error-analysis Workflow
+
+1. Enable error tracking
+2. Setup error patterns
+3. Configure notifications
+
+## Usage
+
+This workflow is automatically managed by the Context Tracker MCP.

package/.windsurf/workflows/explain.md

@@ -0,0 +1,13 @@
+---
+description: Explain code functionality and logic
+---
+
+Explain the provided code in simple, clear terms. Include:
+
+1. **What it does** - Overall purpose and functionality
+2. **How it works** - Step-by-step logic flow
+3. **Key components** - Important functions, variables, patterns
+4. **Inputs/Outputs** - What goes in, what comes out
+5. **Edge cases** - How it handles unusual scenarios
+
+Keep explanations concise but comprehensive. Use bullet points and short paragraphs.

package/.windsurf/workflows/fix.md

@@ -0,0 +1,18 @@
+---
+description: Fix bugs and errors in code
+---
+
+Analyze the provided code and fix all bugs, errors, and issues. Focus on:
+
+1. **Syntax errors** - Fix typos, missing brackets, semicolons
+2. **Logic errors** - Fix incorrect conditions, loops, calculations
+3. **Runtime errors** - Fix null/undefined references, type errors
+4. **Edge cases** - Handle empty inputs, boundary conditions
+5. **Best practices** - Follow language conventions and patterns
+
+Steps:
+1. Read and understand the code
+2. Identify all issues
+3. Apply fixes with minimal changes
+4. Verify the fix doesn't break existing functionality
+5. Return the corrected code with brief explanation of changes

package/.windsurf/workflows/optimize.md

@@ -0,0 +1,14 @@
+---
+description: Optimize code for performance
+---
+
+Optimize the provided code for better performance. Focus on:
+
+1. **Time complexity** - Reduce Big O where possible
+2. **Memory usage** - Minimize memory allocations
+3. **Loop optimization** - Remove unnecessary iterations
+4. **Caching** - Add memoization where beneficial
+5. **Async operations** - Parallelize independent tasks
+6. **Bundle size** - Reduce for frontend code
+
+Maintain readability while improving performance. Measure before and after if possible.

package/.windsurf/workflows/project-intelligence.md

@@ -0,0 +1,12 @@
+---
+description: Learn and suggest based on project patterns
+---
+# project-intelligence Workflow
+
+1. Analyze project patterns
+2. Build knowledge base
+3. Enable suggestions
+
+## Usage
+
+This workflow is automatically managed by the Context Tracker MCP.

package/.windsurf/workflows/refactor.md

@@ -0,0 +1,14 @@
+---
+description: Refactor code for better structure
+---
+
+Refactor the provided code to improve quality and maintainability:
+
+1. **Extract functions** - Break large functions into smaller ones
+2. **Rename variables** - Use clear, descriptive names
+3. **Remove duplication** - Apply DRY principle
+4. **Simplify logic** - Reduce nesting, use early returns
+5. **Add types** - Add TypeScript types or JSDoc
+6. **Improve patterns** - Use modern best practices
+
+Make incremental changes that preserve functionality while improving code quality.

package/.windsurf/workflows/test.md

@@ -0,0 +1,13 @@
+---
+description: Generate unit tests for code
+---
+
+Generate comprehensive unit tests for the provided code. Include:
+
+1. **Happy path tests** - Normal expected inputs and outputs
+2. **Edge case tests** - Empty inputs, boundaries, null values
+3. **Error case tests** - Invalid inputs, exceptions, failures
+4. **Integration tests** - How components work together
+
+Use the testing framework appropriate for the language (Jest for JS, pytest for Python, etc.)
+Cover at least 80% of code paths.

package/dist/index.js

@@ -193,6 +193,25 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     }
                 }
             },
+            {
+                name: 'analyze_project_files',
+                description: 'Analyze project files to identify necessary files, MCP-generated files, and safe-to-remove files',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        includeHidden: {
+                            type: 'boolean',
+                            description: 'Include hidden files and directories in analysis',
+                            default: false
+                        },
+                        scanDepth: {
+                            type: 'number',
+                            description: 'How deep to scan directories (1-10, default: 5)',
+                            default: 5
+                        }
+                    }
+                }
+            },
             {
                 name: 'get_config',
                 description: 'Get current MCP configuration',
@@ -273,6 +292,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'get_error_patterns':
                 const errorStats = errorAnalyzer.getErrorStatistics();
                 return { content: [{ type: 'text', text: JSON.stringify(errorStats, null, 2) }] };
+            case 'analyze_project_files':
+                const fileAnalysis = await analyzeProjectFiles(args?.includeHidden || false, args?.scanDepth || 5);
+                return { content: [{ type: 'text', text: JSON.stringify(fileAnalysis, null, 2) }] };
             case 'get_config':
                 const config = await configManager.loadConfig();
                 const section = args?.section || 'all';
@@ -331,6 +353,175 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
     }
 });
+// Analyze project files function
+async function analyzeProjectFiles(includeHidden = false, scanDepth = 5) {
+    const path = await import('path');
+    const { promises: fs } = await import('fs');
+    const projectRoot = process.cwd();
+    const results = {
+        projectRoot,
+        analysis: {
+            necessary: [],
+            mcpFiles: [],
+            safeToRemove: [],
+            unknown: []
+        },
+        summary: {
+            totalFiles: 0,
+            necessaryCount: 0,
+            mcpFilesCount: 0,
+            safeToRemoveCount: 0,
+            unknownCount: 0
+        }
+    };
+    // MCP file patterns
+    const mcpPatterns = [
+        '.windsurf/',
+        '.context-data/',
+        'mcp-config.json',
+        'context-tracker-mcp*',
+        'setup-mcp-workflows*'
+    ];
+    // Necessary file patterns for different project types
+    const necessaryPatterns = {
+        'package.json': true,
+        'tsconfig.json': true,
+        'webpack.config.js': true,
+        'vite.config.js': true,
+        'next.config.js': true,
+        'tailwind.config.js': true,
+        '.env': true,
+        '.env.example': true,
+        'README.md': true,
+        'LICENSE': true,
+        '.gitignore': true,
+        'src/': true,
+        'components/': true,
+        'pages/': true,
+        'lib/': true,
+        'utils/': true,
+        'public/': true,
+        'dist/': true,
+        'build/': true,
+        'node_modules/': false, // Not necessary for repo
+        '.git/': false // Not necessary for repo
+    };
+    // Safe to remove patterns
+    const safeToRemovePatterns = [
+        'node_modules/',
+        '.DS_Store',
+        'Thumbs.db',
+        '*.log',
+        '.vscode/settings.json.backup',
+        '.idea/workspace.xml',
+        '*.tmp',
+        '*.temp'
+    ];
+    async function scanDirectory(dirPath, currentDepth = 0) {
+        if (currentDepth > scanDepth) return;
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!includeHidden && entry.name.startsWith('.')) continue;
+                const fullPath = path.join(dirPath, entry.name);
+                const relativePath = path.relative(projectRoot, fullPath);
+                results.summary.totalFiles++;
+                // Check MCP files
+                let isMcpFile = false;
+                for (const pattern of mcpPatterns) {
+                    if (pattern.endsWith('/')) {
+                        if (relativePath.startsWith(pattern)) {
+                            isMcpFile = true;
+                            break;
+                        }
+                    } else {
+                        if (relativePath.includes(pattern) || entry.name.includes(pattern)) {
+                            isMcpFile = true;
+                            break;
+                        }
+                    }
+                }
+                if (isMcpFile) {
+                    results.analysis.mcpFiles.push({
+                        path: relativePath,
+                        type: entry.isDirectory() ? 'directory' : 'file',
+                        description: 'MCP-generated file/folder'
+                    });
+                    results.summary.mcpFilesCount++;
+                    continue;
+                }
+                // Check necessary files
+                let isNecessary = false;
+                let necessaryDesc = '';
+                for (const [pattern, desc] of Object.entries(necessaryPatterns)) {
+                    if (pattern.endsWith('/')) {
+                        if (relativePath.startsWith(pattern)) {
+                            isNecessary = true;
+                            necessaryDesc = typeof desc === 'string' ? desc : `Essential ${pattern} directory`;
+                            break;
+                        }
+                    } else {
+                        if (entry.name === pattern || relativePath.endsWith(pattern)) {
+                            isNecessary = true;
+                            necessaryDesc = typeof desc === 'string' ? desc : `Essential ${pattern} file`;
+                            break;
+                        }
+                    }
+                }
+                if (isNecessary) {
+                    results.analysis.necessary.push({
+                        path: relativePath,
+                        type: entry.isDirectory() ? 'directory' : 'file',
+                        description: necessaryDesc
+                    });
+                    results.summary.necessaryCount++;
+                    continue;
+                }
+                // Check safe to remove
+                let isSafeToRemove = false;
+                for (const pattern of safeToRemovePatterns) {
+                    if (pattern.endsWith('/')) {
+                        if (relativePath.startsWith(pattern)) {
+                            isSafeToRemove = true;
+                            break;
+                        }
+                    } else {
+                        if (entry.name.match(pattern.replace('*', '.*'))) {
+                            isSafeToRemove = true;
+                            break;
+                        }
+                    }
+                }
+                if (isSafeToRemove) {
+                    results.analysis.safeToRemove.push({
+                        path: relativePath,
+                        type: entry.isDirectory() ? 'directory' : 'file',
+                        description: 'Safe to remove - generated/cache file',
+                        size: entry.isFile() ? (await fs.stat(fullPath)).size : null
+                    });
+                    results.summary.safeToRemoveCount++;
+                    continue;
+                }
+                // Unknown/uncategorized
+                results.analysis.unknown.push({
+                    path: relativePath,
+                    type: entry.isDirectory() ? 'directory' : 'file',
+                    description: 'Uncategorized file'
+                });
+                results.summary.unknownCount++;
+                // Recurse into directories
+                if (entry.isDirectory()) {
+                    await scanDirectory(fullPath, currentDepth + 1);
+                }
+            }
+        } catch (error) {
+            // Permission denied or other errors
+            console.warn(`Cannot access ${dirPath}:`, error.message);
+        }
+    }
+    await scanDirectory(projectRoot);
+    return results;
+}
 // List resources
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-tracker-mcp1.0",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "MCP server for tracking context, code changes, and generating documentation",
   "main": "dist/index.js",
   "type": "module",
@@ -11,6 +11,7 @@
   "files": [
     "dist/**/*",
     "bin/**/*",
+    ".windsurf/workflows/**/*",
     "README.md",
     "mcp-config.json"
   ],