### Installing and Using a Separate FRESH Theme

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Shows how to install a FRESH theme (like hello-world) from NPM and then apply it to a resume using the -t or --theme option.

```bash
npm install fresh-theme-hello-world
hackmyresume resume.json -t node_modules/fresh-theme-hello-world
```

--------------------------------

### Build Resume with Custom Theme and Output

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Builds a resume from a JSON file and outputs it to a specified file. This command supports custom themes, including themes installed via npm. The example shows how to use a locally installed theme (node_modules/jsonresume-theme-classy) to generate an output file.

```bash
hackmyresume BUILD resume.json TO out/somefile.all -t node_modules/jsonresume-theme-classy
```

--------------------------------

### Build Resume with Themes

Source: https://github.com/hacksalot/hackmyresume/blob/master/FAQ.md

Instructions for building a resume using built-in or external themes. External themes must be installed via NPM before being referenced by their path.

```bash
hackmyresume build resume.json --theme compact
npm install fresh-theme-underscore
hackmyresume BUILD resume.json --theme node_modules/fresh-theme-underscore
npm install jsonresume-theme-classy
hackmyresume BUILD resume.json --theme node_modules/jsonresume-theme-classy
```

--------------------------------

### Install and Initialize HackMyResume

Source: https://github.com/hacksalot/hackmyresume/blob/master/FAQ.md

Commands to install the HackMyResume CLI globally via NPM and initialize a new resume JSON file.

```bash
npm install hackmyresume -g
hackmyresume NEW resume.json
```

--------------------------------

### GET /help

Source: https://github.com/hacksalot/hackmyresume/blob/master/src/cli/help/help.txt

Displays help information for a specific HackMyResume command.

```APIDOC
## GET /help

### Description
The HELP command displays help information for a specific HackMyResume command, including the HELP command itself.

### Method
GET

### Endpoint
hackmyresume HELP [<command>]

### Parameters
#### Path Parameters
- **command** (string) - Required - The HackMyResume command to view help information for. Must be one of: BUILD, NEW, CONVERT, ANALYZE, VALIDATE, PEEK, or HELP.

### Request Example
hackmyresume help convert

### Response
#### Success Response (200)
- **output** (string) - The help documentation text for the requested command.
```

--------------------------------

### FRESHResume Class - Working with FRESH Format

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Explains how to create, parse, manipulate, and save resumes in the FRESH format using the FRESHResume class. Includes examples of accessing data, validation, transformation, and saving.

```APIDOC
## FRESHResume Class - Working with FRESH Format

Create, parse, manipulate, and save FRESH format resumes.

```javascript
const HMR = require('hackmyresume');
const fs = require('fs');

// Create a default (starter) resume
const newResume = HMR.FRESHResume.default();
newResume.name = 'Jane Developer';
newResume.info = { brief: 'Full-stack engineer with 10 years experience' };
newResume.save('my-resume.json');

// Parse an existing resume from JSON string
const jsonData = fs.readFileSync('resume.json', 'utf8');
const resume = new HMR.FRESHResume().parse(jsonData, {
  date: true,     // Parse and normalize dates
  sort: true,     // Sort sections by date
  compute: true   // Calculate computed values (duration, keywords)
});

// Access resume data
console.log('Name:', resume.name);
console.log('Total years experience:', resume.computed.numYears);
console.log('Keywords:', resume.computed.keywords);
console.log('Has GitHub:', resume.hasProfile('github'));
console.log('GitHub profile:', resume.getProfile('github'));

// Validate against the FRESH schema
if (resume.isValid()) {
  console.log('Resume is valid!');
} else {
  console.log('Validation errors:', resume.imp.validationErrors);
}

// Transform for different outputs
const mdResume = resume.markdownify();  // Markdown-interpreted strings
const xmlResume = resume.xmlify();       // XML-escaped strings

// Save in different formats
resume.save('output.json');              // Save as FRESH JSON
resume.saveAs('output-jrs.json', 'JRS'); // Convert and save as JSON Resume

// Clone the resume
const copy = resume.dupe();
```
```

--------------------------------

### Generate PDF with Specified Engine

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Generates a resume in PDF format. Users can choose between 'phantom' (default) and 'wkhtmltopdf' using the `--pdf` or `-p` flag. This allows for flexibility in PDF generation based on installed tools and desired output.

```bash
hackmyresume BUILD resume.json TO out/resume.pdf --pdf phantom
```

```bash
hackmyresume BUILD resume.json TO out/resume.pdf --pdf wkhtmltopdf
```

--------------------------------

### FRESH Resume JSON Schema Structure

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Provides a reference example of the FRESH resume schema, illustrating the organization of metadata, contact information, employment history, education, and skills.

```json
{
  "name": "Jane Developer",
  "meta": { "format": "FRESH@0.6.0", "version": "1.0.0" },
  "info": { "label": "Senior Software Engineer", "brief": "Full-stack developer with 10+ years of experience building scalable web applications." },
  "contact": { "email": "jane@example.com", "phone": "555-123-4567", "website": "https://janedev.io" },
  "location": { "city": "San Francisco", "region": "CA", "country": "US" },
  "social": [{ "network": "GitHub", "user": "janedev", "url": "https://github.com/janedev" }],
  "employment": { "history": [{ "employer": "Tech Corp", "position": "Senior Engineer", "start": "2020-01", "end": "current", "highlights": ["Designed microservices architecture"] }] },
  "skills": { "sets": [{ "name": "Backend Development", "level": "Master", "skills": ["Node.js", "Python"] }] }
}
```

--------------------------------

### Install HackMyResume CLI

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Installs the HackMyResume command-line tool globally using npm. Supports both stable and development versions.

```bash
npm install hackmyresume -g
```

```bash
npm install hacksalot/hackmyresume#dev -g
```

--------------------------------

### HackMyResume Configuration Options

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Example of a configuration file (.hackmyrc or JSON) for HackMyResume, specifying theme, formatting, PDF engine, and section title overrides. This allows for persistent customization of resume generation.

```json
{
  "theme": "modern",
  "prettify": true,
  "pdf": "wkhtmltopdf",
  "css": "embed",
  "sort": true,

  "sectionTitles": {
    "employment": "Work Experience",
    "education": "Education & Training",
    "skills": "Technical Skills"
  },

  "wkhtmltopdf": {
    "margin-top": "15mm",
    "margin-bottom": "15mm",
    "margin-left": "10mm",
    "margin-right": "10mm"
  }
}
```

--------------------------------

### Install HackMyResume Globally

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Installs HackMyResume globally on your system using npm. This command makes the hackmyresume CLI tool available system-wide. External PDF engines like Phantom.js and wkhtmltopdf are no longer installed by default, improving installation speed and reliability.

```bash
npm install hackmyresume -g
```

--------------------------------

### Execute Build Command Programmatically

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Demonstrates how to instantiate the build verb, listen for lifecycle events like file reading and generation, and invoke the build process with specific configuration options.

```javascript
const HMR = require('hackmyresume');
const buildVerb = new HMR.verbs.build();
buildVerb.on('hmr:status', (eventType, data) => {
  switch(eventType) {
    case 'beforeRead': console.log('Reading:', data.file); break;
    case 'afterGenerate': console.log('Generated:', data.file, `(${data.fmt})`); break;
    case 'applyTheme': console.log('Using theme:', data.theme.name); break;
  }
});
buildVerb.on('hmr:error', (err) => {
  console.error('Build error:', err.fluenterror, err.inner?.message);
});
const promise = buildVerb.invoke(['resume.json'], ['out/resume.all'], { theme: 'modern', pdf: 'wkhtmltopdf', prettify: true, private: false });
promise.then((results) => {
  console.log('Build complete!');
  console.log('Generated files:', results.targets.map(t => t.file));
}).catch((err) => {
  console.error('Build failed:', err);
});
```

--------------------------------

### Generate a New Resume with Sample Data

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Creates a new resume file using the 'new' command. When run without a filename, it now generates a valid starter resume with sample data, providing a quick way to begin creating a resume. It also fixes a warning message that previously appeared when no filename was provided.

```bash
hackmyresume new
```

--------------------------------

### Build Resume with Theme Inheritance

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Builds a resume using a specified theme ('awesome'). This command demonstrates how themes can inherit formats from other themes, such as the 'Basis' theme for Markdown and Plain Text formats. Theme messages and usage tips are displayed by default.

```bash
hackmyresume build resume.json -t awesome
```

--------------------------------

### ResumeFactory - Loading Resumes

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Demonstrates how to use the ResumeFactory to load and parse FRESH or JSON Resume files from disk, with options for format detection, objectification, and inner processing.

```APIDOC
## ResumeFactory - Loading Resumes

Load and parse FRESH or JSON Resume files from disk.

```javascript
const HMR = require('hackmyresume');

// Load a single resume (auto-detect format)
const result = HMR.ResumeFactory.loadOne('resume.json', {
  format: null,      // 'FRESH', 'JRS', or null for auto-detect
  objectify: true,   // Return FRESHResume/JRSResume object (true) or raw JSON (false)
  inner: {
    sort: true,      // Sort resume sections by date
    private: false   // Include private fields
  }
});

if (result.fluenterror) {
  console.error('Error loading resume:', result.fluenterror);
} else {
  console.log('Loaded:', result.file);
  console.log('Format:', result.rez.format());
  console.log('Name:', result.rez.name || result.rez.basics?.name);
}

// Load multiple resumes at once
const resumes = HMR.ResumeFactory.load(
  ['resume1.json', 'resume2.json'],
  { format: 'FRESH', objectify: true }
);
```
```

--------------------------------

### Build Verb - Programmatic Usage

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

This section demonstrates how to use the 'build' verb programmatically to convert resume files between formats, with event handling for status updates and errors.

```APIDOC
## Build Verb - Programmatic Usage

### Description
Execute HackMyResume commands via the API with event handling. This example shows how to instantiate the build verb, listen for status and error events, and invoke the build command.

### Method
Programmatic API (JavaScript)

### Endpoint
N/A (Programmatic)

### Parameters
N/A (Programmatic)

### Request Example
```javascript
const HMR = require('hackmyresume');

// Create a build verb instance
const buildVerb = new HMR.verbs.build();

// Listen for status events
buildVerb.on('hmr:status', (eventType, data) => {
  switch(eventType) {
    case 'beforeRead':
      console.log('Reading:', data.file);
      break;
    case 'afterGenerate':
      console.log('Generated:', data.file, `(${data.fmt})`);
      break;
    case 'applyTheme':
      console.log('Using theme:', data.theme.name);
      break;
  }
});

// Listen for errors
buildVerb.on('hmr:error', (err) => {
  console.error('Build error:', err.fluenterror, err.inner?.message);
});

// Invoke the build command
const promise = buildVerb.invoke(
  ['resume.json'],           // Source files
  ['out/resume.all'],        // Destination files
  {
    theme: 'modern',
    pdf: 'wkhtmltopdf',
    prettify: true,
    private: false
  }
);

promise.then((results) => {
  console.log('Build complete!');
  console.log('Generated files:', results.targets.map(t => t.file));
}).catch((err) => {
  console.error('Build failed:', err);
});
```

### Response
#### Success Response (Promise Resolution)
- **results** (object) - An object containing information about the generated files.
  - **targets** (array) - An array of objects, each representing a generated file.
    - **file** (string) - The path to the generated file.

#### Response Example
```javascript
// On successful build:
console.log('Build complete!');
console.log('Generated files:', ['out/resume.all.html', 'out/resume.all.pdf']); // Example output

// On build failure:
console.error('Build failed:', { message: 'Specific error message' }); // Example output
```
```

--------------------------------

### HackMyResume CLI: Build/Convert Command Syntax

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Illustrates the flexibility of the 'build' and 'convert' commands in HackMyResume. It shows how the 'TO' keyword is optional when specifying a single output file, and required for multiple output files.

```shell
hackmyresume BUILD resume.json TO out/resume.all
hackmyresume BUILD resume.json out/resume.all
hackmyresume BUILD resume.json TO out1.doc out2.html out3.tex
```

--------------------------------

### Load Resumes with ResumeFactory

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Shows how to load single or multiple resume files from disk using the ResumeFactory. It supports auto-detection of formats and optional objectification.

```javascript
const HMR = require('hackmyresume');
const result = HMR.ResumeFactory.loadOne('resume.json', {
  format: null,
  objectify: true,
  inner: {
    sort: true,
    private: false
  }
});
if (result.fluenterror) {
  console.error('Error loading resume:', result.fluenterror);
} else {
  console.log('Loaded:', result.file);
  console.log('Format:', result.rez.format());
}
const resumes = HMR.ResumeFactory.load(['resume1.json', 'resume2.json'], { format: 'FRESH', objectify: true });
```

--------------------------------

### Perform Resume Analysis Programmatically

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Shows how to use the analyze verb to extract resume metrics, including section totals, employment coverage, and keyword frequency, processing the results via a promise.

```javascript
const HMR = require('hackmyresume');
const analyzeVerb = new HMR.verbs.analyze();
analyzeVerb.on('hmr:status', (eventType, data) => {
  if (eventType === 'afterAnalyze') {
    const { info } = data;
    console.log('Sections:', info.totals);
    console.log('Coverage:', { totalDays: info.coverage.totals.total, employedDays: info.coverage.totals.work, gaps: info.coverage.gaps, overlaps: info.coverage.overlaps });
    console.log('Top keywords:', info.keywords);
  }
});
const promise = analyzeVerb.invoke(['resume.json'], [], { private: false });
promise.then((results) => {
  results.forEach((analysis, idx) => {
    console.log(`Resume ${idx + 1} analysis:`, analysis);
  });
});
```

--------------------------------

### Specify Complex Options via External File

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Builds a resume using options defined in an external JSON file. The `-o` or `--opts` flag allows for complex configurations to be managed separately, improving readability and reusability of command-line arguments.

```bash
hackmyresume BUILD resume.json TO out/resume.html -o options.json
```

--------------------------------

### Using JavaScript Object Literal Syntax for Options

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Demonstrates how to pass raw JSON or JavaScript object literal syntax directly on the command line for the --options switch. This allows for inline configuration of HackMyResume.

```bash
hackmyresume build resume.json -o "{ theme: 'compact', silent: 'true' }"
```

--------------------------------

### HackMyResume CLI Usage with Options File

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Demonstrates command-line interface usage of HackMyResume, showing how to specify an external options file for configuration during the build process. This is useful for managing different resume generation settings.

```bash
hackmyresume build resume.json TO out/resume.all -o .hackmyrc
hackmyresume build resume.json TO out/resume.all --options config/options.json
```

--------------------------------

