@su-record/vibe 0.1.2 → 0.1.4

package/mcp/dist/tools/planning/generatePrd.js

@@ -1,156 +0,0 @@
-// Planning tool - completely independent
-export const generatePrdDefinition = {
-    name: 'generate_prd',
-    description: 'PRD|요구사항 문서|제품 요구사항|product requirements|requirements document|spec document - Generate Product Requirements Document',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            productName: { type: 'string', description: 'Name of the product/feature' },
-            productVision: { type: 'string', description: 'High-level vision and goals' },
-            targetAudience: { type: 'string', description: 'Target users and stakeholders' },
-            businessObjectives: { type: 'string', description: 'Business goals and success metrics' },
-            functionalRequirements: { type: 'string', description: 'Key features and functionality' },
-            constraints: { type: 'string', description: 'Technical/business constraints' }
-        },
-        required: ['productName', 'productVision']
-    },
-    annotations: {
-        title: 'Generate PRD',
-        audience: ['user', 'assistant']
-    }
-};
-export async function generatePrd(args) {
-    const { productName, productVision, targetAudience = 'General users', businessObjectives = 'Improve user experience and business value', functionalRequirements = 'Core functionality to be defined', constraints = 'Standard technical and budget constraints' } = args;
-    const prd = {
-        action: 'generate_prd',
-        product: productName,
-        document: {
-            title: `Product Requirements Document: ${productName}`,
-            version: '1.0',
-            date: new Date().toISOString().split('T')[0],
-            sections: {
-                executiveSummary: {
-                    title: 'Executive Summary',
-                    content: `${productName} is designed to ${productVision}. This document outlines the requirements, scope, and implementation strategy for delivering value to ${targetAudience}.`
-                },
-                productOverview: {
-                    title: 'Product Overview',
-                    vision: productVision,
-                    objectives: businessObjectives,
-                    targetUsers: targetAudience,
-                    successMetrics: [
-                        'User adoption rate',
-                        'Feature usage metrics',
-                        'User satisfaction score',
-                        'Business impact measurement'
-                    ]
-                },
-                functionalRequirements: {
-                    title: 'Functional Requirements',
-                    description: functionalRequirements,
-                    coreFeatures: [
-                        'User authentication and management',
-                        'Core functionality implementation',
-                        'Data processing and storage',
-                        'User interface and experience',
-                        'Integration capabilities'
-                    ],
-                    userFlows: [
-                        'User onboarding process',
-                        'Main feature usage flow',
-                        'Error handling and recovery',
-                        'Administrative functions'
-                    ]
-                },
-                nonFunctionalRequirements: {
-                    title: 'Non-Functional Requirements',
-                    performance: 'Fast response times (<2s), high availability (99.9%)',
-                    security: 'Data encryption, secure authentication, privacy compliance',
-                    scalability: 'Support growing user base and data volume',
-                    usability: 'Intuitive interface, accessibility standards',
-                    compatibility: 'Cross-platform support, browser compatibility'
-                },
-                constraints: {
-                    title: 'Constraints and Assumptions',
-                    technical: constraints,
-                    timeline: 'Development timeline to be defined based on scope',
-                    budget: 'Budget allocation for development and infrastructure',
-                    resources: 'Team capacity and skill requirements'
-                },
-                implementationPlan: {
-                    title: 'Implementation Strategy',
-                    phases: [
-                        'Phase 1: Core functionality development',
-                        'Phase 2: Advanced features and integrations',
-                        'Phase 3: Performance optimization and scaling',
-                        'Phase 4: Launch and post-launch improvements'
-                    ],
-                    riskMitigation: [
-                        'Technical risk assessment and mitigation',
-                        'Resource and timeline risk management',
-                        'Market and user acceptance risks',
-                        'Compliance and security considerations'
-                    ]
-                }
-            }
-        },
-        recommendations: [
-            'Conduct user research to validate assumptions',
-            'Create detailed wireframes and prototypes',
-            'Define detailed acceptance criteria for each feature',
-            'Set up monitoring and analytics for success metrics',
-            'Plan for iterative development and feedback loops'
-        ],
-        status: 'success'
-    };
-    const formattedPrd = `# ${prd.document.title}
-
-**Version:** ${prd.document.version}  
-**Date:** ${prd.document.date}
-
-## ${prd.document.sections.executiveSummary.title}
-${prd.document.sections.executiveSummary.content}
-
-## ${prd.document.sections.productOverview.title}
-**Vision:** ${prd.document.sections.productOverview.vision}
-**Objectives:** ${prd.document.sections.productOverview.objectives}
-**Target Users:** ${prd.document.sections.productOverview.targetUsers}
-
-**Success Metrics:**
-${prd.document.sections.productOverview.successMetrics.map(metric => `- ${metric}`).join('\n')}
-
-## ${prd.document.sections.functionalRequirements.title}
-${prd.document.sections.functionalRequirements.description}
-
-**Core Features:**
-${prd.document.sections.functionalRequirements.coreFeatures.map(feature => `- ${feature}`).join('\n')}
-
-**User Flows:**
-${prd.document.sections.functionalRequirements.userFlows.map(flow => `- ${flow}`).join('\n')}
-
-## ${prd.document.sections.nonFunctionalRequirements.title}
-- **Performance:** ${prd.document.sections.nonFunctionalRequirements.performance}
-- **Security:** ${prd.document.sections.nonFunctionalRequirements.security}
-- **Scalability:** ${prd.document.sections.nonFunctionalRequirements.scalability}
-- **Usability:** ${prd.document.sections.nonFunctionalRequirements.usability}
-- **Compatibility:** ${prd.document.sections.nonFunctionalRequirements.compatibility}
-
-## ${prd.document.sections.constraints.title}
-- **Technical:** ${prd.document.sections.constraints.technical}
-- **Timeline:** ${prd.document.sections.constraints.timeline}
-- **Budget:** ${prd.document.sections.constraints.budget}
-- **Resources:** ${prd.document.sections.constraints.resources}
-
-## ${prd.document.sections.implementationPlan.title}
-**Development Phases:**
-${prd.document.sections.implementationPlan.phases.map(phase => `- ${phase}`).join('\n')}
-
-**Risk Mitigation:**
-${prd.document.sections.implementationPlan.riskMitigation.map(risk => `- ${risk}`).join('\n')}
-
-## Recommendations
-${prd.recommendations.map(rec => `- ${rec}`).join('\n')}`;
-    return {
-        content: [{ type: 'text', text: formattedPrd }]
-    };
-}

