@lishugupta652/dokploy 0.1.4 → 0.1.5

package/.githooks/commit-msg

@@ -0,0 +1,9 @@
+#!/bin/sh
+set -e
+
+PACKAGE_DIR="dokploy-deploy-automation"
+if [ ! -f "$PACKAGE_DIR/scripts/commit-msg.mjs" ]; then
+  PACKAGE_DIR="."
+fi
+
+node "$PACKAGE_DIR/scripts/commit-msg.mjs" "$1"

package/.githooks/pre-commit

@@ -1,10 +1,5 @@
 #!/bin/sh
 set -e
 
-PACKAGE_DIR="dokploy-deploy-automation"
-if [ ! -f "$PACKAGE_DIR/scripts/bump-version-on-commit.mjs" ]; then
-  PACKAGE_DIR="."
-fi
-
-node "$PACKAGE_DIR/scripts/bump-version-on-commit.mjs"
-git add "$PACKAGE_DIR/package.json" "$PACKAGE_DIR/package-lock.json"
+# Commit message validation and semver bumping happen in commit-msg.
+exit 0

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+## 0.1.5 - 2026-04-13
+
+_Initial changelog generated from repository history._
+
+### Fixes
+
+- scripts (2930c10)
+
+### Other Changes
+
+- add script for deployment (c511505)
+- first commit (3f5e457)
+
+## 0.1.4 - 2026-04-13
+
+_Initial changelog generated from repository history._
+
+### Fixes
+
+- scripts (2930c10)
+
+### Other Changes
+
+- add script for deployment (c511505)
+- first commit (3f5e457)
+

package/README.md

@@ -80,6 +80,8 @@ Or use the helper script:
 
 The script defaults to dry-run mode and publishes only when `--publish` is passed.
 
+Publishing also generates `CHANGELOG.md` from git commits since the latest tag. Conventional Commit messages are grouped into sections such as Features, Fixes, Breaking Changes, and Chores.
+
 ## Commit Version Hook
 
 Install the repo hook once:
