@pc360/chlog 0.1.6

package/CHANGELOG.md

@@ -0,0 +1,67 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on Keep a Changelog, and this project follows Semantic Versioning.
+
+## [Unreleased]
+
+### Changed
+- Removed Ink card border lines so help and status output no longer render inside a box.
+- Added blank lines before and after help and error output to improve readability.
+
+## [0.1.6] - 2026-02-14
+
+### Changed
+- Bumped package version to `0.1.6`.
+
+## [0.1.5] - 2026-02-14
+
+### Changed
+- Bumped package version to `0.1.5`.
+
+## [0.1.4] - 2026-02-14
+
+### Changed
+- Cleaned project files and repository content.
+
+## [0.1.3] - 2026-02-14
+
+### Added
+- Improved help-menu text styling for better readability.
+
+## [0.1.2] - 2026-02-14
+
+### Added
+- Added short CLI flags:
+  - `-t` for `--type`
+  - `-s` for `--scope`
+  - `-m` for `--message`
+  - `-f` for `--frontend`
+  - `-d` for `--dry-run`
+- Expanded unit and integration test coverage for short flag handling.
+
+### Changed
+- Enhanced `chlog --help` content with clearer tool description and usage details.
+
+## [0.1.1] - 2026-02-14
+
+### Changed
+- Refactored CLI terminal rendering to use `ink` with styled output cards.
+
+## [0.1.0] - 2026-02-13
+
+### Added
+- Initial release of `pc360-changelog-cli`.
+- Core CLI flow for creating changelog entry files under:
+  - `changelog/unreleased/added`
+  - `changelog/unreleased/changed`
+  - `changelog/unreleased/fixed`
+  - `changelog/unreleased/removed`
+- Argument parsing and validation for required flags.
+- Timezone-aware timestamp generation (`Asia/Manila` default).
+- Safe file creation using exclusive write mode.
+- Unit test coverage for parser, validation, timestamp, and output line formatting.
+
+### Changed
+- Standardized output path naming from `changelogs/` to `changelog/`.

package/README.md