package/mcp/dist/tools/prompt/analyzePrompt.js

@@ -1,145 +0,0 @@
-// Prompt analysis tool - completely independent
-export const analyzePromptDefinition = {
-    name: 'analyze_prompt',
-    description: '프롬프트 분석|평가|점수|얼마나 좋은지|analyze prompt|rate this|score|how good|prompt quality - Analyze prompt quality',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            prompt: { type: 'string', description: 'Prompt to analyze' },
-            criteria: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Specific criteria to evaluate (default: all)'
-            }
-        },
-        required: ['prompt']
-    },
-    annotations: {
-        title: 'Analyze Prompt',
-        audience: ['user', 'assistant']
-    }
-};
-export async function analyzePrompt(args) {
-    const { prompt, criteria = ['clarity', 'specificity', 'context', 'structure'] } = args;
-    // Initialize scores with explicit types
-    const scores = {};
-    const feedback = {};
-    // Analyze clarity (0-10)
-    if (criteria.includes('clarity')) {
-        let clarityScore = 5.0;
-        const clarityFeedback = [];
-        if (prompt.length < 20) {
-            clarityScore -= 2.0;
-            clarityFeedback.push('프롬프트가 너무 짧습니다');
-        }
-        if (prompt.includes('?') || /\b(해주세요|부탁|요청)\b/.test(prompt)) {
-            clarityScore += 2.0;
-            clarityFeedback.push('명확한 요청 형태 ✓');
-        }
-        if (prompt.split(',').length > 5 || prompt.split('.').length > 10) {
-            clarityScore -= 1.0;
-            clarityFeedback.push('문장이 너무 복잡합니다');
-        }
-        scores.clarity = Math.max(0, Math.min(10, clarityScore));
-        feedback.clarity = clarityFeedback;
-    }
-    // Analyze specificity (0-10)
-    if (criteria.includes('specificity')) {
-        let specificityScore = 5.0;
-        const specificityFeedback = [];
-        const specificKeywords = ['구체적', '정확히', '예시', '예를 들어'];
-        const hasSpecificWords = specificKeywords.some(word => prompt.includes(word));
-        if (hasSpecificWords) {
-            specificityScore += 2.0;
-            specificityFeedback.push('구체적인 표현 사용 ✓');
-        }
-        const techTerms = /\b(JavaScript|Python|React|Node\.js|API|데이터베이스)\b/i;
-        if (techTerms.test(prompt)) {
-            specificityScore += 2.0;
-            specificityFeedback.push('기술 용어 포함 ✓');
-        }
-        if (!prompt.match(/\d+/) && prompt.length > 50) {
-            specificityScore -= 1.0;
-            specificityFeedback.push('수치나 구체적 데이터 부족');
-        }
-        scores.specificity = Math.max(0, Math.min(10, specificityScore));
-        feedback.specificity = specificityFeedback;
-    }
-    // Analyze context (0-10)
-    if (criteria.includes('context')) {
-        let contextScore = 5.0;
-        const contextFeedback = [];
-        const contextKeywords = ['배경', '목적', '이유', '상황', '현재', '문제'];
-        const contextCount = contextKeywords.filter(word => prompt.includes(word)).length;
-        contextScore += contextCount * 1.5;
-        if (contextCount > 0) {
-            contextFeedback.push(`배경 정보 포함 (${contextCount}개 키워드) ✓`);
-        }
-        else {
-            contextFeedback.push('배경 정보 부족');
-        }
-        if (prompt.split('\n').length > 2) {
-            contextScore += 1.0;
-            contextFeedback.push('구조화된 설명 ✓');
-        }
-        scores.context = Math.max(0, Math.min(10, contextScore));
-        feedback.context = contextFeedback;
-    }
-    // Analyze structure (0-10)
-    if (criteria.includes('structure')) {
-        let structureScore = 5.0;
-        const structureFeedback = [];
-        if (prompt.includes('\n')) {
-            structureScore += 2.0;
-            structureFeedback.push('줄바꿈 사용 ✓');
-        }
-        if (/[1-9]\.|[-•]/.test(prompt)) {
-            structureScore += 2.0;
-            structureFeedback.push('목록 형식 사용 ✓');
-        }
-        if (prompt.includes('**') || prompt.includes('##')) {
-            structureScore += 1.0;
-            structureFeedback.push('마크다운 형식 사용 ✓');
-        }
-        scores.structure = Math.max(0, Math.min(10, structureScore));
-        feedback.structure = structureFeedback;
-    }
-    // Calculate total score
-    const totalScore = Object.values(scores).reduce((a, b) => a + b, 0) / Object.keys(scores).length;
-    // Generate recommendations
-    const recommendations = [];
-    if (scores.clarity < 6) {
-        recommendations.push('💡 질문이나 요청을 더 명확하게 표현하세요');
-    }
-    if (scores.specificity < 6) {
-        recommendations.push('💡 구체적인 예시나 기술 사양을 추가하세요');
-    }
-    if (scores.context < 6) {
-        recommendations.push('💡 작업의 배경과 목적을 설명하세요');
-    }
-    if (scores.structure < 6) {
-        recommendations.push('💡 번호나 불릿 포인트로 구조화하세요');
-    }
-    // Identify strengths and weaknesses
-    const strengths = Object.entries(scores)
-        .filter(([_, score]) => score >= 7)
-        .map(([category, score]) => `✨ ${category}: 우수함 (${score.toFixed(1)}/10)`);
-    const weaknesses = Object.entries(scores)
-        .filter(([_, score]) => score < 5)
-        .map(([category, score]) => `⚠️ ${category}: 개선 필요 (${score.toFixed(1)}/10)`);
-    const analysis = {
-        action: 'analyze_prompt',
-        prompt,
-        totalScore: parseFloat(totalScore.toFixed(1)),
-        scores: Object.fromEntries(Object.entries(scores).map(([k, v]) => [k, parseFloat(v.toFixed(1))])),
-        feedback,
-        strengths,
-        weaknesses,
-        recommendations,
-        grade: totalScore >= 8 ? 'A' : totalScore >= 6 ? 'B' : totalScore >= 4 ? 'C' : 'D',
-        status: 'success'
-    };
-    return {
-        content: [{ type: 'text', text: `Score: ${analysis.totalScore}/10 (Grade: ${analysis.grade})\n\nScores:\n${Object.entries(analysis.scores).map(([k, v]) => `- ${k}: ${v}/10`).join('\n')}\n\nStrengths:\n${analysis.strengths.length > 0 ? analysis.strengths.join('\n') : 'None identified'}\n\nWeaknesses:\n${analysis.weaknesses.length > 0 ? analysis.weaknesses.join('\n') : 'None identified'}\n\nRecommendations:\n${analysis.recommendations.map(r => `- ${r}`).join('\n')}` }]
-    };
-}

