@derekhut/alvy 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import meow from "meow";
+import App from "./app.js";
+const cli = meow(`
+  用法
+    $ alvy           每日学习（3 个词根，每个 5 个单词）
+    $ alvy review    复习已学词根
+    $ alvy stats     导出学习进度
+    $ alvy doctor    检查运行环境
+
+  选项
+    --help    显示帮助信息
+    --version 显示版本号
+`, {
+    importMeta: import.meta,
+});
+const validCommands = new Set(["daily", "review", "stats", "doctor"]);
+const input = cli.input[0];
+const command = input && validCommands.has(input)
+    ? input
+    : input
+        ? (() => {
+            console.error(`Unknown command: ${input}. Run alvy --help for usage.`);
+            process.exit(1);
+        })()
+        : "daily";
+render(_jsx(App, { command: command }));

package/dist/lib/ai.d.ts

@@ -0,0 +1 @@
+export declare function generateMnemonic(_word: string, _root: string): Promise<string>;

package/dist/lib/ai.js

@@ -0,0 +1,5 @@
+// V2 stub — AI-powered features (mnemonics, explore mode)
+// Will use OpenAI client when implemented
+export function generateMnemonic(_word, _root) {
+    return Promise.resolve("Coming in V2");
+}

package/dist/lib/progress.d.ts

@@ -0,0 +1,17 @@
+import type { UserData, RootEntry } from "./types.js";
+/** Count fully studied roots (all 5 words seen) */
+export declare function masteredCount(data: UserData): number;
+/** Count roots that have been started */
+export declare function seenCount(data: UserData): number;
+/** Update streak based on today's date */
+export declare function updateStreak(data: UserData): void;
+/** Add XP */
+export declare function addXP(data: UserData, points?: number): void;
+/** Mark a root as seen and track words studied */
+export declare function markRootSeen(data: UserData, rootKey: string): void;
+/** Mark a word as studied */
+export declare function markWordStudied(data: UserData, rootKey: string, word: string): void;
+/** Select next morphemes for a daily session */
+export declare function selectNextMorphemes(data: UserData, allRoots: RootEntry[], count?: number): RootEntry[];
+/** Generate stats summary as markdown */
+export declare function generateStatsSummary(data: UserData, totalRoots: number): string;

package/dist/lib/progress.js

