ctxman 3.0.0

package/lib/formatters/toon-formatter.js

@@ -0,0 +1,291 @@
+/**
+ * TOON Format Wrapper
+ * Wraps official @toon-format/toon package with Ctxman integration
+ *
+ * Official TOON Spec v1.3: https://github.com/toon-format/spec
+ * Reference Implementation: https://github.com/toon-format/toon
+ *
+ * Features (100% Spec Compliant):
+ * - Array length markers [N]
+ * - Delimiter options: comma, tab, pipe
+ * - Length marker prefix: # (optional)
+ * - List format for non-uniform arrays
+ * - Smart quoting rules
+ * - Type normalizations
+ * - Full decoder support
+ */
+
+class ToonFormatter {
+    constructor(options = {}) {
+        this.options = {
+            indent: options.indent || 2,
+            delimiter: options.delimiter || ',',
+            lengthMarker: options.lengthMarker || false
+        };
+
+        // Initialize indentChar
+        this.indentChar = ' '.repeat(this.options.indent);
+
+        // Lazy load official TOON package (ESM)
+        this._toonModule = null;
+    }
+
+    /**
+     * Get official TOON module (lazy load)
+     */
+    async getToonModule() {
+        if (!this._toonModule) {
+            this._toonModule = await import('@toon-format/toon');
+        }
+        return this._toonModule;
+    }
+
+    /**
+     * Encode data to TOON format (Async - uses official package)
+     */
+    async encodeAsync(data, options = {}) {
+        const toon = await this.getToonModule();
+        const opts = { ...this.options, ...options };
+        return toon.encode(data, opts);
+    }
+
+    /**
+     * Encode data to TOON format (Sync - uses custom implementation for backward compat)
+     */
+    encode(data, options = {}) {
+        // Fallback to synchronous custom implementation
+        // This maintains backward compatibility with existing code
+        const opts = { ...this.options, ...options };
+        return this.encodeSync(data, opts);
+    }
+
+    /**
+     * Synchronous encoder (custom implementation - basic features only)
+     * For full spec compliance, use encodeAsync()
+     */
+    encodeSync(data, options = {}) {
+        const { indent = 2 } = options;
+        this.indentChar = ' '.repeat(indent);
+        return this.encodeValue(data, 0, true);
+    }
+
+    encodeValue(value, indent = 0, compact = true) {
+        if (value === null || value === undefined) return 'null';
+        if (typeof value === 'boolean') return String(value);
+        if (typeof value === 'number') return String(value);
+        if (typeof value === 'string') return this.encodeString(value);
+        if (Array.isArray(value)) return this.encodeArray(value, indent, compact);
+        if (typeof value === 'object') return this.encodeObject(value, indent, compact);
+        return 'null';
+    }
+
+    encodeString(str) {
+        const escaped = str
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"')
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r')
+            .replace(/\t/g, '\\t');
+
+        if (/[\s,:{}\[\]]/.test(escaped)) {
+            return `"${escaped}"`;
+        }
+
+        return escaped;
+    }
+
+    encodeArray(arr, indent = 0, compact = true) {
+        if (arr.length === 0) return '[]';
+
+        if (this.isTabularArray(arr)) {
+            return this.encodeTabular(arr, indent, compact);
+        }
+
+        return this.encodeRegularArray(arr, indent, compact);
+    }
+
+    isTabularArray(arr) {
+        if (arr.length < 2) return false;
+        if (!arr.every(item => typeof item === 'object' && item !== null && !Array.isArray(item))) {
+            return false;
+        }
+
+        const firstKeys = Object.keys(arr[0]).sort();
+        return arr.every(item => {
+            const keys = Object.keys(item).sort();
+            return keys.length === firstKeys.length &&
+                   keys.every((key, i) => key === firstKeys[i]);
+        });
+    }
+
+    encodeTabular(arr, indent = 0, compact = true) {
+        const prefix = this.indentChar.repeat(indent);
+        const keys = Object.keys(arr[0]).sort();
+
+        let result = `{${keys.join(',')}}:\n`;
+
+        for (const item of arr) {
+            result += prefix + this.indentChar;
+            const values = keys.map(key => this.encodeValue(item[key], 0, true));
+            result += values.join(',') + '\n';
+        }
+
+        return result;
+    }
+
+    encodeRegularArray(arr, indent = 0, compact = true) {
+        const prefix = this.indentChar.repeat(indent);
+
+        if (compact && arr.every(item => ['string', 'number', 'boolean'].includes(typeof item) || item === null)) {
+            return '[' + arr.map(item => this.encodeValue(item, 0, true)).join(',') + ']';
+        }
+
+        let result = '[\n';
+        for (let i = 0; i < arr.length; i++) {
+            result += prefix + this.indentChar + this.encodeValue(arr[i], indent + 1, compact);
+            if (i < arr.length - 1) result += ',';
+            result += '\n';
+        }
+        result += prefix + ']';
+
+        return result;
+    }
+
+    encodeObject(obj, indent = 0, compact = true) {
+        const keys = Object.keys(obj);
+        if (keys.length === 0) return '{}';
+
+        const prefix = this.indentChar.repeat(indent);
+        let result = '{\n';
+
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const value = obj[key];
+            result += prefix + this.indentChar + key + ': ';
+
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                result += '\n' + this.encodeObject(value, indent + 1, compact);
+            } else {
+                result += this.encodeValue(value, indent + 1, compact);
+            }
+
+            if (i < keys.length - 1) result += ',';
+            result += '\n';
+        }
+
+        result += prefix + '}';
+        return result;
+    }
+
+    /**
+     * Decode TOON string to JavaScript value (Async - uses official package)
+     */
+    async decodeAsync(toonString, options = {}) {
+        const toon = await this.getToonModule();
+        return toon.decode(toonString, options);
+    }
+
+    /**
+     * Decode TOON string (Sync - throws error, decoder not available in sync mode)
+     */
+    decode(toonString, options = {}) {
+        throw new Error('Synchronous decoder not available. Use decodeAsync() instead.');
+    }
+
+    /**
+     * Validate TOON string
+     */
+    validate(toonString) {
+        const errors = [];
+        let braceDepth = 0;
+        let bracketDepth = 0;
+
+        for (const char of toonString) {
+            if (char === '{') braceDepth++;
+            if (char === '}') braceDepth--;
+            if (char === '[') bracketDepth++;
+            if (char === ']') bracketDepth--;
+
+            if (braceDepth < 0) errors.push('Unbalanced braces: extra closing brace');
+            if (bracketDepth < 0) errors.push('Unbalanced brackets: extra closing bracket');
+        }
+
+        if (braceDepth > 0) errors.push('Unbalanced braces: missing closing braces');
+        if (bracketDepth > 0) errors.push('Unbalanced brackets: missing closing brackets');
+
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+
+    /**
+     * Estimate tokens (GPT-4 compatible)
+     */
+    estimateTokens(toonString) {
+        return Math.ceil(toonString.length / 4);
+    }
+
+    /**
+     * Optimize TOON output
+     */
+    optimize(toonString) {
+        const lines = toonString.split('\n');
+        const optimized = lines.map(line => line.trimEnd()).join('\n');
+        return optimized.replace(/\n{3,}/g, '\n\n');
+    }
+
+    /**
+     * Minify TOON output
+     */
+    minify(toonString) {
+        return toonString
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line.length > 0)
+            .join('\n');
+    }
+
+    /**
+     * Compare TOON with JSON (token savings)
+     */
+    compareWithJSON(data) {
+        const toon = this.encode(data);
+        const json = JSON.stringify(data, null, 2);
+
+        const toonSize = toon.length;
+        const jsonSize = json.length;
+        const savings = jsonSize - toonSize;
+        const savingsPercentage = ((savings / jsonSize) * 100).toFixed(1);
+
+        return {
+            toon,
+            json,
+            toonSize,
+            jsonSize,
+            savings,
+            savingsPercentage: parseFloat(savingsPercentage),
+            toonTokens: this.estimateTokens(toon),
+            jsonTokens: this.estimateTokens(json)
+        };
+    }
+
+    /**
+     * Compare with official TOON encoder (async)
+     */
+    async compareWithOfficial(data, options = {}) {
+        const customEncoded = this.encode(data);
+        const officialEncoded = await this.encodeAsync(data, options);
+
+        return {
+            custom: customEncoded,
+            official: officialEncoded,
+            customSize: customEncoded.length,
+            officialSize: officialEncoded.length,
+            difference: customEncoded.length - officialEncoded.length,
+            officialIsBetter: officialEncoded.length < customEncoded.length
+        };
+    }
+}
+
+export default ToonFormatter;

