@qnroa/qtype 0.0.1

package/dist/cli/bootstrap.js

@@ -0,0 +1,190 @@
+/**
+ * One-shot side effect at CLI startup: build the two KvStore instances
+ * (user and repo) and export them.
+ *
+ * ## The two KV instances
+ *
+ * - `userKv` → `~/.config/qtype/config.json` (XDG Base Directory)
+ *   - Holds CLI user preferences (the user layer of cli.* / typing.*)
+ *   - Always available (uses defaults when the file doesn't exist)
+ *
+ * - `repoKv` → `<repo>/.qtype/config.json`
+ *   - Holds repo-bound configuration (the repo layer of repo.* / typing.*)
+ *   - Only available when cwd is inside a qtype repo (detected via `guard`
+ *     checking for the `.qtype/` directory)
+ *
+ * ## Schema (git-style layering)
+ *
+ * Both KVs enable `strict: true` (`qtype config set` needs to reject typo'd keys).
+ * Each key is one of:
+ *   - user-only  → registered on userKv only (cli.*)
+ *   - repo-only  → registered on repoKv only (repo.name)
+ *   - both       → registered on BOTH sides (repo.lang, typing.*).
+ *                  Users can set a global default; individual repos override.
+ *                  Read precedence: repo > user > schema default.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { KvStore, JsonStorage, enumValidator, nonEmptyStringValidator, boolValidator, positiveIntValidator, } from '../store/index.js';
+// ═══════════════════════════════════════════════════════════════
+// Schemas grouped by scope (git-style layering)
+// ═══════════════════════════════════════════════════════════════
+/** user-only: settings tied to the person, not the repo. */
+const userOnlySchema = {
+    // CLI display language. Values are BCP 47 codes; the short forms
+    // `zh` / `en` are accepted for backwards compatibility with older
+    // config files and normalised at read time by the i18n layer.
+    'cli.lang': {
+        validator: enumValidator(['zh-CN', 'en-US', 'zh', 'en']),
+        default: 'en-US',
+    },
+    'cli.color': {
+        validator: enumValidator(['always', 'never', 'auto']),
+        default: 'auto',
+    },
+};
+/** repo-only: settings that only make sense per-repo. */
+const repoOnlySchema = {
+    'repo.name': {
+        validator: nonEmptyStringValidator(),
+    },
+    // ── Password protection for `publish build` ─────────────
+    // On/off toggle. When true, `publish build` reads the other three fields
+    // and encrypts every material/*.md before writing to dist.
+    'publish.password.enabled': {
+        validator: boolValidator(),
+        default: false,
+    },
+    // Argon2id PHC-style hash of the plaintext password, used to verify the
+    // password entered at build time. NOT the AES key — that's derived
+    // separately via `publish.password.aesSalt`. Empty string when protection
+    // is off; shape enforced by `publish password set` writing a well-formed
+    // PHC string.
+    'publish.password.hash': {
+        validator: (v) => typeof v === 'string'
+            ? null
+            : { code: 'err.schema.nonEmptyString', fallback: 'must be a string' },
+        default: '',
+    },
+    // Base64 salt used with argon2id (password → AES-256 key). Rotated only
+    // when the user calls `publish password set` — stable across rebuilds so
+    // the same password unlocks previously published sites.
+    'publish.password.aesSalt': {
+        validator: (v) => typeof v === 'string'
+            ? null
+            : { code: 'err.schema.nonEmptyString', fallback: 'must be a string' },
+        default: '',
+    },
+    // What to encrypt. `all` covers material/ + any future encrypted assets;
+    // `material-only` limits encryption to material/*.md (same behavior in
+    // v0 since qtype has no other content streams).
+    'publish.password.scope': {
+        validator: enumValidator(['all', 'material-only', 'selected']),
+        default: 'all',
+    },
+    // When scope='selected', the list of file names (relative to material/)
+    // to encrypt. Ignored otherwise.
+    'publish.password.selected': {
+        validator: (v) => Array.isArray(v) && v.every((x) => typeof x === 'string')
+            ? null
+            : { code: 'err.schema.nonEmptyString', fallback: 'must be an array of strings' },
+        default: [],
+    },
+};
+/** both: user sets a global default, individual repos override. */
+const bothSchema = {
+    // Repo language. Drives:
+    //   • which template locale (examples/zh vs examples/en) new repos are
+    //     scaffolded from
+    //   • the web UI language — the reader is locked to repo.lang so the UI
+    //     matches the material's own language
+    //
+    // Values are BCP 47 codes (`zh-CN` / `en-US`); the short forms `zh` /
+    // `en` are accepted for backwards compatibility with older `.qtype/
+    // config.json` files and normalised at read time.
+    'repo.lang': {
+        validator: enumValidator(['zh-CN', 'en-US', 'zh', 'en']),
+        default: 'en-US',
+    },
+    'typing.theme': {
+        validator: enumValidator(['mocha', 'latte']),
+        default: 'mocha',
+    },
+    'typing.targetWpm': {
+        validator: positiveIntValidator(),
+    },
+    'typing.tabBehavior': {
+        validator: enumValidator(['reset', 'input', 'disabled']),
+        default: 'reset',
+    },
+    'typing.hint': {
+        validator: enumValidator(['none', 'ghost']),
+        default: 'none',
+    },
+    'typing.showKeyboard': {
+        validator: boolValidator(),
+        default: true,
+    },
+    'typing.showHands': {
+        validator: boolValidator(),
+        default: true,
+    },
+    // Mermaid pre-render mode. `prerender` (default) uses puppeteer at build
+    // time to bake SVGs into dist/material/mermaid.json; `client` ships raw
+    // ```mermaid fences and lets the browser render them; `off` treats mermaid
+    // as plain code blocks.
+    'publish.mermaid': {
+        validator: enumValidator(['prerender', 'client', 'off']),
+        default: 'prerender',
+    },
+};
+// ═══════════════════════════════════════════════════════════════
+// Path resolution
+// ═══════════════════════════════════════════════════════════════
+function userConfigPath() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const base = xdg && xdg.length > 0 ? xdg : path.join(os.homedir(), '.config');
+    return path.join(base, 'qtype', 'config.json');
+}
+/**
+ * Walk upward from cwd to find the nearest `.qtype/` directory. Returns null
+ * if none is found.
+ */
+function findRepoRoot() {
+    let dir = process.cwd();
+    while (true) {
+        if (fs.existsSync(path.join(dir, '.qtype')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+const repoRoot = findRepoRoot();
+const repoConfigPath = path.join(repoRoot ?? process.cwd(), '.qtype', 'config.json');
+export function isInRepo() {
+    return repoRoot !== null;
+}
+export function getRepoRoot() {
+    return repoRoot;
+}
+// ═══════════════════════════════════════════════════════════════
+// User KV: `~/.config/qtype/config.json` (XDG)
+// ═══════════════════════════════════════════════════════════════
+export const userKv = new KvStore(new JsonStorage('user', userConfigPath()), { ...userOnlySchema, ...bothSchema }, { strict: true });
+// ═══════════════════════════════════════════════════════════════
+// Repo KV: `<repo>/.qtype/config.json`
+// ═══════════════════════════════════════════════════════════════
+export const repoKv = new KvStore(new JsonStorage('repo', repoConfigPath, { guard: isInRepo }), { ...repoOnlySchema, ...bothSchema }, { strict: true });
+/**
+ * Build a fresh repo-scoped KvStore pointed at an explicit repo root.
+ * Used by commands that take an explicit `[path]` argument.
+ */
+export function createRepoKv(root) {
+    const absRoot = path.resolve(root);
+    return new KvStore(new JsonStorage('repo', path.join(absRoot, '.qtype', 'config.json'), {
+        guard: () => fs.existsSync(path.join(absRoot, '.qtype')),
+    }), { ...repoOnlySchema, ...bothSchema }, { strict: true });
+}

package/dist/cli/commands/check/action.js

@@ -0,0 +1,56 @@
+/**
+ * `qtype check` action — validate material files without writing anything.
+ *
+ * Reports:
+ *   - Missing `material/` directory (fatal)
+ *   - Cards with non-typable characters (fatal, non-zero exit)
+ *
+ * Exit code: 0 if clean, 1 if any issue was found. Designed to be dropped
+ * into CI before `qtype publish build` so a bad card fails fast rather than
+ * producing a broken site.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { info, success, fatal } from '../../utils/output.js';
+import { ensureQtypeRepo } from '../../utils/repoGuard.js';
+import { t } from '../../i18n/index.js';
+import { parseMaterial } from '../../../core/parser/parseMaterial.js';
+export async function checkAction(opts = {}) {
+    const root = ensureQtypeRepo(opts.repo ?? process.cwd());
+    info(t('check.msg.scanning', { path: root }));
+    const materialDir = path.join(root, 'material');
+    if (!fs.existsSync(materialDir)) {
+        fatal(t('err.dir.notExists', { path: materialDir }));
+    }
+    const files = fs
+        .readdirSync(materialDir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => path.join(materialDir, f));
+    let cardTotal = 0;
+    const bad = [];
+    for (const file of files) {
+        const source = fs.readFileSync(file, 'utf-8');
+        const material = parseMaterial(source, path.relative(root, file));
+        cardTotal += material.cards.length;
+        material.cards.forEach((c, i) => {
+            if (c.unknownChars.length > 0) {
+                bad.push({
+                    file: path.relative(root, file),
+                    card: i + 1,
+                    chars: [...new Set(c.unknownChars)],
+                });
+            }
+        });
+    }
+    console.log('  ' + t('check.msg.summary', { materials: files.length, cards: cardTotal }));
+    if (bad.length > 0) {
+        console.log('\n  ' + t('check.msg.unknownChars', { count: bad.length }));
+        for (const b of bad.slice(0, 30)) {
+            console.log(`  • ${b.file} #${b.card}  →  ${b.chars.join(' ')}`);
+        }
+        if (bad.length > 30)
+            console.log(`  …and ${bad.length - 30} more`);
+        fatal(t('check.msg.failed', { count: bad.length }));
+    }
+    success(t('check.msg.ok'));
+}

package/dist/cli/commands/check/i18n.js

@@ -0,0 +1,26 @@
+export const messages = {
+    'zh-CN': {
+        'check.summary': '校验资料',
+        'check.description': '扫描目录下的 material/*.md，检查卡片格式是否合法',
+        'check.opt.repo': '仓库路径（默认当前目录）',
+        'check.example.basic': '校验当前仓库',
+        'check.example.repo': '校验指定路径',
+        'check.msg.scanning': '校验 {path}',
+        'check.msg.summary': '资料 {materials} · 卡片 {cards}',
+        'check.msg.unknownChars': '含无法练习的字符（{count} 张卡）：',
+        'check.msg.ok': '所有卡片通过校验。',
+        'check.msg.failed': '发现 {count} 个问题，请修复。',
+    },
+    'en-US': {
+        'check.summary': 'Validate materials',
+        'check.description': 'Scan material/*.md in the given directory and report card format issues',
+        'check.opt.repo': 'Repo path (default: current directory)',
+        'check.example.basic': 'Check the current repo',
+        'check.example.repo': 'Check an explicit path',
+        'check.msg.scanning': 'Checking {path}',
+        'check.msg.summary': 'materials {materials} · cards {cards}',
+        'check.msg.unknownChars': 'Non-typable chars ({count} card(s)):',
+        'check.msg.ok': 'All cards passed validation.',
+        'check.msg.failed': 'Found {count} issue(s); please fix.',
+    },
+};

package/dist/cli/commands/check/index.js

@@ -0,0 +1,20 @@
+import { t } from '../../i18n/index.js';
+import { messages } from './i18n.js';
+import { checkAction } from './action.js';
+export const checkCmd = {
+    name: 'check',
+    messages,
+    summary: () => t('check.summary'),
+    describe: () => t('check.description'),
+    options: [
+        { flags: '--repo <path>', describe: () => t('check.opt.repo') },
+    ],
+    examples: () => [
+        { command: 'qtype check', describe: () => t('check.example.basic') },
+        { command: 'qtype check --repo ./my-material', describe: () => t('check.example.repo') },
+    ],
+    seeAlso: ['publish build', 'content lint'],
+    action: async (opts) => {
+        await checkAction({ repo: opts.repo });
+    },
+};

package/dist/cli/commands/config/action.js

@@ -0,0 +1,236 @@
+import { KvError } from '../../../store/index.js';
+import { userKv, repoKv } from '../../bootstrap.js';
+import { info, success, dim, error } from '../../utils/output.js';
+import { t } from '../../i18n/index.js';
+/** --global / --local are mutually exclusive; returns the explicitly-specified scope (neither given → undefined). */
+function pickScope(opts) {
+    if (opts.global && opts.local) {
+        throw new KvError('err.config.scope.conflict', {}, '--global and --local are mutually exclusive');
+    }
+    if (opts.global)
+        return 'user';
+    if (opts.local)
+        return 'repo';
+    return undefined;
+}
+/** Pick the KvStore for a given scope. */
+function kvFor(scope) {
+    return scope === 'user' ? userKv : repoKv;
+}
+/**
+ * Decide which KV to write to (used by set).
+ *
+ * - Explicit `--global` / `--local` → corresponding KV
+ * - Neither given → check which KV the schema is registered in:
+ *   - Only in userKv → userKv
+ *   - Only in repoKv → repoKv
+ *   - In both (view.*) → default to repoKv (if available), else userKv
+ *   - In neither → strict mode will throw unknown key inside set()
+ */
+async function resolveWriteScope(key, explicit) {
+    if (explicit)
+        return explicit;
+    const inUser = userKv.getSchema(key) !== undefined;
+    const inRepo = repoKv.getSchema(key) !== undefined;
+    if (inUser && !inRepo)
+        return 'user';
+    if (inRepo && !inUser)
+        return 'repo';
+    if (inUser && inRepo) {
+        // both-scope key: prefer repo; fall back to user if repo unavailable
+        return (await repoKv.available()) ? 'repo' : 'user';
+    }
+    // Neither side has it: default to repo, let strict throw unknown key;
+    // if repo is unavailable, give user instead
+    return (await repoKv.available()) ? 'repo' : 'user';
+}
+// ═══════════════════════════════════════════════════════════════
+// get
+// ═══════════════════════════════════════════════════════════════
+/** `qtype config get <key>` */
+export async function configGetAction(key, opts) {
+    const scope = pickScope(opts);
+    if (opts.showOrigin) {
+        await showOrigin(key, scope);
+        return;
+    }
+    if (scope) {
+        // Single-layer lookup
+        const kv = kvFor(scope);
+        const has = await kv.has(key);
+        if (!has) {
+            const def = kv.getSchema(key)?.default;
+            if (def === undefined) {
+                error(t('config.get.msg.notSetScoped', { key, scope }));
+                process.exit(1);
+            }
+            console.log(formatValue(def));
+            return;
+        }
+        const v = await kv.get(key);
+        console.log(formatValue(v));
+        return;
+    }
+    // Merged lookup: repo first, fall back to user, then to schema default
+    const fromRepo = (await repoKv.available()) && (await repoKv.has(key));
+    if (fromRepo) {
+        console.log(formatValue(await repoKv.get(key)));
+        return;
+    }
+    const fromUser = await userKv.has(key);
+    if (fromUser) {
+        console.log(formatValue(await userKv.get(key)));
+        return;
+    }
+    // Fall back to default: repo schema first, then user
+    const def = repoKv.getSchema(key)?.default ?? userKv.getSchema(key)?.default;
+    if (def === undefined) {
+        error(t('config.get.msg.notSet', { key }));
+        process.exit(1);
+    }
+    console.log(formatValue(def));
+}
+async function showOrigin(key, scope) {
+    const inRepo = (await repoKv.available()) && (await repoKv.has(key));
+    const inUser = await userKv.has(key);
+    if (scope === 'user') {
+        if (!inUser) {
+            error(t('config.get.msg.notSetScoped', { key, scope: 'user' }));
+            process.exit(1);
+        }
+        console.log(formatValue(await userKv.get(key)));
+        console.error(`  ${dim('from:')} ${userKv.origin} (user)`);
+        return;
+    }
+    if (scope === 'repo') {
+        if (!inRepo) {
+            error(t('config.get.msg.notSetScoped', { key, scope: 'repo' }));
+            process.exit(1);
+        }
+        console.log(formatValue(await repoKv.get(key)));
+        console.error(`  ${dim('from:')} ${repoKv.origin} (repo)`);
+        return;
+    }
+    // Merged mode: repo first
+    if (inRepo) {
+        console.log(formatValue(await repoKv.get(key)));
+        console.error(`  ${dim('from:')} ${repoKv.origin} (repo)`);
+        if (inUser) {
+            console.error(`  ${dim('overridden by:')} ${userKv.origin} (user) = ${formatValue(await userKv.get(key))}`);
+        }
+        return;
+    }
+    if (inUser) {
+        console.log(formatValue(await userKv.get(key)));
+        console.error(`  ${dim('from:')} ${userKv.origin} (user)`);
+        return;
+    }
+    error(t('config.get.msg.notSet', { key }));
+    process.exit(1);
+}
+// ═══════════════════════════════════════════════════════════════
+// set
+// ═══════════════════════════════════════════════════════════════
+/** `qtype config set <key> <value>` */
+export async function configSetAction(key, value, opts) {
+    const explicit = pickScope(opts);
+    const target = await resolveWriteScope(key, explicit);
+    const kv = kvFor(target);
+    // Explicit scope but schema is not in this KV: emit a precise error message
+    if (explicit && kv.getSchema(key) === undefined) {
+        const other = explicit === 'user' ? 'repo' : 'user';
+        const otherHas = (other === 'user' ? userKv : repoKv).getSchema(key) !== undefined;
+        if (otherHas) {
+            throw new KvError('err.config.scope.violation', { name: key, allowed: other, attempted: explicit }, `'${key}' is ${other}-only, cannot write to ${explicit} scope`);
+        }
+        // Otherwise fall through to strict's unknown key path (thrown inside kv.set)
+    }
+    await kv.set(key, value);
+    success(`${key} = ${value}`);
+    console.log(`  ${dim('written to')} ${kv.origin} (${target})`);
+}
+// ═══════════════════════════════════════════════════════════════
+// unset
+// ═══════════════════════════════════════════════════════════════
+/** `qtype config unset <key>` */
+export async function configUnsetAction(key, opts) {
+    const explicit = pickScope(opts);
+    let target;
+    if (explicit) {
+        target = explicit;
+    }
+    else {
+        const inUser = await userKv.has(key);
+        const inRepo = (await repoKv.available()) && (await repoKv.has(key));
+        if (inUser && inRepo) {
+            throw new KvError('err.config.unset.ambiguous', { raw: key }, `'${key}' exists in both user and repo scopes; use --global or --local to disambiguate`);
+        }
+        target = inRepo ? 'repo' : 'user';
+    }
+    const kv = kvFor(target);
+    const removed = await kv.delete(key);
+    if (!removed) {
+        info(t('config.unset.msg.notSet', { key, scope: target }));
+        return;
+    }
+    success(t('config.unset.msg.removed', { key, scope: target }));
+    console.log(`  ${dim('at')} ${kv.origin}`);
+}
+// ═══════════════════════════════════════════════════════════════
+// list
+// ═══════════════════════════════════════════════════════════════
+/** `qtype config list [--global|--local] [--show-origin]` */
+export async function configListAction(opts) {
+    const scope = pickScope(opts);
+    const userEntries = scope === 'repo' ? [] : await userKv.list();
+    const repoEntries = scope === 'user' ? [] : (await repoKv.available()) ? await repoKv.list() : [];
+    const rows = [];
+    if (scope === 'user') {
+        for (const [k, v] of userEntries) {
+            rows.push({ key: k, value: v, scope: 'user', origin: userKv.origin });
+        }
+    }
+    else if (scope === 'repo') {
+        for (const [k, v] of repoEntries) {
+            rows.push({ key: k, value: v, scope: 'repo', origin: repoKv.origin });
+        }
+    }
+    else {
+        // merged: repo overrides user
+        const repoKeys = new Set(repoEntries.map(([k]) => k));
+        for (const [k, v] of userEntries) {
+            if (!repoKeys.has(k)) {
+                rows.push({ key: k, value: v, scope: 'user', origin: userKv.origin });
+            }
+        }
+        for (const [k, v] of repoEntries) {
+            rows.push({ key: k, value: v, scope: 'repo', origin: repoKv.origin });
+        }
+    }
+    if (rows.length === 0) {
+        info(t(scope ? 'config.list.msg.emptyScoped' : 'config.list.msg.empty', { scope: scope ?? '' }));
+        return;
+    }
+    rows.sort((a, b) => a.key.localeCompare(b.key));
+    for (const r of rows) {
+        if (opts.showOrigin) {
+            console.log(`${r.key}=${formatValue(r.value)}\t${dim(`${r.scope}:${r.origin}`)}`);
+        }
+        else {
+            console.log(`${r.key}=${formatValue(r.value)}`);
+        }
+    }
+}
+// ═══════════════════════════════════════════════════════════════
+// helpers
+// ═══════════════════════════════════════════════════════════════
+/** Format a value as a single-line string. Objects / arrays use JSON. */
+function formatValue(v) {
+    if (v == null)
+        return '';
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return JSON.stringify(v);
+}

package/dist/cli/commands/config/i18n.js

@@ -0,0 +1,64 @@
+export const messages = {
+    'zh-CN': {
+        'config.summary': '配置管理',
+        'config.description': '读写 qtype 配置：user 层（~/.config/qtype/）+ repo 层（<repo>/.qtype/），git 风格 --global / --local 切换',
+        'config.arg.key': '配置 key，格式 <section>.<name>，如 cli.lang',
+        'config.arg.value': '配置值',
+        'config.opt.global': '操作 user 层（~/.config/qtype/config.json）',
+        'config.opt.local': '操作 repo 层（<repo>/.qtype/config.json）',
+        'config.opt.showOrigin': '显示配置项来源（文件路径 / 哪一层）',
+        'config.example.setLang': '设置 CLI 语言',
+        'config.example.list': '列出所有生效配置',
+        'config.get.summary': '读配置',
+        'config.get.description': '读取指定 key 的值（默认合并两层；key 不存在 exit 1）',
+        'config.get.example.basic': '读 CLI 语言偏好',
+        'config.get.example.origin': '看值从哪一层来',
+        'config.get.msg.notSet': "'{key}' 未设置",
+        'config.get.msg.notSetScoped': "'{key}' 在 {scope} 层未设置",
+        'config.set.summary': '写配置',
+        'config.set.description': '写入 key=value；不加 flag 时按 section scope 决定写哪层',
+        'config.set.example.user': '写 user 层（cli 是 user-only）',
+        'config.set.example.local': '写当前仓库的 repo 层',
+        'config.unset.summary': '删配置',
+        'config.unset.description': '移除某个配置项',
+        'config.unset.msg.notSet': '{key} 未设置（{scope}），无需操作',
+        'config.unset.msg.removed': '已从 {scope} 移除 {key}',
+        'config.list.summary': '列配置',
+        'config.list.description': '列出所有已设置的配置项',
+        'config.list.example.merged': '合并两层，展示生效值',
+        'config.list.example.global': '只看 user 层',
+        'config.list.msg.empty': '配置为空',
+        'config.list.msg.emptyScoped': '配置为空 ({scope})',
+    },
+    'en-US': {
+        'config.summary': 'Manage config',
+        'config.description': 'Read / write qtype config: user layer (~/.config/qtype/) + repo layer (<repo>/.qtype/), git-style --global / --local',
+        'config.arg.key': 'Config key, format <section>.<name>, e.g. cli.lang',
+        'config.arg.value': 'Config value',
+        'config.opt.global': 'Operate on user scope (~/.config/qtype/config.json)',
+        'config.opt.local': 'Operate on repo scope (<repo>/.qtype/config.json)',
+        'config.opt.showOrigin': 'Show where each entry comes from (file path and scope)',
+        'config.example.setLang': 'Set CLI language',
+        'config.example.list': 'List all effective config',
+        'config.get.summary': 'Get value',
+        'config.get.description': 'Get value for a key (merged by default; exit 1 if key not set)',
+        'config.get.example.basic': 'Read CLI language preference',
+        'config.get.example.origin': 'See which layer the value comes from',
+        'config.get.msg.notSet': "'{key}' is not set",
+        'config.get.msg.notSetScoped': "'{key}' is not set in {scope} scope",
+        'config.set.summary': 'Set value',
+        'config.set.description': 'Write key=value; layer is decided by section scope when no flag is given',
+        'config.set.example.user': 'Write user scope (cli is user-only)',
+        'config.set.example.local': 'Write the current repo scope',
+        'config.unset.summary': 'Remove entry',
+        'config.unset.description': 'Remove a config entry',
+        'config.unset.msg.notSet': '{key} not set ({scope}); nothing to do',
+        'config.unset.msg.removed': 'Removed {key} from {scope}',
+        'config.list.summary': 'List entries',
+        'config.list.description': 'List all configured entries',
+        'config.list.example.merged': 'Merged view, effective values',
+        'config.list.example.global': 'Only user scope',
+        'config.list.msg.empty': 'Config is empty',
+        'config.list.msg.emptyScoped': 'Config is empty ({scope})',
+    },
+};

package/dist/cli/commands/config/index.js

@@ -0,0 +1,72 @@
+import { t } from '../../i18n/index.js';
+import { messages } from './i18n.js';
+import { configGetAction, configSetAction, configUnsetAction, configListAction, } from './action.js';
+/** Shared --global / --local / --show-origin options. */
+const scopeOptions = [
+    { flags: '--global', describe: () => t('config.opt.global') },
+    { flags: '--local', describe: () => t('config.opt.local') },
+];
+const getCmd = {
+    name: 'get',
+    summary: () => t('config.get.summary'),
+    describe: () => t('config.get.description'),
+    args: [{ flag: '<key>', describe: () => t('config.arg.key') }],
+    options: [
+        ...scopeOptions,
+        { flags: '--show-origin', describe: () => t('config.opt.showOrigin') },
+    ],
+    examples: () => [
+        { command: 'qtype config get cli.lang', describe: () => t('config.get.example.basic') },
+        { command: 'qtype config get repo.lang --show-origin', describe: () => t('config.get.example.origin') },
+    ],
+    action: async (key, opts) => configGetAction(key, opts),
+};
+const setCmd = {
+    name: 'set',
+    summary: () => t('config.set.summary'),
+    describe: () => t('config.set.description'),
+    args: [
+        { flag: '<key>', describe: () => t('config.arg.key') },
+        { flag: '<value>', describe: () => t('config.arg.value') },
+    ],
+    options: scopeOptions,
+    examples: () => [
+        { command: 'qtype config set cli.lang zh', describe: () => t('config.set.example.user') },
+        { command: 'qtype config set repo.lang en', describe: () => t('config.set.example.local') },
+    ],
+    action: async (key, value, opts) => configSetAction(key, value, opts),
+};
+const unsetCmd = {
+    name: 'unset',
+    summary: () => t('config.unset.summary'),
+    describe: () => t('config.unset.description'),
+    args: [{ flag: '<key>', describe: () => t('config.arg.key') }],
+    options: scopeOptions,
+    action: async (key, opts) => configUnsetAction(key, opts),
+};
+const listCmd = {
+    name: 'list',
+    aliases: ['ls'],
+    summary: () => t('config.list.summary'),
+    describe: () => t('config.list.description'),
+    options: [
+        ...scopeOptions,
+        { flags: '--show-origin', describe: () => t('config.opt.showOrigin') },
+    ],
+    examples: () => [
+        { command: 'qtype config list', describe: () => t('config.list.example.merged') },
+        { command: 'qtype config list --global', describe: () => t('config.list.example.global') },
+    ],
+    action: async (opts) => configListAction(opts),
+};
+export const configCmd = {
+    name: 'config',
+    messages,
+    summary: () => t('config.summary'),
+    describe: () => t('config.description'),
+    examples: () => [
+        { command: 'qtype config set cli.lang zh', describe: () => t('config.example.setLang') },
+        { command: 'qtype config list', describe: () => t('config.example.list') },
+    ],
+    subcommands: [getCmd, setCmd, unsetCmd, listCmd],
+};