@@ -0,0 +1,103 @@
+/** Count fully studied roots (all 5 words seen) */
+export function masteredCount(data) {
+    return Object.values(data.rootProgress).filter((p) => p.seen && p.wordsStudied >= 5).length;
+}
+/** Count roots that have been started */
+export function seenCount(data) {
+    return Object.values(data.rootProgress).filter((p) => p.seen).length;
+}
+/** Update streak based on today's date */
+export function updateStreak(data) {
+    const today = new Date().toISOString().slice(0, 10);
+    const lastDate = data.streak.lastDate;
+    if (lastDate === today)
+        return;
+    if (lastDate) {
+        const last = new Date(lastDate);
+        const now = new Date(today);
+        const diffDays = (now.getTime() - last.getTime()) / (1000 * 60 * 60 * 24);
+        data.streak.current = diffDays === 1 ? data.streak.current + 1 : 1;
+    }
+    else {
+        data.streak.current = 1;
+    }
+    data.streak.lastDate = today;
+    if (data.streak.current > data.streak.longest) {
+        data.streak.longest = data.streak.current;
+    }
+}
+/** Add XP */
+export function addXP(data, points = 10) {
+    const today = new Date().toISOString().slice(0, 10);
+    if (data.streak.lastDate !== today) {
+        data.xp.today = 0;
+    }
+    data.xp.total += points;
+    data.xp.today += points;
+}
+/** Mark a root as seen and track words studied */
+export function markRootSeen(data, rootKey) {
+    if (!data.rootProgress[rootKey]) {
+        data.rootProgress[rootKey] = {
+            seen: true,
+            wordsStudied: 0,
+            lastStudied: null,
+        };
+    }
+    else {
+        data.rootProgress[rootKey].seen = true;
+    }
+}
+/** Mark a word as studied */
+export function markWordStudied(data, rootKey, word) {
+    const wordsArr = Array.isArray(data.wordsStudied)
+        ? data.wordsStudied
+        : [...data.wordsStudied];
+    if (!wordsArr.includes(word)) {
+        wordsArr.push(word);
+        data.wordsStudied = wordsArr;
+    }
+    const progress = data.rootProgress[rootKey];
+    if (progress) {
+        progress.wordsStudied = (progress.wordsStudied || 0) + 1;
+        progress.lastStudied = new Date().toISOString().slice(0, 10);
+    }
+}
+/** Select next morphemes for a daily session */
+export function selectNextMorphemes(data, allRoots, count = 3) {
+    // Unseen morphemes first (sequential order)
+    const unseen = allRoots.filter((r) => !data.rootProgress[r.root]?.seen);
+    if (unseen.length > 0) {
+        return unseen.slice(0, count);
+    }
+    // All seen — pick least studied, tie-break by oldest lastStudied
+    const sorted = [...allRoots].sort((a, b) => {
+        const pA = data.rootProgress[a.root];
+        const pB = data.rootProgress[b.root];
+        const studiedA = pA?.wordsStudied ?? 0;
+        const studiedB = pB?.wordsStudied ?? 0;
+        if (studiedA !== studiedB)
+            return studiedA - studiedB;
+        const dateA = pA?.lastStudied ?? "";
+        const dateB = pB?.lastStudied ?? "";
+        return dateA.localeCompare(dateB);
+    });
+    return sorted.slice(0, count);
+}
+/** Generate stats summary as markdown */
+export function generateStatsSummary(data, totalRoots) {
+    const mastered = masteredCount(data);
+    const seen = seenCount(data);
+    const totalWords = Array.isArray(data.wordsStudied)
+        ? data.wordsStudied.length
+        : data.wordsStudied.size;
+    return `# 词根学习进度
+
+- **已掌握:** ${mastered}/${totalRoots} 个词根
+- **已学习:** ${seen}/${totalRoots} 个词根
+- **总经验值:** ${data.xp.total} XP
+- **当前连续天数:** ${data.streak.current} 天
+- **最长连续天数:** ${data.streak.longest} 天
+- **已学单词:** ${totalWords} 个
+`;
+}

package/dist/lib/roots-db.d.ts

@@ -0,0 +1,9 @@
+import type { RootEntry } from "./types.js";
+/** Get all root entries */
+export declare function getAllRoots(): RootEntry[];
+/** Get total number of root entries */
+export declare function getRootCount(): number;
+/** Get a root entry by its key (e.g., "bene-") */
+export declare function getRootByKey(key: string): RootEntry | undefined;
+/** Get meanings map for related roots */
+export declare function getRelatedMeanings(entry: RootEntry): Record<string, string>;

package/dist/lib/roots-db.js

@@ -0,0 +1,25 @@
+import rootsData from "../data/roots.json" with { type: "json" };
+const roots = rootsData;
+/** Get all root entries */
+export function getAllRoots() {
+    return roots;
+}
+/** Get total number of root entries */
+export function getRootCount() {
+    return roots.length;
+}
+/** Get a root entry by its key (e.g., "bene-") */
+export function getRootByKey(key) {
+    return roots.find((r) => r.root === key);
+}
+/** Get meanings map for related roots */
+export function getRelatedMeanings(entry) {
+    const result = {};
+    for (const relatedKey of entry.related) {
+        const related = getRootByKey(relatedKey);
+        if (related) {
+            result[relatedKey] = related.meaning_zh;
+        }
+    }
+    return result;
+}

package/dist/lib/store.d.ts

@@ -0,0 +1,6 @@
+import type { UserData } from "./types.js";
+export declare const DATA_DIR: string;
+export declare const DATA_FILE: string;
+export declare function loadData(): UserData;
+export declare function saveData(data: UserData): void;
+export declare function getDataPath(): string;

