@mxyhi/vibe-kanban 0.0.148

package/README.md

@@ -0,0 +1,159 @@
+# Vibe Kanban
+
+> A visual project management tool for developers that integrates with git repositories and coding agents like Claude Code and Amp.
+
+## Quick Start
+
+Run vibe kanban instantly without installation:
+
+```bash
+npx @mxyhi/vibe-kanban
+```
+
+This will launch the application locally and open it in your browser automatically.
+
+## What is Vibe Kanban?
+
+Vibe Kanban is a modern project management tool designed specifically for developers. It helps you organize your coding projects with kanban-style task management while providing powerful integrations with git repositories and AI coding agents.
+
+### ✨ Key Features
+
+**🗂️ Project Management**
+- Add git repositories as projects (existing or create new ones)
+- Automatic git integration and repository validation
+- Project search functionality across all files
+- Custom setup and development scripts per project
+
+**📋 Task Management**
+- Create and manage tasks with kanban-style boards
+- Task status tracking (Todo, In Progress, Done)
+- Rich task descriptions and notes
+- Task execution with multiple AI agents
+
+**🤖 AI Agent Integration**
+- **Claude**: Advanced AI coding assistant
+- **Amp**: Powerful development agent
+- **Echo**: Simple testing/debugging agent
+- Create tasks and immediately start agent execution
+- Follow-up task execution for iterative development
+
+**⚡ Development Workflow**
+- Create isolated git worktrees for each task attempt
+- View diffs of changes made by agents
+- Merge successful changes back to main branch
+- Rebase task branches to stay up-to-date
+- Manual file editing and deletion
+- Integrated development server support
+
+**🎛️ Developer Tools**
+- Browse and validate git repositories from filesystem
+- Open task worktrees in your preferred editor (VS Code, Cursor, Windsurf, IntelliJ, Zed)
+- Real-time execution monitoring and process control
+- Stop running processes individually or all at once
+- Sound notifications for task completion
+
+## How It Works
+
+1. **Add Projects**: Import existing git repositories or create new ones
+2. **Create Tasks**: Define what needs to be built or fixed
+3. **Execute with AI**: Let coding agents work on your tasks in isolated environments
+4. **Review Changes**: See exactly what was modified using git diffs
+5. **Merge Results**: Incorporate successful changes into your main codebase
+
+## Core Functionality
+
+Vibe Kanban provides a complete project management experience with these key capabilities:
+
+**Project Repository Management**
+- Full CRUD operations for managing coding projects
+- Automatic git repository detection and validation  
+- Initialize new repositories or import existing ones
+- Project-wide file search functionality
+
+**Task Lifecycle Management**
+- Create, update, and delete tasks with rich descriptions
+- Track task progress through customizable status workflows
+- One-click task creation with immediate AI agent execution
+- Task attempt tracking with detailed execution history
+
+**AI Agent Execution Environment**
+- Isolated git worktrees for safe code experimentation
+- Real-time execution monitoring and activity logging
+- Process management with ability to stop individual or all processes
+- Support for follow-up executions to iterate on solutions
+
+**Code Change Management**
+- View detailed diffs of all changes made during task execution
+- Branch status monitoring to track divergence from main
+- One-click merging of successful changes back to main branch
+- Automatic rebasing to keep task branches up-to-date
+- Manual file deletion and cleanup capabilities
+
+**Development Integration**
+- Open task worktrees directly in your preferred code editor
+- Start and manage development servers for testing changes
+- Browse local filesystem to add new projects
+- Health monitoring for service availability
+
+## Configuration
+
+Vibe Kanban supports customization through its configuration system:
+
+- **Editor Integration**: Choose your preferred code editor
+- **Sound Notifications**: Customize completion sounds
+- **Project Defaults**: Set default setup and development scripts
+
+## Technical Architecture
+
+- **Backend**: Rust with Axum web framework
+- **Frontend**: React with TypeScript
+- **Database**: SQLite for local data storage
+- **Git Integration**: Native git operations for repository management
+- **Process Management**: Tokio-based async execution monitoring
+
+## Requirements
+
+- Node.js (for npx execution)
+- Git (for repository operations)
+- Your preferred code editor (optional, for opening task worktrees)
+
+## Supported Platforms
+
+- Linux x64
+- Windows x64
+- macOS x64 (Intel)
+- macOS ARM64 (Apple Silicon)
+
+## Use Cases
+
+**🔧 Bug Fixes**
+- Create a task describing the bug
+- Let an AI agent analyze and fix the issue
+- Review the proposed changes
+- Merge if satisfied, or provide follow-up instructions
+
+**✨ Feature Development**
+- Break down features into manageable tasks
+- Use agents for initial implementation
+- Iterate with follow-up executions
+- Test using integrated development servers
+
+**🚀 Project Setup**
+- Bootstrap new projects with AI assistance
+- Set up development environments
+- Configure build and deployment scripts
+
+**📚 Code Documentation**
+- Generate documentation for existing code
+- Create README files and API documentation
+- Maintain up-to-date project information
+
+---
+
+**Ready to supercharge your development workflow?**
+
+```bash
+npx @mxyhi/vibe-kanban
+```
+
+*Start managing your projects with the power of AI coding agents today!*

