@crewx/wbs 0.1.6 → 0.1.8

package/dist/cli.js

@@ -0,0 +1,718 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const engine_1 = require("./src/engine");
+let PKG_VERSION = 'unknown';
+try {
+    const _pkgPath = fs.existsSync(path.join(__dirname, 'package.json'))
+        ? path.join(__dirname, 'package.json')
+        : path.join(__dirname, '..', 'package.json');
+    const _pkg = JSON.parse(fs.readFileSync(_pkgPath, 'utf-8'));
+    if (_pkg?.version)
+        PKG_VERSION = String(_pkg.version);
+}
+catch { }
+async function loadTracer() {
+    try {
+        return await Promise.resolve().then(() => __importStar(require('@crewx/shared/skill-tracer')));
+    }
+    catch {
+        return null;
+    }
+}
+const STATUS_ICONS = {
+    pending: '⬜️',
+    running: '🟡',
+    completed: '✅',
+    failed: '❌',
+    on_hold: '⏸️',
+    planning: '📝',
+    partial: '⚠️',
+};
+function icon(status) {
+    return STATUS_ICONS[status] ?? '❓';
+}
+function getDisplayWidth(str) {
+    let width = 0;
+    for (const char of String(str)) {
+        const code = char.codePointAt(0) ?? 0;
+        if ((code >= 0x1100 && code <= 0x11FF) || (code >= 0x3000 && code <= 0x303F) ||
+            (code >= 0x3040 && code <= 0x309F) || (code >= 0x30A0 && code <= 0x30FF) ||
+            (code >= 0x3130 && code <= 0x318F) || (code >= 0x3200 && code <= 0x32FF) ||
+            (code >= 0x4E00 && code <= 0x9FFF) || (code >= 0xAC00 && code <= 0xD7AF) ||
+            (code >= 0xF900 && code <= 0xFAFF) || (code >= 0xFF00 && code <= 0xFFEF) ||
+            (code >= 0x1F300 && code <= 0x1F9FF) || (code >= 0x2600 && code <= 0x26FF) ||
+            (code >= 0x2700 && code <= 0x27BF)) {
+            width += 2;
+        }
+        else {
+            width += 1;
+        }
+    }
+    return width;
+}
+function pad(str, targetWidth) {
+    const s = String(str);
+    const diff = targetWidth - getDisplayWidth(s);
+    return diff > 0 ? s + ' '.repeat(diff) : s;
+}
+function colWidths(headers, rows) {
+    const widths = headers.map(h => getDisplayWidth(h));
+    rows.forEach(row => row.forEach((cell, i) => {
+        const w = getDisplayWidth(String(cell));
+        if (w > (widths[i] ?? 0))
+            widths[i] = w;
+    }));
+    return widths;
+}
+function fmtRow(cells, widths) {
+    return '| ' + cells.map((c, i) => pad(String(c), widths[i] ?? 0)).join(' | ') + ' |';
+}
+function fmtSep(widths) {
+    return '|' + widths.map(w => '-'.repeat(w + 2)).join('|') + '|';
+}
+function fmtTable(headers, rows) {
+    const w = colWidths(headers, rows);
+    return [fmtRow(headers, w), fmtSep(w), ...rows.map(r => fmtRow(r, w))].join('\n');
+}
+function fmtProjectList(projects) {
+    if (!projects || projects.length === 0)
+        return '📋 WBS Projects (0)\n\nNo projects found.';
+    const rows = projects.map(p => {
+        const jobs = engine_1.engine.listJobs(p.id);
+        const done = jobs.filter(j => j.status === 'completed').length;
+        const total = jobs.length;
+        const progress = total > 0 ? Math.round((done / total) * 100) : 0;
+        const statusIcon = p.status === 'completed' ? icon('completed')
+            : (p.status === 'running' || jobs.some(j => j.status === 'running')) ? icon('running')
+                : done > 0 ? icon('running') : icon('pending');
+        return [statusIcon, p.id, p.title, String(total), `${progress}%`];
+    });
+    return `📋 WBS Projects (${projects.length})\n\n${fmtTable(['상태', 'ID', '프로젝트명', 'Jobs', 'Progress'], rows)}`;
+}
+function fmtStatus(result) {
+    if (!result.project)
+        return '❌ Project not found';
+    const { project, jobs, summary } = result;
+    const lines = [];
+    lines.push(`📋 ${project.title} (${project.id})`);
+    if (summary)
+        lines.push(`   Status: ${project.status} | Progress: ${summary.progress}% (${summary.completed}/${summary.total})`);
+    if (project.detail_path)
+        lines.push(`   Detail: ${project.detail_path}`);
+    lines.push('');
+    if (jobs.length === 0) {
+        lines.push('   Jobs: None');
+    }
+    else {
+        lines.push('   Jobs:');
+        const table = fmtTable(['상태', '#', 'Slug', 'ID', '작업명', '담당'], jobs.map((j, i) => [icon(j.status), String(i + 1), (0, engine_1.getJobSlug)(j), j.id, j.title, j.agent]));
+        table.split('\n').forEach(l => lines.push('   ' + l));
+    }
+    return lines.join('\n');
+}
+function fmtJobList(jobs, wbsId) {
+    if (!jobs || jobs.length === 0)
+        return `📋 Jobs for ${wbsId} (0)\n\nNo jobs found.`;
+    const done = jobs.filter(j => j.status === 'completed').length;
+    const progress = jobs.length > 0 ? Math.round((done / jobs.length) * 100) : 0;
+    const table = fmtTable(['상태', '#', 'Slug', 'ID', '작업명', '담당', 'Status'], jobs.map((j, i) => [icon(j.status), String(i + 1), (0, engine_1.getJobSlug)(j), j.id, j.title, j.agent, j.status]));
+    return `📋 Jobs for ${wbsId} (${jobs.length})\n   Progress: ${progress}% (${done}/${jobs.length})\n\n${table}`;
+}
+function fmtExecList(execs, jobId) {
+    if (execs.length === 0)
+        return `No executions found for job: ${jobId}`;
+    const headers = ['상태', 'ID', 'PID', 'Task ID', '시작', '종료', '코드'];
+    const rows = execs.map(e => [
+        icon(e.status), e.id, String(e.pid ?? '-'), e.task_id ?? '-',
+        e.started_at ? new Date(e.started_at).toLocaleString('ko-KR') : '-',
+        e.ended_at ? new Date(e.ended_at).toLocaleString('ko-KR') : '-',
+        e.exit_code !== null ? String(e.exit_code) : '-',
+    ]);
+    return `📋 Executions for ${jobId}\n\n${fmtTable(headers, rows)}`;
+}
+function fmtExecStatus(exec) {
+    return `\n📋 Execution: ${exec.id}\n\nStatus:     ${icon(exec.status)} ${exec.status}\nJob ID:     ${exec.job_id}\nPID:        ${exec.pid ?? '-'}\nTask ID:    ${exec.task_id ?? '-'}\nStarted:    ${exec.started_at ? new Date(exec.started_at).toLocaleString('ko-KR') : '-'}\nEnded:      ${exec.ended_at ? new Date(exec.ended_at).toLocaleString('ko-KR') : '-'}\nExit Code:  ${exec.exit_code !== null ? exec.exit_code : '-'}\nError:      ${exec.error ?? '-'}\n`;
+}
+function fmtRunning(execs) {
+    if (execs.length === 0)
+        return 'No running executions';
+    const headers = ['상태', 'Exec ID', 'Job ID', 'PID', 'Task ID', '시작'];
+    const rows = execs.map(e => [
+        icon(e.status), e.id, e.job_id, String(e.pid ?? '-'), e.task_id ?? '-',
+        e.started_at ? new Date(e.started_at).toLocaleString('ko-KR') : '-',
+    ]);
+    return `🟡 Running Executions (${execs.length})\n\n${fmtTable(headers, rows)}`;
+}
+function hasJson(args) { return args.includes('--json'); }
+function hasFlag(args, name) { return args.includes(`--${name}`); }
+function getBooleanOpt(args, opts, name) {
+    const inlinePrefix = `--${name}=`;
+    const inlineArg = args.find(arg => arg.startsWith(inlinePrefix));
+    if (inlineArg) {
+        const rawInline = inlineArg.slice(inlinePrefix.length);
+        if (rawInline === 'true' || rawInline === '1')
+            return true;
+        if (rawInline === 'false' || rawInline === '0')
+            return false;
+        console.error(`Invalid boolean for --${name}: ${rawInline} (use true/false)`);
+        process.exit(1);
+    }
+    if (hasFlag(args, name))
+        return true;
+    const raw = opts[name];
+    if (raw === undefined)
+        return undefined;
+    if (raw === 'true' || raw === '1')
+        return true;
+    if (raw === 'false' || raw === '0')
+        return false;
+    console.error(`Invalid boolean for --${name}: ${raw} (use true/false)`);
+    process.exit(1);
+}
+function parseOpts(args, start = 0) {
+    const opts = {};
+    for (let i = start; i < args.length; i++) {
+        const current = args[i];
+        if (!current)
+            continue;
+        const next = args[i + 1];
+        if (current.startsWith('--') && next && !next.startsWith('--')) {
+            opts[current.slice(2)] = next;
+            i++;
+        }
+    }
+    return opts;
+}
+function handleJob(args) {
+    const sub = args[0];
+    switch (sub) {
+        case 'list': {
+            const wbsId = args[1];
+            if (!wbsId) {
+                console.error('Usage: wbs job list <wbs-id> [--json]');
+                process.exit(1);
+            }
+            const jobs = engine_1.engine.listJobs(wbsId);
+            console.log(hasJson(args) ? JSON.stringify(jobs, null, 2) : fmtJobList(jobs, wbsId));
+            break;
+        }
+        case 'add': {
+            const wbsId = args[1];
+            const opts = parseOpts(args, 2);
+            const { title, agent } = opts;
+            const description = opts.desc || opts.description || null;
+            const seq = opts.seq ? parseInt(opts.seq, 10) : 0;
+            const issue_number = opts.issue ? parseInt(opts.issue, 10) : null;
+            const no_git = getBooleanOpt(args, opts, 'no-git') ?? false;
+            if (!wbsId || !title || !agent) {
+                console.error('Usage: wbs job add <wbs-id> --title "Job Title" --agent "@agent" [--desc "..."] [--seq N] [--issue N] [--no-git]');
+                process.exit(1);
+            }
+            const jobId = engine_1.engine.addJob(wbsId, { title, description, agent, seq, issue_number, no_git });
+            (0, engine_1.generateDetailFile)(wbsId);
+            console.log(JSON.stringify({ jobId, wbsId, title, description, agent, seq, issue_number, no_git }, null, 2));
+            break;
+        }
+        case 'update': {
+            const jobIdArg = args[1];
+            if (!jobIdArg) {
+                console.error('Usage: wbs job update <job-id|slug> [--status ...] [--title ...] [--agent ...] [--seq N] [--desc ...] [--issue N] [--no-git[=true|false]]');
+                process.exit(1);
+            }
+            const opts = parseOpts(args, 2);
+            const job = (0, engine_1.resolveJobId)(jobIdArg);
+            if (!job) {
+                console.error(`Job not found: ${jobIdArg}`);
+                process.exit(1);
+            }
+            const jobId = job.id;
+            const fields = {};
+            if (opts.status) {
+                if (!['pending', 'running', 'completed', 'failed'].includes(opts.status)) {
+                    console.error('Invalid status. Must be: pending, running, completed, or failed');
+                    process.exit(1);
+                }
+                fields.status = opts.status;
+            }
+            if (opts.title)
+                fields.title = opts.title;
+            if (opts.agent)
+                fields.agent = opts.agent;
+            if (opts.seq !== undefined)
+                fields.seq = parseInt(opts.seq, 10);
+            if (opts.desc || opts.description)
+                fields.description = opts.desc || opts.description;
+            if (opts.issue !== undefined)
+                fields.issue_number = opts.issue ? parseInt(opts.issue, 10) : null;
+            const noGitOpt = getBooleanOpt(args, opts, 'no-git');
+            if (noGitOpt !== undefined)
+                fields.no_git = noGitOpt;
+            if (Object.keys(fields).length === 0) {
+                console.error('No update options provided.');
+                process.exit(1);
+            }
+            engine_1.engine.updateJob(jobId, fields);
+            const updated = engine_1.engine.getJob(jobId);
+            console.log(JSON.stringify(updated, null, 2));
+            break;
+        }
+        case 'next': {
+            const wbsId = args[1];
+            if (!wbsId) {
+                console.error('Usage: wbs job next <wbs-id>');
+                process.exit(1);
+            }
+            const job = engine_1.engine.getNextJob(wbsId);
+            if (job) {
+                engine_1.engine.runWorker(job).then(r => console.log(JSON.stringify(r, null, 2)));
+            }
+            else {
+                console.log('No pending jobs');
+            }
+            break;
+        }
+        case 'run': {
+            const wbsId = args[1];
+            if (!wbsId) {
+                console.error('Usage: wbs job run <wbs-id>');
+                process.exit(1);
+            }
+            engine_1.engine.run(wbsId);
+            break;
+        }
+        case 'retry': {
+            const jobIdArg = args[1];
+            if (!jobIdArg) {
+                console.error('Usage: wbs job retry <job-id|slug>');
+                process.exit(1);
+            }
+            const job = (0, engine_1.resolveJobId)(jobIdArg);
+            if (!job) {
+                console.error(`Job not found: ${jobIdArg}`);
+                process.exit(1);
+            }
+            engine_1.engine.updateJob(job.id, { status: 'pending' });
+            console.log(`[WBS] Retrying job: ${job.title}`);
+            engine_1.engine.runWorker(job).then(r => console.log(JSON.stringify(r, null, 2)));
+            break;
+        }
+        default:
+            console.log(`
+Job Commands - Manage jobs within a WBS project
+
+Usage:
+  wbs job list <wbs-id> [--json]     List all jobs in a project
+  wbs job add <wbs-id> [options]     Add a new job to the project
+  wbs job update <job-id> [options]  Update an existing job
+  wbs job next <wbs-id>              Run the next pending job
+  wbs job run <wbs-id> [--parallel]  Run all pending jobs (default: sequential)
+  wbs job retry <job-id>             Retry a failed/completed job
+
+Options for 'job add':
+  --title "Job Title"     Job title (required)
+  --agent "@agent"        Worker agent (required)
+  --seq N                 Execution sequence (default: 0)
+  --desc "..."            Detailed instructions
+  --issue N               Related GitHub issue number
+  --no-git                Skip git worktree/PR template for non-code jobs
+
+Options for 'job update':
+  --no-git[=true|false]   Set/clear no_git flag
+
+Options for 'job run':
+  --parallel              Run same-seq pending jobs concurrently (job run only)
+`);
+    }
+}
+function handleExec(args) {
+    const sub = args[0];
+    switch (sub) {
+        case 'list': {
+            const jobIdArg = args[1];
+            if (!jobIdArg) {
+                console.error('Usage: wbs exec list <job-id|slug> [--json]');
+                process.exit(1);
+            }
+            const resolvedJob = (0, engine_1.resolveJobId)(jobIdArg);
+            const jobId = resolvedJob?.id ?? jobIdArg;
+            const execs = engine_1.engine.listExecutions(jobId);
+            console.log(hasJson(args) ? JSON.stringify(execs, null, 2) : fmtExecList(execs, jobId));
+            break;
+        }
+        case 'status': {
+            const execId = args[1];
+            if (!execId) {
+                console.error('Usage: wbs exec status <exec-id> [--json]');
+                process.exit(1);
+            }
+            const exec = engine_1.engine.getExecution(execId);
+            if (!exec) {
+                console.error(`Execution not found: ${execId}`);
+                process.exit(1);
+            }
+            console.log(hasJson(args) ? JSON.stringify(exec, null, 2) : fmtExecStatus(exec));
+            break;
+        }
+        case 'kill': {
+            const execId = args[1];
+            if (!execId) {
+                console.error('Usage: wbs exec kill <exec-id>');
+                process.exit(1);
+            }
+            const ok = engine_1.engine.killExecution(execId);
+            if (ok) {
+                console.log(`Killed execution: ${execId}`);
+            }
+            else {
+                console.error(`Could not kill execution: ${execId} (not running or not found)`);
+                process.exit(1);
+            }
+            break;
+        }
+        case 'running': {
+            const execs = engine_1.engine.getRunningExecutions();
+            console.log(hasJson(args) ? JSON.stringify(execs, null, 2) : fmtRunning(execs));
+            break;
+        }
+        default:
+            console.log(`
+Execution Commands - Manage job executions
+
+Usage:
+  wbs exec list <job-id> [--json]    List execution history for a job
+  wbs exec status <exec-id> [--json] Get execution details
+  wbs exec kill <exec-id>            Kill a running execution
+  wbs exec running [--json]          List all running executions
+`);
+    }
+}
+function getLocalTimestamp() {
+    const now = new Date();
+    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+}
+function daemonTick() {
+    const ts = getLocalTimestamp();
+    console.log(`[${ts}] Daemon tick`);
+    const zombies = engine_1.engine.checkAndFixZombies();
+    if (zombies.length > 0) {
+        console.log(`[${ts}] Fixed ${zombies.length} zombie(s):`);
+        zombies.forEach(z => console.log(`  - ${z.jobId}: ${z.reason}`));
+    }
+    const activeProjects = engine_1.engine.getActiveProjects();
+    if (activeProjects.length === 0) {
+        console.log(`[${ts}] No active projects`);
+        return;
+    }
+    for (const project of activeProjects) {
+        const nextSeq = engine_1.engine.getNextSeq(project.id);
+        if (nextSeq === null) {
+            console.log(`[${ts}] ${project.id}: No pending jobs`);
+            continue;
+        }
+        const running = engine_1.engine.getJobsBySeq(project.id, nextSeq, 'running');
+        const pending = engine_1.engine.getJobsBySeq(project.id, nextSeq, 'pending');
+        if (running.length > 0) {
+            console.log(`[${ts}] ${project.id}: ${running.length} job(s) running in seq ${nextSeq}`);
+            continue;
+        }
+        if (pending.length > 0) {
+            console.log(`[${ts}] ${project.id}: Starting next seq ${nextSeq} (${pending.length} pending)`);
+            try {
+                (0, child_process_1.execSync)(`crewx x "@wbs_coordinator ${project.id} 다음 작업 진행해줘"`, { stdio: 'inherit', cwd: process.cwd() });
+            }
+            catch (e) {
+                console.error(`[${ts}] Failed to call coordinator: ${e.message}`);
+            }
+        }
+    }
+}
+function startDaemon() {
+    const pidFile = engine_1.engine.daemonPidFile;
+    if (fs.existsSync(pidFile)) {
+        const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+        if (engine_1.engine.isProcessAlive(pid)) {
+            console.error(`[WBS Daemon] Already running (PID: ${pid})`);
+            return false;
+        }
+        fs.unlinkSync(pidFile);
+    }
+    const logFile = engine_1.engine.daemonLogFile;
+    const out = fs.openSync(logFile, 'a');
+    const child = (0, child_process_1.spawn)(process.execPath, [__filename, 'daemon', '--foreground'], {
+        detached: true,
+        stdio: ['ignore', out, out],
+        cwd: process.cwd(),
+    });
+    fs.writeFileSync(pidFile, String(child.pid));
+    child.unref();
+    console.log(`[WBS Daemon] Started (PID: ${child.pid})`);
+    console.log(`[WBS Daemon] Log: ${logFile}`);
+    return true;
+}
+function stopDaemon() {
+    const pidFile = engine_1.engine.daemonPidFile;
+    if (!fs.existsSync(pidFile)) {
+        console.error('[WBS Daemon] Not running (no PID file)');
+        return false;
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+    if (!engine_1.engine.isProcessAlive(pid)) {
+        console.log('[WBS Daemon] Process not found, cleaning up PID file');
+        fs.unlinkSync(pidFile);
+        return true;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        fs.unlinkSync(pidFile);
+        console.log(`[WBS Daemon] Stopped (PID: ${pid})`);
+        return true;
+    }
+    catch (e) {
+        console.error(`[WBS Daemon] Failed to stop: ${e.message}`);
+        return false;
+    }
+}
+function handleDaemon(args) {
+    const sub = args[0];
+    switch (sub) {
+        case 'start':
+            startDaemon();
+            break;
+        case 'stop':
+            stopDaemon();
+            break;
+        case 'status': {
+            const pidFile = engine_1.engine.daemonPidFile;
+            if (!fs.existsSync(pidFile)) {
+                const msg = { running: false, message: 'Not running' };
+                console.log(hasJson(args) ? JSON.stringify(msg) : `[WBS Daemon] Not running`);
+            }
+            else {
+                const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+                const alive = engine_1.engine.isProcessAlive(pid);
+                const msg = alive ? { running: true, pid, message: `Running (PID: ${pid})` } : { running: false, pid, message: 'Stale PID file (process dead)' };
+                console.log(hasJson(args) ? JSON.stringify(msg, null, 2) : `[WBS Daemon] ${msg.message}`);
+            }
+            break;
+        }
+        case 'restart':
+            stopDaemon();
+            setTimeout(() => startDaemon(), 1000);
+            break;
+        case '--foreground': {
+            console.log(`[WBS Daemon] Starting in foreground mode`);
+            console.log(`[WBS Daemon] Interval: ${engine_1.DAEMON_INTERVAL_MS / 1000 / 60} minutes`);
+            console.log(`[WBS Daemon] Zombie timeout: ${engine_1.ZOMBIE_TIMEOUT_MS / 1000 / 60} minutes`);
+            console.log(`[WBS Daemon] Press Ctrl+C to stop\n`);
+            daemonTick();
+            setInterval(daemonTick, engine_1.DAEMON_INTERVAL_MS);
+            break;
+        }
+        case 'tick':
+            daemonTick();
+            break;
+        default:
+            console.log(`
+Daemon Commands - Background scheduler for WBS
+
+Usage:
+  wbs daemon start       Start daemon in background
+  wbs daemon stop        Stop running daemon
+  wbs daemon status      Check daemon status
+  wbs daemon restart     Restart daemon
+  wbs daemon tick        Manual tick (for testing)
+`);
+    }
+}
+function showDetailedUsage() {
+    const skillMd = path.join(__dirname, '..', 'SKILL.md');
+    if (fs.existsSync(skillMd)) {
+        process.stdout.write(fs.readFileSync(skillMd, 'utf-8'));
+    }
+    else {
+        showHelp();
+    }
+}
+function showHelp() {
+    console.log(`
+@crewx/wbs@${PKG_VERSION} - Work Breakdown Structure for AI agent teams
+
+Usage:
+  wbs <command> [options]
+
+Project Commands:
+  wbs create "Title" [--detail "path"]  Create a new WBS project
+  wbs list [--json]                     List all projects
+  wbs status <wbs-id> [--json]          Get project status with jobs summary
+  wbs delete <wbs-id>                   Delete a project and its jobs
+
+Job Commands:
+  wbs job list <wbs-id> [--json]        List all jobs in a project
+  wbs job add <wbs-id> [opts]           Add a job to the project
+  wbs job update <job-id> [opts]        Update a job
+  wbs job next <wbs-id>                 Run the next pending job
+  wbs job run <wbs-id>                  Run all pending jobs
+  wbs job retry <job-id>                Retry a failed/completed job
+
+Execution Commands:
+  wbs exec list <job-id>                List execution history for a job
+  wbs exec status <exec-id>             Get execution details
+  wbs exec kill <exec-id>               Kill a running execution
+  wbs exec running                      List all running executions
+
+Daemon Commands:
+  wbs daemon start                      Start background scheduler
+  wbs daemon stop                       Stop daemon
+  wbs daemon status                     Check daemon status
+
+  wbs usage                             Show detailed guide
+
+Options:
+  --json                                Output raw JSON
+  --version                             Show version
+  --help, -h                            Show this help
+
+Examples:
+  wbs create "User Authentication"
+  wbs job add wbs-1 --title "Design API" --agent "@backend" --seq 1
+  wbs status wbs-1
+  wbs job run wbs-1
+
+For detailed usage guide: wbs usage
+`);
+}
+async function main(inputArgs) {
+    const args = inputArgs ?? process.argv.slice(2);
+    const command = args[0];
+    if (command === '--version') {
+        console.log(PKG_VERSION);
+        return;
+    }
+    switch (command) {
+        case 'create': {
+            const title = args[1];
+            if (!title) {
+                console.error('Usage: wbs create "Project Title" [--detail "path"] [--source "branch"] [--target "branch"]');
+                process.exit(1);
+            }
+            const opts = parseOpts(args, 2);
+            const detailOpt = opts.detail ?? null;
+            const sourceBranchOpt = opts.source || undefined;
+            const targetBranchOpt = opts.target || undefined;
+            const id = engine_1.engine.create(title, detailOpt, sourceBranchOpt, targetBranchOpt);
+            let detailPath = detailOpt;
+            if (!detailPath) {
+                const detailsDir = path.join(process.cwd(), 'wbs-details');
+                if (!fs.existsSync(detailsDir))
+                    fs.mkdirSync(detailsDir, { recursive: true });
+                detailPath = `wbs-details/${id}-detail.md`;
+                const detailFile = path.join(process.cwd(), detailPath);
+                fs.writeFileSync(detailFile, `# ${title}\n\n## 개요\n\n(프로젝트 개요를 작성하세요)\n\n## 요구사항\n\n(요구사항을 작성하세요)\n\n## 참고 자료\n\n(참고 자료 링크나 설명을 추가하세요)\n`);
+                engine_1.engine.updateDetailPath(id, detailPath);
+            }
+            console.log(JSON.stringify({ id, title, detailPath }, null, 2));
+            break;
+        }
+        case 'list': {
+            const projects = engine_1.engine.list();
+            console.log(hasJson(args) ? JSON.stringify(projects, null, 2) : fmtProjectList(projects));
+            break;
+        }
+        case 'status': {
+            const wbsId = args[1];
+            if (!wbsId) {
+                console.error('Usage: wbs status <wbs-id> [--json]');
+                process.exit(1);
+            }
+            const result = engine_1.engine.status(wbsId);
+            if (result.project) {
+                const pending = result.jobs.filter(j => j.status === 'pending').length;
+                const running = result.jobs.filter(j => j.status === 'running').length;
+                const completed = result.jobs.filter(j => j.status === 'completed').length;
+                const failed = result.jobs.filter(j => j.status === 'failed').length;
+                result.summary = {
+                    total: result.jobs.length, pending, running, completed, failed,
+                    progress: result.jobs.length > 0 ? Math.round((completed / result.jobs.length) * 100) : 0,
+                };
+            }
+            console.log(hasJson(args) ? JSON.stringify(result, null, 2) : fmtStatus(result));
+            break;
+        }
+        case 'delete': {
+            const wbsId = args[1];
+            if (!wbsId) {
+                console.error('Usage: wbs delete <wbs-id>');
+                process.exit(1);
+            }
+            engine_1.engine.delete(wbsId);
+            console.log(`Deleted: ${wbsId}`);
+            break;
+        }
+        case 'help':
+            showHelp();
+            break;
+        case 'usage':
+            showDetailedUsage();
+            break;
+        case 'job':
+            handleJob(args.slice(1));
+            break;
+        case 'exec':
+            handleExec(args.slice(1));
+            break;
+        case 'daemon':
+            handleDaemon(args.slice(1));
+            break;
+        default: showHelp();
+    }
+}
+if (require.main === module) {
+    const _args = process.argv.slice(2);
+    const _isDaemonForeground = _args[0] === 'daemon' && _args.includes('--foreground');
+    (_isDaemonForeground ? Promise.resolve(null) : loadTracer()).then(tracer => {
+        const opts = tracer ? { skillVersion: tracer.getOwnSkillVersion(__dirname) } : {};
+        return tracer ? tracer.run('crewx/wbs', () => main(), opts) : main();
+    }).catch((e) => {
+        console.error(e.message);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=cli.js.map