@automagik/genie 0.260202.1901 → 0.260203.135

package/src/services/worker-service.ts

@@ -0,0 +1,351 @@
+#!/usr/bin/env bun
+/**
+ * Worker Service for automagik-genie
+ *
+ * Background HTTP service for workflow state management.
+ * Port: 48888 (avoids collision with claude-mem's 37777)
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'http';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { spawn, execSync } from 'child_process';
+
+const PORT = 48888;
+const GENIE_DIR = join(homedir(), '.genie');
+const PID_FILE = join(GENIE_DIR, 'worker.pid');
+const STATE_FILE = join(GENIE_DIR, 'workflow-state.json');
+
+// Ensure .genie directory exists
+if (!existsSync(GENIE_DIR)) {
+  mkdirSync(GENIE_DIR, { recursive: true });
+}
+
+interface WorkflowState {
+  activeWish?: string;
+  activeForge?: {
+    wishSlug: string;
+    currentTask?: string;
+    completedTasks: string[];
+    failedTasks: string[];
+  };
+  lastUpdate: string;
+}
+
+function loadState(): WorkflowState {
+  try {
+    if (existsSync(STATE_FILE)) {
+      return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+    }
+  } catch {
+    // Ignore parse errors
+  }
+  return { lastUpdate: new Date().toISOString() };
+}
+
+function saveState(state: WorkflowState): void {
+  state.lastUpdate = new Date().toISOString();
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+function json(res: ServerResponse, data: unknown, status = 200): void {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}
+
+function parseBody(req: IncomingMessage): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', chunk => body += chunk);
+    req.on('end', () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch {
+        reject(new Error('Invalid JSON'));
+      }
+    });
+  });
+}
+
+async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+  const path = url.pathname;
+  const method = req.method || 'GET';
+
+  // CORS headers
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+  if (method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  // Health check
+  if (path === '/health' || path === '/') {
+    json(res, {
+      status: 'ok',
+      service: 'automagik-genie',
+      version: process.env.GENIE_VERSION || 'dev',
+      port: PORT,
+      uptime: process.uptime()
+    });
+    return;
+  }
+
+  // Workflow status
+  if (path === '/api/workflow/status' && method === 'GET') {
+    const state = loadState();
+    json(res, state);
+    return;
+  }
+
+  // Update workflow state
+  if (path === '/api/workflow/update' && method === 'POST') {
+    try {
+      const body = await parseBody(req) as Partial<WorkflowState>;
+      const state = loadState();
+      Object.assign(state, body);
+      saveState(state);
+      json(res, { success: true, state });
+    } catch (error) {
+      json(res, { error: 'Invalid request body' }, 400);
+    }
+    return;
+  }
+
+  // Start wish tracking
+  if (path === '/api/workflow/wish/start' && method === 'POST') {
+    try {
+      const body = await parseBody(req) as { slug: string };
+      const state = loadState();
+      state.activeWish = body.slug;
+      saveState(state);
+      json(res, { success: true, wish: body.slug });
+    } catch {
+      json(res, { error: 'Invalid request' }, 400);
+    }
+    return;
+  }
+
+  // Start forge session
+  if (path === '/api/workflow/forge/start' && method === 'POST') {
+    try {
+      const body = await parseBody(req) as { wishSlug: string };
+      const state = loadState();
+      state.activeForge = {
+        wishSlug: body.wishSlug,
+        completedTasks: [],
+        failedTasks: []
+      };
+      saveState(state);
+      json(res, { success: true, forge: state.activeForge });
+    } catch {
+      json(res, { error: 'Invalid request' }, 400);
+    }
+    return;
+  }
+
+  // Update forge task status
+  if (path === '/api/workflow/forge/task' && method === 'POST') {
+    try {
+      const body = await parseBody(req) as { task: string; status: 'started' | 'completed' | 'failed' };
+      const state = loadState();
+      if (!state.activeForge) {
+        json(res, { error: 'No active forge session' }, 400);
+        return;
+      }
+      if (body.status === 'started') {
+        state.activeForge.currentTask = body.task;
+      } else if (body.status === 'completed') {
+        state.activeForge.completedTasks.push(body.task);
+        state.activeForge.currentTask = undefined;
+      } else if (body.status === 'failed') {
+        state.activeForge.failedTasks.push(body.task);
+        state.activeForge.currentTask = undefined;
+      }
+      saveState(state);
+      json(res, { success: true, forge: state.activeForge });
+    } catch {
+      json(res, { error: 'Invalid request' }, 400);
+    }
+    return;
+  }
+
+  // Context hook - inject active workflow into Claude session
+  if (path === '/api/hook/context' && method === 'GET') {
+    const state = loadState();
+    let context = '';
+
+    if (state.activeWish) {
+      context += `Active Wish: ${state.activeWish}\n`;
+    }
+    if (state.activeForge) {
+      context += `Active Forge: ${state.activeForge.wishSlug}\n`;
+      if (state.activeForge.currentTask) {
+        context += `  Current Task: ${state.activeForge.currentTask}\n`;
+      }
+      context += `  Completed: ${state.activeForge.completedTasks.length} tasks\n`;
+      if (state.activeForge.failedTasks.length > 0) {
+        context += `  Failed: ${state.activeForge.failedTasks.length} tasks\n`;
+      }
+    }
+
+    if (context) {
+      json(res, { context });
+    } else {
+      json(res, { context: null });
+    }
+    return;
+  }
+
+  // Admin restart endpoint
+  if (path === '/api/admin/restart' && method === 'POST') {
+    json(res, { success: true, message: 'Worker restarting...' });
+    // Schedule restart after response is sent
+    setTimeout(() => {
+      process.exit(0);
+    }, 100);
+    return;
+  }
+
+  // 404 for unknown routes
+  json(res, { error: 'Not found', path }, 404);
+}
+
+// Check if another instance is running
+function isAlreadyRunning(): boolean {
+  try {
+    if (existsSync(PID_FILE)) {
+      const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim(), 10);
+      // Check if process exists
+      process.kill(pid, 0);
+      return true;
+    }
+  } catch {
+    // Process doesn't exist or PID file invalid
+  }
+  return false;
+}
+
+// Write PID file
+function writePidFile(): void {
+  writeFileSync(PID_FILE, String(process.pid));
+}
+
+// CLI commands
+const command = process.argv[2];
+
+if (command === 'start') {
+  if (isAlreadyRunning()) {
+    console.log('Worker already running');
+    process.exit(0);
+  }
+
+  // Start as daemon (background process)
+  if (process.argv[3] !== '--foreground') {
+    const child = spawn(process.argv[0], [process.argv[1], 'start', '--foreground'], {
+      detached: true,
+      stdio: 'ignore'
+    });
+    child.unref();
+    console.log(`Worker started (PID: ${child.pid})`);
+    process.exit(0);
+  }
+
+  // Running in foreground
+  const server = createServer((req, res) => {
+    handleRequest(req, res).catch(err => {
+      console.error('Request error:', err);
+      json(res, { error: 'Internal server error' }, 500);
+    });
+  });
+
+  server.listen(PORT, '127.0.0.1', () => {
+    writePidFile();
+    console.log(`automagik-genie worker listening on http://127.0.0.1:${PORT}`);
+  });
+
+  // Graceful shutdown
+  process.on('SIGTERM', () => {
+    server.close();
+    process.exit(0);
+  });
+  process.on('SIGINT', () => {
+    server.close();
+    process.exit(0);
+  });
+
+} else if (command === 'stop') {
+  try {
+    if (existsSync(PID_FILE)) {
+      const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim(), 10);
+      process.kill(pid, 'SIGTERM');
+      console.log('Worker stopped');
+    } else {
+      console.log('Worker not running');
+    }
+  } catch {
+    console.log('Worker not running');
+  }
+  process.exit(0);
+
+} else if (command === 'status') {
+  if (isAlreadyRunning()) {
+    const pid = readFileSync(PID_FILE, 'utf-8').trim();
+    console.log(`Worker running (PID: ${pid})`);
+    // Try to get health status
+    try {
+      execSync(`curl -s http://127.0.0.1:${PORT}/health`, { encoding: 'utf-8' });
+      console.log('Health: OK');
+    } catch {
+      console.log('Health: Unable to connect');
+    }
+  } else {
+    console.log('Worker not running');
+  }
+  process.exit(0);
+
+} else if (command === 'hook') {
+  // Hook subcommand for lifecycle hooks
+  const hookType = process.argv[3];
+
+  if (hookType === 'context') {
+    // Inject workflow context - called by SessionStart hook
+    try {
+      const response = execSync(`curl -s http://127.0.0.1:${PORT}/api/hook/context`, { encoding: 'utf-8' });
+      const data = JSON.parse(response);
+      if (data.context) {
+        console.log(`\n<genie-workflow>\n${data.context}</genie-workflow>\n`);
+      }
+    } catch {
+      // Worker not running, no context to inject
+    }
+  }
+  process.exit(0);
+
+} else {
+  console.log(`
+automagik-genie worker service
+
+Usage:
+  worker-service start     Start the worker (daemonized)
+  worker-service stop      Stop the worker
+  worker-service status    Check worker status
+  worker-service hook <type>  Run hook command
+
+Endpoints:
+  GET  /health                    Health check
+  GET  /api/workflow/status       Get workflow state
+  POST /api/workflow/update       Update workflow state
+  POST /api/workflow/wish/start   Start tracking a wish
+  POST /api/workflow/forge/start  Start forge session
+  POST /api/workflow/forge/task   Update forge task status
+  GET  /api/hook/context          Get context for injection
+  POST /api/admin/restart         Restart worker
+`);
+  process.exit(0);
+}

package/src/term-commands/close.ts

@@ -39,6 +39,8 @@ export interface CloseOptions {
 // ============================================================================
 
 const WORKTREE_BASE = join(homedir(), '.local', 'share', 'term', 'worktrees');
+// Worktrees are created inside the project at .genie/worktrees/<taskId>
+const WORKTREE_DIR_NAME = '.genie/worktrees';
 
 // ============================================================================
 // Helper Functions
@@ -105,11 +107,19 @@ async function mergeToMain(
 
 /**
  * Remove worktree
- * Uses bd worktree when beads registry is enabled
- * Falls back to WorktreeManager otherwise
+ * Checks .genie/worktrees first, then bd worktree, then WorktreeManager
  */
 async function removeWorktree(taskId: string, repoPath: string): Promise<boolean> {
-  // Try bd worktree first when beads is enabled
+  // First, check .genie/worktrees location (new location)
+  const inProjectWorktree = join(repoPath, WORKTREE_DIR_NAME, taskId);
+  try {
+    await $`git -C ${repoPath} worktree remove ${inProjectWorktree} --force`.quiet();
+    return true;
+  } catch {
+    // Worktree may not exist at this location, continue checking
+  }
+
+  // Try bd worktree when beads is enabled
   if (useBeads) {
     try {
       const removed = await beadsRegistry.removeWorktree(taskId);
@@ -120,7 +130,7 @@ async function removeWorktree(taskId: string, repoPath: string): Promise<boolean
     }
   }
 
-  // Fallback to WorktreeManager
+  // Fallback to WorktreeManager (legacy location)
   try {
     const manager = new WorktreeManager({
       baseDir: WORKTREE_BASE,

package/src/term-commands/create.ts

@@ -0,0 +1,95 @@
+/**
+ * Create command - Simple bd create wrapper
+ *
+ * Usage:
+ *   term create "Task title"                    - Create beads issue
+ *   term create "Task title" -d "Description"   - With description
+ *   term create "Task title" -p bd-1            - With parent/dependency
+ *
+ * Options:
+ *   -d, --description <text>  - Issue description
+ *   -p, --parent <id>         - Parent issue ID (creates dependency)
+ *   --json                    - Output as JSON
+ */
+
+import { $ } from 'bun';
+
+export interface CreateOptions {
+  description?: string;
+  parent?: string;
+  json?: boolean;
+}
+
+/**
+ * Run bd command and return result
+ */
+async function runBd(args: string[]): Promise<{ stdout: string; exitCode: number }> {
+  try {
+    const result = await $`bd ${args}`.quiet();
+    return { stdout: result.stdout.toString().trim(), exitCode: 0 };
+  } catch (error: any) {
+    return {
+      stdout: error.stdout?.toString().trim() || error.message,
+      exitCode: error.exitCode || 1
+    };
+  }
+}
+
+export async function createCommand(
+  title: string,
+  options: CreateOptions = {}
+): Promise<void> {
+  // Build bd create command
+  const args = ['create', title];
+
+  if (options.description) {
+    args.push('--description', options.description);
+  }
+
+  // Run bd create
+  const { stdout, exitCode } = await runBd(args);
+
+  if (exitCode !== 0) {
+    console.error(`Failed to create issue: ${stdout}`);
+    process.exit(1);
+  }
+
+  // Extract issue ID from output
+  // bd create typically outputs something like "Created bd-123" or just the ID
+  const idMatch = stdout.match(/bd-\d+/);
+  const issueId = idMatch ? idMatch[0] : null;
+
+  if (!issueId) {
+    console.log(stdout);
+    return;
+  }
+
+  // If parent specified, add blockedBy relationship
+  if (options.parent) {
+    const { exitCode: updateExit } = await runBd([
+      'update',
+      issueId,
+      '--blocked-by',
+      options.parent,
+    ]);
+
+    if (updateExit !== 0) {
+      console.log(`Created ${issueId} (failed to set parent dependency)`);
+    }
+  }
+
+  if (options.json) {
+    // Fetch full issue details
+    const { stdout: showOutput } = await runBd(['show', issueId, '--json']);
+    console.log(showOutput);
+  } else {
+    console.log(`Created: ${issueId} - "${title}"`);
+    if (options.parent) {
+      console.log(`   Blocked by: ${options.parent}`);
+    }
+    console.log(`\nNext steps:`);
+    console.log(`   term work ${issueId}           - Start working on it`);
+    console.log(`   term spawn genie:wish -t ${issueId}  - Plan with wish skill`);
+    console.log(`   bd show ${issueId}             - View details`);
+  }
+}

package/src/term-commands/kill.ts

@@ -9,6 +9,7 @@
  *   --keep-worktree        - Don't remove the worktree
  */
 
+import { $ } from 'bun';
 import { confirm } from '@inquirer/prompts';
 import * as tmux from '../lib/tmux.js';
 import * as registry from '../lib/worker-registry.js';
@@ -34,6 +35,8 @@ export interface KillOptions {
 // ============================================================================
 
 const WORKTREE_BASE = join(homedir(), '.local', 'share', 'term', 'worktrees');
+// Worktrees are created inside the project at .genie/worktrees/<taskId>
+const WORKTREE_DIR_NAME = '.genie/worktrees';
 
 // ============================================================================
 // Helper Functions
@@ -53,11 +56,19 @@ async function killWorkerPane(paneId: string): Promise<boolean> {
 
 /**
  * Remove worktree
- * Uses bd worktree when beads registry is enabled
- * Falls back to WorktreeManager otherwise
+ * Checks .genie/worktrees first, then bd worktree, then WorktreeManager
  */
 async function removeWorktree(taskId: string, repoPath: string): Promise<boolean> {
-  // Try bd worktree first when beads is enabled
+  // First, check .genie/worktrees location (new location)
+  const inProjectWorktree = join(repoPath, WORKTREE_DIR_NAME, taskId);
+  try {
+    await $`git -C ${repoPath} worktree remove ${inProjectWorktree} --force`.quiet();
+    return true;
+  } catch {
+    // Worktree may not exist at this location, continue checking
+  }
+
+  // Try bd worktree when beads is enabled
   if (useBeads) {
     try {
       const removed = await beadsRegistry.removeWorktree(taskId);
@@ -68,7 +79,7 @@ async function removeWorktree(taskId: string, repoPath: string): Promise<boolean
     }
   }
 
-  // Fallback to WorktreeManager
+  // Fallback to WorktreeManager (legacy location)
   try {
     const manager = new WorktreeManager({
       baseDir: WORKTREE_BASE,

package/src/term-commands/orchestrate.ts

@@ -243,8 +243,9 @@ export async function sendMessage(
   try {
     const { paneId } = await getSessionPane(sessionName, options.pane);
 
-    // Send the message
-    await tmux.executeCommand(paneId, message, false, false);
+    // Send the message cleanly (no TMUX_MCP markers)
+    const escapedMessage = message.replace(/'/g, "'\\''");
+    await tmux.executeTmux(`send-keys -t '${paneId}' '${escapedMessage}' Enter`);
 
     if (options.noWait) {
       console.log(`✅ Message sent to session "${sessionName}"`);

package/src/term-commands/send.ts

@@ -1,6 +1,15 @@
 import * as tmux from '../lib/tmux.js';
 
-export async function sendKeysToSession(sessionName: string, keys: string): Promise<void> {
+export interface SendOptions {
+  enter?: boolean;
+  pane?: string;
+}
+
+export async function sendKeysToSession(
+  sessionName: string,
+  keys: string,
+  options: SendOptions = {}
+): Promise<void> {
   try {
     // Find session
     const session = await tmux.findSessionByName(sessionName);
@@ -9,24 +18,43 @@ export async function sendKeysToSession(sessionName: string, keys: string): Prom
       process.exit(1);
     }
 
-    // Get first window and pane
-    const windows = await tmux.listWindows(session.id);
-    if (!windows || windows.length === 0) {
-      console.error(`❌ No windows found in session "${sessionName}"`);
-      process.exit(1);
-    }
+    let paneId: string;
 
-    const panes = await tmux.listPanes(windows[0].id);
-    if (!panes || panes.length === 0) {
-      console.error(`❌ No panes found in session "${sessionName}"`);
-      process.exit(1);
+    // Use specified pane or find first pane
+    if (options.pane) {
+      paneId = options.pane.startsWith('%') ? options.pane : `%${options.pane}`;
+    } else {
+      // Get first window and pane
+      const windows = await tmux.listWindows(session.id);
+      if (!windows || windows.length === 0) {
+        console.error(`❌ No windows found in session "${sessionName}"`);
+        process.exit(1);
+      }
+
+      const panes = await tmux.listPanes(windows[0].id);
+      if (!panes || panes.length === 0) {
+        console.error(`❌ No panes found in session "${sessionName}"`);
+        process.exit(1);
+      }
+
+      paneId = panes[0].id;
     }
 
-    const paneId = panes[0].id;
+    // Default: enter is true (append Enter key)
+    const withEnter = options.enter !== false;
+
+    // Escape single quotes for shell
+    const escapedKeys = keys.replace(/'/g, "'\\''");
+
+    if (withEnter) {
+      // Send keys with Enter appended
+      await tmux.executeTmux(`send-keys -t '${paneId}' '${escapedKeys}' Enter`);
+    } else {
+      // Send raw keys without Enter
+      await tmux.executeTmux(`send-keys -t '${paneId}' '${escapedKeys}'`);
+    }
 
-    // Send keys without Enter
-    await tmux.executeCommand(paneId, keys, false, true);
-    console.log(`✅ Keys sent to session "${sessionName}"`);
+    console.log(`✅ Keys sent to session "${sessionName}"${withEnter ? ' (with Enter)' : ''}`);
   } catch (error: any) {
     console.error(`❌ Error sending keys: ${error.message}`);
     process.exit(1);