@relipa/ai-flow-kit 0.0.5-beta.1 → 0.0.6-beta.0

package/scripts/task.js

@@ -0,0 +1,384 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { confirm } = require('@inquirer/prompts');
+
+const PROJECT_DIR   = process.cwd();
+const AIFLOW_DIR    = path.join(PROJECT_DIR, '.aiflow');
+const CONTEXT_DIR   = path.join(AIFLOW_DIR, 'context');
+const CURRENT_FILE  = path.join(CONTEXT_DIR, 'current.json');
+const TASKS_DIR     = path.join(AIFLOW_DIR, 'tasks');
+
+// ──────────────────────────────────────────────────────────────
+// Entry point
+// ──────────────────────────────────────────────────────────────
+
+module.exports = async function task(action, options = {}) {
+    try {
+        if (action === 'list')                return await listTasks();
+        if (action === 'status')              return await showStatus();
+        if (action === 'pause')               return await pauseTask(options.note);
+        if (action === 'switch' && options.taskId) return await switchTask(options.taskId);
+        if (action === 'resume' && options.taskId) return await resumeTask(options.taskId);
+        if (action === 'reset'  && options.taskId) return await resetTask(options.taskId);
+        if (action === 'remove' && options.taskId) return await removeTask(options.taskId);
+
+        console.log(chalk.yellow('Usage:'));
+        console.log(chalk.gray('  aiflow task status              — show active task and pending list'));
+        console.log(chalk.gray('  aiflow task list                — list all saved tasks'));
+        console.log(chalk.gray('  aiflow task pause               — pause current task'));
+        console.log(chalk.gray('  aiflow task pause --note "..."  — pause with a note'));
+        console.log(chalk.gray('  aiflow task switch <ticket-id>  — pause current + switch to another task'));
+        console.log(chalk.gray('  aiflow task resume <ticket-id>  — resume a paused task'));
+        console.log(chalk.gray('  aiflow task reset  <ticket-id>  — reset task to Gate 1 (keeps context)'));
+        console.log(chalk.gray('  aiflow task remove <ticket-id>  — permanently delete all task data'));
+    } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+    }
+};
+
+// ──────────────────────────────────────────────────────────────
+// Commands
+// ──────────────────────────────────────────────────────────────
+
+async function showStatus() {
+    const tasks = await loadAllTaskStates();
+    const active  = tasks.filter(t => t.status === 'active');
+    const pending = tasks.filter(t => t.status === 'pending');
+
+    console.log(chalk.cyan('\nTask Status\n'));
+
+    if (active.length === 0) {
+        console.log(chalk.gray('  No active task. Run `aiflow use <ticket>` to start one.'));
+    } else {
+        const t = active[0];
+        console.log(`  ${chalk.green('● Active')}  ${chalk.white(t.taskId)}  ${chalk.gray('Gate ' + t.currentGate)}  ${chalk.gray(t.title.substring(0, 55))}`);
+    }
+
+    if (pending.length > 0) {
+        console.log(chalk.yellow(`\n  Pending (${pending.length}):`));
+        for (const t of pending) {
+            const paused = t.pausedAt ? chalk.gray(` paused ${formatRelative(t.pausedAt)}`) : '';
+            const note   = t.notes    ? chalk.gray(` — ${t.notes.substring(0, 40)}`) : '';
+            console.log(`  ${chalk.gray('○ Pending')} ${chalk.white(t.taskId.padEnd(14))} Gate ${t.currentGate}  ${chalk.gray(t.title.substring(0, 40))}${paused}${note}`);
+        }
+        console.log(chalk.gray('\n  Resume with: aiflow task resume <ticket-id>'));
+    }
+    console.log();
+}
+
+async function listTasks() {
+    const tasks = await loadAllTaskStates();
+    if (tasks.length === 0) {
+        console.log(chalk.gray('No saved tasks.'));
+        return;
+    }
+    console.log(chalk.cyan('\nAll Tasks:\n'));
+    for (const t of tasks) {
+        const icon  = t.status === 'active' ? chalk.green('●') : chalk.gray('○');
+        const label = t.status === 'active' ? chalk.green('active ') : chalk.yellow('pending');
+        console.log(`  ${icon} ${label}  ${chalk.white(t.taskId.padEnd(16))} Gate ${t.currentGate}  ${chalk.gray(t.title.substring(0, 50))}`);
+    }
+    console.log();
+}
+
+async function pauseTask(note = '') {
+    if (!(await fs.pathExists(CURRENT_FILE))) {
+        console.log(chalk.yellow('No active task to pause.'));
+        return;
+    }
+
+    const ctx = await fs.readJson(CURRENT_FILE).catch(() => null);
+    if (!ctx || !ctx.taskId) {
+        console.log(chalk.yellow('Current context has no taskId — cannot pause.'));
+        return;
+    }
+
+    const taskId  = ctx.taskId;
+    const taskDir = path.join(TASKS_DIR, taskId);
+    await fs.ensureDir(taskDir);
+
+    // Save context snapshot
+    await fs.writeJson(path.join(taskDir, 'context.json'), ctx, { spaces: 2 });
+
+    // Detect gate from plan/ artifacts
+    const currentGate = await detectCurrentGate(taskId);
+
+    // Write / update task-state.json
+    const statePath = path.join(taskDir, 'task-state.json');
+    const existing  = (await fs.pathExists(statePath)) ? await fs.readJson(statePath).catch(() => ({})) : {};
+    const now = new Date().toISOString();
+
+    const taskState = {
+        ...existing,
+        taskId,
+        title:       ctx.title || '',
+        status:      'pending',
+        createdAt:   existing.createdAt || now,
+        updatedAt:   now,
+        pausedAt:    now,
+        currentGate,
+        gateApprovals: existing.gateApprovals || {},
+        notes:       note || existing.notes || '',
+    };
+    await fs.writeJson(statePath, taskState, { spaces: 2 });
+
+    // Remove current.json so no task is active
+    await fs.remove(CURRENT_FILE);
+
+    console.log(chalk.green(`✓ Task ${taskId} paused at Gate ${currentGate}.`));
+    if (note) console.log(chalk.gray(`  Note: ${note}`));
+    console.log(chalk.gray(`  Resume later: aiflow task resume ${taskId}`));
+}
+
+async function switchTask(targetId) {
+    // Pause current task if one is active
+    if (await fs.pathExists(CURRENT_FILE)) {
+        const ctx = await fs.readJson(CURRENT_FILE).catch(() => null);
+        if (ctx && ctx.taskId && ctx.taskId !== targetId) {
+            console.log(chalk.gray(`  Pausing current task: ${ctx.taskId}`));
+            await pauseTask();
+        }
+    }
+
+    // Load target task if it exists
+    const statePath = path.join(TASKS_DIR, targetId, 'task-state.json');
+    if (await fs.pathExists(statePath)) {
+        await resumeTask(targetId);
+    } else {
+        console.log(chalk.yellow(`Task ${targetId} not found in saved tasks.`));
+        console.log(chalk.gray(`  Run 'aiflow use ${targetId}' to load it from your ticket system.`));
+    }
+}
+
+async function resumeTask(taskId) {
+    const taskDir   = path.join(TASKS_DIR, taskId);
+    const statePath = path.join(taskDir, 'task-state.json');
+    const ctxPath   = path.join(taskDir, 'context.json');
+
+    if (!(await fs.pathExists(statePath))) {
+        console.log(chalk.red(`Task not found: ${taskId}`));
+        console.log(chalk.gray('  Run `aiflow task list` to see available tasks.'));
+        return;
+    }
+
+    const taskState = await fs.readJson(statePath);
+    const ctx       = await fs.readJson(ctxPath).catch(() => null);
+
+    if (!ctx) {
+        console.log(chalk.red(`Context snapshot missing for task: ${taskId}`));
+        console.log(chalk.gray(`  Try loading it fresh: aiflow use ${taskId}`));
+        return;
+    }
+
+    // Restore context as current
+    await fs.ensureDir(CONTEXT_DIR);
+    await fs.writeJson(CURRENT_FILE, ctx, { spaces: 2 });
+
+    // Mark as active
+    const now = new Date().toISOString();
+    taskState.status    = 'active';
+    taskState.pausedAt  = null;
+    taskState.updatedAt = now;
+    await fs.writeJson(statePath, taskState, { spaces: 2 });
+
+    console.log(chalk.green(`✓ Resumed task: ${taskId}`));
+    console.log(`  ${chalk.white('Gate:')}   ${taskState.currentGate} (${gateLabel(taskState.currentGate)})`);
+    console.log(`  ${chalk.white('Title:')}  ${ctx.title.substring(0, 70)}`);
+    if (taskState.notes) console.log(`  ${chalk.white('Note:')}   ${taskState.notes}`);
+    console.log(chalk.gray('\n  Open Claude to resume: claude'));
+}
+
+async function resetTask(taskId) {
+    const taskDir   = path.join(TASKS_DIR, taskId);
+    const statePath = path.join(taskDir, 'task-state.json');
+
+    if (!(await fs.pathExists(statePath))) {
+        console.log(chalk.red(`Task not found: ${taskId}`));
+        console.log(chalk.gray('  Run `aiflow task list` to see available tasks.'));
+        return;
+    }
+
+    const taskState = await fs.readJson(statePath);
+    const planDir   = path.join(PROJECT_DIR, 'plan', taskId);
+    const planFiles = [];
+    if (await fs.pathExists(planDir)) {
+        const entries = await fs.readdir(planDir);
+        for (const f of entries) planFiles.push(path.join('plan', taskId, f));
+    }
+
+    // Show what will happen
+    console.log(chalk.cyan(`\nReset task: ${taskId}\n`));
+    console.log(chalk.white('  The following will be reset:'));
+    console.log(chalk.gray(`  • .aiflow/tasks/${taskId}/task-state.json`));
+    console.log(chalk.gray(`    Gate: ${taskState.currentGate} → 1  |  Approvals cleared  |  Status: active`));
+
+    const deletePlan = planFiles.length > 0 && await confirm({
+        message: `Also delete ${planFiles.length} plan file(s) in plan/${taskId}/?`,
+        default: false,
+    });
+
+    if (deletePlan) {
+        console.log(chalk.gray('\n  Plan files to delete:'));
+        for (const f of planFiles) console.log(chalk.gray(`  • ${f}`));
+    }
+
+    console.log();
+    const ok = await confirm({ message: 'Proceed with reset?', default: false });
+    if (!ok) { console.log(chalk.gray('Cancelled.')); return; }
+
+    // Reset task-state.json to Gate 1
+    const now = new Date().toISOString();
+    await fs.writeJson(statePath, {
+        ...taskState,
+        status:        'active',
+        currentGate:   1,
+        gateApprovals: {},
+        pausedAt:      null,
+        updatedAt:     now,
+        notes:         '',
+    }, { spaces: 2 });
+
+    // Restore as current context
+    const ctxPath = path.join(taskDir, 'context.json');
+    if (await fs.pathExists(ctxPath)) {
+        await fs.ensureDir(CONTEXT_DIR);
+        await fs.copy(ctxPath, CURRENT_FILE, { overwrite: true });
+    }
+
+    if (deletePlan) await fs.remove(planDir);
+
+    console.log(chalk.green(`✓ Task ${taskId} reset to Gate 1.`));
+    if (deletePlan) console.log(chalk.gray(`  Deleted plan/${taskId}/`));
+    console.log(chalk.gray('  Open Claude to start Gate 1: claude'));
+}
+
+async function removeTask(taskId) {
+    const taskDir   = path.join(TASKS_DIR, taskId);
+    const statePath = path.join(taskDir, 'task-state.json');
+
+    if (!(await fs.pathExists(statePath))) {
+        console.log(chalk.red(`Task not found: ${taskId}`));
+        console.log(chalk.gray('  Run `aiflow task list` to see available tasks.'));
+        return;
+    }
+
+    const isActive  = await fs.pathExists(CURRENT_FILE) &&
+        ((await fs.readJson(CURRENT_FILE).catch(() => ({}))).taskId === taskId);
+    const planDir   = path.join(PROJECT_DIR, 'plan', taskId);
+    const hasPlan   = await fs.pathExists(planDir);
+    const planFiles = hasPlan ? await fs.readdir(planDir) : [];
+
+    // Show what will be deleted
+    console.log(chalk.cyan(`\nRemove task: ${taskId}\n`));
+    console.log(chalk.white('  The following will be permanently deleted:'));
+    console.log(chalk.gray(`  • .aiflow/tasks/${taskId}/  (context snapshot + gate state)`));
+    if (isActive) console.log(chalk.gray(`  • .aiflow/context/current.json  (this is the active task)`));
+    if (hasPlan) {
+        console.log(chalk.gray(`  • plan/${taskId}/  (${planFiles.length} file(s)):`));
+        for (const f of planFiles) console.log(chalk.gray(`      - plan/${taskId}/${f}`));
+    }
+
+    console.log();
+    const ok = await confirm({
+        message: chalk.red('This cannot be undone. Proceed?'),
+        default: false,
+    });
+    if (!ok) { console.log(chalk.gray('Cancelled.')); return; }
+
+    await fs.remove(taskDir);
+    if (isActive) await fs.remove(CURRENT_FILE);
+    if (hasPlan)  await fs.remove(planDir);
+
+    console.log(chalk.green(`✓ Task ${taskId} removed.`));
+}
+
+// ──────────────────────────────────────────────────────────────
+// Internal helpers
+// ──────────────────────────────────────────────────────────────
+
+async function loadAllTaskStates() {
+    if (!(await fs.pathExists(TASKS_DIR))) return [];
+    const entries = await fs.readdir(TASKS_DIR, { withFileTypes: true });
+    const states  = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const statePath = path.join(TASKS_DIR, entry.name, 'task-state.json');
+        if (await fs.pathExists(statePath)) {
+            const s = await fs.readJson(statePath).catch(() => null);
+            if (s) states.push(s);
+        }
+    }
+    return states.sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+}
+
+async function detectCurrentGate(taskId) {
+    const planDir = path.join(PROJECT_DIR, 'plan', taskId);
+    if (!(await fs.pathExists(planDir))) return 1;
+    if (await fs.pathExists(path.join(planDir, 'summary.md')))     return 5;
+    if (await fs.pathExists(path.join(planDir, 'plan.md')))        return 3;
+    if (await fs.pathExists(path.join(planDir, 'requirement.md'))) return 2;
+    return 1;
+}
+
+function gateLabel(n) {
+    const labels = {
+        1: 'AI Analyze Requirement',
+        2: 'Implementation Plan',
+        3: 'Code Generation',
+        4: 'AI Self-Review',
+        5: 'Peer Review & PR',
+    };
+    return labels[n] || `Gate ${n}`;
+}
+
+function formatRelative(isoStr) {
+    const ms   = Date.now() - new Date(isoStr).getTime();
+    const mins = Math.floor(ms / 60000);
+    if (mins < 60)  return `${mins}m ago`;
+    const hrs = Math.floor(mins / 60);
+    if (hrs  < 24)  return `${hrs}h ago`;
+    return `${Math.floor(hrs / 24)}d ago`;
+}
+
+// ──────────────────────────────────────────────────────────────
+// Export helper used by session-start hook and use.js
+// ──────────────────────────────────────────────────────────────
+
+module.exports.getActiveTaskState = async function getActiveTaskState() {
+    if (!(await fs.pathExists(CURRENT_FILE))) return null;
+    const ctx = await fs.readJson(CURRENT_FILE).catch(() => null);
+    if (!ctx || !ctx.taskId) return null;
+    const statePath = path.join(TASKS_DIR, ctx.taskId, 'task-state.json');
+    return (await fs.pathExists(statePath)) ? fs.readJson(statePath).catch(() => null) : null;
+};
+
+module.exports.createOrActivateTaskState = async function createOrActivateTaskState(ctx) {
+    const taskId  = ctx.taskId;
+    if (!taskId) return;
+    const taskDir   = path.join(TASKS_DIR, taskId);
+    const statePath = path.join(taskDir, 'task-state.json');
+    await fs.ensureDir(taskDir);
+
+    // Save context snapshot
+    await fs.writeJson(path.join(taskDir, 'context.json'), ctx, { spaces: 2 });
+
+    // Detect current gate
+    const currentGate = await detectCurrentGate(taskId);
+
+    const existing  = (await fs.pathExists(statePath)) ? await fs.readJson(statePath).catch(() => ({})) : {};
+    const now = new Date().toISOString();
+    const taskState = {
+        ...existing,
+        taskId,
+        title:         ctx.title || '',
+        status:        'active',
+        createdAt:     existing.createdAt || now,
+        updatedAt:     now,
+        pausedAt:      null,
+        currentGate:   existing.currentGate || currentGate,
+        gateApprovals: existing.gateApprovals || {},
+        notes:         existing.notes || '',
+    };
+    await fs.writeJson(statePath, taskState, { spaces: 2 });
+};