@vsokolov/semantix 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Viktor Sokolov
+
+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,303 @@
+# Semantix
+
+A TypeScript CLI tool to automatically configure conventional commits, semantic-release, and automated releases for your projects.
+
+## Quick Start
+
+```bash
+# Install globally
+bun install -g @vsokolov/semantix
+
+# Run in your project
+cd your-project
+semantix
+
+# Make a commit
+git commit -m "feat: add new feature"
+```
+
+See [QUICKSTART.md](./QUICKSTART.md) for a detailed getting started guide.
+
+## Features
+
+- ✅ **Commitlint** - Enforces conventional commit format
+- ✅ **Lefthook** - Git hooks to validate commits
+- ✅ **Semantic Release** - Automated versioning and releases
+- ✅ **Changelog Generation** - Auto-generates CHANGELOG.md
+- ✅ **GitHub Releases** - Creates releases automatically
+- ✅ **GitHub Actions** - CI/CD workflow included
+
+## Installation
+
+### Global Installation (Recommended)
+
+```bash
+# Using Bun
+bun install -g semantix
+
+# Using npm
+npm install -g @vsokolov/semantix
+
+# Using pnpm
+pnpm add -g @vsokolov/semantix
+```
+
+### Local Installation
+
+```bash
+# Using Bun
+bun add -D @vsokolov/semantix
+
+# Using npm
+npm install --save-dev @vsokolov/semantix
+```
+
+## Usage
+
+Navigate to your project directory and run:
+
+```bash
+# If installed globally
+semantix
+
+# If installed locally
+bunx @vsokolov/semantix
+# or
+npx @vsokolov/semantix
+```
+
+That's it! Semantix will automatically configure everything for you.
+
+## Project Structure
+
+After running Semantix, your project will have:
+
+```
+your-project/
+├── .github/
+│   └── workflows/
+│       └── release.yml           # GitHub Actions workflow
+├── lefthook.yml            # Git hooks configuration
+├── commitlint.config.js          # Commit message rules
+├── .releaserc.mjs               # Semantic-release config
+├── COMMIT_CONVENTION.md          # Team documentation
+└── package.json                  # Updated with scripts
+```
+
+## What Gets Configured
+
+### 1. Dependencies Installed
+
+- `@commitlint/cli` & `@commitlint/config-conventional`
+- `@semantic-release/changelog`
+- `@semantic-release/git`
+- `@semantic-release/github`
+- `lefthook`
+- `semantic-release`
+
+### 2. Configuration Files Created
+
+- **commitlint.config.js** - Commit message validation rules
+- **.releaserc.mjs** - Semantic-release configuration
+- **lefthook.yml** - Git hooks configuration
+- **.github/workflows/release.yml** - GitHub Actions workflow
+- **COMMIT_CONVENTION.md** - Documentation for your team
+
+### 3. Package.json Scripts Added
+
+```json
+{
+    "scripts": {
+        "release": "semantic-release",
+        "release:dry": "semantic-release --dry-run",
+        "prepare": "lefthook install"
+    }
+}
+```
+
+## Commit Message Format
+
+```
+<type>[optional scope]: <description>
+
+[optional body]
+
+[optional footer]
+```
+
+### Types
+
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting)
+- `refactor`: Code refactoring
+- `perf`: Performance improvements
+- `test`: Adding or updating tests
+- `build`: Build system changes
+- `ci`: CI configuration changes
+- `chore`: Other changes
+- `revert`: Revert previous commit
+
+### Examples
+
+```bash
+git commit -m "feat: add user authentication"
+git commit -m "fix: resolve memory leak in data processing"
+git commit -m "docs: update installation instructions"
+git commit -m "feat(api)!: redesign authentication flow
+
+BREAKING CHANGE: The authentication API has been completely redesigned"
+```
+
+## How Releases Work
+
+1. **Commit** with conventional commit format
+2. **Push** to `main` or `master` branch
+3. **GitHub Actions** runs automatically
+4. **Semantic-release** analyzes commits and:
+    - Determines version bump (major/minor/patch)
+    - Generates CHANGELOG.md
+    - Creates git tag
+    - Publishes GitHub release
+    - Updates package.json version
+
+### Version Bumping
+
+- `fix:` → Patch release (1.0.0 → 1.0.1)
+- `feat:` → Minor release (1.0.0 → 1.1.0)
+- `BREAKING CHANGE:` → Major release (1.0.0 → 2.0.0)
+
+## Testing Releases
+
+Before pushing, test the release process locally:
+
+```bash
+bun run release:dry
+```
+
+This shows what would happen without actually creating a release.
+
+## GitHub Configuration
+
+### Required: GitHub Token
+
+The GitHub Actions workflow needs a `GITHUB_TOKEN` to create releases. This is automatically provided by GitHub Actions, but ensure your repository has:
+
+1. **Settings** → **Actions** → **General**
+2. **Workflow permissions** → Select "Read and write permissions"
+3. Check "Allow GitHub Actions to create and approve pull requests"
+
+## Customization
+
+### Change Release Branches
+
+Edit `.releaserc.mjs`:
+
+```javascript
+const config = {
+    branches: ['main', 'develop', { name: 'beta', prerelease: true }],
+    // ... rest of config
+};
+
+export default config;
+```
+
+### Customize Commit Types
+
+Edit `commitlint.config.js`:
+
+```javascript
+module.exports = {
+    extends: ['@commitlint/config-conventional'],
+    rules: {
+        'type-enum': [2, 'always', ['feat', 'fix', 'docs', 'custom-type']],
+    },
+};
+```
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/semantix.git
+cd semantix
+
+# Install dependencies
+bun install
+```
+
+### Local Development
+
+```bash
+# Run in watch mode
+bun run dev
+
+# Build the project
+bun run build
+
+# Test locally in another project
+bun link
+cd /path/to/test-project
+semantix
+```
+
+### Testing
+
+```bash
+# Run tests
+bun run test
+
+# Run tests with coverage
+bun run test:coverage
+
+# Type checking
+bun run typecheck
+
+# Linting
+bun run lint
+
+# Fix linting issues
+bun run lint:fix
+
+# Code formatting
+bun run format
+
+# Check formatting
+bun run format:check
+```
+
+### Publishing
+
+```bash
+# Build and publish to npm
+bun run build
+npm publish
+
+# Or use Bun to publish
+bun publish
+```
+
+## Troubleshooting
+
+### Commits are not being validated
+
+```bash
+bunx lefthook install
+```
+
+### Release not triggering
+
+- Check GitHub Actions tab for errors
+- Verify workflow permissions are set correctly
+- Ensure you're pushing to `main` or `master` branch
+
+### "No commits since last release"
+
+This means there are no conventional commits that would trigger a release (feat, fix, etc.)
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { createInterface } from "readline";
+import { resolve } from "node:path";
+
+//#region src/constants.ts
+const PM_LOCK_FILES = {
+	npm: "package-lock.json",
+	yarn: "yarn.lock",
+	pnpm: "pnpm-lock.yaml",
+	bun: ["bun.lockb", "bun.lock"]
+};
+const DEPENDENCIES = [
+	"@semantic-release/changelog",
+	"@semantic-release/git",
+	"@semantic-release/github",
+	"@commitlint/cli",
+	"@commitlint/config-conventional",
+	"lefthook",
+	"semantic-release"
+];
+const COMMIT_TYPES = [
+	"feat",
+	"fix",
+	"docs",
+	"style",
+	"refactor",
+	"perf",
+	"test",
+	"build",
+	"ci",
+	"chore",
+	"revert"
+];
+const COMMITLINT_CONFIG = {
+	extends: ["@commitlint/config-conventional"],
+	rules: {
+		"type-enum": [
+			2,
+			"always",
+			COMMIT_TYPES
+		],
+		"subject-case": [
+			2,
+			"never",
+			["upper-case"]
+		]
+	}
+};
+const SEMANTIC_RELEASE_CONFIG = {
+	branches: ["main", "master"],
+	plugins: [
+		"@semantic-release/commit-analyzer",
+		"@semantic-release/release-notes-generator",
+		["@semantic-release/changelog", { changelogFile: "CHANGELOG.md" }],
+		"@semantic-release/npm",
+		["@semantic-release/github", { assets: ["CHANGELOG.md"] }],
+		["@semantic-release/git", {
+			assets: ["CHANGELOG.md", "package.json"],
+			message: "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+		}]
+	]
+};
+const getGithubWorkflow = (pm = "bun") => {
+	return `name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+  id-token: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+${pm === "bun" ? `
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest` : `
+      - name: Setup Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: '${pm}'`}
+
+      - name: Install dependencies
+        run: ${pm === "npm" ? "npm ci" : `${pm} install`}
+
+      - name: Release
+        env:
+          GH_TOKEN: \${{ secrets.GH_TOKEN }}
+        run: ${pm === "bun" ? "bun run release" : `${pm} run release`}
+  `;
+};
+const ASCII_ART = `
+╔══════════════════════════════════════════════════════════════════════╗
+║                                                                      ║
+║   ███████╗███████╗███╗   ███╗ █████╗ ███╗   ██╗████████╗██╗██╗  ██╗  ║
+║   ██╔════╝██╔════╝████╗ ████║██╔══██╗████╗  ██║╚══██╔══╝██║╚██╗██╔╝  ║
+║   ███████╗█████╗  ██╔████╔██║███████║██╔██╗ ██║   ██║   ██║ ╚███╔╝   ║
+║   ╚════██║██╔══╝  ██║╚██╔╝██║██╔══██║██║╚██╗██║   ██║   ██║ ██╔██╗   ║
+║   ███████║███████╗██║ ╚═╝ ██║██║  ██║██║ ╚████║   ██║   ██║██╔╝ ██╗  ║
+║   ╚══════╝╚══════╝╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚═╝╚═╝  ╚═╝  ║
+║                                                                      ║
+║            Automated Conventional Commits & Releases                 ║
+║                                                                      ║
+╚══════════════════════════════════════════════════════════════════════╝
+`;
+const getLefthookConfig = (pm = "bun") => {
+	const runPrefix = pm === "bun" ? "bun run" : `${pm} run`;
+	return `pre-commit:
+  commands:
+    format-check:
+      run: ${runPrefix} format:check
+    lint:
+      run: ${runPrefix} lint
+    typecheck:
+      run: ${runPrefix} typecheck
+
+commit-msg:
+  commands:
+    commitlint:
+      run: ${pm === "bun" ? "bunx --no -- commitlint --edit {1}" : `${pm === "bun" ? "bunx" : pm === "npm" ? "npx" : pm === "yarn" ? "yarn dlx" : "pnpm dlx"} commitlint --edit {1}`}
+`;
+};
+
+//#endregion
+//#region src/utils.ts
+function log(message, type = "info") {
+	console.log(`${{
+		info: "\x1B[36m",
+		success: "\x1B[32m",
+		error: "\x1B[31m",
+		warning: "\x1B[33m"
+	}[type]}${message}`);
+}
+function execCommand(command, cwd) {
+	try {
+		execSync(command, {
+			cwd,
+			stdio: "inherit"
+		});
+	} catch (error) {
+		log(`Failed to execute: ${command}`, "error");
+		throw error;
+	}
+}
+function ensureDirectoryExists(dirPath) {
+	if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+}
+function writeJsonFile(filePath, data) {
+	writeFileSync(filePath, JSON.stringify(data, null, 4));
+}
+function writeTextFile(filePath, content) {
+	writeFileSync(filePath, content);
+}
+function readJsonFile(filePath) {
+	return JSON.parse(readFileSync(filePath, "utf-8"));
+}
+function detectPackageManager(cwd) {
+	for (const [pm, lockFiles] of Object.entries(PM_LOCK_FILES)) if ((Array.isArray(lockFiles) ? lockFiles : [lockFiles]).some((file) => existsSync(join(cwd, file)))) return pm;
+	return "bun";
+}
+function getInstallCommand(pm, dependencies) {
+	const deps = dependencies.join(" ");
+	switch (pm) {
+		case "npm": return `npm install -D ${deps}`;
+		case "yarn": return `yarn add -D ${deps}`;
+		case "pnpm": return `pnpm add -D ${deps}`;
+		case "bun": return `bun add -D ${deps}`;
+	}
+}
+function promptConfirmation(question) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return new Promise((resolve) => {
+		rl.question(`${question} (Y/n): `, (answer) => {
+			rl.close();
+			const normalized = answer.trim().toLowerCase();
+			resolve(normalized === "" || normalized === "y" || normalized === "yes");
+		});
+	});
+}
+
+//#endregion
+//#region src/configs.ts
+function createCommitlintConfig(cwd) {
+	log("📝 Creating commitlint configuration...", "info");
+	writeTextFile(join(cwd, "commitlint.config.js"), `export default ${JSON.stringify(COMMITLINT_CONFIG, null, 4)};`);
+	log("✓ commitlint.config.js created", "success");
+}
+function createSemanticReleaseConfig(cwd) {
+	log("📝 Creating semantic-release configuration...", "info");
+	const configContent = `const config = ${JSON.stringify(SEMANTIC_RELEASE_CONFIG, null, 4)};
+
+export default config;
+`;
+	writeTextFile(join(cwd, ".releaserc.mjs"), configContent);
+	log("✓ .releaserc.mjs created", "success");
+}
+function setupLefthook(cwd, pm) {
+	log("🥊 Setting up Lefthook...", "info");
+	writeTextFile(join(cwd, "lefthook.yml"), getLefthookConfig(pm));
+	try {
+		let execCmd = "npx lefthook install";
+		if (pm === "bun") execCmd = "bunx lefthook install";
+		if (pm === "yarn") execCmd = "yarn dlx lefthook install";
+		if (pm === "pnpm") execCmd = "pnpm dlx lefthook install";
+		execCommand(execCmd, cwd);
+		log("✓ Lefthook installed and configured", "success");
+	} catch (error) {
+		log(`⚠️ Failed to run 'lefthook install': ${error}`, "warning");
+	}
+}
+function updatePackageJson(cwd) {
+	log("📦 Updating package.json scripts...", "info");
+	const packageJsonPath = join(cwd, "package.json");
+	const scripts = {
+		release: "semantic-release",
+		"release:dry": "semantic-release --dry-run",
+		prepare: "lefthook install"
+	};
+	let packageJson;
+	try {
+		packageJson = readJsonFile(packageJsonPath);
+	} catch (error) {
+		throw new Error(`Failed to read package.json: ${error}`);
+	}
+	if (!packageJson.scripts || typeof packageJson.scripts !== "object") packageJson.scripts = {};
+	const existingScripts = packageJson.scripts;
+	const conflicts = [];
+	const mergedScripts = { ...existingScripts };
+	for (const [key, value] of Object.entries(scripts)) if (existingScripts[key]) {
+		if (existingScripts[key] === value) continue;
+		conflicts.push(key);
+		if (key === "prepare") {
+			const existing = existingScripts[key];
+			if (existing.includes("&&") || existing.includes("lefthook")) {
+				mergedScripts[key] = `${existing} && ${value}`;
+				log(`⚠️ Merged prepare script: "${existing}" + "${value}"`, "warning");
+			} else {
+				mergedScripts[`${key}:lefthook`] = value;
+				log(`⚠️ Conflict detected for "${key}". Preserving existing and adding "prepare:lefthook"`, "warning");
+			}
+		} else {
+			mergedScripts[`${key}:semantic`] = value;
+			log(`⚠️ Conflict detected for "${key}". Preserving existing and adding "${key}:semantic"`, "warning");
+		}
+	} else mergedScripts[key] = value;
+	packageJson.scripts = mergedScripts;
+	try {
+		writeJsonFile(packageJsonPath, packageJson);
+		log("✓ package.json updated", "success");
+		if (conflicts.length > 0) log(`ℹ️ Conflicts resolved for scripts: ${conflicts.join(", ")}`, "info");
+	} catch (error) {
+		throw new Error(`Failed to write package.json: ${error}`);
+	}
+}
+function createGitHubWorkflow(cwd, pm) {
+	log("🔄 Creating GitHub Actions workflow...", "info");
+	const workflowDir = join(cwd, ".github", "workflows");
+	ensureDirectoryExists(workflowDir);
+	writeTextFile(join(workflowDir, "release.yml"), getGithubWorkflow(pm));
+	log("✓ GitHub Actions workflow created", "success");
+}
+
+//#endregion
+//#region src/setup.ts
+var ConventionalCommitSetup = class {
+	cwd;
+	packageManager;
+	skipConfirmation;
+	constructor(cwd = process.cwd(), skipConfirmation = false) {
+		this.cwd = cwd;
+		this.packageManager = detectPackageManager(cwd);
+		this.skipConfirmation = skipConfirmation || process.env.CI === "true" || process.env.NODE_ENV === "test";
+	}
+	installDependencies() {
+		log("📦 Installing dependencies...", "info");
+		execCommand(getInstallCommand(this.packageManager, DEPENDENCIES), this.cwd);
+		log("✓ Dependencies installed", "success");
+	}
+	showPreview() {
+		const installCmd = getInstallCommand(this.packageManager, DEPENDENCIES);
+		log("\n📋 The following will be installed and configured:", "info");
+		log("\n📦 Packages to install:", "info");
+		for (const dep of DEPENDENCIES) log(`   • ${dep}`, "info");
+		log(`\n   Install command: ${installCmd}`, "info");
+		log("\n📝 Configuration files to create:", "info");
+		log("   • commitlint.config.js", "info");
+		log("   • .releaserc.mjs", "info");
+		log("   • lefthook.yml", "info");
+		log("   • .github/workflows/release.yml", "info");
+		log("\n📦 package.json scripts to add:", "info");
+		log("   • release", "info");
+		log("   • release:dry", "info");
+		log("   • prepare (lefthook install)", "info");
+	}
+	async setup() {
+		console.log(ASCII_ART);
+		log("\n🚀 Setting up Conventional Commits...\n", "info");
+		log(`ℹ️  Detected package manager: ${this.packageManager}`, "info");
+		this.showPreview();
+		if (!this.skipConfirmation) {
+			if (!await promptConfirmation("\nDo you want to proceed with the installation")) {
+				log("\n❌ Setup cancelled by user", "error");
+				process.exit(0);
+			}
+		}
+		log("\n⏳ Starting installation...\n", "info");
+		try {
+			this.installDependencies();
+			createCommitlintConfig(this.cwd);
+			createSemanticReleaseConfig(this.cwd);
+			setupLefthook(this.cwd, this.packageManager);
+			updatePackageJson(this.cwd);
+			createGitHubWorkflow(this.cwd, this.packageManager);
+			log("\n✨ Setup completed successfully!\n", "success");
+			const runCmd = this.packageManager === "bun" ? "bun run" : `${this.packageManager} run`;
+			log("Next steps:", "info");
+			log("1. Commit your changes with a conventional commit message", "info");
+			log("2. Push to main/master branch to trigger automatic release", "info");
+			log(`3. Run '${runCmd} release:dry' to test the release process\n`, "info");
+		} catch (error) {
+			log("\n❌ Setup failed", "error");
+			throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/index.ts
+new ConventionalCommitSetup(process.argv[2] ? resolve(process.argv[2]) : void 0).setup().catch((error) => {
+	console.error(error);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,68 @@
+{
+    "name": "@vsokolov/semantix",
+    "version": "1.0.0",
+    "description": "CLI tool to setup conventional commits, semantic-release, and automated releases",
+    "keywords": [
+        "cli",
+        "commitlint",
+        "conventional-commits",
+        "semantic-release",
+        "typescript"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "license": "MIT",
+    "author": "Viktor Sokolov",
+    "bin": {
+        "setup-commits": "./dist/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "type": "module",
+    "scripts": {
+        "build": "rolldown src/index.ts -o dist/index.js -f esm -p node --clean-dir",
+        "start": "bun run ./src/index.ts",
+        "dev": "bun --watch ./src/index.ts",
+        "lint": "oxlint",
+        "lint:fix": "oxlint --fix",
+        "format": "oxfmt src tests --write",
+        "format:check": "oxfmt --check src tests",
+        "typecheck": "tsc --noEmit",
+        "test": "bun test",
+        "test:coverage": "bun test --coverage",
+        "prepublishOnly": "bun run build",
+        "commit": "cz",
+        "jscpd": "jscpd src/ tests",
+        "up-latest": "bun update --latest",
+        "release": "semantic-release",
+        "release:dry": "semantic-release --dry-run",
+        "prepare": "bunx lefthook install"
+    },
+    "devDependencies": {
+        "@commitlint/cli": "^20.4.0",
+        "@commitlint/config-conventional": "^20.4.0",
+        "@semantic-release/changelog": "^6.0.3",
+        "@semantic-release/git": "^10.0.1",
+        "@semantic-release/github": "12.0.3",
+        "@types/bun": "1.3.8",
+        "@types/node": "25.2.0",
+        "find-up": "^8.0.0",
+        "jscpd": "4.0.8",
+        "lefthook": "^2.0.16",
+        "oxfmt": "0.27.0",
+        "oxlint": "1.42.0",
+        "rolldown": "1.0.0-rc.2",
+        "semantic-release": "^25.0.3",
+        "typescript": "^5.9.3"
+    },
+    "peerDependencies": {
+        "bun": "^1.3.8"
+    },
+    "config": {
+        "commitizen": {
+            "path": "cz-conventional-changelog"
+        }
+    }
+}