### Manage FRESH Format Resumes

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Covers creating, parsing, validating, and transforming resumes using the FRESHResume class. Includes methods for computing values and saving in different formats.

```javascript
const HMR = require('hackmyresume');
const fs = require('fs');
const newResume = HMR.FRESHResume.default();
newResume.name = 'Jane Developer';
newResume.save('my-resume.json');
const jsonData = fs.readFileSync('resume.json', 'utf8');
const resume = new HMR.FRESHResume().parse(jsonData, { date: true, sort: true, compute: true });
if (resume.isValid()) {
  console.log('Resume is valid!');
}
resume.saveAs('output-jrs.json', 'JRS');
```

--------------------------------

### Build Themed Resumes with HackMyResume CLI

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Transforms a source resume JSON file into various output formats (HTML, PDF, DOC, MD, TXT) using customizable themes. Supports merging multiple source files and specifying PDF engines.

```bash
hackmyresume build resume.json TO out/resume.all
```

```bash
hackmyresume build resume.json TO out/resume.html
```

```bash
hackmyresume build resume.json TO out/resume.pdf
```

```bash
hackmyresume build resume.json TO out/resume.doc
```

```bash
hackmyresume build resume.json TO out/resume.md
```

```bash
hackmyresume build resume.json TO out/resume.txt
```

```bash
hackmyresume build resume.json TO out/resume.all -t compact
```

```bash
hackmyresume build resume.json TO out/resume.all -t node_modules/jsonresume-theme-classy
```

```bash
hackmyresume build resume.json TO out/resume.html out/resume.pdf out/resume.doc
```

```bash
hackmyresume build base.json specific.json TO out/resume.all
```

```bash
hackmyresume build resume.json TO out/resume.all --private
```

```bash
hackmyresume build resume.json TO out/resume.pdf --pdf wkhtmltopdf
```

--------------------------------

### Create New Resume with HackMyResume CLI

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Generates a new, blank resume document in either FRESH (default) or JSON Resume format. Multiple files can be created at once.

```bash
hackmyresume new resume.json
```

```bash
hackmyresume new resume.json -f jrs
```

```bash
hackmyresume new personal.json work.json academic.json -f fresh
```

--------------------------------

### Build Resume with CSS Linking Option

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Builds a resume and specifies how CSS should be handled for HTML output. The `--css=link` option instructs HackMyResume to link to external CSS files instead of embedding them directly into the HTML. This is useful for managing stylesheets separately.

```bash
hackmyresume BUILD resume.json TO out/resume.all --css=link
```

--------------------------------

### Manage JSON Resume (JRS) Format Resumes

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Demonstrates working with the JRSResume class to create, load, and manipulate resumes following the JSON Resume schema.

```javascript
const HMR = require('hackmyresume');
const fs = require('fs');
const newResume = HMR.JRSResume.default();
newResume.basics = { name: 'John Developer', label: 'Senior Software Engineer' };
newResume.save('my-jrs-resume.json');
const jsonData = fs.readFileSync('resume.json', 'utf8');
const resume = new HMR.JRSResume().parse(jsonData);
console.log('Name:', resume.basics.name);
resume.saveAs('fresh-version.json', 'FRESH');
```

--------------------------------

### View HackMyResume Command Help

Source: https://github.com/hacksalot/hackmyresume/blob/master/src/cli/help/help.txt

The HELP command displays detailed usage information for a specified HackMyResume command. It takes a command name as a parameter and provides insights into its functionality, parameters, and options. This is useful for understanding how to operate other HackMyResume commands effectively.

```bash
hackmyresume help <command>

Example:
   hackmyresume help convert
   hackmyresume help help
```

--------------------------------

### Initialize HackMyResume API

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Demonstrates how to import the HackMyResume module and access its core verbs, classes, and generators for programmatic use.

```javascript
const HMR = require('hackmyresume');
const BuildVerb = HMR.verbs.build;
const AnalyzeVerb = HMR.verbs.analyze;
const ValidateVerb = HMR.verbs.validate;
const ConvertVerb = HMR.verbs.convert;
const CreateVerb = HMR.verbs.new;
const PeekVerb = HMR.verbs.peek;
const FRESHResume = HMR.FRESHResume;
const JRSResume = HMR.JRSResume;
const ResumeFactory = HMR.ResumeFactory;
const HtmlGenerator = HMR.HtmlGenerator;
const PdfGenerator = HMR.HtmlPdfCliGenerator;
const WordGenerator = HMR.WordGenerator;
const MarkdownGenerator = HMR.MarkdownGenerator;
const JsonGenerator = HMR.JsonGenerator;
const YamlGenerator = HMR.YamlGenerator;
const LaTeXGenerator = HMR.LaTeXGenerator;
```

--------------------------------

### HackMyResume CLI: New Command Usage

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Demonstrates how to use the 'new' command in HackMyResume to generate a new resume. It shows the syntax for creating a FRESH-format resume and a JSON Resume (JRS) format resume.

```shell
hackmyresume new resume.json
hackmyresume new resume.json -f jrs
```

--------------------------------

### Customize Section Titles

Source: https://github.com/hacksalot/hackmyresume/blob/master/FAQ.md

Configure custom section titles for FRESH themes by creating a JSON options file and passing it to the build command.

```json
{
  "sectionTitles": {
    "employment": "empleo",
    "skills": "habilidades",
    "education": "educación"
  }
}
```

```bash
hackmyresume BUILD resume.json -o myoptions.json
```

--------------------------------

### Enabling Debug Mode for Stack Traces

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Illustrates how to use the --debug or -d flag to enable extended status and error information, including stack traces, which is useful for troubleshooting.

```bash
hackmyresume build resume.json --debug
```

--------------------------------

### Disable Theme Tips

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Builds a resume and suppresses the display of theme messages and usage tips. The `--no-tips` flag can be used to clean up the output, especially in automated processes.

```bash
hackmyresume build resume.json -t awesome --no-tips
```

--------------------------------

### Convert Resume Formats with HackMyResume

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Converts resumes between FRESH and JSON Resume formats. It accepts multiple input files and generates corresponding output files, auto-detecting input formats.

```bash
hackmyresume convert <INPUTS> <OUTPUTS>
```

--------------------------------

### Inspect Resume Metrics with ANALYZE Command

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Analyzes a resume file to provide metrics such as keyword counts and potential gaps. This is an experimental command that offers insights into the resume's content and structure.

```bash
hackmyresume ANALYZE resume.json
```

--------------------------------

### JRSResume Class - Working with JSON Resume Format

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Details how to work with resumes adhering to the JSON Resume schema using the JRSResume class. Includes creating, loading, parsing, accessing data, and converting to FRESH format.

```APIDOC
## JRSResume Class - Working with JSON Resume Format

Work with JSON Resume schema documents.

```javascript
const HMR = require('hackmyresume');
const fs = require('fs');

// Create a default JSON Resume
const newResume = HMR.JRSResume.default();
newResume.basics = {
  name: 'John Developer',
  label: 'Senior Software Engineer',
  email: 'john@example.com',
  summary: 'Experienced developer specializing in web technologies.'
};
newResume.save('my-jrs-resume.json');

// Load and parse an existing JSON Resume
const jsonData = fs.readFileSync('resume.json', 'utf8');
const resume = new HMR.JRSResume().parse(jsonData);

// Access data using JSON Resume structure
console.log('Name:', resume.basics.name);
console.log('Label:', resume.basics.label);
console.log('Work history:', resume.work?.length || 0, 'positions');

// Convert to FRESH format and save
resume.saveAs('fresh-version.json', 'FRESH');
```
```

--------------------------------

### Analyze Verb - Programmatic Usage

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

This section explains how to use the 'analyze' verb programmatically to run resume analysis and process the resulting metrics, including event handling.

```APIDOC
## Analyze Verb - Programmatic Usage

### Description
Run resume analysis and process the metrics. This example shows how to instantiate the analyze verb, listen for status events, and invoke the analysis command.

### Method
Programmatic API (JavaScript)

### Endpoint
N/A (Programmatic)

### Parameters
N/A (Programmatic)

### Request Example
```javascript
const HMR = require('hackmyresume');

const analyzeVerb = new HMR.verbs.analyze();

analyzeVerb.on('hmr:status', (eventType, data) => {
  if (eventType === 'afterAnalyze') {
    const { info } = data;

    // Section totals
    console.log('Sections:', info.totals);

    // Employment coverage analysis
    console.log('Coverage:', {
      totalDays: info.coverage.totals.total,
      employedDays: info.coverage.totals.work,
      gaps: info.coverage.gaps,
      overlaps: info.coverage.overlaps
    });

    // Keyword frequency
    console.log('Top keywords:', info.keywords);
  }
});

const promise = analyzeVerb.invoke(
  ['resume.json'],
  [],
  { private: false }
);

promise.then((results) => {
  // Results array contains analysis for each input resume
  results.forEach((analysis, idx) => {
    console.log(`Resume ${idx + 1} analysis:`, analysis);
  });
});
```

### Response
#### Success Response (Promise Resolution)
- **results** (array) - An array where each element is the analysis result for a corresponding input resume.
  - **info** (object) - Contains detailed analysis metrics.
    - **totals** (object) - Counts for different resume sections.
    - **coverage** (object) - Analysis of employment history duration and gaps.
      - **totals** (object) - Total and employed days.
      - **gaps** (array) - Detected gaps in employment.
      - **overlaps** (array) - Detected overlaps in employment.
    - **keywords** (array) - Frequently occurring keywords.

#### Response Example
```javascript
// Example output for a single resume analysis:
console.log('Resume 1 analysis:', {
  totals: { employment: 1, education: 1, skills: 2 },
  coverage: {
    totals: { total: 3650, work: 3000 },
    gaps: [],
    overlaps: []
  },
  keywords: ['JavaScript', 'Node.js', 'React']
});
```
```