package/lib/integrations/git/BlameTracker.js

@@ -0,0 +1,142 @@
+/**
+ * BlameTracker - Author Attribution Module
+ * v3.0.0 - Complete Git integration
+ *
+ * Responsibilities:
+ * - Track file ownership
+ * - Author contribution analysis
+ * - Code ownership distribution
+ * - Hot spot detection
+ */
+
+import GitClient from './GitClient.js';
+import { getLogger } from '../../utils/logger.js';
+
+const logger = getLogger('BlameTracker');
+
+export class BlameTracker {
+  constructor(repositoryPath) {
+    this.git = new GitClient(repositoryPath);
+  }
+
+  /**
+   * Get primary author for file (most commits)
+   * @param {string} filePath
+   * @returns {Author|null}
+   */
+  getPrimaryAuthor(filePath) {
+    const authors = this.git.getFileAuthors(filePath);
+    return authors.length > 0 ? authors[0] : null;
+  }
+
+  /**
+   * Get author contribution distribution
+   * @param {Array<string>} filePaths
+   * @returns {Map<string, AuthorStats>}
+   */
+  getAuthorContributions(filePaths) {
+    const contributions = new Map();
+
+    for (const filePath of filePaths) {
+      const authors = this.git.getFileAuthors(filePath);
+
+      for (const author of authors) {
+        if (!contributions.has(author.email)) {
+          contributions.set(author.email, {
+            name: author.name,
+            email: author.email,
+            filesOwned: 0,
+            totalCommits: 0
+          });
+        }
+
+        const stats = contributions.get(author.email);
+        stats.filesOwned++;
+        stats.totalCommits += author.commits;
+      }
+    }
+
+    return contributions;
+  }
+
+  /**
+   * Get code ownership map
+   * @param {Array<string>} filePaths
+   * @returns {Map<string, Author>}
+   */
+  getOwnershipMap(filePaths) {
+    const ownership = new Map();
+
+    for (const filePath of filePaths) {
+      const owner = this.getPrimaryAuthor(filePath);
+      if (owner) {
+        ownership.set(filePath, owner);
+      }
+    }
+
+    return ownership;
+  }
+
+  /**
+   * Detect hot spots (frequently changed files)
+   * @param {Array<string>} filePaths
+   * @param {number} threshold - Minimum commits to be considered hot
+   * @returns {Array<HotSpot>}
+   */
+  detectHotSpots(filePaths, threshold = 10) {
+    const hotSpots = [];
+
+    for (const filePath of filePaths) {
+      const commitCount = this.git.getCommitCount(filePath);
+
+      if (commitCount >= threshold) {
+        const authors = this.git.getFileAuthors(filePath);
+
+        hotSpots.push({
+          path: filePath,
+          commitCount,
+          authorCount: authors.length,
+          primaryAuthor: authors[0],
+          risk: this.calculateRiskScore(commitCount, authors.length)
+        });
+      }
+    }
+
+    return hotSpots.sort((a, b) => b.risk - a.risk);
+  }
+
+  /**
+   * Calculate risk score for a file
+   * @param {number} commitCount
+   * @param {number} authorCount
+   * @returns {number}
+   */
+  calculateRiskScore(commitCount, authorCount) {
+    // High commit count + multiple authors = higher risk
+    const commitScore = Math.log(commitCount + 1) * 10;
+    const authorScore = authorCount * 5;
+    return commitScore + authorScore;
+  }
+
+  /**
+   * Get file ownership summary
+   * @param {Array<string>} filePaths
+   * @returns {object}
+   */
+  getOwnershipSummary(filePaths) {
+    const contributions = this.getAuthorContributions(filePaths);
+
+    const topContributors = Array.from(contributions.values())
+      .sort((a, b) => b.totalCommits - a.totalCommits)
+      .slice(0, 10);
+
+    return {
+      totalAuthors: contributions.size,
+      totalFiles: filePaths.length,
+      topContributors,
+      averageFilesPerAuthor: filePaths.length / contributions.size
+    };
+  }
+}
+
+export default BlameTracker;

