redminectl 0.1.0

package/README.md

@@ -0,0 +1,50 @@
+# Redmine CLI
+
+AI Agent 友好的 Redmine 命令行工具。
+
+## 安装
+
+### 方式一：一键安装（推荐）
+
+**macOS / Linux：**
+```bash
+curl -fsSL https://raw.githubusercontent.com/largeoliu/redmine-cli/main/scripts/install.sh | sh
+```
+
+**Windows (PowerShell)：**
+```powershell
+irm https://raw.githubusercontent.com/largeoliu/redmine-cli/main/scripts/install.ps1 | iex
+```
+
+### 方式二：npm 安装
+
+```bash
+npm install -g rmcli
+```
+
+### 方式三：手动下载
+
+从 [GitHub Releases](https://github.com/largeoliu/redmine-cli/releases) 下载对应平台的预编译二进制。
+
+### 方式四：从源码构建
+
+```bash
+go install github.com/largeoliu/redmine-cli@latest
+```
+
+## 快速开始
+
+```bash
+# 登录
+redmine login
+
+# 列出 Issues
+redmine issue list
+
+# 创建 Issue
+redmine issue create --project 1 --subject "Bug report"
+```
+
+## 文档
+
+- [设计文档](docs/specs/2026-04-12-redmine-cli-design.md)

package/bin/redmine

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+
+const binDir = path.join(__dirname, '..', 'bin');
+const binaryName = os.platform() === 'win32' ? 'redmine.exe' : 'redmine';
+const binaryPath = path.join(binDir, binaryName);
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+    env: process.env
+});
+
+child.on('exit', (code) => {
+    process.exit(code || 0);
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "redminectl",
+  "version": "0.1.0",
+  "description": "AI Agent friendly Redmine CLI tool",
+  "main": "index.js",
+  "bin": {
+    "redmine": "./bin/redmine"
+  },
+  "scripts": {
+    "postinstall": "node scripts/download.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/largeoliu/redmine-cli.git"
+  },
+  "keywords": [
+    "redmine",
+    "cli",
+    "issue-tracker",
+    "project-management",
+    "ai-agent"
+  ],
+  "author": "largeoliu",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/largeoliu/redmine-cli/issues"
+  },
+  "homepage": "https://github.com/largeoliu/redmine-cli#readme",
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "bin",
+    "scripts"
+  ],
+  "dependencies": {
+    "axios": "^1.6.0",
+    "unzipper": "^0.10.14",
+    "tar": "^6.2.0"
+  }
+}