@@ -88,7 +90,17 @@ Install the repo hook once:
 npm run hooks:install
 ```
 
-The pre-commit hook bumps the package patch version and stages `package.json` plus `package-lock.json`. Set `SKIP_DOKPLOY_VERSION_BUMP=1` to skip it for a commit.
+The `commit-msg` hook enforces Conventional Commits and bumps `package.json` plus `package-lock.json` from the commit message:
+
+```text
+feat: add project listing          # minor
+fix(projects): normalize host      # patch
+perf: improve status lookup        # patch
+feat!: change config schema        # major
+docs: update usage                 # no version bump
+```
+
+Use `SKIP_DOKPLOY_VERSION_BUMP=1` to keep commit validation but skip version changes. Use `SKIP_DOKPLOY_COMMIT_CHECK=1` only when you intentionally need to bypass the hook.
 
 ## Notes
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lishugupta652/dokploy",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A YAML-driven CLI for applying Dokploy projects through the Dokploy API.",
   "type": "module",
   "bin": {
@@ -11,15 +11,18 @@
     "examples",
     "scripts",
     ".githooks",
+    "CHANGELOG.md",
     "README.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "changelog": "node scripts/generate-changelog.mjs",
     "check": "tsc -p tsconfig.json --noEmit",
     "dev": "tsx src/index.ts",
+    "commit-msg": "node scripts/commit-msg.mjs",
     "hooks:install": "node scripts/install-git-hooks.mjs",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run check && npm run build",
+    "prepublishOnly": "npm run check && npm run build && npm run changelog",
     "version:commit": "node scripts/bump-version-on-commit.mjs"
   },
   "publishConfig": {

package/scripts/commit-msg.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const allowedTypes = new Set([
+  "feat",
+  "fix",
+  "perf",
+  "refactor",
+  "docs",
+  "test",
+  "build",
+  "ci",
+  "chore",
+  "style",
+  "revert",
+]);
+
+const bumpByType = new Map([
+  ["feat", "minor"],
+  ["fix", "patch"],
+  ["perf", "patch"],
+]);
+
+const messagePath = process.argv[2];
+if (!messagePath) {
+  console.error("Missing commit message file path.");
+  process.exit(1);
+}
+
+const message = readFileSync(messagePath, "utf8");
+const header = firstCommitMessageLine(message);
+
+if (!header) {
+  fail("Commit message is empty.");
+}
+
+if (process.env.SKIP_DOKPLOY_COMMIT_CHECK === "1") {
+  process.exit(0);
+}
+
+if (isGeneratedCommit(header)) {
+  process.exit(0);
+}
+
+const parsed = parseConventionalCommit(header);
+if (!parsed) {
+  fail(`Invalid commit message: ${header}`);
+}
+
+if (!allowedTypes.has(parsed.type)) {
+  fail(`Unsupported commit type "${parsed.type}".`);
+}
+
+if (parsed.subject.trim().length === 0) {
+  fail("Commit subject cannot be empty.");
+}
+
+const bump = resolveBump(parsed, message);
+if (!bump) {
+  console.log(`Commit type "${parsed.type}" does not change the package version.`);
+  process.exit(0);
+}
+
+if (process.env.SKIP_DOKPLOY_VERSION_BUMP === "1") {
+  console.log(`Skipping ${bump} version bump because SKIP_DOKPLOY_VERSION_BUMP=1.`);
+  process.exit(0);
+}
+
+const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJsonPath = path.join(packageDir, "package.json");
+const packageLockPath = path.join(packageDir, "package-lock.json");
+
+const packageJson = readJson(packageJsonPath);
+const nextVersion = bumpVersion(packageJson.version, bump);
+
+if (process.env.DOKPLOY_VERSION_DRY_RUN === "1") {
+  console.log(`${parsed.type} commit will create ${bump} version: ${packageJson.version} -> ${nextVersion}`);
+  process.exit(0);
+}
+
+packageJson.version = nextVersion;
+writeJson(packageJsonPath, packageJson);
+
+const packageLock = readJson(packageLockPath);
+packageLock.name = packageJson.name;
+packageLock.version = nextVersion;
+if (packageLock.packages?.[""]) {
+  packageLock.packages[""].name = packageJson.name;
+  packageLock.packages[""].version = nextVersion;
+  packageLock.packages[""].bin = packageJson.bin;
+}
+writeJson(packageLockPath, packageLock);
+
+execFileSync("git", ["-C", packageDir, "add", packageJsonPath, packageLockPath], {
+  stdio: "inherit",
+});
+
+console.log(`${parsed.type} commit created ${bump} version: ${packageJson.name}@${nextVersion}`);
+
+function firstCommitMessageLine(rawMessage) {
+  return rawMessage
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => line.length > 0 && !line.startsWith("#"));
+}
+
+function isGeneratedCommit(headerLine) {
+  return (
+    headerLine.startsWith("Merge ") ||
+    headerLine.startsWith("Revert ") ||
+    headerLine.startsWith("fixup!") ||
+    headerLine.startsWith("squash!")
+  );
+}
+
+function parseConventionalCommit(headerLine) {
+  const match = headerLine.match(/^([a-z]+)(\([a-z0-9._/-]+\))?(!)?: (.+)$/);
+  if (!match) return undefined;
+
+  return {
+    type: match[1],
+    breaking: Boolean(match[3]),
+    subject: match[4],
+  };
+}
+
+function resolveBump(parsedCommit, rawMessage) {
+  if (parsedCommit.breaking || /\nBREAKING[ -]CHANGE:/m.test(rawMessage)) {
+    return "major";
+  }
+  return bumpByType.get(parsedCommit.type);
+}
+
+function bumpVersion(version, bump) {
+  if (typeof version !== "string") {
+    throw new Error("package.json version must be a string");
+  }
+
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(-.+)?$/);
+  if (!match) {
+    throw new Error(`Unsupported semver version: ${version}`);
+  }
+
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+
+  switch (bump) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+    default:
+      throw new Error(`Unsupported bump type: ${bump}`);
+  }
+}
+
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+
+function writeJson(filePath, value) {
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function fail(messageText) {
+  console.error(messageText);
+  console.error("");
+  console.error("Use Conventional Commits:");
+  console.error("  feat: add project listing");
+  console.error("  fix(projects): normalize Dokploy host");
+  console.error("  feat!: change config schema");
+  console.error("");
+  console.error("Version bump rules:");
+  console.error("  feat or feat(scope)  -> minor");
+  console.error("  fix/perf             -> patch");
+  console.error("  ! or BREAKING CHANGE -> major");
+  console.error("  docs/chore/etc.      -> no version bump");
+  process.exit(1);
+}

package/scripts/generate-changelog.mjs

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJsonPath = path.join(packageDir, "package.json");
+const changelogPath = path.join(packageDir, "CHANGELOG.md");
+const args = new Set(process.argv.slice(2));
+const dryRun = args.has("--dry-run");
+
+const packageJson = readJson(packageJsonPath);
+const version = stringValue(packageJson.version, "0.0.0");
+const today = new Date().toISOString().slice(0, 10);
+const lastTag = getLastTag();
+const commits = getCommits(lastTag);
+const section = renderVersionSection(version, today, lastTag, commits);
+
+if (dryRun) {
+  console.log(section.trimEnd());
+  process.exit(0);
+}
+
+const currentChangelog = readChangelog();
+const nextChangelog = upsertVersionSection(currentChangelog, version, section);
+writeFileSync(changelogPath, nextChangelog, "utf8");
+
+console.log(`Updated CHANGELOG.md for ${packageJson.name}@${version}`);
+
+function getLastTag() {
+  try {
+    return execFileSync("git", ["-C", packageDir, "describe", "--tags", "--abbrev=0"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return undefined;
+  }
+}
+
+function getCommits(tag) {
+  const range = tag ? [`${tag}..HEAD`] : [];
+  const output = execFileSync(
+    "git",
+    [
+      "-C",
+      packageDir,
+      "log",
+      "--date=short",
+      "--pretty=format:%H%x1f%ad%x1f%s%x1f%b%x1e",
+      ...range,
+    ],
+    { encoding: "utf8" },
+  );
+
+  return output
+    .split("\x1e")
+    .map((record) => record.trim())
+    .filter(Boolean)
+    .map(parseCommit);
+}
+
+function parseCommit(record) {
+  const [hash = "", date = "", subject = "", body = ""] = record.split("\x1f");
+  const conventional = subject.match(/^([a-z]+)(\([a-z0-9._/-]+\))?(!)?: (.+)$/);
+
+  if (!conventional) {
+    return {
+      hash,
+      date,
+      type: "other",
+      breaking: /\nBREAKING[ -]CHANGE:/m.test(body),
+      subject,
+    };
+  }
+
+  return {
+    hash,
+    date,
+    type: conventional[1],
+    breaking: Boolean(conventional[3]) || /\nBREAKING[ -]CHANGE:/m.test(body),
+    subject: conventional[4],
+  };
+}
+
+function renderVersionSection(nextVersion, date, tag, commits) {
+  const lines = [`## ${nextVersion} - ${date}`, ""];
+  lines.push(tag ? `_Changes since ${tag}._` : "_Initial changelog generated from repository history._");
+  lines.push("");
+
+  if (commits.length === 0) {
+    lines.push("- No commits found since the last tag.", "");
+    return `${lines.join("\n")}\n`;
+  }
+
+  const breaking = commits.filter((commit) => commit.breaking);
+  appendGroup(lines, "Breaking Changes", breaking);
+
+  const grouped = [
+    ["Features", ["feat"]],
+    ["Fixes", ["fix"]],
+    ["Performance", ["perf"]],
+    ["Refactoring", ["refactor"]],
+    ["Documentation", ["docs"]],
+    ["Tests", ["test"]],
+    ["Build", ["build"]],
+    ["CI", ["ci"]],
+    ["Chores", ["chore"]],
+    ["Styles", ["style"]],
+    ["Reverts", ["revert"]],
+    ["Other Changes", ["other"]],
+  ];
+
+  for (const [title, types] of grouped) {
+    appendGroup(
+      lines,
+      title,
+      commits.filter((commit) => types.includes(commit.type) && !commit.breaking),
+    );
+  }
+
+  return `${lines.join("\n").trimEnd()}\n\n`;
+}
+
+function appendGroup(lines, title, commits) {
+  if (commits.length === 0) return;
+
+  lines.push(`### ${title}`, "");
+  for (const commit of commits) {
+    lines.push(`- ${commit.subject} (${commit.hash.slice(0, 7)})`);
+  }
+  lines.push("");
+}
+
+function upsertVersionSection(currentChangelog, nextVersion, section) {
+  const header = "# Changelog\n\n";
+  const body = currentChangelog.startsWith("# Changelog\n")
+    ? currentChangelog.slice(header.length)
+    : currentChangelog.trimStart();
+  const versionHeader = `## ${nextVersion} - `;
+  const start = body.indexOf(versionHeader);
+
+  if (start === -1) {
+    return `${header}${section}${body.trimStart()}`;
+  }
+
+  const nextSectionStart = body.indexOf("\n## ", start + 1);
+  const before = body.slice(0, start);
+  const after = nextSectionStart === -1 ? "" : body.slice(nextSectionStart + 1);
+
+  return `${header}${before}${section}${after}`.replace(/\n{3,}/g, "\n\n");
+}
+
+function readChangelog() {
+  try {
+    return readFileSync(changelogPath, "utf8");
+  } catch {
+    return "# Changelog\n\n";
+  }
+}
+
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+
+function stringValue(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}

package/scripts/publish.sh

@@ -102,6 +102,15 @@ echo "CLI smoke test..."
 node dist/index.js --version
 node dist/index.js --help >/dev/null
 
+echo ""
+if [ "$PUBLISH" = "1" ]; then
+  echo "Generating changelog..."
+  "$PACKAGE_MANAGER" run changelog
+else
+  echo "Changelog dry-run..."
+  "$PACKAGE_MANAGER" run changelog -- --dry-run
+fi
+
 echo ""
 echo "Pack dry-run..."
 "$PACKAGE_MANAGER" pack --dry-run