package/lib/integrations/git/DiffAnalyzer.js

@@ -0,0 +1,260 @@
+/**
+ * DiffAnalyzer - Git Diff Analysis Module
+ * v3.0.0 - Complete Git integration
+ *
+ * Responsibilities:
+ * - Analyze git diffs
+ * - Detect change impact
+ * - Find related files
+ * - Generate change summaries
+ */
+
+import GitClient from './GitClient.js';
+import { getLogger } from '../../utils/logger.js';
+
+const logger = getLogger('DiffAnalyzer');
+
+export class DiffAnalyzer {
+  constructor(repositoryPath) {
+    this.git = new GitClient(repositoryPath);
+    this.repoPath = repositoryPath;
+  }
+
+  /**
+   * Analyze changes since a reference point
+   * @param {string} since - Commit/branch reference
+   * @returns {ChangeAnalysis}
+   */
+  analyzeChanges(since = null) {
+    logger.info(`Analyzing changes since: ${since || 'uncommitted'}`);
+
+    const changedFiles = since
+      ? this.git.getChangedFiles(since)
+      : this.git.getAllModifiedFiles();
+
+    const analysis = {
+      changedFiles: changedFiles,
+      totalChangedFiles: changedFiles.length,
+      since: since,
+      relatedFiles: [],
+      impact: this.calculateImpact(changedFiles)
+    };
+
+    return analysis;
+  }
+
+  /**
+   * Get changed files with detailed diff
+   * @param {string} since
+   * @returns {Array<FileChange>}
+   */
+  getDetailedChanges(since = null) {
+    const changedFiles = since
+      ? this.git.getChangedFiles(since)
+      : this.git.getAllModifiedFiles();
+
+    return changedFiles.map(filePath => {
+      const diff = this.getFileDiff(filePath, since);
+      return {
+        path: filePath,
+        ...diff
+      };
+    });
+  }
+
+  /**
+   * Get diff for specific file
+   * @param {string} filePath
+   * @param {string} since
+   * @returns {FileDiff}
+   */
+  getFileDiff(filePath, since = null) {
+    try {
+      const command = since
+        ? `diff ${since} -- "${filePath}"`
+        : `diff -- "${filePath}"`;
+
+      const diffOutput = this.git.exec(command);
+      const stats = this.parseDiffStats(diffOutput);
+
+      return {
+        added: stats.added,
+        deleted: stats.deleted,
+        modified: stats.added + stats.deleted,
+        diff: diffOutput
+      };
+    } catch (error) {
+      logger.warn(`Failed to get diff for ${filePath}: ${error.message}`);
+      return { added: 0, deleted: 0, modified: 0, diff: '' };
+    }
+  }
+
+  /**
+   * Parse diff statistics
+   * @param {string} diffOutput
+   * @returns {object}
+   */
+  parseDiffStats(diffOutput) {
+    let added = 0;
+    let deleted = 0;
+
+    const lines = diffOutput.split('\n');
+    for (const line of lines) {
+      if (line.startsWith('+') && !line.startsWith('+++')) {
+        added++;
+      } else if (line.startsWith('-') && !line.startsWith('---')) {
+        deleted++;
+      }
+    }
+
+    return { added, deleted };
+  }
+
+  /**
+   * Calculate change impact score
+   * @param {Array<string>} changedFiles
+   * @returns {object}
+   */
+  calculateImpact(changedFiles) {
+    const impact = {
+      level: 'low',
+      score: 0,
+      details: {
+        coreFiles: 0,
+        configFiles: 0,
+        testFiles: 0,
+        documentationFiles: 0
+      }
+    };
+
+    for (const file of changedFiles) {
+      const fileLower = file.toLowerCase();
+
+      // Core files (high impact)
+      if (fileLower.includes('src/') || fileLower.includes('lib/') ||
+          fileLower.includes('index.') || fileLower.includes('main.') ||
+          fileLower.includes('app.') || fileLower.includes('server.')) {
+        impact.details.coreFiles++;
+        impact.score += 10;
+      }
+
+      // Config files (medium-high impact)
+      if (fileLower.endsWith('.json') || fileLower.endsWith('.yml') ||
+          fileLower.endsWith('.yaml') || fileLower.endsWith('.config.js')) {
+        impact.details.configFiles++;
+        impact.score += 7;
+      }
+
+      // Test files (medium impact)
+      if (fileLower.includes('test') || fileLower.includes('spec')) {
+        impact.details.testFiles++;
+        impact.score += 3;
+      }
+
+      // Documentation (low impact)
+      if (fileLower.endsWith('.md') || fileLower.includes('docs/')) {
+        impact.details.documentationFiles++;
+        impact.score += 1;
+      }
+    }
+
+    // Determine impact level
+    if (impact.score >= 50) {
+      impact.level = 'critical';
+    } else if (impact.score >= 25) {
+      impact.level = 'high';
+    } else if (impact.score >= 10) {
+      impact.level = 'medium';
+    } else {
+      impact.level = 'low';
+    }
+
+    return impact;
+  }
+
+  /**
+   * Find related files based on imports/dependencies
+   * @param {Array<string>} changedFiles
+   * @returns {Array<string>}
+   */
+  findRelatedFiles(changedFiles) {
+    // TODO: Implement import graph analysis
+    // For now, return empty array
+    logger.debug('Related files detection not yet implemented');
+    return [];
+  }
+
+  /**
+   * Get file change frequency (how often file is modified)
+   * @param {string} filePath
+   * @returns {number}
+   */
+  getFileChangeFrequency(filePath) {
+    return this.git.getCommitCount(filePath);
+  }
+
+  /**
+   * Compare two branches
+   * @param {string} base - Base branch
+   * @param {string} compare - Compare branch
+   * @returns {BranchComparison}
+   */
+  compareBranches(base, compare) {
+    try {
+      const command = `diff --name-status ${base}...${compare}`;
+      const output = this.git.exec(command);
+
+      const changes = {
+        added: [],
+        modified: [],
+        deleted: [],
+        renamed: []
+      };
+
+      if (!output) return changes;
+
+      const lines = output.split('\n');
+      for (const line of lines) {
+        const [status, ...pathParts] = line.split('\t');
+        const filePath = pathParts.join('\t');
+
+        if (status === 'A') changes.added.push(filePath);
+        else if (status === 'M') changes.modified.push(filePath);
+        else if (status === 'D') changes.deleted.push(filePath);
+        else if (status.startsWith('R')) changes.renamed.push(filePath);
+      }
+
+      return changes;
+    } catch (error) {
+      logger.error(`Branch comparison failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get commit range statistics
+   * @param {string} range - Commit range (e.g., 'v1.0.0..v2.0.0')
+   * @returns {object}
+   */
+  getRangeStats(range) {
+    try {
+      const command = `diff --shortstat ${range}`;
+      const output = this.git.exec(command);
+
+      // Parse: "3 files changed, 45 insertions(+), 12 deletions(-)"
+      const match = output.match(/(\d+) file[s]? changed(?:, (\d+) insertion[s]?\(\+\))?(?:, (\d+) deletion[s]?\(-\))?/);
+
+      if (!match) return null;
+
+      return {
+        filesChanged: parseInt(match[1], 10),
+        insertions: parseInt(match[2] || 0, 10),
+        deletions: parseInt(match[3] || 0, 10)
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+}
+
+export default DiffAnalyzer;