@mytechtoday/augment-extensions 0.4.0 → 0.7.0

package/cli/dist/commands/show.js

@@ -1,11 +1,57 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.showCommand = showCommand;
+exports.showModuleCommand = showModuleCommand;
 const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const highlight_js_1 = __importDefault(require("highlight.js"));
 const module_system_1 = require("../utils/module-system");
+const inspection_cache_1 = require("../utils/inspection-cache");
+const stream_reader_1 = require("../utils/stream-reader");
+const progress_1 = require("../utils/progress");
+const vscode_links_1 = require("../utils/vscode-links");
+const vscode_editor_1 = require("../utils/vscode-editor");
+/**
+ * Legacy show command - displays basic module information
+ * @deprecated Use showModuleCommand for enhanced inspection
+ */
 async function showCommand(moduleName, options) {
     try {
         const module = (0, module_system_1.findModule)(moduleName);
@@ -62,16 +108,888 @@ async function showCommand(moduleName, options) {
         process.exit(1);
     }
 }
-async function getSimilarModules(searchTerm) {
-    const allModules = (0, module_system_1.discoverModules)();
-    // Find similar modules (contains search term or search term contains module name)
+/**
+ * Enhanced module inspection command with advanced features
+ * Supports module overview, content viewing, and file inspection
+ */
+async function showModuleCommand(moduleName, filePath, options) {
+    try {
+        // Validate module name
+        if (!moduleName || moduleName.trim() === '') {
+            console.error(chalk_1.default.red('Error: Module name is required'));
+            console.log(chalk_1.default.gray('\nUsage: augx show module <module-name> [file-path] [options]'));
+            console.log(chalk_1.default.gray('Example: augx show module php-standards'));
+            console.log(chalk_1.default.gray('         augx show module php-standards rules/psr-standards.md'));
+            process.exit(1);
+        }
+        // Disable cache if --no-cache flag is set
+        if (options.noCache) {
+            inspection_cache_1.moduleInspectionCache.setEnabled(false);
+        }
+        // Discover and validate module using enhanced discovery
+        const module = (0, module_system_1.findModuleEnhanced)(moduleName);
+        if (!module) {
+            console.error(chalk_1.default.red(`Module not found: ${moduleName}`));
+            // Suggest similar modules using enhanced suggestions
+            const suggestions = (0, module_system_1.getModuleSuggestions)(moduleName, 5);
+            if (suggestions.length > 0) {
+                console.log(chalk_1.default.yellow('\nDid you mean one of these?'));
+                suggestions.forEach(suggestion => {
+                    console.log(chalk_1.default.cyan(`  • ${suggestion.fullName}`));
+                });
+            }
+            console.log(chalk_1.default.gray('\nUse "augx list" to see all available modules.'));
+            process.exit(1);
+        }
+        // Route to appropriate handler based on options and arguments
+        if (filePath) {
+            // Individual file inspection
+            await showModuleFile(module, filePath, options);
+        }
+        else if (options.content) {
+            // Aggregated content view
+            await showModuleContent(module, options);
+        }
+        else {
+            // Module overview (default)
+            await showModuleOverview(module, options);
+        }
+        // Re-enable cache after command completes
+        if (options.noCache) {
+            inspection_cache_1.moduleInspectionCache.setEnabled(true);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Error inspecting module:'), error);
+        if (error instanceof Error) {
+            console.error(chalk_1.default.gray(error.message));
+        }
+        // Re-enable cache on error
+        if (options.noCache) {
+            inspection_cache_1.moduleInspectionCache.setEnabled(true);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Display module overview with metadata and file listing
+ */
+async function showModuleOverview(module, options) {
+    // Try to get from cache first
+    const cacheKey = `overview:${module.fullName}`;
+    let extendedMetadata = inspection_cache_1.moduleInspectionCache.get(cacheKey, module.path);
+    if (!extendedMetadata) {
+        // Extract comprehensive metadata
+        extendedMetadata = (0, module_system_1.extractModuleMetadata)(module.path);
+        if (!extendedMetadata) {
+            console.error(chalk_1.default.red('Failed to extract module metadata'));
+            return;
+        }
+        // Cache the result
+        inspection_cache_1.moduleInspectionCache.set(cacheKey, extendedMetadata, module.path);
+    }
+    // Handle JSON output format
+    if (options.json || options.format === 'json') {
+        const jsonOutput = {
+            name: module.fullName,
+            version: extendedMetadata.version,
+            type: extendedMetadata.type,
+            description: extendedMetadata.description,
+            displayName: extendedMetadata.displayName,
+            tags: extendedMetadata.tags,
+            path: module.path,
+            files: {
+                total: extendedMetadata.files?.total || 0,
+                rules: extendedMetadata.files?.rules || 0,
+                examples: extendedMetadata.files?.examples || 0,
+                other: extendedMetadata.files?.other || 0
+            },
+            size: {
+                totalBytes: extendedMetadata.size?.totalBytes || 0,
+                totalCharacters: extendedMetadata.size?.totalCharacters || 0
+            },
+            lastModified: extendedMetadata.lastModified,
+            augment: extendedMetadata.augment
+        };
+        console.log(JSON.stringify(jsonOutput, null, 2));
+        return;
+    }
+    // Handle Markdown output format
+    if (options.format === 'markdown') {
+        console.log(`# ${module.fullName}\n`);
+        console.log(`**Version:** ${extendedMetadata.version}\n`);
+        console.log(`**Type:** ${extendedMetadata.type}\n`);
+        console.log(`**Description:** ${extendedMetadata.description}\n`);
+        if (extendedMetadata.tags && extendedMetadata.tags.length > 0) {
+            console.log(`**Tags:** ${extendedMetadata.tags.join(', ')}\n`);
+        }
+        console.log(`## Files\n`);
+        console.log(`- Total: ${extendedMetadata.files?.total || 0}`);
+        console.log(`- Rules: ${extendedMetadata.files?.rules || 0}`);
+        console.log(`- Examples: ${extendedMetadata.files?.examples || 0}`);
+        console.log(`- Other: ${extendedMetadata.files?.other || 0}\n`);
+        console.log(`## Size\n`);
+        const totalBytes = extendedMetadata.size?.totalBytes || 0;
+        const totalChars = extendedMetadata.size?.totalCharacters || 0;
+        console.log(`- Total: ${formatBytes(totalBytes)} (${totalBytes.toLocaleString()} bytes)`);
+        console.log(`- Characters: ${totalChars.toLocaleString()}\n`);
+        if (extendedMetadata.lastModified) {
+            console.log(`**Last Modified:** ${formatDate(extendedMetadata.lastModified)}\n`);
+        }
+        console.log(`**Location:** \`${module.path}\`\n`);
+        return;
+    }
+    // Handle plain text output format (ASCII-only, no colors)
+    if (options.format === 'text') {
+        console.log();
+        console.log(`Module: ${module.fullName}`);
+        console.log('='.repeat(60));
+        console.log();
+        console.log('Metadata:');
+        console.log(`  Name:        ${extendedMetadata.displayName}`);
+        console.log(`  Version:     ${extendedMetadata.version}`);
+        console.log(`  Type:        ${extendedMetadata.type}`);
+        console.log(`  Description: ${extendedMetadata.description}`);
+        if (extendedMetadata.tags && extendedMetadata.tags.length > 0) {
+            console.log(`  Tags:        ${extendedMetadata.tags.join(', ')}`);
+        }
+        console.log();
+        console.log('Files:');
+        console.log(`  Total:       ${extendedMetadata.files?.total || 0}`);
+        console.log(`  Rules:       ${extendedMetadata.files?.rules || 0}`);
+        console.log(`  Examples:    ${extendedMetadata.files?.examples || 0}`);
+        console.log(`  Other:       ${extendedMetadata.files?.other || 0}`);
+        console.log();
+        console.log('Size:');
+        const totalBytes = extendedMetadata.size?.totalBytes || 0;
+        const totalChars = extendedMetadata.size?.totalCharacters || 0;
+        console.log(`  Total:       ${formatBytes(totalBytes)} (${totalBytes.toLocaleString()} bytes)`);
+        console.log(`  Characters:  ${totalChars.toLocaleString()}`);
+        console.log();
+        if (extendedMetadata.lastModified) {
+            console.log('Last Modified:');
+            console.log(`  ${formatDate(extendedMetadata.lastModified)}`);
+            console.log();
+        }
+        console.log('Location:');
+        console.log(`  ${module.path}`);
+        console.log();
+        return;
+    }
+    // Colored text output format (default)
+    console.log();
+    console.log(chalk_1.default.bold.blue(`📦 ${module.fullName}`));
+    console.log(chalk_1.default.gray('─'.repeat(60)));
+    console.log();
+    // Basic metadata
+    console.log(chalk_1.default.bold('Metadata:'));
+    console.log(chalk_1.default.gray(`  Name:        ${extendedMetadata.displayName}`));
+    console.log(chalk_1.default.gray(`  Version:     ${extendedMetadata.version}`));
+    console.log(chalk_1.default.gray(`  Type:        ${extendedMetadata.type}`));
+    console.log(chalk_1.default.gray(`  Description: ${extendedMetadata.description}`));
+    if (extendedMetadata.tags && extendedMetadata.tags.length > 0) {
+        console.log(chalk_1.default.gray(`  Tags:        ${extendedMetadata.tags.join(', ')}`));
+    }
+    console.log();
+    // File statistics
+    console.log(chalk_1.default.bold('Files:'));
+    console.log(chalk_1.default.gray(`  Total:       ${extendedMetadata.files?.total || 0}`));
+    console.log(chalk_1.default.cyan(`  Rules:       ${extendedMetadata.files?.rules || 0}`));
+    console.log(chalk_1.default.green(`  Examples:    ${extendedMetadata.files?.examples || 0}`));
+    console.log(chalk_1.default.gray(`  Other:       ${extendedMetadata.files?.other || 0}`));
+    console.log();
+    // Size statistics
+    console.log(chalk_1.default.bold('Size:'));
+    const totalBytes = extendedMetadata.size?.totalBytes || 0;
+    const totalChars = extendedMetadata.size?.totalCharacters || 0;
+    console.log(chalk_1.default.gray(`  Total:       ${formatBytes(totalBytes)} (${totalBytes.toLocaleString()} bytes)`));
+    console.log(chalk_1.default.gray(`  Characters:  ${totalChars.toLocaleString()}`));
+    console.log();
+    // Last modified
+    if (extendedMetadata.lastModified) {
+        console.log(chalk_1.default.bold('Last Modified:'));
+        console.log(chalk_1.default.gray(`  ${formatDate(extendedMetadata.lastModified)}`));
+        console.log();
+    }
+    // Augment configuration
+    if (extendedMetadata.augment) {
+        console.log(chalk_1.default.bold('Augment Configuration:'));
+        if (extendedMetadata.augment.priority) {
+            console.log(chalk_1.default.gray(`  Priority:    ${extendedMetadata.augment.priority}`));
+        }
+        if (extendedMetadata.augment.category) {
+            console.log(chalk_1.default.gray(`  Category:    ${extendedMetadata.augment.category}`));
+        }
+        if (extendedMetadata.augment.characterCount !== undefined) {
+            console.log(chalk_1.default.gray(`  Char Count:  ${extendedMetadata.augment.characterCount.toLocaleString()}`));
+        }
+        console.log();
+    }
+    // Path information
+    console.log(chalk_1.default.bold('Location:'));
+    console.log(chalk_1.default.gray(`  ${module.path}`));
+    console.log();
+    // Helpful commands
+    console.log(chalk_1.default.bold('Commands:'));
+    console.log(chalk_1.default.gray(`  View content:     augx show module ${module.fullName} --content`));
+    console.log(chalk_1.default.gray(`  List files:       augx show module ${module.fullName} --filter "*.md"`));
+    console.log(chalk_1.default.gray(`  Search content:   augx show module ${module.fullName} --search "keyword"`));
+    console.log();
+}
+/**
+ * Format bytes to human-readable format
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+/**
+ * Format date to human-readable format
+ */
+function formatDate(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays === 0) {
+        return `Today at ${date.toLocaleTimeString()}`;
+    }
+    else if (diffDays === 1) {
+        return `Yesterday at ${date.toLocaleTimeString()}`;
+    }
+    else if (diffDays < 7) {
+        return `${diffDays} days ago`;
+    }
+    else {
+        return date.toLocaleDateString();
+    }
+}
+/**
+ * Display aggregated content from all module files
+ */
+async function showModuleContent(module, options) {
+    const { listModuleFiles } = await Promise.resolve().then(() => __importStar(require('../utils/module-system')));
+    // Get all markdown files from the module
+    const files = listModuleFiles(module.path, {
+        recursive: true,
+        filter: options.filter || '*.md',
+        groupByDirectory: true,
+        depth: options.depth
+    });
+    if (files.length === 0) {
+        console.log(chalk_1.default.yellow('No markdown files found in module'));
+        return;
+    }
+    // Apply search filter if provided
+    let searchResults = [];
+    if (options.search) {
+        searchResults = performSearch(files, options.search);
+        if (searchResults.length === 0) {
+            console.log(chalk_1.default.yellow(`No matches found for: "${options.search}"`));
+            return;
+        }
+    }
+    // Handle search results display
+    if (options.search && searchResults.length > 0) {
+        displaySearchResults(module, searchResults, options);
+        return;
+    }
+    // Handle JSON output format
+    if (options.json || options.format === 'json') {
+        const jsonOutput = {
+            module: module.fullName,
+            fileCount: files.length,
+            files: files.map(f => ({
+                path: f.relativePath,
+                size: f.size,
+                modified: f.modified,
+                type: f.type
+            })),
+            content: files.map(f => {
+                let content = fs.readFileSync(f.path, 'utf-8');
+                if (options.secure) {
+                    content = redactSensitiveData(content, false);
+                }
+                return {
+                    file: f.relativePath,
+                    content: content
+                };
+            })
+        };
+        console.log(JSON.stringify(jsonOutput, null, 2));
+        // Log redactions summary if secure mode is enabled
+        if (options.secure) {
+            console.error(chalk_1.default.yellow('\n⚠️  Sensitive data has been redacted from output'));
+        }
+        return;
+    }
+    // Handle Markdown output format
+    if (options.format === 'markdown') {
+        console.log(`# ${module.fullName}\n`);
+        console.log(`**Module Type:** ${module.metadata.type}\n`);
+        console.log(`**Version:** ${module.metadata.version}\n`);
+        if (options.secure) {
+            console.log(`**Security:** Sensitive data redacted\n`);
+        }
+        console.log(`---\n`);
+        for (const file of files) {
+            console.log(`## ${file.relativePath}\n`);
+            let content = fs.readFileSync(file.path, 'utf-8');
+            if (options.secure) {
+                content = redactSensitiveData(content, false);
+            }
+            console.log(content);
+            console.log('\n---\n');
+        }
+        if (options.secure) {
+            console.log(`\n> ⚠️ Sensitive data has been redacted from this output\n`);
+        }
+        return;
+    }
+    // Handle plain text output format (ASCII-only, no colors)
+    if (options.format === 'text') {
+        console.log();
+        console.log(`Aggregated Content: ${module.fullName}`);
+        console.log('='.repeat(60));
+        console.log();
+        console.log(`Files: ${files.length}`);
+        if (options.secure) {
+            console.log('Security: Sensitive data redacted');
+        }
+        console.log();
+        for (const file of files) {
+            console.log(`File: ${file.relativePath}`);
+            console.log(`Size: ${formatBytes(file.size)} | Modified: ${formatDate(file.modified)}`);
+            console.log('-'.repeat(60));
+            console.log();
+            let content = fs.readFileSync(file.path, 'utf-8');
+            if (options.secure) {
+                content = redactSensitiveData(content, false);
+            }
+            console.log(content);
+            console.log();
+            console.log('='.repeat(60));
+            console.log();
+        }
+        const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+        console.log('Summary:');
+        console.log(`  Total files:  ${files.length}`);
+        console.log(`  Total size:   ${formatBytes(totalSize)}`);
+        if (options.secure) {
+            console.log();
+            console.log('WARNING: Sensitive data has been redacted from this output');
+        }
+        console.log();
+        return;
+    }
+    // Colored text output format (default)
+    console.log();
+    console.log(chalk_1.default.bold.blue(`📄 Aggregated Content: ${module.fullName}`));
+    console.log(chalk_1.default.gray('─'.repeat(60)));
+    console.log();
+    // Apply pagination if requested
+    const pageSize = options.pageSize || 10;
+    const currentPage = options.page || 1;
+    const totalPages = Math.ceil(files.length / pageSize);
+    let filesToDisplay = files;
+    let paginationInfo = '';
+    if (options.page) {
+        const startIndex = (currentPage - 1) * pageSize;
+        const endIndex = Math.min(startIndex + pageSize, files.length);
+        filesToDisplay = files.slice(startIndex, endIndex);
+        paginationInfo = ` (Page ${currentPage} of ${totalPages})`;
+    }
+    console.log(chalk_1.default.bold(`Files: ${files.length}${paginationInfo}`));
+    if (options.secure) {
+        console.log(chalk_1.default.yellow('🔒 Security: Sensitive data redacted'));
+    }
+    console.log();
+    // Display each file with section headers
+    for (const file of filesToDisplay) {
+        console.log(chalk_1.default.bold.cyan(`┌─ ${file.relativePath}`));
+        console.log(chalk_1.default.gray(`│  Size: ${formatBytes(file.size)} | Modified: ${formatDate(file.modified)}`));
+        console.log(chalk_1.default.bold.cyan('└' + '─'.repeat(58)));
+        console.log();
+        let content = fs.readFileSync(file.path, 'utf-8');
+        if (options.secure) {
+            content = redactSensitiveData(content, false);
+        }
+        // Preserve markdown formatting
+        console.log(content);
+        console.log();
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log();
+    }
+    // Summary
+    const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+    console.log(chalk_1.default.bold('Summary:'));
+    console.log(chalk_1.default.gray(`  Total files:  ${files.length}`));
+    console.log(chalk_1.default.gray(`  Displayed:    ${filesToDisplay.length}`));
+    console.log(chalk_1.default.gray(`  Total size:   ${formatBytes(totalSize)}`));
+    if (options.page && totalPages > 1) {
+        console.log();
+        console.log(chalk_1.default.bold('Pagination:'));
+        console.log(chalk_1.default.gray(`  Current page: ${currentPage} of ${totalPages}`));
+        if (currentPage < totalPages) {
+            console.log(chalk_1.default.cyan(`  Next page:    augx show module ${module.fullName} --content --page ${currentPage + 1}`));
+        }
+        if (currentPage > 1) {
+            console.log(chalk_1.default.cyan(`  Prev page:    augx show module ${module.fullName} --content --page ${currentPage - 1}`));
+        }
+    }
+    if (options.secure) {
+        console.log();
+        console.log(chalk_1.default.yellow('⚠️  Sensitive data has been redacted from this output'));
+    }
+    console.log();
+}
+/**
+ * Display individual file content with line numbers and optional syntax highlighting
+ */
+async function showModuleFile(module, filePath, options) {
+    // Resolve file path (support both absolute and relative paths)
+    let fullPath;
+    if (path.isAbsolute(filePath)) {
+        fullPath = filePath;
+    }
+    else {
+        // Try relative to module path
+        fullPath = path.join(module.path, filePath);
+    }
+    // Check if file exists
+    if (!fs.existsSync(fullPath)) {
+        console.error(chalk_1.default.red(`File not found: ${filePath}`));
+        console.log(chalk_1.default.gray(`\nSearched in: ${fullPath}`));
+        console.log(chalk_1.default.gray(`Module path: ${module.path}`));
+        process.exit(1);
+    }
+    // Handle --open flag: Open file in VS Code editor
+    if (options.open) {
+        try {
+            if (!(0, vscode_editor_1.isVSCodeAvailable)()) {
+                console.error(chalk_1.default.red('VS Code CLI is not available. Please install VS Code and ensure "code" is in your PATH.'));
+                process.exit(1);
+            }
+            await (0, vscode_editor_1.openInEditor)(fullPath);
+            console.log(chalk_1.default.green(`✓ Opened ${path.basename(fullPath)} in VS Code editor`));
+            return;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Failed to open file: ${error instanceof Error ? error.message : String(error)}`));
+            process.exit(1);
+        }
+    }
+    // Handle --preview flag: Open file in VS Code preview pane
+    if (options.preview) {
+        try {
+            if (!(0, vscode_editor_1.isVSCodeAvailable)()) {
+                console.error(chalk_1.default.red('VS Code CLI is not available. Please install VS Code and ensure "code" is in your PATH.'));
+                process.exit(1);
+            }
+            await (0, vscode_editor_1.openInPreview)(fullPath);
+            console.log(chalk_1.default.green(`✓ Opened ${path.basename(fullPath)} in VS Code preview pane`));
+            return;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Failed to open file: ${error instanceof Error ? error.message : String(error)}`));
+            process.exit(1);
+        }
+    }
+    const stats = fs.statSync(fullPath);
+    const fileSizeThreshold = 1024 * 1024; // 1MB threshold for streaming
+    // Use streaming for large files
+    let content;
+    if (stats.size > fileSizeThreshold) {
+        // Show progress for large files
+        const spinner = new progress_1.Spinner(`Reading large file (${formatBytes(stats.size)})...`);
+        spinner.start();
+        try {
+            // Stream large files
+            const chunks = [];
+            await (0, stream_reader_1.readFileStreaming)(fullPath, async (chunk, streamStats) => {
+                chunks.push(chunk);
+                const progress = (streamStats.bytesRead / stats.size) * 100;
+                spinner.setText(`Reading large file: ${progress.toFixed(1)}% (${formatBytes(streamStats.bytesRead)}/${formatBytes(stats.size)})`);
+            }, { highWaterMark: 64 * 1024 });
+            content = chunks.join('');
+            spinner.stop(chalk_1.default.green('✓ File loaded successfully'));
+        }
+        catch (error) {
+            spinner.stop(chalk_1.default.red('✗ Failed to read file'));
+            throw error;
+        }
+    }
+    else {
+        // Read small files normally
+        content = fs.readFileSync(fullPath, 'utf-8');
+    }
+    // Apply redaction if secure flag is set
+    if (options.secure) {
+        content = redactSensitiveData(content, true);
+    }
+    const lines = content.split('\n');
+    // Get relative path for display
+    const relativePath = path.relative(module.path, fullPath);
+    // Handle JSON output format
+    if (options.json || options.format === 'json') {
+        const jsonOutput = {
+            module: module.fullName,
+            file: relativePath,
+            path: fullPath,
+            size: stats.size,
+            modified: stats.mtime,
+            lines: lines.length,
+            content: content
+        };
+        console.log(JSON.stringify(jsonOutput, null, 2));
+        return;
+    }
+    // Handle Markdown output format
+    if (options.format === 'markdown') {
+        console.log(`# ${relativePath}\n`);
+        console.log(`**Module:** ${module.fullName}\n`);
+        console.log(`**Size:** ${formatBytes(stats.size)} | **Lines:** ${lines.length}\n`);
+        console.log('```');
+        console.log(content);
+        console.log('```');
+        return;
+    }
+    // Handle plain text output format (ASCII-only, no colors, no line numbers)
+    if (options.format === 'text') {
+        console.log();
+        console.log(`File: ${relativePath}`);
+        console.log('='.repeat(60));
+        console.log();
+        console.log('File Information:');
+        console.log(`  Module:   ${module.fullName}`);
+        console.log(`  Path:     ${relativePath}`);
+        console.log(`  Size:     ${formatBytes(stats.size)}`);
+        console.log(`  Lines:    ${lines.length}`);
+        console.log(`  Modified: ${formatDate(stats.mtime)}`);
+        const detectedLang = detectLanguage(fullPath);
+        if (detectedLang) {
+            console.log(`  Language: ${detectedLang}`);
+        }
+        console.log();
+        console.log('Content:');
+        console.log('-'.repeat(60));
+        console.log();
+        console.log(content);
+        console.log();
+        console.log('='.repeat(60));
+        console.log();
+        return;
+    }
+    // Colored text output format (default) with line numbers
+    const workspaceRoot = (0, vscode_links_1.getWorkspaceRoot)();
+    const clickablePath = (0, vscode_links_1.formatClickablePath)(fullPath, { workspaceRoot });
+    console.log();
+    console.log(chalk_1.default.bold.blue(`📄 ${relativePath}`));
+    console.log(chalk_1.default.gray(`   ${clickablePath}`));
+    console.log(chalk_1.default.gray('─'.repeat(60)));
+    console.log();
+    console.log(chalk_1.default.bold('File Information:'));
+    console.log(chalk_1.default.gray(`  Module:   ${module.fullName}`));
+    console.log(chalk_1.default.gray(`  Path:     ${relativePath}`));
+    console.log(chalk_1.default.gray(`  Full:     ${clickablePath}`));
+    console.log(chalk_1.default.gray(`  Size:     ${formatBytes(stats.size)}`));
+    console.log(chalk_1.default.gray(`  Lines:    ${lines.length}`));
+    console.log(chalk_1.default.gray(`  Modified: ${formatDate(stats.mtime)}`));
+    // Display detected language
+    const detectedLang = detectLanguage(fullPath);
+    if (detectedLang) {
+        console.log(chalk_1.default.gray(`  Language: ${detectedLang}`));
+    }
+    console.log();
+    console.log(chalk_1.default.bold('Content:'));
+    console.log(chalk_1.default.gray('─'.repeat(60)));
+    console.log();
+    // Apply syntax highlighting if enabled (default: enabled)
+    const enableHighlighting = options.format !== 'text' && process.stdout.isTTY;
+    if (enableHighlighting && detectedLang) {
+        // Try to apply syntax highlighting
+        try {
+            const highlighted = applySyntaxHighlighting(content, fullPath, true);
+            const highlightedLines = highlighted.split('\n');
+            // Display with line numbers
+            const lineNumberWidth = highlightedLines.length.toString().length;
+            highlightedLines.forEach((line, index) => {
+                const lineNumber = (index + 1).toString().padStart(lineNumberWidth, ' ');
+                console.log(chalk_1.default.gray(`${lineNumber} │ `) + line);
+            });
+        }
+        catch (error) {
+            // Fallback to plain display if highlighting fails
+            const lineNumberWidth = lines.length.toString().length;
+            lines.forEach((line, index) => {
+                const lineNumber = (index + 1).toString().padStart(lineNumberWidth, ' ');
+                console.log(chalk_1.default.gray(`${lineNumber} │ `) + line);
+            });
+        }
+    }
+    else {
+        // Display content with line numbers (no highlighting)
+        const lineNumberWidth = lines.length.toString().length;
+        lines.forEach((line, index) => {
+            const lineNumber = (index + 1).toString().padStart(lineNumberWidth, ' ');
+            console.log(chalk_1.default.gray(`${lineNumber} │ `) + line);
+        });
+    }
+    console.log();
+    console.log(chalk_1.default.gray('─'.repeat(60)));
+    console.log();
+}
+/**
+ * Display search results with highlighting and context
+ */
+function displaySearchResults(module, searchResults, options) {
+    const searchTerm = options.search || '';
+    // JSON output
+    if (options.json || options.format === 'json') {
+        const jsonOutput = {
+            module: module.fullName,
+            searchTerm: searchTerm,
+            totalMatches: searchResults.reduce((sum, r) => sum + r.matches.length, 0),
+            results: searchResults.map(r => ({
+                file: r.file.relativePath,
+                matchCount: r.matches.length,
+                matches: r.matches.map(m => ({
+                    line: m.line,
+                    text: m.text
+                }))
+            }))
+        };
+        console.log(JSON.stringify(jsonOutput, null, 2));
+        return;
+    }
+    // Text output
+    console.log();
+    console.log(chalk_1.default.bold.blue(`🔍 Search Results: "${searchTerm}"`));
+    console.log(chalk_1.default.gray('─'.repeat(60)));
+    console.log();
+    const totalMatches = searchResults.reduce((sum, r) => sum + r.matches.length, 0);
+    console.log(chalk_1.default.bold(`Found ${totalMatches} matches in ${searchResults.length} files`));
+    console.log();
+    for (const result of searchResults) {
+        console.log(chalk_1.default.bold.cyan(`📄 ${result.file.relativePath}`));
+        console.log(chalk_1.default.gray(`   ${result.matches.length} matches`));
+        console.log();
+        for (const match of result.matches) {
+            console.log(chalk_1.default.gray(`   Line ${match.line}:`));
+            console.log('   ' + highlightSearchTerm(match.text, searchTerm));
+            console.log();
+        }
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log();
+    }
+    console.log(chalk_1.default.bold('Summary:'));
+    console.log(chalk_1.default.gray(`  Total matches: ${totalMatches}`));
+    console.log(chalk_1.default.gray(`  Files with matches: ${searchResults.length}`));
+    console.log();
+}
+/**
+ * Perform search within module files
+ */
+function performSearch(files, searchTerm) {
+    const results = [];
     const searchLower = searchTerm.toLowerCase();
-    return allModules
-        .filter(module => {
-        const moduleLower = module.fullName.toLowerCase();
-        return moduleLower.includes(searchLower) || searchLower.includes(moduleLower);
-    })
-        .map(m => m.fullName)
-        .slice(0, 5); // Limit to 5 suggestions
+    for (const file of files) {
+        const content = fs.readFileSync(file.path, 'utf-8');
+        const lines = content.split('\n');
+        const matches = [];
+        lines.forEach((line, index) => {
+            if (line.toLowerCase().includes(searchLower)) {
+                // Get context lines (2 before, 2 after)
+                const contextBefore = lines.slice(Math.max(0, index - 2), index);
+                const contextAfter = lines.slice(index + 1, Math.min(lines.length, index + 3));
+                matches.push({
+                    line: index + 1,
+                    text: line,
+                    context: [...contextBefore, line, ...contextAfter]
+                });
+            }
+        });
+        if (matches.length > 0) {
+            results.push({ file, matches });
+        }
+    }
+    return results;
+}
+/**
+ * Highlight search term in text
+ */
+function highlightSearchTerm(text, searchTerm) {
+    const regex = new RegExp(`(${searchTerm})`, 'gi');
+    return text.replace(regex, chalk_1.default.yellow.bold('$1'));
+}
+/**
+ * Apply syntax highlighting to code content
+ * Detects language from file extension and applies appropriate highlighting
+ */
+function applySyntaxHighlighting(content, filePath, enableColors = true) {
+    if (!enableColors) {
+        return content;
+    }
+    try {
+        // Detect language from file extension
+        const ext = path.extname(filePath).toLowerCase();
+        const languageMap = {
+            '.ts': 'typescript',
+            '.js': 'javascript',
+            '.jsx': 'javascript',
+            '.tsx': 'typescript',
+            '.py': 'python',
+            '.php': 'php',
+            '.rb': 'ruby',
+            '.go': 'go',
+            '.rs': 'rust',
+            '.java': 'java',
+            '.c': 'c',
+            '.cpp': 'cpp',
+            '.cs': 'csharp',
+            '.sh': 'bash',
+            '.ps1': 'powershell',
+            '.md': 'markdown',
+            '.json': 'json',
+            '.yaml': 'yaml',
+            '.yml': 'yaml',
+            '.xml': 'xml',
+            '.html': 'html',
+            '.css': 'css',
+            '.scss': 'scss',
+            '.sql': 'sql'
+        };
+        const language = languageMap[ext];
+        if (language) {
+            const highlighted = highlight_js_1.default.highlight(content, { language, ignoreIllegals: true });
+            return highlighted.value;
+        }
+        // Auto-detect if no extension match
+        const autoDetected = highlight_js_1.default.highlightAuto(content);
+        return autoDetected.value;
+    }
+    catch (error) {
+        // If highlighting fails, return original content
+        return content;
+    }
+}
+/**
+ * Convert ANSI color codes from highlight.js to chalk colors
+ * This is a simplified version - highlight.js uses HTML-like tags
+ */
+function convertHighlightToChalk(highlightedCode) {
+    // highlight.js returns HTML-like output, we need to convert to terminal colors
+    // For now, return as-is since we're using it in terminal context
+    // A more sophisticated implementation would parse the HTML and apply chalk colors
+    return highlightedCode;
+}
+/**
+ * Detect language from file extension
+ */
+function detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const languageMap = {
+        '.ts': 'TypeScript',
+        '.js': 'JavaScript',
+        '.jsx': 'JavaScript (JSX)',
+        '.tsx': 'TypeScript (TSX)',
+        '.py': 'Python',
+        '.php': 'PHP',
+        '.rb': 'Ruby',
+        '.go': 'Go',
+        '.rs': 'Rust',
+        '.java': 'Java',
+        '.c': 'C',
+        '.cpp': 'C++',
+        '.cs': 'C#',
+        '.sh': 'Bash',
+        '.ps1': 'PowerShell',
+        '.md': 'Markdown',
+        '.json': 'JSON',
+        '.yaml': 'YAML',
+        '.yml': 'YAML',
+        '.xml': 'XML',
+        '.html': 'HTML',
+        '.css': 'CSS',
+        '.scss': 'SCSS',
+        '.sql': 'SQL'
+    };
+    return languageMap[ext] || null;
+}
+/**
+ * Get similar modules for legacy showCommand
+ * @deprecated Use getModuleSuggestions from module-system instead
+ */
+async function getSimilarModules(searchTerm) {
+    const suggestions = (0, module_system_1.getModuleSuggestions)(searchTerm, 5);
+    return suggestions.map(m => m.fullName);
+}
+/**
+ * Redaction patterns for sensitive data
+ */
+const REDACTION_PATTERNS = [
+    // API Keys
+    { pattern: /\b([A-Za-z0-9_-]*API[_-]?KEY[_-]?[A-Za-z0-9_-]*)\s*[:=]\s*['"]?([A-Za-z0-9_\-\/+=]{16,})['"]?/gi, name: 'API_KEY' },
+    { pattern: /\b(api[_-]?key)\s*[:=]\s*['"]?([A-Za-z0-9_\-\/+=]{16,})['"]?/gi, name: 'API_KEY' },
+    // Secrets
+    { pattern: /\b([A-Za-z0-9_-]*SECRET[_-]?[A-Za-z0-9_-]*)\s*[:=]\s*['"]?([A-Za-z0-9_\-\/+=]{16,})['"]?/gi, name: 'SECRET' },
+    { pattern: /\b(secret)\s*[:=]\s*['"]?([A-Za-z0-9_\-\/+=]{16,})['"]?/gi, name: 'SECRET' },
+    // Tokens
+    { pattern: /\b([A-Za-z0-9_-]*TOKEN[_-]?[A-Za-z0-9_-]*)\s*[:=]\s*['"]?([A-Za-z0-9_\-\/+=]{16,})['"]?/gi, name: 'TOKEN' },
+    { pattern: /\b(token)\s*[:=]\s*['"]?([A-Za-z0-9_\-\/+=]{16,})['"]?/gi, name: 'TOKEN' },
+    { pattern: /\b(bearer)\s+([A-Za-z0-9_\-\/+=]{16,})/gi, name: 'BEARER_TOKEN' },
+    // Passwords
+    { pattern: /\b([A-Za-z0-9_-]*PASSWORD[_-]?[A-Za-z0-9_-]*)\s*[:=]\s*['"]?([^\s'"]{8,})['"]?/gi, name: 'PASSWORD' },
+    { pattern: /\b(password|passwd|pwd)\s*[:=]\s*['"]?([^\s'"]{8,})['"]?/gi, name: 'PASSWORD' },
+    // Private Keys
+    { pattern: /(-----BEGIN\s+(?:RSA\s+)?PRIVATE\s+KEY-----[\s\S]*?-----END\s+(?:RSA\s+)?PRIVATE\s+KEY-----)/gi, name: 'PRIVATE_KEY' },
+    // AWS Keys
+    { pattern: /\b(AKIA[0-9A-Z]{16})\b/g, name: 'AWS_ACCESS_KEY' },
+    { pattern: /\b([A-Za-z0-9/+=]{40})\b/g, name: 'AWS_SECRET_KEY' },
+    // GitHub Tokens
+    { pattern: /\b(ghp_[A-Za-z0-9]{36})\b/g, name: 'GITHUB_TOKEN' },
+    { pattern: /\b(gho_[A-Za-z0-9]{36})\b/g, name: 'GITHUB_OAUTH' },
+    { pattern: /\b(ghu_[A-Za-z0-9]{36})\b/g, name: 'GITHUB_USER_TOKEN' },
+    { pattern: /\b(ghs_[A-Za-z0-9]{36})\b/g, name: 'GITHUB_SERVER_TOKEN' },
+    { pattern: /\b(ghr_[A-Za-z0-9]{36})\b/g, name: 'GITHUB_REFRESH_TOKEN' },
+    // Generic credentials
+    { pattern: /\b(credentials?)\s*[:=]\s*['"]?([^\s'"]{16,})['"]?/gi, name: 'CREDENTIALS' },
+    { pattern: /\b(auth)\s*[:=]\s*['"]?([A-Za-z0-9_\-\/+=]{16,})['"]?/gi, name: 'AUTH' }
+];
+/**
+ * Redact sensitive data from content
+ */
+function redactSensitiveData(content, logRedactions = false) {
+    let redactedContent = content;
+    const redactions = [];
+    for (const { pattern, name } of REDACTION_PATTERNS) {
+        const matches = content.match(pattern);
+        if (matches && matches.length > 0) {
+            redactedContent = redactedContent.replace(pattern, (match, ...args) => {
+                // For patterns with capture groups, preserve the key name but redact the value
+                if (args.length >= 2) {
+                    const keyName = args[0];
+                    return `${keyName}=[REDACTED_${name}]`;
+                }
+                // For patterns without capture groups, redact the entire match
+                return `[REDACTED_${name}]`;
+            });
+            if (logRedactions) {
+                redactions.push({ pattern: name, count: matches.length });
+            }
+        }
+    }
+    // Log redactions if requested
+    if (logRedactions && redactions.length > 0) {
+        console.log(chalk_1.default.yellow('\n⚠️  Sensitive data redacted:'));
+        for (const { pattern, count } of redactions) {
+            console.log(chalk_1.default.gray(`   ${pattern}: ${count} occurrence(s)`));
+        }
+        console.log();
+    }
+    return redactedContent;
 }
 //# sourceMappingURL=show.js.map