@pc360/chlog 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -10,6 +10,13 @@ The format is based on Keep a Changelog, and this project follows Semantic Versi
 
 - No changes yet.
 
+## [0.2.3] - 2026-02-16
+
+### Changed
+
+- Updated package publish configuration guidance to ensure README image assets are included for npm rendering.
+- Clarified that only paths listed in `package.json` `files` are published (and that omitted folders like `test/` are excluded by default).
+
 ## [0.2.2] - 2026-02-16
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pc360/chlog",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "PC360 Changelog CLI Tool",
   "keywords": [
     "changelog",
@@ -13,6 +13,8 @@
   "files": [
     "bin",
     "lib",
+    "assets",
+    "test",
     "README.md",
     "CHANGELOG.md"
   ],

package/test/chlog-cli.integration.test.js

@@ -0,0 +1,112 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const { version } = require("../package.json");
+
+const BIN_PATH = path.resolve(__dirname, "../bin/chlog.js");
+
+function createTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "chlog-cli-"));
+}
+
+function runCli(args, cwd) {
+  return spawnSync(process.execPath, [BIN_PATH, ...args], {
+    cwd,
+    encoding: "utf8",
+  });
+}
+
+function cleanup(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+test("CLI exits 1 when run non-interactively without required interactive inputs", () => {
+  const cwd = createTempDir();
+
+  try {
+    const res = runCli([], cwd);
+    assert.equal(res.status, 1);
+    assert.match(res.stderr, /--type must be one of/);
+    assert.match(res.stderr, /Run: chlog --help/);
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI --dry-run still requires interactive inputs in non-TTY mode", () => {
+  const cwd = createTempDir();
+
+  try {
+    const res = runCli(["--dry-run"], cwd);
+
+    assert.equal(res.status, 1);
+    assert.match(res.stderr, /--type must be one of/);
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI prints version and exits 0 for --version and -v", () => {
+  const cwd = createTempDir();
+
+  try {
+    const longRes = runCli(["--version"], cwd);
+    const shortRes = runCli(["-v"], cwd);
+
+    assert.equal(longRes.status, 0);
+    assert.equal(shortRes.status, 0);
+    assert.equal(longRes.stdout.trim(), version);
+    assert.equal(shortRes.stdout.trim(), version);
+    assert.equal(longRes.stderr, "");
+    assert.equal(shortRes.stderr, "");
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI help shows interactive usage", () => {
+  const cwd = createTempDir();
+
+  try {
+    const res = runCli(["--help"], cwd);
+    assert.equal(res.status, 0);
+    assert.match(res.stdout, /Usage:\n  chlog/);
+    assert.doesNotMatch(res.stdout, /--type/);
+    assert.doesNotMatch(res.stdout, /--scope/);
+    assert.doesNotMatch(res.stdout, /--message/);
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI rejects removed flags", () => {
+  const cwd = createTempDir();
+  try {
+    const typeRes = runCli(["--type", "added"], cwd);
+    const frontendRes = runCli(["--frontend"], cwd);
+
+    assert.equal(typeRes.status, 1);
+    assert.equal(frontendRes.status, 1);
+    assert.match(typeRes.stderr, /Unknown argument: --type/);
+    assert.match(frontendRes.stderr, /Unknown argument: --frontend/);
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI handles unknown argument", () => {
+  const cwd = createTempDir();
+  try {
+    const res = runCli(["--not-a-real-flag"], cwd);
+    assert.equal(res.status, 1);
+    assert.match(res.stderr, /Unknown argument: --not-a-real-flag/);
+  } finally {
+    cleanup(cwd);
+  }
+});

package/test/chlog-lib.test.js

@@ -0,0 +1,147 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+  parseArgs,
+  validateArgs,
+  generateTimestamp,
+  buildLine,
+} = require("../lib/chlog-lib");
+
+test("parseArgs keeps interactive fields empty and parses defaults", () => {
+  const args = parseArgs(["node", "chlog"]);
+
+  assert.equal(args.type, null);
+  assert.equal(args.scope, null);
+  assert.equal(args.message, null);
+  assert.equal(args.tz, "Asia/Manila");
+  assert.equal(args.frontend, false);
+  assert.equal(args.layerSet, false);
+  assert.equal(args.dryRun, false);
+  assert.equal(args.dryRunSet, false);
+  assert.equal(args.help, false);
+  assert.equal(args.version, false);
+});
+
+test("parseArgs supports --dry-run", () => {
+  const args = parseArgs(["node", "chlog", "--dry-run"]);
+  assert.equal(args.dryRun, true);
+  assert.equal(args.dryRunSet, true);
+});
+
+test("parseArgs supports -d short dry-run flag", () => {
+  const args = parseArgs(["node", "chlog", "-d"]);
+  assert.equal(args.dryRun, true);
+  assert.equal(args.dryRunSet, true);
+});
+
+test("parseArgs supports --tz", () => {
+  const args = parseArgs(["node", "chlog", "--tz", "UTC"]);
+  assert.equal(args.tz, "UTC");
+});
+
+test("parseArgs rejects unknown argument", () => {
+  assert.throws(() => parseArgs(["node", "chlog", "--not-a-real-flag"]), /Unknown argument/);
+});
+
+test("validateArgs throws if missing scope", () => {
+  assert.throws(
+    () =>
+      validateArgs({
+        type: "added",
+        scope: null,
+        message: "x",
+        tz: "Asia/Manila",
+      }),
+    /--scope is required/,
+  );
+});
+
+test("validateArgs throws if message is whitespace-only", () => {
+  assert.throws(
+    () =>
+      validateArgs({
+        type: "added",
+        scope: "JES-1",
+        message: "   ",
+        tz: "Asia/Manila",
+      }),
+    /--message is required/,
+  );
+});
+
+test("validateArgs trims scope and message", () => {
+  const args = {
+    type: "added",
+    scope: "  JES-1  ",
+    message: "  fix typo  ",
+    tz: "Asia/Manila",
+  };
+
+  assert.equal(validateArgs(args), true);
+  assert.equal(args.scope, "JES-1");
+  assert.equal(args.message, "fix typo");
+});
+
+test("validateArgs throws if invalid type", () => {
+  assert.throws(
+    () =>
+      validateArgs({
+        type: "nope",
+        scope: "JES-1",
+        message: "x",
+        tz: "Asia/Manila",
+      }),
+    /--type must be one of/,
+  );
+});
+
+test("validateArgs throws if invalid timezone", () => {
+  assert.throws(
+    () =>
+      validateArgs({
+        type: "added",
+        scope: "JES-1",
+        message: "x",
+        tz: "Not/A_Timezone",
+      }),
+    /Invalid time zone|timeZone/i,
+  );
+});
+
+test("generateTimestamp returns 14 digits", () => {
+  const ts = generateTimestamp(new Date("2026-02-13T00:00:00Z"), "Asia/Manila");
+  assert.match(ts, /^\d{14}$/);
+});
+
+test("buildLine defaults to [Back-End] prefix and includes scope", () => {
+  const line = buildLine({
+    scope: "JES-33",
+    message: "Add daily consolidated JE job",
+    frontend: false,
+  });
+
+  assert.equal(line, "[JES-33] [Back-End] Add daily consolidated JE job\n");
+});
+
+test("buildLine uses [Front-End] when frontend=true", () => {
+  const line = buildLine({
+    scope: "JES-45",
+    message: "Fix pagination",
+    frontend: true,
+  });
+
+  assert.equal(line, "[JES-45] [Front-End] Fix pagination\n");
+});
+
+test("buildLine does not double-prefix if message already starts with label", () => {
+  const line = buildLine({
+    scope: "JES-99",
+    message: "[Back-End] Already prefixed",
+    frontend: false,
+  });
+
+  assert.equal(line, "[JES-99] [Back-End] Already prefixed\n");
+});

package/test/chlog-prompts.test.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { isPromptCancelled } = require("../lib/chlog-prompts");
+
+test("isPromptCancelled returns true for enquirer cancellation payloads", () => {
+  assert.equal(isPromptCancelled(""), true);
+  assert.equal(isPromptCancelled(null), true);
+  assert.equal(isPromptCancelled(undefined), true);
+  assert.equal(isPromptCancelled("cancelled"), true);
+  assert.equal(isPromptCancelled(new Error("Prompt was canceled")), true);
+});
+
+test("isPromptCancelled returns false for normal errors", () => {
+  assert.equal(isPromptCancelled(new Error("Invalid timezone")), false);
+  assert.equal(isPromptCancelled("Unknown argument"), false);
+});