repo-wrapped 0.0.6 → 0.0.9

package/dist/features/knowledge/analyzer.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeKnowledgeDistribution = analyzeKnowledgeDistribution;
+const child_process_1 = require("child_process");
+const emptyResults_1 = require("../../utils/emptyResults");
+/**
+ * Extract directory from file path
+ */
+function getDirectory(filePath) {
+    const parts = filePath.replace(/\\/g, '/').split('/');
+    if (parts.length <= 1)
+        return '/';
+    return parts.slice(0, -1).join('/');
+}
+/**
+ * Calculate bus factor risk score
+ * 1 owner = 10 (critical), 2+ = 1 (low/safe)
+ * Adjusted for realistic team dynamics where 2+ knowledgeable owners is considered safe
+ */
+function calculateRiskScore(significantOwners) {
+    if (significantOwners === 0)
+        return 10;
+    if (significantOwners === 1)
+        return 10;
+    return 1; // 2+ owners = low risk
+}
+/**
+ * Determine ownership type based on contribution percentages
+ */
+function determineOwnershipType(owners) {
+    if (owners.length === 0)
+        return 'solo';
+    const topOwnerPercentage = owners[0]?.percentage || 0;
+    if (topOwnerPercentage >= 100)
+        return 'solo';
+    if (topOwnerPercentage >= 70)
+        return 'primary';
+    if (topOwnerPercentage >= 40)
+        return 'shared';
+    return 'collaborative';
+}
+/**
+ * Get risk level from score
+ */
+function getRiskLevel(score) {
+    if (score >= 9)
+        return 'critical';
+    if (score >= 6)
+        return 'high';
+    if (score >= 3)
+        return 'medium';
+    return 'low';
+}
+/**
+ * Calculate knowledge age in human-readable format
+ */
+function calculateKnowledgeAge(lastActive) {
+    const now = new Date();
+    const diffMs = now.getTime() - lastActive.getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays < 7)
+        return `${diffDays}d`;
+    if (diffDays < 30)
+        return `${Math.floor(diffDays / 7)}w`;
+    if (diffDays < 365)
+        return `${Math.floor(diffDays / 30)}mo`;
+    return `${Math.floor(diffDays / 365)}y`;
+}
+/**
+ * Determine if an area is high risk
+ * High risk = bus factor 1 OR (bus factor ≤ 2 AND knowledge age > 3 months)
+ */
+function isHighRisk(busFactorRisk, lastActive) {
+    const daysSinceActive = Math.floor((Date.now() - lastActive.getTime()) / (1000 * 60 * 60 * 24));
+    const threeMonths = 90;
+    if (busFactorRisk >= 10)
+        return true; // Bus factor 1
+    if (busFactorRisk >= 7 && daysSinceActive > threeMonths)
+        return true; // Bus factor 2 + stale
+    return false;
+}
+/**
+ * Parse git log with file names for deep analysis
+ */
+function parseGitLogWithFiles(repoPath) {
+    const fileStats = new Map();
+    try {
+        // Get git log with files: format is "hash|author|date" followed by file names
+        const gitLog = (0, child_process_1.execSync)('git log --name-only --pretty=format:"%H|%an|%ad" --date=iso', { cwd: repoPath, encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 });
+        const lines = gitLog.split('\n');
+        let currentAuthor = '';
+        let currentDate = new Date();
+        for (const line of lines) {
+            if (line.includes('|')) {
+                // This is a commit header line
+                const parts = line.split('|');
+                currentAuthor = parts[1]?.trim() || 'Unknown';
+                currentDate = new Date(parts[2]?.trim() || Date.now());
+            }
+            else if (line.trim()) {
+                // This is a file path
+                const filePath = line.trim().replace(/\\/g, '/');
+                // Skip common non-code files
+                if (filePath.includes('node_modules/') ||
+                    filePath.includes('.git/') ||
+                    filePath.endsWith('.lock') ||
+                    filePath.endsWith('.log')) {
+                    continue;
+                }
+                if (!fileStats.has(filePath)) {
+                    fileStats.set(filePath, { authors: new Map() });
+                }
+                const fileData = fileStats.get(filePath);
+                const authorData = fileData.authors.get(currentAuthor) || { commits: 0, lastActive: currentDate };
+                fileData.authors.set(currentAuthor, {
+                    commits: authorData.commits + 1,
+                    lastActive: currentDate > authorData.lastActive ? currentDate : authorData.lastActive
+                });
+            }
+        }
+    }
+    catch (error) {
+        // Silent fail - return empty map if git log fails
+    }
+    return fileStats;
+}
+/**
+ * Build file ownership data for a directory
+ */
+function buildFileOwnership(fileStats, directoryPath) {
+    const files = [];
+    fileStats.forEach((data, filePath) => {
+        const dir = getDirectory(filePath);
+        if (dir !== directoryPath && !filePath.startsWith(directoryPath + '/')) {
+            return;
+        }
+        const totalCommits = Array.from(data.authors.values()).reduce((sum, a) => sum + a.commits, 0);
+        let primaryOwner = 'Unknown';
+        let maxCommits = 0;
+        let lastModified = new Date(0);
+        data.authors.forEach((authorData, author) => {
+            if (authorData.commits > maxCommits) {
+                maxCommits = authorData.commits;
+                primaryOwner = author;
+            }
+            if (authorData.lastActive > lastModified) {
+                lastModified = authorData.lastActive;
+            }
+        });
+        const ownershipPercentage = Math.round((maxCommits / totalCommits) * 100);
+        const knowledgeAge = calculateKnowledgeAge(lastModified);
+        const significantOwners = Array.from(data.authors.values()).filter(a => (a.commits / totalCommits) >= 0.65).length;
+        const busFactorRiskScore = calculateRiskScore(significantOwners);
+        const riskLevel = getRiskLevel(busFactorRiskScore);
+        files.push({
+            path: filePath,
+            primaryOwner,
+            ownershipPercentage,
+            lastModified,
+            knowledgeAge,
+            riskLevel,
+            busFactorRisk: busFactorRiskScore >= 7
+        });
+    });
+    // Sort by risk (high risk first), then by ownership percentage (high percentage = more concentrated = more risk)
+    return files
+        .filter(f => f.path.startsWith(directoryPath + '/') || getDirectory(f.path) === directoryPath)
+        .sort((a, b) => {
+        if (a.busFactorRisk !== b.busFactorRisk)
+            return a.busFactorRisk ? -1 : 1;
+        return b.ownershipPercentage - a.ownershipPercentage;
+    })
+        .slice(0, 20); // Limit to 20 files per directory
+}
+/**
+ * Analyzes knowledge distribution across the codebase to identify bus factor risks.
+ *
+ * Identifies:
+ * - Directory ownership patterns (solo, primary, shared, collaborative)
+ * - Bus factor risks (areas with single knowledge holders)
+ * - Knowledge silos (directories owned by one person)
+ * - Shared knowledge areas (directories with 3+ active contributors)
+ *
+ * @param commits - Array of commit data to analyze
+ * @param repoPath - Optional repository path for deep file-level analysis via git log
+ * @param deepAnalysis - Whether to perform file-level analysis (slower but more accurate)
+ * @returns Knowledge distribution with ownership data, risks, and recommendations
+ *
+ * @example
+ * ```typescript
+ * const knowledge = analyzeKnowledgeDistribution(commits, '/path/to/repo', true);
+ * console.log(`Bus factor risk: ${knowledge.busFactorRisk.level}`);
+ * console.log(`Knowledge silos: ${knowledge.knowledgeSilos.length}`);
+ * ```
+ */
+function analyzeKnowledgeDistribution(commits, repoPath, deepAnalysis = false) {
+    if (commits.length === 0) {
+        return (0, emptyResults_1.getEmptyKnowledgeDistribution)();
+    }
+    // For deep analysis, parse git log with file names
+    let fileStats = null;
+    if (deepAnalysis && repoPath) {
+        fileStats = parseGitLogWithFiles(repoPath);
+    }
+    // Build directory → author → commits mapping
+    const directoryStats = new Map();
+    if (fileStats && fileStats.size > 0) {
+        // Use actual file data for directory stats
+        fileStats.forEach((data, filePath) => {
+            const dir = getDirectory(filePath);
+            if (!directoryStats.has(dir)) {
+                directoryStats.set(dir, new Map());
+            }
+            const dirAuthors = directoryStats.get(dir);
+            data.authors.forEach((authorData, author) => {
+                const existing = dirAuthors.get(author) || { commits: 0, lastActive: authorData.lastActive };
+                dirAuthors.set(author, {
+                    commits: existing.commits + authorData.commits,
+                    lastActive: authorData.lastActive > existing.lastActive ? authorData.lastActive : existing.lastActive
+                });
+            });
+        });
+    }
+    else {
+        // Fallback: use heuristics based on commit messages
+        commits.forEach(commit => {
+            const author = commit.author;
+            const commitDate = new Date(commit.date);
+            const directories = new Set();
+            // Try to extract directories from commit message (simplified)
+            const pathMatch = commit.message.match(/(?:in|for|to)\s+([a-zA-Z0-9_\-./]+)/g);
+            if (pathMatch) {
+                pathMatch.forEach(match => {
+                    const path = match.replace(/^(?:in|for|to)\s+/, '');
+                    if (path.includes('/')) {
+                        directories.add(getDirectory(path));
+                    }
+                });
+            }
+            // Default directory based on commit type
+            if (directories.size === 0) {
+                const type = commit.message.match(/^(feat|fix|docs|test|refactor)/i)?.[1]?.toLowerCase();
+                switch (type) {
+                    case 'feat':
+                    case 'fix':
+                    case 'refactor':
+                        directories.add('src');
+                        break;
+                    case 'docs':
+                        directories.add('docs');
+                        break;
+                    case 'test':
+                        directories.add('test');
+                        break;
+                    default:
+                        directories.add('src');
+                }
+            }
+            directories.forEach(dir => {
+                if (!directoryStats.has(dir)) {
+                    directoryStats.set(dir, new Map());
+                }
+                const dirAuthors = directoryStats.get(dir);
+                const existing = dirAuthors.get(author) || { commits: 0, lastActive: commitDate };
+                dirAuthors.set(author, {
+                    commits: existing.commits + 1,
+                    lastActive: commitDate > existing.lastActive ? commitDate : existing.lastActive
+                });
+            });
+        });
+    }
+    // Build directory ownership array
+    const directories = [];
+    const knowledgeSilos = [];
+    const sharedKnowledge = [];
+    const criticalPaths = [];
+    let totalRiskScore = 0;
+    let dirCount = 0;
+    directoryStats.forEach((authorStats, dirPath) => {
+        const totalCommits = Array.from(authorStats.values()).reduce((sum, a) => sum + a.commits, 0);
+        // Skip areas with too few commits - not enough data to assess bus factor
+        const MIN_COMMITS_FOR_ASSESSMENT = 20;
+        if (totalCommits < MIN_COMMITS_FOR_ASSESSMENT) {
+            return; // Skip this directory
+        }
+        // Get the latest and earliest activity date for the directory
+        let latestActivity = new Date(0);
+        let earliestActivity = new Date();
+        authorStats.forEach(stats => {
+            if (stats.lastActive > latestActivity) {
+                latestActivity = stats.lastActive;
+            }
+            if (stats.lastActive < earliestActivity) {
+                earliestActivity = stats.lastActive;
+            }
+        });
+        // Calculate directory age in days
+        const dirAgeInDays = Math.floor((Date.now() - earliestActivity.getTime()) / (1000 * 60 * 60 * 24));
+        const MIN_AGE_FOR_SILO = 14; // Don't flag new directories as silos
+        const owners = Array.from(authorStats.entries())
+            .map(([author, stats]) => ({
+            author,
+            commits: stats.commits,
+            percentage: Math.round((stats.commits / totalCommits) * 100),
+            lastActive: stats.lastActive,
+            knowledgeAge: calculateKnowledgeAge(stats.lastActive)
+        }))
+            .sort((a, b) => b.commits - a.commits);
+        // Calculate significant owners (>= 65% contribution)
+        const significantOwners = owners.filter(o => o.percentage >= 65).length;
+        const busFactorRisk = calculateRiskScore(significantOwners);
+        const ownershipType = determineOwnershipType(owners);
+        // Build high-risk files list if deep analysis is enabled
+        let highRiskFiles;
+        if (deepAnalysis && fileStats && isHighRisk(busFactorRisk, latestActivity)) {
+            highRiskFiles = buildFileOwnership(fileStats, dirPath);
+        }
+        directories.push({
+            path: dirPath,
+            totalCommits,
+            owners,
+            ownershipType,
+            busFactorRisk,
+            highRiskFiles
+        });
+        // Track silos and shared knowledge (only if directory is old enough)
+        if (ownershipType === 'solo' && dirAgeInDays >= MIN_AGE_FOR_SILO) {
+            knowledgeSilos.push(`${dirPath} — ${owners[0]?.author || 'Unknown'} (100%)`);
+            criticalPaths.push(dirPath);
+        }
+        else if (ownershipType === 'collaborative' || significantOwners >= 3) {
+            sharedKnowledge.push(dirPath);
+        }
+        totalRiskScore += busFactorRisk;
+        dirCount++;
+    });
+    // Calculate overall bus factor risk
+    const overallRisk = dirCount > 0 ? Math.round(totalRiskScore / dirCount) : 0;
+    // Generate recommendations
+    const recommendations = generateRecommendations({
+        knowledgeSilos,
+        sharedKnowledge,
+        directories,
+        overallRisk
+    });
+    return {
+        directories: directories.sort((a, b) => b.busFactorRisk - a.busFactorRisk).slice(0, 15),
+        busFactorRisk: {
+            overall: overallRisk,
+            level: getRiskLevel(overallRisk),
+            criticalPaths
+        },
+        knowledgeSilos: knowledgeSilos.slice(0, 10),
+        sharedKnowledge: sharedKnowledge.slice(0, 10),
+        recommendations,
+        isDeepAnalysis: deepAnalysis
+    };
+}
+/**
+ * Generate recommendations based on knowledge distribution
+ */
+function generateRecommendations(data) {
+    const recommendations = [];
+    if (data.knowledgeSilos.length > 0) {
+        recommendations.push(`Consider cross-training on ${data.knowledgeSilos.length} knowledge silo(s) to reduce bus factor risk`);
+    }
+    if (data.overallRisk >= 7) {
+        recommendations.push('High bus factor risk detected — prioritize knowledge sharing sessions');
+    }
+    const soloDirectories = data.directories.filter(d => d.ownershipType === 'solo');
+    if (soloDirectories.length > 3) {
+        recommendations.push(`${soloDirectories.length} directories have single owners — pair programming recommended`);
+    }
+    if (data.sharedKnowledge.length > 0) {
+        recommendations.push(`Good knowledge distribution in ${data.sharedKnowledge.length} area(s) — maintain this pattern`);
+    }
+    const inactiveOwners = data.directories.flatMap(d => d.owners.filter(o => {
+        const daysSinceActive = Math.floor((Date.now() - o.lastActive.getTime()) / (1000 * 60 * 60 * 24));
+        return daysSinceActive > 60 && o.percentage > 30;
+    }));
+    if (inactiveOwners.length > 0) {
+        recommendations.push('Some significant contributors have been inactive — ensure knowledge transfer');
+    }
+    return recommendations.slice(0, 5);
+}