@@ -0,0 +1,226 @@
+# PC360 Changelog CLI
+
+Internal CLI tool for creating structured changelog entries under:
+
+```
+changelog/unreleased/{added|changed|fixed|removed}
+```
+
+The CLI now renders polished terminal cards using `ink` in interactive terminals, with plain-text fallback for scripts/CI.
+
+Each entry file is automatically:
+
+- Named using Asia/Manila timestamp (`YYYYMMDDHHmmss`)
+- Placed in the correct type directory
+- Written as a single clean line
+- Prefixed with scope and layer (`Back-End` or `Front-End`)
+
+---
+
+## 📦 Installation
+
+### Option 1 — Install from `.tgz` package
+
+```
+npm install -g pc360-changelog-cli-0.1.6.tgz
+```
+
+### Option 2 — Install from project folder
+
+```
+npm install -g .
+```
+
+After installation, the `chlog` command will be globally available.
+
+---
+
+## 🚀 Usage
+
+```
+chlog --type <added|changed|fixed|removed> \
+      --scope <scope> \
+      --message "<description>" \
+      [--frontend]
+
+# Short form
+chlog -t <added|changed|fixed|removed> -s <scope> -m "<description>" [-f]
+```
+
+---
+
+## 🧩 Parameters
+
+| Flag             | Required | Description                                         |
+| ---------------- | -------- | --------------------------------------------------- |
+| `-t, --type`     | ✅       | Change type: `added`, `changed`, `fixed`, `removed` |
+| `-s, --scope`    | ✅       | Jira ticket or module name                          |
+| `-m, --message`  | ✅       | Description of the change                           |
+| `-f, --frontend` | ❌       | Uses `[Front-End]` instead of `[Back-End]`          |
+| `-d, --dry-run`  | ❌       | Preview file creation without writing               |
+| `-h, --help`     | ❌       | Show help                                           |
+
+---
+
+## 📝 Examples
+
+### Back-End Change (Default)
+
+```
+chlog --type added --scope JES-33 --message "Add daily consolidated JE job"
+```
+
+Creates:
+
+```
+changelog/unreleased/added/20260213124530
+```
+
+File content:
+
+```
+[JES-33] [Back-End] Add daily consolidated JE job
+```
+
+---
+
+### Front-End Change
+
+```
+chlog --type fixed --scope JES-45 --frontend --message "Fix table pagination issue"
+```
+
+File content:
+
+```
+[JES-45] [Front-End] Fix table pagination issue
+```
+
+---
+
+### Module-Based Scope
+
+```
+chlog --type changed --scope "Credit Validation" --message "Improve credit limit computation"
+```
+
+File content:
+
+```
+[Credit Validation] [Back-End] Improve credit limit computation
+```
+
+---
+
+## 📂 Directory Structure
+
+```
+changelog/
+└── unreleased/
+    ├── added/
+    ├── changed/
+    ├── fixed/
+    └── removed/
+```
+
+Each entry is stored as a timestamp-named file:
+
+```
+YYYYMMDDHHmmss
+```
+
+Timezone used: **Asia/Manila**
+
+---
+
+## 🔐 Rules Enforced by CLI
+
+- `--type` is required
+- `--scope` is required
+- `--message` is required
+- Prevents overwriting existing files
+- Automatically inserts `[Back-End]` or `[Front-End]`
+- Generates timestamp using Asia/Manila timezone
+
+---
+
+## 🧠 Recommended Conventions
+
+Preferred scope format:
+
+- Jira ticket: `JES-45`
+- Module name: `"Credit Validation"`
+
+Recommended message style:
+
+- Use imperative mood
+- Start with capital letter
+- Do not end with period
+
+Example:
+
+```
+Add dealer credit validation logic
+Fix FR status blocking issue
+```
+
+---
+
+## 🧪 Dry Run Mode
+
+Preview without creating file:
+
+```
+chlog --type added --scope JES-99 --message "Test entry" --dry-run
+```
+
+---
+
+## 🛠 Node Version
+
+Requires:
+
+```
+Node.js >= 18
+```
+
+Runtime dependencies:
+
+- `ink`
+- `react`
+
+---
+
+## 🧪 Running Unit Tests
+
+This project uses Node.js built-in test runner (`node:test`). No external test framework is required.
+
+### Run Tests
+
+From the project root:
+
+```
+npm test
+```
+
+Or directly with Node:
+
+```
+node --test
+```
+
+### What Is Tested
+
+- Argument parsing (`parseArgs`)
+- Required flag validation (`validateArgs`)
+- Timezone validation
+- Timestamp format generation (14-digit format)
+- Output line formatting
+- Front-End vs Back-End label handling
+- Prevention of double label prefixing
+
+---
+
+## 👨‍💻 Maintainer
+
+- almerleoalmazan@gmail.com

