@askdkc/dsh-cli 0.11.7 → 0.12.0

package/node_modules/dsh-working-activity/lib/types/lang.js

@@ -0,0 +1,209 @@
+/**
+ * Language resolution + copy dictionary for the working-activity plugin.
+ *
+ * The plugin follows the dsh-tui UI language without importing it: the same
+ * chain dsh-tui resolves (`DSH_TUI_LANG` env → `~/.dsh-tui/lang.json` → OS
+ * locale → zh) is read here directly, so a `/lang en|zh` switch (or the
+ * /settings language pick) hot-swaps this plugin's narration and status-line
+ * copy on the next render tick.
+ *
+ * Resolution order:
+ *   1. `setLangOverride()` — a plugin-level `lang: zh|en` config key
+ *      (cordis.yml) or an explicit test pin.
+ *   2. `DSH_TUI_LANG` env var — pinned at process start.
+ *   3. `~/.dsh-tui/lang.json` — the persisted dsh-tui choice, mtime-cached
+ *      so the per-tick status render never re-reads an unchanged file.
+ *   4. OS locale guess (`LC_ALL` / `LC_MESSAGES` / `LANG`); POSIX/C means
+ *      "no locale selected" and maps to English.
+ *   5. `zh` — the original hard-coded language.
+ *
+ * The dictionary is a flat key → per-language string map; `t(key, params)`
+ * substitutes `{{name}}` placeholders. Missing keys render the key itself so
+ * a typo is visible instead of silently blank.
+ * @module @deepseek-ai/dsh-working-activity/lang
+ */
+import { readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** The languages shipped with the plugin, in display order. */
+export const LANGS = ['zh', 'en', 'ja'];
+const progressLanguage = new AsyncLocalStorage();
+/** Scope a rendered status line to its own session without changing the UI language. */
+export function withProgressLang(lang, render) {
+    return progressLanguage.run(lang, render);
+}
+/** Use the terminal locale only for the first ambiguous prompt in a session. */
+export function terminalProgressLang() {
+    const locale = (process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || '').toLowerCase();
+    if (locale.startsWith('ja'))
+        return 'ja';
+    if (locale.startsWith('zh'))
+        return 'zh';
+    return 'en';
+}
+/** Detect only confident language signals in user-authored prose. */
+export function detectInputLanguage(input) {
+    const prose = input.normalize('NFKC')
+        .replace(/```[\s\S]*?(?:```|$)/g, ' ')
+        .replace(/`[^`]*`/g, ' ')
+        .replace(/^\s*>.*$/gm, ' ')
+        .replace(/\b(?:https?|file):\/\/\S+/gi, ' ')
+        .replace(/(?:^|\s)(?:[A-Za-z]:\\|\/|\.\.?\/)[^\s]+/g, ' ');
+    if (/[\p{Script=Hiragana}\p{Script=Katakana}]/u.test(prose))
+        return 'ja';
+    const han = prose.match(/\p{Script=Han}/gu)?.length ?? 0;
+    const latin = prose.match(/[A-Za-z]/g)?.length ?? 0;
+    if (han >= 4 && han > latin)
+        return 'zh';
+    if ((prose.match(/\b[A-Za-z]+(?:'[A-Za-z]+)?\b/g)?.length ?? 0) >= 3)
+        return 'en';
+    return undefined;
+}
+/** The dsh-tui prefs file this plugin mirrors (shared language contract). */
+const LANG_FILE = join(homedir(), '.dsh-tui', 'lang.json');
+const dict = {
+    // ── ⏵ self-narration contract (system prompt, /lang aware) ──────────
+    'narrate-instruction': {
+        zh: '[状态栏] 你有一个状态栏展示给用户。【必须】在每个步骤/子任务开始时（不只是调用工具前），在回复正文的最前面单独写一行：⏵ 你在做的具体事情（不超过20字），然后换行继续正常回复。整轮回复只写一行 ⏵，不要重复。信息为主——让人一眼知道你在干什么，风格自然、可以带点俏皮。例：⏵ 修复登录页样式、⏵ 查一下报错原因、⏵ 给补丁跑个验证。切换任务时必须更新。',
+        en: '[Status line] You have a status line visible to the user. [Required] At the start of each step or subtask (not only before tool calls), write exactly one standalone line at the very beginning of your response: ⏵ a concrete description of what you are doing (20 words max), then continue with the normal response on the next line. Write only one ⏵ line per response and do not repeat it. Prioritize information so the user can understand the current work at a glance; keep the style natural and optionally playful. Examples: ⏵ Fixing the login page styles, ⏵ Investigating the error, ⏵ Running validation for the patch. Update it when the task changes.',
+    },
+    // ── status-line structural copy ─────────────────────────────────────
+    /** Plain (non-playful) phase labels. */
+    'waiting-label': { zh: '等待模型响应', en: 'Waiting for model', ja: 'モデルの応答待ち' },
+    'thinking-label': { zh: '思考中', en: 'Thinking', ja: '考えています' },
+    /** Elapsed suffix: zh glues the char, en keeps a space. */
+    'line-elapsed': { zh: '总{{elapsed}}', en: 'total {{elapsed}}', ja: '合計 {{elapsed}}' },
+    /** Plain-mode completion prefix (playful pools pick their own). */
+    'done-prefix': { zh: '搞定 ✓', en: 'Finished', ja: '完了 ✓' },
+    /** Turn-completion summary. */
+    'done-summary': {
+        zh: '{{tools}} · 想{{thinking}} 干{{tooling}}',
+        en: '{{tools}} · thought {{thinking}} worked {{tooling}}',
+        ja: '{{tools}} · 思考 {{thinking}} 作業 {{tooling}}',
+    },
+    'tool-count-one': { zh: '{{count}} 工具', en: '{{count}} tool', ja: 'ツール {{count}} 件' },
+    'tool-count-many': { zh: '{{count}} 工具', en: '{{count}} tools', ja: 'ツール {{count}} 件' },
+    /** Consecutive-tool streak badge (replaces the old flame emoji). */
+    'tool-streak': { zh: '工具x{{count}}', en: 'tool x{{count}}', ja: 'ツール連続 {{count}} 件' },
+    /** Approval badge while a tool is parked on the user's decision. */
+    'tool-waiting-approval': { zh: '在等你批准', en: 'awaiting your approval', ja: '承認待ち' },
+    /** Subagent count in the done summary. */
+    'subagent-count': { zh: '子代理 {{count}} 个', en: '{{count}} subagents', ja: 'サブエージェント {{count}} 件' },
+    /** Work-reminder copy after `workRemindAt` turn-hours. */
+    'work-remind': { zh: '已连续工作 {{hours}} 小时，歇会儿？', en: 'Worked {{hours}}h straight — take a break?', ja: '{{hours}} 時間続けて作業しています。少し休みますか？' },
+};
+/** Explicit pin set by plugin config or tests; `auto` restores the chain. */
+let override = 'auto';
+/** Force (or release) the active language; `auto` re-enables the chain. */
+export function setLangOverride(lang) {
+    override = lang;
+    // Releasing (or re-setting) the pin decides the language from the file again,
+    // and an explicit switch must not wait out the probe TTL.
+    invalidateLangCache();
+}
+/** The currently active language. */
+export function langNow() {
+    const scoped = progressLanguage.getStore();
+    if (scoped !== undefined)
+        return scoped;
+    if (override !== 'auto')
+        return override;
+    const env = process.env.DSH_TUI_LANG;
+    if (env === 'zh' || env === 'en')
+        return env;
+    return readLangFile() ?? detectLocaleLang();
+}
+/** Translate a dictionary key, substituting `{{name}}` placeholders. */
+export function t(key, params = {}) {
+    const entry = dict[key];
+    const template = entry?.[langNow()] ?? entry?.en ?? key;
+    return template.replace(/\{\{(\w+)\}\}/g, (match, name) => name in params ? String(params[name]) : match);
+}
+/** Is a value a valid shipped language code? */
+export function isLang(value) {
+    return value === 'zh' || value === 'en' || value === 'ja';
+}
+/**
+ * How long one filesystem probe is trusted. Long enough that a 500 ms status
+ * render does not stat the file on every translation, short enough that a
+ * `/lang` switch written by the UI still lands within a second.
+ */
+const LANG_FILE_PROBE_TTL_MS = 1000;
+/**
+ * Read the persisted dsh-tui language choice.
+ *
+ * The probe is cached twice over: the parsed value is reused while the file's
+ * mtime is unchanged, and even the `statSync` itself is skipped for
+ * {@link LANG_FILE_PROBE_TTL_MS}. Both halves matter — one render translates
+ * several keys, and a host that never wrote the file would otherwise pay a
+ * FAILED stat on every one of them (issue #14).
+ *
+ * @param nowMs - Instant to measure the probe cache against.
+ * @returns the persisted language, or `undefined` when the file is absent or
+ * holds no valid `{ lang }` value.
+ */
+export function readLangFile(nowMs = Date.now()) {
+    if (lastProbeAt !== 0 && nowMs - lastProbeAt < LANG_FILE_PROBE_TTL_MS)
+        return cachedLang;
+    lastProbeAt = nowMs;
+    let mtimeMs;
+    try {
+        mtimeMs = statSync(LANG_FILE).mtimeMs;
+    }
+    catch {
+        // Absence is cached like any other answer: the common case on a host that
+        // never ran the UI's language picker.
+        cachedMtime = -1;
+        cachedLang = undefined;
+        return undefined;
+    }
+    if (cachedMtime === mtimeMs)
+        return cachedLang;
+    try {
+        const parsed = JSON.parse(readFileSync(LANG_FILE, 'utf8'));
+        const lang = parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed.lang
+            : undefined;
+        cachedLang = isLang(lang) ? lang : undefined;
+    }
+    catch {
+        cachedLang = undefined;
+    }
+    cachedMtime = mtimeMs;
+    return cachedLang;
+}
+/**
+ * Drop the file cache so the next read probes the filesystem immediately.
+ * Called whenever the language is pinned explicitly, so a switch is never
+ * delayed by the probe TTL.
+ */
+export function invalidateLangCache() {
+    lastProbeAt = 0;
+    cachedMtime = -1;
+    cachedLang = undefined;
+}
+let cachedMtime = -1;
+let cachedLang;
+/** When the file was last probed; `0` means "never probed in this process". */
+let lastProbeAt = 0;
+/**
+ * Guess the language from the OS locale (`LC_ALL`, `LC_MESSAGES`, `LANG`),
+ * defaulting to `zh`. POSIX/C means "no locale selected" and conventionally
+ * maps to English (what CI runners report). An absent locale variable
+ * (typical on Windows) defaults to `zh`.
+ */
+export function detectLocaleLang() {
+    const raw = process.env.LC_ALL ||
+        process.env.LC_MESSAGES ||
+        process.env.LANG ||
+        '';
+    const locale = raw.split('.')[0]?.toLowerCase() ?? '';
+    if (locale.startsWith('zh'))
+        return 'zh';
+    if (locale.startsWith('en'))
+        return 'en';
+    if (locale === 'c' || locale === 'posix')
+        return 'en';
+    return 'zh';
+}

package/node_modules/dsh-working-activity/lib/types/phrases.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Copy pools for the working-activity status line: short, colloquial, playful
+ * fragments with a "live person" vibe, in both Chinese and English. The zh
+ * pools are the original copy; the en pools mirror the same tone — deadpan,
+ * meme-y, occasionally unhinged. Everything here is pure data + pure pickers;
+ * the active language is resolved per pick via `langNow()`.
+ * @module @deepseek-ai/dsh-working-activity/phrases
+ */
+import type { WaitingReason } from './activity-event.js';
+/** A pool of copy fragments. */
+export type PhrasePool = readonly string[];
+/** Pick one random entry; repeated draws avoid the previous entry when possible. */
+export declare function pickPhrase(entries: PhrasePool, previous?: string): string;
+/** A rotation window: the turn's seed, and which window of it. */
+export interface PhraseSlot {
+    readonly seed: number;
+    readonly slot: number;
+}
+/**
+ * Deterministic 32-bit mix of a seed and a window index (avalanche, then mask).
+ *
+ * The point is reproducibility, not cryptography: the same inputs must always
+ * produce the same value, so a reader may re-derive a phrase as often as it
+ * likes without the copy moving under it.
+ */
+export declare function mixSlot(seed: number, slot: number): number;
+/**
+ * Deterministic sibling of {@link pickPhrase}.
+ *
+ * The projected line is READ far more often than it is written — a client ticks
+ * it, the host validates it, a checkpoint may re-render it — so picking at
+ * random inside a read makes the copy churn on every read (measured: three
+ * different phrases across three consecutive 500 ms reads). This picks by
+ * position instead: one phrase per window, always the same phrase for the same
+ * window, and adjacent windows differ.
+ * @param entries - The pool to draw from.
+ * @param seed - Per-turn seed (the turn's start time), so turns differ.
+ * @param slot - Rotation window index within the phase.
+ */
+export declare function pickPhraseAt(entries: PhrasePool, seed: number, slot: number): string;
+/** Thinking phrases while the model works without a tool. */
+export declare const THINKING_PHRASES: readonly string[];
+/** Tiered phrases when thinking runs long (elapsed >= threshold). */
+export declare const THINKING_TIERS: readonly {
+    /** Minimum thinking ms for this tier. */
+    readonly atMs: number;
+    readonly pool: readonly string[];
+}[];
+/** Phrases shown while waiting for the first streamed token. */
+export declare const WAITING_PHRASES: readonly string[];
+/** Tool-name patterns mapped to playful action verbs. */
+export declare const ACTION_MAP: readonly {
+    readonly test: RegExp;
+    readonly actions: readonly string[];
+}[];
+/** Fallback verbs for unknown tools. */
+export declare const FALLBACK_ACTIONS: readonly string[];
+/** Tool failure phrases, replacing a bare ✗. */
+export declare const FAIL_PHRASES: readonly string[];
+/** Turn-completion phrases. */
+export declare const DONE_PHRASES: readonly string[];
+/** Night-owl phrases mixed in between 00:00 and 06:00 local time. */
+export declare const NIGHT_PHRASES: readonly string[];
+/** English thinking phrases — casual, meme-y, alive. */
+export declare const EN_THINKING_PHRASES: readonly string[];
+/** English tiered phrases when thinking runs long. */
+export declare const EN_THINKING_TIERS: readonly {
+    readonly atMs: number;
+    readonly pool: readonly string[];
+}[];
+/** English phrases while waiting for the first token. */
+export declare const EN_WAITING_PHRASES: readonly string[];
+/** English tool-name → action verbs. */
+export declare const EN_ACTION_MAP: readonly {
+    readonly test: RegExp;
+    readonly actions: readonly string[];
+}[];
+/** English fallback verbs for unknown tools. */
+export declare const EN_FALLBACK_ACTIONS: readonly string[];
+/** English tool failure phrases. */
+export declare const EN_FAIL_PHRASES: readonly string[];
+/** English turn-completion phrases. */
+export declare const EN_DONE_PHRASES: readonly string[];
+/** English night-owl phrases. */
+export declare const EN_NIGHT_PHRASES: readonly string[];
+/** Rare easter-egg phrases (1/150 draw, pi `RARE_PHRASES`). */
+export declare const RARE_PHRASES: readonly string[];
+/** English rare easter-egg phrases. */
+export declare const EN_RARE_PHRASES: readonly string[];
+/** Chance of drawing a rare phrase per thinking rotation. */
+export declare const RARE_CHANCE: number;
+/** Weekend-greeting phrases (once per turn on Sat/Sun). */
+export declare const WEEKEND_PHRASES: readonly string[];
+/** English weekend greetings. */
+export declare const EN_WEEKEND_PHRASES: readonly string[];
+/** Whether `date` falls on a weekend. */
+export declare function isWeekend(date: Date): boolean;
+/** Holiday copy keyed by `MM-DD` (zh). */
+export declare const HOLIDAY_PHRASES: Readonly<Record<string, readonly string[]>>;
+/** English holiday copy keyed by `MM-DD`. */
+export declare const EN_HOLIDAY_PHRASES: Readonly<Record<string, readonly string[]>>;
+/** Lunar New Year copy (approximated by Gregorian dates, extended yearly). */
+export declare const LUNAR_NEW_YEAR_PHRASES: readonly string[];
+/** English Lunar New Year copy. */
+export declare const EN_LUNAR_NEW_YEAR_PHRASES: readonly string[];
+/**
+ * Gregorian dates marked as Lunar New Year (2025–2030, extend yearly).
+ *
+ * Each year lists the seven-day holiday block starting at the new moon.
+ * `tests/easter-eggs.spec.ts` fails when the table no longer covers the
+ * current year + 1, so an expired table goes red in CI instead of silently
+ * stopping the egg.
+ */
+export declare const LUNAR_NEW_YEAR_DAYS: Readonly<Record<string, true>>;
+/** Phrases shown after the user interrupts and the model resumes. */
+export declare const CONTINUE_PHRASES: readonly string[];
+/** English post-interruption phrases. */
+export declare const EN_CONTINUE_PHRASES: readonly string[];
+/** Phrases after a successful context compaction. */
+export declare const COMPACT_PHRASES: readonly string[];
+/** English post-compaction phrases. */
+export declare const EN_COMPACT_PHRASES: readonly string[];
+/** Urgent phrases when compaction is forced by overflow. */
+export declare const OVERFLOW_PHRASES: readonly string[];
+/** English overflow phrases. */
+export declare const EN_OVERFLOW_PHRASES: readonly string[];
+/** Phrases when retrying after a forced compaction. */
+export declare const COMPACT_RETRY_PHRASES: readonly string[];
+/** English compact-retry phrases. */
+export declare const EN_COMPACT_RETRY_PHRASES: readonly string[];
+/**
+ * Phrases while the provider asked for a retry (rate limit / transient error).
+ * The waiting pool cannot say this: "still queuing" reads as the model's own
+ * latency, while a retry is the provider pushing back.
+ */
+export declare const RETRY_PHRASES: readonly string[];
+/** English retry phrases. */
+export declare const EN_RETRY_PHRASES: readonly string[];
+/** Phrases while a tool is parked on the user's approval. */
+export declare const APPROVAL_PHRASES: readonly string[];
+/** English approval phrases. */
+export declare const EN_APPROVAL_PHRASES: readonly string[];
+/** Phrases while the host is compacting the context. */
+export declare const COMPACTION_START_PHRASES: readonly string[];
+/** English compaction-in-progress phrases. */
+export declare const EN_COMPACTION_START_PHRASES: readonly string[];
+/**
+ * Pick the copy for one waiting reason, in the active language.
+ *
+ * Deterministic per stall: the caller seeds the draw with the turn and the
+ * stall's start, so repeated reads of one stall show one line (a per-read
+ * re-roll is the flicker bug this module's slot scheme exists to prevent).
+ * @param reason - Why the turn is stalled.
+ * @param at - Slot (seed + window) making the pick reproducible.
+ */
+export declare function waitingReasonPhrase(reason: WaitingReason, at?: PhraseSlot): string;
+/** Model-switch quips keyed by a lowercase substring of the model id. */
+export declare const MODEL_QUIPS: Readonly<Record<string, readonly string[]>>;
+/** English model-switch quips. */
+export declare const EN_MODEL_QUIPS: Readonly<Record<string, readonly string[]>>;
+/** Detect a holiday for `date`, Lunar New Year first. */
+export declare function holidayPhrase(date: Date, at?: PhraseSlot): string | null;
+/** Pick a rare easter-egg phrase in the active language. */
+export declare function rarePhrase(previous?: string, at?: PhraseSlot): string;
+/** Pick a weekend greeting in the active language. */
+export declare function weekendPhrase(previous?: string, at?: PhraseSlot): string;
+/** Pick a post-interruption phrase in the active language. */
+export declare function continuePhrase(): string;
+/** Pick a post-compaction phrase in the active language. */
+export declare function compactPhrase(): string;
+/** Pick an overflow phrase in the active language. */
+export declare function overflowPhrase(): string;
+/** Pick a compact-retry phrase in the active language. */
+export declare function compactRetryPhrase(): string;
+/**
+ * Quip for a model id (substring match), or null when no pool matches.
+ * @param modelId - Model id, e.g. `deepseek-chat` or `gpt-4o`.
+ */
+export declare function modelQuip(modelId: string): string | null;
+/** Feature toggles for the lively phrase selector. */
+export interface LivelyFeatures {
+    /** Allow rare 1/150 easter eggs. */
+    readonly rareEggs?: boolean;
+    /** Allow weekend greetings on Sat/Sun. */
+    readonly weekend?: boolean;
+    /** Allow date-matched holiday / Lunar New Year copy. */
+    readonly holidays?: boolean;
+    /** Mix night-owl copy between 00:00 and 06:00. */
+    readonly nightPhrases?: boolean;
+}
+/**
+ * Pick a thinking phrase with the pi extension's egg order: holiday first,
+ * then rare (1/150), then weekend, then the elapsed-time tiers with night
+ * mixing. Every egg is gated by `features` (defaults all on).
+ * @param elapsedMs - Milliseconds spent thinking in the current phase.
+ * @param previous - Previously shown phrase, to avoid repeats.
+ * @param night - Whether the night window is active (mixes night copy).
+ * @param now - Current wall-clock time (injectable for tests).
+ * @param features - Feature toggles; absent flags default to on.
+ * @param extra - User custom phrases appended to the base thinking pool.
+ */
+export declare function livelyThinkingPhrase(elapsedMs: number, previous?: string, night?: boolean, now?: Date, features?: LivelyFeatures, extra?: readonly string[]): string;
+/** Common git tool names / bash commands containing `git `. */
+export declare const GIT_TOOL_RE: RegExp;
+/** Detect the 00:00–06:00 night window (local time). */
+export declare function isNight(hour: number): boolean;
+/** The zh or en base waiting pool by the active language. */
+export declare function waitingPool(): readonly string[];
+/**
+ * Pick a thinking phrase appropriate for the elapsed thinking time, in the
+ * active language.
+ * @param elapsedMs - Milliseconds spent thinking in the current phase.
+ * @param previous - Previously shown phrase, to avoid repeats.
+ * @param night - Mix night-owl copy into the pool.
+ * @param extra - User custom phrases appended to the base (non-tier) pool.
+ */
+export declare function thinkingPhrase(elapsedMs: number, previous?: string, night?: boolean, extra?: readonly string[], at?: PhraseSlot): string;
+/** Pick a waiting phrase in the active language. */
+export declare function waitingPhrase(previous?: string, at?: PhraseSlot): string;
+/**
+ * The line shown when thinking turns into doing: the turn's first tool call.
+ *
+ * Deliberately its own pool rather than part of the thinking copy — it marks a
+ * transition, so it must read as one ("thought it through, getting to work")
+ * instead of as another "the model is busy" fragment.
+ */
+export declare const TOOL_OPENING_PHRASES: readonly string[];
+/** English mirror of {@link TOOL_OPENING_PHRASES}. */
+export declare const EN_TOOL_OPENING_PHRASES: readonly string[];
+/** Pick the thinking→doing opening line in the active language. */
+export declare function toolOpeningPhrase(at?: PhraseSlot): string;
+/** Pick a tool-failure phrase in the active language. */
+export declare function failPhrase(): string;
+/** Pick a turn-completion phrase in the active language. */
+export declare function donePhrase(): string;
+/**
+ * Map a tool name to a playful action verb, in the active language.
+ * @param toolName - Registry tool name (unqualified).
+ * @param custom - Exact-name custom action pools, matched case-insensitively
+ *   (user-owned copy, used verbatim in any language).
+ */
+export declare function actionFor(toolName: string, custom?: Readonly<Record<string, readonly string[]>>): string;
+/** Whether a tool is a git operation (name match, or a shell command containing `git `). */
+export declare function isGitTool(toolName: string, args?: Readonly<Record<string, unknown>>): boolean;
+/** Format milliseconds as a compact human duration (`1m23s`). */
+export declare function fmtDuration(ms: number): string;