package/dist/features/knowledge/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildKnowledgeSection = exports.analyzeKnowledgeDistribution = void 0;
+/**
+ * Knowledge Distribution Feature
+ * @module features/knowledge
+ */
+__exportStar(require("./types"), exports);
+var analyzer_1 = require("./analyzer");
+Object.defineProperty(exports, "analyzeKnowledgeDistribution", { enumerable: true, get: function () { return analyzer_1.analyzeKnowledgeDistribution; } });
+var template_1 = require("./template");
+Object.defineProperty(exports, "buildKnowledgeSection", { enumerable: true, get: function () { return template_1.buildKnowledgeSection; } });

package/dist/features/knowledge/template.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildKnowledgeSection = buildKnowledgeSection;
+/**
+ * Build the Knowledge Distribution section for the dashboard
+ */
+function buildKnowledgeSection(knowledge) {
+    const riskClass = `risk-${knowledge.busFactorRisk.level}`;
+    const isDeepAnalysis = knowledge.isDeepAnalysis || false;
+    return `
+    <div class="knowledge-section">
+      <h2>Knowledge Distribution ${isDeepAnalysis ? '<span class="deep-analysis-badge">Deep Analysis</span>' : ''}</h2>
+      
+      <div class="bus-factor-summary">
+        <div class="risk-indicator ${riskClass}">
+          <span class="risk-value">${knowledge.busFactorRisk.overall}</span>
+          <span class="risk-scale">/10</span>
+        </div>
+        <div class="risk-meta">
+          <span class="risk-label">Bus Factor Risk</span>
+          <span class="risk-level">${formatRiskLevel(knowledge.busFactorRisk.level)}</span>
+        </div>
+      </div>
+      
+      ${knowledge.directories.length > 0 ? `
+        <div class="ownership-table">
+          <h3>Directory Ownership</h3>
+          <table class="data-table knowledge-table">
+            <thead>
+              <tr>
+                <th ${isDeepAnalysis ? 'class="expandable-header"' : ''}>Directory</th>
+                <th>Primary Owner</th>
+                <th>Ownership</th>
+                <th>Last Activity</th>
+                <th>Type</th>
+                <th>Risk</th>
+              </tr>
+            </thead>
+            <tbody>
+              ${knowledge.directories.slice(0, 10).map((dir, idx) => buildDirectoryRow(dir, idx, isDeepAnalysis)).join('')}
+            </tbody>
+          </table>
+        </div>
+      ` : ''}
+      
+      ${knowledge.knowledgeSilos.length > 0 ? `
+        <div class="knowledge-warnings">
+          <h3>Knowledge Silos</h3>
+          <p class="warning-intro">These directories have single owners — consider cross-training:</p>
+          <ul class="silo-list">
+            ${knowledge.knowledgeSilos.map(silo => `<li>${silo}</li>`).join('')}
+          </ul>
+        </div>
+      ` : ''}
+      
+      ${knowledge.sharedKnowledge.length > 0 ? `
+        <div class="shared-knowledge">
+          <h3>Well-Distributed Knowledge</h3>
+          <p class="success-intro">These areas have good knowledge sharing:</p>
+          <ul class="shared-list">
+            ${knowledge.sharedKnowledge.map(area => `<li>${area}</li>`).join('')}
+          </ul>
+        </div>
+      ` : ''}
+      
+      ${knowledge.recommendations.length > 0 ? `
+        <div class="recommendations">
+          <h3>Recommendations</h3>
+          <ul>
+            ${knowledge.recommendations.map(rec => `<li>${rec}</li>`).join('')}
+          </ul>
+        </div>
+      ` : ''}
+    </div>
+  `;
+}
+/**
+ * Build a directory row with optional expandable details
+ */
+function buildDirectoryRow(dir, index, isDeepAnalysis) {
+    const hasExpandableContent = isDeepAnalysis && dir.highRiskFiles && dir.highRiskFiles.length > 0;
+    const knowledgeAge = dir.owners[0]?.knowledgeAge || '—';
+    const rowId = `knowledge-row-${index}`;
+    // Main directory row
+    const mainRow = `
+    <tr class="${hasExpandableContent ? 'expandable-row' : ''}" ${hasExpandableContent ? `data-row-id="${rowId}" role="button" aria-expanded="false"` : ''}>
+      <td class="dir-path">
+        ${hasExpandableContent ? '<span class="expand-icon">▶</span>' : ''}
+        ${dir.path || '/'}
+      </td>
+      <td>${dir.owners[0]?.author || 'Unknown'}</td>
+      <td>
+        <div class="ownership-bar-mini">
+          <div class="ownership-fill" style="width: ${dir.owners[0]?.percentage || 0}%"></div>
+        </div>
+        <span class="ownership-percent">${dir.owners[0]?.percentage || 0}%</span>
+      </td>
+      <td class="last-activity">${knowledgeAge}</td>
+      <td><span class="ownership-type type-${dir.ownershipType}">${formatOwnershipType(dir.ownershipType)}</span></td>
+      <td><span class="risk-badge risk-${getRiskClass(dir.busFactorRisk)}">${dir.busFactorRisk}</span></td>
+    </tr>
+  `;
+    // Expandable details row (contributor breakdown + file list)
+    if (hasExpandableContent) {
+        const detailsRow = `
+      <tr class="expanded-content hidden" id="${rowId}-content">
+        <td colspan="6">
+          <div class="expansion-panel">
+            ${buildContributorBreakdown(dir)}
+            ${buildFileList(dir.highRiskFiles)}
+          </div>
+        </td>
+      </tr>
+    `;
+        return mainRow + detailsRow;
+    }
+    return mainRow;
+}
+/**
+ * Build contributor breakdown for expanded row
+ */
+function buildContributorBreakdown(dir) {
+    if (!dir.owners || dir.owners.length === 0)
+        return '';
+    return `
+    <div class="contributor-breakdown">
+      <h4>Contributors</h4>
+      <div class="contributors-list">
+        ${dir.owners.slice(0, 5).map(owner => `
+          <div class="contributor-item">
+            <span class="contributor-name">${owner.author}</span>
+            <div class="contributor-stats">
+              <span class="contributor-commits">${owner.commits} commits</span>
+              <span class="contributor-percent">${owner.percentage}%</span>
+              <span class="contributor-age" title="Knowledge age">${owner.knowledgeAge || '—'}</span>
+            </div>
+            <div class="contributor-bar">
+              <div class="contributor-fill" style="width: ${owner.percentage}%"></div>
+            </div>
+          </div>
+        `).join('')}
+      </div>
+    </div>
+  `;
+}
+/**
+ * Build file list for expanded row (high-risk files only)
+ */
+function buildFileList(files) {
+    if (!files || files.length === 0)
+        return '';
+    const visibleCount = 10;
+    const hasMore = files.length > visibleCount;
+    const uniqueId = `files-${Math.random().toString(36).substr(2, 9)}`;
+    return `
+    <div class="file-breakdown">
+      <h4>High-Risk Files</h4>
+      <table class="file-table">
+        <thead>
+          <tr>
+            <th>File</th>
+            <th>Primary Owner</th>
+            <th>Ownership</th>
+            <th>Last Modified</th>
+            <th>Risk</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${files.slice(0, visibleCount).map(file => `
+            <tr class="${file.busFactorRisk ? 'high-risk-file' : ''}">
+              <td class="file-path" title="${file.path}">${getFileName(file.path)}</td>
+              <td class="file-owner">${file.primaryOwner}</td>
+              <td>
+                <span class="file-ownership">${file.ownershipPercentage}%</span>
+              </td>
+              <td class="file-age">${file.knowledgeAge}</td>
+              <td><span class="risk-badge risk-${file.riskLevel}">${file.riskLevel}</span></td>
+            </tr>
+          `).join('')}
+          ${hasMore ? files.slice(visibleCount).map(file => `
+            <tr class="${file.busFactorRisk ? 'high-risk-file' : ''} hidden-file" data-group="${uniqueId}" style="display: none;">
+              <td class="file-path" title="${file.path}">${getFileName(file.path)}</td>
+              <td class="file-owner">${file.primaryOwner}</td>
+              <td>
+                <span class="file-ownership">${file.ownershipPercentage}%</span>
+              </td>
+              <td class="file-age">${file.knowledgeAge}</td>
+              <td><span class="risk-badge risk-${file.riskLevel}">${file.riskLevel}</span></td>
+            </tr>
+          `).join('') : ''}
+        </tbody>
+      </table>
+      ${hasMore ? `<button class="more-files-btn" data-target="${uniqueId}" data-count="${files.length - visibleCount}" onclick="toggleMoreFiles(this)">+ ${files.length - visibleCount} more files</button>` : ''}
+    </div>
+  `;
+}
+/**
+ * Get just the filename from a path
+ */
+function getFileName(path) {
+    const parts = path.replace(/\\/g, '/').split('/');
+    return parts[parts.length - 1] || path;
+}
+/**
+ * Format risk level for display
+ */
+function formatRiskLevel(level) {
+    const labels = {
+        critical: 'Critical',
+        high: 'High Risk',
+        medium: 'Moderate',
+        low: 'Low Risk'
+    };
+    return labels[level] || level;
+}
+/**
+ * Format ownership type for display
+ */
+function formatOwnershipType(type) {
+    const labels = {
+        solo: 'Solo',
+        primary: 'Primary',
+        shared: 'Shared',
+        collaborative: 'Team'
+    };
+    return labels[type] || type;
+}
+/**
+ * Get risk class based on numeric value
+ */
+function getRiskClass(risk) {
+    if (risk >= 9)
+        return 'critical';
+    if (risk >= 6)
+        return 'high';
+    if (risk >= 3)
+        return 'medium';
+    return 'low';
+}

package/dist/features/knowledge/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });