resume-cli 3.2.0 → 3.4.0

package/README.md

@@ -24,7 +24,7 @@ npm install -g resume-cli
 |---|---|
 | init | Initialize a `resume.json` file. |
 | validate | Schema validation test your `resume.json`. |
-| export path/to/file.html | Export to `.html`. |
+| export path/to/file.html | Export to `.html`, `.pdf`, `.md` or `.txt`. |
 | serve | Serve resume at `http://localhost:4000/`. |
 
 ### `resume --help`
@@ -43,9 +43,30 @@ Validates your `resume.json` against our schema to ensure it complies with the s
 
 ### `resume export [fileName]`
 
-Exports your resume in a stylized HTML or PDF format.
+Exports your resume to one of four formats:
 
-A list of available themes can be found here:  
+- `.html` / `.pdf` — stylized output rendered through a theme.
+- `.md` — clean Markdown (one heading per section). No theme required.
+- `.txt` — readable plain text. No theme required.
+
+The format is inferred from the file extension, or set it explicitly with
+`--format`:
+
+```
+resume export resume.md                  # Markdown (inferred)
+resume export resume.txt --format text   # plain text (explicit)
+resume export resume.html --theme even   # themed HTML
+resume export resume.pdf --theme even    # themed PDF
+```
+
+`--format` accepts `html`, `pdf`, `markdown` (or `md`) and `text` (or `txt`).
+
+The Markdown and text formats render every JSON Resume section that is present
+(basics, work, volunteer, education, awards, publications, skills, languages,
+interests, references, projects) and skip any that are missing — so no theme
+install is needed.
+
+A list of available themes (for `.html` / `.pdf`) can be found here:  
 https://jsonresume.org/themes/
 
 Please npm install the theme you wish to use before attempting to export it.
@@ -53,7 +74,7 @@ Please npm install the theme you wish to use before attempting to export it.
 Options:
 
 - `--format <file type>` Example: `--format pdf`
-- `--theme <name>` Example: `--theme even`
+- `--theme <name>` Example: `--theme even` (only used for `.html` / `.pdf`)
 
 ### `resume serve`
 

package/build/builder.js

@@ -5,6 +5,10 @@ const fs = require('fs');
 const request = require('superagent');
 const chalk = require('chalk');
 const renderHtml = require('./render-html').default;
+const {
+  ThemeNotFoundError,
+  formatThemeNotFound
+} = require('./theme-errors');
 const denormalizeTheme = value => {
   return value.match(/jsonresume-theme-(.*)/)[1];
 };
@@ -45,7 +49,13 @@ module.exports = function resumeBuilder(theme, dir, resumeFilename, cb) {
       });
       cb(null, html);
     } catch (err) {
-      console.log(err);
+      if (err instanceof ThemeNotFoundError) {
+        // Theme isn't installed locally. Show an actionable message, then fall
+        // back to the hosted theme server (preserving existing behavior).
+        console.log(formatThemeNotFound(err.theme));
+      } else {
+        console.log(err);
+      }
       console.log(chalk.yellow('Could not run the render function from local theme.'));
       sendExportHTML(resumeJson, theme, cb);
     }

package/build/export-resume.js

@@ -8,6 +8,32 @@ const writeFile = (0, _util.promisify)(_fs.default.writeFile);
 const path = require('path');
 const puppeteer = require('puppeteer');
 const btoa = require('btoa');
