automagik-forge 0.1.0

package/README.md

@@ -0,0 +1,159 @@
+# Automagik Forge
+
+> 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 automagik-forge
+```
+
+This will launch the application locally and open it in your browser automatically.
+
+## What is Automagik Forge?
+
+Automagik Forge 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
+
+Automagik Forge 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
+
+Automagik Forge 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 automagik-forge
+```
+
+*Start managing your projects with the power of AI coding agents today!*

package/bin/cli.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+// Load .env file from current working directory
+function loadEnvFile() {
+  const envPath = path.join(process.cwd(), '.env');
+  if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, 'utf8');
+    envContent.split('\n').forEach(line => {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith('#')) {
+        const [key, ...valueParts] = trimmed.split('=');
+        if (key && valueParts.length > 0) {
+          const value = valueParts.join('=');
+          if (!process.env[key]) {
+            process.env[key] = value;
+          }
+        }
+      }
+    });
+  }
+}
+
+// Load environment variables from .env file
+loadEnvFile();
+
+// Detect true CPU arch on macOS (handles Rosetta)
+function getUnderlyingArch() {
+  const platform = process.platform;
+  const nodeArch = process.arch;
+
+  if (platform !== "darwin") {
+    return nodeArch;
+  }
+
+  // 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";
+}
+
+const platform = process.platform;
+const arch = getUnderlyingArch();
+
+// 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();
+const extractDir = path.join(__dirname, "..", "dist", platformDir);
+const isMcpMode = process.argv.includes("--mcp");
+const isMcpSseMode = process.argv.includes("--mcp-sse");
+
+// ensure output dir
+fs.mkdirSync(extractDir, { recursive: true });
+
+function extractAndRun(baseName, launch) {
+  const binName = getBinaryName(baseName);
+  const binPath = path.join(extractDir, binName);
+  const zipName = `${baseName}.zip`;
+  const zipPath = path.join(extractDir, zipName);
+
+  // clean old binary
+  if (fs.existsSync(binPath)) fs.unlinkSync(binPath);
+  if (!fs.existsSync(zipPath)) {
+    console.error(`❌ ${zipName} not found at: ${zipPath}`);
+    console.error(`Current platform: ${platform}-${arch} (${platformDir})`);
+    process.exit(1);
+  }
+
+  // extract
+  const unzipCmd =
+    platform === "win32"
+      ? `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${extractDir}' -Force"`
+      : `unzip -qq -o "${zipPath}" -d "${extractDir}"`;
+  execSync(unzipCmd, { stdio: "inherit" });
+
+  // perms & launch
+  if (platform !== "win32") {
+    try {
+      fs.chmodSync(binPath, 0o755);
+    } catch { }
+  }
+  return launch(binPath);
+}
+
+if (isMcpMode || isMcpSseMode) {
+  extractAndRun("automagik-forge-mcp", (bin) => {
+    const mcpArgs = isMcpSseMode ? ["--mcp-sse"] : [];
+    console.log(`Starting MCP server with ${isMcpSseMode ? 'SSE + STDIO' : 'STDIO'} transport...`);
+    
+    // Environment variables are already loaded from .env file
+    
+    const proc = spawn(bin, mcpArgs, { 
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    process.stdin.pipe(proc.stdin);
+    proc.stdout.pipe(process.stdout);
+    proc.stderr.pipe(process.stdout);
+
+    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", () => {
+      console.error("\n🛑 Shutting down MCP server...");
+      proc.kill("SIGINT");
+    });
+    process.on("SIGTERM", () => proc.kill("SIGTERM"));
+  });
+} else {
+  // Start both main backend server and MCP SSE server concurrently
+  console.log(`📦 Extracting automagik-forge and automagik-forge-mcp...`);
+  
+  // Environment variables are loaded from .env file
+  // Use safe defaults (localhost only) unless overridden
+  const mcpSsePort = process.env.MCP_SSE_PORT || "8889";
+  const backendPort = process.env.BACKEND_PORT || process.env.PORT || "8887";
+  const host = process.env.HOST || "127.0.0.1";
+  
+  let mainServerProc, mcpServerProc;
+  let shutdownInProgress = false;
+  
+  // Function to gracefully shutdown both servers
+  const shutdown = (signal) => {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    
+    console.log(`\n🛑 Shutting down servers (${signal})...`);
+    
+    if (mainServerProc && !mainServerProc.killed) {
+      mainServerProc.kill(signal);
+    }
+    if (mcpServerProc && !mcpServerProc.killed) {
+      mcpServerProc.kill(signal);
+    }
+    
+    // Force exit after timeout
+    setTimeout(() => {
+      console.log("⏰ Force exit after timeout");
+      process.exit(1);
+    }, 5000);
+  };
+  
+  // Extract and start main backend server
+  extractAndRun("automagik-forge", (mainBin) => {
+    console.log(`🚀 Starting main backend server on http://${host}:${backendPort}...`);
+    mainServerProc = spawn(mainBin, [], { 
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    
+    mainServerProc.stdout.on("data", (data) => {
+      process.stdout.write(`[MAIN] ${data}`);
+    });
+    mainServerProc.stderr.on("data", (data) => {
+      process.stderr.write(`[MAIN] ${data}`);
+    });
+    
+    mainServerProc.on("exit", (code) => {
+      if (!shutdownInProgress) {
+        console.error(`❌ Main server exited with code ${code}`);
+        shutdown("SIGTERM");
+      }
+    });
+    
+    mainServerProc.on("error", (e) => {
+      console.error("❌ Main server error:", e.message);
+      shutdown("SIGTERM");
+    });
+    
+    // Extract and start MCP SSE server
+    extractAndRun("automagik-forge-mcp", (mcpBin) => {
+      console.log(`🚀 Starting MCP SSE server on http://${host}:${mcpSsePort}/sse...`);
+      mcpServerProc = spawn(mcpBin, ["--mcp-sse"], { 
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env }
+      });
+      
+      mcpServerProc.stdout.on("data", (data) => {
+        process.stdout.write(`[MCP] ${data}`);
+      });
+      mcpServerProc.stderr.on("data", (data) => {
+        process.stderr.write(`[MCP] ${data}`);
+      });
+      
+      mcpServerProc.on("exit", (code) => {
+        if (!shutdownInProgress) {
+          console.error(`❌ MCP server exited with code ${code}`);
+          shutdown("SIGTERM");
+        }
+      });
+      
+      mcpServerProc.on("error", (e) => {
+        console.error("❌ MCP server error:", e.message);
+        shutdown("SIGTERM");
+      });
+    });
+  });
+  
+  // Handle shutdown signals
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("exit", () => shutdown("SIGTERM"));
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "automagik-forge",
+  "private": false,
+  "version": "0.1.0",
+  "main": "index.js",
+  "bin": {
+    "automagik-forge": "bin/cli.js"
+  },
+  "keywords": ["ai", "agent", "claude", "gemini", "automation", "kanban", "task-management", "mcp", "assistant"],
+  "author": "Namastex Labs",
+  "license": "MIT",
+  "description": "AI Agent Execution Substrate - Get 10X more out of Claude Code, Gemini CLI, and other coding agents with kanban task management",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/namastexlabs/automagik-forge.git"
+  },
+  "homepage": "https://namastex.ai",
+  "bugs": {
+    "url": "https://github.com/namastexlabs/automagik-forge/issues"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ]
+}