package/bin/chlog.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs/promises");
+const path = require("path");
+
+const {
+  parseArgs,
+  validateArgs,
+  generateTimestamp,
+  buildLine,
+} = require("../lib/chlog-lib");
+const {
+  renderHelp,
+  renderDryRun,
+  renderSuccess,
+  renderError,
+} = require("../lib/chlog-ui");
+
+function getHelpText() {
+  return `
+Create timestamped changelog entries for release notes and audit tracking.
+
+This command writes a single-line entry file under:
+  changelog/unreleased/<type>/<YYYYMMDDHHmmss>
+
+Each entry is formatted as:
+  [<scope>] [Back-End|Front-End] <message>
+
+Usage:
+  chlog --type <added|changed|fixed|removed> --scope <ticket> --message "<text>" [--frontend]
+  chlog -t <added|changed|fixed|removed> -s <ticket> -m "<text>" [-f]
+
+Options:
+  -t, --type <t>         Entry type (required)
+  -s, --scope <ticket>   Jira ticket or scope (required)
+  -m, --message "<msg>"  Entry message (required)
+  -f, --frontend         Use [Front-End] instead of [Back-End]
+  --tz "<iana>"          Timezone (default: Asia/Manila)
+  -d, --dry-run          Preview only
+  -h, --help             Show help
+`.trim();
+}
+
+async function main() {
+  try {
+    const args = parseArgs(process.argv);
+
+    if (args.help) {
+      await renderHelp(getHelpText());
+      process.exit(0);
+    }
+
+    validateArgs(args);
+
+    const timestamp = generateTimestamp(new Date(), args.tz);
+
+    const entryDir = path.join(
+      process.cwd(),
+      "changelog",
+      "unreleased",
+      args.type,
+    );
+
+    const entryPath = path.join(entryDir, timestamp);
+
+    const content = buildLine({
+      scope: args.scope,
+      message: args.message,
+      frontend: args.frontend,
+    });
+
+    if (args.dryRun) {
+      await renderDryRun({ entryPath, content });
+      process.exit(0);
+    }
+
+    await fs.mkdir(entryDir, { recursive: true });
+
+    await fs.writeFile(entryPath, content, {
+      encoding: "utf8",
+      flag: "wx",
+    });
+
+    await renderSuccess({ entryPath });
+  } catch (err) {
+    await renderError(err);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/chlog-lib.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const VALID_TYPES = new Set(["added", "changed", "fixed", "removed"]);
+
+function parseArgs(argv) {
+  const args = {
+    type: null,
+    scope: null,
+    message: null,
+    tz: "Asia/Manila",
+    frontend: false,
+    dryRun: false,
+    help: false,
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === "-h" || arg === "--help") {
+      args.help = true;
+      break;
+    }
+
+    if (arg === "--dry-run" || arg === "-d") {
+      args.dryRun = true;
+      continue;
+    }
+
+    if (arg === "--frontend" || arg === "-f") {
+      args.frontend = true;
+      continue;
+    }
+
+    if (arg === "--type" || arg === "-t") {
+      args.type = argv[++i];
+      continue;
+    }
+
+    if (arg === "--scope" || arg === "-s") {
+      args.scope = argv[++i];
+      continue;
+    }
+
+    if (arg === "--message" || arg === "-m") {
+      args.message = argv[++i];
+      continue;
+    }
+
+    if (arg === "--tz") {
+      args.tz = argv[++i];
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return args;
+}
+
+function validateArgs(args) {
+  if (!args.type || !VALID_TYPES.has(args.type)) {
+    throw new Error(`--type must be one of: added, changed, fixed, removed`);
+  }
+  if (!args.scope) {
+    throw new Error(`--scope is required (e.g. JES-33)`);
+  }
+  if (!args.message) {
+    throw new Error(`--message is required`);
+  }
+
+  // Validate timezone (throws RangeError if invalid)
+  new Intl.DateTimeFormat("en-US", { timeZone: args.tz }).format(new Date());
+
+  return true;
+}
+
+function generateTimestamp(date = new Date(), timeZone = "Asia/Manila") {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false,
+  }).formatToParts(date);
+
+  const map = Object.fromEntries(parts.map((p) => [p.type, p.value]));
+
+  return map.year + map.month + map.day + map.hour + map.minute + map.second;
+}
+
+function buildLine({ scope, message, frontend }) {
+  const layerLabel = frontend ? "[Front-End]" : "[Back-End]";
+
+  let msg = String(message ?? "").trim();
+  if (!msg.startsWith(layerLabel)) {
+    msg = `${layerLabel} ${msg}`;
+  }
+
+  return `[${scope}] ${msg}\n`;
+}
+
+module.exports = {
+  VALID_TYPES,
+  parseArgs,
+  validateArgs,
+  generateTimestamp,
+  buildLine,
+};

package/lib/chlog-ui.js

@@ -0,0 +1,225 @@
+"use strict";
+
+const path = require("path");
+
+function canUseInk(stream) {
+  return Boolean(stream?.isTTY) && process.env.TERM !== "dumb";
+}
+
+function printPlain(lines, { stream = process.stdout } = {}) {
+  const output = `${lines.join("\n")}\n`;
+  stream.write(output);
+}
+
+function getRelativeEntryPath(entryPath) {
+  return path.relative(process.cwd(), entryPath);
+}
+
+async function renderInkCard(
+  { title, subtitle, lines, tone = "info" },
+  { stream = process.stdout } = {},
+) {
+  if (!canUseInk(stream)) {
+    return false;
+  }
+
+  try {
+    const ReactModule = await import("react");
+    const InkModule = await import("ink");
+    const React = ReactModule.default || ReactModule;
+    const { render, Box, Text, useApp } = InkModule;
+
+    const palette = {
+      info: "cyan",
+      success: "green",
+      warning: "yellow",
+      error: "red",
+    };
+
+    function ExitOnRender() {
+      const { exit } = useApp();
+      React.useEffect(() => {
+        exit();
+      }, [exit]);
+      return null;
+    }
+
+    function Card({ model }) {
+      const borderColor = palette[model.tone] || "cyan";
+      const textElements = model.lines.map((line, index) => {
+        const text = typeof line === "string" ? line : line.text;
+        const props = { key: `line-${index}` };
+
+        if (typeof line !== "string") {
+          if (line.color) {
+            props.color = line.color;
+          }
+          if (line.bold) {
+            props.bold = true;
+          }
+          if (line.dimColor) {
+            props.dimColor = true;
+          }
+        }
+
+        return React.createElement(Text, props, text === "" ? " " : text);
+      });
+
+      return React.createElement(
+        Box,
+        {
+          flexDirection: "column",
+          alignSelf: "flex-start",
+          flexGrow: 0,
+          paddingX: 0,
+          paddingY: 0,
+        },
+        React.createElement(
+          Text,
+          { color: borderColor, bold: true },
+          model.title,
+        ),
+        model.subtitle
+          ? React.createElement(Text, { dimColor: true }, model.subtitle)
+          : null,
+        model.lines.length
+          ? React.createElement(
+              Box,
+              { marginTop: 1, flexDirection: "column" },
+              textElements,
+            )
+          : null,
+        React.createElement(ExitOnRender, null),
+      );
+    }
+
+    const app = render(
+      React.createElement(Card, { model: { title, subtitle, lines, tone } }),
+      {
+        stdout: stream,
+      },
+    );
+
+    await app.waitUntilExit();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function renderHelp(helpText) {
+  const lines = helpText.split("\n");
+  const styledLines = lines.map((line) => {
+    if (!line.trim()) {
+      return { text: line };
+    }
+    if (line === "Usage:" || line === "Options:") {
+      return { text: line, color: "cyan", bold: true };
+    }
+    if (line.startsWith("  chlog ")) {
+      return { text: line, color: "green" };
+    }
+    if (line.startsWith("  -")) {
+      return { text: line, color: "yellow" };
+    }
+    if (line.startsWith("  [<scope>]")) {
+      return { text: line, color: "magenta" };
+    }
+    if (line.startsWith("  changelog/")) {
+      return { text: line, color: "blue" };
+    }
+
+    return { text: line, dimColor: true };
+  });
+
+  process.stdout.write("\n");
+
+  const rendered = await renderInkCard(
+    {
+      title: "PC360 Changelog CLI - v0.1.6",
+      subtitle: "Usage & options",
+      lines: styledLines,
+      tone: "info",
+    },
+    { stream: process.stdout },
+  );
+
+  if (!rendered) {
+    printPlain(["", ...lines, ""], { stream: process.stdout });
+    return;
+  }
+
+  process.stdout.write("\n");
+}
+
+async function renderDryRun({ entryPath, content }) {
+  const lines = [
+    `[Dry Run]`,
+    `Would create: ${entryPath}`,
+    "",
+    "--- Content ---",
+    "",
+    content.trimEnd(),
+  ];
+
+  const rendered = await renderInkCard(
+    {
+      title: "Preview",
+      subtitle: "No files were written",
+      lines,
+      tone: "warning",
+    },
+    { stream: process.stdout },
+  );
+
+  if (!rendered) {
+    printPlain(lines, { stream: process.stdout });
+  }
+}
+
+async function renderSuccess({ entryPath }) {
+  const lines = [`Created: ${getRelativeEntryPath(entryPath)}`];
+
+  const rendered = await renderInkCard(
+    {
+      title: "Entry Created",
+      subtitle: "Changelog updated",
+      lines,
+      tone: "success",
+    },
+    { stream: process.stdout },
+  );
+
+  if (!rendered) {
+    printPlain(lines, { stream: process.stdout });
+  }
+}
+
+async function renderError(error) {
+  const lines = [`${error.message}`, "Run: chlog --help"];
+  process.stderr.write("\n");
+
+  const rendered = await renderInkCard(
+    {
+      title: "Error",
+      subtitle: "Could not create changelog entry",
+      lines,
+      tone: "error",
+    },
+    { stream: process.stderr },
+  );
+
+  if (!rendered) {
+    printPlain(["", ...lines, ""], { stream: process.stderr });
+    return;
+  }
+
+  process.stderr.write("\n");
+}
+
+module.exports = {
+  renderHelp,
+  renderDryRun,
+  renderSuccess,
+  renderError,
+};

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@pc360/chlog",
+  "version": "0.1.6",
+  "description": "PC360 Changelog CLI Tool",
+  "author": "aalmazan@pcdsi.ph",
+  "bin": {
+    "chlog": "bin/chlog.js"
+  },
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "ink": "^4.4.1",
+    "react": "^18.3.1"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}

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

@@ -0,0 +1,161 @@
+"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 { generateTimestamp } = require("../lib/chlog-lib");
+
+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 dry-run previews target path/content and exits 0", () => {
+  const cwd = createTempDir();
+
+  try {
+    const res = runCli(
+      [
+        "--type",
+        "added",
+        "--scope",
+        "JES-99",
+        "--message",
+        "Test entry",
+        "--dry-run",
+      ],
+      cwd,
+    );
+
+    assert.equal(res.status, 0);
+    assert.match(res.stdout, /\[Dry Run\]/);
+    assert.match(
+      res.stdout,
+      /Would create: .*changelog[\/\\]unreleased[\/\\]added[\/\\]\d{14}/,
+    );
+    assert.match(res.stdout, /\[JES-99\] \[Back-End\] Test entry/);
+    assert.equal(fs.existsSync(path.join(cwd, "changelog")), false);
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI supports short flags for required values and toggles", () => {
+  const cwd = createTempDir();
+
+  try {
+    const res = runCli(
+      ["-t", "added", "-s", "JES-100", "-m", "Use short options", "-f", "-d"],
+      cwd,
+    );
+
+    assert.equal(res.status, 0);
+    assert.match(res.stdout, /\[Dry Run\]/);
+    assert.match(
+      res.stdout,
+      /Would create: .*changelog[\/\\]unreleased[\/\\]added[\/\\]\d{14}/,
+    );
+    assert.match(res.stdout, /\[JES-100\] \[Front-End\] Use short options/);
+    assert.equal(fs.existsSync(path.join(cwd, "changelog")), false);
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI creates changelog file with expected content and exits 0", () => {
+  const cwd = createTempDir();
+
+  try {
+    const res = runCli(
+      [
+        "--type",
+        "fixed",
+        "--scope",
+        "JES-45",
+        "--message",
+        "Fix pagination",
+        "--frontend",
+      ],
+      cwd,
+    );
+
+    assert.equal(res.status, 0);
+    assert.match(
+      res.stdout,
+      /Created: changelog[\/\\]unreleased[\/\\]fixed[\/\\]\d{14}/,
+    );
+
+    const entryDir = path.join(cwd, "changelog", "unreleased", "fixed");
+    const files = fs.readdirSync(entryDir);
+    assert.equal(files.length, 1);
+    assert.match(files[0], /^\d{14}$/);
+
+    const content = fs.readFileSync(path.join(entryDir, files[0]), "utf8");
+    assert.equal(content, "[JES-45] [Front-End] Fix pagination\n");
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI returns exit code 1 for missing required flags", () => {
+  const cwd = createTempDir();
+
+  try {
+    const res = runCli(["--type", "added", "--scope", "JES-1"], cwd);
+
+    assert.equal(res.status, 1);
+    assert.match(res.stderr, /--message is required/);
+    assert.match(res.stderr, /Run: chlog --help/);
+  } finally {
+    cleanup(cwd);
+  }
+});
+
+test("CLI surfaces timestamp collision errors and exits 1", () => {
+  const cwd = createTempDir();
+
+  try {
+    const entryDir = path.join(cwd, "changelog", "unreleased", "changed");
+    fs.mkdirSync(entryDir, { recursive: true });
+
+    const now = Date.now();
+    for (let offset = -5; offset <= 5; offset++) {
+      const ts = generateTimestamp(new Date(now + offset * 1000), "Asia/Manila");
+      fs.writeFileSync(path.join(entryDir, ts), "existing\n", "utf8");
+    }
+
+    const res = runCli(
+      [
+        "--type",
+        "changed",
+        "--scope",
+        "JES-77",
+        "--message",
+        "Update report formatting",
+      ],
+      cwd,
+    );
+
+    assert.equal(res.status, 1);
+    assert.match(res.stderr, /EEXIST|file already exists/i);
+    assert.match(res.stderr, /Run: chlog --help/);
+  } finally {
+    cleanup(cwd);
+  }
+});

package/test/chlog-lib.test.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+  parseArgs,
+  validateArgs,
+  generateTimestamp,
+  buildLine,
+} = require("../lib/chlog-lib");
+
+test("parseArgs parses required flags and defaults", () => {
+  const args = parseArgs([
+    "node",
+    "chlog",
+    "--type",
+    "added",
+    "--scope",
+    "JES-33",
+    "--message",
+    "Hello",
+  ]);
+
+  assert.equal(args.type, "added");
+  assert.equal(args.scope, "JES-33");
+  assert.equal(args.message, "Hello");
+  assert.equal(args.tz, "Asia/Manila");
+  assert.equal(args.frontend, false);
+  assert.equal(args.dryRun, false);
+  assert.equal(args.help, false);
+});
+
+test("parseArgs supports --frontend and --dry-run", () => {
+  const args = parseArgs([
+    "node",
+    "chlog",
+    "--type",
+    "fixed",
+    "--scope",
+    "JES-45",
+    "--message",
+    "Fix thing",
+    "--frontend",
+    "--dry-run",
+  ]);
+
+  assert.equal(args.frontend, true);
+  assert.equal(args.dryRun, true);
+});
+
+test("parseArgs supports short flags", () => {
+  const args = parseArgs([
+    "node",
+    "chlog",
+    "-t",
+    "changed",
+    "-s",
+    "JES-50",
+    "-m",
+    "Update validation flow",
+    "-f",
+    "-d",
+  ]);
+
+  assert.equal(args.type, "changed");
+  assert.equal(args.scope, "JES-50");
+  assert.equal(args.message, "Update validation flow");
+  assert.equal(args.frontend, true);
+  assert.equal(args.dryRun, true);
+});
+
+test("parseArgs supports mixed long/short flags", () => {
+  const args = parseArgs([
+    "node",
+    "chlog",
+    "--type",
+    "fixed",
+    "-s",
+    "JES-88",
+    "--message",
+    "Mixed flags",
+    "-d",
+  ]);
+
+  assert.equal(args.type, "fixed");
+  assert.equal(args.scope, "JES-88");
+  assert.equal(args.message, "Mixed flags");
+  assert.equal(args.dryRun, true);
+  assert.equal(args.frontend, false);
+});
+
+test("parseArgs supports -h short help flag", () => {
+  const args = parseArgs(["node", "chlog", "-h"]);
+  assert.equal(args.help, true);
+});
+
+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 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");
+});