@wundam/orchex 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/intelligence/slicing-templates.js

@@ -1,420 +0,0 @@
-// ============================================================================
-// Template Definitions
-// ============================================================================
-/**
- * Template for documentation sets (guides, API docs, tutorials).
- */
-const DOCUMENTATION_SET_TEMPLATE = {
-    id: 'documentation-set',
-    name: 'Documentation Set',
-    description: 'Multiple documentation files (guides, tutorials, API references) that should be created independently',
-    keywords: ['docs', 'documentation', 'guide', 'tutorial', 'readme', 'api reference', 'multiple pages'],
-    patterns: [
-        'Multiple .md files in docs/',
-        'Creating 3+ documentation files',
-        'Tutorial series',
-        'API documentation pages',
-    ],
-    streamStructure: [
-        {
-            namePattern: 'docs-{topic}',
-            purpose: 'Create documentation for a specific topic',
-            dependsOn: [],
-            ownsPatterns: ['docs/{topic}/**/*.md'],
-            readsPatterns: ['src/**/*.ts', 'README.md'],
-            planOutline: 'Research implementation → Write documentation → Add examples → Review completeness',
-        },
-    ],
-    guidelines: [
-        'Split by logical topic, not file count',
-        'Each stream should own 1-3 related doc files',
-        'Order dependencies: concepts → API reference → tutorials → advanced guides',
-        'Streams can run in parallel if topics are independent',
-        'Keep related examples with their topic',
-    ],
-};
-/**
- * Template for code feature implementations.
- */
-const CODE_FEATURE_TEMPLATE = {
-    id: 'code-feature',
-    name: 'Code Feature Implementation',
-    description: 'Multi-component feature with types, implementation, tests, and documentation',
-    keywords: ['feature', 'implement', 'add', 'create', 'types', 'tests', 'integration'],
-    patterns: [
-        'Types → Implementation → Tests → Docs',
-        'Multiple source files with dependencies',
-        'Test files alongside implementation',
-        'Integration with existing code',
-    ],
-    streamStructure: [
-        {
-            namePattern: '{feature}-types',
-            purpose: 'Define interfaces, types, and schemas',
-            dependsOn: [],
-            ownsPatterns: ['src/types/{feature}.ts', 'src/schemas/{feature}.ts'],
-            readsPatterns: ['src/types.ts'],
-            planOutline: 'Analyze requirements → Define types → Add validation schemas → Export types',
-        },
-        {
-            namePattern: '{feature}-core',
-            purpose: 'Core feature implementation',
-            dependsOn: ['{feature}-types'],
-            ownsPatterns: ['src/{feature}/*.ts'],
-            readsPatterns: ['src/types/{feature}.ts', 'src/utils/*.ts'],
-            planOutline: 'Implement core logic → Add error handling → Integrate with existing systems',
-        },
-        {
-            namePattern: '{feature}-tests',
-            purpose: 'Unit and integration tests',
-            dependsOn: ['{feature}-core'],
-            ownsPatterns: ['tests/{feature}.test.ts'],
-            readsPatterns: ['src/{feature}/*.ts'],
-            planOutline: 'Write unit tests → Add integration tests → Test edge cases → Verify coverage',
-        },
-        {
-            namePattern: '{feature}-docs',
-            purpose: 'Documentation and examples',
-            dependsOn: ['{feature}-core'],
-            ownsPatterns: ['docs/{feature}/*.md'],
-            readsPatterns: ['src/{feature}/*.ts'],
-            planOutline: 'Document API → Add usage examples → Write integration guide',
-        },
-    ],
-    guidelines: [
-        'Always start with types to establish contracts',
-        'Core implementation depends on types being defined',
-        'Tests and docs can run in parallel after core is complete',
-        'Keep streams focused: one stream = one responsibility',
-        'If a file has 200+ lines, consider splitting implementation into multiple streams',
-    ],
-};
-/**
- * Template for data/code migrations.
- */
-const MIGRATION_TEMPLATE = {
-    id: 'migration',
-    name: 'Migration',
-    description: 'Migrating code, data, or structure with backward compatibility',
-    keywords: ['migration', 'migrate', 'refactor', 'rename', 'move', 'deprecate', 'backward compatible'],
-    patterns: [
-        'From old to new',
-        'Rename/move files or functions',
-        'Change data structure',
-        'Update multiple call sites',
-        'Maintain backward compatibility',
-    ],
-    streamStructure: [
-        {
-            namePattern: '{migration}-new-implementation',
-            purpose: 'Create new implementation alongside old one',
-            dependsOn: [],
-            ownsPatterns: ['src/{new}/*.ts'],
-            readsPatterns: ['src/{old}/*.ts'],
-            planOutline: 'Implement new version → Match old API → Add compatibility layer',
-        },
-        {
-            namePattern: '{migration}-migrate-{component}',
-            purpose: 'Migrate specific component to new implementation',
-            dependsOn: ['{migration}-new-implementation'],
-            ownsPatterns: ['src/{component}/**/*.ts'],
-            readsPatterns: ['src/{new}/*.ts', 'src/{old}/*.ts'],
-            planOutline: 'Update imports → Replace function calls → Update tests → Verify behavior',
-        },
-        {
-            namePattern: '{migration}-deprecate-old',
-            purpose: 'Mark old implementation as deprecated',
-            dependsOn: ['{migration}-migrate-*'],
-            ownsPatterns: ['src/{old}/*.ts'],
-            readsPatterns: [],
-            planOutline: 'Add deprecation notices → Update docs → Plan removal timeline',
-        },
-    ],
-    guidelines: [
-        'Create new before removing old',
-        'Migrate in small, independent chunks (by component/module)',
-        'Each migration stream should be independently testable',
-        'Keep deprecation as the final step',
-        'Ensure each stream leaves the codebase in a working state',
-    ],
-};
-/**
- * Template for tutorial/example creation.
- */
-const TUTORIAL_TEMPLATE = {
-    id: 'tutorial',
-    name: 'Tutorial Series',
-    description: 'Progressive tutorial series from basics to advanced',
-    keywords: ['tutorial', 'guide', 'example', 'walkthrough', 'getting started', 'beginner', 'advanced'],
-    patterns: [
-        'Multiple tutorial steps',
-        'Progressive complexity',
-        'Beginner → Intermediate → Advanced',
-        'Examples with documentation',
-    ],
-    streamStructure: [
-        {
-            namePattern: 'tutorial-{level}-{topic}',
-            purpose: 'Create tutorial for specific level and topic',
-            dependsOn: ['tutorial-{previous-level}-*'],
-            ownsPatterns: ['docs/tutorials/{level}-{topic}.md', 'examples/{topic}/**/*'],
-            readsPatterns: ['src/**/*.ts', 'docs/tutorials/{previous}*.md'],
-            planOutline: 'Define learning objectives → Write tutorial → Create working example → Add exercises',
-        },
-    ],
-    guidelines: [
-        'Order by prerequisite knowledge: basics → intermediate → advanced',
-        'Each tutorial should be self-contained but build on previous concepts',
-        'Include working code examples',
-        'Beginner tutorials can run in parallel if they cover different topics',
-        'Advanced tutorials depend on relevant beginner/intermediate tutorials',
-    ],
-};
-/**
- * Template for API reference documentation.
- */
-const API_REFERENCE_TEMPLATE = {
-    id: 'api-reference',
-    name: 'API Reference',
-    description: 'Comprehensive API documentation for modules, classes, and functions',
-    keywords: ['api', 'reference', 'documentation', 'modules', 'classes', 'functions', 'methods'],
-    patterns: [
-        'Documenting multiple modules',
-        'Class/function reference',
-        'Method documentation',
-        'Parameter and return type docs',
-    ],
-    streamStructure: [
-        {
-            namePattern: 'api-{module}-reference',
-            purpose: 'Create API reference for a specific module',
-            dependsOn: [],
-            ownsPatterns: ['docs/api/{module}.md'],
-            readsPatterns: ['src/{module}/**/*.ts'],
-            planOutline: 'Extract types/interfaces → Document functions → Add examples → Cross-link related APIs',
-        },
-    ],
-    guidelines: [
-        'Split by module or logical grouping',
-        'All API reference streams can run in parallel',
-        'Include type signatures and examples',
-        'Cross-reference related APIs',
-        'Keep each stream to 1-2 related modules',
-    ],
-};
-/**
- * All available templates.
- */
-const ALL_TEMPLATES = [
-    DOCUMENTATION_SET_TEMPLATE,
-    CODE_FEATURE_TEMPLATE,
-    MIGRATION_TEMPLATE,
-    TUTORIAL_TEMPLATE,
-    API_REFERENCE_TEMPLATE,
-];
-// ============================================================================
-// Template Matching
-// ============================================================================
-/**
- * Find the best matching template for a stream description.
- * Returns null if no good match is found.
- */
-export function findMatchingTemplate(description) {
-    const lowerDesc = description.toLowerCase();
-    let bestMatch = null;
-    for (const template of ALL_TEMPLATES) {
-        let score = 0;
-        // Check keyword matches
-        for (const keyword of template.keywords) {
-            if (lowerDesc.includes(keyword.toLowerCase())) {
-                score += 2;
-            }
-        }
-        // Check pattern matches (partial)
-        for (const pattern of template.patterns) {
-            // Split on whitespace and common punctuation (/, ,) to handle patterns like "Rename/move"
-            const patternWords = pattern
-                .toLowerCase()
-                .split(/[\s/,]+/)
-                .filter(word => word.length > 2); // Filter short words like "or", "to"
-            const matchedWords = patternWords.filter(word => lowerDesc.includes(word));
-            if (matchedWords.length >= patternWords.length / 2) {
-                score += 1;
-            }
-        }
-        // Update best match if this template scores higher
-        if (score > 0 && (!bestMatch || score > bestMatch.score)) {
-            bestMatch = { template, score };
-        }
-    }
-    // Return template if we have a reasonable match (score >= 3)
-    return bestMatch && bestMatch.score >= 3 ? bestMatch.template : null;
-}
-/**
- * Apply a template to generate stream definitions.
- * Returns suggested streams based on the template structure.
- */
-export function applyTemplate(template, context) {
-    const streams = [];
-    if (template.id === 'documentation-set') {
-        // Generate streams for each topic
-        const topics = context.topics || [];
-        for (const topic of topics) {
-            streams.push({
-                name: `docs-${topic}`,
-                deps: [],
-                owns: [`docs/${topic}/**/*.md`],
-                reads: ['src/**/*.ts', 'README.md'],
-                plan: `Research ${topic} implementation → Write documentation → Add examples → Review completeness`,
-            });
-        }
-    }
-    else if (template.id === 'code-feature') {
-        // Generate types → core → tests → docs
-        const feature = context.featureName;
-        streams.push({
-            name: `${feature}-types`,
-            deps: [],
-            owns: [`src/types/${feature}.ts`],
-            reads: ['src/types.ts'],
-            plan: 'Analyze requirements → Define types → Add validation schemas → Export types',
-        }, {
-            name: `${feature}-core`,
-            deps: [`${feature}-types`],
-            owns: [`src/${feature}/*.ts`],
-            reads: [`src/types/${feature}.ts`, 'src/utils/*.ts'],
-            plan: 'Implement core logic → Add error handling → Integrate with existing systems',
-        }, {
-            name: `${feature}-tests`,
-            deps: [`${feature}-core`],
-            owns: [`tests/${feature}.test.ts`],
-            reads: [`src/${feature}/*.ts`],
-            plan: 'Write unit tests → Add integration tests → Test edge cases → Verify coverage',
-        }, {
-            name: `${feature}-docs`,
-            deps: [`${feature}-core`],
-            owns: [`docs/${feature}/*.md`],
-            reads: [`src/${feature}/*.ts`],
-            plan: 'Document API → Add usage examples → Write integration guide',
-        });
-    }
-    else if (template.id === 'migration') {
-        // Generate new implementation → migrate components → deprecate old
-        const feature = context.featureName;
-        const components = context.components || [];
-        streams.push({
-            name: `${feature}-new-implementation`,
-            deps: [],
-            owns: [`src/${feature}-new/*.ts`],
-            reads: [`src/${feature}-old/*.ts`],
-            plan: 'Implement new version → Match old API → Add compatibility layer',
-        });
-        for (const component of components) {
-            streams.push({
-                name: `${feature}-migrate-${component}`,
-                deps: [`${feature}-new-implementation`],
-                owns: [`src/${component}/**/*.ts`],
-                reads: [`src/${feature}-new/*.ts`, `src/${feature}-old/*.ts`],
-                plan: 'Update imports → Replace function calls → Update tests → Verify behavior',
-            });
-        }
-        streams.push({
-            name: `${feature}-deprecate-old`,
-            deps: components.map(c => `${feature}-migrate-${c}`),
-            owns: [`src/${feature}-old/*.ts`],
-            reads: [],
-            plan: 'Add deprecation notices → Update docs → Plan removal timeline',
-        });
-    }
-    else if (template.id === 'tutorial') {
-        // Generate tutorial streams for each topic
-        const topics = context.topics || [];
-        for (const topic of topics) {
-            streams.push({
-                name: `tutorial-${topic}`,
-                deps: [],
-                owns: [`docs/tutorials/${topic}.md`, `examples/${topic}/**/*`],
-                reads: ['src/**/*.ts'],
-                plan: 'Define learning objectives → Write tutorial → Create working example → Add exercises',
-            });
-        }
-    }
-    else if (template.id === 'api-reference') {
-        // Generate API reference streams for each module
-        const modules = context.modules || [];
-        for (const module of modules) {
-            streams.push({
-                name: `api-${module}-reference`,
-                deps: [],
-                owns: [`docs/api/${module}.md`],
-                reads: [`src/${module}/**/*.ts`],
-                plan: 'Extract types/interfaces → Document functions → Add examples → Cross-link related APIs',
-            });
-        }
-    }
-    return streams;
-}
-/**
- * Analyze a stream and suggest how to split it if needed.
- * Returns null if the stream seems appropriately sized.
- */
-export function suggestSplit(stream) {
-    const owns = stream.owns || [];
-    const reads = stream.reads || [];
-    // Check if stream owns too many files
-    if (owns.length > 5) {
-        return {
-            originalStream: stream.name,
-            reason: `Stream owns ${owns.length} files, which may be too many for a single stream`,
-            guidance: [
-                'Consider grouping related files together',
-                'Split by logical component or responsibility',
-                'Create dependencies between resulting streams if needed',
-            ],
-            suggestedStreams: [],
-        };
-    }
-    // Check if stream reads too many files
-    if (reads.length > 10) {
-        return {
-            originalStream: stream.name,
-            reason: `Stream reads ${reads.length} files, which may indicate broad scope`,
-            guidance: [
-                'Reading many files often means the stream is doing too much',
-                'Consider splitting into smaller, focused streams',
-                'Each stream should ideally read 3-5 context files',
-            ],
-            suggestedStreams: [],
-        };
-    }
-    // Try to find a matching template for suggestions
-    const description = `${stream.name} ${stream.plan || ''}`;
-    const template = findMatchingTemplate(description);
-    if (template) {
-        // Check if stream name suggests it should be split
-        const nameKeywords = ['multiple', 'all', 'complete', 'full', 'entire'];
-        const shouldSplit = nameKeywords.some(keyword => stream.name.toLowerCase().includes(keyword));
-        if (shouldSplit) {
-            return {
-                originalStream: stream.name,
-                reason: `Stream name suggests broad scope that could be split`,
-                template,
-                guidance: template.guidelines,
-                suggestedStreams: [],
-            };
-        }
-    }
-    return null;
-}
-/**
- * Get all available templates.
- */
-export function getAllTemplates() {
-    return [...ALL_TEMPLATES];
-}
-/**
- * Get a specific template by ID.
- */
-export function getTemplate(id) {
-    return ALL_TEMPLATES.find(t => t.id === id) || null;
-}

