npm - @chromamark/cli - Versions diffs - 0.1.3 → 0.2.0 - Mend

@chromamark/cli 0.1.3 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -2,7 +2,8 @@
 Compile [ChromaMark](https://github.com/cjfravel-dev/ChromaMark) (`.cm`) files
 into **self-contained HTML** — the theme is inlined, so there's no CDN or build
-step to deploy.
+step to deploy — render them straight to a **color terminal**, or **lint** them
+in CI.
 ## Install
@@ -21,19 +22,39 @@ chromamark build docs/ -o site/            # every .cm in a tree → site/*.html
 chromamark report.cm --stdout > out.html   # write to stdout
 cat report.cm | chromamark -               # read from stdin
 chromamark build report.cm --watch         # rebuild on change
+chromamark render report.cm                # render to the terminal (ANSI)
+cat report.cm | chromamark render          # render piped stdin
+chromamark render report.cm --no-color     # plain, icon-annotated text
+chromamark lint report.cm                  # check for common mistakes (CI)
+chromamark lint report.cm --disable CM001  # suppress a rule
 ```
-Options: `-o/--output`, `--stdout`, `--title <text>`, `--watch`, `-h/--help`,
+Options: `-o/--output`, `--stdout`, `--title <text>`, `--watch`,
+`--color <auto|always|never>`, `--no-color`, `--disable <rules>`, `-h/--help`,
 `-v/--version`.
+The `render` command turns tones into terminal colors, pills into bracketed
+icon chips (`[✓ PASS]`), blocks into a colored left bar, and meters into a
+unicode bar. Color is automatic on a TTY and can be forced with `--color`; it
+also honors the [`NO_COLOR`](https://no-color.org) convention.
+The `lint` command flags mistakes that otherwise degrade silently — a construct
+wrapped in backticks (`CM001`), an unknown tone (`CM002`), an unknown block kind
+(`CM003`), a bad meter value (`CM004`), or an unclosed container (`CM005`) — and
+exits non-zero when any are found. Suppress rules with `--disable CM001,CM003`.
 ## Programmatic
 ```js
-import { compile, render } from '@chromamark/cli';
+import { compile, render, renderAnsi, lint } from '@chromamark/cli';
 const page = compile('::: success\nAll good [!pass]\n:::', { title: 'Report' });
 // → complete <!DOCTYPE html> document with the theme inlined
 const fragment = render('[!pass]'); // just the HTML fragment
+const ansi = renderAnsi('[!pass]', { color: 'always' }); // terminal-styled text
+const problems = lint('Use `[!pass]` here'); // [{ line, column, rule, ... }]
 ```
 ## License

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@chromamark/cli",
-  "version": "0.1.3",
-  "description": "ChromaMark command-line compiler — turn .cm files into self-contained HTML (theme inlined, no CDN).",
+  "version": "0.2.0",
+  "description": "ChromaMark command-line tool — compile .cm to self-contained HTML, render to a color terminal, or lint.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "cjfravel-dev",
   "homepage": "https://github.com/cjfravel-dev/ChromaMark#readme",
@@ -42,6 +42,6 @@
     "html"
   ],
   "dependencies": {
-    "@chromamark/renderer": "^0.2.2"
+    "@chromamark/renderer": "^0.3.0"
   }
 }

package/src/cli.js CHANGED Viewed

@@ -4,37 +4,75 @@
  */
 import {
-  readFileSync, writeFileSync, statSync, readdirSync, mkdirSync, watch,
+  readFileSync, readSync, writeFileSync, statSync, readdirSync, mkdirSync, watch,
 } from 'node:fs';
 import { join, basename, extname, dirname, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { compile } from './index.js';
+import { compile, renderAnsi, lint } from './index.js';
-const HELP = `chromamark — compile ChromaMark (.cm) to self-contained HTML
+const HELP = `chromamark — compile ChromaMark (.cm) to HTML, render it, or lint it
 Usage:
-  chromamark [build] <input.cm> [-o <output.html>]   compile one file
+  chromamark [build] <input.cm> [-o <output.html>]   compile one file to HTML
   chromamark [build] <dir> -o <outdir>               compile every .cm in a tree
+  chromamark render <input.cm>                       render to ANSI on stdout
+  chromamark lint <input.cm>                         check for common mistakes
+  cat file.cm | chromamark render                    render stdin to ANSI
   chromamark <input.cm> --stdout                     write HTML to stdout
-  cat file.cm | chromamark -                          read from stdin
+  cat file.cm | chromamark -                          read HTML from stdin
 Options:
-  -o, --output <path>   output file or directory
+  -o, --output <path>   output file or directory (build)
   --stdout              write HTML to stdout instead of a file
   --title <text>        page title (default: derived from the file name)
+  --color <when>        colorize render output: auto (default), always, never
+  --no-color            disable color (same as --color never)
+  --disable <rules>     lint: comma-separated rule ids to suppress (e.g. CM001)
   --watch               rebuild when inputs change
   -h, --help            show this help
   -v, --version         print the version
 `;
+const COMMANDS = new Set(['build', 'render', 'lint']);
+/**
+ * Read all of stdin synchronously. Unlike readFileSync(0), this tolerates a
+ * non-blocking pipe from another process (which throws EAGAIN when no data is
+ * ready yet) by retrying after a short sleep until EOF.
+ */
+function readStdin() {
+  const chunks = [];
+  const buf = Buffer.alloc(65536);
+  const idle = new Int32Array(new SharedArrayBuffer(4));
+  for (;;) {
+    let bytes;
+    try {
+      bytes = readSync(0, buf, 0, buf.length, null);
+    } catch (err) {
+      if (err.code === 'EAGAIN') { Atomics.wait(idle, 0, 0, 5); continue; }
+      if (err.code === 'EOF') break; // some platforms signal EOF this way
+      throw err;
+    }
+    if (bytes === 0) break;
+    chunks.push(Buffer.from(buf.subarray(0, bytes)));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
 function version() {
   const url = new URL('../package.json', import.meta.url);
   return JSON.parse(readFileSync(fileURLToPath(url), 'utf8')).version;
 }
 function parseArgs(argv) {
-  const opts = { input: null, output: null, stdout: false, title: null, watch: false };
-  const rest = argv[0] === 'build' ? argv.slice(1) : argv.slice(0);
+  const opts = {
+    command: 'build', input: null, output: null, stdout: false, title: null, watch: false, color: 'auto', disable: [],
+  };
+  let rest = argv;
+  if (argv.length && COMMANDS.has(argv[0])) {
+    opts.command = argv[0];
+    rest = argv.slice(1);
+  }
   for (let i = 0; i < rest.length; i++) {
     const a = rest[i];
     const takeValue = (flag) => {
@@ -49,7 +87,14 @@ function parseArgs(argv) {
     else if (a === '-v' || a === '--version') opts.version = true;
     else if (a === '--stdout') opts.stdout = true;
     else if (a === '--watch') opts.watch = true;
-    else if (a === '-o' || a === '--output') opts.output = takeValue(a);
+    else if (a === '--no-color') opts.color = 'never';
+    else if (a === '--color') {
+      const v = takeValue(a);
+      if (!['auto', 'always', 'never'].includes(v)) throw new Error('--color must be auto, always, or never');
+      opts.color = v;
+    } else if (a === '--disable') {
+      opts.disable = opts.disable.concat(takeValue(a).split(',').map((s) => s.trim()).filter(Boolean));
+    } else if (a === '-o' || a === '--output') opts.output = takeValue(a);
     else if (a === '--title') opts.title = takeValue(a);
     else if (a === '-') opts.input = '-';
     else if (a.startsWith('-')) throw new Error(`unknown option: ${a}`);
@@ -62,6 +107,60 @@ function titleFor(file) {
   return basename(file, extname(file));
 }
+/** Read source from a file, `-`, or piped stdin. Returns { src, path } or an
+ *  error shape ({ error } / { empty }) the command can turn into an exit code. */
+function readInput(opts) {
+  if (opts.input === '-' || (opts.input == null && !process.stdin.isTTY)) {
+    const src = readStdin();
+    if (opts.input !== '-' && !src.trim()) return { empty: true };
+    return { src, path: '<stdin>' };
+  }
+  if (opts.input == null) return null;
+  return { src: readFileSync(opts.input, 'utf8'), path: opts.input };
+}
+/** Render ChromaMark to ANSI on stdout, from a file, `-`, or piped stdin. */
+function runRender(opts) {
+  let input;
+  try {
+    input = readInput(opts);
+  } catch (err) {
+    process.stderr.write(`error: ${err.message}\n`);
+    return 1;
+  }
+  if (!input || input.empty) {
+    process.stderr.write(`error: render needs an input file or piped stdin\n\n${HELP}`);
+    return 1;
+  }
+  process.stdout.write(renderAnsi(input.src, { color: opts.color }));
+  return 0;
+}
+/** Lint ChromaMark and print diagnostics; exit non-zero when any are found. */
+function runLint(opts) {
+  let input;
+  try {
+    input = readInput(opts);
+  } catch (err) {
+    process.stderr.write(`error: ${err.message}\n`);
+    return 1;
+  }
+  if (!input || input.empty) {
+    process.stderr.write(`error: lint needs an input file or piped stdin\n\n${HELP}`);
+    return 1;
+  }
+  const diags = lint(input.src, { disable: opts.disable });
+  for (const d of diags) {
+    process.stdout.write(`${input.path}:${d.line}:${d.column}  ${d.severity}  ${d.rule}  ${d.message}\n`);
+  }
+  if (diags.length) {
+    process.stderr.write(`✗ ${diags.length} problem${diags.length === 1 ? '' : 's'}\n`);
+    return 1;
+  }
+  process.stderr.write(`✓ ${input.path}: no problems\n`);
+  return 0;
+}
 function listCmFiles(dir) {
   const out = [];
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
@@ -109,8 +208,15 @@ export function run(argv = process.argv.slice(2)) {
   if (opts.help) { process.stdout.write(HELP); return 0; }
   if (opts.version) { process.stdout.write(`${version()}\n`); return 0; }
+  if (opts.command === 'render') {
+    return runRender(opts);
+  }
+  if (opts.command === 'lint') {
+    return runLint(opts);
+  }
   if (opts.input === '-' || (opts.input == null && !process.stdin.isTTY)) {
-    const src = readFileSync(0, 'utf8');
+    const src = readStdin();
     if (opts.input !== '-' && !src.trim()) {
       process.stderr.write(`error: no input file given and stdin was empty\n\n${HELP}`);
       return 1;

package/src/index.js CHANGED Viewed

@@ -5,13 +5,19 @@
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { render as renderFragment } from '@chromamark/renderer';
+import { render as renderFragment, renderAnsi, lint } from '@chromamark/renderer';
 const require = createRequire(import.meta.url);
 /** Render ChromaMark to an HTML fragment (no page chrome). */
 export const render = renderFragment;
+/** Render ChromaMark to ANSI-styled text for a terminal. */
+export { renderAnsi };
+/** Lint ChromaMark source, returning an array of diagnostics. */
+export { lint };
 let cachedTheme;
 /** The ChromaMark theme stylesheet, read from @chromamark/renderer. */