vibe-fabric 0.1.0

package/dist/core/doctor/sync.js

@@ -0,0 +1,146 @@
+/**
+ * Sync status health checks
+ * Validates sync data freshness
+ */
+import { existsSync, statSync } from 'fs';
+import { readdir } from 'fs/promises';
+import path from 'path';
+import { findProjectRoot } from '../project.js';
+/**
+ * Default stale threshold in minutes
+ */
+const STALE_THRESHOLD_MINUTES = 30;
+/**
+ * Get last sync time from sync-cache directory
+ */
+async function getLastSyncTime(projectRoot) {
+    const syncCachePath = path.join(projectRoot, 'docs/sync-cache');
+    if (!existsSync(syncCachePath)) {
+        return null;
+    }
+    try {
+        const entries = await readdir(syncCachePath, { withFileTypes: true });
+        let latestTime = null;
+        for (const entry of entries) {
+            const entryPath = path.join(syncCachePath, entry.name);
+            const stats = statSync(entryPath);
+            const mtime = stats.mtime;
+            if (!latestTime || mtime > latestTime) {
+                latestTime = mtime;
+            }
+        }
+        return latestTime;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Format time difference as human-readable string
+ */
+function formatTimeDiff(minutes) {
+    if (minutes < 1) {
+        return 'just now';
+    }
+    if (minutes < 60) {
+        return `${Math.floor(minutes)} minute${Math.floor(minutes) === 1 ? '' : 's'} ago`;
+    }
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24) {
+        return `${hours} hour${hours === 1 ? '' : 's'} ago`;
+    }
+    const days = Math.floor(hours / 24);
+    return `${days} day${days === 1 ? '' : 's'} ago`;
+}
+/**
+ * Sync cache exists check
+ */
+export const syncCacheExistsCheck = {
+    name: 'Sync cache exists',
+    category: 'sync',
+    critical: false,
+    run: async () => {
+        const cwd = process.cwd();
+        const projectRoot = findProjectRoot(cwd);
+        if (!projectRoot) {
+            return {
+                name: 'Sync cache exists',
+                category: 'sync',
+                status: 'warning',
+                details: 'No project found',
+            };
+        }
+        const syncCachePath = path.join(projectRoot, 'docs/sync-cache');
+        if (existsSync(syncCachePath)) {
+            return {
+                name: 'Sync cache exists',
+                category: 'sync',
+                status: 'passed',
+                details: 'docs/sync-cache directory exists',
+            };
+        }
+        return {
+            name: 'Sync cache exists',
+            category: 'sync',
+            status: 'warning',
+            details: 'docs/sync-cache not found',
+            fix: 'Run `vibe sync` to create sync cache',
+        };
+    },
+};
+/**
+ * Sync data freshness check
+ */
+export const syncDataFreshCheck = {
+    name: 'Sync data fresh',
+    category: 'sync',
+    critical: false,
+    run: async () => {
+        const cwd = process.cwd();
+        const projectRoot = findProjectRoot(cwd);
+        if (!projectRoot) {
+            return {
+                name: 'Sync data fresh',
+                category: 'sync',
+                status: 'warning',
+                details: 'No project found',
+            };
+        }
+        const lastSync = await getLastSyncTime(projectRoot);
+        if (!lastSync) {
+            return {
+                name: 'Sync data fresh',
+                category: 'sync',
+                status: 'warning',
+                details: 'No sync data found',
+                fix: 'Run `vibe sync` to sync data from repositories',
+                fixable: true,
+            };
+        }
+        const ageMinutes = (Date.now() - lastSync.getTime()) / 1000 / 60;
+        if (ageMinutes < STALE_THRESHOLD_MINUTES) {
+            return {
+                name: 'Sync data fresh',
+                category: 'sync',
+                status: 'passed',
+                details: `Last synced ${formatTimeDiff(ageMinutes)}`,
+            };
+        }
+        return {
+            name: 'Sync data fresh',
+            category: 'sync',
+            status: 'warning',
+            details: `Data is ${formatTimeDiff(ageMinutes)} old (stale after ${STALE_THRESHOLD_MINUTES}min)`,
+            fix: 'Run `vibe sync` to refresh data',
+            fixable: true,
+        };
+    },
+};
+/**
+ * All sync checks
+ */
+export const syncChecks = [
+    syncCacheExistsCheck,
+    syncDataFreshCheck,
+];
+//# sourceMappingURL=sync.js.map

package/dist/core/doctor/sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.js","sourceRoot":"","sources":["../../../src/core/doctor/sync.ts"],"names":[],"mappings":"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"}

package/dist/core/gaps.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Core gaps module - gap analysis between PRD and implementation
+ *
+ * Identifies missing implementations, partial implementations,
+ * and orphaned implementations using cached data only.
+ */
+import { Gap, GapPriority, MissingGap, PartialGap, OrphanedGap, GapSummary, SuggestedScope, GapAnalysisData, GapsJsonOutput, GapFilterOptions } from '../types/gaps.js';
+/**
+ * Parsed requirement from PRD
+ */
+interface ParsedRequirement {
+    id: string;
+    title: string;
+    module: string;
+    priority: string;
+    tags: string[];
+    description: string;
+}
+/**
+ * Parse requirement files from PRD modules
+ */
+export declare function parseRequirements(projectPath: string): Promise<ParsedRequirement[]>;
+/**
+ * Assign gap priority based on tags and conditions
+ */
+export declare function assignGapPriority(tags: string[], hasBlocker: boolean, originalPriority: string): GapPriority;
+/**
+ * Find requirements without linked scopes (missing implementations)
+ */
+export declare function findMissingImplementations(projectPath: string): Promise<MissingGap[]>;
+/**
+ * Find scopes that are in progress but not completed (partial implementations)
+ */
+export declare function findPartialImplementations(projectPath: string): Promise<PartialGap[]>;
+/**
+ * Find orphaned implementations from sync cache
+ * Note: This is a simplified implementation that looks for
+ * implementation plans not linked to PRD requirements
+ */
+export declare function findOrphanedImplementations(projectPath: string): Promise<OrphanedGap[]>;
+/**
+ * Calculate gap summary from gap lists
+ */
+export declare function calculateSummary(missing: MissingGap[], partial: PartialGap[], orphaned: OrphanedGap[]): GapSummary;
+/**
+ * Generate scope suggestions from missing gaps
+ */
+export declare function generateSuggestions(gaps: MissingGap[]): SuggestedScope[];
+/**
+ * Apply filters to gaps
+ */
+export declare function filterGaps<T extends Gap>(gaps: T[], options: GapFilterOptions): T[];
+/**
+ * Perform complete gap analysis
+ */
+export declare function analyzeGaps(projectPath: string, options?: GapFilterOptions): Promise<GapAnalysisData>;
+/**
+ * Get list of available module names
+ */
+export declare function getModuleNames(projectPath: string): Promise<string[]>;
+/**
+ * Convert gap analysis data to JSON output format
+ */
+export declare function toGapsJsonOutput(data: GapAnalysisData): GapsJsonOutput;
+/**
+ * Check if there are any P1 gaps (for CI mode)
+ */
+export declare function hasP1Gaps(data: GapAnalysisData): boolean;
+export {};
+//# sourceMappingURL=gaps.d.ts.map

package/dist/core/gaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaps.d.ts","sourceRoot":"","sources":["../../src/core/gaps.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EACL,GAAG,EACH,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,UAAU,EAGV,cAAc,EACd,eAAe,EACf,cAAc,EACd,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAc1B;;GAEG;AACH,UAAU,iBAAiB;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAmEzF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EAAE,EACd,UAAU,EAAE,OAAO,EACnB,gBAAgB,EAAE,MAAM,GACvB,WAAW,CAkBb;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,EAAE,CAAC,CA6BvB;AAoDD;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,EAAE,CAAC,CA6BvB;AAED;;;;GAIG;AACH,wBAAsB,2BAA2B,CAC/C,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,WAAW,EAAE,CAAC,CAwExB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,UAAU,EAAE,EACrB,OAAO,EAAE,UAAU,EAAE,EACrB,QAAQ,EAAE,WAAW,EAAE,GACtB,UAAU,CAuBZ;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,cAAc,EAAE,CAqExE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,GAAG,EACtC,IAAI,EAAE,CAAC,EAAE,EACT,OAAO,EAAE,gBAAgB,GACxB,CAAC,EAAE,CAqBL;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CAkC1B;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAa3E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,cAAc,CAmBtE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAExD"}

package/dist/core/gaps.js

@@ -0,0 +1,448 @@
+/**
+ * Core gaps module - gap analysis between PRD and implementation
+ *
+ * Identifies missing implementations, partial implementations,
+ * and orphaned implementations using cached data only.
+ */
+import { readFile, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import { loadScopes } from './coverage.js';
+/**
+ * Priority tags that indicate P1 (security/compliance)
+ */
+const P1_TAGS = ['security', 'compliance', 'critical', 'blocking'];
+/**
+ * Priority tags that indicate P2 (core functionality)
+ */
+const P2_TAGS = ['core', 'essential', 'important'];
+/**
+ * Parse requirement files from PRD modules
+ */
+export async function parseRequirements(projectPath) {
+    const requirements = [];
+    const modulesDir = path.join(projectPath, 'docs', 'prd', 'modules');
+    try {
+        if (!existsSync(modulesDir)) {
+            return requirements;
+        }
+        const moduleDirs = await readdir(modulesDir);
+        for (const moduleDir of moduleDirs) {
+            const modulePath = path.join(modulesDir, moduleDir);
+            try {
+                const files = await readdir(modulePath);
+                for (const file of files) {
+                    if (!file.endsWith('.md') || file.startsWith('_'))
+                        continue;
+                    const filePath = path.join(modulePath, file);
+                    const content = await readFile(filePath, 'utf-8');
+                    // Check if this is a requirement file
+                    const idMatch = content.match(/\*\*ID\*\*\s*\|\s*`?(REQ-[A-Z]+-\d+)`?/);
+                    if (!idMatch || !idMatch[1])
+                        continue;
+                    const id = idMatch[1];
+                    // Extract title
+                    const titleMatch = content.match(/^#\s+(?:REQ:\s*)?(.+?)(?:\n|$)/m);
+                    const title = titleMatch?.[1] ?? id;
+                    // Extract priority
+                    const priorityMatch = content.match(/\*\*Priority\*\*\s*\|\s*`?(P[1234])`?/);
+                    const priority = priorityMatch?.[1] ?? 'P3';
+                    // Extract tags
+                    const tagsMatch = content.match(/\*\*Tags\*\*\s*\|\s*([^|\n]+)/);
+                    const tagsStr = tagsMatch?.[1]?.trim() ?? '';
+                    const tags = tagsStr
+                        .split(',')
+                        .map((t) => t.trim().toLowerCase())
+                        .filter(Boolean);
+                    // Extract description
+                    const descMatch = content.match(/## Description\s*\n\n([^\n]+)/);
+                    const description = descMatch?.[1] ?? '';
+                    requirements.push({
+                        id,
+                        title,
+                        module: moduleDir,
+                        priority,
+                        tags,
+                        description,
+                    });
+                }
+            }
+            catch {
+                // Can't read module directory
+            }
+        }
+    }
+    catch {
+        // Can't read modules directory
+    }
+    return requirements;
+}
+/**
+ * Assign gap priority based on tags and conditions
+ */
+export function assignGapPriority(tags, hasBlocker, originalPriority) {
+    // P1: Security/compliance tags or blocking status
+    if (tags.some((tag) => P1_TAGS.includes(tag)) || hasBlocker) {
+        return 'P1';
+    }
+    // P2: Core functionality tags or elevated from blocker
+    if (tags.some((tag) => P2_TAGS.includes(tag))) {
+        return 'P2';
+    }
+    // Use original priority from requirement if available
+    if (originalPriority === 'P1')
+        return 'P1';
+    if (originalPriority === 'P2')
+        return 'P2';
+    if (originalPriority === 'P3')
+        return 'P3';
+    // Default for orphaned
+    return 'P4';
+}
+/**
+ * Find requirements without linked scopes (missing implementations)
+ */
+export async function findMissingImplementations(projectPath) {
+    const requirements = await parseRequirements(projectPath);
+    const scopes = await loadScopes(projectPath);
+    const missing = [];
+    for (const req of requirements) {
+        // Check if any scope links to this requirement
+        const linkedScope = scopes.find((scope) => scope.requirements.includes(req.id));
+        if (!linkedScope) {
+            const priority = assignGapPriority(req.tags, false, req.priority);
+            missing.push({
+                type: 'missing',
+                priority,
+                requirementId: req.id,
+                title: req.title,
+                module: req.module,
+                impact: req.description.slice(0, 100) || 'No description available',
+                tags: req.tags,
+                suggestion: `Create a scope to implement ${req.id}`,
+            });
+        }
+    }
+    return missing;
+}
+/**
+ * Parse scope file for additional details (progress, blockers)
+ */
+async function parseScopeDetails(projectPath, scope) {
+    // Determine the directory based on status
+    const statusToDir = {
+        draft: 'drafts',
+        ready: 'ready',
+        sent: 'sent',
+        completed: 'completed',
+    };
+    const dir = statusToDir[scope.status] ?? 'drafts';
+    const scopesDir = path.join(projectPath, 'docs', 'scopes', dir);
+    // Find the scope file
+    try {
+        const files = await readdir(scopesDir);
+        const scopeFile = files.find((f) => f.startsWith(`${scope.id}-`) || f === `${scope.id}.md`);
+        if (!scopeFile) {
+            return { progress: 0, blocked: false };
+        }
+        const filePath = path.join(scopesDir, scopeFile);
+        const content = await readFile(filePath, 'utf-8');
+        // Extract progress (if available)
+        const progressMatch = content.match(/\*\*Progress\*\*\s*\|\s*`?(\d+)%?`?/);
+        const progress = progressMatch && progressMatch[1] ? parseInt(progressMatch[1], 10) : 0;
+        // Check for blockers
+        const blockerMatch = content.match(/\*\*Blocked\*\*\s*\|\s*`?([^|\n`]+)`?/);
+        const blockerValue = blockerMatch?.[1]?.trim();
+        const blocked = blockerValue !== undefined &&
+            blockerValue.toLowerCase() !== 'no' &&
+            blockerValue !== '-';
+        const blockerReason = blocked ? blockerValue : undefined;
+        return { progress, blocked, blockerReason };
+    }
+    catch {
+        return { progress: 0, blocked: false };
+    }
+}
+/**
+ * Find scopes that are in progress but not completed (partial implementations)
+ */
+export async function findPartialImplementations(projectPath) {
+    const scopes = await loadScopes(projectPath);
+    const partial = [];
+    for (const scope of scopes) {
+        // Only include sent or ready scopes (in progress but not completed)
+        if (scope.status !== 'sent' && scope.status !== 'ready') {
+            continue;
+        }
+        const details = await parseScopeDetails(projectPath, scope);
+        // A partial gap is a scope that's in progress with < 100% completion
+        const priority = assignGapPriority([], details.blocked, 'P3');
+        partial.push({
+            type: 'partial',
+            priority: details.blocked ? 'P2' : priority,
+            scopeId: scope.id,
+            title: scope.title,
+            status: scope.status,
+            progress: details.progress,
+            blocked: details.blocked,
+            blockerReason: details.blockerReason,
+            requirements: scope.requirements,
+        });
+    }
+    return partial;
+}
+/**
+ * Find orphaned implementations from sync cache
+ * Note: This is a simplified implementation that looks for
+ * implementation plans not linked to PRD requirements
+ */
+export async function findOrphanedImplementations(projectPath) {
+    const orphaned = [];
+    const syncCacheDir = path.join(projectPath, 'docs', 'sync-cache');
+    try {
+        if (!existsSync(syncCacheDir)) {
+            return orphaned;
+        }
+        // Load last sync data to get repository information
+        const lastSyncPath = path.join(syncCacheDir, 'last-sync.json');
+        if (!existsSync(lastSyncPath)) {
+            return orphaned;
+        }
+        const lastSyncContent = await readFile(lastSyncPath, 'utf-8');
+        const lastSync = JSON.parse(lastSyncContent);
+        // Load all requirements for checking links
+        const requirements = await parseRequirements(projectPath);
+        const reqIds = new Set(requirements.map((r) => r.id));
+        // Check each repository's impl-plans for orphaned implementations
+        for (const [repoAlias, _repoData] of Object.entries(lastSync.repos ?? {})) {
+            const repoDir = path.join(syncCacheDir, 'repos', repoAlias);
+            if (!existsSync(repoDir))
+                continue;
+            const implPlansDir = path.join(repoDir, 'impl-plans');
+            if (!existsSync(implPlansDir))
+                continue;
+            try {
+                const planFiles = await readdir(implPlansDir);
+                for (const planFile of planFiles) {
+                    if (!planFile.endsWith('.md'))
+                        continue;
+                    const planPath = path.join(implPlansDir, planFile);
+                    const content = await readFile(planPath, 'utf-8');
+                    // Extract requirement references from the plan
+                    const reqMatches = content.matchAll(/REQ-[A-Z]+-\d+/g);
+                    const linkedReqs = new Set([...reqMatches].map((m) => m[0]));
+                    // Check if all linked requirements exist
+                    const orphanedReqs = [...linkedReqs].filter((r) => !reqIds.has(r));
+                    if (orphanedReqs.length > 0 || linkedReqs.size === 0) {
+                        const titleMatch = content.match(/^#\s+(.+?)(?:\n|$)/m);
+                        const identifier = titleMatch?.[1] ?? planFile.replace('.md', '');
+                        orphaned.push({
+                            type: 'orphaned',
+                            priority: 'P4',
+                            identifier,
+                            repository: repoAlias,
+                            files: [planFile],
+                            suggestedAction: linkedReqs.size === 0
+                                ? 'Link to PRD requirements or remove if obsolete'
+                                : `Update to use valid requirements (${orphanedReqs.join(', ')} not found)`,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Can't read impl-plans directory
+            }
+        }
+    }
+    catch {
+        // Can't read sync cache
+    }
+    return orphaned;
+}
+/**
+ * Calculate gap summary from gap lists
+ */
+export function calculateSummary(missing, partial, orphaned) {
+    const allGaps = [...missing, ...partial, ...orphaned];
+    const byPriority = {
+        P1: 0,
+        P2: 0,
+        P3: 0,
+        P4: 0,
+        total: allGaps.length,
+    };
+    const byType = {
+        missing: missing.length,
+        partial: partial.length,
+        orphaned: orphaned.length,
+        total: allGaps.length,
+    };
+    for (const gap of allGaps) {
+        byPriority[gap.priority]++;
+    }
+    return { byPriority, byType };
+}
+/**
+ * Generate scope suggestions from missing gaps
+ */
+export function generateSuggestions(gaps) {
+    // Group gaps by module
+    const byModule = new Map();
+    for (const gap of gaps) {
+        const existing = byModule.get(gap.module) ?? [];
+        existing.push(gap);
+        byModule.set(gap.module, existing);
+    }
+    const suggestions = [];
+    for (const [module, moduleGaps] of byModule) {
+        // Further group by priority within module
+        const p1Gaps = moduleGaps.filter((g) => g.priority === 'P1');
+        const p2Gaps = moduleGaps.filter((g) => g.priority === 'P2');
+        const otherGaps = moduleGaps.filter((g) => g.priority !== 'P1' && g.priority !== 'P2');
+        // Create suggestions for P1 gaps (one per gap due to urgency)
+        for (const gap of p1Gaps) {
+            suggestions.push({
+                title: `Implement ${gap.requirementId}: ${gap.title}`,
+                priority: 'P1',
+                requirements: [gap.requirementId],
+                estimatedEffort: 'M',
+                module,
+            });
+        }
+        // Bundle P2 gaps by module (max 3 per scope)
+        if (p2Gaps.length > 0) {
+            for (let i = 0; i < p2Gaps.length; i += 3) {
+                const batch = p2Gaps.slice(i, i + 3);
+                const effort = batch.length >= 3 ? 'L' : batch.length >= 2 ? 'M' : 'S';
+                suggestions.push({
+                    title: `${module}: ${batch.map((g) => g.title).join(', ')}`,
+                    priority: 'P2',
+                    requirements: batch.map((g) => g.requirementId),
+                    estimatedEffort: effort,
+                    module,
+                });
+            }
+        }
+        // Bundle other gaps by module (max 5 per scope)
+        if (otherGaps.length > 0) {
+            for (let i = 0; i < otherGaps.length; i += 5) {
+                const batch = otherGaps.slice(i, i + 5);
+                const effort = batch.length >= 4 ? 'L' : batch.length >= 2 ? 'M' : 'S';
+                suggestions.push({
+                    title: `${module}: ${batch.map((g) => g.title).join(', ')}`,
+                    priority: 'P3',
+                    requirements: batch.map((g) => g.requirementId),
+                    estimatedEffort: effort,
+                    module,
+                });
+            }
+        }
+    }
+    // Sort by priority
+    suggestions.sort((a, b) => {
+        const order = { P1: 0, P2: 1, P3: 2, P4: 3 };
+        return order[a.priority] - order[b.priority];
+    });
+    return suggestions;
+}
+/**
+ * Apply filters to gaps
+ */
+export function filterGaps(gaps, options) {
+    let filtered = [...gaps];
+    if (options.priority) {
+        filtered = filtered.filter((g) => g.priority === options.priority);
+    }
+    if (options.type) {
+        filtered = filtered.filter((g) => g.type === options.type);
+    }
+    if (options.module) {
+        filtered = filtered.filter((g) => {
+            if (g.type === 'missing') {
+                return g.module.toLowerCase() === options.module.toLowerCase();
+            }
+            return true; // Other types don't have module field
+        });
+    }
+    return filtered;
+}
+/**
+ * Perform complete gap analysis
+ */
+export async function analyzeGaps(projectPath, options = {}) {
+    // Find all gaps
+    let missing = await findMissingImplementations(projectPath);
+    let partial = await findPartialImplementations(projectPath);
+    let orphaned = await findOrphanedImplementations(projectPath);
+    // Apply filters
+    if (options.priority || options.module) {
+        missing = filterGaps(missing, options);
+        partial = filterGaps(partial, options);
+        orphaned = filterGaps(orphaned, options);
+    }
+    if (options.type) {
+        if (options.type !== 'missing')
+            missing = [];
+        if (options.type !== 'partial')
+            partial = [];
+        if (options.type !== 'orphaned')
+            orphaned = [];
+    }
+    // Calculate summary
+    const summary = calculateSummary(missing, partial, orphaned);
+    // Generate suggestions from missing gaps
+    const suggestions = generateSuggestions(missing);
+    return {
+        summary,
+        gaps: {
+            missing,
+            partial,
+            orphaned,
+        },
+        suggestions,
+    };
+}
+/**
+ * Get list of available module names
+ */
+export async function getModuleNames(projectPath) {
+    const modulesDir = path.join(projectPath, 'docs', 'prd', 'modules');
+    try {
+        if (!existsSync(modulesDir)) {
+            return [];
+        }
+        const entries = await readdir(modulesDir, { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Convert gap analysis data to JSON output format
+ */
+export function toGapsJsonOutput(data) {
+    const allGaps = [
+        ...data.gaps.missing,
+        ...data.gaps.partial,
+        ...data.gaps.orphaned,
+    ];
+    // Sort by priority
+    allGaps.sort((a, b) => {
+        const order = { P1: 0, P2: 1, P3: 2, P4: 3 };
+        return order[a.priority] - order[b.priority];
+    });
+    return {
+        timestamp: new Date().toISOString(),
+        summary: data.summary,
+        gaps: allGaps,
+        suggestions: data.suggestions,
+    };
+}
+/**
+ * Check if there are any P1 gaps (for CI mode)
+ */
+export function hasP1Gaps(data) {
+    return data.summary.byPriority.P1 > 0;
+}
+//# sourceMappingURL=gaps.js.map