package/dist/lib/store.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+export const DATA_DIR = path.join(os.homedir(), ".alvy");
+export const DATA_FILE = path.join(DATA_DIR, "data.json");
+const BACKUP_FILE = path.join(DATA_DIR, "data.backup.json");
+const OLD_DATA_DIR = path.join(os.homedir(), ".toefl-roots");
+const OLD_DATA_FILE = path.join(OLD_DATA_DIR, "data.json");
+function defaultData() {
+    return {
+        streak: { current: 0, longest: 0, lastDate: null },
+        xp: { total: 0, today: 0 },
+        dailyGoal: 3,
+        rootProgress: {},
+        wordsStudied: [],
+    };
+}
+function ensureDir() {
+    if (!fs.existsSync(DATA_DIR)) {
+        fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+}
+function migrateFromOldPath() {
+    if (!fs.existsSync(DATA_FILE) && fs.existsSync(OLD_DATA_FILE)) {
+        fs.copyFileSync(OLD_DATA_FILE, DATA_FILE);
+    }
+}
+export function loadData() {
+    ensureDir();
+    migrateFromOldPath();
+    if (!fs.existsSync(DATA_FILE)) {
+        const data = defaultData();
+        saveData(data);
+        return data;
+    }
+    try {
+        const raw = fs.readFileSync(DATA_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.streak || !parsed.xp || !parsed.rootProgress) {
+            throw new Error("Invalid data structure");
+        }
+        return {
+            ...parsed,
+            wordsStudied: parsed.wordsStudied ?? [],
+        };
+    }
+    catch {
+        if (fs.existsSync(DATA_FILE)) {
+            fs.copyFileSync(DATA_FILE, BACKUP_FILE);
+        }
+        console.error(`警告: data.json 已损坏，已备份至 ${BACKUP_FILE}。重新开始。`);
+        const data = defaultData();
+        saveData(data);
+        return data;
+    }
+}
+export function saveData(data) {
+    ensureDir();
+    const persisted = {
+        streak: data.streak,
+        xp: data.xp,
+        dailyGoal: data.dailyGoal,
+        rootProgress: data.rootProgress,
+        wordsStudied: Array.isArray(data.wordsStudied)
+            ? data.wordsStudied
+            : [...data.wordsStudied],
+    };
+    const json = JSON.stringify(persisted, null, 2);
+    const tmpFile = DATA_FILE + ".tmp";
+    fs.writeFileSync(tmpFile, json, "utf-8");
+    fs.renameSync(tmpFile, DATA_FILE);
+}
+export function getDataPath() {
+    return DATA_FILE;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,39 @@
+export interface RootWord {
+    word: string;
+    breakdown: string;
+    derivation: string;
+    meaning_en: string;
+    meaning_zh: string;
+    example: string;
+    example_zh: string;
+    toefl_frequency: "high" | "medium" | "low";
+}
+export interface RootEntry {
+    root: string;
+    type: "root" | "prefix" | "suffix";
+    meaning_en: string;
+    meaning_zh: string;
+    origin: string;
+    related: string[];
+    words: RootWord[];
+}
+export interface RootProgress {
+    seen: boolean;
+    wordsStudied: number;
+    lastStudied: string | null;
+}
+export interface UserData {
+    streak: {
+        current: number;
+        longest: number;
+        lastDate: string | null;
+    };
+    xp: {
+        total: number;
+        today: number;
+    };
+    dailyGoal: number;
+    rootProgress: Record<string, RootProgress>;
+    wordsStudied: Set<string> | string[];
+}
+export type Command = "daily" | "review" | "stats" | "doctor";

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@derekhut/alvy",
+  "version": "1.0.0",
+  "description": "Terminal-based vocabulary tool — learn English word roots with Chinese translations",
+  "type": "module",
+  "bin": {
+    "alvy": "./dist/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "doctor": "node dist/index.js doctor",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "ink": "^5.1.0",
+    "meow": "^13.2.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.2"
+  }
+}