package/bin/cli.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require("child_process");
+const AdmZip = require("adm-zip");
+const path = require("path");
+const fs = require("fs");
+const {
+  ensureBinary,
+  BINARY_TAG,
+  CACHE_DIR,
+  LOCAL_DEV_MODE,
+  LOCAL_DIST_DIR,
+  RELEASE_REPO,
+  getLatestVersion
+} = require("./download");
+
+const CLI_PACKAGE = require("../package.json");
+const CLI_VERSION = CLI_PACKAGE.version;
+const CLI_NAME = CLI_PACKAGE.name;
+
+// Resolve effective arch for our published 64-bit binaries only.
+// Any ARM → arm64; anything else → x64. On macOS, handle Rosetta.
+function getEffectiveArch() {
+  const platform = process.platform;
+  const nodeArch = process.arch;
+
+  if (platform === "darwin") {
+    // If Node itself is arm64, we're natively on Apple silicon
+    if (nodeArch === "arm64") return "arm64";
+
+    // Otherwise check for Rosetta translation
+    try {
+      const translated = execSync("sysctl -in sysctl.proc_translated", {
+        encoding: "utf8",
+      }).trim();
+      if (translated === "1") return "arm64";
+    } catch {
+      // sysctl key not present → assume true Intel
+    }
+    return "x64";
+  }
+
+  // Non-macOS: coerce to broad families we support
+  if (/arm/i.test(nodeArch)) return "arm64";
+
+  // On Windows with 32-bit Node (ia32), detect OS arch via env
+  if (platform === "win32") {
+    const pa = process.env.PROCESSOR_ARCHITECTURE || "";
+    const paw = process.env.PROCESSOR_ARCHITEW6432 || "";
+    if (/arm/i.test(pa) || /arm/i.test(paw)) return "arm64";
+  }
+
+  return "x64";
+}
+
+const platform = process.platform;
+const arch = getEffectiveArch();
+
+// Map to our build target names
+function getPlatformDir() {
+  if (platform === "linux" && arch === "x64") return "linux-x64";
+  if (platform === "linux" && arch === "arm64") return "linux-arm64";
+  if (platform === "win32" && arch === "x64") return "windows-x64";
+  if (platform === "win32" && arch === "arm64") return "windows-arm64";
+  if (platform === "darwin" && arch === "x64") return "macos-x64";
+  if (platform === "darwin" && arch === "arm64") return "macos-arm64";
+
+  console.error(`Unsupported platform: ${platform}-${arch}`);
+  console.error("Supported platforms:");
+  console.error("  - Linux x64");
+  console.error("  - Linux ARM64");
+  console.error("  - Windows x64");
+  console.error("  - Windows ARM64");
+  console.error("  - macOS x64 (Intel)");
+  console.error("  - macOS ARM64 (Apple Silicon)");
+  process.exit(1);
+}
+
+function getBinaryName(base) {
+  return platform === "win32" ? `${base}.exe` : base;
+}
+
+const platformDir = getPlatformDir();
+// In local dev mode, extract directly to dist directory; otherwise use global cache
+const versionCacheDir = LOCAL_DEV_MODE
+  ? path.join(LOCAL_DIST_DIR, platformDir)
+  : path.join(CACHE_DIR, BINARY_TAG, platformDir);
+
+function showProgress(downloaded, total) {
+  const percent = total ? Math.round((downloaded / total) * 100) : 0;
+  const mb = (downloaded / (1024 * 1024)).toFixed(1);
+  const totalMb = total ? (total / (1024 * 1024)).toFixed(1) : "?";
+  process.stderr.write(`\r   Downloading: ${mb}MB / ${totalMb}MB (${percent}%)`);
+}
+
+async function extractAndRun(baseName, launch) {
+  const binName = getBinaryName(baseName);
+  const binPath = path.join(versionCacheDir, binName);
+  const zipPath = path.join(versionCacheDir, `${baseName}.zip`);
+
+  // Clean old binary if exists
+  try {
+    if (fs.existsSync(binPath)) {
+      fs.unlinkSync(binPath);
+    }
+  } catch (err) {
+    if (process.env.VIBE_KANBAN_DEBUG) {
+      console.warn(`Warning: Could not delete existing binary: ${err.message}`);
+    }
+  }
+
+  // Download if not cached
+  if (!fs.existsSync(zipPath)) {
+    console.error(`Downloading ${baseName}...`);
+    try {
+      await ensureBinary(platformDir, baseName, showProgress);
+      console.error(""); // newline after progress
+    } catch (err) {
+      console.error(`\nDownload failed: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Extract
+  if (!fs.existsSync(binPath)) {
+    try {
+      const zip = new AdmZip(zipPath);
+      zip.extractAllTo(versionCacheDir, true);
+    } catch (err) {
+      console.error("Extraction failed:", err.message);
+      try {
+        fs.unlinkSync(zipPath);
+      } catch {}
+      process.exit(1);
+    }
+  }
+
+  if (!fs.existsSync(binPath)) {
+    console.error(`Extracted binary not found at: ${binPath}`);
+    console.error("This usually indicates a corrupt download. Please try again.");
+    process.exit(1);
+  }
+
+  // Set permissions (non-Windows)
+  if (platform !== "win32") {
+    try {
+      fs.chmodSync(binPath, 0o755);
+    } catch {}
+  }
+
+  return launch(binPath);
+}
+
+async function main() {
+  fs.mkdirSync(versionCacheDir, { recursive: true });
+
+  const args = process.argv.slice(2);
+  const isMcpMode = args.includes("--mcp");
+  const isReviewMode = args[0] === "review";
+
+  // Non-blocking update check (skip in MCP mode, local dev mode, and when repo not configured)
+  const hasValidReleaseRepo = !RELEASE_REPO.startsWith("__");
+  if (!isMcpMode && !LOCAL_DEV_MODE && hasValidReleaseRepo) {
+    getLatestVersion()
+      .then((latest) => {
+        if (latest && latest !== CLI_VERSION) {
+          setTimeout(() => {
+            console.log(`\nUpdate available: ${CLI_VERSION} -> ${latest}`);
+            console.log(`Run: npx ${CLI_NAME}@latest`);
+          }, 2000);
+        }
+      })
+      .catch(() => {});
+  }
+
+  if (isMcpMode) {
+    await extractAndRun("vibe-kanban-mcp", (bin) => {
+      const proc = spawn(bin, [], { stdio: "inherit" });
+      proc.on("exit", (c) => process.exit(c || 0));
+      proc.on("error", (e) => {
+        console.error("MCP server error:", e.message);
+        process.exit(1);
+      });
+      process.on("SIGINT", () => {
+        proc.kill("SIGINT");
+      });
+      process.on("SIGTERM", () => proc.kill("SIGTERM"));
+    });
+  } else if (isReviewMode) {
+    await extractAndRun("vibe-kanban-review", (bin) => {
+      const reviewArgs = args.slice(1);
+      const proc = spawn(bin, reviewArgs, { stdio: "inherit" });
+      proc.on("exit", (c) => process.exit(c || 0));
+      proc.on("error", (e) => {
+        console.error("Review CLI error:", e.message);
+        process.exit(1);
+      });
+    });
+  } else {
+    const modeLabel = LOCAL_DEV_MODE ? " (local dev)" : "";
+    console.log(`Starting vibe-kanban v${CLI_VERSION}${modeLabel}...`);
+    await extractAndRun("vibe-kanban", (bin) => {
+      if (platform === "win32") {
+        execSync(`"${bin}"`, { stdio: "inherit" });
+      } else {
+        execSync(`"${bin}"`, { stdio: "inherit" });
+      }
+    });
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err.message);
+  if (process.env.VIBE_KANBAN_DEBUG) {
+    console.error(err.stack);
+  }
+  process.exit(1);
+});

package/bin/download.js

@@ -0,0 +1,154 @@
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+// Replaced during npm publish by workflow
+const RELEASE_REPO = "__RELEASE_REPO__"; // e.g., mxyhi/vibe-kanban
+const BINARY_TAG = "__BINARY_TAG__"; // e.g., v0.0.135
+const RELEASE_BASE_URL = `https://github.com/${RELEASE_REPO}/releases/download`;
+const CACHE_DIR = path.join(require("os").homedir(), ".vibe-kanban", "bin");
+
+// Local development mode: use binaries from npx-cli/dist/ instead of GitHub Releases
+// Only activate if dist/ exists (i.e., running from source after local-build.sh)
+const LOCAL_DIST_DIR = path.join(__dirname, "..", "dist");
+const LOCAL_DEV_MODE = fs.existsSync(LOCAL_DIST_DIR) || process.env.VIBE_KANBAN_LOCAL === "1";
+
+async function fetchJson(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    https.get(url, options, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return fetchJson(res.headers.location, options).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+      }
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse JSON from ${url}`));
+        }
+      });
+    }).on("error", reject);
+  });
+}
+
+async function downloadFile(url, destPath, expectedSha256, onProgress) {
+  const tempPath = destPath + ".tmp";
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(tempPath);
+    const hash = crypto.createHash("sha256");
+
+    const cleanup = () => {
+      try {
+        fs.unlinkSync(tempPath);
+      } catch {}
+    };
+
+    https.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        file.close();
+        cleanup();
+        return downloadFile(res.headers.location, destPath, expectedSha256, onProgress)
+          .then(resolve)
+          .catch(reject);
+      }
+
+      if (res.statusCode !== 200) {
+        file.close();
+        cleanup();
+        return reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
+      }
+
+      const totalSize = parseInt(res.headers["content-length"], 10);
+      let downloadedSize = 0;
+
+      res.on("data", (chunk) => {
+        downloadedSize += chunk.length;
+        hash.update(chunk);
+        if (onProgress) onProgress(downloadedSize, totalSize);
+      });
+      res.pipe(file);
+
+      file.on("finish", () => {
+        file.close();
+        const actualSha256 = hash.digest("hex");
+        if (expectedSha256 && actualSha256 !== expectedSha256) {
+          cleanup();
+          reject(new Error(`Checksum mismatch: expected ${expectedSha256}, got ${actualSha256}`));
+        } else {
+          try {
+            fs.renameSync(tempPath, destPath);
+            resolve(destPath);
+          } catch (err) {
+            cleanup();
+            reject(err);
+          }
+        }
+      });
+    }).on("error", (err) => {
+      file.close();
+      cleanup();
+      reject(err);
+    });
+  });
+}
+
+function getAssetName(platform, binaryName) {
+  return `${binaryName}-${platform}.zip`;
+}
+
+async function ensureBinary(platform, binaryName, onProgress) {
+  // In local dev mode, use binaries directly from npx-cli/dist/
+  if (LOCAL_DEV_MODE) {
+    const localZipPath = path.join(LOCAL_DIST_DIR, getAssetName(platform, binaryName));
+    if (fs.existsSync(localZipPath)) {
+      return localZipPath;
+    }
+    throw new Error(
+      `Local binary not found: ${localZipPath}\n` +
+      `Run ./local-build.sh first to build the binaries.`
+    );
+  }
+
+  const cacheDir = path.join(CACHE_DIR, BINARY_TAG, platform);
+  const zipPath = path.join(cacheDir, `${binaryName}.zip`);
+
+  if (fs.existsSync(zipPath)) return zipPath;
+
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  const manifest = await fetchJson(`${RELEASE_BASE_URL}/${BINARY_TAG}/manifest.json`);
+  const binaryInfo = manifest.platforms?.[platform]?.[binaryName];
+
+  if (!binaryInfo) {
+    throw new Error(`Binary ${binaryName} not available for ${platform}`);
+  }
+
+  const assetName = getAssetName(platform, binaryName);
+  const url = `${RELEASE_BASE_URL}/${BINARY_TAG}/${assetName}`;
+  await downloadFile(url, zipPath, binaryInfo.sha256, onProgress);
+
+  return zipPath;
+}
+
+async function getLatestVersion() {
+  const headers = { "User-Agent": "vibe-kanban-cli" };
+  const apiUrl = `https://api.github.com/repos/${RELEASE_REPO}/releases/latest`;
+  const release = await fetchJson(apiUrl, { headers });
+  const tag = release.tag_name || "";
+  return tag.startsWith("v") ? tag.slice(1) : tag;
+}
+
+module.exports = {
+  RELEASE_REPO,
+  BINARY_TAG,
+  CACHE_DIR,
+  LOCAL_DEV_MODE,
+  LOCAL_DIST_DIR,
+  ensureBinary,
+  getLatestVersion
+};

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@mxyhi/vibe-kanban",
+  "private": false,
+  "version": "0.0.148",
+  "main": "index.js",
+  "bin": {
+    "vibe-kanban": "bin/cli.js"
+  },
+  "keywords": [],
+  "author": "bloop",
+  "license": "",
+  "description": "NPX wrapper around vibe-kanban and vibe-kanban-mcp",
+  "dependencies": {
+    "adm-zip": "^0.5.16"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ]
+}