ctxman 3.0.0

package/lib/integrations/git/GitClient.js

@@ -0,0 +1,336 @@
+/**
+ * GitClient - Git Operations Module
+ * v3.0.0 - Complete Git integration
+ *
+ * Responsibilities:
+ * - Execute git commands
+ * - Parse git output
+ * - Provide high-level git operations
+ * - Cache git metadata
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { getLogger } from '../../utils/logger.js';
+
+const logger = getLogger('GitClient');
+
+export class GitClient {
+  constructor(repositoryPath) {
+    this.repoPath = repositoryPath;
+    this.isGitRepo = this.checkIsGitRepository();
+  }
+
+  /**
+   * Check if directory is a git repository
+   * @returns {boolean}
+   */
+  checkIsGitRepository() {
+    try {
+      const gitDir = path.join(this.repoPath, '.git');
+      return fs.existsSync(gitDir);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Validate git reference to prevent command injection
+   * @param {string} ref 
+   * @returns {boolean}
+   */
+  validateGitRef(ref) {
+    if (!ref) return true; // null/undefined is safe (handled logic elsewhere)
+    // Allow alphanumeric, /, -, _, ., @, ^, ~
+    // Disallow ; | & $ > < ` \ !
+    return /^[a-zA-Z0-9/\-_.\@\^\~]+$/.test(ref);
+  }
+
+  /**
+   * Execute git command
+   * @param {string} command - Git command (without 'git' prefix)
+   * @returns {string} Command output
+   */
+  exec(command) {
+    if (!this.isGitRepo) {
+      throw new Error('Not a git repository');
+    }
+
+    // Basic sanity check against shell injection if the command string was constructed with user input
+    // This is a last line of defense; specific methods should validate their inputs.
+    if (command.includes(';') || command.includes('&')) {
+       logger.warn(`Potential injection detected in command: ${command}`);
+       throw new Error('Invalid characters in git command');
+    }
+
+    try {
+      const fullCommand = `git ${command}`;
+      const output = execSync(fullCommand, {
+        cwd: this.repoPath,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      return output.trim();
+    } catch (error) {
+      logger.error(`Git command failed: ${command}`);
+      throw new Error(`Git command failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get current branch name
+   * @returns {string}
+   */
+  getCurrentBranch() {
+    return this.exec('rev-parse --abbrev-ref HEAD');
+  }
+
+  /**
+   * Get default branch name
+   * @returns {string}
+   */
+  getDefaultBranch() {
+    try {
+      return this.exec('symbolic-ref refs/remotes/origin/HEAD --short').split('/').pop();
+    } catch (error) {
+      return 'main'; // Fallback
+    }
+  }
+
+  /**
+   * Get changed files
+   * @param {string} since - Commit/branch reference (e.g., 'main', 'HEAD~5')
+   * @returns {Array<string>}
+   */
+  getChangedFiles(since = null) {
+    let command;
+
+    if (since) {
+      // Files changed between commits/branches
+      command = `diff --name-only ${since}`;
+    } else {
+      // Files with uncommitted changes
+      command = 'diff --name-only';
+    }
+
+    const output = this.exec(command);
+    return output ? output.split('\n').filter(Boolean) : [];
+  }
+
+  /**
+   * Get staged files
+   * @returns {Array<string>}
+   */
+  getStagedFiles() {
+    const output = this.exec('diff --cached --name-only');
+    return output ? output.split('\n').filter(Boolean) : [];
+  }
+
+  /**
+   * Get unstaged files
+   * @returns {Array<string>}
+   */
+  getUnstagedFiles() {
+    const output = this.exec('diff --name-only');
+    return output ? output.split('\n').filter(Boolean) : [];
+  }
+
+  /**
+   * Get untracked files
+   * @returns {Array<string>}
+   */
+  getUntrackedFiles() {
+    const output = this.exec('ls-files --others --exclude-standard');
+    return output ? output.split('\n').filter(Boolean) : [];
+  }
+
+  /**
+   * Get all modified files (staged + unstaged + untracked)
+   * @returns {Array<string>}
+   */
+  getAllModifiedFiles() {
+    const staged = this.getStagedFiles();
+    const unstaged = this.getUnstagedFiles();
+    const untracked = this.getUntrackedFiles();
+
+    // Deduplicate
+    return [...new Set([...staged, ...unstaged, ...untracked])];
+  }
+
+  /**
+   * Get file history
+   * @param {string} filePath - File path
+   * @param {number} limit - Number of commits
+   * @returns {Array<Commit>}
+   */
+  getFileHistory(filePath, limit = 10) {
+    const command = `log --follow --pretty=format:"%H|%an|%ae|%at|%s" -n ${limit} -- "${filePath}"`;
+    const output = this.exec(command);
+
+    if (!output) return [];
+
+    return output.split('\n').map(line => {
+      const [hash, author, email, timestamp, subject] = line.split('|');
+      return {
+        hash,
+        author,
+        email,
+        timestamp: parseInt(timestamp, 10),
+        date: new Date(parseInt(timestamp, 10) * 1000),
+        subject
+      };
+    });
+  }
+
+  /**
+   * Get blame information for file
+   * @param {string} filePath - File path
+   * @returns {Array<BlameLine>}
+   */
+  getBlame(filePath) {
+    try {
+      const command = `blame --line-porcelain "${filePath}"`;
+      const output = this.exec(command);
+
+      return this.parseBlameOutput(output);
+    } catch (error) {
+      logger.warn(`Blame failed for ${filePath}: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Parse git blame porcelain output
+   * @param {string} output
+   * @returns {Array<BlameLine>}
+   */
+  parseBlameOutput(output) {
+    const lines = output.split('\n');
+    const blameInfo = [];
+    let currentCommit = null;
+    let currentAuthor = null;
+    let currentTimestamp = null;
+
+    for (const line of lines) {
+      if (line.match(/^[0-9a-f]{40}/)) {
+        // Commit hash line
+        currentCommit = line.split(' ')[0];
+      } else if (line.startsWith('author ')) {
+        currentAuthor = line.substring(7);
+      } else if (line.startsWith('author-time ')) {
+        currentTimestamp = parseInt(line.substring(12), 10);
+      } else if (line.startsWith('\t')) {
+        // Code line
+        blameInfo.push({
+          commit: currentCommit,
+          author: currentAuthor,
+          timestamp: currentTimestamp,
+          date: new Date(currentTimestamp * 1000),
+          code: line.substring(1)
+        });
+      }
+    }
+
+    return blameInfo;
+  }
+
+  /**
+   * Get commit count for file
+   * @param {string} filePath
+   * @returns {number}
+   */
+  getCommitCount(filePath) {
+    try {
+      const output = this.exec(`log --follow --oneline "${filePath}"`);
+      return output ? output.split('\n').length : 0;
+    } catch (error) {
+      return 0;
+    }
+  }
+
+  /**
+   * Get file authors
+   * @param {string} filePath
+   * @returns {Array<Author>}
+   */
+  getFileAuthors(filePath) {
+    try {
+      const command = `log --follow --pretty=format:"%an|%ae" -- "${filePath}"`;
+      const output = this.exec(command);
+
+      if (!output) return [];
+
+      const authorsMap = new Map();
+
+      output.split('\n').forEach(line => {
+        const [name, email] = line.split('|');
+        if (!authorsMap.has(email)) {
+          authorsMap.set(email, { name, email, commits: 0 });
+        }
+        authorsMap.get(email).commits++;
+      });
+
+      return Array.from(authorsMap.values())
+        .sort((a, b) => b.commits - a.commits);
+
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Get repository statistics
+   * @returns {object}
+   */
+  getRepoStats() {
+    if (!this.isGitRepo) {
+      return null;
+    }
+
+    try {
+      const totalCommits = this.exec('rev-list --count HEAD');
+      const totalFiles = this.exec('ls-files').split('\n').length;
+      const contributors = this.exec('shortlog -sn --all').split('\n').length;
+
+      return {
+        totalCommits: parseInt(totalCommits, 10),
+        totalFiles,
+        contributors,
+        currentBranch: this.getCurrentBranch()
+      };
+    } catch (error) {
+      logger.warn(`Failed to get repo stats: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Get last commit info for file
+   * @param {string} filePath
+   * @returns {Commit|null}
+   */
+  getLastCommit(filePath) {
+    try {
+      const command = `log -1 --pretty=format:"%H|%an|%ae|%at|%s" -- "${filePath}"`;
+      const output = this.exec(command);
+
+      if (!output) return null;
+
+      const [hash, author, email, timestamp, subject] = output.split('|');
+      return {
+        hash,
+        author,
+        email,
+        timestamp: parseInt(timestamp, 10),
+        date: new Date(parseInt(timestamp, 10) * 1000),
+        subject
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+}
+
+export default GitClient;

package/lib/parsers/gitignore-parser.js

@@ -0,0 +1,127 @@
+/**
+ * GitIgnore Parser
+ * Parses .gitignore, .contextignore, and .contextinclude files
+ */
+
+import fs from 'fs';
+
+class GitIgnoreParser {
+    constructor(gitignorePath, contextIgnorePath, contextIncludePath) {
+        this.patterns = [];
+        this.contextPatterns = [];
+        this.hasIncludeFile = false;
+        this._lastIgnoreReason = null;
+
+        this.loadPatterns(gitignorePath, contextIgnorePath, contextIncludePath);
+    }
+
+    loadPatterns(gitignorePath, contextIgnorePath, contextIncludePath) {
+        // Load .gitignore
+        if (fs.existsSync(gitignorePath)) {
+            this.patterns = this.parsePatternFile(gitignorePath);
+        }
+
+        // Load context patterns (include takes priority)
+        if (contextIncludePath && fs.existsSync(contextIncludePath)) {
+            this.contextPatterns = this.parsePatternFile(contextIncludePath);
+            this.hasIncludeFile = true;
+            console.log(`📅 Context include rules loaded: ${this.contextPatterns.length} patterns`);
+        } else if (contextIgnorePath && fs.existsSync(contextIgnorePath)) {
+            this.contextPatterns = this.parsePatternFile(contextIgnorePath);
+            console.log(`📋 Context ignore rules loaded: ${this.contextPatterns.length} patterns`);
+        }
+    }
+
+    parsePatternFile(filePath) {
+        try {
+            // Check if path is actually a file (not a directory)
+            const stats = fs.statSync(filePath);
+            if (stats.isDirectory()) {
+                console.warn(`Warning: ${filePath} is a directory, expected a file`);
+                return [];
+            }
+
+            return fs.readFileSync(filePath, 'utf8')
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#'))
+                .map(pattern => this.convertToRegex(pattern));
+        } catch (error) {
+            // File doesn't exist or can't be read
+            return [];
+        }
+    }
+
+    convertToRegex(pattern) {
+        const isDirectory = pattern.endsWith('/');
+        const isNegation = pattern.startsWith('!');
+        const original = pattern;
+
+        pattern = pattern.replace(/^[!/]/, '').replace(/\/$/, '');
+
+        let regexPattern = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*')
+            .replace(/\?/g, '[^/]');
+
+        regexPattern = original.startsWith('/')
+            ? `^${regexPattern}`
+            : `(^|/)${regexPattern}`;
+
+        regexPattern += isDirectory ? '(/.*)?$' : '$';
+
+        return { regex: new RegExp(regexPattern), isNegation, original, isDirectory };
+    }
+
+    isIgnored(filePath, relativePath) {
+        let ignored = this.testPatterns(this.patterns, relativePath, 'gitignore');
+
+        if (this.hasIncludeFile) {
+            if (ignored) return true; // Keep gitignore exclusions
+
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                const shouldTraverse = this.contextPatterns.some(p =>
+                    p.original.startsWith(relativePath) ||
+                    p.original.includes('**') ||
+                    relativePath === ''
+                );
+                ignored = !shouldTraverse;
+            } else {
+                const included = this.testPatternsWithNegation(this.contextPatterns, relativePath);
+                ignored = !included;
+            }
+
+            if (ignored) this._lastIgnoreReason = 'context-include';
+        } else if (!ignored) {
+            ignored = this.testPatterns(this.contextPatterns, relativePath, 'context');
+        }
+
+        return ignored;
+    }
+
+    testPatterns(patterns, relativePath, reason) {
+        let ignored = false;
+        for (const pattern of patterns) {
+            if (pattern.regex.test(relativePath)) {
+                ignored = !pattern.isNegation;
+                if (ignored) this._lastIgnoreReason = reason;
+            }
+        }
+        return ignored;
+    }
+
+    testPatternsWithNegation(patterns, relativePath) {
+        let included = false;
+        for (const pattern of patterns) {
+            if (pattern.regex.test(relativePath)) {
+                included = pattern.isNegation ? false : true;
+                if (pattern.isNegation) break;
+            }
+        }
+        return included;
+    }
+}
+
+export default GitIgnoreParser;

package/lib/parsers/method-filter-parser.js

@@ -0,0 +1,50 @@
+/**
+ * Method Filter Parser
+ * Parses .methodinclude and .methodignore files for method-level filtering
+ */
+
+import fs from 'fs';
+
+class MethodFilterParser {
+    constructor(methodIncludePath, methodIgnorePath) {
+        this.includePatterns = [];
+        this.ignorePatterns = [];
+        this.hasIncludeFile = false;
+
+        if (methodIncludePath && fs.existsSync(methodIncludePath)) {
+            this.includePatterns = this.parseMethodFile(methodIncludePath);
+            this.hasIncludeFile = true;
+            console.log(`🔧 Method include rules loaded: ${this.includePatterns.length} patterns`);
+        }
+
+        if (methodIgnorePath && fs.existsSync(methodIgnorePath)) {
+            this.ignorePatterns = this.parseMethodFile(methodIgnorePath);
+            console.log(`🚫 Method ignore rules loaded: ${this.ignorePatterns.length} patterns`);
+        }
+    }
+
+    parseMethodFile(filePath) {
+        return fs.readFileSync(filePath, 'utf8')
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'))
+            .map(pattern => ({
+                pattern: pattern,
+                regex: new RegExp(pattern.replace(/\*/g, '.*'), 'i')
+            }));
+    }
+
+    shouldIncludeMethod(methodName, fileName) {
+        if (this.hasIncludeFile) {
+            return this.includePatterns.some(p =>
+                p.regex.test(methodName) || p.regex.test(`${fileName}.${methodName}`)
+            );
+        }
+
+        return !this.ignorePatterns.some(p =>
+            p.regex.test(methodName) || p.regex.test(`${fileName}.${methodName}`)
+        );
+    }
+}
+
+export default MethodFilterParser;

package/lib/plugins/ExporterPlugin.js

@@ -0,0 +1,102 @@
+/**
+ * ExporterPlugin - Base Class for Format Exporter Plugins
+ * v3.0.0 - Plugin architecture
+ *
+ * All format exporters should extend this class
+ */
+
+export class ExporterPlugin {
+  constructor() {
+    this.name = 'base';
+    this.extension = '.txt';
+    this.mimeType = 'text/plain';
+    this.version = '1.0.0';
+  }
+
+  /**
+   * Get plugin metadata
+   * @returns {object}
+   */
+  getMetadata() {
+    return {
+      name: this.name,
+      version: this.version,
+      extension: this.extension,
+      mimeType: this.mimeType,
+      supportsChunking: this.supportsChunking(),
+      supportsCompression: this.supportsCompression()
+    };
+  }
+
+  /**
+   * Check if this exporter supports chunking
+   * @returns {boolean}
+   */
+  supportsChunking() {
+    return false;
+  }
+
+  /**
+   * Check if this exporter supports compression
+   * @returns {boolean}
+   */
+  supportsCompression() {
+    return false;
+  }
+
+  /**
+   * Encode context to this format
+   * @param {Context} context
+   * @param {object} options
+   * @returns {string}
+   */
+  encode(context, options = {}) {
+    throw new Error('encode() must be implemented by subclass');
+  }
+
+  /**
+   * Decode this format to context
+   * @param {string} content
+   * @returns {Context}
+   */
+  decode(content) {
+    throw new Error('decode() not supported for this format');
+  }
+
+  /**
+   * Validate encoded output
+   * @param {string} content
+   * @returns {boolean}
+   */
+  validate(content) {
+    return typeof content === 'string' && content.length > 0;
+  }
+
+  /**
+   * Estimate token count of encoded output
+   * @param {Context} context
+   * @returns {number}
+   */
+  estimateTokens(context) {
+    const encoded = this.encode(context);
+    return Math.ceil(encoded.length / 4); // Rough estimate
+  }
+
+  /**
+   * Compress output (optional)
+   * @param {string} content
+   * @returns {string}
+   */
+  compress(content) {
+    return content; // Override if compression supported
+  }
+
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    // Override if needed
+  }
+}
+
+export default ExporterPlugin;

package/lib/plugins/LanguagePlugin.js

@@ -0,0 +1,100 @@
+/**
+ * LanguagePlugin - Base Class for Language Plugins
+ * v3.0.0 - Plugin architecture
+ *
+ * All language analyzers should extend this class
+ */
+
+export class LanguagePlugin {
+  constructor() {
+    this.name = 'base';
+    this.extensions = [];
+    this.version = '1.0.0';
+  }
+
+  /**
+   * Get plugin metadata
+   * @returns {object}
+   */
+  getMetadata() {
+    return {
+      name: this.name,
+      version: this.version,
+      extensions: this.extensions,
+      supportsAST: this.supportsAST(),
+      supportsMethodExtraction: this.supportsMethodExtraction(),
+      supportsFrameworkDetection: this.supportsFrameworkDetection()
+    };
+  }
+
+  /**
+   * Check if this plugin supports AST parsing
+   * @returns {boolean}
+   */
+  supportsAST() {
+    return false;
+  }
+
+  /**
+   * Check if this plugin supports method extraction
+   * @returns {boolean}
+   */
+  supportsMethodExtraction() {
+    return true;
+  }
+
+  /**
+   * Check if this plugin supports framework detection
+   * @returns {boolean}
+   */
+  supportsFrameworkDetection() {
+    return false;
+  }
+
+  /**
+   * Extract methods from code
+   * @param {string} content - File content
+   * @param {string} filePath - File path
+   * @returns {Array<Method>}
+   */
+  extractMethods(content, filePath) {
+    throw new Error('extractMethods() must be implemented by subclass');
+  }
+
+  /**
+   * Detect framework (optional)
+   * @param {string} content - File content
+   * @returns {string|null} Framework name or null
+   */
+  detectFramework(content) {
+    return null;
+  }
+
+  /**
+   * Analyze code complexity (optional)
+   * @param {string} content - Method content
+   * @returns {number} Complexity score
+   */
+  analyzeComplexity(content) {
+    // Default: Simple line count
+    return content.split('\n').length;
+  }
+
+  /**
+   * Validate file content
+   * @param {string} content - File content
+   * @returns {boolean}
+   */
+  validate(content) {
+    return typeof content === 'string' && content.length > 0;
+  }
+
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    // Override if needed
+  }
+}
+
+export default LanguagePlugin;