@automagik/genie 0.260202.1833 → 0.260203.43

package/src/lib/skill-loader.ts

@@ -0,0 +1,215 @@
+/**
+ * Skill Loader - Find and load Claude skills
+ *
+ * Skills are stored in:
+ *   1. .claude/skills/<skill-name>/SKILL.md (project local)
+ *   2. ~/.claude/skills/<skill-name>/SKILL.md (user global)
+ *
+ * Skill names are simple (wish, forge, review) and map to directories:
+ *   - Direct match: wish -> wish/
+ *   - Prefixed: wish -> genie-wish/
+ */
+
+import { access, readFile } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export interface SkillInfo {
+  name: string;
+  path: string;
+  skillFile: string;
+  description?: string;
+}
+
+/**
+ * Get possible directory names for a skill
+ * e.g., "wish" -> ["wish", "genie-wish"]
+ */
+function skillNameToDirs(skillName: string): string[] {
+  return [skillName, `genie-${skillName}`];
+}
+
+/**
+ * Check if a path exists
+ */
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Find a skill by name
+ *
+ * Search order:
+ * 1. .claude/skills/<skill-dir>/SKILL.md (project local)
+ * 2. ~/.claude/skills/<skill-dir>/SKILL.md (user global)
+ *
+ * For each location, tries both exact name and genie-prefixed name.
+ *
+ * @param skillName - Skill name (e.g., "wish", "forge", "review")
+ * @param projectRoot - Project root directory (defaults to cwd)
+ * @returns SkillInfo if found, null otherwise
+ */
+export async function findSkill(
+  skillName: string,
+  projectRoot?: string
+): Promise<SkillInfo | null> {
+  const dirNames = skillNameToDirs(skillName);
+  const cwd = projectRoot || process.cwd();
+
+  // Search locations in order of precedence
+  const searchLocations = [
+    join(cwd, '.claude', 'skills'),
+    join(homedir(), '.claude', 'skills'),
+  ];
+
+  for (const location of searchLocations) {
+    for (const dirName of dirNames) {
+      const skillPath = join(location, dirName);
+      const skillFile = join(skillPath, 'SKILL.md');
+
+      if (await pathExists(skillFile)) {
+        // Parse description from frontmatter if available
+        let description: string | undefined;
+        try {
+          const content = await readFile(skillFile, 'utf-8');
+          const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+          if (frontmatterMatch) {
+            const descMatch = frontmatterMatch[1].match(/description:\s*["']?([^"'\n]+)["']?/);
+            if (descMatch) {
+              description = descMatch[1];
+            }
+          }
+        } catch {
+          // Ignore parse errors
+        }
+
+        return {
+          name: skillName,
+          path: skillPath,
+          skillFile,
+          description,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Validate that a skill exists and has required files
+ *
+ * @param skillPath - Path to skill directory
+ * @returns true if valid, false otherwise
+ */
+export async function validateSkill(skillPath: string): Promise<boolean> {
+  const skillFile = join(skillPath, 'SKILL.md');
+  return pathExists(skillFile);
+}
+
+/**
+ * Read skill content from SKILL.md
+ *
+ * @param skillFile - Path to SKILL.md
+ * @returns Skill content as string
+ */
+export async function readSkillContent(skillFile: string): Promise<string> {
+  return readFile(skillFile, 'utf-8');
+}
+
+/**
+ * Build a prompt that loads a skill
+ *
+ * Reads the skill file and includes its content directly in the prompt.
+ *
+ * @param skill - SkillInfo from findSkill
+ * @param additionalPrompt - Optional additional context/instructions
+ * @returns Combined prompt string
+ */
+export async function buildSkillPrompt(
+  skill: SkillInfo,
+  additionalPrompt?: string
+): Promise<string> {
+  // Read the skill content
+  const skillContent = await readFile(skill.skillFile, 'utf-8');
+
+  const parts = [
+    `You are running skill: ${skill.name}`,
+    '',
+    '## Skill Instructions',
+    '',
+    skillContent,
+  ];
+
+  if (additionalPrompt) {
+    parts.push('', '---', '', '## Additional Context', '', additionalPrompt);
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Parse skill name from SKILL.md frontmatter
+ * Falls back to directory name conversion if no frontmatter name
+ */
+async function parseSkillName(skillFile: string, dirName: string): Promise<string> {
+  try {
+    const content = await readFile(skillFile, 'utf-8');
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+      const nameMatch = frontmatterMatch[1].match(/name:\s*["']?([^"'\n]+)["']?/);
+      if (nameMatch) {
+        return nameMatch[1].trim();
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+  // Fallback: convert first hyphen to colon (genie-wish -> genie:wish)
+  // but leave subsequent hyphens as-is for multi-word names
+  return dirName.replace(/-/, ':');
+}
+
+/**
+ * List all available skills
+ *
+ * @param projectRoot - Project root directory (defaults to cwd)
+ * @returns Array of skill names found
+ */
+export async function listSkills(projectRoot?: string): Promise<string[]> {
+  const { readdir } = await import('fs/promises');
+  const cwd = projectRoot || process.cwd();
+  const skills: string[] = [];
+
+  const searchPaths = [
+    join(cwd, '.claude', 'skills'),
+    join(homedir(), '.claude', 'skills'),
+  ];
+
+  for (const searchPath of searchPaths) {
+    try {
+      const entries = await readdir(searchPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillFile = join(searchPath, entry.name, 'SKILL.md');
+          if (await pathExists(skillFile)) {
+            // Get skill name from frontmatter or convert directory name
+            const skillName = await parseSkillName(skillFile, entry.name);
+            if (!skills.includes(skillName)) {
+              skills.push(skillName);
+            }
+          }
+        }
+      }
+    } catch {
+      // Directory doesn't exist, skip
+    }
+  }
+
+  return skills.sort();
+}

package/src/lib/tmux.ts

@@ -222,15 +222,25 @@ export async function killPane(paneId: string): Promise<void> {
   await executeTmux(`kill-pane -t '${paneId}'`);
 }
 
+/**
+ * Escape a string for safe use in shell single quotes.
+ * Replaces ' with '\'' (end quote, escaped quote, start quote).
+ */
+function escapeShellPath(path: string): string {
+  return path.replace(/'/g, "'\\''");
+}
+
 /**
  * Split a tmux pane horizontally or vertically
  */
 export async function splitPane(
   targetPaneId: string,
   direction: 'horizontal' | 'vertical' = 'vertical',
-  size?: number
+  size?: number,
+  workingDir?: string
 ): Promise<TmuxPane | null> {
   // Build the split-window command
+  // Order follows tmux convention: flags, -c, -p, -t, -F
   let splitCommand = 'split-window';
 
   // Add direction flag (-h for horizontal, -v for vertical)
@@ -240,25 +250,34 @@ export async function splitPane(
     splitCommand += ' -v';
   }
 
-  // Add target pane
-  splitCommand += ` -t '${targetPaneId}'`;
+  // Add working directory if specified (must come before -t)
+  if (workingDir) {
+    splitCommand += ` -c '${escapeShellPath(workingDir)}'`;
+  }
 
   // Add size if specified (as percentage)
   if (size !== undefined && size > 0 && size < 100) {
     splitCommand += ` -p ${size}`;
   }
 
-  // Execute the split command
-  await executeTmux(splitCommand);
+  // Add target pane
+  splitCommand += ` -t '${targetPaneId}'`;
+
+  // Add -P flag to print new pane info, with format to get pane ID
+  splitCommand += ` -P -F '#{pane_id}'`;
 
-  // Get the window ID from the target pane to list all panes
-  const windowInfo = await executeTmux(`display-message -p -t '${targetPaneId}' '#{window_id}'`);
+  // Execute the split command - returns the new pane ID
+  const newPaneId = (await executeTmux(splitCommand)).trim();
 
-  // List all panes in the window to find the newly created one
-  const panes = await listPanes(windowInfo);
+  // Get the window ID for the new pane
+  const windowId = await executeTmux(`display-message -p -t '${newPaneId}' '#{window_id}'`);
 
-  // The newest pane is typically the last one in the list
-  return panes.length > 0 ? panes[panes.length - 1] : null;
+  return {
+    id: newPaneId,
+    windowId: windowId.trim(),
+    active: false,
+    title: ''
+  };
 }
 
 // Map to track ongoing command executions

package/src/lib/version.ts

@@ -1,5 +1,5 @@
 // Runtime version (baked in at build time)
-export const VERSION = '0.260202.1833';
+export const VERSION = '0.260203.0043';
 
 // Generate version string from current datetime
 // Format: 0.YYMMDD.HHMM (e.g., 0.260201.1430 = Feb 1, 2026 at 14:30)

package/src/lib/worker-registry.ts

@@ -47,6 +47,8 @@ export interface Worker {
   lastStateChange: string;
   /** Repository path where worker operates */
   repoPath: string;
+  /** Claude session ID for resume capability */
+  claudeSessionId?: string;
 }
 
 export interface WorkerRegistry {
@@ -176,6 +178,14 @@ export async function findByWish(wishSlug: string): Promise<Worker[]> {
   return workers.filter(w => w.wishSlug === wishSlug);
 }
 
+/**
+ * Find worker by Claude session ID
+ */
+export async function findBySessionId(sessionId: string): Promise<Worker | null> {
+  const workers = await list();
+  return workers.find(w => w.claudeSessionId === sessionId) || null;
+}
+
 /**
  * Check if a worker exists for a given task
  */

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);
+}