package/dist/intelligence/split-suggester.d.ts

@@ -1,69 +0,0 @@
-/**
- * Split suggester for interactive stream improvement.
- * Combines anti-pattern detection with template-based split suggestions.
- */
-import type { StreamDefinitionInput } from '../types.js';
-import { type AntiPatternIssue, type StreamAnalysis, AntiPatternDetector } from './anti-pattern-detector.js';
-import { type SlicingTemplate } from './slicing-templates.js';
-/**
- * Interactive suggestion for a problematic stream.
- */
-export interface InteractiveSuggestion {
-    /** Stream ID with issues */
-    streamId: string;
-    /** Anti-pattern violations found */
-    violations: AntiPatternIssue[];
-    /** Quality score (0-100) */
-    qualityScore: number;
-    /** Matched template (if any) */
-    templateMatch: SlicingTemplate | null;
-    /** Suggested replacement streams */
-    suggestedSplit: StreamDefinitionInput[] | null;
-    /** Human-readable message for CLI */
-    message: string;
-    /** Suggested action */
-    action: 'accept_split' | 'modify' | 'ignore';
-}
-/**
- * Summary of all suggestions for a stream set.
- */
-export interface SuggestionsSummary {
-    /** Total streams analyzed */
-    totalStreams: number;
-    /** Streams with errors (critical issues) */
-    errorCount: number;
-    /** Streams with warnings */
-    warningCount: number;
-    /** Streams with template matches */
-    templateMatches: number;
-    /** Human-readable summary */
-    summary: string;
-}
-/**
- * Generate an interactive suggestion for a problematic stream.
- */
-export declare function generateInteractiveSuggestion(streamId: string, stream: StreamDefinitionInput, analysis: StreamAnalysis): InteractiveSuggestion | null;
-/**
- * Generate suggestions for all streams in a set.
- */
-export declare function generateAllSuggestions(streams: Record<string, StreamDefinitionInput>, detector?: AntiPatternDetector): InteractiveSuggestion[];
-/**
- * Apply accepted splits to a stream set.
- * Returns new stream set with original streams replaced by split streams.
- */
-export declare function applySplits(streams: Record<string, StreamDefinitionInput>, acceptedSplits: Array<{
-    originalId: string;
-    newStreams: StreamDefinitionInput[];
-}>): Record<string, StreamDefinitionInput>;
-/**
- * Generate a summary of all suggestions.
- */
-export declare function getSuggestionsSummary(suggestions: InteractiveSuggestion[]): SuggestionsSummary;
-/**
- * Format a single suggestion for CLI display.
- */
-export declare function formatSuggestion(suggestion: InteractiveSuggestion): string;
-/**
- * Format all suggestions as a report.
- */
-export declare function formatSuggestionsReport(suggestions: InteractiveSuggestion[]): string;

