@git.zone/tsdoc 1.5.1 → 1.6.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/tsdoc',
-    version: '1.5.1',
+    version: '1.6.0',
     description: 'A comprehensive TypeScript documentation tool that leverages AI to generate and enhance project documentation, including dynamic README creation, API docs via TypeDoc, and smart commit message generation.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxpQkFBaUI7SUFDdkIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDhNQUE4TTtDQUM1TixDQUFBIn0=

package/dist_ts/aidocs_classes/commit.js

@@ -53,8 +53,8 @@ interface {
 For the recommendedNextVersionDetails, please only add a detail entries to the array if it has an obvious value to the reader.
 
 You are being given the files of the project. You should use them to create the commit message.
-Also you are given a diff
-
+Also you are given a diff.
+Never mention CLAUDE code, or codex.
 `,
             messageHistory: [],
             userMessage: contextString,

package/dist_ts/context/config-manager.d.ts

@@ -1,4 +1,4 @@
-import type { IContextConfig, ITrimConfig, ITaskConfig, TaskType } from './types.js';
+import type { IContextConfig, ITrimConfig, ITaskConfig, TaskType, ICacheConfig, IAnalyzerConfig, IPrioritizationWeights, ITierConfig } from './types.js';
 /**
  * Manages configuration for context building
  */
@@ -6,6 +6,7 @@ export declare class ConfigManager {
     private static instance;
     private config;
     private projectDir;
+    private configCache;
     /**
      * Get the singleton instance of ConfigManager
      */
@@ -55,4 +56,24 @@ export declare class ConfigManager {
      * @param config The new configuration
      */
     updateConfig(config: Partial<IContextConfig>): Promise<void>;
+    /**
+     * Get cache configuration
+     */
+    getCacheConfig(): ICacheConfig;
+    /**
+     * Get analyzer configuration
+     */
+    getAnalyzerConfig(): IAnalyzerConfig;
+    /**
+     * Get prioritization weights
+     */
+    getPrioritizationWeights(): IPrioritizationWeights;
+    /**
+     * Get tier configuration
+     */
+    getTierConfig(): ITierConfig;
+    /**
+     * Clear the config cache (force reload on next access)
+     */
+    clearCache(): void;
 }

package/dist_ts/context/config-manager.js

@@ -1,4 +1,5 @@
 import * as plugins from '../plugins.js';
+import * as fs from 'fs';
 /**
  * Manages configuration for context building
  */
@@ -17,6 +18,7 @@ export class ConfigManager {
      */
     constructor() {
         this.projectDir = '';
+        this.configCache = null;
         this.config = this.getDefaultConfig();
     }
     /**
@@ -57,6 +59,28 @@ export class ConfigManager {
                 maxFunctionLines: 5,
                 removeComments: true,
                 removeBlankLines: true
+            },
+            cache: {
+                enabled: true,
+                ttl: 3600, // 1 hour
+                maxSize: 100, // 100MB
+                directory: undefined // Will be set to .nogit/context-cache by ContextCache
+            },
+            analyzer: {
+                enabled: true,
+                useAIRefinement: false, // Disabled by default for now
+                aiModel: 'haiku'
+            },
+            prioritization: {
+                dependencyWeight: 0.3,
+                relevanceWeight: 0.4,
+                efficiencyWeight: 0.2,
+                recencyWeight: 0.1
+            },
+            tiers: {
+                essential: { minScore: 0.8, trimLevel: 'none' },
+                important: { minScore: 0.5, trimLevel: 'light' },
+                optional: { minScore: 0.2, trimLevel: 'aggressive' }
             }
         };
     }
@@ -68,16 +92,33 @@ export class ConfigManager {
             if (!this.projectDir) {
                 return;
             }
-            // Create KeyValueStore for this project
-            // We'll just use smartfile directly instead of KeyValueStore
+            const npmextraJsonPath = plugins.path.join(this.projectDir, 'npmextra.json');
+            // Check if file exists
+            const fileExists = await plugins.smartfile.fs.fileExists(npmextraJsonPath);
+            if (!fileExists) {
+                return;
+            }
+            // Check cache
+            const stats = await fs.promises.stat(npmextraJsonPath);
+            const currentMtime = Math.floor(stats.mtimeMs);
+            if (this.configCache && this.configCache.mtime === currentMtime) {
+                // Use cached config
+                this.config = this.configCache.config;
+                return;
+            }
             // Read the npmextra.json file
-            const npmextraJsonFile = await plugins.smartfile.SmartFile.fromFilePath(plugins.path.join(this.projectDir, 'npmextra.json'));
+            const npmextraJsonFile = await plugins.smartfile.SmartFile.fromFilePath(npmextraJsonPath);
             const npmextraContent = JSON.parse(npmextraJsonFile.contents.toString());
             // Check for tsdoc context configuration
             if (npmextraContent?.tsdoc?.context) {
                 // Merge with default config
                 this.config = this.mergeConfigs(this.config, npmextraContent.tsdoc.context);
             }
+            // Cache the config
+            this.configCache = {
+                mtime: currentMtime,
+                config: { ...this.config }
+            };
         }
         catch (error) {
             console.error('Error loading context configuration:', error);
@@ -115,6 +156,34 @@ export class ConfigManager {
                 ...userConfig.trimming
             };
         }
+        // Merge cache configuration
+        if (userConfig.cache) {
+            result.cache = {
+                ...result.cache,
+                ...userConfig.cache
+            };
+        }
+        // Merge analyzer configuration
+        if (userConfig.analyzer) {
+            result.analyzer = {
+                ...result.analyzer,
+                ...userConfig.analyzer
+            };
+        }
+        // Merge prioritization weights
+        if (userConfig.prioritization) {
+            result.prioritization = {
+                ...result.prioritization,
+                ...userConfig.prioritization
+            };
+        }
+        // Merge tier configuration
+        if (userConfig.tiers) {
+            result.tiers = {
+                ...result.tiers,
+                ...userConfig.tiers
+            };
+        }
         return result;
     }
     /**
@@ -155,6 +224,8 @@ export class ConfigManager {
     async updateConfig(config) {
         // Merge with existing config
         this.config = this.mergeConfigs(this.config, config);
+        // Invalidate cache
+        this.configCache = null;
         try {
             if (!this.projectDir) {
                 return;
@@ -179,5 +250,44 @@ export class ConfigManager {
             console.error('Error updating context configuration:', error);
         }
     }
+    /**
+     * Get cache configuration
+     */
+    getCacheConfig() {
+        return this.config.cache || { enabled: true, ttl: 3600, maxSize: 100 };
+    }
+    /**
+     * Get analyzer configuration
+     */
+    getAnalyzerConfig() {
+        return this.config.analyzer || { enabled: true, useAIRefinement: false, aiModel: 'haiku' };
+    }
+    /**
+     * Get prioritization weights
+     */
+    getPrioritizationWeights() {
+        return this.config.prioritization || {
+            dependencyWeight: 0.3,
+            relevanceWeight: 0.4,
+            efficiencyWeight: 0.2,
+            recencyWeight: 0.1
+        };
+    }
+    /**
+     * Get tier configuration
+     */
+    getTierConfig() {
+        return this.config.tiers || {
+            essential: { minScore: 0.8, trimLevel: 'none' },
+            important: { minScore: 0.5, trimLevel: 'light' },
+            optional: { minScore: 0.2, trimLevel: 'aggressive' }
+        };
+    }
+    /**
+     * Clear the config cache (force reload on next access)
+     */
+    clearCache() {
+        this.configCache = null;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-manager.js","sourceRoot":"","sources":["../../ts/context/config-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/context/context-analyzer.d.ts

@@ -0,0 +1,73 @@
+import type { IFileMetadata, IAnalysisResult, TaskType, IPrioritizationWeights, ITierConfig } from './types.js';
+/**
+ * ContextAnalyzer provides intelligent file selection and prioritization
+ * based on dependency analysis, task relevance, and configurable weights
+ */
+export declare class ContextAnalyzer {
+    private projectRoot;
+    private weights;
+    private tiers;
+    /**
+     * Creates a new ContextAnalyzer
+     * @param projectRoot - Root directory of the project
+     * @param weights - Prioritization weights
+     * @param tiers - Tier configuration
+     */
+    constructor(projectRoot: string, weights?: Partial<IPrioritizationWeights>, tiers?: Partial<ITierConfig>);
+    /**
+     * Analyzes files for a specific task type
+     * @param metadata - Array of file metadata to analyze
+     * @param taskType - Type of task being performed
+     * @param changedFiles - Optional list of recently changed files (for commits)
+     * @returns Analysis result with scored files
+     */
+    analyze(metadata: IFileMetadata[], taskType: TaskType, changedFiles?: string[]): Promise<IAnalysisResult>;
+    /**
+     * Builds a dependency graph from file metadata
+     * @param metadata - Array of file metadata
+     * @returns Dependency graph as a map
+     */
+    private buildDependencyGraph;
+    /**
+     * Extracts import statements from file contents
+     * @param contents - File contents
+     * @param filePath - Path of the file being analyzed
+     * @returns Array of absolute paths to imported files
+     */
+    private extractImports;
+    /**
+     * Calculates centrality scores for all nodes in the dependency graph
+     * Uses a simplified PageRank-like algorithm
+     * @param graph - Dependency graph
+     */
+    private calculateCentrality;
+    /**
+     * Analyzes a single file
+     * @param meta - File metadata
+     * @param taskType - Task being performed
+     * @param graph - Dependency graph
+     * @param changedFiles - Recently changed files
+     * @returns File analysis
+     */
+    private analyzeFile;
+    /**
+     * Calculates task-specific relevance score
+     */
+    private calculateRelevance;
+    /**
+     * Calculates efficiency score (information density)
+     */
+    private calculateEfficiency;
+    /**
+     * Calculates recency score for changed files
+     */
+    private calculateRecency;
+    /**
+     * Assigns a tier based on importance score
+     */
+    private assignTier;
+    /**
+     * Generates a human-readable reason for the score
+     */
+    private generateReason;
+}

package/dist_ts/context/context-analyzer.js

@@ -0,0 +1,311 @@
+import * as plugins from '../plugins.js';
+/**
+ * ContextAnalyzer provides intelligent file selection and prioritization
+ * based on dependency analysis, task relevance, and configurable weights
+ */
+export class ContextAnalyzer {
+    /**
+     * Creates a new ContextAnalyzer
+     * @param projectRoot - Root directory of the project
+     * @param weights - Prioritization weights
+     * @param tiers - Tier configuration
+     */
+    constructor(projectRoot, weights = {}, tiers = {}) {
+        this.projectRoot = projectRoot;
+        // Default weights
+        this.weights = {
+            dependencyWeight: weights.dependencyWeight ?? 0.3,
+            relevanceWeight: weights.relevanceWeight ?? 0.4,
+            efficiencyWeight: weights.efficiencyWeight ?? 0.2,
+            recencyWeight: weights.recencyWeight ?? 0.1,
+        };
+        // Default tiers
+        this.tiers = {
+            essential: tiers.essential ?? { minScore: 0.8, trimLevel: 'none' },
+            important: tiers.important ?? { minScore: 0.5, trimLevel: 'light' },
+            optional: tiers.optional ?? { minScore: 0.2, trimLevel: 'aggressive' },
+        };
+    }
+    /**
+     * Analyzes files for a specific task type
+     * @param metadata - Array of file metadata to analyze
+     * @param taskType - Type of task being performed
+     * @param changedFiles - Optional list of recently changed files (for commits)
+     * @returns Analysis result with scored files
+     */
+    async analyze(metadata, taskType, changedFiles = []) {
+        const startTime = Date.now();
+        // Build dependency graph
+        const dependencyGraph = await this.buildDependencyGraph(metadata);
+        // Calculate centrality scores
+        this.calculateCentrality(dependencyGraph);
+        // Analyze each file
+        const files = [];
+        for (const meta of metadata) {
+            const analysis = await this.analyzeFile(meta, taskType, dependencyGraph, changedFiles);
+            files.push(analysis);
+        }
+        // Sort by importance score (highest first)
+        files.sort((a, b) => b.importanceScore - a.importanceScore);
+        const analysisDuration = Date.now() - startTime;
+        return {
+            taskType,
+            files,
+            dependencyGraph,
+            totalFiles: metadata.length,
+            analysisDuration,
+        };
+    }
+    /**
+     * Builds a dependency graph from file metadata
+     * @param metadata - Array of file metadata
+     * @returns Dependency graph as a map
+     */
+    async buildDependencyGraph(metadata) {
+        const graph = new Map();
+        // Initialize graph entries
+        for (const meta of metadata) {
+            graph.set(meta.path, {
+                path: meta.path,
+                imports: [],
+                importedBy: [],
+                centrality: 0,
+            });
+        }
+        // Parse imports from each file
+        for (const meta of metadata) {
+            try {
+                const contents = await plugins.smartfile.fs.toStringSync(meta.path);
+                const imports = this.extractImports(contents, meta.path);
+                const deps = graph.get(meta.path);
+                deps.imports = imports;
+                // Update importedBy for imported files
+                for (const importPath of imports) {
+                    const importedDeps = graph.get(importPath);
+                    if (importedDeps) {
+                        importedDeps.importedBy.push(meta.path);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to parse imports from ${meta.path}:`, error.message);
+            }
+        }
+        return graph;
+    }
+    /**
+     * Extracts import statements from file contents
+     * @param contents - File contents
+     * @param filePath - Path of the file being analyzed
+     * @returns Array of absolute paths to imported files
+     */
+    extractImports(contents, filePath) {
+        const imports = [];
+        const fileDir = plugins.path.dirname(filePath);
+        // Match various import patterns
+        const importRegex = /(?:import|export).*?from\s+['"](.+?)['"]/g;
+        let match;
+        while ((match = importRegex.exec(contents)) !== null) {
+            const importPath = match[1];
+            // Skip external modules
+            if (!importPath.startsWith('.')) {
+                continue;
+            }
+            // Resolve relative import to absolute path
+            let resolvedPath = plugins.path.resolve(fileDir, importPath);
+            // Handle various file extensions
+            const extensions = ['.ts', '.js', '.tsx', '.jsx', '/index.ts', '/index.js'];
+            let found = false;
+            for (const ext of extensions) {
+                const testPath = resolvedPath.endsWith(ext) ? resolvedPath : resolvedPath + ext;
+                try {
+                    // Use synchronous file check to avoid async in this context
+                    const fs = require('fs');
+                    const exists = fs.existsSync(testPath);
+                    if (exists) {
+                        imports.push(testPath);
+                        found = true;
+                        break;
+                    }
+                }
+                catch (error) {
+                    // Continue trying other extensions
+                }
+            }
+            if (!found && !resolvedPath.includes('.')) {
+                // Try with .ts extension as default
+                imports.push(resolvedPath + '.ts');
+            }
+        }
+        return imports;
+    }
+    /**
+     * Calculates centrality scores for all nodes in the dependency graph
+     * Uses a simplified PageRank-like algorithm
+     * @param graph - Dependency graph
+     */
+    calculateCentrality(graph) {
+        const damping = 0.85;
+        const iterations = 10;
+        const nodeCount = graph.size;
+        // Initialize scores
+        const scores = new Map();
+        for (const path of graph.keys()) {
+            scores.set(path, 1.0 / nodeCount);
+        }
+        // Iterative calculation
+        for (let i = 0; i < iterations; i++) {
+            const newScores = new Map();
+            for (const [path, deps] of graph.entries()) {
+                let score = (1 - damping) / nodeCount;
+                // Add contributions from nodes that import this file
+                for (const importerPath of deps.importedBy) {
+                    const importerDeps = graph.get(importerPath);
+                    if (importerDeps) {
+                        const importerScore = scores.get(importerPath) ?? 0;
+                        const outgoingCount = importerDeps.imports.length || 1;
+                        score += damping * (importerScore / outgoingCount);
+                    }
+                }
+                newScores.set(path, score);
+            }
+            // Update scores
+            for (const [path, score] of newScores) {
+                scores.set(path, score);
+            }
+        }
+        // Normalize scores to 0-1 range
+        const maxScore = Math.max(...scores.values());
+        if (maxScore > 0) {
+            for (const deps of graph.values()) {
+                const score = scores.get(deps.path) ?? 0;
+                deps.centrality = score / maxScore;
+            }
+        }
+    }
+    /**
+     * Analyzes a single file
+     * @param meta - File metadata
+     * @param taskType - Task being performed
+     * @param graph - Dependency graph
+     * @param changedFiles - Recently changed files
+     * @returns File analysis
+     */
+    async analyzeFile(meta, taskType, graph, changedFiles) {
+        const deps = graph.get(meta.path);
+        const centralityScore = deps?.centrality ?? 0;
+        // Calculate task-specific relevance
+        const relevanceScore = this.calculateRelevance(meta, taskType);
+        // Calculate efficiency (information per token)
+        const efficiencyScore = this.calculateEfficiency(meta);
+        // Calculate recency (for commit tasks)
+        const recencyScore = this.calculateRecency(meta, changedFiles);
+        // Calculate combined importance score
+        const importanceScore = relevanceScore * this.weights.relevanceWeight +
+            centralityScore * this.weights.dependencyWeight +
+            efficiencyScore * this.weights.efficiencyWeight +
+            recencyScore * this.weights.recencyWeight;
+        // Assign tier
+        const tier = this.assignTier(importanceScore);
+        return {
+            path: meta.path,
+            relevanceScore,
+            centralityScore,
+            efficiencyScore,
+            recencyScore,
+            importanceScore,
+            tier,
+            reason: this.generateReason(meta, taskType, importanceScore, tier),
+        };
+    }
+    /**
+     * Calculates task-specific relevance score
+     */
+    calculateRelevance(meta, taskType) {
+        const relativePath = meta.relativePath.toLowerCase();
+        let score = 0.5; // Base score
+        // README generation - prioritize public APIs and main exports
+        if (taskType === 'readme') {
+            if (relativePath.includes('index.ts'))
+                score += 0.3;
+            if (relativePath.match(/^ts\/[^\/]+\.ts$/))
+                score += 0.2; // Root level exports
+            if (relativePath.includes('test/'))
+                score -= 0.3;
+            if (relativePath.includes('classes/'))
+                score += 0.1;
+            if (relativePath.includes('interfaces/'))
+                score += 0.1;
+        }
+        // Commit messages - prioritize changed files and their dependencies
+        if (taskType === 'commit') {
+            if (relativePath.includes('test/'))
+                score -= 0.2;
+            // Recency will handle changed files
+        }
+        // Description generation - prioritize main exports and core interfaces
+        if (taskType === 'description') {
+            if (relativePath.includes('index.ts'))
+                score += 0.4;
+            if (relativePath.match(/^ts\/[^\/]+\.ts$/))
+                score += 0.3;
+            if (relativePath.includes('test/'))
+                score -= 0.4;
+            if (relativePath.includes('interfaces/'))
+                score += 0.2;
+        }
+        return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * Calculates efficiency score (information density)
+     */
+    calculateEfficiency(meta) {
+        // Prefer files that are not too large (good signal-to-noise ratio)
+        const optimalSize = 5000; // ~1250 tokens
+        const distance = Math.abs(meta.estimatedTokens - optimalSize);
+        const normalized = Math.max(0, 1 - distance / optimalSize);
+        return normalized;
+    }
+    /**
+     * Calculates recency score for changed files
+     */
+    calculateRecency(meta, changedFiles) {
+        if (changedFiles.length === 0) {
+            return 0;
+        }
+        // Check if this file was changed
+        const isChanged = changedFiles.some((changed) => changed === meta.path);
+        return isChanged ? 1.0 : 0.0;
+    }
+    /**
+     * Assigns a tier based on importance score
+     */
+    assignTier(score) {
+        if (score >= this.tiers.essential.minScore)
+            return 'essential';
+        if (score >= this.tiers.important.minScore)
+            return 'important';
+        if (score >= this.tiers.optional.minScore)
+            return 'optional';
+        return 'excluded';
+    }
+    /**
+     * Generates a human-readable reason for the score
+     */
+    generateReason(meta, taskType, score, tier) {
+        const reasons = [];
+        if (meta.relativePath.includes('index.ts')) {
+            reasons.push('main export file');
+        }
+        if (meta.relativePath.includes('test/')) {
+            reasons.push('test file (lower priority)');
+        }
+        if (taskType === 'readme' && meta.relativePath.match(/^ts\/[^\/]+\.ts$/)) {
+            reasons.push('root-level module');
+        }
+        reasons.push(`score: ${score.toFixed(2)}`);
+        reasons.push(`tier: ${tier}`);
+        return reasons.join(', ');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-analyzer.js","sourceRoot":"","sources":["../../ts/context/context-analyzer.ts"],"names":[],"mappings":"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"}