@ranger-testing/ranger-cli 1.0.13 → 1.1.0

package/build/commands/feature.js

@@ -3,10 +3,11 @@ import { join } from 'path';
 import { existsSync } from 'fs';
 import { execSync } from 'child_process';
 import inquirer from 'inquirer';
-import { createFeature, listFeatures, getFeature, updateFeature, addChecklistItem, updateChecklistItem, getFeatureReport, } from './utils/featureApi.js';
-import { generateFeatureReport } from './utils/featureReportGenerator.js';
-// Active feature file path
-const ACTIVE_FEATURE_FILE = '.ranger/active-feature.txt';
+import { createFeature, listFeatures, getFeature, updateFeature, getFeatureReportMarkdown, listFeatureSessions, startSession, concludeSession, createChecklistItem, } from './utils/featureApi.js';
+import { getRangerDir } from './utils/rangerRoot.js';
+import { registerSession } from './utils/sessionCache.js';
+// Active feature file name (relative to .ranger dir)
+const ACTIVE_FEATURE_FILE = 'active-feature.txt';
 /**
  * Get the current git remote URL
  */
@@ -44,7 +45,7 @@ function getGitBranch() {
  * Get the active feature ID from the local file
  */
 export async function getActiveFeatureId() {
-    const filePath = join(process.cwd(), ACTIVE_FEATURE_FILE);
+    const filePath = join(getRangerDir(), ACTIVE_FEATURE_FILE);
     if (!existsSync(filePath)) {
         return null;
     }
@@ -60,24 +61,69 @@ export async function getActiveFeatureId() {
  * Set the active feature ID
  */
 async function setActiveFeatureId(featureId) {
-    const filePath = join(process.cwd(), ACTIVE_FEATURE_FILE);
-    const dir = join(process.cwd(), '.ranger');
+    const dir = getRangerDir();
+    const filePath = join(dir, ACTIVE_FEATURE_FILE);
     if (!existsSync(dir)) {
         await mkdir(dir, { recursive: true });
     }
     await writeFile(filePath, featureId, 'utf-8');
 }
 /**
- * Display a feature with its checklist
+ * Get Dev Status display info for a feature based on completedAt and currentSession
+ */
+function getDevStatusDisplay(feature) {
+    if (feature.completedAt) {
+        return { emoji: '\u2705', label: 'Completed' };
+    }
+    if (!feature.currentSession) {
+        return { emoji: '\u2b1c', label: 'Unknown' };
+    }
+    switch (feature.currentSession.status) {
+        case 'ready':
+            return { emoji: '\u25b6\ufe0f', label: 'Ready' }; // ▶️
+        case 'in_progress':
+            return { emoji: '\ud83d\udd04', label: 'In Progress' }; // 🔄
+        case 'completed':
+            return { emoji: '\u2705', label: 'Completed' }; // session completed
+        default:
+            return { emoji: '\u2753', label: 'Unknown' };
+    }
+}
+/**
+ * Get Review Status display info for a feature
+ */
+function getReviewStatusDisplay(feature) {
+    const { latestReview, currentSession, completedAt } = feature;
+    // Determine review status
+    if (completedAt) {
+        return { emoji: '\u2705', label: 'Approved' };
+    }
+    if (latestReview) {
+        if (!latestReview.submittedAt) {
+            return { emoji: '\ud83d\udcdd', label: 'In Review' }; // 📝
+        }
+        if (latestReview.overallVerdict === 'approved') {
+            return { emoji: '\u2705', label: 'Approved' };
+        }
+        return { emoji: '\ud83d\udd04', label: 'Changes Needed' }; // 🔄
+    }
+    if (currentSession?.status === 'completed') {
+        return { emoji: '\u23f3', label: 'Awaiting Review' }; // ⏳
+    }
+    // Not ready for review
+    return null;
+}
+/**
+ * Display a feature with its checklist (current session items only)
  */
 function displayFeature(feature, checklistItems) {
-    const statusEmoji = feature.status === 'completed'
-        ? '\u2705'
-        : feature.status === 'blocked'
-            ? '\ud83d\uded1'
-            : '\ud83d\udd04';
-    console.log(`\n${statusEmoji} ${feature.name} (${feature.id})`);
-    console.log(`   Status: ${feature.status}`);
+    const devStatus = getDevStatusDisplay(feature);
+    const reviewStatus = getReviewStatusDisplay(feature);
+    console.log(`\n${devStatus.emoji} ${feature.name} (${feature.dashboardUrl})`);
+    console.log(`   Dev Status: ${devStatus.label}`);
+    if (reviewStatus) {
+        console.log(`   Review Status: ${reviewStatus.emoji} ${reviewStatus.label}`);
+    }
     if (feature.description) {
         console.log(`   Description: ${feature.description}`);
     }
@@ -92,22 +138,30 @@ function displayFeature(feature, checklistItems) {
         console.log(`   Completed: ${new Date(feature.completedAt).toLocaleString()}`);
     }
     if (checklistItems && checklistItems.length > 0) {
-        console.log('\n   Checklist:');
-        for (let i = 0; i < checklistItems.length; i++) {
-            const item = checklistItems[i];
-            const itemEmoji = item.status === 'verified'
-                ? '\u2705'
-                : item.status === 'blocked'
-                    ? '\ud83d\uded1'
-                    : item.status === 'canceled'
-                        ? '\u26d4'
-                        : '\u2b1c'; // white square for pending
-            console.log(`   ${i + 1}. ${itemEmoji} ${item.description}`);
-            if (item.status === 'blocked' && item.blockedReason) {
-                console.log(`      Blocked: ${item.blockedReason}`);
-            }
-            if (item.status === 'canceled' && item.canceledReason) {
-                console.log(`      Canceled: ${item.canceledReason}`);
+        // Filter to only show items from the current session
+        const currentSessionItems = feature.currentSessionId
+            ? checklistItems.filter((item) => item.sessionId === feature.currentSessionId)
+            : checklistItems;
+        if (currentSessionItems.length > 0) {
+            console.log('\n   Checklist:');
+            for (let i = 0; i < currentSessionItems.length; i++) {
+                const item = currentSessionItems[i];
+                const itemEmoji = item.status === 'verified'
+                    ? '\u2705'
+                    : item.status === 'incomplete'
+                        ? '\ud83d\udfe0' // orange circle
+                        : item.status === 'blocked'
+                            ? '\ud83d\uded1'
+                            : item.status === 'canceled'
+                                ? '\u26d4'
+                                : '\u2b1c'; // white square for pending
+                console.log(`   ${i + 1}. ${itemEmoji} ${item.description}`);
+                if (item.status === 'blocked' && item.blockedReason) {
+                    console.log(`      Blocked: ${item.blockedReason}`);
+                }
+                if (item.status === 'canceled' && item.canceledReason) {
+                    console.log(`      Canceled: ${item.canceledReason}`);
+                }
             }
         }
     }
@@ -116,9 +170,9 @@ function displayFeature(feature, checklistItems) {
  * Create a new feature
  */
 export async function featureCreate(name, options) {
-    // Parse checklist from comma-separated string
+    // Get checklist items from array (each -c flag is one item)
     const checklistItems = options.checklist
-        ? options.checklist.split(',').map((s) => s.trim())
+        ? options.checklist.map((s) => s.trim())
         : [];
     // Auto-detect git context
     const gitRepoUrl = getGitRepoUrl();
@@ -133,6 +187,13 @@ export async function featureCreate(name, options) {
     });
     // Set as active feature
     await setActiveFeatureId(feature.id);
+    // Start the session immediately so it's in_progress
+    await tryStartCurrentSession(feature.id);
+    // Register Claude session if provided via env var
+    const claudeSessionId = process.env.CLAUDE_SESSION_ID;
+    if (claudeSessionId) {
+        registerSession(claudeSessionId, feature.id);
+    }
     console.log(`\n\u2705 Feature created: ${feature.id}`);
     displayFeature(feature, feature.checklistItems);
     console.log(`\n\u27a1\ufe0f  Set as active feature`);
@@ -141,10 +202,10 @@ export async function featureCreate(name, options) {
  * List features
  */
 export async function featureList(options) {
-    const filters = {};
-    if (options.status) {
-        filters.status = options.status;
-    }
+    const filters = {
+        limit: options.limit ?? 10,
+        offset: options.offset ?? 0,
+    };
     if (options.currentBranch) {
         filters.gitRepoUrl = getGitRepoUrl();
         filters.gitBranch = getGitBranch();
@@ -154,21 +215,32 @@ export async function featureList(options) {
         console.log('\nNo features found.');
         return;
     }
-    console.log(`\n${result.items.length} feature(s) found:\n`);
+    const showing = result.totalCount > result.items.length
+        ? `Showing ${result.items.length} of ${result.totalCount}`
+        : `${result.totalCount} feature(s) found`;
+    console.log(`\n${showing}:\n`);
     for (const feature of result.items) {
-        const statusEmoji = feature.status === 'completed'
-            ? '\u2705'
-            : feature.status === 'blocked'
-                ? '\ud83d\uded1'
-                : '\ud83d\udd04';
-        console.log(`${statusEmoji} ${feature.name}`);
+        const devStatus = getDevStatusDisplay(feature);
+        const reviewStatus = getReviewStatusDisplay(feature);
+        console.log(`${devStatus.emoji} ${feature.name}`);
         console.log(`   ID: ${feature.id}`);
-        console.log(`   Status: ${feature.status}`);
+        console.log(`   Dev Status: ${devStatus.label}`);
+        if (reviewStatus) {
+            console.log(`   Review Status: ${reviewStatus.emoji} ${reviewStatus.label}`);
+        }
         if (feature.gitBranch) {
             console.log(`   Branch: ${feature.gitBranch}`);
         }
         console.log('');
     }
+    // Show next page command if there are more items
+    const currentLimit = filters.limit ?? 10;
+    const nextOffset = (filters.offset ?? 0) + result.items.length;
+    if (nextOffset < result.totalCount) {
+        const limitFlag = currentLimit !== 10 ? ` --limit ${currentLimit}` : '';
+        const branchFlag = options.currentBranch ? ' --current-branch' : '';
+        console.log(`Next page: ranger feature list --offset ${nextOffset}${limitFlag}${branchFlag}`);
+    }
 }
 /**
  * Show feature details
@@ -177,25 +249,38 @@ export async function featureShow(id) {
     const featureId = id || (await getActiveFeatureId());
     if (!featureId) {
         console.error('\n\u274c No feature ID provided and no active feature set.');
-        console.error('Run: ranger feature use <id> to set an active feature');
+        console.error('Run: ranger feature resume <id> to set an active feature');
         process.exit(1);
     }
     const feature = await getFeature(featureId);
     displayFeature(feature, feature.checklistItems);
 }
-/**
- * Set active feature
- */
-export async function featureUse(id) {
-    // Verify the feature exists
-    const feature = await getFeature(id);
-    await setActiveFeatureId(feature.id);
-    console.log(`\n\u2705 Active feature set to: ${feature.name} (${feature.id})`);
-}
 /**
  * Resume feature matching current git context
+ * @param id Optional feature ID to resume directly (bypasses search/prompt)
  */
-export async function featureResume() {
+export async function featureResume(id) {
+    // If ID provided, set it as the active feature directly
+    if (id) {
+        const feature = await getFeature(id);
+        await setActiveFeatureId(feature.id);
+        // Update the feature's gitBranch to the current branch
+        const currentBranch = getGitBranch();
+        if (currentBranch && currentBranch !== feature.gitBranch) {
+            await updateFeature(feature.id, { gitBranch: currentBranch });
+            console.log(`   Updated branch to: ${currentBranch}`);
+        }
+        console.log(`\n\u2705 Resumed feature: ${feature.name} (${feature.id})`);
+        // Start the current session if it's ready
+        await tryStartCurrentSession(feature.id);
+        // Register Claude session if provided via env var
+        const claudeSessionId = process.env.CLAUDE_SESSION_ID;
+        if (claudeSessionId) {
+            registerSession(claudeSessionId, feature.id);
+        }
+        displayFeature(feature, feature.checklistItems);
+        return;
+    }
     const gitRepoUrl = getGitRepoUrl();
     const gitBranch = getGitBranch();
     if (!gitRepoUrl && !gitBranch) {
@@ -204,291 +289,198 @@ export async function featureResume() {
     }
     console.log(`\nSearching for features matching: ${gitRepoUrl || 'any'} / ${gitBranch || 'any'}...`);
     const result = await listFeatures({
-        status: 'in_progress',
         gitRepoUrl,
         gitBranch,
     });
-    if (result.items.length === 0) {
-        console.log('\nNo matching in-progress features found.');
+    // Filter to non-completed features
+    const activeFeatures = result.items.filter((f) => !f.completedAt);
+    if (activeFeatures.length === 0) {
+        console.log('\nNo matching active features found.');
         console.log('Run: ranger feature create "<name>" to create a new feature');
         return;
     }
     let selectedFeature;
-    if (result.items.length === 1) {
-        selectedFeature = result.items[0];
+    if (activeFeatures.length === 1) {
+        selectedFeature = activeFeatures[0];
     }
     else {
-        // Multiple matches - prompt user to select
+        // Multiple matches - check if we're in interactive mode
+        const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+        if (!isInteractive) {
+            // Non-interactive mode: list features and require explicit ID
+            console.log('\nNon-interactive mode detected. Multiple features found:');
+            for (const f of activeFeatures) {
+                const devStatus = getDevStatusDisplay(f);
+                console.log(`  ${devStatus.emoji} ${f.name}`);
+                console.log(`     ID: ${f.id}`);
+                if (f.gitBranch) {
+                    console.log(`     Branch: ${f.gitBranch}`);
+                }
+            }
+            console.error('\nPlease specify the feature ID: ranger feature resume <id>');
+            process.exit(1);
+        }
+        // Interactive mode: prompt user to select
         const { selected } = await inquirer.prompt([
             {
                 type: 'list',
                 name: 'selected',
                 message: 'Multiple features found. Select one:',
-                choices: result.items.map((f) => ({
+                choices: activeFeatures.map((f) => ({
                     name: `${f.name} (${f.id})`,
                     value: f.id,
                 })),
             },
         ]);
-        selectedFeature = result.items.find((f) => f.id === selected);
+        selectedFeature = activeFeatures.find((f) => f.id === selected);
     }
     await setActiveFeatureId(selectedFeature.id);
+    // Update the feature's gitBranch to the current branch
+    if (gitBranch && gitBranch !== selectedFeature.gitBranch) {
+        await updateFeature(selectedFeature.id, { gitBranch });
+        console.log(`   Updated branch to: ${gitBranch}`);
+    }
     console.log(`\n\u2705 Resumed feature: ${selectedFeature.name} (${selectedFeature.id})`);
-    // Show current status
+    // Start the current session if it's ready
+    await tryStartCurrentSession(selectedFeature.id);
+    // Register Claude session if provided via env var
     const fullFeature = await getFeature(selectedFeature.id);
+    const claudeSessionId = process.env.CLAUDE_SESSION_ID;
+    if (claudeSessionId) {
+        registerSession(claudeSessionId, fullFeature.id);
+    }
+    // Show current status
     displayFeature(fullFeature, fullFeature.checklistItems);
 }
 /**
- * Block a feature
+ * Try to start the current session if it's in ready status
+ */
+async function tryStartCurrentSession(featureId) {
+    try {
+        const { sessions } = await listFeatureSessions(featureId);
+        // Find the current session (most recent ready one)
+        const readySession = sessions.find((s) => s.status === 'ready');
+        if (readySession) {
+            await startSession(featureId, readySession.id);
+            console.log(`   \u25b6\ufe0f Started session ${readySession.iteration}`);
+        }
+    }
+    catch {
+        // Silently ignore - session may already be started or in another state
+    }
+}
+/**
+ * Generate feature report
  */
-export async function featureBlock(id, options) {
+export async function featureReport(id, options) {
     const featureId = id || (await getActiveFeatureId());
     if (!featureId) {
         console.error('\n\u274c No feature ID provided and no active feature set.');
         process.exit(1);
     }
-    const feature = await updateFeature(featureId, { status: 'blocked' });
-    console.log(`\n\ud83d\uded1 Feature blocked: ${feature.name} (${feature.id})`);
-    console.log(`   Reason: ${options.reason}`);
-}
-/**
- * Helper to get item by index (1-based)
- */
-function getItemByIndex(items, index) {
-    const itemIndex = index - 1; // Convert to 0-based
-    if (itemIndex < 0 || itemIndex >= items.length) {
-        throw new Error(`Invalid item index: ${index}. Feature has ${items.length} items.`);
+    console.log('\nGenerating report...');
+    // Fetch markdown report from API (includes embedded screenshots)
+    const markdown = await getFeatureReportMarkdown(featureId, {
+        style: options.style,
+    });
+    // Determine output path
+    const outputPath = options.output || join(getRangerDir(), 'reports', `${featureId}.md`);
+    // Ensure directory exists
+    const outputDir = join(outputPath, '..');
+    if (!existsSync(outputDir)) {
+        await mkdir(outputDir, { recursive: true });
     }
-    return items[itemIndex];
+    await writeFile(outputPath, markdown, 'utf-8');
+    console.log(`\n\u2705 Report generated: ${outputPath}`);
 }
 /**
- * Manage checklist items (interactive or with flags)
+ * Conclude the current session (even with incomplete items)
  */
-export async function featureManage(options = {}) {
-    const featureId = await getActiveFeatureId();
+export async function featureConcludeSession(id) {
+    const featureId = id || (await getActiveFeatureId());
     if (!featureId) {
-        console.error('\n\u274c No active feature set.');
-        console.error('Run: ranger feature use <id> to set an active feature');
+        console.error('\n\u274c No feature ID provided and no active feature set.');
+        console.error('Run: ranger feature resume <id> to set an active feature');
         process.exit(1);
     }
     const feature = await getFeature(featureId);
-    // Check if any non-interactive flag is provided
-    const hasNonInteractiveFlag = options.add !== undefined ||
-        options.edit !== undefined ||
-        options.block !== undefined ||
-        options.cancel !== undefined ||
-        options.reset !== undefined;
-    // Non-interactive mode: handle flags directly
-    if (hasNonInteractiveFlag) {
-        // --add: Add a new item
-        if (options.add) {
-            const item = await addChecklistItem(featureId, {
-                description: options.add.trim(),
-            });
-            console.log(`\u2705 Added: ${item.description}`);
-            return;
-        }
-        // --edit: Edit item description
-        if (options.edit !== undefined) {
-            if (!options.description) {
-                console.error('\u274c --description is required when using --edit');
-                process.exit(1);
-            }
-            const item = getItemByIndex(feature.checklistItems, options.edit);
-            await updateChecklistItem(featureId, item.id, {
-                description: options.description.trim(),
-            });
-            console.log(`\u270f\ufe0f Item ${options.edit} updated: ${options.description.trim()}`);
-            return;
-        }
-        // --block: Block an item
-        if (options.block !== undefined) {
-            const item = getItemByIndex(feature.checklistItems, options.block);
-            await updateChecklistItem(featureId, item.id, {
-                status: 'blocked',
-                blockedReason: options.reason || undefined,
-            });
-            console.log(`\ud83d\uded1 Item ${options.block} blocked: ${item.description}`);
-            return;
-        }
-        // --cancel: Cancel an item
-        if (options.cancel !== undefined) {
-            const item = getItemByIndex(feature.checklistItems, options.cancel);
-            await updateChecklistItem(featureId, item.id, {
-                status: 'canceled',
-                canceledReason: options.reason || undefined,
-            });
-            console.log(`\u26d4 Item ${options.cancel} canceled: ${item.description}`);
-            return;
-        }
-        // --reset: Reset item to pending
-        if (options.reset !== undefined) {
-            const item = getItemByIndex(feature.checklistItems, options.reset);
-            await updateChecklistItem(featureId, item.id, {
-                status: 'pending',
-            });
-            console.log(`\u2b1c Item ${options.reset} reset to pending: ${item.description}`);
-            return;
-        }
+    if (!feature.currentSessionId) {
+        console.error('\n\u274c No active session for this feature.');
+        process.exit(1);
     }
-    // Interactive mode: show prompts
-    console.log(`\nManaging: ${feature.name} (${feature.id})\n`);
-    // Show current checklist
-    if (feature.checklistItems.length > 0) {
-        console.log('Current checklist:');
-        for (let i = 0; i < feature.checklistItems.length; i++) {
-            const item = feature.checklistItems[i];
-            const itemEmoji = item.status === 'verified'
-                ? '\u2705'
-                : item.status === 'blocked'
-                    ? '\ud83d\uded1'
-                    : item.status === 'canceled'
-                        ? '\u26d4'
-                        : '\u2b1c';
-            console.log(`${i + 1}. ${itemEmoji} ${item.description}`);
-        }
-        console.log('');
+    const { sessions } = await listFeatureSessions(featureId);
+    const currentSession = sessions.find((s) => s.id === feature.currentSessionId);
+    if (!currentSession) {
+        console.error('\n\u274c Current session not found.');
+        process.exit(1);
     }
-    else {
-        console.log('No checklist items yet.\n');
-    }
-    // Prompt for action
-    const { action } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'action',
-            message: 'What would you like to do?',
-            choices: [
-                { name: 'Add new item', value: 'add' },
-                { name: 'Update existing item', value: 'update' },
-                { name: 'Cancel', value: 'cancel' },
-            ],
-        },
-    ]);
-    if (action === 'cancel') {
+    if (currentSession.status === 'completed') {
+        console.log('\n\u2705 Session is already completed.');
         return;
     }
-    if (action === 'add') {
-        const { description } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'description',
-                message: 'Enter item description:',
-                validate: (input) => input.trim() ? true : 'Description is required',
-            },
-        ]);
-        const item = await addChecklistItem(featureId, {
-            description: description.trim(),
-        });
-        console.log(`\n\u2705 Added: ${item.description}`);
+    if (currentSession.status !== 'in_progress') {
+        console.error(`\n\u274c Cannot conclude session with status: ${currentSession.status}`);
+        process.exit(1);
+    }
+    console.log('\nConcluding session...');
+    await concludeSession(featureId, feature.currentSessionId);
+    console.log(`\n\u2705 Session ${currentSession.iteration} concluded.`);
+    console.log(`   The feature is now ready for human review on the Ranger dashboard.`);
+}
+/**
+ * List sessions for a feature
+ */
+export async function featureSessions(id) {
+    const featureId = id || (await getActiveFeatureId());
+    if (!featureId) {
+        console.error('\n\u274c No feature ID provided and no active feature set.');
+        process.exit(1);
+    }
+    const feature = await getFeature(featureId);
+    console.log(`\n\ud83d\udcc1 Sessions for: ${feature.name}\n`);
+    const { sessions } = await listFeatureSessions(featureId);
+    if (sessions.length === 0) {
+        console.log('No sessions found.');
         return;
     }
-    if (action === 'update') {
-        if (feature.checklistItems.length === 0) {
-            console.log('\nNo items to update.');
-            return;
-        }
-        const { itemIndex } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'itemIndex',
-                message: 'Select item to update:',
-                choices: feature.checklistItems.map((item, i) => ({
-                    name: `${i + 1}. ${item.description}`,
-                    value: i,
-                })),
-            },
-        ]);
-        const selectedItem = feature.checklistItems[itemIndex];
-        const { updateAction } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'updateAction',
-                message: 'What would you like to do with this item?',
-                choices: [
-                    { name: 'Edit description', value: 'edit' },
-                    { name: 'Mark as blocked', value: 'block' },
-                    { name: 'Cancel item', value: 'cancel' },
-                    { name: 'Reset to pending', value: 'pending' },
-                    { name: 'Go back', value: 'back' },
-                ],
-            },
-        ]);
-        if (updateAction === 'back') {
-            return;
-        }
-        if (updateAction === 'edit') {
-            const { newDescription } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'newDescription',
-                    message: 'Enter new description:',
-                    default: selectedItem.description,
-                    validate: (input) => input.trim() ? true : 'Description is required',
-                },
-            ]);
-            await updateChecklistItem(featureId, selectedItem.id, {
-                description: newDescription.trim(),
-            });
-            console.log(`\n\u270f\ufe0f Item updated: ${newDescription.trim()}`);
-        }
-        else if (updateAction === 'block') {
-            const { reason } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'reason',
-                    message: 'Enter blocking reason:',
-                },
-            ]);
-            await updateChecklistItem(featureId, selectedItem.id, {
-                status: 'blocked',
-                blockedReason: reason || undefined,
-            });
-            console.log(`\n\ud83d\uded1 Item blocked: ${selectedItem.description}`);
-        }
-        else if (updateAction === 'cancel') {
-            const { reason } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'reason',
-                    message: 'Enter cancellation reason:',
-                },
-            ]);
-            await updateChecklistItem(featureId, selectedItem.id, {
-                status: 'canceled',
-                canceledReason: reason || undefined,
-            });
-            console.log(`\n\u26d4 Item canceled: ${selectedItem.description}`);
-        }
-        else if (updateAction === 'pending') {
-            await updateChecklistItem(featureId, selectedItem.id, {
-                status: 'pending',
-            });
-            console.log(`\n\u2b1c Item reset to pending: ${selectedItem.description}`);
+    for (const session of sessions) {
+        const statusEmoji = session.status === 'completed'
+            ? '\u2705'
+            : session.status === 'in_progress'
+                ? '\ud83d\udd04'
+                : '\u25b6\ufe0f'; // ready
+        console.log(`${statusEmoji} Session ${session.iteration} (${session.id})`);
+        console.log(`   Status: ${session.status}`);
+        console.log(`   Created: ${new Date(session.createdAt).toLocaleString()}`);
+        if (session.completedAt) {
+            console.log(`   Completed: ${new Date(session.completedAt).toLocaleString()}`);
         }
+        console.log('');
     }
 }
 /**
- * Generate feature report
+ * Add a checklist item to the active feature
  */
-export async function featureReport(id, options) {
+export async function featureAddChecklistItem(description, id) {
     const featureId = id || (await getActiveFeatureId());
     if (!featureId) {
         console.error('\n\u274c No feature ID provided and no active feature set.');
+        console.error('Run: ranger feature resume <id> to set an active feature');
         process.exit(1);
     }
-    console.log('\nGenerating report...');
-    const reportData = await getFeatureReport(featureId);
-    const markdown = generateFeatureReport(reportData);
-    // Determine output path
-    const outputPath = options.output ||
-        join(process.cwd(), '.ranger', 'reports', `${featureId}.md`);
-    // Ensure directory exists
-    const outputDir = join(outputPath, '..');
-    if (!existsSync(outputDir)) {
-        await mkdir(outputDir, { recursive: true });
+    const feature = await getFeature(featureId);
+    // Check if there's an active (non-submitted) review
+    if (feature.latestReview && !feature.latestReview.submittedAt) {
+        console.error('\n\u274c Cannot add checklist item: feature has an active review.');
+        console.error('Please finish your review first:');
+        console.error(`  ${feature.dashboardUrl}`);
+        process.exit(1);
     }
-    await writeFile(outputPath, markdown, 'utf-8');
-    console.log(`\n\u2705 Report generated: ${outputPath}`);
+    // Create the checklist item
+    await createChecklistItem(featureId, description);
+    // Refetch and display the updated feature
+    const updatedFeature = await getFeature(featureId);
+    console.log(`\n\u2705 Checklist item added`);
+    displayFeature(updatedFeature, updatedFeature.checklistItems);
 }
 //# sourceMappingURL=feature.js.map