icoa-cli 2.19.19 → 2.19.20

package/dist/commands/exam.js

@@ -1,13 +1,108 @@
 import chalk from 'chalk';
 import { confirm } from '@inquirer/prompts';
 import { ExamClient } from '../lib/exam-client.js';
-import { getConfig } from '../lib/config.js';
+import { getConfig, saveConfig } from '../lib/config.js';
 import { getExamState, saveExamState, clearExamState, getExamDeadline } from '../lib/exam-state.js';
+import { getDemoStats, recordDemoAttempt, saveRetryQueue, getRetryQueue, clearRetryQueue } from '../lib/demo-stats.js';
 import { logCommand } from '../lib/logger.js';
 import { printSuccess, printError, printWarning, printInfo, printTable, printHeader, printKeyValue, createSpinner, formatCountdown, } from '../lib/ui.js';
 import { t } from '../lib/i18n.js';
 import { getDeviceFingerprint } from '../lib/access.js';
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Skippable intro animation for first-time demo users.
+ * Resolves immediately on any keypress. Max 30s auto-advance.
+ */
+async function playDemoIntro() {
+    let skipped = false;
+    const stdin = process.stdin;
+    const onKey = () => { skipped = true; };
+    const rawSupported = stdin.isTTY && typeof stdin.setRawMode === 'function';
+    if (rawSupported) {
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.once('data', onKey);
+    }
+    const waitOrSkip = async (ms) => {
+        const step = 80;
+        let waited = 0;
+        while (waited < ms && !skipped) {
+            await sleep(step);
+            waited += step;
+        }
+    };
+    const cleanup = () => {
+        if (rawSupported) {
+            stdin.removeListener('data', onKey);
+            try {
+                stdin.setRawMode(false);
+            }
+            catch { }
+            stdin.pause();
+        }
+    };
+    try {
+        console.clear();
+        console.log();
+        console.log(chalk.gray('   ') + chalk.dim('(press any key to skip)'));
+        console.log();
+        console.log(chalk.bold.white('   ██╗ ██████╗ ██████╗  █████╗'));
+        console.log(chalk.bold.white('   ██║██╔════╝██╔═══██╗██╔══██╗'));
+        console.log(chalk.bold.white('   ██║██║     ██║   ██║███████║'));
+        console.log(chalk.bold.white('   ██║██║     ██║   ██║██╔══██║'));
+        console.log(chalk.bold.white('   ██║╚██████╗╚██████╔╝██║  ██║'));
+        console.log(chalk.bold.white('   ╚═╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═╝'));
+        console.log();
+        console.log(chalk.bold.yellow('   International Cyber Olympiad in AI'));
+        console.log(chalk.gray('   Sydney, Australia  ·  Jun 27 – Jul 2, 2026'));
+        await waitOrSkip(2500);
+        if (skipped)
+            return;
+        console.log();
+        console.log(chalk.white('   What you\'ll do today:'));
+        console.log();
+        await waitOrSkip(600);
+        if (skipped)
+            return;
+        console.log(chalk.cyan('     ▣ ') + chalk.white('Answer 10 quick questions') + chalk.gray('        (now, ~5 min)'));
+        await waitOrSkip(700);
+        if (skipped)
+            return;
+        console.log(chalk.green('     ▣ ') + chalk.white('Team up with AI to solve CTFs') + chalk.gray('    (ai4ctf)'));
+        await waitOrSkip(700);
+        if (skipped)
+            return;
+        console.log(chalk.red('     ▣ ') + chalk.white('Hack the AI\'s guardrails') + chalk.gray('         (ctf4ai)'));
+        await waitOrSkip(900);
+        if (skipped)
+            return;
+        console.log();
+        console.log(chalk.bold.white('   Your terminal ') + chalk.bold.yellow('IS') + chalk.bold.white(' the competition.'));
+        console.log();
+        await waitOrSkip(1500);
+        if (skipped)
+            return;
+        console.log(chalk.gray('   · 109 CTF tools pre-configured'));
+        await waitOrSkip(400);
+        if (skipped)
+            return;
+        console.log(chalk.gray('   · 15 languages, real-time AI translation'));
+        await waitOrSkip(400);
+        if (skipped)
+            return;
+        console.log(chalk.gray('   · 15,000+ concurrent participants'));
+        await waitOrSkip(800);
+        if (skipped)
+            return;
+        console.log();
+        console.log(chalk.bold.cyan('   Press any key to start demo...'));
+        await waitOrSkip(4000);
+    }
+    finally {
+        cleanup();
+        console.clear();
+    }
+}
 function drawProgress(percent, label) {
     const width = 30;
     const filled = Math.round((percent / 100) * width);
@@ -554,6 +649,14 @@ export function registerExamCommand(program) {
         const answered = Object.keys(state.answers).length;
         const total = state.session.questionCount;
         printSuccess(`Q${num}: ${c} ✓  (${answered}/${total} answered)`);
+        // Demo-only: gentle per-answer feedback (grey, non-intrusive)
+        if (state.session.examId === 'demo-free' && q.answer) {
+            const NICE_WORDS = ['Nice one.', 'Solid pick.', 'On the money.', 'Exactly.', 'Spot on.'];
+            const CLOSE_WORDS = ['Close — we\'ll revisit this one.', 'Hmm, worth a second look at the end.', 'Keep it in mind for review.'];
+            const pool = c === q.answer ? NICE_WORDS : CLOSE_WORDS;
+            const word = pool[Math.floor(Math.random() * pool.length)];
+            console.log(chalk.gray(`    · ${word}`));
+        }
         // Auto-show next question and update _lastQ
         if (num < state.questions.length) {
             const nextQ = state.questions[num]; // 0-indexed: questions[num] = question num+1
@@ -732,19 +835,39 @@ export function registerExamCommand(program) {
                 console.log(chalk.gray('   Sydney, Australia · Jun 27 - Jul 2, 2026'));
                 console.log();
                 console.log(chalk.cyan('  ═══════════════════════════════════════'));
-                // Per-category breakdown
+                // Per-category breakdown with ASCII progress bars
                 const catEntries = Object.entries(categoryStats);
                 if (catEntries.length > 0) {
                     console.log();
                     console.log(chalk.bold.white('  By category'));
+                    const BAR_WIDTH = 10;
                     for (const [cat, s] of catEntries) {
                         const pct = s.total > 0 ? Math.round(s.correct / s.total * 100) : 0;
+                        const filled = s.total > 0 ? Math.round((s.correct / s.total) * BAR_WIDTH) : 0;
+                        const empty = BAR_WIDTH - filled;
                         const color = pct >= 80 ? chalk.green : pct >= 50 ? chalk.yellow : chalk.red;
-                        console.log('    ' + color(`${cat.padEnd(20)} ${s.correct}/${s.total}  (${pct}%)`));
+                        const bar = color('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+                        console.log('    ' + chalk.white(cat.padEnd(20)) + ' ' + bar + '  ' + color(`${s.correct}/${s.total}`) + chalk.gray(` (${pct}%)`));
                     }
                     console.log();
                     console.log(chalk.cyan('  ─────────────────────────────────────────────'));
                 }
+                // Record stats locally + save retry queue
+                const updatedStats = recordDemoAttempt(score, total);
+                const isNewBest = score === updatedStats.best && updatedStats.attempts > 1 && score > 0;
+                if (isNewBest) {
+                    console.log();
+                    console.log(chalk.bold.green('  ★ New personal best!'));
+                }
+                if (wrongQuestions.length > 0) {
+                    const wrongSnapshots = questionsSnapshot
+                        .filter((q) => wrongQuestions.includes(q.number))
+                        .map((q) => ({ ...q }));
+                    saveRetryQueue(wrongSnapshots);
+                }
+                else {
+                    clearRetryQueue();
+                }
                 // Show wrong answers with explanations
                 if (wrongQuestions.length > 0) {
                     console.log();
@@ -776,6 +899,11 @@ export function registerExamCommand(program) {
                     console.log();
                     console.log(chalk.green(`  ${t('perfectScore')}`));
                 }
+                // Offer retry wrong only
+                if (wrongQuestions.length > 0) {
+                    console.log();
+                    console.log(chalk.white('  💪 Want to nail the ones you missed? Type: ') + chalk.bold.cyan('retry'));
+                }
                 console.log();
                 // ─── What is CTF + Dual-track introduction ───
                 console.log(chalk.white(`  ${t('theoryDone')}`));
@@ -966,6 +1094,12 @@ export function registerExamCommand(program) {
         .action(async () => {
         logCommand('exam demo');
         const { pickDemoQuestions, getLocalizedDemoSession, DEMO_PICK_SIZE, DEMO_POOL_SIZE } = await import('../lib/demo-exam.js');
+        // First-time intro animation (skippable)
+        const cfg = getConfig();
+        if (!cfg.demoIntroSeen) {
+            await playDemoIntro();
+            saveConfig({ demoIntroSeen: true });
+        }
         const DEMO_QUESTIONS = pickDemoQuestions(DEMO_PICK_SIZE);
         const DEMO_SESSION = getLocalizedDemoSession();
         const existing = getExamState();
@@ -985,6 +1119,14 @@ export function registerExamCommand(program) {
         console.log();
         console.log(chalk.white('  Free practice · No account needed · No time limit'));
         console.log(chalk.white(`  ${DEMO_PICK_SIZE} random questions from a pool of ${DEMO_POOL_SIZE} · Pick one answer per question`));
+        // Best score tracker
+        const stats = getDemoStats();
+        if (stats.attempts > 0) {
+            const bestPct = stats.bestPercentage;
+            const bestColor = bestPct >= 80 ? chalk.green : bestPct >= 60 ? chalk.yellow : chalk.white;
+            console.log();
+            console.log(chalk.gray('  Your best: ') + bestColor(`${stats.best}/${DEMO_PICK_SIZE} (${bestPct}%)`) + chalk.gray(`  ·  ${stats.attempts} attempts`));
+        }
         console.log();
         printHowToPlay();
         console.log();
@@ -1018,6 +1160,67 @@ export function registerExamCommand(program) {
         // Show first question
         printQuestion(DEMO_QUESTIONS[0]);
     });
+    // ─── exam demo-retry ───  (runs demo with the wrong questions from last attempt)
+    exam
+        .command('demo-retry')
+        .description('Retry only the questions you got wrong last demo attempt')
+        .action(async () => {
+        logCommand('exam demo-retry');
+        const { getLocalizedDemoSession } = await import('../lib/demo-exam.js');
+        const retryQueue = getRetryQueue();
+        if (!retryQueue || retryQueue.length === 0) {
+            console.log();
+            console.log(chalk.yellow('  No wrong questions to retry. Run ') + chalk.bold.cyan('demo') + chalk.yellow(' first.'));
+            console.log();
+            return;
+        }
+        const existing = getExamState();
+        if (existing) {
+            if (existing.session.examId === 'demo-free') {
+                clearExamState();
+            }
+            else {
+                printWarning(`Exam "${existing.session.examName}" is in progress.`);
+                printInfo('Submit it first: exam submit');
+                return;
+            }
+        }
+        // Reshuffle each question's options (keeps learning fresh), renumber 1..n
+        const shuffleOpts = (q) => {
+            if (!q.answer)
+                return q;
+            const correctText = q.options[q.answer];
+            const values = ['A', 'B', 'C', 'D'].map((k) => q.options[k]);
+            for (let i = values.length - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [values[i], values[j]] = [values[j], values[i]];
+            }
+            const newOptions = { A: values[0], B: values[1], C: values[2], D: values[3] };
+            const newAnswer = ['A', 'B', 'C', 'D'].find((k) => newOptions[k] === correctText);
+            return { ...q, options: newOptions, answer: newAnswer };
+        };
+        const retryQuestions = retryQueue.map((q, i) => ({
+            ...shuffleOpts(q),
+            number: i + 1,
+        }));
+        const baseSession = getLocalizedDemoSession();
+        const session = {
+            ...baseSession,
+            examName: `${baseSession.examName}  (Retry wrong only)`,
+            questionCount: retryQuestions.length,
+            startedAt: new Date().toISOString(),
+        };
+        console.log();
+        printHeader('Demo Retry — Wrong Questions Only');
+        console.log();
+        console.log(chalk.white(`  Practicing ${retryQuestions.length} question${retryQuestions.length === 1 ? '' : 's'} you got wrong.`));
+        console.log(chalk.gray('  Options have been reshuffled.'));
+        console.log();
+        saveExamState({ session, questions: retryQuestions, answers: {} });
+        printKeyValue('Questions', String(retryQuestions.length));
+        printKeyValue('Duration', 'No time limit');
+        printQuestion(retryQuestions[0]);
+    });
     // Default action: show status or help
     exam.action(() => {
         logCommand('exam');

package/dist/lib/demo-stats.d.ts

@@ -0,0 +1,16 @@
+import type { ExamQuestion } from '../types/index.js';
+export interface DemoStats {
+    best: number;
+    bestPercentage: number;
+    attempts: number;
+    lastFive: Array<{
+        score: number;
+        total: number;
+        at: string;
+    }>;
+}
+export declare function getDemoStats(): DemoStats;
+export declare function recordDemoAttempt(score: number, total: number): DemoStats;
+export declare function saveRetryQueue(questions: ExamQuestion[]): void;
+export declare function getRetryQueue(): ExamQuestion[] | null;
+export declare function clearRetryQueue(): void;

package/dist/lib/demo-stats.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getIcoaDir } from './config.js';
+const STATS_FILE = () => join(getIcoaDir(), 'demo-stats.json');
+const RETRY_FILE = () => join(getIcoaDir(), 'demo-retry.json');
+const DEFAULT_STATS = {
+    best: 0,
+    bestPercentage: 0,
+    attempts: 0,
+    lastFive: [],
+};
+export function getDemoStats() {
+    try {
+        if (!existsSync(STATS_FILE()))
+            return { ...DEFAULT_STATS };
+        const data = JSON.parse(readFileSync(STATS_FILE(), 'utf-8'));
+        return { ...DEFAULT_STATS, ...data };
+    }
+    catch {
+        return { ...DEFAULT_STATS };
+    }
+}
+export function recordDemoAttempt(score, total) {
+    const current = getDemoStats();
+    const pct = total > 0 ? Math.round((score / total) * 100) : 0;
+    const next = {
+        best: Math.max(current.best, score),
+        bestPercentage: Math.max(current.bestPercentage, pct),
+        attempts: current.attempts + 1,
+        lastFive: [
+            { score, total, at: new Date().toISOString() },
+            ...current.lastFive,
+        ].slice(0, 5),
+    };
+    try {
+        writeFileSync(STATS_FILE(), JSON.stringify(next, null, 2));
+    }
+    catch { }
+    return next;
+}
+export function saveRetryQueue(questions) {
+    try {
+        writeFileSync(RETRY_FILE(), JSON.stringify({ questions, savedAt: new Date().toISOString() }, null, 2));
+    }
+    catch { }
+}
+export function getRetryQueue() {
+    try {
+        if (!existsSync(RETRY_FILE()))
+            return null;
+        const data = JSON.parse(readFileSync(RETRY_FILE(), 'utf-8'));
+        if (Array.isArray(data.questions) && data.questions.length > 0) {
+            return data.questions;
+        }
+    }
+    catch { }
+    return null;
+}
+export function clearRetryQueue() {
+    try {
+        if (existsSync(RETRY_FILE()))
+            writeFileSync(RETRY_FILE(), JSON.stringify({ questions: [] }, null, 2));
+    }
+    catch { }
+}

package/dist/repl.js

@@ -500,8 +500,8 @@ export async function startRepl(program, resumeMode) {
         }
         const cmd = input.split(/\s+/)[0].toLowerCase();
         // ─── Mode-based command filtering ───
-        const selectionCommands = ['exam', 'demo', 'nations', 'next', 'prev', 'continue', 'setup', 'lang', 'ref', 'ai4ctf', 'ctf4ai'];
-        const organizerCommands = ['join', 'exam', 'demo', 'next', 'prev', 'logout', 'setup', 'lang', 'ref', 'ctf'];
+        const selectionCommands = ['exam', 'demo', 'retry', 'nations', 'next', 'prev', 'continue', 'setup', 'lang', 'ref', 'ai4ctf', 'ctf4ai'];
+        const organizerCommands = ['join', 'exam', 'demo', 'retry', 'next', 'prev', 'logout', 'setup', 'lang', 'ref', 'ctf'];
         if (mode === 'selection' && !selectionCommands.includes(cmd)) {
             console.log(chalk.gray('  Not available in Selection mode.'));
             if (examState) {
@@ -537,7 +537,7 @@ export async function startRepl(program, resumeMode) {
             'scoreboard', 'sb', 'status', 'time', 'hint', 'hint-b', 'hint-c',
             'hint-budget', 'ref', 'shell', 'files', 'connect', 'note',
             'log', 'lang', 'setup', 'env', 'ai4ctf', 'model', 'ctf',
-            'exam', 'demo', 'nations', 'next', 'prev', 'continue', 'logout', 'ctf4ai',
+            'exam', 'demo', 'retry', 'nations', 'next', 'prev', 'continue', 'logout', 'ctf4ai',
         ];
         if (!knownCommands.includes(cmd)) {
             // Block dangerous commands
@@ -681,6 +681,7 @@ function mapCommand(input) {
     const rest = parts.slice(1);
     const ctfShortcuts = {
         'demo': ['exam', 'demo'],
+        'retry': ['exam', 'demo-retry'],
         'nations': ['exam', 'nations'],
         'next': ['exam', 'next'],
         'prev': ['exam', 'prev'],

package/dist/types/index.d.ts

@@ -104,6 +104,7 @@ export interface IcoaConfig {
     sessionCookie: string;
     country: string;
     mode: IcoaMode | '';
+    demoIntroSeen: boolean;
 }
 export type CompetitionState = 'pre_competition' | 'demo' | 'live' | 'finished' | 'unknown';
 export type IcoaMode = 'selection' | 'olympiad' | 'organizer';

package/dist/types/index.js

@@ -32,5 +32,6 @@ export const DEFAULT_CONFIG = {
     sessionCookie: '',
     country: '',
     mode: '',
+    demoIntroSeen: false,
 };
 export const SUPPORTED_LANGUAGES = ['en', 'zh', 'ja', 'ko', 'es', 'ar', 'fr', 'pt', 'ru', 'hi', 'de', 'id', 'th', 'vi', 'tr'];

package/package.json

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