@ali.mazaheri/nanocat 0.0.0-stage → 0.3.0

package/README.md

@@ -1,3 +1,51 @@
-# Temporary Holding Version
+# nanocat
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Syntax-highlight files or piped `stdin` directly in your terminal using GNU nano's `.nanorc` syntax definitions—so your CLI output matches the exact colours you see inside `nano`.
+
+Zero external dependencies (Python 3 standard library only).
+
+## Features
+
+- Evaluates `.nanorc` `color` and `icolor` rules (including multi-line `start=... end=...` blocks) in nano's exact top-to-bottom precedence order
+- Reads `~/.nanorc` `include` directives and `numbercolor` / `titlecolor` theme settings (plus `--theme` overrides)
+- Line numbers (`-n` / `--number`), Git diff gutter markers (`-g` / `--git`), and line-range slicing (`-r 10:40`)
+- Soft-wrapping (`-w` / `--wrap`), multi-file headers, and auto-paging through `less -R` (`--paging=auto|always|never`)
+
+## Installation
+
+### Quick Install (One-Liner)
+
+```bash
+curl -fsSL https://githubusercontent.com | bash
+```
+
+### Via pipx or uv
+
+```bash
+pipx install git+https://github.com
+```
+
+### Manual Install
+
+```bash
+git clone https://github.com
+mkdir -p ~/.local/bin
+ln -sf "\$(pwd)/nanocat/nanocat" ~/.local/bin/nanocat
+```
+
+## Usage
+
+```bash
+# Highlight one or more files directly (auto-detects extension or shebang)
+nanocat path/to/file.tsx
+nanocat -n -g src/App.tsx src/index.tsx
+
+# Show line numbers, git diff markers, and slice lines 10 to 40
+nanocat -n -g -r 10:40 path/to/file.go
+
+# Highlight piped stdin using a specific language
+grep -n "func " main.go | nanocat -l go
+
+# List all detected .nanorc syntax definitions
+nanocat --list
+```

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export interface NanorcRule {
+    type: "single" | "block";
+    color: string;
+    start: RegExp;
+    end?: RegExp;
+}
+export interface NanorcSyntax {
+    name: string;
+    extensions: RegExp[];
+    rules: NanorcRule[];
+}
+export declare function parseNanorc(content: string): NanorcSyntax[];
+export declare function highlight(code: string, syntax: NanorcSyntax, format?: "ansi" | "html"): string;

package/dist/index.js