+const {
+  ThemeNotFoundError
+} = require('./theme-errors');
+const toMarkdown = require('./formatters/markdown');
+const toText = require('./formatters/text');
+
+// Theme-less formatters keyed by their normalized format. The value pairs the
+// pure renderer with the file extension used on disk.
+const THEMELESS_FORMATTERS = {
+  md: {
+    render: toMarkdown,
+    ext: '.md'
+  },
+  markdown: {
+    render: toMarkdown,
+    ext: '.md'
+  },
+  txt: {
+    render: toText,
+    ext: '.txt'
+  },
+  text: {
+    render: toText,
+    ext: '.txt'
+  }
+};
 module.exports = ({
   resume: resumeJson,
   fileName,
@@ -21,17 +47,29 @@ module.exports = ({
   const fileNameAndFormat = getFileNameAndFormat(fileName, format);
   fileName = fileNameAndFormat.fileName;
   const fileFormatToUse = fileNameAndFormat.fileFormatToUse;
+  const themeless = THEMELESS_FORMATTERS[(fileFormatToUse || '').toLowerCase()];
+  if (themeless) {
+    createThemeless(resumeJson, fileName, themeless, error => {
+      if (error) {
+        console.error(error, '`createThemeless` errored out');
+      }
+      callback(error, fileName, themeless.ext);
+    });
+    return;
+  }
   const formatToUse = '.' + fileFormatToUse;
   if (formatToUse === '.html') {
     createHtml(resumeJson, fileName, theme, formatToUse, error => {
-      if (error) {
+      // ThemeNotFoundError is reported as a friendly message by the caller;
+      // don't dump the raw object here.
+      if (error && !(error instanceof ThemeNotFoundError)) {
         console.error(error, '`createHtml` errored out');
       }
       callback(error, fileName, formatToUse);
     });
   } else if (formatToUse === '.pdf') {
     createPdf(resumeJson, fileName, theme, formatToUse, error => {
-      if (error) {
+      if (error && !(error instanceof ThemeNotFoundError)) {
         console.error(error, '`createPdf` errored out');
       }
       callback(error, fileName, formatToUse);
@@ -58,16 +96,24 @@ const getThemePkg = theme => {
     const themePkg = require(theme);
     return themePkg;
   } catch (err) {
-    // Theme not installed
-    console.log('You have to install this theme relative to the folder to use it e.g. `npm install ' + theme + '`');
-    process.exit();
+    // Theme not installed. Throw a typed error so the caller can render an
+    // actionable, stack-trace-free message and exit with a non-zero code.
+    throw new ThemeNotFoundError(theme);
   }
 };
 async function createHtml(resumeJson, fileName, themePath, format, callback) {
-  const html = await (0, _renderHtml.default)({
-    resume: resumeJson,
-    themePath
-  });
+  let html;
+  try {
+    html = await (0, _renderHtml.default)({
+      resume: resumeJson,
+      themePath
+    });
+  } catch (err) {
+    // Surface theme-resolution (and other render) failures to the caller so
+    // they can be reported as an actionable message rather than an
+    // unhandled-rejection stack trace.
+    return callback(err);
+  }
   const pathToStream = path.resolve(process.cwd(), fileName + format);
   await writeFile(pathToStream, ''); // workaround for https://github.com/streamich/unionfs/issues/428
   const stream = _fs.default.createWriteStream(pathToStream);
@@ -75,6 +121,17 @@ async function createHtml(resumeJson, fileName, themePath, format, callback) {
     stream.close(callback);
   });
 }
+// Render a resume with a pure (theme-less) formatter and write it to disk.
+async function createThemeless(resumeJson, fileName, formatter, callback) {
+  try {
+    const output = formatter.render(resumeJson);
+    const pathToStream = path.resolve(process.cwd(), fileName + formatter.ext);
+    await writeFile(pathToStream, output);
+    callback(null);
+  } catch (err) {
+    callback(err);
+  }
+}
 const createPdf = (resumeJson, fileName, theme, format, callback) => {
   (async () => {
     const themePkg = getThemePkg(theme);

package/build/formatters/markdown.js

@@ -0,0 +1,118 @@
+"use strict";
+
+// Pure Markdown formatter for a JSON Resume. No external theme required.
+// Renders every JSON Resume schema section that is present, and silently
+// skips sections that are missing or empty so partial resumes work too.
+
+const {
+  isNonEmptyArray,
+  dateRange,
+  contactParts,
+  section
+} = require('./utils');
+const link = (label, url) => url ? `[${label}](${url})` : label;
+const sec = (title, items, renderItem) => section([`## ${title}`], items, renderItem);
+const highlights = items => isNonEmptyArray(items) ? items.map(h => `- ${h}`) : [];
+const csv = keywords => isNonEmptyArray(keywords) ? [keywords.join(', ')] : [];
+const italic = text => text ? [`*${text}*`] : [];
+const basics = resume => {
+  const b = resume.basics;
+  if (!b) {
+    return [];
+  }
+  const lines = [];
+  if (b.name) {
+    lines.push(`# ${b.name}`);
+  }
+  if (b.label) {
+    lines.push(`> ${b.label}`);
+  }
+  const contact = contactParts(b);
+  if (contact.length) {
+    lines.push(contact.join(' | '));
+  }
+  if (isNonEmptyArray(b.profiles)) {
+    const profiles = b.profiles.map(p => link(p.network || p.username || p.url, p.url)).filter(Boolean);
+    if (profiles.length) {
+      lines.push(profiles.join(' | '));
+    }
+  }
+  if (b.summary) {
+    lines.push('', b.summary);
+  }
+  return lines;
+};
+const work = resume => sec('Work', resume.work, w => {
+  const heading = [w.position, w.name || w.company].filter(Boolean).join(', ');
+  const lines = [`### ${link(heading || 'Role', w.url)}`];
+  lines.push(...italic(dateRange(w.startDate, w.endDate)));
+  if (w.summary) {
+    lines.push('', w.summary);
+  }
+  return lines.concat(highlights(w.highlights));
+});
+const volunteer = resume => sec('Volunteer', resume.volunteer, v => {
+  const heading = [v.position, v.organization].filter(Boolean).join(', ');
+  const lines = [`### ${link(heading || 'Volunteer', v.url)}`];
+  lines.push(...italic(dateRange(v.startDate, v.endDate)));
+  if (v.summary) {
+    lines.push('', v.summary);
+  }
+  return lines.concat(highlights(v.highlights));
+});
+const education = resume => sec('Education', resume.education, e => {
+  const study = [e.studyType, e.area].filter(Boolean).join(', ');
+  const title = [e.institution, study].filter(Boolean).join(' — ');
+  const lines = [`### ${link(title || 'Education', e.url)}`];
+  lines.push(...italic(dateRange(e.startDate, e.endDate)));
+  if (e.score) {
+    lines.push(`Score: ${e.score}`);
+  }
+  if (isNonEmptyArray(e.courses)) {
+    lines.push('', ...e.courses.map(c => `- ${c}`));
+  }
+  return lines;
+});
+const awards = resume => sec('Awards', resume.awards, a => {
+  const lines = [`### ${a.title || 'Award'}`];
+  lines.push(...italic([a.awarder, a.date].filter(Boolean).join(' — ')));
+  if (a.summary) {
+    lines.push('', a.summary);
+  }
+  return lines;
+});
+const publications = resume => sec('Publications', resume.publications, p => {
+  const lines = [`### ${link(p.name || 'Publication', p.url)}`];
+  lines.push(...italic([p.publisher, p.releaseDate].filter(Boolean).join(' — ')));
+  if (p.summary) {
+    lines.push('', p.summary);
+  }
+  return lines;
+});
+const skills = resume => sec('Skills', resume.skills, s => {
+  const heading = [s.name, s.level].filter(Boolean).join(' — ');
+  return [`### ${heading || 'Skill'}`].concat(csv(s.keywords));
+});
+const languages = resume => sec('Languages', resume.languages, l => [`- ${[l.language, l.fluency].filter(Boolean).join(' — ')}`]);
+const interests = resume => sec('Interests', resume.interests, i => [`### ${i.name || 'Interest'}`].concat(csv(i.keywords)));
+const references = resume => sec('References', resume.references, r => {
+  const lines = [`### ${r.name || 'Reference'}`];
+  if (r.reference) {
+    lines.push('', `> ${r.reference}`);
+  }
+  return lines;
+});
+const projects = resume => sec('Projects', resume.projects, p => {
+  const lines = [`### ${link(p.name || 'Project', p.url)}`];
+  lines.push(...italic(dateRange(p.startDate, p.endDate)));
+  if (p.description) {
+    lines.push('', p.description);
+  }
+  return lines.concat(highlights(p.highlights)).concat(csv(p.keywords));
+});
+const toMarkdown = (resume = {}) => {
+  const lines = [...basics(resume), ...work(resume), ...volunteer(resume), ...education(resume), ...awards(resume), ...publications(resume), ...skills(resume), ...languages(resume), ...interests(resume), ...references(resume), ...projects(resume)];
+  return `${lines.join('\n').trim()}\n`;
+};
+module.exports = toMarkdown;
+module.exports.toMarkdown = toMarkdown;

package/build/formatters/markdown.test.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _markdown = _interopRequireDefault(require("./markdown"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const sample = require('@jsonresume/schema/sample.resume.json');
+describe('markdown formatter', () => {
+  describe('against the bundled sample resume', () => {
+    let md;
+    beforeAll(() => {
+      md = (0, _markdown.default)(sample);
+    });
+    it('returns a non-empty string ending in a newline', () => {
+      expect(typeof md).toBe('string');
+      expect(md.length).toBeGreaterThan(0);
+      expect(md.endsWith('\n')).toBe(true);
+    });
+    it('renders the person name as the top-level heading', () => {
+      expect(md).toContain('# Richard Hendriks');
+    });
+    it('renders a heading for every populated section', () => {
+      ['## Work', '## Volunteer', '## Education', '## Awards', '## Publications', '## Skills', '## Languages', '## Interests', '## References', '## Projects'].forEach(heading => {
+        expect(md).toContain(heading);
+      });
+    });
+    it('renders entry details, highlights and keywords', () => {
+      expect(md).toContain('Pied Piper');
+      expect(md).toContain('CEO/President');
+      expect(md).toContain('- Successfully won Techcrunch Disrupt');
+      expect(md).toContain('University of Oklahoma');
+      expect(md).toContain('Miss Direction');
+      expect(md).toContain('HTML, CSS, Javascript');
+      expect(md).toContain('English — Native speaker');
+    });
+    it('links urls using markdown link syntax', () => {
+      expect(md).toContain('](http://piedpiper.example.com)');
+    });
+  });
+  describe('with missing / partial sections', () => {
+    it('handles an empty resume without throwing', () => {
+      expect(() => (0, _markdown.default)({})).not.toThrow();
+      expect(() => (0, _markdown.default)()).not.toThrow();
+    });
+    it('omits sections that are absent', () => {
+      const md = (0, _markdown.default)({
+        basics: {
+          name: 'Jane Doe'
+        }
+      });
+      expect(md).toContain('# Jane Doe');
+      expect(md).not.toContain('## Work');
+      expect(md).not.toContain('## Skills');
+    });
+    it('omits sections that are present but empty', () => {
+      const md = (0, _markdown.default)({
+        basics: {
+          name: 'Jane Doe'
+        },
+        work: []
+      });
+      expect(md).not.toContain('## Work');
+    });
+  });
+});

package/build/formatters/text.js

@@ -0,0 +1,144 @@
+"use strict";
+
+// Pure plain-text formatter for a JSON Resume. No external theme required.
+// Renders every JSON Resume schema section that is present, and silently
+// skips sections that are missing or empty so partial resumes work too.
+
+const {
+  isNonEmptyArray,
+  dateRange,
+  contactParts,
+  section
+} = require('./utils');
+const heading = text => [text.toUpperCase(), '='.repeat(text.length)];
+const sec = (title, items, renderItem) => section(heading(title), items, renderItem);
+const bullets = items => isNonEmptyArray(items) ? items.map(i => `  * ${i}`) : [];
+const csv = keywords => isNonEmptyArray(keywords) ? [`  ${keywords.join(', ')}`] : [];
+const basics = resume => {
+  const b = resume.basics;
+  if (!b) {
+    return [];
+  }
+  const lines = [];
+  if (b.name) {
+    lines.push(b.name);
+  }
+  if (b.label) {
+    lines.push(b.label);
+  }
+  const contact = contactParts(b);
+  if (contact.length) {
+    lines.push(contact.join(' | '));
+  }
+  if (isNonEmptyArray(b.profiles)) {
+    b.profiles.forEach(p => {
+      const label = [p.network, p.username].filter(Boolean).join(' ');
+      const parts = [label, p.url].filter(Boolean);
+      if (parts.length) {
+        lines.push(parts.join(': '));
+      }
+    });
+  }
+  if (b.summary) {
+    lines.push('', b.summary);
+  }
+  return lines;
+};
+const work = resume => sec('Work', resume.work, w => {
+  const title = [w.position, w.name || w.company].filter(Boolean).join(' @ ');
+  const lines = [title || 'Role'];
+  const range = dateRange(w.startDate, w.endDate);
+  if (range) {
+    lines.push(range);
+  }
+  if (w.url) {
+    lines.push(w.url);
+  }
+  if (w.summary) {
+    lines.push(w.summary);
+  }
+  return lines.concat(bullets(w.highlights));
+});
+const volunteer = resume => sec('Volunteer', resume.volunteer, v => {
+  const title = [v.position, v.organization].filter(Boolean).join(' @ ');
+  const lines = [title || 'Volunteer'];
+  const range = dateRange(v.startDate, v.endDate);
+  if (range) {
+    lines.push(range);
+  }
+  if (v.summary) {
+    lines.push(v.summary);
+  }
+  return lines.concat(bullets(v.highlights));
+});
+const education = resume => sec('Education', resume.education, e => {
+  const study = [e.studyType, e.area].filter(Boolean).join(', ');
+  const title = [e.institution, study].filter(Boolean).join(' - ');
+  const lines = [title || 'Education'];
+  const range = dateRange(e.startDate, e.endDate);
+  if (range) {
+    lines.push(range);
+  }
+  if (e.score) {
+    lines.push(`Score: ${e.score}`);
+  }
+  return lines.concat(bullets(e.courses));
+});
+const awards = resume => sec('Awards', resume.awards, a => {
+  const lines = [a.title || 'Award'];
+  const meta = [a.awarder, a.date].filter(Boolean).join(' - ');
+  if (meta) {
+    lines.push(meta);
+  }
+  if (a.summary) {
+    lines.push(a.summary);
+  }
+  return lines;
+});
+const publications = resume => sec('Publications', resume.publications, p => {
+  const lines = [p.name || 'Publication'];
+  const meta = [p.publisher, p.releaseDate].filter(Boolean).join(' - ');
+  if (meta) {
+    lines.push(meta);
+  }
+  if (p.url) {
+    lines.push(p.url);
+  }
+  if (p.summary) {
+    lines.push(p.summary);
+  }
+  return lines;
+});
+const skills = resume => sec('Skills', resume.skills, s => {
+  const title = [s.name, s.level].filter(Boolean).join(' - ');
+  return [title || 'Skill'].concat(csv(s.keywords));
+});
+const languages = resume => sec('Languages', resume.languages, l => [`  * ${[l.language, l.fluency].filter(Boolean).join(' - ')}`]);
+const interests = resume => sec('Interests', resume.interests, i => [i.name || 'Interest'].concat(csv(i.keywords)));
+const references = resume => sec('References', resume.references, r => {
+  const lines = [r.name || 'Reference'];
+  if (r.reference) {
+    lines.push(r.reference);
+  }
+  return lines;
+});
+const projects = resume => sec('Projects', resume.projects, p => {
+  const lines = [p.name || 'Project'];
+  const range = dateRange(p.startDate, p.endDate);
+  if (range) {
+    lines.push(range);
+  }
+  if (p.url) {
+    lines.push(p.url);
+  }
+  if (p.description) {
+    lines.push(p.description);
+  }
+  return lines.concat(bullets(p.highlights)).concat(csv(p.keywords));
+});
+const toText = (resume = {}) => {
+  const lines = [...basics(resume), ...work(resume), ...volunteer(resume), ...education(resume), ...awards(resume), ...publications(resume), ...skills(resume), ...languages(resume), ...interests(resume), ...references(resume), ...projects(resume)];
+  return `${lines.join('\n').trim()}\n`;
+};
+module.exports = toText;
+module.exports.toText = toText;

package/build/formatters/text.test.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _text = _interopRequireDefault(require("./text"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const sample = require('@jsonresume/schema/sample.resume.json');
+describe('text formatter', () => {
+  describe('against the bundled sample resume', () => {
+    let txt;
+    beforeAll(() => {
+      txt = (0, _text.default)(sample);
+    });
+    it('returns a non-empty string ending in a newline', () => {
+      expect(typeof txt).toBe('string');
+      expect(txt.length).toBeGreaterThan(0);
+      expect(txt.endsWith('\n')).toBe(true);
+    });
+    it('renders the person name', () => {
+      expect(txt).toContain('Richard Hendriks');
+    });
+    it('renders an underlined heading for every populated section', () => {
+      ['WORK', 'VOLUNTEER', 'EDUCATION', 'AWARDS', 'PUBLICATIONS', 'SKILLS', 'LANGUAGES', 'INTERESTS', 'REFERENCES', 'PROJECTS'].forEach(heading => {
+        expect(txt).toContain(heading);
+      });
+      // headings are underlined with '=' rules
+      expect(txt).toContain('====');
+    });
+    it('renders entry details, highlights and keywords', () => {
+      expect(txt).toContain('CEO/President @ Pied Piper');
+      expect(txt).toContain('  * Successfully won Techcrunch Disrupt');
+      expect(txt).toContain('University of Oklahoma');
+      expect(txt).toContain('Miss Direction');
+      expect(txt).toContain('HTML, CSS, Javascript');
+      expect(txt).toContain('English - Native speaker');
+    });
+    it('does not contain markdown markup', () => {
+      expect(txt).not.toContain('# ');
+      expect(txt).not.toContain('](');
+    });
+  });
+  describe('with missing / partial sections', () => {
+    it('handles an empty resume without throwing', () => {
+      expect(() => (0, _text.default)({})).not.toThrow();
+      expect(() => (0, _text.default)()).not.toThrow();
+    });
+    it('omits sections that are absent', () => {
+      const txt = (0, _text.default)({
+        basics: {
+          name: 'Jane Doe'
+        }
+      });
+      expect(txt).toContain('Jane Doe');
+      expect(txt).not.toContain('WORK');
+      expect(txt).not.toContain('SKILLS');
+    });
+    it('omits sections that are present but empty', () => {
+      const txt = (0, _text.default)({
+        basics: {
+          name: 'Jane Doe'
+        },
+        work: []
+      });
+      expect(txt).not.toContain('WORK');
+    });
+  });
+});

package/build/formatters/utils.js

@@ -0,0 +1,53 @@
+"use strict";
+
+// Shared helpers for the theme-less resume formatters (markdown + text).
+
+const isNonEmptyArray = value => Array.isArray(value) && value.length > 0;
+const dateRange = (startDate, endDate) => {
+  if (!startDate && !endDate) {
+    return '';
+  }
+  return `${startDate || ''} - ${endDate || 'Present'}`;
+};
+
+// Flatten a contact line out of basics: email, phone, url and a one-line
+// location. Returns an array of fragments (caller decides the separator).
+const contactParts = (basics = {}) => {
+  const parts = [];
+  if (basics.email) {
+    parts.push(basics.email);
+  }
+  if (basics.phone) {
+    parts.push(basics.phone);
+  }
+  if (basics.url) {
+    parts.push(basics.url);
+  }
+  const loc = basics.location;
+  if (loc) {
+    const locParts = [loc.address, loc.city, loc.region, loc.postalCode, loc.countryCode].filter(Boolean);
+    if (locParts.length) {
+      parts.push(locParts.join(', '));
+    }
+  }
+  return parts;
+};
+
+// Build a section block: returns [] when there are no items, otherwise the
+// `headerLines` followed by each rendered item (separated by a blank line).
+const section = (headerLines, items, renderItem) => {
+  if (!isNonEmptyArray(items)) {
+    return [];
+  }
+  const lines = ['', ...headerLines];
+  items.forEach(item => {
+    lines.push('', ...renderItem(item));
+  });
+  return lines;
+};
+module.exports = {
+  isNonEmptyArray,
+  dateRange,
+  contactParts,
+  section
+};

package/build/main.js

@@ -13,6 +13,10 @@ const serve = require('./serve');
 const program = require('commander');
 const chalk = require('chalk');
 const path = require('path');
+const {
+  ThemeNotFoundError,
+  formatThemeNotFound
+} = require('./theme-errors');
 const normalizeTheme = (value, defaultValue) => {
   const theme = value || defaultValue;
   // TODO - This is not great, but bypasses this function if it is a relative path
@@ -22,7 +26,7 @@ const normalizeTheme = (value, defaultValue) => {
   return theme.match('jsonresume-theme-.*') ? theme : `jsonresume-theme-${theme}`;
 };
 (async () => {
-  program.name('resume').usage('[command] [options]').version(pkg.version).option('-F, --force', 'Used by `publish` and `export` - bypasses schema testing.').option('-t, --theme <theme name>', 'Specify theme used by `export` and `serve` or specify a path starting with . (use . for current directory or ../some/other/dir)', normalizeTheme, 'jsonresume-theme-elegant').option('-f, --format <file type extension>', 'Used by `export`.').option('-r, --resume <resume filename>', "path to the resume in json format. Use '-' to read from stdin", 'resume.json').option('-p, --port <port>', 'Used by `serve` (default: 4000)', 4000).option('-s, --silent', 'Used by `serve` to tell it if open browser auto or not.', false).option('-d, --dir <path>', 'Used by `serve` to indicate a public directory path.', 'public').option('--schema <relativePath>', 'Used by `validate` to validate against a custom schema.');
+  program.name('resume').usage('[command] [options]').version(pkg.version).option('-F, --force', 'Used by `publish` and `export` - bypasses schema testing.').option('-t, --theme <theme name>', 'Theme used by `export` and `serve` (browse themes at https://jsonresume.org/themes/), or a path starting with . (use . for current directory or ../some/other/dir)', normalizeTheme, 'jsonresume-theme-elegant').option('-f, --format <file type extension>', 'Used by `export`.').option('-r, --resume <resume filename>', "path to the resume in json format. Use '-' to read from stdin", 'resume.json').option('-p, --port <port>', 'Used by `serve` (default: 4000)', 4000).option('-s, --silent', 'Used by `serve` to tell it if open browser auto or not.', false).option('-d, --dir <path>', 'Used by `serve` to indicate a public directory path.', 'public').option('--schema <relativePath>', 'Used by `validate` to validate against a custom schema.');
   program.command('init').description('Initialize a resume.json file').action(async () => {
     await (0, _init.default)({
       resumePath: program.resume
@@ -40,12 +44,13 @@ const normalizeTheme = (value, defaultValue) => {
         resume,
         schema
       });
+      console.log(chalk.green(`✓ ${program.resume} is valid`));
     } catch (e) {
       console.error(e.message);
       process.exitCode = 1;
     }
   });
-  program.command('export [fileName]').description('Export locally to .html or .pdf. Supply a --format <file format> flag and argument to specify export format.').action(async fileName => {
+  program.command('export [fileName]').description('Export locally to .html, .pdf, .md (markdown) or .txt (text). Supply a --format <file format> flag and argument to specify export format. .md and .txt need no theme; pick a theme for .html/.pdf with --theme (https://jsonresume.org/themes/).').action(async fileName => {
     const resume = await (0, _getResume.default)({
       path: program.resume
     });
@@ -54,6 +59,15 @@ const normalizeTheme = (value, defaultValue) => {
       resume,
       fileName
     }, (err, fileName, format) => {
+      if (err) {
+        if (err instanceof ThemeNotFoundError) {
+          console.error(formatThemeNotFound(err.theme));
+        } else {
+          console.error(err.message || err);
+        }
+        process.exitCode = 1;
+        return;
+      }
       console.log(chalk.green('\nDone! Find your new', format, 'resume at:\n', path.resolve(process.cwd(), fileName + format)));
     });
   });

package/build/main.test.js

@@ -8,12 +8,15 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 const exec = (0, _util.promisify)(_child_process.exec);
 const run = async (argv, {
   waitForVolumeExport = true,
-  stdin = ''
+  stdin = '',
+  captureStderr = false
 } = {}) => {
   let volume;
   let exitCode;
   const child = (0, _child_process.spawn)(process.execPath, ['build/test-utils/cli-test-entry.js', ...argv], {
-    stdio: ['pipe', 'pipe', 2, 'ipc']
+    // When captureStderr is set, pipe fd 2 so the test can read the
+    // friendly error output; otherwise inherit it (existing behavior).
+    stdio: ['pipe', 'pipe', captureStderr ? 'pipe' : 2, 'ipc']
   });
   const allChecks = Promise.all([waitForVolumeExport ? new Promise(volumeSet => {
     child.on('message', async message => {
@@ -30,12 +33,16 @@ const run = async (argv, {
   })]);
   child.stdin.write(stdin);
   child.stdin.end();
-  const stdout = await (0, _streamToString.default)(child.stdout);
+  const stdoutPromise = (0, _streamToString.default)(child.stdout);
+  const stderrPromise = captureStderr ? (0, _streamToString.default)(child.stderr) : Promise.resolve('');
+  const stdout = await stdoutPromise;
+  const stderr = await stderrPromise;
   await allChecks;
   return {
     volume,
     code: exitCode,
-    stdout
+    stdout,
+    stderr
   };
 };
 describe('cli configuration', () => {
@@ -53,10 +60,11 @@ describe('cli configuration', () => {
         -V, --version                       output the version number
         -F, --force                         Used by \`publish\` and \`export\` - bypasses
                                             schema testing.
-        -t, --theme <theme name>            Specify theme used by \`export\` and
-                                            \`serve\` or specify a path starting with .
-                                            (use . for current directory or
-                                            ../some/other/dir) (default:
+        -t, --theme <theme name>            Theme used by \`export\` and \`serve\`
+                                            (browse themes at
+                                            https://jsonresume.org/themes/), or a
+                                            path starting with . (use . for current
+                                            directory or ../some/other/dir) (default:
                                             "jsonresume-theme-elegant")
         -f, --format <file type extension>  Used by \`export\`.
         -r, --resume <resume filename>      path to the resume in json format. Use
@@ -75,9 +83,13 @@ describe('cli configuration', () => {
       Commands:
         init                                Initialize a resume.json file
         validate                            Validate your resume's schema
-        export [fileName]                   Export locally to .html or .pdf. Supply
-                                            a --format <file format> flag and
-                                            argument to specify export format.
+        export [fileName]                   Export locally to .html, .pdf, .md
+                                            (markdown) or .txt (text). Supply a
+                                            --format <file format> flag and argument
+                                            to specify export format. .md and .txt
+                                            need no theme; pick a theme for
+                                            .html/.pdf with --theme
+                                            (https://jsonresume.org/themes/).
         serve                               Serve resume at http://localhost:4000/
         help [command]                      display help for command
       "
@@ -88,16 +100,37 @@ describe('cli configuration', () => {
       const {
         stdout
       } = await run(['validate', '--schema', '/test-resumes/only-number-schema.json', '--resume', '/test-resumes/only-number.json']);
-      expect(stdout).toMatchInlineSnapshot(`""`);
+      expect(stdout).toMatchInlineSnapshot(`
+        "✓ /test-resumes/only-number.json is valid
+        "
+      `);
     });
     it('should fail when trying to validate an invalid resume specified by the --resume option', async () => {
       expect((await run(['validate', '--resume', '/test-resumes/invalid-resume.json'])).code).toEqual(1);
     });
+    it('should print the per-field error list (not a success line) when validation fails', async () => {
+      const {
+        code,
+        stdout,
+        stderr
+      } = await run(['validate', '--resume', '/test-resumes/invalid-resume.json'], {
+        waitForVolumeExport: false,
+        captureStderr: true
+      });
+      expect(code).toEqual(1);
+      expect(stderr).toContain('Invalid resume:');
+      expect(stderr).toContain('data/basics/name must be string');
+      // The success line must not appear for an invalid resume.
+      expect(stdout).not.toContain('is valid');
+    });
     it('should validate a resume specified by the --resume option', async () => {
       const {
         stdout
       } = await run(['validate', '--resume', '/test-resumes/resume.json']);
-      expect(stdout).toMatchInlineSnapshot(`""`);
+      expect(stdout).toMatchInlineSnapshot(`
+        "✓ /test-resumes/resume.json is valid
+        "
+      `);
     });
   });
   describe('export', () => {
@@ -139,5 +172,55 @@ describe('cli configuration', () => {
         "
       `);
     });
+    it('should export markdown without requiring a theme', async () => {
+      const {
+        stdout,
+        volume
+      } = await run(['export', '/test-resumes/exported-resume.md', '--resume', '-', '--format', 'markdown'], {
+        stdin: JSON.stringify({
+          basics: {
+            name: 'thomas-md'
+          },
+          skills: [{
+            name: 'JS',
+            keywords: ['Node']
+          }]
+        })
+      });
+      const output = volume['/test-resumes/exported-resume.md'];
+      expect(output).toEqual(expect.stringContaining('# thomas-md'));
+      expect(output).toEqual(expect.stringContaining('## Skills'));
+      expect(stdout).toContain('.md resume at:');
+    });
+    it('should export plain text without requiring a theme', async () => {
+      const {
+        stdout,
+        volume
+      } = await run(['export', '/test-resumes/exported-resume.txt', '--resume', '-', '--format', 'text'], {
+        stdin: JSON.stringify({
+          basics: {
+            name: 'thomas-txt'
+          }
+        })
+      });
+      const output = volume['/test-resumes/exported-resume.txt'];
+      expect(output).toEqual(expect.stringContaining('thomas-txt'));
+      expect(stdout).toContain('.txt resume at:');
+    });
+    it('should print a friendly, actionable message and exit non-zero when the theme is not installed', async () => {
+      const {
+        code,
+        stderr
+      } = await run(['export', '/test-resumes/exported-resume.html', '--resume', '/test-resumes/resume.json', '--theme', 'nonexistent-xyz'], {
+        waitForVolumeExport: false,
+        captureStderr: true
+      });
+      expect(code).toEqual(1);
+      expect(stderr).toContain("Theme 'nonexistent-xyz' not found.");
+      expect(stderr).toContain('npm install jsonresume-theme-nonexistent-xyz');
+      expect(stderr).toContain('https://jsonresume.org/themes/');
+      // The raw stack trace must not leak to the user.
+      expect(stderr).not.toContain('at _default');
+    });
   });
 });

package/build/render-html.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _themeErrors = require("./theme-errors");
 const tryResolve = (...args) => {
   try {
     return require.resolve(...args);
@@ -22,7 +23,7 @@ var _default = async ({
       paths: [cwd]
     });
     if (!path) {
-      throw new Error(`Theme ${themePath} could not be resolved relative to ${cwd}`);
+      throw new _themeErrors.ThemeNotFoundError(themePath);
     }
   }
   if (!path) {
@@ -36,7 +37,7 @@ var _default = async ({
     });
   }
   if (!path) {
-    throw new Error(`theme path ${themePath} could not be resolved from current working directory`);
+    throw new _themeErrors.ThemeNotFoundError(themePath);
   }
   const theme = require(path);
   if (typeof theme?.render !== 'function') {

package/build/theme-errors.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const chalk = require('chalk');
+
+// Strip the `jsonresume-theme-` prefix (and any relative-path noise) so the
+// message we show the user matches what they would type with `--theme`.
+const shortThemeName = theme => {
+  if (!theme) {
+    return theme;
+  }
+  const base = theme.replace(/^.*jsonresume-theme-/, '');
+  return base.replace(/[/\\].*$/, '');
+};
+
+// Error raised when a `--theme` cannot be resolved. Carries the requested
+// theme name so the CLI can render an actionable, stack-trace-free message.
+class ThemeNotFoundError extends Error {
+  constructor(theme) {
+    super(`Theme not found: ${theme}`);
+    this.name = 'ThemeNotFoundError';
+    this.theme = theme;
+  }
+}
+
+// Build the user-facing, actionable message for a missing theme.
+const formatThemeNotFound = theme => {
+  const short = shortThemeName(theme);
+  const pkg = short.startsWith('jsonresume-theme-') ? short : `jsonresume-theme-${short}`;
+  return [chalk.red(`Theme '${short}' not found.`), `Install it:  ${chalk.cyan(`npm install ${pkg}`)}`, `Browse themes:  ${chalk.cyan('https://jsonresume.org/themes/')}`].join('\n');
+};
+module.exports = {
+  ThemeNotFoundError,
+  formatThemeNotFound,
+  shortThemeName
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resume-cli",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "The JSON Resume command line interface",
   "main": "build/main.js",
   "engines": {