vocabflow 0.0.2 → 0.1.0

package/dist/commands/login.d.ts

@@ -1,2 +1 @@
 export declare function login(): Promise<void>;
-//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.js

@@ -48,4 +48,3 @@ export async function login() {
         process.exit(1);
     }
 }
-//# sourceMappingURL=login.js.map

package/dist/commands/logout.d.ts

@@ -1,2 +1 @@
 export declare function logout(): Promise<void>;
-//# sourceMappingURL=logout.d.ts.map

package/dist/commands/logout.js

@@ -25,4 +25,3 @@ export async function logout() {
         });
     });
 }
-//# sourceMappingURL=logout.js.map

package/dist/commands/review.d.ts

@@ -1,3 +1,4 @@
-import type { ReviewMode } from '../types/review.js';
+import type { ReviewMode, TodayReviewVO } from '../types/review.js';
+export declare function formatRelativeTime(isoString: string): string;
+export declare function getStatsLine(word: TodayReviewVO, maxWidth: number): string;
 export declare function review(initialMode?: ReviewMode): Promise<void>;
-//# sourceMappingURL=review.d.ts.map

package/dist/commands/review.js

@@ -1,6 +1,7 @@
 import picocolors from 'picocolors';
 import { isInteractive, setupRawMode, cleanup, clearScreen, moveCursorTop } from '../lib/tty.js';
 import { requireAuth, reviewApi, isApiSuccess } from '../lib/api-client.js';
+import { detectPronounceCapability, speakWord } from '../lib/pronounce.js';
 import { getModeLabel } from '../lib/review-mode.js';
 const CHOICE_LABELS = ['A', 'B', 'C', 'D'];
 const HIGHLIGHT_OPEN = '\x1b[38;2;217;119;87m'; // #D97757
@@ -269,6 +270,26 @@ function getPhoneticLine(word, question, loading) {
     }
     return picocolors.dim('/.../');
 }
+export function formatRelativeTime(isoString) {
+    const diffMs = Date.now() - new Date(isoString).getTime();
+    const diffMin = Math.floor(diffMs / 60_000);
+    if (diffMin < 60)
+        return `${diffMin}m ago`;
+    const diffHr = Math.floor(diffMin / 60);
+    if (diffHr < 24)
+        return `${diffHr}h ago`;
+    return `${Math.floor(diffHr / 24)}d ago`;
+}
+export function getStatsLine(word, maxWidth) {
+    const count = word.reviewCount ?? 0;
+    const accuracyDisplay = word.accuracyRate ?? '--';
+    const parts = [`Reviewed ${count} times`, `Accuracy ${accuracyDisplay}`];
+    if (word.lastReviewTime) {
+        parts.push(`Last: ${formatRelativeTime(word.lastReviewTime)}`);
+    }
+    const line = parts.join('  |  ');
+    return picocolors.dim(truncateLine(line, maxWidth));
+}
 function getQuestionCacheKey(wordId, mode) {
     return `${wordId}:${mode}`;
 }
@@ -308,6 +329,24 @@ function resolveChoiceOutcome(payload) {
         correctAnswer: textValue(data.correctAnswer) || undefined,
     };
 }
