deadbranch 0.0.1 → 0.1.1

package/README.md

@@ -1,45 +1,56 @@
-# deadbranch
+# deadbranch npm package
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+This is the npm distribution package for [deadbranch](https://github.com/armgabrielyan/deadbranch), a CLI tool to clean up stale git branches safely.
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+## Installation
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+```bash
+npm install -g deadbranch
+```
 
-## Purpose
+Or run directly with npx:
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `deadbranch`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+```bash
+npx deadbranch list
+```
 
-## What is OIDC Trusted Publishing?
+## What this package does
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+When you install this package, it automatically downloads the appropriate pre-built binary for your platform from GitHub Releases. Supported platforms:
 
-## Setup Instructions
+- macOS (Intel & Apple Silicon)
+- Linux (x64 & ARM64)
+- Windows (x64)
 
-To properly configure OIDC trusted publishing for this package:
+## Alternative installation methods
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+If npm installation fails, you can install deadbranch using other methods:
 
-## DO NOT USE THIS PACKAGE
+### Shell installer (Linux/macOS)
+```bash
+curl -sSf https://raw.githubusercontent.com/armgabrielyan/deadbranch/main/install.sh | sh
+```
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+### Cargo (from source)
+```bash
+cargo install deadbranch
+```
 
-## More Information
+### Homebrew (macOS/Linux)
+```bash
+brew install armgabrielyan/deadbranch/deadbranch
+```
 
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
+## Usage
 
----
+```bash
+deadbranch list              # List stale branches
+deadbranch clean             # Delete merged stale branches
+deadbranch clean --dry-run   # Preview what would be deleted
+```
 
-**Maintained for OIDC setup purposes only**
+For more information, see the [full documentation](https://github.com/armgabrielyan/deadbranch).
+
+## License
+
+MIT

package/bin/deadbranch

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+/**
+ * Binary wrapper for deadbranch
+ * This script runs the actual binary with all passed arguments
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+
+const binaryExt = os.platform() === 'win32' ? '.exe' : '';
+const binaryPath = path.join(__dirname, 'deadbranch' + binaryExt);
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});

package/package.json

@@ -1,10 +1,40 @@
 {
   "name": "deadbranch",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for deadbranch",
+  "version": "0.1.1",
+  "description": "Clean up stale git branches safely",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/armgabrielyan/deadbranch.git"
+  },
+  "author": "Armen Gabrielyan",
+  "license": "MIT",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
+    "git",
+    "cli",
+    "branches",
+    "cleanup",
+    "devtools"
+  ],
+  "bin": {
+    "deadbranch": "bin/deadbranch"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
   ]
 }

package/scripts/install.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+/**
+ * npm postinstall script for deadbranch
+ * Downloads the appropriate pre-built binary for the current platform
+ */
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const https = require('https');
+const path = require('path');
+const os = require('os');
+const zlib = require('zlib');
+
+const REPO = 'armgabrielyan/deadbranch';
+const BINARY_NAME = 'deadbranch';
+const VERSION = require('../package.json').version;
+
+/**
+ * Get the target triple for the current platform
+ */
+function getTarget() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const targets = {
+    'darwin-x64': 'x86_64-apple-darwin',
+    'darwin-arm64': 'aarch64-apple-darwin',
+    'linux-x64': 'x86_64-unknown-linux-gnu',
+    'linux-arm64': 'aarch64-unknown-linux-gnu',
+    'win32-x64': 'x86_64-pc-windows-msvc',
+  };
+
+  const key = `${platform}-${arch}`;
+  const target = targets[key];
+
+  if (!target) {
+    throw new Error(`Unsupported platform: ${key}`);
+  }
+
+  return target;
+}
+
+/**
+ * Get the archive extension for the current platform
+ */
+function getArchiveExt() {
+  return os.platform() === 'win32' ? 'zip' : 'tar.gz';
+}
+
+/**
+ * Download a file from a URL
+ */
+function download(url) {
+  return new Promise((resolve, reject) => {
+    const handleResponse = (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        // Follow redirect
+        https.get(response.headers.location, handleResponse).on('error', reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: ${response.statusCode}`));
+        return;
+      }
+
+      const chunks = [];
+      response.on('data', (chunk) => chunks.push(chunk));
+      response.on('end', () => resolve(Buffer.concat(chunks)));
+      response.on('error', reject);
+    };
+
+    https.get(url, handleResponse).on('error', reject);
+  });
+}
+
+/**
+ * Extract tar.gz archive
+ */
+function extractTarGz(buffer, destDir) {
+  const tarPath = path.join(os.tmpdir(), 'deadbranch.tar');
+  
+  // Decompress gzip
+  const decompressed = zlib.gunzipSync(buffer);
+  fs.writeFileSync(tarPath, decompressed);
+  
+  // Extract tar
+  execSync(`tar -xf "${tarPath}" -C "${destDir}"`, { stdio: 'inherit' });
+  fs.unlinkSync(tarPath);
+}
+
+/**
+ * Extract zip archive (Windows)
+ */
+function extractZip(buffer, destDir) {
+  const zipPath = path.join(os.tmpdir(), 'deadbranch.zip');
+  fs.writeFileSync(zipPath, buffer);
+  
+  // Use PowerShell to extract
+  execSync(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`, { stdio: 'inherit' });
+  fs.unlinkSync(zipPath);
+}
+
+async function install() {
+  console.log('Installing deadbranch...');
+
+  try {
+    const target = getTarget();
+    const ext = getArchiveExt();
+    const archiveName = `deadbranch-${VERSION}-${target}.${ext}`;
+    const url = `https://github.com/${REPO}/releases/download/v${VERSION}/${archiveName}`;
+
+    console.log(`Downloading ${archiveName}...`);
+    const buffer = await download(url);
+
+    const binDir = path.join(__dirname, '..', 'bin');
+    if (!fs.existsSync(binDir)) {
+      fs.mkdirSync(binDir, { recursive: true });
+    }
+
+    // Create temp dir for extraction
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deadbranch-'));
+
+    console.log('Extracting...');
+    if (ext === 'zip') {
+      extractZip(buffer, tmpDir);
+    } else {
+      extractTarGz(buffer, tmpDir);
+    }
+
+    // Copy binary to bin directory
+    const binaryExt = os.platform() === 'win32' ? '.exe' : '';
+    const srcBinary = path.join(tmpDir, BINARY_NAME + binaryExt);
+    const destBinary = path.join(binDir, BINARY_NAME + binaryExt);
+
+    fs.copyFileSync(srcBinary, destBinary);
+    
+    // Make executable on Unix
+    if (os.platform() !== 'win32') {
+      fs.chmodSync(destBinary, 0o755);
+    }
+
+    // Cleanup temp dir
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+
+    console.log('deadbranch installed successfully!');
+  } catch (error) {
+    console.error('Failed to install deadbranch:', error.message);
+    console.error('');
+    console.error('You can install from source instead:');
+    console.error('  cargo install deadbranch');
+    process.exit(1);
+  }
+}
+
+install();