--------------------------------

### Analyze Resume with HackMyResume CLI

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Analyzes a resume file (or multiple files) for metrics like keyword density, employment gaps, and section totals. Supports inclusion of private fields.

```bash
hackmyresume analyze resume.json
```

```bash
hackmyresume analyze resume1.json resume2.json
```

```bash
hackmyresume analyze resume.json --private
```

--------------------------------

### Convert Resume Formats with HackMyResume CLI

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Converts resume files between FRESH and JSON Resume formats. Supports auto-detection of input format and explicit format specification, including specific schema versions.

```bash
hackmyresume convert fresh-resume.json TO jrs-resume.json
```

```bash
hackmyresume convert resume.json TO converted.json -f JRS
```

```bash
hackmyresume convert resume.json TO converted.json -f FRESH
```

```bash
hackmyresume convert resume.json TO converted.json -f JRS@1
```

```bash
hackmyresume convert r1.json r2.json TO out1.json out2.json
```

--------------------------------

### Analyze Resume with HackMyResume

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Analyzes a resume file for keywords, employment gaps, and other metrics. The output provides a summary of sections, coverage, and keyword mentions.

```bash
hackmyresume analyze <my-resume>.json
```

--------------------------------

### Peek Resume Fields with HackMyResume CLI

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Inspects specific sections or fields of a resume file directly from the command line. Can display the entire resume or targeted fields.

```bash
hackmyresume peek resume.json
```

```bash
hackmyresume peek resume.json info.brief
```

--------------------------------

### Module Overview

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Provides an overview of the HackMyResume Node.js API, including available verbs (commands) and core classes.

```APIDOC
## Module Overview

HackMyResume exposes a Node.js API for programmatic resume manipulation.

```javascript
const HMR = require('hackmyresume');

// Available verbs (commands)
const BuildVerb = HMR.verbs.build;
const AnalyzeVerb = HMR.verbs.analyze;
const ValidateVerb = HMR.verbs.validate;
const ConvertVerb = HMR.verbs.convert;
const CreateVerb = HMR.verbs.new;
const PeekVerb = HMR.verbs.peek;

// Core classes
const FRESHResume = HMR.FRESHResume;
const JRSResume = HMR.JRSResume;
const ResumeFactory = HMR.ResumeFactory;

// Generators
const HtmlGenerator = HMR.HtmlGenerator;
const PdfGenerator = HMR.HtmlPdfCliGenerator;
const WordGenerator = HMR.WordGenerator;
const MarkdownGenerator = HMR.MarkdownGenerator;
const JsonGenerator = HMR.JsonGenerator;
const YamlGenerator = HMR.YamlGenerator;
const LaTeXGenerator = HMR.LaTeXGenerator;
```
```

--------------------------------

### Manage Private Resume Fields

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Tag specific resume entries with "private": true to exclude them from standard builds. Use the --private flag during build to include these fields in the output.

```json
"employment": {
  "history": [
    {
      "employer": "Acme Real Estate"
    },
    {
      "employer": "Area 51 Alien Research Laboratory",
      "private": true
    },
    {
      "employer": "H&R Block"
    }
  ]
}
```

```bash
hackmyresume build resume.json private-resume.all --private
```

--------------------------------

### Apply File-based Options with HackMyResume

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Allows passing options to HackMyResume via an external JSON file using the --options or -o switch. Options in the file can include theme, sectionTitles, and wkhtmltopdf settings. Command-line options override file options.

```bash
hackmyresume build resume.json -o path/to/options.json
```

```json
{
  "theme": "compact",

  "sectionTitles": {
    "employment": "Work"
  },

  "wkhtmltopdf": {
    "margin-top": "20mm"
  }
}
```

```bash
# path/to/options.json specifes the POSITIVE theme
# -t parameter specifies the COMPACT theme
# The -t parameter wins.
hackmyresume build resume.json -o path/to/options.json -t compact
```

--------------------------------

### Disable PDF Generation

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Builds a resume without generating a PDF file. The `--pdf none` option explicitly disables PDF output, which can be useful when only other formats like HTML or Word are required.

```bash
hackmyresume BUILD resume.json TO out/resume.html --pdf none
```

--------------------------------

### VALIDATE command

Source: https://github.com/hacksalot/hackmyresume/blob/master/src/cli/help/validate.txt

Validates one or more FRESH or JRS resume files against their schema.

```APIDOC
## VALIDATE <resume>

### Description
The VALIDATE command checks a FRESH or JRS resume document against its governing schema to ensure it is correctly structured and formatted.

### Method
CLI COMMAND

### Endpoint
hackmyresume VALIDATE <resume> [--assert]

### Parameters
#### Path Parameters
- **resume** (string) - Required - Path to a FRESH or JRS resume file. Multiple files can be provided.

#### Options
- **--assert / -a** (boolean) - Optional - Returns a non-zero process exit code if the resume fails validation.

### Request Example
hackmyresume VALIDATE resume.json

### Response
#### Success Response (0)
- **status** (string) - Validation successful message.

#### Error Response (Non-zero)
- **status** (string) - Validation failed message (triggered if --assert is used).
```

