Resume/CV Creator

What this skill does

# Resume/CV Creator

The Resume/CV Creator skill automates the creation of professional resumes and curriculum vitae with multiple templates, formatting options, and ATS (Applicant Tracking System) optimization. It handles standard resume formats, academic CVs, creative portfolios, and international variations. The skill ensures proper structure, formatting, and keyword optimization for job applications.

Generate resumes in multiple formats (PDF, DOCX, HTML), customize for specific job applications, and maintain multiple versions for different industries or roles.

## Core Workflows

### Workflow 1: Generate Professional Resume
**Purpose:** Create a standard professional resume with clean formatting

**Steps:**
1. Collect candidate information (personal, education, experience, skills)
2. Choose resume template and style
3. Format contact information and header
4. Add professional summary or objective
5. List work experience in reverse chronological order
6. Include education and certifications
7. Add skills section with relevant keywords
8. Format for readability and ATS compatibility
9. Export to PDF and DOCX

**Implementation:**
```javascript
const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType, TabStopType, TabStopPosition } = require('docx');
const fs = require('fs');

async function generateResume(resumeData, outputPath) {
  const doc = new Document({
    sections: [{
      properties: {},
      children: [
        // Header - Name
        new Paragraph({
          text: resumeData.personalInfo.name,
          heading: HeadingLevel.HEADING_1,
          alignment: AlignmentType.CENTER,
          spacing: { after: 100 }
        }),

        // Contact Info
        new Paragraph({
          alignment: AlignmentType.CENTER,
          children: [
            new TextRun(`${resumeData.personalInfo.email} | `),
            new TextRun(`${resumeData.personalInfo.phone} | `),
            new TextRun(`${resumeData.personalInfo.location} | `),
            new TextRun({
              text: resumeData.personalInfo.linkedin,
              style: 'Hyperlink'
            })
          ],
          spacing: { after: 300 }
        }),

        // Professional Summary
        new Paragraph({
          text: 'PROFESSIONAL SUMMARY',
          heading: HeadingLevel.HEADING_2,
          spacing: { before: 200, after: 100 }
        }),
        new Paragraph({
          text: resumeData.summary,
          spacing: { after: 300 }
        }),

        // Work Experience
        new Paragraph({
          text: 'WORK EXPERIENCE',
          heading: HeadingLevel.HEADING_2,
          spacing: { before: 200, after: 100 }
        }),

        ...resumeData.experience.flatMap(job => [
          new Paragraph({
            children: [
              new TextRun({
                text: job.title,
                bold: true,
                size: 24
              }),
              new TextRun({
                text: ` | ${job.company}`,
                size: 24
              })
            ],
            spacing: { before: 150 }
          }),
          new Paragraph({
            children: [
              new TextRun({
                text: `${job.location} | ${job.startDate} - ${job.endDate}`,
                italics: true,
                size: 20
              })
            ],
            spacing: { after: 100 }
          }),
          ...job.achievements.map(achievement =>
            new Paragraph({
              text: achievement,
              bullet: {
                level: 0
              },
              spacing: { after: 50 }
            })
          )
        ]),

        // Education
        new Paragraph({
          text: 'EDUCATION',
          heading: HeadingLevel.HEADING_2,
          spacing: { before: 300, after: 100 }
        }),

        ...resumeData.education.map(edu => [
          new Paragraph({
            children: [
              new TextRun({
                text: edu.degree,
                bold: true
              }),
              new TextRun(` | ${edu.institution}`)
            ]
          }),
          new Paragraph({
            text: `${edu.location} | Graduated ${edu.graduationDate}`,
            italics: true,
            spacing: { after: 100 }
          }),
          ...(edu.achievements ? [
            new Paragraph({
              text: edu.achievements,
              spacing: { after: 150 }
            })
          ] : [])
        ]).flat(),

        // Skills
        new Paragraph({
          text: 'SKILLS',
          heading: HeadingLevel.HEADING_2,
          spacing: { before: 300, after: 100 }
        }),

        ...Object.entries(groupSkills(resumeData.skills)).map(([category, skills]) =>
          new Paragraph({
            children: [
              new TextRun({
                text: `${category}: `,
                bold: true
              }),
              new TextRun(skills.join(', '))
            ],
            spacing: { after: 100 }
          })
        ),

        // Certifications (if any)
        ...(resumeData.certifications && resumeData.certifications.length > 0 ? [
          new Paragraph({
            text: 'CERTIFICATIONS',
            heading: HeadingLevel.HEADING_2,
            spacing: { before: 300, after: 100 }
          }),
          ...resumeData.certifications.map(cert =>
            new Paragraph({
              text: `${cert.name} - ${cert.issuer} (${cert.date})`,
              bullet: { level: 0 },
              spacing: { after: 50 }
            })
          )
        ] : [])
      ]
    }]
  });

  const buffer = await Packer.toBuffer(doc);
  fs.writeFileSync(outputPath, buffer);

  return outputPath;
}

function groupSkills(skills) {
  const grouped = {};

  skills.forEach(skill => {
    const category = skill.category || 'General';
    if (!grouped[category]) {
      grouped[category] = [];
    }
    grouped[category].push(skill.name);
  });

  return grouped;
}
```

### Workflow 2: Tailor Resume for Job Application
**Purpose:** Customize resume to match specific job description and requirements

**Steps:**
1. Parse job description for keywords
2. Identify required skills and qualifications
3. Extract candidate's relevant experience
4. Reorder sections to highlight matching qualifications
5. Add keywords naturally throughout resume
6. Adjust professional summary to match role
7. Emphasize achievements relevant to position
8. Optimize for ATS scanning

**Implementation:**
```javascript
const natural = require('natural');
const TfIdf = natural.TfIdf;

function tailorResumeForJob(resumeData, jobDescription) {
  // Extract keywords from job description
  const keywords = extractKeywords(jobDescription);

  // Score candidate's experience against job requirements
  const scoredExperience = scoreExperience(resumeData.experience, keywords);

  // Rewrite professional summary
  const tailoredSummary = generateTailoredSummary(resumeData, keywords);

  // Prioritize relevant skills
  const prioritizedSkills = prioritizeSkills(resumeData.skills, keywords);

  // Highlight matching achievements
  const enhancedExperience = enhanceExperience(scoredExperience, keywords);

  return {
    ...resumeData,
    summary: tailoredSummary,
    experience: enhancedExperience,
    skills: prioritizedSkills,
    tailoredFor: {
      jobTitle: extractJobTitle(jobDescription),
      matchScore: calculateMatchScore(resumeData, keywords),
      keywords: keywords.slice(0, 10) // Top 10 keywords
    }
  };
}

function extractKeywords(jobDescription) {
  const tfidf = new TfIdf();
  tfidf.addDocument(jobDescription.toLowerCase());

  const keywords = [];
  tfidf.listTerms(0).forEach(item => {
    if (item.term.length > 3 && !isCommonWord(item.term)) {
      keywords.push({
        term: item.term,
        score: item.tfidf
      });
    }
  });

  return keywords
    .sort((a, b) => b.score - a.score)
    .map(k => k.term);
}

function scoreExperience(experience, keywords) {
  return experience.map(job => {