@vibedx/vibekit 0.8.7 → 0.9.0

package/src/commands/plan/to-ticket.js

@@ -0,0 +1,312 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import yaml from 'js-yaml';
+import { getTicketsDir, getConfig, getNextTicketId, createSlug } from '../../utils/index.js';
+import { logger } from '../../utils/cli.js';
+
+/**
+ * Parse CLI arguments for the to-ticket subcommand
+ */
+function parseToTicketArgs(args) {
+  let planFile = null;
+  let dryRun = false;
+  let autoCreate = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--dry-run') {
+      dryRun = true;
+    } else if (arg === '--auto') {
+      autoCreate = true;
+    } else if (!arg.startsWith('-')) {
+      planFile = arg;
+    }
+  }
+
+  return { planFile, dryRun, autoCreate };
+}
+
+/**
+ * Read and validate a plan file
+ */
+function readPlanFile(planFile) {
+  if (!planFile) {
+    throw new Error('Plan file path is required');
+  }
+
+  // Resolve path relative to cwd if not absolute
+  const filePath = path.isAbsolute(planFile)
+    ? planFile
+    : path.join(process.cwd(), planFile);
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Plan file not found: ${filePath}`);
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return { filePath, content };
+}
+
+/**
+ * Create a prompt for Claude to extract tickets from a plan
+ */
+function createExtractionPrompt(planContent) {
+  return `You are a senior software engineer analyzing a project plan.
+
+Plan content:
+${planContent}
+
+Extract all actionable work items from this plan and convert them to a JSON list of tickets.
+
+For each ticket, provide:
+- title: A clear, descriptive title (max 80 chars)
+- description: The main work to be done
+- acceptance_criteria: An array of 2-4 specific, measurable criteria
+- priority: One of: low, medium, high, critical
+- estimated_hours: Rough estimate (0.5, 1, 2, 4, 8, 16, 32)
+
+Return ONLY a valid JSON object with this structure:
+{
+  "tickets": [
+    {
+      "title": "...",
+      "description": "...",
+      "acceptance_criteria": ["...", "..."],
+      "priority": "medium",
+      "estimated_hours": 4
+    }
+  ]
+}
+
+Ensure each ticket is focused, actionable, and independent.`;
+}
+
+/**
+ * Parse Claude envelope and extract text
+ */
+function parseClaudeEnvelope(raw) {
+  let envelope;
+  try {
+    envelope = JSON.parse(raw.trim());
+  } catch {
+    throw new Error('Claude returned non-JSON output');
+  }
+
+  if (envelope.is_error) {
+    throw new Error(envelope.result || 'Claude reported an error');
+  }
+
+  const text = envelope.result ?? '';
+  if (!text.trim()) {
+    throw new Error('Claude returned an empty result');
+  }
+
+  return text;
+}
+
+/**
+ * Extract JSON from Claude's text response
+ */
+function extractJsonFromResponse(text) {
+  const cleaned = text.trim();
+
+  // 1. Direct parse — Claude responded with pure JSON
+  try {
+    JSON.parse(cleaned);
+    return cleaned;
+  } catch { /* fall through */ }
+
+  // 2. Markdown code block — ```json ... ``` or ``` ... ```
+  const codeBlockMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  if (codeBlockMatch) {
+    const inner = codeBlockMatch[1].trim();
+    try {
+      JSON.parse(inner);
+      return inner;
+    } catch { /* fall through */ }
+  }
+
+  // 3. Loose extraction — grab first {...} block
+  const objMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (objMatch) {
+    try {
+      JSON.parse(objMatch[0]);
+      return objMatch[0];
+    } catch { /* fall through */ }
+  }
+
+  throw new Error('No valid JSON object found in Claude response');
+}
+
+/**
+ * Execute Claude to extract tickets from plan
+ */
+async function extractTicketsFromPlan(planContent) {
+  const prompt = createExtractionPrompt(planContent);
+
+  return new Promise((resolve, reject) => {
+    const env = { ...process.env };
+    delete env.ANTHROPIC_API_KEY;
+
+    const child = spawn('claude', ['--print', '--output-format', 'json'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk;
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk;
+    });
+
+    child.on('error', (err) => {
+      reject(new Error(`Failed to spawn Claude: ${err.message}`));
+    });
+
+    child.on('close', (code) => {
+      if (!stdout.trim()) {
+        reject(new Error(stderr.trim() || `Claude exited with code ${code}`));
+        return;
+      }
+
+      try {
+        const text = parseClaudeEnvelope(stdout);
+        const jsonStr = extractJsonFromResponse(text);
+        const result = JSON.parse(jsonStr);
+        resolve(result.tickets || []);
+      } catch (err) {
+        reject(new Error(`Failed to parse Claude response: ${err.message}`));
+      }
+    });
+
+    child.stdin.write(prompt, 'utf8');
+    child.stdin.end();
+  });
+}
+
+/**
+ * Create a ticket in .vibe/tickets/
+ */
+function createTicketFile(ticketData, ticketsDir, ticketId) {
+  const slug = createSlug(ticketData.title);
+  const fileName = `${ticketId}-${slug}.md`;
+  const filePath = path.join(ticketsDir, fileName);
+
+  const acceptanceCriteria = (ticketData.acceptance_criteria || [])
+    .map(criterion => `- [ ] ${criterion}`)
+    .join('\n');
+
+  const content = `---
+id: ${ticketId}
+title: ${ticketData.title}
+slug: ${slug}
+description: ${ticketData.description || ''}
+priority: ${ticketData.priority || 'medium'}
+status: open
+created_at: "${new Date().toISOString()}"
+updated_at: "${new Date().toISOString()}"
+estimated_hours: ${ticketData.estimated_hours || 0}
+---
+
+## Description
+
+${ticketData.description || 'No description provided'}
+
+## Acceptance Criteria
+
+${acceptanceCriteria || '- [ ] Complete the work'}
+
+## Notes
+
+Generated from plan via \`vibe plan to-ticket\`.
+`;
+
+  fs.writeFileSync(filePath, content, 'utf-8');
+  return { fileName, filePath };
+}
+
+/**
+ * Main to-ticket subcommand
+ */
+async function toTicketCommand(args) {
+  try {
+    const { planFile, dryRun, autoCreate } = parseToTicketArgs(args);
+
+    // Validate plan file
+    const { filePath, content: planContent } = readPlanFile(planFile);
+
+    console.log(`📄 Reading plan: ${path.basename(filePath)}`);
+    console.log('');
+
+    // Extract tickets using Claude
+    console.log('🤖 Analyzing plan with Claude...');
+    const tickets = await extractTicketsFromPlan(planContent);
+
+    if (!tickets || tickets.length === 0) {
+      console.log('⚠️  No tickets extracted from plan.');
+      process.exit(0);
+    }
+
+    console.log(`✅ Extracted ${tickets.length} ticket(s)\n`);
+
+    // Show extracted tickets
+    for (const ticket of tickets) {
+      console.log(`📋 ${ticket.title}`);
+      console.log(`   Priority: ${ticket.priority || 'medium'}`);
+      console.log(`   Est. hours: ${ticket.estimated_hours || '?'}`);
+      if (ticket.acceptance_criteria && ticket.acceptance_criteria.length > 0) {
+        console.log(`   Criteria: ${ticket.acceptance_criteria.length} items`);
+      }
+      console.log('');
+    }
+
+    if (dryRun) {
+      console.log('🏁 Dry run complete. No tickets created.');
+      process.exit(0);
+    }
+
+    if (!autoCreate) {
+      console.log('💡 Use --auto to create these tickets automatically.');
+      process.exit(0);
+    }
+
+    // Create tickets
+    const ticketsDir = getTicketsDir();
+    if (!fs.existsSync(ticketsDir)) {
+      fs.mkdirSync(ticketsDir, { recursive: true });
+    }
+
+    console.log('✨ Creating tickets...\n');
+
+    const createdTickets = [];
+    for (const ticketData of tickets) {
+      try {
+        const ticketId = getNextTicketId(ticketsDir);
+        const result = createTicketFile(ticketData, ticketsDir, ticketId);
+        createdTickets.push({ id: ticketId, ...result });
+        console.log(`  ✅ ${ticketId}: ${ticketData.title}`);
+      } catch (error) {
+        console.error(`  ❌ Failed to create ticket: ${error.message}`);
+      }
+    }
+
+    console.log('');
+    console.log(`🎉 Created ${createdTickets.length} ticket(s)`);
+    console.log('');
+    console.log('Next steps:');
+    console.log('  vibe list           # See all tickets');
+    console.log('  vibe start TKT-XXX  # Start working on a ticket');
+
+  } catch (error) {
+    console.error(`❌ ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export default toTicketCommand;

package/src/commands/plan/to-ticket.test.js

@@ -0,0 +1,149 @@
+import { jest } from '@jest/globals';
+import fs from 'fs';
+import path from 'path';
+
+let ticketIdCounter = 1;
+jest.unstable_mockModule('../../utils/index.js', () => ({
+  getTicketsDir: jest.fn(),
+  getConfig: jest.fn(() => ({})),
+  createSlug: jest.fn(title => title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')),
+  getNextTicketId: jest.fn(() => `TKT-${String(ticketIdCounter++).padStart(3, '0')}`)
+}));
+
+const mockChild = {
+  stdout: { on: jest.fn() },
+  stderr: { on: jest.fn() },
+  stdin: { write: jest.fn(), end: jest.fn() },
+  on: jest.fn()
+};
+
+jest.unstable_mockModule('child_process', () => ({
+  spawn: jest.fn(() => mockChild)
+}));
+
+const { default: toTicketCommand } = await import('./to-ticket.js');
+const { getTicketsDir } = await import('../../utils/index.js');
+const childProcess = await import('child_process');
+
+const PLAN_CONTENT = `# Feature Plan
+
+## Goals
+- Build a login page
+- Add a settings page
+`;
+
+const CLAUDE_TICKETS = {
+  tickets: [
+    {
+      title: 'Build login page',
+      description: 'Create the login form',
+      acceptance_criteria: ['Form renders', 'Submits credentials'],
+      priority: 'high',
+      estimated_hours: 4
+    },
+    {
+      title: 'Add settings page',
+      description: 'User settings screen',
+      acceptance_criteria: ['Settings persist'],
+      priority: 'medium',
+      estimated_hours: 2
+    }
+  ]
+};
+
+// Drive the mocked Claude process: feed it a JSON envelope and close.
+function primeClaude(resultObj, { isError = false } = {}) {
+  const envelope = JSON.stringify({
+    is_error: isError,
+    result: isError ? 'boom' : JSON.stringify(resultObj)
+  });
+
+  mockChild.stdout.on.mockImplementation((event, cb) => {
+    if (event === 'data') cb(Buffer.from(envelope));
+  });
+  mockChild.stderr.on.mockImplementation(() => {});
+  mockChild.on.mockImplementation((event, cb) => {
+    if (event === 'close') cb(0);
+  });
+}
+
+describe('plan to-ticket command', () => {
+  let tempDir;
+  let ticketsDir;
+  let planFile;
+  let mockExit;
+  let mockConsoleLog;
+  let mockConsoleError;
+
+  beforeEach(() => {
+    ticketIdCounter = 1;
+    tempDir = fs.mkdtempSync(path.join('/tmp', 'vibe-to-ticket-'));
+    ticketsDir = path.join(tempDir, '.vibe', 'tickets');
+    fs.mkdirSync(ticketsDir, { recursive: true });
+    planFile = path.join(tempDir, 'plan.md');
+    fs.writeFileSync(planFile, PLAN_CONTENT);
+
+    getTicketsDir.mockReturnValue(ticketsDir);
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => { throw new Error('process.exit'); });
+    mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+    mockConsoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    mockExit.mockRestore();
+    mockConsoleLog.mockRestore();
+    mockConsoleError.mockRestore();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    jest.clearAllMocks();
+  });
+
+  test('errors when plan file is missing', async () => {
+    await expect(toTicketCommand(['/tmp/does-not-exist.md'])).rejects.toThrow('process.exit');
+    expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Plan file not found'));
+  });
+
+  test('dry-run extracts tickets without creating files', async () => {
+    primeClaude(CLAUDE_TICKETS);
+    await expect(toTicketCommand([planFile, '--dry-run'])).rejects.toThrow('process.exit');
+    expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Dry run complete'));
+    expect(fs.readdirSync(ticketsDir)).toHaveLength(0);
+  });
+
+  test('preview (no --auto) does not create tickets', async () => {
+    primeClaude(CLAUDE_TICKETS);
+    await expect(toTicketCommand([planFile])).rejects.toThrow('process.exit');
+    expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('--auto'));
+    expect(fs.readdirSync(ticketsDir)).toHaveLength(0);
+  });
+
+  test('--auto creates one ticket file per extracted item', async () => {
+    primeClaude(CLAUDE_TICKETS);
+    await toTicketCommand([planFile, '--auto']);
+    const files = fs.readdirSync(ticketsDir).sort();
+    expect(files).toEqual([
+      'TKT-001-build-login-page.md',
+      'TKT-002-add-settings-page.md'
+    ].sort());
+
+    const first = fs.readFileSync(path.join(ticketsDir, 'TKT-001-build-login-page.md'), 'utf-8');
+    expect(first).toContain('id: TKT-001');
+    expect(first).toContain('priority: high');
+    expect(first).toContain('- [ ] Form renders');
+  });
+
+  test('surfaces Claude errors', async () => {
+    primeClaude(null, { isError: true });
+    await expect(toTicketCommand([planFile, '--auto'])).rejects.toThrow('process.exit');
+    expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('boom'));
+  });
+
+  test('spawns claude with json output format', async () => {
+    primeClaude(CLAUDE_TICKETS);
+    await toTicketCommand([planFile, '--auto']);
+    expect(childProcess.spawn).toHaveBeenCalledWith(
+      'claude',
+      expect.arrayContaining(['--print', '--output-format', 'json']),
+      expect.any(Object)
+    );
+  });
+});

package/src/commands/start/index.js

@@ -3,7 +3,6 @@ import path from 'path';
 import yaml from 'js-yaml';
 import { execSync, spawn } from 'child_process';
 import { getTicketsDir, getConfig, createSlug } from '../../utils/index.js';
-import { fileURLToPath } from 'url';
 import {
   isGitRepository,
   getCurrentBranch,
@@ -19,16 +18,7 @@ import {
   getRepoRoot,
   getDefaultBaseBranch
 } from '../../utils/git.js';
-
-function loadSkillContext() {
-  try {
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const skillPath = path.join(__dirname, '..', '..', '..', 'skills', 'vibekit', 'SKILL.md');
-    return fs.readFileSync(skillPath, 'utf-8');
-  } catch {
-    return '';
-  }
-}
+import { loadSkillContext, buildAgentPrompt, spawnAgent } from '../../utils/agent.js';
 
 function parseTicketIds(args) {
   const ids = [];
@@ -280,24 +270,15 @@ function startCommand(args) {
     }
 
     if (spawnAgent) {
-      const agentTimeout = config.worktree?.agent?.timeout || 900;
+      const agentTimeout = config.worktree?.agent?.timeout || config.agent?.timeout || 900;
       const skillContext = loadSkillContext();
       console.log('\n🤖 Spawning Claude agents...\n');
       for (const info of worktreeInfos) {
-        const ticketContent = fs.readFileSync(info.ticket.filePath, 'utf-8');
-        const prompt = flags.prompt
-          ? flags.prompt
-          : `You are working on ticket ${info.ticket.frontmatter.id}: ${info.title}\n\nHere is the full ticket:\n\n${ticketContent}\n\nImplement the ticket requirements. Follow the acceptance criteria. Commit your work when done. Update the ticket status to done when complete.${skillContext ? `\n\n--- VibeKit Skill Reference ---\n${skillContext}` : ''}`;
+        const prompt = buildAgentPrompt(info.ticket, flags.prompt, skillContext);
 
         try {
-          const agentProcess = spawn('claude', ['-p', prompt, '--timeout', String(agentTimeout * 1000)], {
-            cwd: info.worktreePath,
-            stdio: 'ignore',
-            detached: true
-          });
-
-          agentProcess.unref();
-          console.log(`  🤖 ${info.ticket.frontmatter.id}: Agent spawned in ${info.worktreePath} (timeout: ${agentTimeout}s)`);
+          const pid = spawnAgent(prompt, info.worktreePath, agentTimeout);
+          console.log(`  🤖 ${info.ticket.frontmatter.id}: Agent spawned in ${info.worktreePath} (PID ${pid}, timeout: ${agentTimeout}s)`);
         } catch (error) {
           console.error(`  ❌ ${info.ticket.frontmatter.id}: Failed to spawn agent — ${error.message}`);
         }
@@ -337,23 +318,14 @@ function startCommand(args) {
 
     if (spawnAgent) {
       const ticket = tickets[0];
-      const agentTimeout = config.worktree?.agent?.timeout || 900;
+      const agentTimeout = config.worktree?.agent?.timeout || config.agent?.timeout || 900;
       const skillContext = loadSkillContext();
-      const ticketContent = fs.readFileSync(ticket.filePath, 'utf-8');
-      const prompt = flags.prompt
-        ? flags.prompt
-        : `You are working on ticket ${ticket.frontmatter.id}: ${ticket.frontmatter.title}\n\nHere is the full ticket:\n\n${ticketContent}\n\nImplement the ticket requirements. Follow the acceptance criteria. Commit your work when done. Update the ticket status to done when complete.${skillContext ? `\n\n--- VibeKit Skill Reference ---\n${skillContext}` : ''}`;
+      const prompt = buildAgentPrompt(ticket, flags.prompt, skillContext);
 
       console.log('\n🤖 Spawning Claude agent...\n');
       try {
-        const agentProcess = spawn('claude', ['-p', prompt, '--timeout', String(agentTimeout * 1000)], {
-          cwd: process.cwd(),
-          stdio: 'ignore',
-          detached: true
-        });
-
-        agentProcess.unref();
-        console.log(`  🤖 ${ticket.frontmatter.id}: Agent spawned (timeout: ${agentTimeout}s)`);
+        const pid = spawnAgent(prompt, process.cwd(), agentTimeout);
+        console.log(`  🤖 ${ticket.frontmatter.id}: Agent spawned (PID ${pid}, timeout: ${agentTimeout}s)`);
         console.log('\n🏁 Agent launched!\n');
         console.log('Monitor progress:');
         console.log('  vibe status          # see ticket status');