--------------------------------

### Disable Default Validation

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Builds a resume without performing validation prior to generation. The `--novalidate` or `--force` switch bypasses the default validation step, which can speed up the build process for known-good resumes.

```bash
hackmyresume build resume.json --novalidate
```

```bash
hackmyresume build resume.json --force
```

--------------------------------

### FRESH Resume Data Schema

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Defines the structure of a resume document using the FRESH (Freeform Resume Exchange Standard) schema, version 0.6.0.

```APIDOC
## FRESH Resume Structure

### Description
The FRESH schema organizes resume data with clear section separation, providing a standardized format for resume information.

### Method
Schema Definition

### Endpoint
N/A (Schema)

### Parameters
N/A (Schema)

### Request Body
N/A (Schema Definition)

### Request Example
```json
{
  "name": "Jane Developer",
  "meta": {
    "format": "FRESH@0.6.0",
    "version": "1.0.0"
  },
  "info": {
    "label": "Senior Software Engineer",
    "brief": "Full-stack developer with 10+ years of experience building scalable web applications."
  },
  "contact": {
    "email": "jane@example.com",
    "phone": "555-123-4567",
    "website": "https://janedev.io"
  },
  "location": {
    "city": "San Francisco",
    "region": "CA",
    "country": "US"
  },
  "social": [
    { "network": "GitHub", "user": "janedev", "url": "https://github.com/janedev" },
    { "network": "LinkedIn", "user": "janedeveloper", "url": "https://linkedin.com/in/janedeveloper" }
  ],
  "employment": {
    "history": [
      {
        "employer": "Tech Corp",
        "position": "Senior Engineer",
        "url": "https://techcorp.com",
        "start": "2020-01",
        "end": "current",
        "summary": "Lead backend development team.",
        "highlights": [
          "Designed microservices architecture serving 1M+ requests/day",
          "Reduced deployment time by 75% with CI/CD pipeline"
        ],
        "keywords": ["Node.js", "Python", "AWS", "Kubernetes"]
      }
    ]
  },
  "education": {
    "history": [
      {
        "institution": "MIT",
        "studyType": "Bachelor",
        "area": "Computer Science",
        "start": "2006-09",
        "end": "2010-05",
        "grade": "3.8"
      }
    ]
  },
  "skills": {
    "sets": [
      {
        "name": "Backend Development",
        "level": "Master",
        "skills": ["Node.js", "Python", "Go", "PostgreSQL", "Redis"]
      },
      {
        "name": "DevOps",
        "level": "Advanced",
        "skills": ["Docker", "Kubernetes", "AWS", "Terraform", "CI/CD"]
      }
    ]
  },
  "writing": [
    {
      "title": "Scaling Node.js Applications",
      "publisher": "Tech Blog",
      "date": "2023-06",
      "url": "https://blog.example.com/scaling-nodejs"
    }
  ],
  "recognition": [
    {
      "title": "Employee of the Year",
      "date": "2022",
      "from": "Tech Corp"
    }
  ]
}
```

### Response
N/A (Schema Definition)

### Response Example
N/A (Schema Definition)
```

--------------------------------

### Define Private Fields in Resume JSON

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Demonstrates how to mark specific resume sections as private by adding the "private": true property. Fields marked this way will be excluded from the generated output.

```json
"employment": {
  "history": [
    {
      "employer": "Acme Real Estate"
    },
    {
      "employer": "Area 51 Alien Research Laboratory",
      "private": true
    },
    {
      "employer": "H&R Block"
    }
  ]
}
```

--------------------------------

### Treat Validation Errors as Warnings

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Validates a resume file but treats validation errors as warnings rather than fatal errors. The `--assert` switch is specific to the VALIDATE command and allows for more lenient validation checks.

```bash
hackmyresume validate resume.json --assert
```

--------------------------------

### Generating PDF Output with Multiple Engines

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Highlights HackMyResume's capability to generate PDF output using various engines like Phantom, wkhtmltopdf, etc., by interacting with them via their command-line interfaces.

```bash
hackmyresume build resume.json --pdf
```

--------------------------------

### Validate Resume via CLI

Source: https://github.com/hacksalot/hackmyresume/blob/master/src/cli/help/validate.txt

Executes the validation process for one or more resume files. The --assert flag can be used to integrate validation into CI/CD pipelines by returning a non-zero exit code on failure.

```bash
hackmyresume VALIDATE resume.json
hackmyresume VALIDATE r1.json r2.json r3.json --assert
```

--------------------------------

### Validate Resume with HackMyResume CLI

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Validates a resume file (or multiple files) against the FRESH or JSON Resume schema. The --assert flag can be used for CI/CD pipelines to return a non-zero exit code on failure.

```bash
hackmyresume validate resume.json
```