package/dist/intelligence/split-suggester.js

@@ -1,176 +0,0 @@
-/**
- * Split suggester for interactive stream improvement.
- * Combines anti-pattern detection with template-based split suggestions.
- */
-import { createDetector, } from './anti-pattern-detector.js';
-import { findMatchingTemplate, applyTemplate, } from './slicing-templates.js';
-/**
- * Generate an interactive suggestion for a problematic stream.
- */
-export function generateInteractiveSuggestion(streamId, stream, analysis) {
-    // Only suggest for streams with issues
-    if (analysis.issues.length === 0) {
-        return null;
-    }
-    const hasErrors = analysis.issues.some(i => i.severity === 'error');
-    const hasWarnings = analysis.issues.some(i => i.severity === 'warning');
-    // Try to find a matching template
-    const description = `${stream.name ?? streamId} ${stream.plan ?? ''}`;
-    const template = findMatchingTemplate(description);
-    // Generate suggested split if template matches
-    let suggestedSplit = null;
-    if (template) {
-        // Extract feature name from stream ID
-        const featureName = streamId.replace(/-/g, '_');
-        suggestedSplit = applyTemplate(template, { featureName });
-    }
-    // Build CLI message
-    let message = '';
-    if (hasErrors) {
-        message = `Stream "${streamId}" has critical issues:\n`;
-    }
-    else if (hasWarnings) {
-        message = `Stream "${streamId}" has potential issues:\n`;
-    }
-    else {
-        message = `Stream "${streamId}" has suggestions:\n`;
-    }
-    for (const issue of analysis.issues) {
-        const icon = issue.severity === 'error' ? '❌' : issue.severity === 'warning' ? '⚠️' : 'ℹ️';
-        message += `  ${icon} ${issue.message}\n`;
-        if (issue.details) {
-            message += `     ${issue.details}\n`;
-        }
-    }
-    if (template && suggestedSplit && suggestedSplit.length > 0) {
-        message += `\n📋 Suggested split using "${template.name}" template:\n`;
-        for (const s of suggestedSplit) {
-            const owns = s.owns?.join(', ') ?? 'TBD';
-            message += `  • ${s.name}: ${owns}\n`;
-        }
-        message += '\nAccept suggested split? [Y/n/edit]';
-    }
-    else {
-        message += '\nNo template match. Consider manual split or ignore.';
-    }
-    return {
-        streamId,
-        violations: analysis.issues,
-        qualityScore: analysis.qualityScore,
-        templateMatch: template,
-        suggestedSplit,
-        message,
-        action: hasErrors ? 'accept_split' : hasWarnings ? 'modify' : 'ignore',
-    };
-}
-/**
- * Generate suggestions for all streams in a set.
- */
-export function generateAllSuggestions(streams, detector) {
-    const det = detector ?? createDetector();
-    const suggestions = [];
-    for (const [id, stream] of Object.entries(streams)) {
-        const analysis = det.analyzeStream(id, stream);
-        const suggestion = generateInteractiveSuggestion(id, stream, analysis);
-        if (suggestion) {
-            suggestions.push(suggestion);
-        }
-    }
-    // Sort by severity (errors first, then warnings, then info)
-    suggestions.sort((a, b) => {
-        const aHasError = a.violations.some(v => v.severity === 'error');
-        const bHasError = b.violations.some(v => v.severity === 'error');
-        if (aHasError && !bHasError)
-            return -1;
-        if (!aHasError && bHasError)
-            return 1;
-        const aHasWarning = a.violations.some(v => v.severity === 'warning');
-        const bHasWarning = b.violations.some(v => v.severity === 'warning');
-        if (aHasWarning && !bHasWarning)
-            return -1;
-        if (!aHasWarning && bHasWarning)
-            return 1;
-        return 0;
-    });
-    return suggestions;
-}
-/**
- * Apply accepted splits to a stream set.
- * Returns new stream set with original streams replaced by split streams.
- */
-export function applySplits(streams, acceptedSplits) {
-    const result = { ...streams };
-    for (const split of acceptedSplits) {
-        // Remove original stream
-        delete result[split.originalId];
-        // Add new streams
-        for (const stream of split.newStreams) {
-            const streamId = stream.name.replace(/\s+/g, '-').toLowerCase();
-            result[streamId] = stream;
-        }
-        // Update dependencies in other streams that depended on the original
-        for (const [id, stream] of Object.entries(result)) {
-            if (stream.deps?.includes(split.originalId)) {
-                // Replace dependency with the last stream in the split (typically the integration stream)
-                const newStreamIds = split.newStreams.map(s => s.name.replace(/\s+/g, '-').toLowerCase());
-                const lastStream = newStreamIds[newStreamIds.length - 1];
-                stream.deps = stream.deps.map(d => d === split.originalId ? lastStream : d);
-            }
-        }
-    }
-    return result;
-}
-/**
- * Generate a summary of all suggestions.
- */
-export function getSuggestionsSummary(suggestions) {
-    const errorCount = suggestions.filter(s => s.violations.some(v => v.severity === 'error')).length;
-    const warningCount = suggestions.filter(s => s.violations.some(v => v.severity === 'warning') &&
-        !s.violations.some(v => v.severity === 'error')).length;
-    const templateMatches = suggestions.filter(s => s.templateMatch !== null).length;
-    let summary = '';
-    if (suggestions.length === 0) {
-        summary = '✅ All streams passed validation. No issues detected.';
-    }
-    else {
-        summary = `Stream Validation Summary:\n`;
-        summary += `  ${errorCount} stream${errorCount !== 1 ? 's' : ''} with errors\n`;
-        summary += `  ${warningCount} stream${warningCount !== 1 ? 's' : ''} with warnings\n`;
-        summary += `  ${templateMatches} template match${templateMatches !== 1 ? 'es' : ''} found\n`;
-        if (errorCount > 0) {
-            summary += '\n❌ Critical issues (must fix):\n';
-            for (const s of suggestions.filter(s => s.violations.some(v => v.severity === 'error'))) {
-                const errors = s.violations.filter(v => v.severity === 'error').map(v => v.type);
-                summary += `  • ${s.streamId}: ${errors.join(', ')}\n`;
-            }
-        }
-    }
-    return {
-        totalStreams: suggestions.length,
-        errorCount,
-        warningCount,
-        templateMatches,
-        summary,
-    };
-}
-/**
- * Format a single suggestion for CLI display.
- */
-export function formatSuggestion(suggestion) {
-    return suggestion.message;
-}
-/**
- * Format all suggestions as a report.
- */
-export function formatSuggestionsReport(suggestions) {
-    const summary = getSuggestionsSummary(suggestions);
-    if (suggestions.length === 0) {
-        return summary.summary;
-    }
-    let report = summary.summary + '\n';
-    report += '─'.repeat(50) + '\n';
-    for (const suggestion of suggestions) {
-        report += '\n' + formatSuggestion(suggestion) + '\n';
-    }
-    return report;
-}