cntx-ui 2.0.0 → 2.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cntx-ui",
   "type": "module",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Minimal file bundling and tagging tool for AI development",
   "keywords": [
     "ai",

package/server.js

@@ -29,6 +29,7 @@ export class CntxServer {
     this.CNTX_DIR = join(cwd, '.cntx');
     this.CONFIG_FILE = join(this.CNTX_DIR, 'config.json');
     this.BUNDLES_FILE = join(this.CNTX_DIR, 'bundles.json');
+    this.HIDDEN_FILES_CONFIG = join(this.CNTX_DIR, 'hidden-files.json');
     this.IGNORE_FILE = join(cwd, '.cntxignore');
     this.CURSOR_RULES_FILE = join(cwd, '.cursorrules');
 
@@ -37,11 +38,19 @@ export class CntxServer {
     this.watchers = [];
     this.clients = new Set();
     this.isScanning = false;
+
+    this.hiddenFilesConfig = {
+      globalHidden: [], // Files hidden across all bundles
+      bundleSpecific: {}, // Files hidden per bundle: { bundleName: [filePaths] }
+      userIgnorePatterns: [], // User-added ignore patterns
+      disabledSystemPatterns: [] // System patterns the user disabled
+    };
   }
 
   init() {
     if (!existsSync(this.CNTX_DIR)) mkdirSync(this.CNTX_DIR, { recursive: true });
     this.loadConfig();
+    this.loadHiddenFilesConfig();
     this.loadIgnorePatterns();
     this.loadBundleStates();
     this.startWatching();
@@ -75,21 +84,183 @@ export class CntxServer {
     }
   }
 
+  loadHiddenFilesConfig() {
+    if (existsSync(this.HIDDEN_FILES_CONFIG)) {
+      try {
+        const config = JSON.parse(readFileSync(this.HIDDEN_FILES_CONFIG, 'utf8'));
+        this.hiddenFilesConfig = { ...this.hiddenFilesConfig, ...config };
+      } catch (e) {
+        console.warn('Could not load hidden files config:', e.message);
+      }
+    }
+  }
+
+  saveHiddenFilesConfig() {
+    try {
+      writeFileSync(this.HIDDEN_FILES_CONFIG, JSON.stringify(this.hiddenFilesConfig, null, 2));
+    } catch (e) {
+      console.error('Failed to save hidden files config:', e.message);
+    }
+  }
+
+  isFileHidden(filePath, bundleName = null) {
+    // Check global hidden files
+    if (this.hiddenFilesConfig.globalHidden.includes(filePath)) {
+      return true;
+    }
+
+    // Check bundle-specific hidden files
+    if (bundleName && this.hiddenFilesConfig.bundleSpecific[bundleName]) {
+      return this.hiddenFilesConfig.bundleSpecific[bundleName].includes(filePath);
+    }
+
+    return false;
+  }
+
+  toggleFileVisibility(filePath, bundleName = null, forceHide = null) {
+    if (bundleName) {
+      // Bundle-specific hiding
+      if (!this.hiddenFilesConfig.bundleSpecific[bundleName]) {
+        this.hiddenFilesConfig.bundleSpecific[bundleName] = [];
+      }
+
+      const bundleHidden = this.hiddenFilesConfig.bundleSpecific[bundleName];
+      const isCurrentlyHidden = bundleHidden.includes(filePath);
+
+      if (forceHide === null) {
+        // Toggle current state
+        if (isCurrentlyHidden) {
+          this.hiddenFilesConfig.bundleSpecific[bundleName] = bundleHidden.filter(f => f !== filePath);
+        } else {
+          bundleHidden.push(filePath);
+        }
+      } else {
+        // Force to specific state
+        if (forceHide && !isCurrentlyHidden) {
+          bundleHidden.push(filePath);
+        } else if (!forceHide && isCurrentlyHidden) {
+          this.hiddenFilesConfig.bundleSpecific[bundleName] = bundleHidden.filter(f => f !== filePath);
+        }
+      }
+    } else {
+      // Global hiding
+      const isCurrentlyHidden = this.hiddenFilesConfig.globalHidden.includes(filePath);
+
+      if (forceHide === null) {
+        // Toggle current state
+        if (isCurrentlyHidden) {
+          this.hiddenFilesConfig.globalHidden = this.hiddenFilesConfig.globalHidden.filter(f => f !== filePath);
+        } else {
+          this.hiddenFilesConfig.globalHidden.push(filePath);
+        }
+      } else {
+        // Force to specific state
+        if (forceHide && !isCurrentlyHidden) {
+          this.hiddenFilesConfig.globalHidden.push(filePath);
+        } else if (!forceHide && isCurrentlyHidden) {
+          this.hiddenFilesConfig.globalHidden = this.hiddenFilesConfig.globalHidden.filter(f => f !== filePath);
+        }
+      }
+    }
+
+    this.saveHiddenFilesConfig();
+  }
+
+  bulkToggleFileVisibility(filePaths, bundleName = null, forceHide = null) {
+    filePaths.forEach(filePath => {
+      this.toggleFileVisibility(filePath, bundleName, forceHide);
+    });
+  }
+
+  addUserIgnorePattern(pattern) {
+    if (!this.hiddenFilesConfig.userIgnorePatterns.includes(pattern)) {
+      this.hiddenFilesConfig.userIgnorePatterns.push(pattern);
+      this.saveHiddenFilesConfig();
+      this.loadIgnorePatterns();
+      this.generateAllBundles();
+      return true;
+    }
+    return false;
+  }
+
+  removeUserIgnorePattern(pattern) {
+    const index = this.hiddenFilesConfig.userIgnorePatterns.indexOf(pattern);
+    if (index > -1) {
+      this.hiddenFilesConfig.userIgnorePatterns.splice(index, 1);
+      this.saveHiddenFilesConfig();
+      this.loadIgnorePatterns();
+      this.generateAllBundles();
+      return true;
+    }
+    return false;
+  }
+
+  toggleSystemIgnorePattern(pattern) {
+    const index = this.hiddenFilesConfig.disabledSystemPatterns.indexOf(pattern);
+    if (index > -1) {
+      // Re-enable the pattern
+      this.hiddenFilesConfig.disabledSystemPatterns.splice(index, 1);
+    } else {
+      // Disable the pattern
+      this.hiddenFilesConfig.disabledSystemPatterns.push(pattern);
+    }
+
+    this.saveHiddenFilesConfig();
+    this.loadIgnorePatterns();
+    this.generateAllBundles();
+  }
+
   loadIgnorePatterns() {
+    const systemPatterns = [
+      '**/.git/**',
+      '**/node_modules/**',
+      '**/.cntx/**'
+    ];
+
+    // Read from .cntxignore file
+    let filePatterns = [];
     if (existsSync(this.IGNORE_FILE)) {
-      this.ignorePatterns = readFileSync(this.IGNORE_FILE, 'utf8')
+      filePatterns = readFileSync(this.IGNORE_FILE, 'utf8')
         .split('\n')
         .map(line => line.trim())
         .filter(line => line && !line.startsWith('#'));
-    } else {
-      this.ignorePatterns = [
-        // Keep minimal patterns since we handle most stuff in shouldIgnoreAnything
-        '**/.git/**',
-        '**/node_modules/**',
-        '**/.cntx/**'
-      ];
-      writeFileSync(this.IGNORE_FILE, this.ignorePatterns.join('\n'));
     }
+
+    // Combine all patterns
+    this.ignorePatterns = [
+      // System patterns (filtered by disabled list)
+      ...systemPatterns.filter(pattern =>
+        !this.hiddenFilesConfig.disabledSystemPatterns.includes(pattern)
+      ),
+      // File patterns
+      ...filePatterns.filter(pattern =>
+        !systemPatterns.includes(pattern) &&
+        !this.hiddenFilesConfig.userIgnorePatterns.includes(pattern)
+      ),
+      // User-added patterns
+      ...this.hiddenFilesConfig.userIgnorePatterns
+    ];
+
+    // Update .cntxignore file with current patterns
+    const allPatterns = [
+      '# System patterns',
+      ...systemPatterns.map(pattern =>
+        this.hiddenFilesConfig.disabledSystemPatterns.includes(pattern)
+          ? `# ${pattern}`
+          : pattern
+      ),
+      '',
+      '# User patterns',
+      ...this.hiddenFilesConfig.userIgnorePatterns,
+      '',
+      '# File-specific patterns (edit manually)',
+      ...filePatterns.filter(pattern =>
+        !systemPatterns.includes(pattern) &&
+        !this.hiddenFilesConfig.userIgnorePatterns.includes(pattern)
+      )
+    ];
+
+    writeFileSync(this.IGNORE_FILE, allPatterns.join('\n'));
   }
 
   loadBundleStates() {
@@ -534,10 +705,15 @@ Add your specific project rules and preferences below:
     console.log(`Generating bundle: ${name}`);
     const allFiles = this.getAllFiles();
 
-    bundle.files = allFiles.filter(file =>
+    // Filter files by bundle patterns
+    let bundleFiles = allFiles.filter(file =>
       bundle.patterns.some(pattern => this.matchesPattern(file, pattern))
     );
 
+    // Remove hidden files
+    bundleFiles = bundleFiles.filter(file => !this.isFileHidden(file, name));
+
+    bundle.files = bundleFiles;
     bundle.content = this.generateBundleXML(name, bundle.files);
     bundle.changed = false;
     bundle.lastGenerated = new Date().toISOString();
@@ -606,6 +782,53 @@ Add your specific project rules and preferences below:
       .replace(/'/g, ''');
   }
 
+  getFileStats(filePath) {
+    try {
+      const fullPath = join(this.CWD, filePath);
+      const stat = statSync(fullPath);
+      return {
+        size: stat.size,
+        mtime: stat.mtime
+      };
+    } catch (e) {
+      return {
+        size: 0,
+        mtime: new Date()
+      };
+    }
+  }
+
+  getFileListWithVisibility(bundleName = null) {
+    const allFiles = this.getAllFiles();
+
+    return allFiles.map(filePath => {
+      const fileStats = this.getFileStats(filePath);
+      const isGloballyHidden = this.hiddenFilesConfig.globalHidden.includes(filePath);
+      const bundleHidden = bundleName ? this.isFileHidden(filePath, bundleName) : false;
+
+      // Determine which bundles this file appears in
+      const inBundles = [];
+      this.bundles.forEach((bundle, name) => {
+        const matchesPattern = bundle.patterns.some(pattern => this.matchesPattern(filePath, pattern));
+        const notHidden = !this.isFileHidden(filePath, name);
+        if (matchesPattern && notHidden) {
+          inBundles.push(name);
+        }
+      });
+
+      return {
+        path: filePath,
+        size: fileStats.size,
+        modified: fileStats.mtime,
+        visible: !isGloballyHidden && !bundleHidden,
+        globallyHidden: isGloballyHidden,
+        bundleHidden: bundleHidden,
+        inBundles: inBundles,
+        matchesIgnorePattern: this.shouldIgnoreFile(join(this.CWD, filePath))
+      };
+    });
+  }
+
   startServer(port = 3333) {
     const server = createServer((req, res) => {
       const url = new URL(req.url, `http://localhost:${port}`);
@@ -705,7 +928,7 @@ Add your specific project rules and preferences below:
         }
       }
 
-      // API Routes (existing code continues here...)
+      // API Routes
       if (url.pathname === '/api/bundles') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         const bundleData = Array.from(this.bundles.entries()).map(([name, bundle]) => ({
@@ -865,6 +1088,167 @@ Add your specific project rules and preferences below:
           res.end('Method not allowed');
         }
 
+      } else if (url.pathname === '/api/hidden-files') {
+        if (req.method === 'GET') {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          const stats = {
+            totalFiles: this.getAllFiles().length,
+            globallyHidden: this.hiddenFilesConfig.globalHidden.length,
+            bundleSpecificHidden: this.hiddenFilesConfig.bundleSpecific,
+            ignorePatterns: {
+              system: [
+                { pattern: '**/.git/**', active: !this.hiddenFilesConfig.disabledSystemPatterns.includes('**/.git/**') },
+                { pattern: '**/node_modules/**', active: !this.hiddenFilesConfig.disabledSystemPatterns.includes('**/node_modules/**') },
+                { pattern: '**/.cntx/**', active: !this.hiddenFilesConfig.disabledSystemPatterns.includes('**/.cntx/**') }
+              ],
+              user: this.hiddenFilesConfig.userIgnorePatterns,
+              disabled: this.hiddenFilesConfig.disabledSystemPatterns
+            }
+          };
+          res.end(JSON.stringify(stats));
+        } else if (req.method === 'POST') {
+          let body = '';
+          req.on('data', chunk => body += chunk);
+          req.on('end', () => {
+            try {
+              const { action, filePath, filePaths, bundleName, forceHide } = JSON.parse(body);
+
+              if (action === 'toggle' && filePath) {
+                this.toggleFileVisibility(filePath, bundleName, forceHide);
+              } else if (action === 'bulk-toggle' && filePaths) {
+                this.bulkToggleFileVisibility(filePaths, bundleName, forceHide);
+              }
+
+              this.generateAllBundles();
+              this.broadcastUpdate();
+
+              res.writeHead(200, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ success: true }));
+            } catch (e) {
+              res.writeHead(400, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: e.message }));
+            }
+          });
+        }
+
+      } else if (url.pathname === '/api/files-with-visibility') {
+        const bundleName = url.searchParams.get('bundle');
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        const files = this.getFileListWithVisibility(bundleName);
+        res.end(JSON.stringify(files));
+
+      } else if (url.pathname === '/api/ignore-patterns') {
+        if (req.method === 'GET') {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+
+          // Read file patterns
+          let filePatterns = [];
+          if (existsSync(this.IGNORE_FILE)) {
+            filePatterns = readFileSync(this.IGNORE_FILE, 'utf8')
+              .split('\n')
+              .map(line => line.trim())
+              .filter(line => line && !line.startsWith('#'));
+          }
+
+          const systemPatterns = ['**/.git/**', '**/node_modules/**', '**/.cntx/**'];
+
+          const patterns = {
+            system: systemPatterns.map(pattern => ({
+              pattern,
+              active: !this.hiddenFilesConfig.disabledSystemPatterns.includes(pattern)
+            })),
+            user: this.hiddenFilesConfig.userIgnorePatterns.map(pattern => ({ pattern, active: true })),
+            file: filePatterns.filter(pattern =>
+              !systemPatterns.includes(pattern) &&
+              !this.hiddenFilesConfig.userIgnorePatterns.includes(pattern)
+            ).map(pattern => ({ pattern, active: true }))
+          };
+          res.end(JSON.stringify(patterns));
+
+        } else if (req.method === 'POST') {
+          let body = '';
+          req.on('data', chunk => body += chunk);
+          req.on('end', () => {
+            try {
+              const { action, pattern } = JSON.parse(body);
+              let success = false;
+
+              switch (action) {
+                case 'add':
+                  success = this.addUserIgnorePattern(pattern);
+                  break;
+                case 'remove':
+                  success = this.removeUserIgnorePattern(pattern);
+                  break;
+                case 'toggle-system':
+                  this.toggleSystemIgnorePattern(pattern);
+                  success = true;
+                  break;
+              }
+
+              this.broadcastUpdate();
+              res.writeHead(200, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ success }));
+            } catch (e) {
+              res.writeHead(400, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: e.message }));
+            }
+          });
+        }
+
+      } else if (url.pathname === '/api/bundle-visibility-stats') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        const stats = {};
+
+        this.bundles.forEach((bundle, bundleName) => {
+          const allFiles = this.getAllFiles();
+          const matchingFiles = allFiles.filter(file =>
+            bundle.patterns.some(pattern => this.matchesPattern(file, pattern))
+          );
+
+          const visibleFiles = matchingFiles.filter(file => !this.isFileHidden(file, bundleName));
+          const hiddenFiles = matchingFiles.length - visibleFiles.length;
+
+          stats[bundleName] = {
+            total: matchingFiles.length,
+            visible: visibleFiles.length,
+            hidden: hiddenFiles,
+            patterns: bundle.patterns
+          };
+        });
+
+        res.end(JSON.stringify(stats));
+
+      } else if (url.pathname === '/api/reset-hidden-files') {
+        if (req.method === 'POST') {
+          let body = '';
+          req.on('data', chunk => body += chunk);
+          req.on('end', () => {
+            try {
+              const { scope, bundleName } = JSON.parse(body);
+
+              if (scope === 'global') {
+                this.hiddenFilesConfig.globalHidden = [];
+              } else if (scope === 'bundle' && bundleName) {
+                delete this.hiddenFilesConfig.bundleSpecific[bundleName];
+              } else if (scope === 'all') {
+                this.hiddenFilesConfig.globalHidden = [];
+                this.hiddenFilesConfig.bundleSpecific = {};
+              }
+
+              this.saveHiddenFilesConfig();
+              this.generateAllBundles();
+              this.broadcastUpdate();
+
+              res.writeHead(200, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ success: true }));
+            } catch (e) {
+              res.writeHead(400, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: e.message }));
+            }
+          });
+        }
+
       } else {
         res.writeHead(404);
         res.end('Not found');