fix: regular expression templating issue when using special character for example in windows (#32)

Author: gblanc-1a

schemas/hub-config.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://github.com/wherka/prompt-registry/schemas/hub-config.schema.json",
+  "$id": "https://github.com/AmadeusITGroup/prompt-registry/blob/main/schemas/hub-config.schema.json",
   "title": "Hub Configuration Schema",
   "description": "JSON Schema for Prompt Registry hub configuration files",
   "type": "object",

src/services/CopilotSyncService.ts

@@ -19,6 +19,7 @@ import * as path from 'path';
 import { promisify } from 'util';
 import * as yaml from 'js-yaml';
 import { Logger } from '../utils/logger';
+import { escapeRegex } from '../utils/regexUtils';
 import { DeploymentManifest } from '../types/registry';
 
 const readFile = promisify(fs.readFile);
@@ -74,7 +75,8 @@ export class CopilotSyncService {
             const baseDir = path.dirname(path.dirname(globalStoragePath));
 
             // Check if we're in a profiles structure
-            const profilesMatch = baseDir.match(new RegExp(`profiles${path.sep}([^${path.sep}]+)`));
+            const escapedSep = escapeRegex(path.sep);
+            const profilesMatch = baseDir.match(new RegExp(`profiles${escapedSep}([^${escapedSep}]+)`));
             if (profilesMatch) {
                 const profileId = profilesMatch[1];
                 const profileName = this.getActiveProfileName(baseDir) || profileId;
@@ -91,7 +93,8 @@ export class CopilotSyncService {
         // Check if this is a profile-based path by looking for '/profiles/' after User
         // Path structure: .../User/profiles/<profile-id>/globalStorage/...
         const remainingPath = globalStoragePath.substring(userDir.length);
-        const profilesMatch = remainingPath.match(new RegExp(`^${path.sep}profiles${path.sep}([^${path.sep}]+)`));
+        const escapedSep = escapeRegex(path.sep);
+        const profilesMatch = remainingPath.match(new RegExp(`^${escapedSep}profiles${escapedSep}([^${escapedSep}]+)`));
 
         if (profilesMatch) {
             // Profile-based path: include the profile directory

src/services/PromptExecutor.ts

@@ -5,6 +5,7 @@
 
 import * as vscode from 'vscode';
 import { Logger } from '../utils/logger';
+import { replaceVariables } from '../utils/regexUtils';
 
 export interface PromptExecutionOptions {
     promptContent: string;
@@ -142,13 +143,11 @@ export class PromptExecutor {
         variables: Record<string, string>,
         options: PromptExecutionOptions
     ): Promise<void> {
-        // Substitute template variables
-        let processedPrompt = promptTemplate;
-        
-        for (const [key, value] of Object.entries(variables)) {
-            const pattern = new RegExp(`\\{${key}\\}`, 'g');
-            processedPrompt = processedPrompt.replace(pattern, value);
-        }
+        // Substitute template variables using safe regex utility
+        const processedPrompt = replaceVariables(promptTemplate, variables, {
+            prefix: '{',
+            suffix: '}'
+        });
 
         // Execute with processed prompt
         await this.execute({

src/services/TemplateEngine.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { Logger } from '../utils/logger';
+import { replaceVariables } from '../utils/regexUtils';
 
 export interface TemplateContext {
     projectName: string;
@@ -73,11 +74,8 @@ export class TemplateEngine {
         // Enhance context with computed values
         const enhancedContext = this.enhanceContext(context);
 
-        // Substitute variables
-        for (const [key, value] of Object.entries(enhancedContext)) {
-            const placeholder = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
-            content = content.replace(placeholder, value);
-        }
+        // Substitute variables using safe regex utility
+        content = replaceVariables(content, enhancedContext);
 
         return content;
     }

src/services/githubService.ts

@@ -4,6 +4,7 @@ import * as semver from 'semver';
 import { GitHubRelease, GitHubAsset, VersionInfo, BundleInfo } from '../types/github';
 import { Platform } from '../types/platform';
 import { Logger } from '../utils/logger';
+import { escapeRegex } from '../utils/regexUtils';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 
@@ -302,7 +303,10 @@ export class GitHubService {
      */
     public findPlatformBundle(release: GitHubRelease, platform: Platform): BundleInfo | null {
         const platformPrefix = this.getPlatformPrefix(platform);
-        const bundlePattern = new RegExp(`^${platformPrefix}-installation-bundle-(.*)\\.zip$`, 'i');
+        // Note: Current platform prefixes ('vscode', 'windsurf', etc.) don't contain special chars,
+        // but escaping is kept for future-proofing in case platform names change
+        const escapedPrefix = escapeRegex(platformPrefix);
+        const bundlePattern = new RegExp(`^${escapedPrefix}-installation-bundle-(.*)\\.zip$`, 'i');
 
         for (const asset of release.assets) {
             const match = asset.name.match(bundlePattern);

src/utils/regexUtils.ts

@@ -0,0 +1,101 @@
+/**
+ * Regex utility functions for safe pattern matching and string replacement
+ * Handles cross-platform path issues (Windows backslashes, special characters)
+ */
+
+/**
+ * Escape special regex characters in a string
+ * This prevents strings (like Windows paths) from being interpreted as regex patterns
+ * 
+ * @param str - String to escape
+ * @returns Escaped string safe for use in RegExp constructor
+ * 
+ * @example
+ * ```typescript
+ * const path = 'C:\\Users\\Test\\file.txt';
+ * const escaped = escapeRegex(path);
+ * const regex = new RegExp(escaped); // Safe - won't throw
+ * ```
+ */
+export function escapeRegex(str: string): string {
+    // Escape all special regex characters: . * + ? ^ $ { } ( ) | [ ] \
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Create a RegExp from a string, escaping special characters
+ * 
+ * @param pattern - Pattern string to convert to regex
+ * @param flags - Optional regex flags (g, i, m, etc.)
+ * @returns RegExp object
+ * 
+ * @example
+ * ```typescript
+ * const regex = createSafeRegex('path.with.dots', 'g');
+ * // Matches literal "path.with.dots", not "path" followed by any chars
+ * ```
+ */
+export function createSafeRegex(pattern: string, flags?: string): RegExp {
+    return new RegExp(escapeRegex(pattern), flags);
+}
+
+/**
+ * Replace all occurrences of a literal string in text
+ * Safer than String.replace() with regex for dynamic patterns
+ * 
+ * @param text - Text to search in
+ * @param search - Literal string to find (will be escaped)
+ * @param replacement - Replacement string (special chars like $ and \ are preserved)
+ * @returns Text with replacements
+ * 
+ * @example
+ * ```typescript
+ * const template = 'Path: {{PATH}}';
+ * const windowsPath = 'C:\\Users\\Test';
+ * const result = replaceAll(template, '{{PATH}}', windowsPath);
+ * // Result: 'Path: C:\\Users\\Test' (backslashes preserved)
+ * ```
+ */
+export function replaceAll(text: string, search: string, replacement: string): string {
+    const escapedSearch = escapeRegex(search);
+    const regex = new RegExp(escapedSearch, 'g');
+    // Use function to prevent interpretation of $ and \ in replacement
+    return text.replace(regex, () => replacement);
+}
+
+/**
+ * Replace template variables in text with values
+ * Handles special characters in both keys and values safely
+ * 
+ * @param text - Template text with placeholders
+ * @param variables - Object with variable names and values
+ * @param options - Configuration options
+ * @returns Text with variables replaced
+ * 
+ * @example
+ * ```typescript
+ * const template = 'Install to: {{PATH}}, version: {{VERSION}}';
+ * const result = replaceVariables(template, {
+ *   PATH: 'C:\\Users\\Test',
+ *   VERSION: '1.0.0'
+ * });
+ * ```
+ */
+export function replaceVariables(
+    text: string,
+    variables: Record<string, string>,
+    options: {
+        prefix?: string;
+        suffix?: string;
+    } = {}
+): string {
+    const { prefix = '{{', suffix = '}}' } = options;
+    let result = text;
+    
+    for (const [key, value] of Object.entries(variables)) {
+        const placeholder = `${prefix}${key}${suffix}`;
+        result = replaceAll(result, placeholder, value);
+    }
+    
+    return result;
+}

test/services/CopilotSyncService.test.ts

@@ -8,7 +8,6 @@
 
 import * as assert from 'assert';
 import * as path from 'path';
-import * as os from 'os';
 import * as fs from 'fs';
 import { CopilotSyncService } from '../../src/services/CopilotSyncService';
 
@@ -181,6 +180,131 @@ suite('CopilotSyncService', () => {
         });
     });
 
+    suite('Windows Path Regex Handling (Backslash Escaping)', () => {
+        // These tests verify the fix for: "Invalid regular expression: /\profiles\([^\]+)/: Unterminated character class"
+        // The issue was that Windows path.sep (\) wasn't properly escaped in regex character classes
+        
+        test('should handle Windows-style path with backslashes - standard profile', async () => {
+            // Use path.join to create platform-appropriate paths
+            const userPath = path.join(tempDir, 'WinTest', 'Users', 'Username', 'AppData', 'Roaming', 'Code', 'User');
+            const globalStoragePath = path.join(userPath, 'globalStorage', 'amadeusitgroup.prompt-registry');
+            
+            const winContext = {
+                globalStorageUri: { fsPath: globalStoragePath },
+                storageUri: { fsPath: tempDir },
+                extensionPath: __dirname,
+                subscriptions: [],
+            } as any;
+            
+            const winService = new CopilotSyncService(winContext);
+            
+            // The key test: should not throw "Invalid regular expression" or "Unterminated character class"
+            const status = await winService.getStatus();
+            
+            // Should successfully parse without regex errors
+            assert.ok(status.copilotDir, 'Should return a valid path');
+            assert.ok(status.copilotDir.includes('User'), 'Should include User directory');
+            assert.ok(status.copilotDir.endsWith('prompts'), 'Should end with prompts');
+            
+            const expectedPath = path.join(userPath, 'prompts');
+            assert.strictEqual(status.copilotDir, expectedPath, 'Should resolve to User/prompts');
+        });
+
+        test('should handle Windows-style path with backslashes - profile-based', async () => {
+            // Simulate the exact error case from the screenshot
+            const userPath = path.join(tempDir, 'WinProfile', 'Users', 'Username', '.vscode', 'extensions', 'dist', 'User');
+            const profileId = 'security-best-practices';
+            const globalStoragePath = path.join(userPath, 'profiles', profileId, 'globalStorage', 'amadeusitgroup.prompt-registry');
+            
+            const winProfileContext = {
+                globalStorageUri: { fsPath: globalStoragePath },
+                storageUri: { fsPath: tempDir },
+                extensionPath: __dirname,
+                subscriptions: [],
+            } as any;
+            
+            const winProfileService = new CopilotSyncService(winProfileContext);
+            
+            // The key test: should not throw regex errors
+            const status = await winProfileService.getStatus();
+            
+            // Should successfully parse the profile path without regex errors
+            assert.ok(status.copilotDir, 'Should return a valid path');
+            assert.ok(status.copilotDir.includes('profiles'), 'Should include profiles directory');
+            assert.ok(status.copilotDir.includes(profileId), 'Should include profile ID');
+            assert.ok(status.copilotDir.endsWith('prompts'), 'Should end with prompts');
+            
+            const expectedPath = path.join(userPath, 'profiles', profileId, 'prompts');
+            assert.strictEqual(status.copilotDir, expectedPath, 'Should resolve to profile prompts directory');
+        });
+
+        test('should handle Windows-style path - custom data directory with profile', async () => {
+            // Test custom data directory (no User folder) with profile
+            const customDataDir = path.join(tempDir, 'CustomVSCode', 'Data');
+            const profileId = 'work-profile';
+            const globalStoragePath = path.join(customDataDir, 'profiles', profileId, 'globalStorage', 'publisher.extension');
+            
+            const customContext = {
+                globalStorageUri: { fsPath: globalStoragePath },
+                storageUri: { fsPath: tempDir },
+                extensionPath: __dirname,
+                subscriptions: [],
+            } as any;
+            
+            const customService = new CopilotSyncService(customContext);
+            
+            // The key test: should not throw regex errors
+            const status = await customService.getStatus();
+            
+            // Should handle custom data directory with profiles
+            assert.ok(status.copilotDir, 'Should return a valid path');
+            assert.ok(status.copilotDir.includes('profiles'), 'Should include profiles directory');
+            assert.ok(status.copilotDir.includes(profileId), 'Should include profile ID');
+            
+            const expectedPath = path.join(customDataDir, 'profiles', profileId, 'prompts');
+            assert.strictEqual(status.copilotDir, expectedPath, 'Should resolve custom data dir with profile');
+        });
+
+        test('should not throw regex errors with any path separator', async () => {
+            // This is the core regression test for the bug fix
+            // The bug was: new RegExp(`[^${path.sep}]`) would create [^\] on Windows
+            // which is an unterminated character class
+            
+            const testPath = path.join(tempDir, 'RegexTest', 'Code', 'User', 'profiles', 'test-id', 'globalStorage', 'ext');
+            
+            const testContext = {
+                globalStorageUri: { fsPath: testPath },
+                storageUri: { fsPath: tempDir },
+                extensionPath: __dirname,
+                subscriptions: [],
+            } as any;
+            
+            const testService = new CopilotSyncService(testContext);
+            
+            // Should not throw regex errors regardless of platform
+            try {
+                const status = await testService.getStatus();
+                assert.ok(status, 'Should successfully get status');
+                assert.ok(status.copilotDir, 'Should return a path');
+            } catch (error: any) {
+                // The specific errors we're testing for
+                assert.ok(
+                    !error.message.includes('Invalid regular expression'),
+                    `Should not throw "Invalid regular expression", got: ${error.message}`
+                );
+                assert.ok(
+                    !error.message.includes('Unterminated character class'),
+                    `Should not throw "Unterminated character class", got: ${error.message}`
+                );
+                assert.ok(
+                    !error.message.includes('SyntaxError'),
+                    `Should not throw SyntaxError from regex, got: ${error.message}`
+                );
+                // If it's a different error (like file not found), that's acceptable for this test
+            }
+        });
+    });
+
     suite('getStatus', () => {
         test('should return status information', async () => {
             const status = await service.getStatus();