@makispps/releasejet 1.0.0

package/.releasejet.example.yml

@@ -0,0 +1,28 @@
+# ReleaseJet Configuration
+# Copy to .releasejet.yml and customize for your project.
+# Or run: releasejet init
+
+# GitLab instance URL
+gitlab:
+  url: https://gitlab.example.com
+
+# Client definitions (omit for single-client repos)
+# clients:
+#   - prefix: mobile
+#     label: MOBILE
+#   - prefix: web
+#     label: WEB
+
+# Category label mappings
+# Key: the label name in GitLab
+# Value: the section heading in release notes
+categories:
+  feature: "New Features"
+  bug: "Bug Fixes"
+  improvement: "Improvements"
+  breaking-change: "Breaking Changes"
+
+# How to handle uncategorized issues
+# "lenient" — include under "Other" with a warning (default)
+# "strict" — fail release generation
+uncategorized: lenient

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mavroudis Papas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+<img width="480" height="120" alt="lockup-light-1x" src="https://github.com/user-attachments/assets/1fd84e91-86f3-4f62-bad7-8bf4b72b517f" />
+
+Automated release notes generator for GitLab and GitHub. Collects closed issues (or merged pull requests) between Git tags, categorizes them by label, and publishes formatted release notes.
+
+## Features
+
+- **GitLab and GitHub support** — works with both providers out of the box
+- **Issues or Pull Requests** — generate notes from closed issues (default) or merged PRs (GitHub)
+- **Multi-client repos** — filter by client label (e.g., `mobile-v1.0.0`, `web-v2.0.0`)
+- **Single-client repos** — just use `v<semver>` tags
+- **Configurable categories** — map labels to sections (features, bugs, improvements, etc.)
+- **CI/CD integration** — runs automatically on tag push via GitLab CI or GitHub Actions
+- **Strict/lenient modes** — enforce labeling or allow uncategorized issues under "Other"
+- **Milestone detection** — automatically links the most common milestone in release notes
+
+## Quick Start
+
+```bash
+npm install -g releasejet
+
+# Interactive setup (detects provider from git remote)
+releasejet init
+
+# Preview release notes
+releasejet generate --tag v1.0.0
+
+# Generate and publish
+releasejet generate --tag v1.0.0 --publish
+```
+
+## Configuration
+
+Create `.releasejet.yml` in your project root (or run `releasejet init`):
+
+```yaml
+provider:
+  type: github       # 'gitlab' or 'github'
+  url: https://github.com
+
+# GitHub-only: generate notes from issues or pull requests
+source: issues       # 'issues' (default) or 'pull_requests'
+
+# For multi-client repos (omit for single-client)
+clients:
+  - prefix: mobile
+    label: MOBILE
+  - prefix: web
+    label: WEB
+
+categories:
+  feature: "New Features"
+  bug: "Bug Fixes"
+  improvement: "Improvements"
+  breaking-change: "Breaking Changes"
+
+uncategorized: lenient  # or "strict" to enforce labeling
+```
+
+## CI/CD Integration
+
+### GitHub Actions
+
+Run `releasejet init` and select CI setup, or add `.github/workflows/release-notes.yml`:
+
+```yaml
+name: Release Notes
+on:
+  push:
+    tags:
+      - '**'
+jobs:
+  release-notes:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm install -g releasejet
+      - run: releasejet generate --tag "${{ github.ref_name }}" --publish
+        env:
+          RELEASEJET_TOKEN: ${{ secrets.RELEASEJET_TOKEN }}
+```
+
+Set `RELEASEJET_TOKEN` as a repository secret (Settings > Secrets > Actions).
+
+### GitLab CI
+
+Add to your `.gitlab-ci.yml` (or run `releasejet ci enable`):
+
+```yaml
+release-notes:
+  stage: deploy
+  image: node:20-alpine
+  rules:
+    - if: $CI_COMMIT_TAG
+  before_script:
+    - npm install -g releasejet
+  script:
+    - releasejet generate --tag "$CI_COMMIT_TAG" --publish
+```
+
+Set `GITLAB_API_TOKEN` (or `RELEASEJET_TOKEN`) as a CI/CD variable with `api` scope.
+
+## Authentication
+
+Token resolution order:
+
+1. `RELEASEJET_TOKEN` env var (works for both providers)
+2. Provider-specific env var: `GITLAB_API_TOKEN` or `GITHUB_TOKEN`
+3. Stored credentials from `~/.releasejet/credentials.yml`
+
+## Tag Format
+
+| Repo type | Format | Example |
+|-----------|--------|---------|
+| Multi-client | `<prefix>-v<semver>` | `mobile-v1.2.0` |
+| Single-client | `v<semver>` | `v1.2.0` |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `releasejet init` | Interactive setup wizard |
+| `releasejet generate --tag <tag>` | Generate release notes |
+| `releasejet generate --tag <tag> --publish` | Generate and publish release |
+| `releasejet validate` | Check issues for proper labeling |
+| `releasejet ci enable` | Add CI configuration to `.gitlab-ci.yml` |
+| `releasejet ci disable` | Remove CI configuration |
+
+### Generate Flags
+
+| Flag | Description |
+|------|-------------|
+| `--publish` | Publish as a release on the provider |
+| `--dry-run` | Preview without publishing |
+| `--format <format>` | Output format: `markdown` (default) or `json` |
+| `--config <path>` | Custom config file path |
+| `--debug` | Show debug information |
+
+## License
+
+MIT