@@ -0,0 +1,138 @@
+const ANSI_FG = {
+    black: "30", red: "31", green: "32", yellow: "33",
+    blue: "34", magenta: "35", cyan: "36", white: "37",
+    brightblack: "90", brightred: "91", brightgreen: "92",
+    brightyellow: "93", brightblue: "94", brightmagenta: "95",
+    brightcyan: "96", brightwhite: "97", orange: "38;5;208",
+};
+function posixToJsRegex(pat) {
+    return pat
+        .replace(/\\</g, "\\b")
+        .replace(/\\>/g, "\\b")
+        .replace(/\[\[:space:\]\]|\[:space:\]/g, "\\s")
+        .replace(/\[\[:digit:\]\]|\[:digit:\]/g, "[0-9]")
+        .replace(/\[\[:alpha:\]\]|\[:alpha:\]/g, "[A-Za-z]")
+        .replace(/\[\[:alnum:\]\]|\[:alnum:\]/g, "[A-Za-z0-9]");
+}
+function colorToAnsi(spec) {
+    const parts = spec.toLowerCase().split(",").map((s) => s.trim());
+    const codes = [];
+    for (const p of parts) {
+        if (p === "bold")
+            codes.push("1");
+        else if (ANSI_FG[p])
+            codes.push(ANSI_FG[p]);
+    }
+    return codes.length ? `\x1b[${codes.join(";")}m` : "";
+}
+function extractQuoted(line) {
+    const out = [];
+    const re = /"((?:\\"|[^"])*)"/g;
+    let m;
+    while ((m = re.exec(line)) !== null) {
+        out.push(m[1].replace(/\\"/g, '"'));
+    }
+    return out;
+}
+export function parseNanorc(content) {
+    const syntaxes = [];
+    let current = null;
+    for (const raw of content.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        if (line.startsWith("syntax ")) {
+            const quoted = extractQuoted(line.slice(7));
+            current = {
+                name: quoted[0] ?? "unknown",
+                extensions: quoted.slice(1).map((p) => new RegExp(posixToJsRegex(p))),
+                rules: [],
+            };
+            syntaxes.push(current);
+        }
+        else if (current && (line.startsWith("color ") || line.startsWith("icolor "))) {
+            const icase = line.startsWith("icolor ");
+            const rest = line.slice(icase ? 7 : 6).trim();
+            const spaceIdx = rest.search(/\s/);
+            if (spaceIdx === -1)
+                continue;
+            const colorSpec = rest.slice(0, spaceIdx);
+            const body = rest.slice(spaceIdx).trim();
+            const flags = icase ? "gm" : "gm";
+            const quoted = extractQuoted(body);
+            if (body.startsWith("start=") && quoted.length >= 2) {
+                current.rules.push({
+                    type: "block",
+                    color: colorSpec,
+                    start: new RegExp(posixToJsRegex(quoted[0]), icase ? "gim" : "gm"),
+                    end: new RegExp(posixToJsRegex(quoted[1]), icase ? "gim" : "gm"),
+                });
+            }
+            else {
+                for (const pat of quoted) {
+                    current.rules.push({
+                        type: "single",
+                        color: colorSpec,
+                        start: new RegExp(posixToJsRegex(pat), icase ? "gim" : "gm"),
+                    });
+                }
+            }
+        }
+    }
+    return syntaxes;
+}
+export function highlight(code, syntax, format = "ansi") {
+    const n = code.length;
+    const styles = new Array(n).fill("");
+    for (const rule of syntax.rules) {
+        if (rule.type === "single") {
+            rule.start.lastIndex = 0;
+            let m;
+            while ((m = rule.start.exec(code)) !== null) {
+                if (m[0].length === 0) {
+                    rule.start.lastIndex++;
+                    continue;
+                }
+                for (let i = m.index; i < m.index + m[0].length; i++)
+                    styles[i] = rule.color;
+            }
+        }
+        else if (rule.type === "block" && rule.end) {
+            let pos = 0;
+            while (pos < n) {
+                rule.start.lastIndex = pos;
+                const ms = rule.start.exec(code);
+                if (!ms)
+                    break;
+                rule.end.lastIndex = ms.index + ms[0].length;
+                const me = rule.end.exec(code);
+                const endPos = me ? me.index + me[0].length : n;
+                for (let i = ms.index; i < endPos; i++)
+                    styles[i] = rule.color;
+                pos = Math.max(endPos, ms.index + 1);
+            }
+        }
+    }
+    let out = "";
+    let cur = "";
+    for (let i = 0; i < n; i++) {
+        const st = styles[i];
+        if (st !== cur) {
+            if (cur)
+                out += format === "ansi" ? "\x1b[0m" : "</span>";
+            if (st) {
+                out += format === "ansi"
+                    ? colorToAnsi(st)
+                    : `<span class="nc-${st.replace(/[^a-z0-9]/gi, "-")}">`;
+            }
+            cur = st;
+        }
+        const ch = code[i];
+        out += format === "html"
+            ? ch.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+            : ch;
+    }
+    if (cur)
+        out += format === "ansi" ? "\x1b[0m" : "</span>";
+    return out;
+}

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "@ali.mazaheri/nanocat",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Zero-dependency .nanorc syntax highlighter for Node.js CI and browser HTML output.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test tests/nanocat.test.mjs"
+  },
+  "keywords": ["nano", "nanorc", "syntax-highlighting", "ansi", "ci", "typescript"],
+  "license": "MIT"
+}

package/src/index.ts

@@ -0,0 +1,150 @@
+export interface NanorcRule {
+  type: "single" | "block";
+  color: string;
+  start: RegExp;
+  end?: RegExp;
+}
+
+export interface NanorcSyntax {
+  name: string;
+  extensions: RegExp[];
+  rules: NanorcRule[];
+}
+
+const ANSI_FG: Record<string, string> = {
+  black: "30", red: "31", green: "32", yellow: "33",
+  blue: "34", magenta: "35", cyan: "36", white: "37",
+  brightblack: "90", brightred: "91", brightgreen: "92",
+  brightyellow: "93", brightblue: "94", brightmagenta: "95",
+  brightcyan: "96", brightwhite: "97", orange: "38;5;208",
+};
+
+function posixToJsRegex(pat: string): string {
+  return pat
+    .replace(/\\</g, "\\b")
+    .replace(/\\>/g, "\\b")
+    .replace(/\[\[:space:\]\]|\[:space:\]/g, "\\s")
+    .replace(/\[\[:digit:\]\]|\[:digit:\]/g, "[0-9]")
+    .replace(/\[\[:alpha:\]\]|\[:alpha:\]/g, "[A-Za-z]")
+    .replace(/\[\[:alnum:\]\]|\[:alnum:\]/g, "[A-Za-z0-9]");
+}
+
+function colorToAnsi(spec: string): string {
+  const parts = spec.toLowerCase().split(",").map((s) => s.trim());
+  const codes: string[] = [];
+  for (const p of parts) {
+    if (p === "bold") codes.push("1");
+    else if (ANSI_FG[p]) codes.push(ANSI_FG[p]);
+  }
+  return codes.length ? `\x1b[${codes.join(";")}m` : "";
+}
+
+function extractQuoted(line: string): string[] {
+  const out: string[] = [];
+  const re = /"((?:\\"|[^"])*)"/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(line)) !== null) {
+    out.push(m[1].replace(/\\"/g, '"'));
+  }
+  return out;
+}
+
+export function parseNanorc(content: string): NanorcSyntax[] {
+  const syntaxes: NanorcSyntax[] = [];
+  let current: NanorcSyntax | null = null;
+
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+
+    if (line.startsWith("syntax ")) {
+      const quoted = extractQuoted(line.slice(7));
+      current = {
+        name: quoted[0] ?? "unknown",
+        extensions: quoted.slice(1).map((p) => new RegExp(posixToJsRegex(p))),
+        rules: [],
+      };
+      syntaxes.push(current);
+    } else if (current && (line.startsWith("color ") || line.startsWith("icolor "))) {
+      const icase = line.startsWith("icolor ");
+      const rest = line.slice(icase ? 7 : 6).trim();
+      const spaceIdx = rest.search(/\s/);
+      if (spaceIdx === -1) continue;
+      const colorSpec = rest.slice(0, spaceIdx);
+      const body = rest.slice(spaceIdx).trim();
+      const flags = icase ? "gm" : "gm";
+      const quoted = extractQuoted(body);
+
+      if (body.startsWith("start=") && quoted.length >= 2) {
+        current.rules.push({
+          type: "block",
+          color: colorSpec,
+          start: new RegExp(posixToJsRegex(quoted[0]), icase ? "gim" : "gm"),
+          end: new RegExp(posixToJsRegex(quoted[1]), icase ? "gim" : "gm"),
+        });
+      } else {
+        for (const pat of quoted) {
+          current.rules.push({
+            type: "single",
+            color: colorSpec,
+            start: new RegExp(posixToJsRegex(pat), icase ? "gim" : "gm"),
+          });
+        }
+      }
+    }
+  }
+  return syntaxes;
+}
+
+export function highlight(
+  code: string,
+  syntax: NanorcSyntax,
+  format: "ansi" | "html" = "ansi"
+): string {
+  const n = code.length;
+  const styles = new Array<string>(n).fill("");
+
+  for (const rule of syntax.rules) {
+    if (rule.type === "single") {
+      rule.start.lastIndex = 0;
+      let m: RegExpExecArray | null;
+      while ((m = rule.start.exec(code)) !== null) {
+        if (m[0].length === 0) { rule.start.lastIndex++; continue; }
+        for (let i = m.index; i < m.index + m[0].length; i++) styles[i] = rule.color;
+      }
+    } else if (rule.type === "block" && rule.end) {
+      let pos = 0;
+      while (pos < n) {
+        rule.start.lastIndex = pos;
+        const ms = rule.start.exec(code);
+        if (!ms) break;
+        rule.end.lastIndex = ms.index + ms[0].length;
+        const me = rule.end.exec(code);
+        const endPos = me ? me.index + me[0].length : n;
+        for (let i = ms.index; i < endPos; i++) styles[i] = rule.color;
+        pos = Math.max(endPos, ms.index + 1);
+      }
+    }
+  }
+
+  let out = "";
+  let cur = "";
+  for (let i = 0; i < n; i++) {
+    const st = styles[i];
+    if (st !== cur) {
+      if (cur) out += format === "ansi" ? "\x1b[0m" : "</span>";
+      if (st) {
+        out += format === "ansi"
+          ? colorToAnsi(st)
+          : `<span class="nc-${st.replace(/[^a-z0-9]/gi, "-")}">`;
+      }
+      cur = st;
+    }
+    const ch = code[i];
+    out += format === "html"
+      ? ch.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+      : ch;
+  }
+  if (cur) out += format === "ansi" ? "\x1b[0m" : "</span>";
+  return out;
+}

package/tests/nanocat.test.mjs

@@ -0,0 +1,22 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseNanorc, highlight } from "../dist/index.js";
+
+test("parseNanorc and highlight ANSI and HTML", () => {
+  const rc = `
+syntax "demo" "\\.demo$"
+color green "\\<(func|return)\\>"
+color brightblue start="/\\*" end="\\*/"
+`;
+  const syntaxes = parseNanorc(rc);
+  assert.equal(syntaxes.length, 1);
+
+  const code = "func main() { /* return */ return }";
+  const ansi = highlight(code, syntaxes[0], "ansi");
+  const html = highlight(code, syntaxes[0], "html");
+
+  assert.match(ansi, /\x1b\[32mfunc\x1b\[0m/);
+  assert.match(ansi, /\x1b\[94m\/\* return \*\/\x1b\[0m/);
+  assert.match(html, /<span class="nc-green">func<\/span>/);
+  assert.match(html, /<span class="nc-brightblue">\/\* return \*\/<\/span>/);
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "strict": true
+  },
+  "include": ["src/**/*"]
+}