+function getPronounceUnavailableMessage(capability) {
+    if (capability.reason === 'unsupported-platform') {
+        return '当前平台暂不支持发音。';
+    }
+    if (capability.reason === 'probe-failed') {
+        return '发音能力探测失败，请稍后重试。';
+    }
+    return '当前终端无可用 TTS 命令。';
+}
+function getSpeakFailureMessage(result) {
+    if (result.reason === 'timeout') {
+        return '发音超时。';
+    }
+    if (result.detail) {
+        return `发音失败: ${result.detail}`;
+    }
+    return '发音失败。';
+}
 export async function review(initialMode = 'FLASHCARD_FORWARD') {
     await requireAuth();
     const response = await reviewApi.getTodayReview();
@@ -331,6 +370,8 @@ export async function review(initialMode = 'FLASHCARD_FORWARD') {
     let confirmDelete = false;
     let notice = null;
     let pendingActionText = null;
+    let pronounceCapability = null;
+    let pronounceInFlight = false;
     setupRawMode();
     function render() {
         const word = words[currentIndex];
@@ -347,6 +388,7 @@ export async function review(initialMode = 'FLASHCARD_FORWARD') {
         console.log(picocolors.bold(picocolors.cyan(truncateLine(word.wordText, maxWidth))));
         console.log(getPhoneticLine(word, question, loadingCurrent));
         console.log(picocolors.yellow(`${currentIndex + 1}/${total}`));
+        console.log(getStatsLine(word, maxWidth));
         console.log(picocolors.dim('─'.repeat(Math.min(maxWidth, 72))));
         if (choiceMode) {
             console.log(picocolors.green('Question'));
@@ -386,9 +428,10 @@ export async function review(initialMode = 'FLASHCARD_FORWARD') {
         const hintParts = choiceMode
             ? [
                 `${picocolors.cyan('[A/B/C/D]')} Choose`,
+                `${picocolors.cyan('[P]')} Pronounce`,
                 `${picocolors.cyan('[r]')} Toggle mode`,
                 `${picocolors.magenta('Mode:')} ${getModeLabel(currentMode)}`,
-                `${picocolors.red('[d]')} Delete`,
+                `${picocolors.red('[Backspace]')} Delete`,
                 `${picocolors.cyan('[h/l]')} Prev/Next`,
                 `${picocolors.red('[q]')} Quit`,
             ]
@@ -397,9 +440,10 @@ export async function review(initialMode = 'FLASHCARD_FORWARD') {
                 `${picocolors.yellow('[1]')} Forget`,
                 `${picocolors.yellow('[2]')} Hard`,
                 `${picocolors.yellow('[3]')} Mastered`,
+                `${picocolors.cyan('[P]')} Pronounce`,
                 `${picocolors.cyan('[r]')} Toggle mode`,
                 `${picocolors.magenta('Mode:')} ${getModeLabel(currentMode)}`,
-                `${picocolors.red('[d]')} Delete`,
+                `${picocolors.red('[Backspace]')} Delete`,
                 `${picocolors.cyan('[h/l]')} Prev/Next`,
                 `${picocolors.red('[q]')} Quit`,
             ];
@@ -494,6 +538,53 @@ export async function review(initialMode = 'FLASHCARD_FORWARD') {
             render();
         }
     }
+    function triggerPronunciation() {
+        if (pronounceInFlight) {
+            notice = { type: 'warning', text: '发音进行中，请稍候。' };
+            render();
+            return;
+        }
+        const wordText = words[currentIndex]?.wordText?.trim();
+        if (!wordText) {
+            notice = { type: 'warning', text: '当前词条为空，无法发音。' };
+            render();
+            return;
+        }
+        pronounceInFlight = true;
+        void (async () => {
+            try {
+                if (!pronounceCapability) {
+                    pronounceCapability = await detectPronounceCapability();
+                }
+                if (pronounceCapability.status !== 'available') {
+                    notice = { type: 'warning', text: getPronounceUnavailableMessage(pronounceCapability) };
+                    return;
+                }
+                const speakResult = await speakWord(wordText);
+                if (speakResult.status === 'spoken') {
+                    notice = { type: 'success', text: `已发音: ${wordText}` };
+                    return;
+                }
+                if (speakResult.status === 'skipped') {
+                    notice = {
+                        type: 'warning',
+                        text: speakResult.reason === 'empty-word'
+                            ? '当前词条为空，无法发音。'
+                            : '当前终端无可用 TTS 命令。',
+                    };
+                    return;
+                }
+                notice = { type: 'error', text: getSpeakFailureMessage(speakResult) };
+            }
+            catch (error) {
+                notice = { type: 'error', text: `发音失败: ${error?.message || 'Unknown error'}` };
+            }
+            finally {
+                pronounceInFlight = false;
+                render();
+            }
+        })();
+    }
     process.stdin.on('keypress', async (_chunk, key) => {
         if (pendingActionText) {
             return;
@@ -538,7 +629,11 @@ export async function review(initialMode = 'FLASHCARD_FORWARD') {
             render();
             return;
         }
-        if (key.name === 'd') {
+        if (key.name === 'p') {
+            triggerPronunciation();
+            return;
+        }
+        if (key.name === 'backspace') {
             confirmDelete = true;
             notice = null;
             render();
@@ -648,4 +743,3 @@ export async function review(initialMode = 'FLASHCARD_FORWARD') {
     await ensureQuestionLoaded(words[currentIndex].id, currentMode, false);
     render();
 }
-//# sourceMappingURL=review.js.map

package/dist/commands/settings.d.ts

@@ -1,2 +1 @@
 export declare function settings(args: string[]): Promise<void>;
-//# sourceMappingURL=settings.d.ts.map

package/dist/commands/settings.js

@@ -38,4 +38,3 @@ export async function settings(args) {
     }
     throw new Error('Invalid settings command. Use: vocabflow settings --help');
 }
-//# sourceMappingURL=settings.js.map

package/dist/commands/status.d.ts

@@ -1,2 +1 @@
 export declare function status(): Promise<void>;
-//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.js

@@ -26,4 +26,3 @@ export async function status() {
         process.exit(1);
     }
 }
-//# sourceMappingURL=status.js.map

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { login } from './commands/login.js';
 import { logout } from './commands/logout.js';
 import { status } from './commands/status.js';
@@ -9,6 +12,16 @@ import { getDefaultReviewMode } from './lib/config.js';
 import { parseReviewModeArg } from './lib/review-mode.js';
 const command = process.argv[2];
 const commandArgs = process.argv.slice(3);
+const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../package.json');
+function getCliVersion() {
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return packageJson.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 function parseReviewMode(args) {
     const modeFlagIndex = args.findIndex((arg) => arg === '--mode');
     if (modeFlagIndex === -1) {
@@ -21,6 +34,10 @@ function parseReviewMode(args) {
     return parseReviewModeArg(modeValue);
 }
 async function main() {
+    if (command === '--version' || command === '-v' || command === 'version') {
+        console.log(getCliVersion());
+        process.exit(0);
+    }
     switch (command) {
         case 'login':
             await login();
@@ -51,6 +68,7 @@ async function main() {
     ${picocolors.cyan('vocabflow settings')}      Show or update settings
     ${picocolors.cyan('vocabflow review')}      Start a vocabulary review session
     ${picocolors.cyan('vocabflow review --mode revert')} Start in REVERT (A/B/C/D) mode
+    ${picocolors.cyan('vocabflow --version')}      Show current version
 
   ${picocolors.dim('Run `vocabflow <command> --help` for more options.')}
       `);
@@ -61,4 +79,3 @@ main().catch((err) => {
     console.error(picocolors.red(`Error: ${err.message}`));
     process.exit(1);
 });
-//# sourceMappingURL=index.js.map

package/dist/lib/api-client.d.ts

@@ -52,4 +52,3 @@ export declare const reviewApi: {
         timestamp?: number;
     }>;
 };
-//# sourceMappingURL=api-client.d.ts.map

package/dist/lib/api-client.js

@@ -90,4 +90,3 @@ export const reviewApi = {
      */
     deleteWord: (wordId) => cliApi.delete(`api/words/${wordId}`),
 };
-//# sourceMappingURL=api-client.js.map

package/dist/lib/config.d.ts

@@ -21,4 +21,3 @@ export declare function isTokenExpired(): boolean;
 export declare function getDefaultReviewMode(): ReviewMode;
 export declare function setDefaultReviewMode(mode: ReviewMode): void;
 export { config };
-//# sourceMappingURL=config.d.ts.map

package/dist/lib/config.js

@@ -45,4 +45,3 @@ export function setDefaultReviewMode(mode) {
     config.set('defaultReviewMode', mode);
 }
 export { config };
-//# sourceMappingURL=config.js.map

package/dist/lib/oauth-callback.d.ts

@@ -8,4 +8,3 @@ export interface CallbackError {
 }
 export type CallbackResult = CallbackSuccess | CallbackError;
 export declare function startCallbackServer(): Promise<CallbackResult>;
-//# sourceMappingURL=oauth-callback.d.ts.map

package/dist/lib/oauth-callback.js

@@ -4,9 +4,23 @@ const CALLBACK_PORT = 58421;
 const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 export async function startCallbackServer() {
     return new Promise((resolve, reject) => {
+        let settled = false;
+        const settleSuccess = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            server.close(() => resolve(result));
+        };
+        const settleError = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            server.close(() => reject(error));
+        };
         const timer = setTimeout(() => {
-            server.close();
-            reject(new Error('Authentication timed out. Please try again.'));
+            settleError(new Error('Authentication timed out. Please try again.'));
         }, CALLBACK_TIMEOUT_MS);
         const server = http.createServer((req, res) => {
             // Handle CORS preflight
@@ -38,10 +52,9 @@ export async function startCallbackServer() {
               <p>You can close this window.</p>
             </body>
           </html>
-        `);
-                clearTimeout(timer);
-                server.close();
-                resolve({ type: 'error', message: msg });
+        `, () => {
+                    settleSuccess({ type: 'error', message: msg });
+                });
                 return;
             }
             if (token) {
@@ -57,10 +70,9 @@ export async function startCallbackServer() {
               <p>You can close this window and return to the CLI.</p>
             </body>
           </html>
-        `);
-                clearTimeout(timer);
-                server.close();
-                resolve({ type: 'success', token });
+        `, () => {
+                    settleSuccess({ type: 'success', token });
+                });
                 return;
             }
             // Unknown route
@@ -69,10 +81,10 @@ export async function startCallbackServer() {
         });
         server.on('error', (err) => {
             if (err.code === 'EADDRINUSE') {
-                reject(new Error(`Port ${CALLBACK_PORT} is already in use. Please close other vocab processes and try again.`));
+                settleError(new Error(`Port ${CALLBACK_PORT} is already in use. Please close other vocab processes and try again.`));
             }
             else {
-                reject(err);
+                settleError(err);
             }
         });
         server.listen(CALLBACK_PORT, () => {
@@ -80,4 +92,3 @@ export async function startCallbackServer() {
         });
     });
 }
-//# sourceMappingURL=oauth-callback.js.map

package/dist/lib/pronounce.d.ts

@@ -0,0 +1,20 @@
+export type PronounceAvailability = 'available' | 'unavailable';
+export type PronounceReason = 'command-not-found' | 'unsupported-platform' | 'probe-failed' | 'unavailable' | 'empty-word' | 'execution-failed' | 'timeout';
+type SpeakerId = 'darwin-say' | 'linux-espeak-ng' | 'linux-espeak' | 'linux-spd-say' | 'win-powershell' | 'win-pwsh';
+export interface PronounceCapability {
+    status: PronounceAvailability;
+    platform: NodeJS.Platform;
+    speaker?: SpeakerId;
+    command?: string;
+    reason?: Extract<PronounceReason, 'command-not-found' | 'unsupported-platform' | 'probe-failed'>;
+    detail?: string;
+}
+export interface SpeakWordResult {
+    status: 'spoken' | 'skipped' | 'failed';
+    reason?: PronounceReason;
+    detail?: string;
+}
+export declare function resetPronounceCapabilityCache(): void;
+export declare function detectPronounceCapability(platform?: NodeJS.Platform): Promise<PronounceCapability>;
+export declare function speakWord(word: string, platform?: NodeJS.Platform): Promise<SpeakWordResult>;
+export {};

package/dist/lib/pronounce.js

@@ -0,0 +1,230 @@
+import { spawn } from 'node:child_process';
+const WINDOWS_SPEAK_SCRIPT = '$word = $args[0]; Add-Type -AssemblyName System.Speech; $synth = New-Object System.Speech.Synthesis.SpeechSynthesizer; $synth.Speak($word)';
+const CANDIDATES_BY_PLATFORM = {
+    darwin: [
+        {
+            id: 'darwin-say',
+            command: 'say',
+            probeArgs: ['-v', '?'],
+        },
+    ],
+    linux: [
+        {
+            id: 'linux-espeak-ng',
+            command: 'espeak-ng',
+            probeArgs: ['--version'],
+        },
+        {
+            id: 'linux-espeak',
+            command: 'espeak',
+            probeArgs: ['--version'],
+        },
+        {
+            id: 'linux-spd-say',
+            command: 'spd-say',
+            probeArgs: ['--version'],
+        },
+    ],
+    win32: [
+        {
+            id: 'win-powershell',
+            command: 'powershell',
+            probeArgs: ['-NoProfile', '-NonInteractive', '-Command', '$PSVersionTable.PSVersion.ToString()'],
+        },
+        {
+            id: 'win-pwsh',
+            command: 'pwsh',
+            probeArgs: ['-NoProfile', '-NonInteractive', '-Command', '$PSVersionTable.PSVersion.ToString()'],
+        },
+    ],
+};
+const capabilityCache = new Map();
+function getCandidates(platform) {
+    if (platform === 'darwin' || platform === 'linux' || platform === 'win32') {
+        return CANDIDATES_BY_PLATFORM[platform];
+    }
+    return [];
+}
+function buildSpeakArgs(speaker, word) {
+    switch (speaker) {
+        case 'darwin-say':
+            return [word];
+        case 'linux-espeak-ng':
+        case 'linux-espeak':
+            return ['-q', word];
+        case 'linux-spd-say':
+            return [word];
+        case 'win-powershell':
+        case 'win-pwsh':
+            return ['-NoProfile', '-NonInteractive', '-Command', WINDOWS_SPEAK_SCRIPT, word];
+        default:
+            return [word];
+    }
+}
+function runCommand(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        const finalize = (outcome) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(outcome);
+        };
+        let child;
+        try {
+            child = spawn(command, args, { stdio: 'ignore' });
+        }
+        catch (error) {
+            finalize({
+                ok: false,
+                reason: 'spawn-error',
+                detail: error?.message ?? String(error),
+            });
+            return;
+        }
+        const timeout = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            timedOut = true;
+            child.kill('SIGTERM');
+            setTimeout(() => {
+                if (!settled) {
+                    child.kill('SIGKILL');
+                    finalize({
+                        ok: false,
+                        reason: 'timeout',
+                        detail: 'process-timeout',
+                    });
+                }
+            }, 150);
+        }, timeoutMs);
+        timeout.unref?.();
+        child.once('error', (error) => {
+            clearTimeout(timeout);
+            if (error?.code === 'ENOENT') {
+                finalize({
+                    ok: false,
+                    reason: 'command-not-found',
+                    detail: error?.message ?? 'command-not-found',
+                });
+                return;
+            }
+            finalize({
+                ok: false,
+                reason: 'spawn-error',
+                detail: error?.message ?? String(error),
+            });
+        });
+        child.once('exit', (code) => {
+            clearTimeout(timeout);
+            if (timedOut) {
+                finalize({
+                    ok: false,
+                    reason: 'timeout',
+                    detail: 'process-timeout',
+                });
+                return;
+            }
+            if (code === 0) {
+                finalize({ ok: true });
+                return;
+            }
+            finalize({
+                ok: false,
+                reason: 'execution-failed',
+                detail: typeof code === 'number' ? `exit-${code}` : 'exit-unknown',
+            });
+        });
+    });
+}
+async function detectCapabilityForPlatform(platform) {
+    const candidates = getCandidates(platform);
+    if (candidates.length === 0) {
+        return {
+            status: 'unavailable',
+            platform,
+            reason: 'unsupported-platform',
+        };
+    }
+    let sawProbeFailure = false;
+    for (const candidate of candidates) {
+        const probe = await runCommand(candidate.command, candidate.probeArgs, 2_500);
+        if (probe.ok || probe.reason === 'execution-failed') {
+            return {
+                status: 'available',
+                platform,
+                speaker: candidate.id,
+                command: candidate.command,
+            };
+        }
+        if (probe.reason === 'spawn-error' || probe.reason === 'timeout') {
+            sawProbeFailure = true;
+        }
+    }
+    if (sawProbeFailure) {
+        return {
+            status: 'unavailable',
+            platform,
+            reason: 'probe-failed',
+        };
+    }
+    return {
+        status: 'unavailable',
+        platform,
+        reason: 'command-not-found',
+    };
+}
+export function resetPronounceCapabilityCache() {
+    capabilityCache.clear();
+}
+export async function detectPronounceCapability(platform = process.platform) {
+    const cached = capabilityCache.get(platform);
+    if (cached) {
+        return cached;
+    }
+    const task = detectCapabilityForPlatform(platform);
+    capabilityCache.set(platform, task);
+    return task;
+}
+export async function speakWord(word, platform = process.platform) {
+    const normalized = word.trim();
+    if (!normalized) {
+        return {
+            status: 'skipped',
+            reason: 'empty-word',
+        };
+    }
+    try {
+        const capability = await detectPronounceCapability(platform);
+        if (capability.status !== 'available' || !capability.speaker || !capability.command) {
+            return {
+                status: 'skipped',
+                reason: capability.reason ?? 'unavailable',
+                detail: capability.detail,
+            };
+        }
+        const args = buildSpeakArgs(capability.speaker, normalized);
+        const outcome = await runCommand(capability.command, args, 12_000);
+        if (outcome.ok) {
+            return { status: 'spoken' };
+        }
+        if (outcome.reason === 'command-not-found') {
+            capabilityCache.delete(platform);
+        }
+        return {
+            status: 'failed',
+            reason: outcome.reason === 'timeout' ? 'timeout' : 'execution-failed',
+            detail: outcome.detail,
+        };
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            reason: 'execution-failed',
+            detail: error?.message ?? String(error),
+        };
+    }
+}

package/dist/lib/review-mode.d.ts

@@ -2,4 +2,3 @@ import type { ReviewMode } from '../types/review.js';
 export declare function parseReviewModeArg(raw: string): ReviewMode;
 export declare function getModeLabel(mode: ReviewMode): 'FORWARD' | 'REVERT' | 'BACKWARD' | 'CHOICE';
 export declare function getModeFlag(mode: ReviewMode): string;
-//# sourceMappingURL=review-mode.d.ts.map

package/dist/lib/review-mode.js

@@ -38,4 +38,3 @@ export function getModeFlag(mode) {
     }
     return 'forward';
 }
-//# sourceMappingURL=review-mode.js.map

package/dist/lib/tty.d.ts

@@ -25,4 +25,3 @@ export declare function moveCursorTop(): void;
  * Clear screen from cursor position to bottom
  */
 export declare function clearScreen(): void;
-//# sourceMappingURL=tty.d.ts.map

package/dist/lib/tty.js

@@ -56,4 +56,3 @@ export function clearScreen() {
     // ANSI full-screen clear avoids stale lines in some TTY implementations.
     process.stdout.write('\u001B[2J');
 }
-//# sourceMappingURL=tty.js.map

package/dist/types/review.d.ts

@@ -10,6 +10,9 @@ export interface TodayReviewVO {
     reviewCount: number;
     intervalDays: number;
     easeFactor: number;
+    correctCount?: number;
+    accuracyRate?: string | null;
+    lastReviewTime?: string | null;
 }
 export interface PagedResponseTodayReviewVO {
     datas?: TodayReviewVO[];
@@ -77,4 +80,3 @@ export interface ApiResponseReviewResponseDto {
     data: ReviewResponseDto;
     timestamp: number;
 }
-//# sourceMappingURL=review.d.ts.map

package/dist/types/review.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=review.js.map