package/scripts/download.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { pipeline } = require('stream');
+const { promisify } = require('util');
+const streamPipeline = promisify(pipeline);
+
+const REPO = 'largeoliu/redmine-cli';
+const BINARY_NAME = 'redmine';
+
+function getPlatform() {
+    switch (process.platform) {
+        case 'win32': return 'windows';
+        case 'darwin': return 'darwin';
+        case 'linux': return 'linux';
+        default: throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+}
+
+function getArch() {
+    switch (process.arch) {
+        case 'x64': return 'amd64';
+        case 'arm64': return 'arm64';
+        default: throw new Error(`Unsupported architecture: ${process.arch}`);
+    }
+}
+
+async function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { headers: { 'User-Agent': 'redmine-cli-npm' } }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return fetchJson(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode !== 200) {
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        }).on('error', reject);
+    });
+}
+
+async function getLatestVersion() {
+    const releases = await fetchJson(`https://api.github.com/repos/${REPO}/releases/latest`);
+    return releases.tag_name;
+}
+
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? https : http;
+        protocol.get(url, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return downloadFile(res.headers.location, dest).then(resolve).catch(reject);
+            }
+            if (res.statusCode !== 200) {
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            const file = fs.createWriteStream(dest);
+            streamPipeline(res, file).then(resolve).catch(reject);
+        }).on('error', reject);
+    });
+}
+
+async function extractArchive(archivePath, destDir, isZip) {
+    const targetDir = path.dirname(destDir);
+    
+    if (isZip) {
+        const unzipper = require('unzipper');
+        await new Promise((resolve, reject) => {
+            fs.createReadStream(archivePath)
+                .pipe(unzipper.Extract({ path: targetDir }))
+                .on('close', resolve)
+                .on('error', reject);
+        });
+    } else {
+        const tar = require('tar');
+        await tar.x({ file: archivePath, cwd: targetDir });
+    }
+}
+
+async function main() {
+    const binDir = path.join(__dirname, '..', 'bin');
+    const platform = getPlatform();
+    const arch = getArch();
+    
+    console.log(`[INFO] Installing redmine-cli for ${platform}/${arch}...`);
+    
+    let version;
+    try {
+        version = await getLatestVersion();
+        console.log(`[INFO] Latest version: ${version}`);
+    } catch (e) {
+        console.error('[ERROR] Failed to get latest version:', e.message);
+        process.exit(1);
+    }
+    
+    const ext = platform === 'windows' ? 'zip' : 'tar.gz';
+    const archiveName = `${BINARY_NAME}_${version.replace('v', '')}_${platform}_${arch}.${ext}`;
+    const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${archiveName}`;
+    
+    const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'redmine-cli-'));
+    const archivePath = path.join(tmpDir, archiveName);
+    
+    try {
+        console.log(`[INFO] Downloading ${archiveName}...`);
+        await downloadFile(downloadUrl, archivePath);
+        
+        console.log('[INFO] Extracting...');
+        await extractArchive(archivePath, binDir, platform === 'windows');
+        
+        const binaryName = platform === 'windows' ? `${BINARY_NAME}.exe` : BINARY_NAME;
+        const extractedPath = path.join(tmpDir, binaryName);
+        const destPath = path.join(binDir, binaryName);
+        
+        if (fs.existsSync(extractedPath)) {
+            fs.renameSync(extractedPath, destPath);
+        }
+        
+        if (platform !== 'windows') {
+            fs.chmodSync(destPath, 0o755);
+        }
+        
+        console.log('[INFO] Successfully installed redmine-cli');
+    } catch (e) {
+        console.error('[ERROR] Installation failed:', e.message);
+        process.exit(1);
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+
+main();

package/scripts/install.ps1

@@ -0,0 +1,177 @@
+param(
+    [string]$InstallDir = "",
+    [string]$Version = ""
+)
+
+$ErrorActionPreference = "Stop"
+
+$REPO = "largeoliu/redmine-cli"
+$BINARY_NAME = "redmine"
+
+if (-not $InstallDir) {
+    $InstallDir = Join-Path $env:USERPROFILE ".local\bin"
+}
+
+function Write-Info {
+    param([string]$Message)
+    Write-Host "[INFO] " -ForegroundColor Green -NoNewline
+    Write-Host $Message
+}
+
+function Write-Warn {
+    param([string]$Message)
+    Write-Host "[WARN] " -ForegroundColor Yellow -NoNewline
+    Write-Host $Message
+}
+
+function Write-Error-Exit {
+    param([string]$Message)
+    Write-Host "[ERROR] " -ForegroundColor Red -NoNewline
+    Write-Host $Message
+    exit 1
+}
+
+function Get-OS {
+    if ($IsWindows -or ($env:OS -match "Windows")) {
+        return "windows"
+    } elseif ($IsMacOS) {
+        return "darwin"
+    } elseif ($IsLinux) {
+        return "linux"
+    }
+    Write-Error-Exit "Unsupported OS"
+}
+
+function Get-Arch {
+    $arch = [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture
+    switch ($arch) {
+        "X64" { return "amd64" }
+        "Arm64" { return "arm64" }
+        default { Write-Error-Exit "Unsupported architecture: $arch" }
+    }
+}
+
+function Get-LatestVersion {
+    $latestUrl = "https://github.com/$REPO/releases/latest"
+    try {
+        $response = Invoke-WebRequest -Uri $latestUrl -Method Head -MaximumRedirection 0 -ErrorAction SilentlyContinue
+    } catch {
+        $response = $_.Exception.Response
+    }
+    
+    if ($response.Headers.Location) {
+        $location = $response.Headers.Location.ToString()
+        $version = $location.Split("/")[-1]
+        return $version
+    }
+    
+    Write-Error-Exit "Failed to get latest version"
+}
+
+function Download-Binary {
+    param(
+        [string]$Version,
+        [string]$OS,
+        [string]$Arch
+    )
+    
+    $archiveName = "${BINARY_NAME}_$($Version.Substring(1))_${OS}_${Arch}.zip"
+    $downloadUrl = "https://github.com/$REPO/releases/download/$Version/$archiveName"
+    
+    Write-Info "Downloading $archiveName..."
+    
+    $tmpDir = New-TemporaryDirectory
+    $archivePath = Join-Path $tmpDir $archiveName
+    
+    try {
+        Invoke-WebRequest -Uri $downloadUrl -OutFile $archivePath -UseBasicParsing
+    } catch {
+        Write-Error-Exit "Failed to download $archiveName : $_"
+    }
+    
+    Write-Info "Extracting..."
+    
+    try {
+        Expand-Archive -Path $archivePath -DestinationPath $tmpDir -Force
+    } catch {
+        Write-Error-Exit "Failed to extract archive: $_"
+    }
+    
+    return $tmpDir
+}
+
+function New-TemporaryDirectory {
+    $tmpPath = [System.IO.Path]::GetTempPath()
+    $tmpDir = [System.IO.Path]::Combine($tmpPath, [System.IO.Path]::GetRandomFileName())
+    New-Item -ItemType Directory -Path $tmpDir | Out-Null
+    return $tmpDir
+}
+
+function Install-Binary {
+    param([string]$TmpDir)
+    
+    if (-not (Test-Path $InstallDir)) {
+        Write-Info "Creating install directory: $InstallDir"
+        New-Item -ItemType Directory -Path $InstallDir -Force | Out-Null
+    }
+    
+    $binaryPath = Join-Path $TmpDir "$BINARY_NAME.exe"
+    
+    if (-not (Test-Path $binaryPath)) {
+        $binaryPath = Join-Path $TmpDir $BINARY_NAME
+    }
+    
+    if (-not (Test-Path $binaryPath)) {
+        Write-Error-Exit "Binary not found in archive"
+    }
+    
+    $destPath = Join-Path $InstallDir "$BINARY_NAME.exe"
+    Move-Item -Path $binaryPath -Destination $destPath -Force
+    
+    Remove-Item -Path $TmpDir -Recurse -Force -ErrorAction SilentlyContinue
+}
+
+function Test-PathInEnv {
+    $pathDirs = $env:PATH -split ";"
+    return $pathDirs -contains $InstallDir
+}
+
+function Add-ToPath {
+    $currentPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    if ($currentPath -notlike "*$InstallDir*") {
+        $newPath = "$currentPath;$InstallDir"
+        [Environment]::SetEnvironmentVariable("Path", $newPath, "User")
+        Write-Info "Added $InstallDir to user PATH"
+    }
+}
+
+$os = Get-OS
+$arch = Get-Arch
+
+if (-not $Version) {
+    $Version = Get-LatestVersion
+}
+
+Write-Info "Installing $BINARY_NAME..."
+Write-Info "OS: $os, Arch: $arch, Version: $Version"
+
+$tmpDir = Download-Binary -Version $Version -OS $os -Arch $arch
+Install-Binary -TmpDir $tmpDir
+
+Write-Info "Successfully installed $BINARY_NAME to $InstallDir"
+
+if (-not (Test-PathInEnv)) {
+    Write-Host ""
+    Write-Warn "$InstallDir is not in your PATH"
+    Write-Host ""
+    
+    $addToPath = Read-Host "Would you like to add it to your PATH? (Y/n)"
+    if ($addToPath -ne "n" -and $addToPath -ne "N") {
+        Add-ToPath
+        Write-Host ""
+        Write-Info "Please restart your terminal or run: `$env:Path = [System.Environment]::GetEnvironmentVariable('Path','User')"
+    }
+}
+
+Write-Host ""
+Write-Info "Run '$BINARY_NAME --help' to get started"