package/mcp/dist/tools/prompt/enhancePrompt.js

@@ -1,105 +0,0 @@
-// Prompt enhancement tool - completely independent
-export const enhancePromptDefinition = {
-    name: 'enhance_prompt',
-    description: '구체적으로|자세히|명확하게|더 구체적으로|be specific|more detail|clarify|elaborate|vague - Transform vague requests',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            prompt: { type: 'string', description: 'Original prompt to enhance' },
-            context: { type: 'string', description: 'Additional context or project information' },
-            enhancement_type: {
-                type: 'string',
-                enum: ['clarity', 'specificity', 'context', 'all'],
-                description: 'Type of enhancement (default: all)'
-            }
-        },
-        required: ['prompt']
-    },
-    annotations: {
-        title: 'Enhance Prompt',
-        audience: ['user', 'assistant']
-    }
-};
-export async function enhancePrompt(args) {
-    const { prompt, context = '', enhancement_type = 'all' } = args;
-    // Enhancement logic
-    const enhancements = {
-        clarity: [],
-        specificity: [],
-        context: [],
-        structure: []
-    };
-    // Analyze original prompt
-    const promptLength = prompt.length;
-    const hasQuestion = prompt.includes('?');
-    const hasSpecificTerms = /\b(구현|개발|수정|분석|디버그|리팩토링)\b/i.test(prompt);
-    // Apply enhancements based on type
-    if (enhancement_type === 'clarity' || enhancement_type === 'all') {
-        if (promptLength < 20) {
-            enhancements.clarity.push('더 구체적인 설명 추가');
-        }
-        if (!hasQuestion && !hasSpecificTerms) {
-            enhancements.clarity.push('명확한 요청이나 질문 형태로 변환');
-        }
-    }
-    if (enhancement_type === 'specificity' || enhancement_type === 'all') {
-        if (!prompt.match(/\b(언어|프레임워크|라이브러리|버전)\b/)) {
-            enhancements.specificity.push('기술 스택 명시');
-        }
-        if (!prompt.match(/\b(입력|출력|결과|형식)\b/)) {
-            enhancements.specificity.push('예상 입출력 정의');
-        }
-    }
-    if (enhancement_type === 'context' || enhancement_type === 'all') {
-        if (!prompt.match(/\b(목적|이유|배경|상황)\b/)) {
-            enhancements.context.push('작업 목적과 배경 추가');
-        }
-        if (context) {
-            enhancements.context.push('제공된 컨텍스트 통합');
-        }
-    }
-    // Generate enhanced prompt
-    let enhancedPrompt = prompt;
-    // Build enhanced version
-    const components = [];
-    // Add objective
-    components.push(`**목표**: ${prompt}`);
-    // Add context if provided
-    if (context) {
-        components.push(`**배경**: ${context}`);
-    }
-    // Add specific requirements based on analysis
-    const requirements = [];
-    if (enhancements.specificity.includes('기술 스택 명시')) {
-        requirements.push('- 사용할 언어/프레임워크를 명시해주세요');
-    }
-    if (enhancements.specificity.includes('예상 입출력 정의')) {
-        requirements.push('- 예상되는 입력과 출력 형식을 설명해주세요');
-    }
-    if (requirements.length > 0) {
-        components.push(`**요구사항**:\n${requirements.join('\n')}`);
-    }
-    // Add quality considerations
-    const quality = [
-        '- 에러 처리 포함',
-        '- 테스트 가능한 구조',
-        '- 확장 가능한 설계'
-    ];
-    components.push(`**품질 기준**:\n${quality.join('\n')}`);
-    enhancedPrompt = components.join('\n\n');
-    const result = {
-        action: 'enhance_prompt',
-        original: prompt,
-        enhanced: enhancedPrompt,
-        enhancements,
-        improvements: [
-            enhancements.clarity.length > 0 ? `명확성 개선 (${enhancements.clarity.length}개)` : null,
-            enhancements.specificity.length > 0 ? `구체성 추가 (${enhancements.specificity.length}개)` : null,
-            enhancements.context.length > 0 ? `맥락 보강 (${enhancements.context.length}개)` : null
-        ].filter(Boolean),
-        status: 'success'
-    };
-    return {
-        content: [{ type: 'text', text: `Original: ${prompt}\n\nEnhanced:\n${enhancedPrompt}\n\nImprovements: ${result.improvements.join(', ')}` }]
-    };
-}