```bash
hackmyresume validate resume1.json resume2.json resume3.json
```

```bash
hackmyresume validate resume.json --assert
```

--------------------------------

### JSON Resume Schema Structure

Source: https://context7.com/hacksalot/hackmyresume/llms.txt

Defines the structure of a resume using the JSON Resume schema, a flatter format with a 'basics' root object. It includes sections for personal information, work experience, education, skills, languages, awards, and publications.

```json
{
  "basics": {
    "name": "John Developer",
    "label": "Full Stack Developer",
    "picture": "https://example.com/photo.jpg",
    "email": "john@example.com",
    "phone": "(555) 123-4567",
    "website": "https://johndeveloper.com",
    "summary": "Passionate developer with expertise in modern web technologies.",
    "location": {
      "address": "123 Main St",
      "postalCode": "94102",
      "city": "San Francisco",
      "countryCode": "US",
      "region": "California"
    },
    "profiles": [
      {
        "network": "GitHub",
        "username": "johndev",
        "url": "https://github.com/johndev"
      }
    ]
  },
  "work": [
    {
      "company": "Startup Inc",
      "position": "Lead Developer",
      "website": "https://startup.io",
      "startDate": "2019-03-01",
      "endDate": "2023-12-31",
      "summary": "Led development of core platform features.",
      "highlights": [
        "Built real-time collaboration features used by 50K+ users",
        "Mentored team of 5 junior developers"
      ]
    }
  ],
  "education": [
    {
      "institution": "Stanford University",
      "area": "Computer Science",
      "studyType": "Master",
      "startDate": "2015-09-01",
      "endDate": "2017-06-15",
      "gpa": "3.9",
      "courses": ["CS229 - Machine Learning", "CS231N - Deep Learning"]
    }
  ],
  "skills": [
    {
      "name": "Frontend",
      "level": "Master",
      "keywords": ["React", "TypeScript", "Vue.js", "CSS", "Webpack"]
    },
    {
      "name": "Backend",
      "level": "Advanced",
      "keywords": ["Node.js", "Express", "GraphQL", "REST APIs"]
    }
  ],
  "languages": [
    { "language": "English", "fluency": "Native" },
    { "language": "Spanish", "fluency": "Professional" }
  ],
  "awards": [
    {
      "title": "Best Innovation Award",
      "date": "2022-11-15",
      "awarder": "Tech Conference 2022",
      "summary": "Awarded for innovative use of AI in developer tools."
    }
  ],
  "publications": [
    {
      "name": "Building Scalable APIs",
      "publisher": "O'Reilly Media",
      "releaseDate": "2021-03-01",
      "website": "https://oreilly.com/library/view/building-scalable-apis",
      "summary": "Comprehensive guide to designing and implementing scalable REST APIs."
    }
  ]
}
```

--------------------------------

### Register Custom Handlebars Helpers

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Add custom logic to themes by defining paths to JavaScript files in the helpers array within theme.json. HackMyResume will register these with Handlebars automatically.

```json
{
  "title": "my-cool-theme",
  "helpers": [
    "../path/to/helpers/*.js",
    "some-other-helper.js"
  ]
}
```

--------------------------------

### Validate Resume with Line and Column Info

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Validates a FRESH or JRS resume and emits detailed syntax error information, including line and column numbers. This aids in pinpointing and correcting syntax issues within the resume files.

```bash
hackmyresume validate resume.fresh
```

```bash
hackmyresume validate resume.json
```

--------------------------------

### Validate Resume with HackMyResume

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Validates one or more resume files against the FRESH/FRESCA or JSON Resume formats. The command indicates whether each specified resume is valid or invalid.

```bash
# Validate myresume.json against either the FRESH or JSON Resume schema.
hackmyresume validate resumeA.json resumeB.json
```

--------------------------------

### Distinguish Validation and Syntax Errors

Source: https://github.com/hacksalot/hackmyresume/blob/master/CHANGELOG.md

Validates a FRESH or JRS resume, distinguishing between semantic validation errors and pure syntax errors. This provides clearer feedback on the nature of issues found in the resume file.

```bash
hackmyresume validate resume.fresh
```

--------------------------------

### Disable HTML Prettification with HackMyResume

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Disables the default js-beautify style HTML prettification for generated HTML resumes using the --no-prettify or -n flag.

```bash
hackmyresume build resume.json out.all --no-prettify
```

--------------------------------

### Enable Debug Mode in HackMyResume

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Use the debug flag to force the application to emit call stacks during errors. This helps in troubleshooting build or analysis processes.

```bash
hackmyresume build resume.json -d
hackmyresume analyze resume.json --debug
```

--------------------------------

### Run HackMyResume in Silent Mode

Source: https://github.com/hacksalot/hackmyresume/blob/master/README.md

Executes HackMyResume commands in silent mode, suppressing most output, using the -s or --silent flags.

```bash
hackmyresume build resume.json -o someFile.all -s
```

```bash
hackmyresume build resume.json -o someFile.all --silent
```