package/scripts/install.sh

@@ -0,0 +1,150 @@
+#!/bin/sh
+
+set -e
+
+REPO="largeoliu/redmine-cli"
+BINARY_NAME="redmine"
+INSTALL_DIR="${INSTALL_DIR:-$HOME/.local/bin}"
+
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+info() {
+    echo "${GREEN}[INFO]${NC} $1"
+}
+
+warn() {
+    echo "${YELLOW}[WARN]${NC} $1"
+}
+
+error() {
+    echo "${RED}[ERROR]${NC} $1"
+    exit 1
+}
+
+detect_os() {
+    case "$(uname -s)" in
+        Darwin*)    echo "darwin" ;;
+        Linux*)     echo "linux" ;;
+        CYGWIN*|MINGW*|MSYS*)    echo "windows" ;;
+        *)          error "Unsupported OS: $(uname -s)" ;;
+    esac
+}
+
+detect_arch() {
+    case "$(uname -m)" in
+        x86_64|amd64)    echo "amd64" ;;
+        arm64|aarch64)   echo "arm64" ;;
+        *)               error "Unsupported architecture: $(uname -m)" ;;
+    esac
+}
+
+get_latest_version() {
+    latest_url="https://github.com/${REPO}/releases/latest"
+    version=$(curl -sI "$latest_url" | grep -i "location:" | sed 's/.*\/tag\/\(.*\)/\1/' | tr -d '\r\n')
+    if [ -z "$version" ]; then
+        error "Failed to get latest version"
+    fi
+    echo "$version"
+}
+
+download_binary() {
+    version="$1"
+    os="$2"
+    arch="$3"
+    
+    if [ "$os" = "windows" ]; then
+        archive_name="${BINARY_NAME}_${version#v}_${os}_${arch}.zip"
+    else
+        archive_name="${BINARY_NAME}_${version#v}_${os}_${arch}.tar.gz"
+    fi
+    
+    download_url="https://github.com/${REPO}/releases/download/${version}/${archive_name}"
+    
+    info "Downloading ${archive_name}..."
+    
+    tmp_dir=$(mktemp -d)
+    archive_path="${tmp_dir}/${archive_name}"
+    
+    if ! curl -fsSL "$download_url" -o "$archive_path"; then
+        error "Failed to download ${archive_name}"
+    fi
+    
+    info "Extracting..."
+    
+    if [ "$os" = "windows" ]; then
+        if ! unzip -q "$archive_path" -d "$tmp_dir"; then
+            error "Failed to extract archive"
+        fi
+    else
+        if ! tar -xzf "$archive_path" -C "$tmp_dir"; then
+            error "Failed to extract archive"
+        fi
+    fi
+    
+    echo "$tmp_dir"
+}
+
+install_binary() {
+    tmp_dir="$1"
+    
+    if [ ! -d "$INSTALL_DIR" ]; then
+        info "Creating install directory: $INSTALL_DIR"
+        mkdir -p "$INSTALL_DIR"
+    fi
+    
+    binary_path="${tmp_dir}/${BINARY_NAME}"
+    
+    if [ ! -f "$binary_path" ]; then
+        error "Binary not found in archive"
+    fi
+    
+    chmod +x "$binary_path"
+    mv "$binary_path" "${INSTALL_DIR}/${BINARY_NAME}"
+    
+    rm -rf "$tmp_dir"
+}
+
+check_path() {
+    case ":$PATH:" in
+        *":$INSTALL_DIR:"*)
+            return 0
+            ;;
+        *)
+            return 1
+            ;;
+    esac
+}
+
+main() {
+    info "Installing ${BINARY_NAME}..."
+    
+    os=$(detect_os)
+    arch=$(detect_arch)
+    version=$(get_latest_version)
+    
+    info "OS: ${os}, Arch: ${arch}, Version: ${version}"
+    
+    tmp_dir=$(download_binary "$version" "$os" "$arch")
+    install_binary "$tmp_dir"
+    
+    info "Successfully installed ${BINARY_NAME} to ${INSTALL_DIR}"
+    
+    if ! check_path; then
+        echo ""
+        warn "${INSTALL_DIR} is not in your PATH"
+        echo ""
+        echo "Add the following to your shell profile (~/.bashrc, ~/.zshrc, etc.):"
+        echo ""
+        echo "    export PATH=\"\$PATH:${INSTALL_DIR}\""
+        echo ""
+        echo "Then restart your shell or run: source ~/.bashrc (or ~/.zshrc)"
+    fi
+    
+    echo ""
+    info "Run '${BINARY_NAME} --help' to get started"
+}
+
+main "$@"