icoa-cli 2.7.2 → 2.9.0

package/dist/commands/exam.js

@@ -62,10 +62,20 @@ function printQuestionProgress(current, total, answered) {
     console.log();
     console.log(`  ${bar}  ${chalk.white.bold(`${current}`)}${chalk.gray(`/${total}`)}  ${chalk.gray(`(${answered} answered)`)}  ${chalk.gray(`${pct}%`)}`);
 }
+function getHelpState(state) {
+    return {
+        used: state._helpUsed || 0,
+        max: state._helpMax || 5,
+        perQ: state._helpPerQ || {},
+        eliminated: state._eliminated || {},
+    };
+}
 function printQuestion(q, answer) {
     const state = getExamState();
     const total = Number(state?.session.questionCount || 30);
     const answered = Object.keys(state?.answers || {}).length;
+    const help = getHelpState(state);
+    const eliminated = help.eliminated[q.number] || [];
     // Progress bar
     printQuestionProgress(q.number, total, answered);
     // Easter egg
@@ -78,20 +88,27 @@ function printQuestion(q, answer) {
     console.log(`  ${q.text}`);
     console.log();
     for (const key of ['A', 'B', 'C', 'D']) {
+        const isEliminated = eliminated.includes(key);
         const selected = answer === key;
-        const prefix = selected ? chalk.green.bold(`  ▸ ${key}.`) : chalk.gray(`    ${key}.`);
-        const text = selected ? chalk.green.bold(q.options[key]) : chalk.white(q.options[key]);
-        console.log(`${prefix} ${text}`);
+        if (isEliminated) {
+            console.log(chalk.gray.strikethrough(`    ${key}. ${q.options[key]}`));
+        }
+        else if (selected) {
+            console.log(chalk.green.bold(`  ▸ ${key}. ${q.options[key]}`));
+        }
+        else {
+            console.log(chalk.gray(`    ${key}.`) + ' ' + chalk.white(q.options[key]));
+        }
     }
     console.log();
-    // Navigation hint
-    const nav = [];
-    if (q.number > 1)
-        nav.push('exam prev');
-    if (q.number < total)
-        nav.push('exam next');
-    nav.push(`exam answer ${q.number} <A-D>`);
-    console.log(chalk.gray(`  ${nav.join(' · ')}`));
+    // Navigation + help hint
+    const remaining = help.max - help.used;
+    const helpHint = remaining > 0
+        ? chalk.yellow('help') + chalk.gray(` (${remaining}/${help.max})`)
+        : (help.max < 8 ? chalk.gray('help 0/5 — type ') + chalk.yellow('more help') : chalk.gray('help 0/8'));
+    console.log(chalk.gray('  Type ') + chalk.white('A') + chalk.gray('/') + chalk.white('B') + chalk.gray('/') + chalk.white('C') + chalk.gray('/') + chalk.white('D') + chalk.gray(' to answer  ·  ') + helpHint +
+        (q.number > 1 ? chalk.gray('  ·  ') + chalk.white('prev') : '') +
+        (q.number < total ? chalk.gray('  ·  ') + chalk.white('next') : ''));
 }
 export function registerExamCommand(program) {
     const exam = program.command('exam').description('National selection exam');
@@ -210,6 +227,8 @@ export function registerExamCommand(program) {
                 printError(`Question ${n} not found (1-${state.questions.length}).`);
                 return;
             }
+            state._lastQ = num;
+            saveExamState(state);
             printQuestion(q, state.answers[num]);
         }
         else {
@@ -264,6 +283,140 @@ export function registerExamCommand(program) {
         const q = state.questions[prev - 1];
         printQuestion(q, state.answers[q.number]);
     });
+    // ─── exam help ───
+    exam
+        .command('help')
+        .description('Eliminate one wrong option (limited uses)')
+        .action(() => {
+        logCommand('exam help');
+        const state = getExamState();
+        if (!state) {
+            printError('No exam in progress.');
+            return;
+        }
+        const help = getHelpState(state);
+        const currentQ = state._lastQ || 1;
+        const qHelps = help.perQ[currentQ] || 0;
+        const eliminated = help.eliminated[currentQ] || [];
+        const q = state.questions.find((qq) => qq.number === currentQ);
+        if (!q)
+            return;
+        // Find the correct answer for demo
+        let correctAnswer = null;
+        if (state.session.examId === 'demo-free') {
+            import('../lib/demo-exam.js').then(({ DEMO_ANSWERS }) => {
+                correctAnswer = DEMO_ANSWERS[currentQ];
+            });
+        }
+        // Check: already used 2 helps on this question
+        if (qHelps >= 2) {
+            console.log();
+            console.log(chalk.yellow('  🙈 I can\'t help you more on this one!'));
+            console.log(chalk.gray('  You already have a 50/50 — trust your instinct!'));
+            console.log();
+            printQuestion(q, state.answers[q.number]);
+            return;
+        }
+        // Check: only 1 option left (shouldn't happen with max 2 helps, but safety)
+        const remaining = ['A', 'B', 'C', 'D'].filter((k) => !eliminated.includes(k));
+        if (remaining.length <= 2) {
+            console.log();
+            console.log(chalk.yellow('  😄 Only 2 options left — you got this!'));
+            console.log();
+            printQuestion(q, state.answers[q.number]);
+            return;
+        }
+        // Check budget
+        if (help.used >= help.max) {
+            if (help.max < 8) {
+                console.log();
+                console.log(chalk.yellow(`  Help used: ${help.used}/${help.max}`));
+                console.log(chalk.white('  Need more? Type: ') + chalk.bold.yellow('more help') + chalk.gray(' (+3 bonus uses)'));
+                console.log();
+            }
+            else {
+                console.log();
+                console.log(chalk.gray(`  All help used (${help.used}/${help.max}). You\'re on your own! 💪`));
+                console.log();
+            }
+            return;
+        }
+        // Eliminate one wrong option (async for demo answers)
+        const doEliminate = (correct) => {
+            const wrongRemaining = remaining.filter((k) => k !== correct && !eliminated.includes(k));
+            if (wrongRemaining.length === 0)
+                return;
+            // Pick random wrong option to eliminate
+            const toRemove = wrongRemaining[Math.floor(Math.random() * wrongRemaining.length)];
+            eliminated.push(toRemove);
+            // Update state
+            if (!help.eliminated[currentQ])
+                help.eliminated[currentQ] = [];
+            help.eliminated[currentQ] = eliminated;
+            help.perQ[currentQ] = qHelps + 1;
+            help.used++;
+            state._helpUsed = help.used;
+            state._helpMax = help.max;
+            state._helpPerQ = help.perQ;
+            state._eliminated = help.eliminated;
+            saveExamState(state);
+            console.log();
+            console.log(chalk.yellow(`  💡 Option ${toRemove} eliminated!`) + chalk.gray(`  (help ${help.used}/${help.max})`));
+            printQuestion(q, state.answers[q.number]);
+        };
+        if (state.session.examId === 'demo-free') {
+            import('../lib/demo-exam.js').then(({ DEMO_ANSWERS }) => {
+                doEliminate(DEMO_ANSWERS[currentQ]);
+            });
+        }
+        else {
+            // For server exams, we don't know the answer — eliminate random non-selected option
+            const userAnswer = state.answers[currentQ];
+            const candidates = remaining.filter((k) => k !== userAnswer);
+            const toRemove = candidates[Math.floor(Math.random() * candidates.length)];
+            eliminated.push(toRemove);
+            if (!help.eliminated[currentQ])
+                help.eliminated[currentQ] = [];
+            help.eliminated[currentQ] = eliminated;
+            help.perQ[currentQ] = qHelps + 1;
+            help.used++;
+            state._helpUsed = help.used;
+            state._helpMax = help.max;
+            state._helpPerQ = help.perQ;
+            state._eliminated = help.eliminated;
+            saveExamState(state);
+            console.log();
+            console.log(chalk.yellow(`  💡 Option ${toRemove} eliminated!`) + chalk.gray(`  (help ${help.used}/${help.max})`));
+            printQuestion(q, state.answers[q.number]);
+        }
+    });
+    // ─── exam more-help ───
+    exam
+        .command('more-help')
+        .description('Unlock 3 bonus help uses')
+        .action(() => {
+        logCommand('exam more-help');
+        const state = getExamState();
+        if (!state) {
+            printError('No exam in progress.');
+            return;
+        }
+        const help = getHelpState(state);
+        if (help.max >= 8) {
+            console.log(chalk.gray('  Bonus help already unlocked.'));
+            return;
+        }
+        if (help.used < help.max) {
+            console.log(chalk.gray(`  You still have ${help.max - help.used} helps remaining. Use them first!`));
+            return;
+        }
+        state._helpMax = 8;
+        saveExamState(state);
+        console.log();
+        console.log(chalk.green('  🎁 +3 bonus help unlocked! (3/8 remaining)'));
+        console.log(chalk.gray('  Type "help" on any question to use.'));
+        console.log();
+    });
     // ─── exam answer <n> <choice> ───
     exam
         .command('answer <n> <choice>')
@@ -500,17 +653,18 @@ export function registerExamCommand(program) {
         console.log();
         printHeader('ICOA Demo Exam — Free Practice');
         console.log();
-        console.log(chalk.white('  This is a free practice exam to help you prepare.'));
-        console.log(chalk.white('  30 questions · 30 minutes · English'));
-        console.log(chalk.white('  No account or login required.'));
+        console.log(chalk.white('  Free practice exam · No account needed'));
+        console.log(chalk.white('  30 questions · 30 minutes · Single choice'));
         console.log();
         console.log(chalk.gray('  ┌─────────────────────────────────────────────────┐'));
-        console.log(chalk.gray('  │') + chalk.yellow('  For real exams, your proctor will provide:       ') + chalk.gray('│'));
-        console.log(chalk.gray('  │') + chalk.white('    · Server URL                                   ') + chalk.gray('│'));
-        console.log(chalk.gray('  │') + chalk.white('    · Username & Password                          ') + chalk.gray('│'));
-        console.log(chalk.gray('  │') + chalk.white('    · Exam ID                                     ') + chalk.gray('│'));
+        console.log(chalk.gray('  │') + chalk.white('  Each question has 4 options (A/B/C/D)            ') + chalk.gray('│'));
+        console.log(chalk.gray('  │') + chalk.white('  Type a letter to answer the current question     ') + chalk.gray('│'));
+        console.log(chalk.gray('  │') + chalk.white('  Type ') + chalk.yellow('help') + chalk.white(' to eliminate a wrong option (5 uses) ') + chalk.gray('│'));
+        console.log(chalk.gray('  │') + chalk.white('  Type ') + chalk.yellow('next') + chalk.white('/') + chalk.yellow('prev') + chalk.white(' to navigate between questions  ') + chalk.gray('│'));
         console.log(chalk.gray('  └─────────────────────────────────────────────────┘'));
         console.log();
+        console.log(chalk.gray('  For real exams, your proctor will provide credentials.'));
+        console.log();
         const proceed = await confirm({
             message: chalk.white('Start demo exam now?'),
             default: true,

package/dist/repl.js

@@ -5,6 +5,7 @@ import { isConnected, getConfig, saveConfig } from './lib/config.js';
 import { isActivated, activateToken, isFreeCommand, isDeviceMatch, recordExit, recordResume, isFirstRunOrUpgrade, markVersionSeen } from './lib/access.js';
 import { setReplMode } from './lib/ui.js';
 import { isChatActive, handleChatMessage } from './commands/ai4ctf.js';
+import { getExamState } from './lib/exam-state.js';
 import { resetTerminalTheme } from './lib/theme.js';
 import { ensureSandbox, runInSandbox, isDockerAvailable } from './lib/sandbox.js';
 import { logCommand } from './lib/logger.js';
@@ -236,12 +237,35 @@ export async function startRepl(program, resumeMode) {
             realExit(0);
             return;
         }
-        // Help
+        // Help — during exam, route to exam help; otherwise show REPL help
         if (input === 'help' || input === '?') {
+            if (getExamState()) {
+                processing = true;
+                try {
+                    await program.parseAsync(['node', 'icoa', 'exam', 'help']);
+                }
+                catch { }
+                processing = false;
+                rl.prompt();
+                return;
+            }
             printReplHelp(isActivated(), mode);
             rl.prompt();
             return;
         }
+        // "more help" — during exam, unlock bonus helps
+        if (input.toLowerCase() === 'more help') {
+            if (getExamState()) {
+                processing = true;
+                try {
+                    await program.parseAsync(['node', 'icoa', 'exam', 'more-help']);
+                }
+                catch { }
+                processing = false;
+                rl.prompt();
+                return;
+            }
+        }
         // Clear
         if (input === 'clear' || input === 'cls') {
             console.clear();
@@ -271,6 +295,37 @@ export async function startRepl(program, resumeMode) {
             rl.prompt();
             return;
         }
+        // ─── Quick exam answer shortcuts ───
+        // "A" / "B" / "C" / "D" → answer current question
+        // "2 C" / "5 A" → answer specific question
+        const examState = getExamState();
+        if (examState) {
+            const upper = input.toUpperCase().trim();
+            // Single letter: A, B, C, D → answer current question
+            if (/^[ABCD]$/.test(upper)) {
+                const currentQ = examState._lastQ || 1;
+                processing = true;
+                try {
+                    await program.parseAsync(['node', 'icoa', 'exam', 'answer', String(currentQ), upper]);
+                }
+                catch { }
+                processing = false;
+                rl.prompt();
+                return;
+            }
+            // "N X" pattern: e.g. "2 C", "15 A"
+            const match = upper.match(/^(\d+)\s+([ABCD])$/);
+            if (match) {
+                processing = true;
+                try {
+                    await program.parseAsync(['node', 'icoa', 'exam', 'answer', match[1], match[2]]);
+                }
+                catch { }
+                processing = false;
+                rl.prompt();
+                return;
+            }
+        }
         const cmd = input.split(/\s+/)[0].toLowerCase();
         // ─── Mode-based command filtering ───
         const selectionCommands = ['join', 'exam', 'demo', 'next', 'prev', 'setup', 'lang', 'ref', 'ctf'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icoa-cli",
-  "version": "2.7.2",
+  "version": "2.9.0",
   "description": "ICOA CLI — The world's first CLI-native CTF competition terminal",
   "type": "module",
   "bin": {