package/ci/release-notes-github.yml

@@ -0,0 +1,19 @@
+name: Release Notes
+on:
+  push:
+    tags:
+      - '**'
+jobs:
+  release-notes:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm install -g releasejet
+      - run: releasejet generate --tag "${{ github.ref_name }}" --publish
+        env:
+          RELEASEJET_TOKEN: ${{ secrets.RELEASEJET_TOKEN }}

package/ci/release-notes-gitlab.yml

@@ -0,0 +1,22 @@
+# ReleaseJet — Shared GitLab CI Template
+#
+# Include in your project's .gitlab-ci.yml:
+#
+#   include:
+#     - project: 'tools/releasejet'
+#       file: '/ci/release-notes.yml'
+#
+#   variables:
+#     RELEASEJET_TOKEN: $GITLAB_API_TOKEN
+
+release-notes:
+  stage: deploy
+  image: node:20-alpine
+  rules:
+    - if: $CI_COMMIT_TAG
+  variables:
+    RELEASEJET_TOKEN: ${RELEASEJET_TOKEN}
+  before_script:
+    - npm install -g releasejet
+  script:
+    - releasejet generate --tag "$CI_COMMIT_TAG" --publish

package/dist/cli.js

@@ -0,0 +1,967 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/core/config.ts
+import { readFile } from "fs/promises";
+import { parse as parseYaml } from "yaml";
+var DEFAULT_CATEGORIES = {
+  feature: "New Features",
+  bug: "Bug Fixes",
+  improvement: "Improvements",
+  "breaking-change": "Breaking Changes"
+};
+var DEFAULT_CONFIG = {
+  provider: { type: "gitlab", url: "" },
+  source: "issues",
+  clients: [],
+  categories: { ...DEFAULT_CATEGORIES },
+  uncategorized: "lenient"
+};
+async function loadConfig(configPath = ".releasejet.yml") {
+  let raw;
+  try {
+    const content = await readFile(configPath, "utf-8");
+    raw = parseYaml(content) ?? {};
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {
+        ...DEFAULT_CONFIG,
+        clients: [],
+        categories: { ...DEFAULT_CONFIG.categories }
+      };
+    }
+    throw err;
+  }
+  return mergeWithDefaults(raw);
+}
+function mergeWithDefaults(raw) {
+  const clients = raw.clients;
+  const categories = raw.categories;
+  const uncategorized = raw.uncategorized;
+  const source = raw.source;
+  const providerRaw = raw.provider;
+  const gitlabRaw = raw.gitlab;
+  let provider;
+  if (providerRaw) {
+    provider = {
+      type: providerRaw.type === "github" ? "github" : "gitlab",
+      url: providerRaw.url ?? ""
+    };
+  } else if (gitlabRaw) {
+    provider = {
+      type: "gitlab",
+      url: gitlabRaw.url ?? ""
+    };
+  } else {
+    provider = { type: "gitlab", url: "" };
+  }
+  return {
+    provider,
+    source: source === "pull_requests" ? "pull_requests" : "issues",
+    clients: Array.isArray(clients) ? clients : [],
+    categories: categories ?? { ...DEFAULT_CATEGORIES },
+    uncategorized: uncategorized === "strict" ? "strict" : "lenient"
+  };
+}
+
+// src/core/git.ts
+import { execSync } from "child_process";
+function getRemoteUrl() {
+  return execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
+}
+function resolveHostUrl(remoteUrl) {
+  const sshMatch = remoteUrl.match(/^git@([^:]+):/);
+  if (sshMatch) return `https://${sshMatch[1]}`;
+  const httpsMatch = remoteUrl.match(/^(https?:\/\/[^/]+)/);
+  if (httpsMatch) return httpsMatch[1];
+  throw new Error(`Cannot parse host URL from remote: ${remoteUrl}`);
+}
+function resolveProjectInfo(remoteUrl) {
+  if (process.env.GITHUB_SERVER_URL && process.env.GITHUB_REPOSITORY) {
+    return {
+      hostUrl: process.env.GITHUB_SERVER_URL,
+      projectPath: process.env.GITHUB_REPOSITORY
+    };
+  }
+  if (process.env.CI_SERVER_URL && process.env.CI_PROJECT_PATH) {
+    return {
+      hostUrl: process.env.CI_SERVER_URL,
+      projectPath: process.env.CI_PROJECT_PATH
+    };
+  }
+  return {
+    hostUrl: resolveHostUrl(remoteUrl),
+    projectPath: resolveProjectPath(remoteUrl)
+  };
+}
+function resolveProjectPath(remoteUrl) {
+  const sshMatch = remoteUrl.match(/^git@[^:]+:(.+?)(?:\.git)?$/);
+  if (sshMatch) return sshMatch[1];
+  const httpsMatch = remoteUrl.match(/^https?:\/\/[^/]+\/(.+?)(?:\.git)?$/);
+  if (httpsMatch) return httpsMatch[1];
+  throw new Error(`Cannot parse project path from remote: ${remoteUrl}`);
+}
+function detectProviderFromRemote(remoteUrl) {
+  return remoteUrl.includes("github.com") ? "github" : "gitlab";
+}
+
+// src/core/tag-parser.ts
+import * as semver from "semver";
+function parseTag(tag) {
+  const multiMatch = tag.match(/^(.+?)-v(.+)$/);
+  if (multiMatch) {
+    const [, prefix, versionPart] = multiMatch;
+    const coerced = semver.coerce(versionPart);
+    if (coerced) {
+      const suffix = versionPart.slice(coerced.version.length) || null;
+      return { raw: tag, prefix, version: coerced.version, suffix };
+    }
+  }
+  const singleMatch = tag.match(/^v(.+)$/);
+  if (singleMatch) {
+    const [, versionPart] = singleMatch;
+    const coerced = semver.coerce(versionPart);
+    if (coerced) {
+      const suffix = versionPart.slice(coerced.version.length) || null;
+      return { raw: tag, prefix: null, version: coerced.version, suffix };
+    }
+  }
+  throw new Error(
+    `Invalid tag format: "${tag}". Expected <prefix>-v<semver> or v<semver>.`
+  );
+}
+function findPreviousTag(allTags, current) {
+  const candidates = allTags.filter((t) => t.prefix === current.prefix && t.raw !== current.raw).filter((t) => t.suffix === null).filter((t) => semver.lt(t.version, current.version)).sort((a, b) => {
+    const cmp = semver.rcompare(a.version, b.version);
+    if (cmp !== 0) return cmp;
+    return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+  });
+  return candidates[0] ?? null;
+}
+
+// src/core/issue-collector.ts
+async function collectIssues(client, projectPath, currentTag, previousTag, config, debug = () => {
+}) {
+  const clientLabel = currentTag.prefix ? config.clients.find((c) => c.prefix === currentTag.prefix)?.label : void 0;
+  debug("Client label filter:", clientLabel ?? "none (single-client)");
+  debug("API query: state=closed, updatedAfter=" + (previousTag?.createdAt ?? "none"));
+  const fetchOptions = {
+    state: "closed",
+    updatedAfter: previousTag?.createdAt,
+    labels: clientLabel
+  };
+  const issues = config.source === "pull_requests" ? await client.listPullRequests(projectPath, fetchOptions) : await client.listIssues(projectPath, fetchOptions);
+  debug(`API returned ${issues.length} issues:`);
+  for (const issue of issues) {
+    debug(`  #${issue.number} "${issue.title}" closedAt=${issue.closedAt} labels=[${issue.labels.join(", ")}]`);
+  }
+  const filtered = issues.filter((issue) => {
+    if (!issue.closedAt) return false;
+    const closed = new Date(issue.closedAt).getTime();
+    const before = new Date(currentTag.createdAt).getTime();
+    if (closed > before) return false;
+    if (previousTag) {
+      const after = new Date(previousTag.createdAt).getTime();
+      if (closed <= after) return false;
+    }
+    return true;
+  });
+  debug(`After closedAt filter: ${filtered.length} issues remain`);
+  const categoryLabels = Object.keys(config.categories);
+  const categorized = {};
+  const uncategorized = [];
+  for (const issue of filtered) {
+    const matchedLabel = issue.labels.find(
+      (l) => categoryLabels.includes(l)
+    );
+    if (matchedLabel) {
+      const heading = config.categories[matchedLabel];
+      if (!categorized[heading]) categorized[heading] = [];
+      categorized[heading].push(issue);
+    } else {
+      uncategorized.push(issue);
+    }
+  }
+  return { categorized, uncategorized };
+}
+function detectMilestone(issues) {
+  const allIssues = [
+    ...Object.values(issues.categorized).flat(),
+    ...issues.uncategorized
+  ];
+  const counts = /* @__PURE__ */ new Map();
+  for (const issue of allIssues) {
+    if (issue.milestone) {
+      const existing = counts.get(issue.milestone.title);
+      counts.set(issue.milestone.title, {
+        count: (existing?.count ?? 0) + 1,
+        url: issue.milestone.url
+      });
+    }
+  }
+  if (counts.size === 0) return null;
+  const [title, { url }] = [...counts.entries()].sort((a, b) => b[1].count - a[1].count)[0];
+  return { title, url };
+}
+
+// src/core/formatter.ts
+function formatReleaseNotes(data, config) {
+  const lines = [];
+  const title = data.clientPrefix ? `${data.clientPrefix.toUpperCase()} v${data.version}` : `v${data.version}`;
+  lines.push(`## ${title}`);
+  lines.push("");
+  const tagUrl = config.provider.type === "github" ? `${data.projectUrl}/releases/tag/${data.tagName}` : `${data.projectUrl}/-/tags/${data.tagName}`;
+  const metaParts = [
+    `**Released:** ${data.date}`,
+    `**Tag:** [${data.tagName}](${tagUrl})`
+  ];
+  if (data.milestone) {
+    metaParts.push(`**Milestone:** [${data.milestone.title}](${data.milestone.url})`);
+  }
+  const issuesSummary = data.uncategorizedCount > 0 ? `${data.totalCount} closed | ${data.uncategorizedCount} uncategorized` : `${data.totalCount} closed`;
+  metaParts.push(`**Issues:** ${issuesSummary}`);
+  lines.push(metaParts.join(" | "));
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  const categoryOrder = Object.values(config.categories);
+  for (const heading of categoryOrder) {
+    const issues = data.issues.categorized[heading];
+    if (!issues || issues.length === 0) continue;
+    lines.push(`#### ${heading}`);
+    for (const issue of issues) {
+      lines.push(`- ${issue.title} (#${issue.number})`);
+    }
+    lines.push("");
+  }
+  if (data.issues.uncategorized.length > 0 && config.uncategorized === "lenient") {
+    lines.push("#### Other");
+    for (const issue of data.issues.uncategorized) {
+      lines.push(`- ${issue.title} (#${issue.number})`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by [ReleaseJet](https://github.com/makisp/releasejet)*");
+  return lines.join("\n");
+}
+
+// src/gitlab/client.ts
+import { Gitlab } from "@gitbeaker/rest";
+function createGitLabClient(url, token) {
+  const api = new Gitlab({ host: url, token });
+  return {
+    async listTags(projectPath) {
+      const tags = await api.Tags.all(projectPath);
+      return tags.map((t) => ({
+        name: t.name,
+        createdAt: t.created_at ?? t.commit?.created_at ?? ""
+      }));
+    },
+    async listIssues(projectPath, options) {
+      const params = {
+        projectId: projectPath,
+        state: options.state ?? "closed"
+      };
+      if (options.updatedAfter) params.updatedAfter = options.updatedAfter;
+      if (options.labels) params.labels = options.labels;
+      const issues = await api.Issues.all(params);
+      return issues.map((i) => ({
+        number: i.iid,
+        title: i.title,
+        labels: i.labels,
+        closedAt: i.closed_at ?? "",
+        webUrl: i.web_url,
+        milestone: i.milestone ? { title: i.milestone.title, url: i.milestone.web_url } : null
+      }));
+    },
+    async listPullRequests(_projectPath, _options) {
+      throw new Error("listPullRequests is not supported by the GitLab provider");
+    },
+    async createRelease(projectPath, options) {
+      const params = {
+        tag_name: options.tagName,
+        name: options.name,
+        description: options.description
+      };
+      if (options.milestones?.length) {
+        params.milestones = options.milestones;
+      }
+      await api.ProjectReleases.create(projectPath, params);
+    },
+    async listMilestones(projectPath, options) {
+      const params = {};
+      if (options?.search) params.search = options.search;
+      if (options?.state) params.state = options.state;
+      const milestones = await api.ProjectMilestones.all(projectPath, params);
+      return milestones.map((m) => ({
+        id: m.id,
+        title: m.title,
+        state: m.state
+      }));
+    }
+  };
+}
+
+// src/github/client.ts
+import { Octokit } from "@octokit/rest";
+function parseOwnerRepo(projectPath) {
+  const [owner, repo] = projectPath.split("/");
+  return { owner, repo };
+}
+function createGitHubClient(url, token) {
+  const baseUrl = url && url !== "https://github.com" ? `${url.replace(/\/$/, "")}/api/v3` : void 0;
+  const octokit = new Octokit({ auth: token, baseUrl });
+  return {
+    async listTags(projectPath) {
+      const { owner, repo } = parseOwnerRepo(projectPath);
+      const { data: tags } = await octokit.repos.listTags({ owner, repo, per_page: 100 });
+      const result = [];
+      for (const tag of tags) {
+        const { data: commit } = await octokit.repos.getCommit({ owner, repo, ref: tag.commit.sha });
+        result.push({
+          name: tag.name,
+          createdAt: commit.commit.committer?.date ?? ""
+        });
+      }
+      return result;
+    },
+    async listIssues(projectPath, options) {
+      const { owner, repo } = parseOwnerRepo(projectPath);
+      const params = {
+        owner,
+        repo,
+        state: options.state ?? "closed",
+        per_page: 100
+      };
+      if (options.updatedAfter) params.since = options.updatedAfter;
+      if (options.labels) params.labels = options.labels;
+      const { data: issues } = await octokit.issues.listForRepo(params);
+      return issues.filter((i) => !i.pull_request).map((i) => ({
+        number: i.number,
+        title: i.title,
+        labels: i.labels.map((l) => typeof l === "string" ? l : l.name),
+        closedAt: i.closed_at ?? "",
+        webUrl: i.html_url,
+        milestone: i.milestone ? { title: i.milestone.title, url: i.milestone.html_url } : null
+      }));
+    },
+    async listPullRequests(projectPath, options) {
+      const { owner, repo } = parseOwnerRepo(projectPath);
+      const params = {
+        owner,
+        repo,
+        state: options.state ?? "closed",
+        per_page: 100
+      };
+      const { data: prs } = await octokit.pulls.list(params);
+      return prs.filter((pr) => pr.merged_at !== null).map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        labels: pr.labels.map((l) => typeof l === "string" ? l : l.name),
+        closedAt: pr.closed_at ?? "",
+        webUrl: pr.html_url,
+        milestone: pr.milestone ? { title: pr.milestone.title, url: pr.milestone.html_url } : null
+      }));
+    },
+    async createRelease(projectPath, options) {
+      const { owner, repo } = parseOwnerRepo(projectPath);
+      await octokit.repos.createRelease({
+        owner,
+        repo,
+        tag_name: options.tagName,
+        name: options.name,
+        body: options.description
+      });
+    },
+    async listMilestones(projectPath, options) {
+      const { owner, repo } = parseOwnerRepo(projectPath);
+      const params = { owner, repo, per_page: 100 };
+      if (options?.state) params.state = options.state;
+      const { data: milestones } = await octokit.issues.listMilestones(params);
+      return milestones.map((m) => ({
+        id: m.number,
+        title: m.title,
+        state: m.state
+      }));
+    }
+  };
+}
+
+// src/providers/factory.ts
+function createClient(config, token) {
+  if (config.provider.type === "github") {
+    return createGitHubClient(config.provider.url, token);
+  }
+  return createGitLabClient(config.provider.url, token);
+}
+
+// src/cli/auth.ts
+import { readFile as readFile2 } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { parse as parseYaml2 } from "yaml";
+async function resolveToken(providerType) {
+  const envToken = process.env.RELEASEJET_TOKEN;
+  if (envToken) return envToken;
+  const providerEnvVar = providerType === "github" ? "GITHUB_TOKEN" : "GITLAB_API_TOKEN";
+  const providerToken = process.env[providerEnvVar];
+  if (providerToken) return providerToken;
+  try {
+    const credPath = join(homedir(), ".releasejet", "credentials.yml");
+    const content = (await readFile2(credPath, "utf-8")).trim();
+    const creds = parseYaml2(content);
+    if (creds?.[providerType]) return creds[providerType];
+  } catch {
+  }
+  try {
+    const legacyPath = join(homedir(), ".releasejet", "credentials");
+    const stored = (await readFile2(legacyPath, "utf-8")).trim();
+    if (stored) return stored;
+  } catch {
+  }
+  const providerName = providerType === "github" ? "GitHub" : "GitLab";
+  throw new Error(
+    `${providerName} API token not found. Set RELEASEJET_TOKEN environment variable or run \`releasejet init\`.`
+  );
+}
+
+// src/cli/prompts.ts
+import { select } from "@inquirer/prompts";
+async function promptForUncategorized(issues, config) {
+  console.log(
+    `
+\u26A0 ${issues.uncategorized.length} uncategorized issues found:
+`
+  );
+  const categoryChoices = Object.entries(config.categories).map(
+    ([label, heading]) => ({
+      name: `${heading} (${label})`,
+      value: label
+    })
+  );
+  const toProcess = [...issues.uncategorized];
+  issues.uncategorized.length = 0;
+  for (const issue of toProcess) {
+    const action = await select({
+      message: `#${issue.number} - ${issue.title}:`,
+      choices: [
+        ...categoryChoices,
+        { name: "Skip (exclude)", value: "skip" },
+        { name: "Other (uncategorized)", value: "other" }
+      ]
+    });
+    if (action === "skip") continue;
+    if (action === "other") {
+      issues.uncategorized.push(issue);
+    } else {
+      const heading = config.categories[action];
+      if (!issues.categorized[heading]) issues.categorized[heading] = [];
+      issues.categorized[heading].push(issue);
+    }
+  }
+}
+
+// src/cli/commands/generate.ts
+function registerGenerateCommand(program2) {
+  program2.command("generate").description("Generate release notes for a tag").requiredOption("--tag <tag>", "Git tag to generate release notes for").option("--publish", "Publish release", false).option("--dry-run", "Preview without publishing", false).option("--format <format>", "Output format (markdown|json)", "markdown").option("--config <path>", "Config file path", ".releasejet.yml").option("--debug", "Show debug information", false).action(async (options) => {
+    await runGenerate(options);
+  });
+}
+async function runGenerate(options) {
+  const debug = options.debug ? (...args) => console.error("[DEBUG]", ...args) : () => {
+  };
+  const config = await loadConfig(options.config);
+  debug("Config loaded:", JSON.stringify(config, null, 2));
+  const remoteUrl = process.env.CI_SERVER_URL || process.env.GITHUB_SERVER_URL ? "" : getRemoteUrl();
+  const { hostUrl: detectedUrl, projectPath } = resolveProjectInfo(remoteUrl);
+  const hostUrl = config.provider.url || detectedUrl;
+  debug("Host URL:", hostUrl);
+  debug("Project path:", projectPath);
+  const token = await resolveToken(config.provider.type);
+  const client = createClient(config, token);
+  const currentParsed = parseTag(options.tag);
+  debug("Parsed tag:", JSON.stringify(currentParsed));
+  const apiTags = await client.listTags(projectPath);
+  debug("All remote tags:", apiTags.map((t) => `${t.name} (${t.createdAt})`).join(", "));
+  const allTags = apiTags.map((t) => {
+    try {
+      const parsed = parseTag(t.name);
+      return { ...parsed, createdAt: t.createdAt };
+    } catch {
+      return null;
+    }
+  }).filter((t) => t !== null);
+  const currentTag = allTags.find((t) => t.raw === options.tag);
+  if (!currentTag) {
+    throw new Error(
+      `Tag "${options.tag}" not found in remote repository.`
+    );
+  }
+  debug("Current tag:", JSON.stringify(currentTag));
+  const previousTag = findPreviousTag(allTags, currentTag);
+  debug("Previous tag:", previousTag ? JSON.stringify(previousTag) : "none (first release)");
+  debug("Date range:", previousTag?.createdAt ?? "beginning", "->", currentTag.createdAt);
+  const issues = await collectIssues(
+    client,
+    projectPath,
+    currentTag,
+    previousTag,
+    config,
+    debug
+  );
+  if (issues.uncategorized.length > 0) {
+    if (process.stdin.isTTY) {
+      await promptForUncategorized(issues, config);
+    } else if (config.uncategorized === "strict") {
+      console.error("Error: Uncategorized issues found (strict mode):");
+      for (const issue of issues.uncategorized) {
+        console.error(`  #${issue.number} - ${issue.title}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const milestone = detectMilestone(issues);
+  const totalCount = Object.values(issues.categorized).reduce(
+    (sum, arr) => sum + arr.length,
+    0
+  ) + issues.uncategorized.length;
+  const data = {
+    tagName: options.tag,
+    version: currentParsed.version,
+    clientPrefix: currentParsed.prefix,
+    date: currentTag.createdAt.split("T")[0],
+    milestone,
+    projectUrl: `${hostUrl}/${projectPath}`,
+    issues,
+    totalCount,
+    uncategorizedCount: issues.uncategorized.length
+  };
+  if (options.format === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    const markdown = formatReleaseNotes(data, config);
+    console.log(markdown);
+    if (options.publish && !options.dryRun) {
+      const releaseName = currentParsed.prefix ? `${currentParsed.prefix.toUpperCase()} v${currentParsed.version}` : `v${currentParsed.version}`;
+      await client.createRelease(projectPath, {
+        tagName: options.tag,
+        name: releaseName,
+        description: markdown,
+        milestones: milestone ? [milestone] : void 0
+      });
+      console.log(`
+\u2713 Release published for ${options.tag}`);
+    }
+  }
+}
+
+// src/cli/commands/validate.ts
+function registerValidateCommand(program2) {
+  program2.command("validate").description("Check open issues for proper labeling").option("--config <path>", "Config file path", ".releasejet.yml").action(async (options) => {
+    await runValidate(options);
+  });
+}
+async function runValidate(options) {
+  const config = await loadConfig(options.config);
+  const remoteUrl = getRemoteUrl();
+  const hostUrl = config.provider.url || resolveHostUrl(remoteUrl);
+  const projectPath = resolveProjectPath(remoteUrl);
+  const token = await resolveToken(config.provider.type);
+  const client = createClient(config, token);
+  const issues = await client.listIssues(projectPath, {
+    state: "opened"
+  });
+  const categoryLabels = Object.keys(config.categories);
+  const clientLabels = config.clients.map((c) => c.label);
+  const isMultiClient = clientLabels.length > 0;
+  const problems = [];
+  for (const issue of issues) {
+    const missing = [];
+    if (isMultiClient && !issue.labels.some((l) => clientLabels.includes(l))) {
+      missing.push("client label");
+    }
+    if (!issue.labels.some((l) => categoryLabels.includes(l))) {
+      missing.push("category label");
+    }
+    if (missing.length > 0) {
+      problems.push({ number: issue.number, title: issue.title, missing });
+    }
+  }
+  if (problems.length === 0) {
+    console.log("\u2713 All open issues are properly labeled.");
+    return;
+  }
+  console.log(`\u26A0 ${problems.length} issues with missing labels:
+`);
+  for (const p of problems) {
+    console.log(`  #${p.number} - ${p.title}`);
+    console.log(`    Missing: ${p.missing.join(", ")}`);
+  }
+  process.exitCode = 1;
+}
+
+// src/cli/commands/init.ts
+import { readFile as readFile3, writeFile, mkdir } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { input, confirm, select as select2 } from "@inquirer/prompts";
+import { stringify as stringifyYaml, parse as parseYaml3 } from "yaml";
+
+// src/core/ci.ts
+var CI_MARKER_START = "# --- ReleaseJet CI (managed by releasejet) ---";
+var CI_MARKER_END = "# --- End ReleaseJet CI ---";
+var DEFAULT_TAGS = ["short-duration"];
+function generateCiBlock(tags) {
+  const tagLines = tags.map((t) => `    - ${t}`).join("\n");
+  return [
+    CI_MARKER_START,
+    "release-notes:",
+    "  stage: deploy",
+    "  image: node:20-alpine",
+    "  rules:",
+    "    - if: $CI_COMMIT_TAG",
+    "  tags:",
+    tagLines,
+    "  before_script:",
+    "    - npm install -g releasejet",
+    "  script:",
+    '    - releasejet generate --tag "$CI_COMMIT_TAG" --publish',
+    CI_MARKER_END
+  ].join("\n");
+}
+function hasCiBlock(content) {
+  const start = content.indexOf(CI_MARKER_START);
+  const end = content.indexOf(CI_MARKER_END);
+  return start !== -1 && end !== -1 && start < end;
+}
+function appendCiBlock(existingContent, block) {
+  const trimmed = existingContent.trimEnd();
+  if (trimmed.length === 0) return block + "\n";
+  return trimmed + "\n\n" + block + "\n";
+}
+function removeCiBlock(content) {
+  const startIdx = content.indexOf(CI_MARKER_START);
+  const endIdx = content.indexOf(CI_MARKER_END);
+  if (startIdx === -1 || endIdx === -1) return content;
+  if (startIdx > endIdx) return content;
+  const before = content.substring(0, startIdx);
+  const after = content.substring(endIdx + CI_MARKER_END.length);
+  const cleaned = (before + after).replace(/\n{3,}/g, "\n\n").trim();
+  return cleaned;
+}
+
+// src/cli/commands/init.ts
+var GITHUB_ACTIONS_TEMPLATE = `name: Release Notes
+on:
+  push:
+    tags:
+      - '**'
+jobs:
+  release-notes:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm install -g releasejet
+      - run: releasejet generate --tag "\${{ github.ref_name }}" --publish
+        env:
+          RELEASEJET_TOKEN: \${{ secrets.RELEASEJET_TOKEN }}
+`;
+function registerInitCommand(program2) {
+  program2.command("init").description("Interactive setup for ReleaseJet").action(async () => {
+    await runInit();
+  });
+}
+async function runInit() {
+  console.log("\u{1F680} ReleaseJet Setup\n");
+  let detectedProvider = "gitlab";
+  let defaultUrl = "";
+  try {
+    const remoteUrl = getRemoteUrl();
+    detectedProvider = detectProviderFromRemote(remoteUrl);
+    defaultUrl = resolveHostUrl(remoteUrl);
+  } catch {
+  }
+  const providerType = await select2({
+    message: "Which provider are you using?",
+    choices: [
+      { name: "GitLab", value: "gitlab" },
+      { name: "GitHub", value: "github" }
+    ],
+    default: detectedProvider
+  });
+  const urlDefault = providerType === "github" ? defaultUrl || "https://github.com" : defaultUrl || "https://gitlab.example.com";
+  const providerUrl = await input({
+    message: providerType === "github" ? "GitHub URL:" : "GitLab instance URL:",
+    default: urlDefault
+  });
+  let source;
+  if (providerType === "github") {
+    source = await select2({
+      message: "Generate release notes from:",
+      choices: [
+        { name: "Issues", value: "issues" },
+        { name: "Pull requests", value: "pull_requests" }
+      ],
+      default: "issues"
+    });
+  }
+  const isMultiClient = await confirm({
+    message: "Is this a multi-client repository?",
+    default: false
+  });
+  const clients = [];
+  if (isMultiClient) {
+    let addMore = true;
+    while (addMore) {
+      const prefix = await input({
+        message: 'Client tag prefix (e.g., "mobile"):'
+      });
+      const label = await input({
+        message: `Label for "${prefix}" (e.g., "MOBILE"):`,
+        default: prefix.toUpperCase()
+      });
+      clients.push({ prefix, label });
+      addMore = await confirm({
+        message: "Add another client?",
+        default: false
+      });
+    }
+  }
+  const uncategorized = await select2({
+    message: "How to handle uncategorized issues?",
+    choices: [
+      {
+        name: 'Lenient \u2014 include under "Other" with a warning',
+        value: "lenient"
+      },
+      {
+        name: "Strict \u2014 fail release generation",
+        value: "strict"
+      }
+    ]
+  });
+  const defaultCategories = {
+    feature: "New Features",
+    bug: "Bug Fixes",
+    improvement: "Improvements",
+    "breaking-change": "Breaking Changes"
+  };
+  const categoryMode = await select2({
+    message: "Issue categories (editable later in .releasejet.yml):",
+    choices: [
+      {
+        name: "Use defaults (feature, bug, improvement, breaking-change)",
+        value: "defaults"
+      },
+      {
+        name: "Keep defaults and add custom categories",
+        value: "extend"
+      },
+      {
+        name: "Define only my own categories (ignore defaults)",
+        value: "custom"
+      }
+    ]
+  });
+  let categories;
+  if (categoryMode === "defaults") {
+    categories = { ...defaultCategories };
+  } else {
+    categories = categoryMode === "extend" ? { ...defaultCategories } : {};
+    const existing = new Set(Object.keys(categories));
+    let needsAtLeastOne = categoryMode === "custom";
+    while (true) {
+      const label = await input({
+        message: needsAtLeastOne ? "At least one category is required. Label (as it appears in GitLab):" : "Label (as it appears in GitLab, or press Enter when done):"
+      });
+      if (!label.trim()) {
+        if (categoryMode === "custom" && Object.keys(categories).length === 0) {
+          needsAtLeastOne = true;
+          continue;
+        }
+        break;
+      }
+      if (existing.has(label.trim())) {
+        continue;
+      }
+      const heading = await input({
+        message: `Section heading in release notes:`
+      });
+      const finalLabel = label.trim();
+      const finalHeading = heading.trim() || finalLabel.charAt(0).toUpperCase() + finalLabel.slice(1);
+      categories[finalLabel] = finalHeading;
+      existing.add(finalLabel);
+      needsAtLeastOne = false;
+      console.log(`  Added: ${finalLabel} \u2192 "${finalHeading}"`);
+    }
+  }
+  const config = {
+    provider: { type: providerType, url: providerUrl },
+    categories,
+    uncategorized
+  };
+  if (source && source !== "issues") {
+    config.source = source;
+  }
+  if (clients.length > 0) {
+    config.clients = clients;
+  }
+  const yamlContent = stringifyYaml(config);
+  await writeFile(".releasejet.yml", yamlContent);
+  console.log("\n\u2713 Created .releasejet.yml");
+  const ciLabel = providerType === "github" ? "GitHub Actions" : "GitLab CI/CD";
+  const setupCi = await confirm({
+    message: `Set up ${ciLabel} integration?`,
+    default: true
+  });
+  if (setupCi) {
+    if (providerType === "github") {
+      await setupGitHubActions();
+    } else {
+      await setupGitLabCi();
+    }
+  }
+  const tokenMessage = providerType === "github" ? "GitHub personal access token (repo scope):" : "GitLab API token (api scope):";
+  const token = await input({ message: tokenMessage });
+  if (token) {
+    const credDir = join2(homedir2(), ".releasejet");
+    await mkdir(credDir, { recursive: true });
+    const credPath = join2(credDir, "credentials.yml");
+    let existingCreds = {};
+    try {
+      const content = await readFile3(credPath, "utf-8");
+      existingCreds = parseYaml3(content) ?? {};
+    } catch {
+    }
+    existingCreds[providerType] = token;
+    const yamlCreds = stringifyYaml(existingCreds);
+    await writeFile(credPath, yamlCreds, { mode: 384 });
+    console.log(`\u2713 Token stored in ${credPath}`);
+  }
+  console.log("\nSetup complete! You can now run:");
+  console.log(
+    "  releasejet generate --tag <tag>          # Preview release notes"
+  );
+  console.log(
+    "  releasejet generate --tag <tag> --publish # Publish release"
+  );
+  console.log(
+    "  releasejet validate                       # Check issue labels"
+  );
+}
+async function setupGitLabCi() {
+  const tagsInput = await input({
+    message: 'Runner tags (comma-separated, or Enter for "short-duration"):'
+  });
+  const ciTags = tagsInput.trim() ? tagsInput.split(",").map((t) => t.trim()).filter(Boolean) : DEFAULT_TAGS;
+  let existingCi = "";
+  try {
+    existingCi = await readFile3(".gitlab-ci.yml", "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  if (hasCiBlock(existingCi)) {
+    console.log("  ReleaseJet CI is already configured.");
+  } else {
+    const block = generateCiBlock(ciTags);
+    const ciContent = appendCiBlock(existingCi, block);
+    await writeFile(".gitlab-ci.yml", ciContent);
+    console.log("\u2713 Created .gitlab-ci.yml with ReleaseJet CI configuration");
+  }
+}
+async function setupGitHubActions() {
+  const workflowPath = ".github/workflows/release-notes.yml";
+  let exists = false;
+  try {
+    await readFile3(workflowPath, "utf-8");
+    exists = true;
+  } catch {
+  }
+  if (exists) {
+    console.log("  GitHub Actions workflow already exists.");
+    return;
+  }
+  await mkdir(".github/workflows", { recursive: true });
+  await writeFile(workflowPath, GITHUB_ACTIONS_TEMPLATE);
+  console.log("\u2713 Created .github/workflows/release-notes.yml");
+}
+
+// src/cli/commands/ci.ts
+import { readFile as readFile4, writeFile as writeFile2, unlink } from "fs/promises";
+import { input as input2 } from "@inquirer/prompts";
+var CI_FILE = ".gitlab-ci.yml";
+function registerCiCommand(program2) {
+  const ci = program2.command("ci").description("Manage GitLab CI/CD integration");
+  ci.command("enable").description("Add ReleaseJet CI configuration to .gitlab-ci.yml").option("--tags <tags>", "Runner tags (comma-separated)").action(async (options) => {
+    await runCiEnable(options);
+  });
+  ci.command("disable").description("Remove ReleaseJet CI configuration from .gitlab-ci.yml").action(async () => {
+    await runCiDisable();
+  });
+}
+async function runCiEnable(options) {
+  let existing = "";
+  try {
+    existing = await readFile4(CI_FILE, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  if (hasCiBlock(existing)) {
+    console.log("ReleaseJet CI is already enabled.");
+    return;
+  }
+  let tags;
+  if (options.tags) {
+    tags = options.tags.split(",").map((t) => t.trim()).filter(Boolean);
+  } else {
+    const tagsInput = await input2({
+      message: 'Runner tags (comma-separated, or Enter for "short-duration"):'
+    });
+    tags = tagsInput.trim() ? tagsInput.split(",").map((t) => t.trim()).filter(Boolean) : DEFAULT_TAGS;
+  }
+  const block = generateCiBlock(tags);
+  const content = appendCiBlock(existing, block);
+  await writeFile2(CI_FILE, content);
+  console.log("\u2713 ReleaseJet CI configuration added to .gitlab-ci.yml");
+}
+async function runCiDisable() {
+  let existing;
+  try {
+    existing = await readFile4(CI_FILE, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    console.log("ReleaseJet CI is not configured.");
+    return;
+  }
+  if (!hasCiBlock(existing)) {
+    console.log("ReleaseJet CI is not configured.");
+    return;
+  }
+  const cleaned = removeCiBlock(existing);
+  if (cleaned.trim().length === 0) {
+    await unlink(CI_FILE);
+    console.log("\u2713 Removed .gitlab-ci.yml (no other configuration found)");
+  } else {
+    await writeFile2(CI_FILE, cleaned + "\n");
+    console.log("\u2713 ReleaseJet CI configuration removed from .gitlab-ci.yml");
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("releasejet").description("Automated GitLab release notes generator").version("1.0.0");
+registerGenerateCommand(program);
+registerValidateCommand(program);
+registerInitCommand(program);
+registerCiCommand(program);
+program.parse();

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@makispps/releasejet",
+  "version": "1.0.0",
+  "description": "Automated release notes generator for GitLab and GitHub",
+  "license": "MIT",
+  "author": "Mavroudis Papas",
+  "homepage": "https://www.releasejet.dev/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/makisp/releasejet.git"
+  },
+  "bugs": {
+    "url": "https://github.com/makisp/releasejet/issues"
+  },
+  "keywords": [
+    "release-notes",
+    "changelog",
+    "gitlab",
+    "github",
+    "cli",
+    "automation",
+    "ci-cd"
+  ],
+  "type": "module",
+  "bin": {
+    "releasejet": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "ci",
+    ".releasejet.example.yml"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "dev": "tsx src/cli/index.ts",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "dependencies": {
+    "@gitbeaker/rest": "^41.3.0",
+    "@inquirer/prompts": "^7.2.0",
+    "@octokit/rest": "^22.0.1",
+    "commander": "^13.1.0",
+    "semver": "^7.7.1",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@types/semver": "^7.5.8",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}