package/mcp/dist/tools/semantic/findReferences.js

@@ -1,195 +0,0 @@
-// Semantic code analysis tool - Find References (v1.3)
-// With ProjectCache for 25x performance improvement
-import { Node } from 'ts-morph';
-import * as path from 'path';
-import { ProjectCache } from '../../lib/ProjectCache.js';
-import { readFile } from 'fs/promises';
-export const findReferencesDefinition = {
-    name: 'find_references',
-    description: '어디서 쓰|참조|사용처|find usage|references|where used - Find symbol references',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            symbolName: { type: 'string', description: 'Name of the symbol to find references for' },
-            filePath: { type: 'string', description: 'File path where the symbol is defined' },
-            line: { type: 'number', description: 'Line number of the symbol definition' },
-            projectPath: { type: 'string', description: 'Project directory path' }
-        },
-        required: ['symbolName', 'projectPath']
-    },
-    annotations: {
-        title: 'Find References',
-        audience: ['user', 'assistant']
-    }
-};
-export async function findReferences(args) {
-    const { symbolName, filePath, line, projectPath } = args;
-    try {
-        // Use cached project for performance
-        const projectCache = ProjectCache.getInstance();
-        const project = projectCache.getOrCreate(projectPath);
-        const allReferences = [];
-        // Check for Python files
-        const glob = await import('glob');
-        const pythonFiles = glob.globSync(path.join(projectPath, '**/*.py'), {
-            ignore: ['**/node_modules/**', '**/.git/**', '**/venv/**', '**/__pycache__/**']
-        });
-        // Parse Python files for references
-        for (const pyFile of pythonFiles) {
-            try {
-                const content = await readFile(pyFile, 'utf-8');
-                const lines = content.split('\n');
-                lines.forEach((line, index) => {
-                    if (line.includes(symbolName)) {
-                        const column = line.indexOf(symbolName);
-                        allReferences.push({
-                            filePath: pyFile,
-                            line: index + 1,
-                            column: column,
-                            text: line.trim().substring(0, 100),
-                            isDefinition: /^(def|class)\s/.test(line.trim())
-                        });
-                    }
-                });
-            }
-            catch (error) {
-                console.error(`Error parsing Python file ${pyFile}:`, error);
-            }
-        }
-        // If specific file and line provided, use precise reference finding
-        if (filePath && line) {
-            const sourceFile = project.getSourceFile(filePath);
-            if (sourceFile) {
-                const position = sourceFile.compilerNode.getPositionOfLineAndCharacter(line - 1, 0);
-                const node = sourceFile.getDescendantAtPos(position);
-                if (node) {
-                    const symbol = node.getSymbol();
-                    if (symbol) {
-                        const references = project.getLanguageService().findReferencesAtPosition(sourceFile, position);
-                        if (references) {
-                            for (const ref of references) {
-                                for (const reference of ref.getReferences()) {
-                                    const refSourceFile = reference.getSourceFile();
-                                    const refNode = reference.getNode();
-                                    const start = refNode.getStartLinePos();
-                                    const pos = refSourceFile.getLineAndColumnAtPos(start);
-                                    allReferences.push({
-                                        filePath: refSourceFile.getFilePath(),
-                                        line: pos.line,
-                                        column: pos.column,
-                                        text: refNode.getParent()?.getText().substring(0, 100) || refNode.getText(),
-                                        isDefinition: reference.isDefinition() || false
-                                    });
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            // Fallback: search by name across all files
-            for (const sourceFile of project.getSourceFiles()) {
-                const filePath = sourceFile.getFilePath();
-                // Skip node_modules and other irrelevant paths
-                if (filePath.includes('node_modules') || filePath.includes('.git')) {
-                    continue;
-                }
-                // Find all identifiers matching the symbol name
-                sourceFile.forEachDescendant((node) => {
-                    if (Node.isIdentifier(node) && node.getText() === symbolName) {
-                        const start = node.getStartLinePos();
-                        const pos = sourceFile.getLineAndColumnAtPos(start);
-                        const parent = node.getParent();
-                        // Determine if this is a definition
-                        const isDefinition = isSymbolDefinition(node);
-                        allReferences.push({
-                            filePath: filePath,
-                            line: pos.line,
-                            column: pos.column,
-                            text: parent?.getText().substring(0, 100) || node.getText(),
-                            isDefinition
-                        });
-                    }
-                });
-            }
-        }
-        const definitions = allReferences.filter(r => r.isDefinition);
-        const usages = allReferences.filter(r => !r.isDefinition);
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Found ${allReferences.length} references (${definitions.length} defs, ${usages.length} uses):\n${allReferences.slice(0, 20).map(r => `${r.isDefinition ? 'DEF' : 'USE'}: ${r.filePath}:${r.line}`).join('\n')}`
-                }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Error finding references: ${error instanceof Error ? error.message : 'Unknown error'}`
-                }]
-        };
-    }
-}
-function isSymbolDefinition(node) {
-    const parent = node.getParent();
-    if (!parent)
-        return false;
-    // Check if this is a declaration
-    return Node.isFunctionDeclaration(parent) ||
-        Node.isClassDeclaration(parent) ||
-        Node.isInterfaceDeclaration(parent) ||
-        Node.isTypeAliasDeclaration(parent) ||
-        Node.isVariableDeclaration(parent) ||
-        Node.isMethodDeclaration(parent) ||
-        Node.isPropertyDeclaration(parent) ||
-        Node.isParameterDeclaration(parent);
-}
-function groupReferencesByFile(references) {
-    const grouped = {};
-    for (const ref of references) {
-        if (!grouped[ref.filePath]) {
-            grouped[ref.filePath] = [];
-        }
-        grouped[ref.filePath].push(ref);
-    }
-    // Sort references within each file by line number
-    for (const filePath in grouped) {
-        grouped[filePath].sort((a, b) => a.line - b.line);
-    }
-    return grouped;
-}
-function formatReferenceResults(result) {
-    let output = `# Reference Search Results\n\n`;
-    output += `**Symbol:** ${result.symbol}\n`;
-    output += `**Total References:** ${result.totalReferences}\n`;
-    output += `**Files:** ${result.filesCount}\n`;
-    output += `**Definitions:** ${result.definitions.length}\n`;
-    output += `**Usages:** ${result.usages.length}\n\n`;
-    if (result.totalReferences === 0) {
-        output += `No references found for "${result.symbol}".\n`;
-        return output;
-    }
-    // Show definitions first
-    if (result.definitions.length > 0) {
-        output += `## Definitions\n\n`;
-        result.definitions.forEach((def, index) => {
-            output += `${index + 1}. **${def.filePath}:${def.line}:${def.column}**\n`;
-            output += `   \`\`\`typescript\n   ${def.text}\n   \`\`\`\n\n`;
-        });
-    }
-    // Show usages grouped by file
-    output += `## Usages by File\n\n`;
-    for (const [filePath, refs] of Object.entries(result.references)) {
-        const usages = refs.filter(r => !r.isDefinition);
-        if (usages.length === 0)
-            continue;
-        output += `### ${filePath} (${usages.length} usages)\n\n`;
-        usages.forEach((ref) => {
-            output += `- **Line ${ref.line}:** \`${ref.text.substring(0, 60)}...\`\n`;
-        });
-        output += `\n`;
-    }
-    return output;
-}