ctxman 3.0.0

package/lib/watch/FileWatcher.js

@@ -0,0 +1,208 @@
+/**
+ * FileWatcher - Real-Time File Watching Module
+ * v3.0.0 - Watch mode
+ *
+ * Responsibilities:
+ * - Watch file system for changes
+ * - Debounce rapid changes
+ * - Emit change events
+ * - Support ignore patterns
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { EventEmitter } from 'events';
+import GitIgnoreParser from '../parsers/gitignore-parser.js';
+import { getLogger } from '../utils/logger.js';
+
+const logger = getLogger('FileWatcher');
+
+export class FileWatcher extends EventEmitter {
+  constructor(rootPath, options = {}) {
+    super();
+
+    this.rootPath = rootPath;
+    this.options = {
+      debounce: 1000, // 1 second debounce
+      recursive: true,
+      ignorePatterns: [],
+      ...options
+    };
+
+    // Initialize GitIgnoreParser with correct file paths
+    const gitignorePath = path.join(rootPath, '.gitignore');
+    const contextIgnorePath = path.join(rootPath, '.contextignore');
+    const contextIncludePath = path.join(rootPath, '.contextinclude');
+
+    this.gitIgnore = new GitIgnoreParser(gitignorePath, contextIgnorePath, contextIncludePath);
+    this.watchers = [];
+    this.debounceTimers = new Map();
+    this.isWatching = false;
+
+    this.stats = {
+      totalChanges: 0,
+      ignoredChanges: 0,
+      errors: 0
+    };
+  }
+
+  /**
+   * Start watching
+   */
+  start() {
+    if (this.isWatching) {
+      logger.warn('Already watching');
+      return;
+    }
+
+    logger.info(`Starting file watch: ${this.rootPath}`);
+
+    try {
+      const watcher = fs.watch(
+        this.rootPath,
+        { recursive: this.options.recursive },
+        (eventType, filename) => {
+          this.handleFileChange(eventType, filename);
+        }
+      );
+
+      this.watchers.push(watcher);
+      this.isWatching = true;
+
+      this.emit('watch:started', { path: this.rootPath });
+      logger.info('Watch mode started');
+
+    } catch (error) {
+      logger.error(`Failed to start watch: ${error.message}`);
+      this.emit('watch:error', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Stop watching
+   */
+  stop() {
+    if (!this.isWatching) {
+      return;
+    }
+
+    logger.info('Stopping file watch...');
+
+    // Close all watchers
+    for (const watcher of this.watchers) {
+      watcher.close();
+    }
+
+    // Clear debounce timers
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+
+    this.watchers = [];
+    this.debounceTimers.clear();
+    this.isWatching = false;
+
+    this.emit('watch:stopped');
+    logger.info('Watch mode stopped');
+  }
+
+  /**
+   * Handle file change event
+   * @param {string} eventType - 'rename' or 'change'
+   * @param {string} filename - Changed file name
+   */
+  handleFileChange(eventType, filename) {
+    if (!filename) return;
+
+    const filePath = path.join(this.rootPath, filename);
+    const relativePath = path.relative(this.rootPath, filePath);
+
+    // Check ignore patterns
+    if (this.shouldIgnore(relativePath)) {
+      this.stats.ignoredChanges++;
+      return;
+    }
+
+    this.stats.totalChanges++;
+
+    // Debounce rapid changes
+    if (this.debounceTimers.has(filePath)) {
+      clearTimeout(this.debounceTimers.get(filePath));
+    }
+
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(filePath);
+      this.emitFileChange(eventType, filePath, relativePath);
+    }, this.options.debounce);
+
+    this.debounceTimers.set(filePath, timer);
+  }
+
+  /**
+   * Emit file change event
+   * @param {string} eventType
+   * @param {string} filePath
+   * @param {string} relativePath
+   */
+  emitFileChange(eventType, filePath, relativePath) {
+    logger.debug(`File ${eventType}: ${relativePath}`);
+
+    const event = {
+      type: eventType,
+      path: filePath,
+      relativePath: relativePath,
+      timestamp: Date.now(),
+      exists: fs.existsSync(filePath)
+    };
+
+    // Add file stats if exists
+    if (event.exists) {
+      try {
+        const stats = fs.statSync(filePath);
+        event.size = stats.size;
+        event.modified = stats.mtime;
+      } catch (error) {
+        // Stats not available
+      }
+    }
+
+    this.emit('file:changed', event);
+  }
+
+  /**
+   * Check if file should be ignored
+   * @param {string} relativePath
+   * @returns {boolean}
+   */
+  shouldIgnore(relativePath) {
+    // Use GitIgnoreParser for ignore rules
+    return !this.gitIgnore.shouldIncludeFile(relativePath);
+  }
+
+  /**
+   * Get watch statistics
+   * @returns {object}
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      isWatching: this.isWatching,
+      activeWatchers: this.watchers.length,
+      pendingDebounce: this.debounceTimers.size
+    };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalChanges: 0,
+      ignoredChanges: 0,
+      errors: 0
+    };
+  }
+}
+
+export default FileWatcher;

package/lib/watch/IncrementalAnalyzer.js

@@ -0,0 +1,206 @@
+/**
+ * IncrementalAnalyzer - Incremental Analysis Module
+ * v3.0.0 - Watch mode
+ *
+ * Responsibilities:
+ * - Perform incremental analysis on file changes
+ * - Update aggregate statistics
+ * - Emit analysis events
+ * - Optimize for performance
+ */
+
+import { EventEmitter } from 'events';
+import { Analyzer } from '../core/Analyzer.js';
+import { getLogger } from '../utils/logger.js';
+
+const logger = getLogger('IncrementalAnalyzer');
+
+export class IncrementalAnalyzer extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    this.options = {
+      autoAnalyze: true,
+      ...options
+    };
+
+    this.analyzer = new Analyzer(options);
+    this.fileCache = new Map(); // Cache of file analyses
+    this.aggregateStats = null;
+  }
+
+  /**
+   * Analyze changed file and update stats
+   * @param {FileChangeEvent} changeEvent
+   */
+  async analyzeChange(changeEvent) {
+    logger.debug(`Analyzing change: ${changeEvent.relativePath}`);
+
+    const startTime = Date.now();
+
+    try {
+      // If file deleted, remove from cache
+      if (!changeEvent.exists) {
+        this.handleFileDeleted(changeEvent);
+        return;
+      }
+
+      // Analyze file
+      const fileInfo = {
+        path: changeEvent.path,
+        relativePath: changeEvent.relativePath,
+        name: path.basename(changeEvent.path),
+        extension: path.extname(changeEvent.path),
+        size: changeEvent.size,
+        modified: changeEvent.modified
+      };
+
+      const analysis = await this.analyzer.analyzeFile(fileInfo);
+
+      if (analysis) {
+        // Update cache
+        const oldAnalysis = this.fileCache.get(changeEvent.path);
+        this.fileCache.set(changeEvent.path, analysis);
+
+        // Update aggregate stats
+        this.updateAggregateStats(oldAnalysis, analysis);
+
+        const elapsed = Date.now() - startTime;
+
+        this.emit('analysis:complete', {
+          file: changeEvent.relativePath,
+          analysis,
+          elapsed,
+          cached: false
+        });
+
+        logger.debug(`Analysis complete: ${changeEvent.relativePath} (${elapsed}ms)`);
+      }
+
+    } catch (error) {
+      logger.error(`Analysis failed for ${changeEvent.relativePath}: ${error.message}`);
+      this.emit('analysis:error', {
+        file: changeEvent.relativePath,
+        error
+      });
+    }
+  }
+
+  /**
+   * Handle file deletion
+   * @param {FileChangeEvent} changeEvent
+   */
+  handleFileDeleted(changeEvent) {
+    const oldAnalysis = this.fileCache.get(changeEvent.path);
+
+    if (oldAnalysis) {
+      // Remove from cache
+      this.fileCache.delete(changeEvent.path);
+
+      // Update stats (subtract)
+      if (this.aggregateStats) {
+        this.aggregateStats.totalFiles--;
+        this.aggregateStats.totalTokens -= oldAnalysis.tokens;
+        this.aggregateStats.totalSize -= oldAnalysis.size;
+
+        // Update language stats
+        const lang = oldAnalysis.language;
+        if (this.aggregateStats.byLanguage[lang]) {
+          this.aggregateStats.byLanguage[lang].files--;
+          this.aggregateStats.byLanguage[lang].tokens -= oldAnalysis.tokens;
+          this.aggregateStats.byLanguage[lang].size -= oldAnalysis.size;
+        }
+      }
+
+      this.emit('file:deleted', {
+        file: changeEvent.relativePath,
+        oldTokens: oldAnalysis.tokens
+      });
+
+      logger.debug(`File deleted from cache: ${changeEvent.relativePath}`);
+    }
+  }
+
+  /**
+   * Update aggregate statistics
+   * @param {FileAnalysis|null} oldAnalysis
+   * @param {FileAnalysis} newAnalysis
+   */
+  updateAggregateStats(oldAnalysis, newAnalysis) {
+    if (!this.aggregateStats) {
+      this.aggregateStats = this.analyzer.getStats();
+    }
+
+    // Subtract old values if exists
+    if (oldAnalysis) {
+      this.aggregateStats.totalTokens -= oldAnalysis.tokens;
+      this.aggregateStats.totalSize -= oldAnalysis.size;
+
+      const oldLang = oldAnalysis.language;
+      if (this.aggregateStats.byLanguage[oldLang]) {
+        this.aggregateStats.byLanguage[oldLang].tokens -= oldAnalysis.tokens;
+        this.aggregateStats.byLanguage[oldLang].size -= oldAnalysis.size;
+      }
+    } else {
+      // New file
+      this.aggregateStats.totalFiles++;
+    }
+
+    // Add new values
+    this.aggregateStats.totalTokens += newAnalysis.tokens;
+    this.aggregateStats.totalSize += newAnalysis.size;
+
+    const lang = newAnalysis.language;
+    if (!this.aggregateStats.byLanguage[lang]) {
+      this.aggregateStats.byLanguage[lang] = { files: 0, tokens: 0, size: 0 };
+    }
+
+    if (!oldAnalysis) {
+      this.aggregateStats.byLanguage[lang].files++;
+    }
+
+    this.aggregateStats.byLanguage[lang].tokens += newAnalysis.tokens;
+    this.aggregateStats.byLanguage[lang].size += newAnalysis.size;
+
+    // Emit stats update
+    this.emit('stats:updated', this.aggregateStats);
+  }
+
+  /**
+   * Get current aggregate statistics
+   * @returns {object}
+   */
+  getStats() {
+    return this.aggregateStats || this.analyzer.getStats();
+  }
+
+  /**
+   * Get cached file analysis
+   * @param {string} filePath
+   * @returns {FileAnalysis|null}
+   */
+  getCachedAnalysis(filePath) {
+    return this.fileCache.get(filePath) || null;
+  }
+
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.fileCache.clear();
+    logger.info('Analysis cache cleared');
+  }
+
+  /**
+   * Get cache statistics
+   * @returns {object}
+   */
+  getCacheStats() {
+    return {
+      cachedFiles: this.fileCache.size,
+      cacheSize: this.fileCache.size * 1024 // Rough estimate
+    };
+  }
+}
+
+export default IncrementalAnalyzer;

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "ctxman",
+  "version": "3.0.0",
+  "description": "AI Development Platform with plugin architecture, Git integration, REST API, watch mode, LLM optimization, and support for 14+ languages. Features include TOON format (40-50% token reduction), real-time analysis, and comprehensive context generation.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "ctxman": "bin/cli.js"
+  },
+  "exports": {
+    ".": "./index.js"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "analyze": "node bin/cli.js",
+    "analyze:cli": "node bin/cli.js --cli",
+    "analyze:methods": "node bin/cli.js --cli --method-level",
+    "analyze:gitingest": "node bin/cli.js --cli --gitingest",
+    "serve": "node bin/cli.js serve",
+    "watch": "node bin/cli.js watch",
+    "github": "node bin/cm-gitingest.js",
+    "install:local": "bash scripts/install.sh",
+    "uninstall:local": "bash scripts/uninstall.sh",
+    "install:windows": "powershell -ExecutionPolicy Bypass -File scripts/install.ps1",
+    "uninstall:windows": "powershell -ExecutionPolicy Bypass -File scripts/uninstall.ps1",
+    "update:check": "node bin/cm-update.js check",
+    "update:install": "node bin/cm-update.js install",
+    "update:rollback": "node bin/cm-update.js rollback",
+    "update:channel": "node bin/cm-update.js channel",
+    "build": "echo 'No build step required'",
+    "build:deb": "make build-deb",
+    "prepublishOnly": "npm test",
+    "mcp": "node bin/mcp-server.js",
+    "postinstall": "node -e \"console.log('\\n✅ Ctxman installed! Run: ctxman --help\\n')\""
+  },
+  "keywords": [
+    "code",
+    "analysis",
+    "llm",
+    "context",
+    "plugin-system",
+    "git-integration",
+    "api-server",
+    "watch-mode",
+    "method-level",
+    "javascript",
+    "typescript",
+    "rust",
+    "csharp",
+    "go",
+    "java",
+    "python",
+    "php",
+    "ruby",
+    "kotlin",
+    "swift",
+    "cpp",
+    "scala",
+    "multi-language",
+    "ast",
+    "tiktoken",
+    "optimizer",
+    "gitingest",
+    "real-time",
+    "caching",
+    "platform"
+  ],
+  "author": "Hakkı Sağdıç",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@lancedb/lancedb": "^0.23.0",
+    "@modelcontextprotocol/sdk": "^1.21.1",
+    "@toon-format/toon": "^0.7.0",
+    "@xenova/transformers": "^2.17.2",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "ink": "^6.4.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^19.2.0",
+    "vitest": "^4.0.18",
+    "zod": "^4.1.12"
+  },
+  "files": [
+    "index.js",
+    "ctxman.js",
+    "lib/",
+    "bin/",
+    ".ctxman/",
+    "examples/",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@anthropic-ai/tokenizer": "^0.0.4",
+    "@playwright/test": "^1.58.1",
+    "@vitejs/plugin-vue": "^6.0.2",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
+    "@vue/test-utils": "^2.4.6",
+    "c8": "^10.1.3",
+    "eslint": "^9.39.1",
+    "llama3-tokenizer-js": "^1.2.0",
+    "prettier": "^3.6.2",
+    "supertest": "^7.2.2",
+    "tiktoken": "^1.0.22",
+    "vite": "^7.2.4",
+    "vue": "^3.5.24"
+  }
+}