@toddzheng024/dscode-bundle 0.7.12 → 0.7.14

package/vendor/tui/lib/git-workflow.mjs

@@ -0,0 +1,278 @@
+/**
+ * Read-only Git inspection used by /diff and /review. Every diff
+ * invocation carries --no-ext-diff and --no-textconv, so configured
+ * external diff drivers and text converters can never execute as a
+ * side effect of reading a diff.
+ */
+import { execFile } from 'node:child_process';
+import { t } from './i18n.mjs';
+/** Split Git's stable `diff --git` framing without interpreting patch content. */
+export function parseGitDiffFiles(text) {
+    if (text === '')
+        return [];
+    const chunks = text.split(/(?=^diff --git )/mu).filter(chunk => chunk !== '');
+    return chunks.map((chunk, index) => {
+        const lines = chunk.replace(/\n$/u, '').split('\n');
+        const plus = lines.find(line => line.startsWith('+++ b/'));
+        const minus = lines.find(line => line.startsWith('--- a/'));
+        const header = /^diff --git a\/(.+) b\/(.+)$/u.exec(lines[0] ?? '');
+        const path = plus?.slice(6) || minus?.slice(6) || header?.[2] || header?.[1] || `file ${index + 1}`;
+        return { path, lines };
+    });
+}
+/** Parse the intentionally small, option-safe /diff argument vocabulary. */
+export function parseGitDiffSpec(argument) {
+    const value = argument.trim();
+    if (value === '')
+        return { label: 'working tree vs HEAD', args: ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', 'HEAD', '--'] };
+    if (value === '--staged' || value === '--cached') {
+        return { label: 'staged changes', args: ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', '--cached', '--'] };
+    }
+    if (value.startsWith('-') || /\s/u.test(value))
+        throw new Error('usage: /diff [--staged|git-ref]');
+    return { label: `changes since ${value}`, args: ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', value, '--'] };
+}
+function executeGit(cwd, args, signal) {
+    return new Promise((resolve, reject) => {
+        execFile('git', [...args], { cwd, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, windowsHide: true, signal }, (error, stdout, stderr) => {
+            if (error !== null) {
+                reject(new Error(stderr.trim() || error.message));
+                return;
+            }
+            resolve(stdout.replace(/\r\n/gu, '\n'));
+        });
+    });
+}
+/** Arguments for the unstaged-only fallback below. */
+const UNSTAGED_DIFF_ARGS = ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', '--'];
+/** Whether the repository has at least one commit (a HEAD revision). */
+function hasHeadRevision(cwd, signal) {
+    return executeGit(cwd, ['rev-parse', '--verify', '--quiet', 'HEAD'], signal)
+        .then(() => true)
+        .catch(() => false);
+}
+/**
+ * Load one complete textual diff without invoking external programs.
+ * @param signal - aborted by the caller on session switches/quit, killing the
+ * git subprocess instead of letting a stale repository's diff land later.
+ */
+export async function loadGitDiff(cwd, argument, signal) {
+    const spec = parseGitDiffSpec(argument);
+    try {
+        const text = await executeGit(cwd, spec.args, signal);
+        return { title: `git diff - ${spec.label}`, files: parseGitDiffFiles(text) };
+    }
+    catch (error) {
+        // Only a repository without commits (no HEAD to diff against) may
+        // narrow the default form to the unstaged fallback. Every other
+        // failure — output past the buffer limit, a corrupt index, a missing
+        // repository, or the caller aborting between the two calls — must
+        // surface, not silently shrink what /diff and /review end up seeing
+        // (an aborted probe would otherwise masquerade as an unborn repo).
+        if (argument.trim() !== '' || signal?.aborted === true || (await hasHeadRevision(cwd, signal)))
+            throw error;
+        const text = await executeGit(cwd, UNSTAGED_DIFF_ARGS, signal);
+        return { title: 'git diff - working tree (no commits yet)', files: parseGitDiffFiles(text) };
+    }
+}
+/**
+ * The /review argument is always a free-form note applied to the uncommitted
+ * working tree (`/review 使用中文` reviews the uncommitted diff in Chinese);
+ * branch and commit targets come from the candidate picker, never from
+ * argument guessing.
+ */
+export function parseReviewArgument(argument) {
+    const value = argument.trim();
+    if (value === '')
+        return { kind: 'uncommitted' };
+    if (value.startsWith('-'))
+        throw new Error('usage: /review [note]');
+    if (value.length > 4000)
+        throw new Error('review note is too long');
+    return { kind: 'custom', instructions: value };
+}
+/** The merge base of HEAD and one branch, or undefined when git cannot compute one. */
+export function mergeBaseWith(cwd, branch, signal) {
+    return executeGit(cwd, ['merge-base', 'HEAD', branch, '--'], signal)
+        .then(output => output.trim() === '' ? undefined : output.trim())
+        .catch(() => undefined);
+}
+/** One commit's own patch (parent..commit), falling back to `git show` for root commits. */
+export async function loadCommitDiff(cwd, sha, signal) {
+    const args = ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', `${sha}~1`, sha, '--'];
+    try {
+        const text = await executeGit(cwd, args, signal);
+        return { title: `git diff - commit ${sha.slice(0, 7)}`, files: parseGitDiffFiles(text) };
+    }
+    catch (error) {
+        // A root commit has no parent to diff against; show its full patch.
+        if (signal?.aborted === true)
+            throw error;
+        const text = await executeGit(cwd, ['show', '--format=', '--no-ext-diff', '--no-textconv', '--unified=3', sha, '--'], signal);
+        return { title: `git diff - commit ${sha.slice(0, 7)}`, files: parseGitDiffFiles(text) };
+    }
+}
+/**
+ * Build the in-session review prompt: the diff is pasted whole (truncated at
+ * the character cap with an explicit marker the model can see), the rubric's
+ * essentials ride along — P0-P3 priorities, file/line anchors, only defects
+ * this change introduced — and an optional user note (language, focus)
+ * prefixes everything as the user's explicit instruction.
+ */
+export function buildReviewPrompt(diff, label, note, maxChars = 200_000) {
+    const truncated = diff.length > maxChars;
+    const body = truncated ? diff.slice(0, maxChars) : diff;
+    return [
+        'Review the following Git changes. Do not modify files or run write operations.',
+        'Lead with concrete bugs, regressions, security risks, and missing tests, ordered by severity.',
+        'Tag every finding [P0]-[P3] (P0 drop everything · P1 urgent · P2 normal · P3 nice to have) and anchor it to file paths with line ranges from the diff; only report defects this change introduced, and prefer reporting nothing over speculation.',
+        `Scope: ${label}${truncated ? ' (diff truncated by CLI — later files are not visible)' : ''}`,
+        ...(note === undefined || note.trim() === '' ? [] : [`User note: ${note.trim()}`]),
+        '',
+        '```diff',
+        body,
+        '```',
+    ].join('\n');
+}
+/**
+ * Local branch names for the review picker, newest activity first and with
+ * the current branch excluded (reviewing against it is always empty).
+ */
+export async function listReviewBranches(cwd, signal) {
+    const text = await executeGit(cwd, ['branch', '--sort=-committerdate', '--format=%(HEAD)%(refname:short)'], signal);
+    return text.split('\n')
+        .map(line => line.trim())
+        .filter(line => line !== '' && !line.startsWith('*'))
+        .map(name => ({ name }));
+}
+/** Recent commits on the current branch for the review picker. */
+export async function listReviewCommits(cwd, signal, limit = 30) {
+    const text = await executeGit(cwd, ['log', `-n${limit}`, '--format=%H%x09%s%x09%ct'], signal);
+    const commits = [];
+    for (const line of text.split('\n')) {
+        if (line === '')
+            continue;
+        const [sha, title, seconds] = line.split('\t');
+        if (sha === undefined || title === undefined)
+            continue;
+        commits.push({ sha, title, at: Number(seconds ?? 0) * 1000 });
+    }
+    return commits;
+}
+/** Extract the first balanced {...} substring (the Codex fallback parse). */
+function firstJsonObject(text) {
+    const start = text.indexOf('{');
+    if (start < 0)
+        return undefined;
+    let depth = 0;
+    let insideString = false;
+    let escaped = false;
+    for (let at = start; at < text.length; at += 1) {
+        const ch = text[at];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            if (insideString)
+                escaped = true;
+            continue;
+        }
+        if (ch === '"')
+            insideString = !insideString;
+        if (insideString)
+            continue;
+        if (ch === '{')
+            depth += 1;
+        if (ch === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return text.slice(start, at + 1);
+        }
+    }
+    return undefined;
+}
+function coercePriority(value) {
+    if (typeof value !== 'number' || !Number.isInteger(value))
+        return undefined;
+    return value >= 0 && value <= 3 ? value : undefined;
+}
+/**
+ * Parse the reviewer's reply into a conclusion: whole-text JSON first, then
+ * the first balanced JSON object anywhere in the text, then undefined (the
+ * reply renders as plain markdown with no summary line). Malformed fields
+ * are dropped, never thrown.
+ */
+export function parseReviewConclusion(text) {
+    const candidates = [text.trim(), firstJsonObject(text)];
+    for (const candidate of candidates) {
+        if (candidate === undefined || !candidate.startsWith('{'))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(candidate);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed !== 'object' || parsed === null)
+            continue;
+        const record = parsed;
+        const findings = [];
+        if (Array.isArray(record['findings'])) {
+            for (const item of record['findings']) {
+                if (typeof item !== 'object' || item === null)
+                    continue;
+                const finding = item;
+                const title = typeof finding['title'] === 'string' ? finding['title'].replace(/^\s*\[P[0-3]\]\s*/u, '').trim() : '';
+                if (title === '')
+                    continue;
+                findings.push({
+                    priority: coercePriority(finding['priority']),
+                    title,
+                    ...(typeof finding['path'] === 'string' && finding['path'] !== '' ? { path: finding['path'] } : {}),
+                    ...(typeof finding['range'] === 'string' && finding['range'] !== '' ? { range: finding['range'] } : {}),
+                });
+            }
+        }
+        const overall = record['overall'] === 'incorrect' ? 'incorrect' : record['overall'] === 'correct' ? 'correct' : undefined;
+        return {
+            findings,
+            ...(overall === undefined ? {} : { overall }),
+            ...(typeof record['explanation'] === 'string' && record['explanation'].trim() !== '' ? { explanation: record['explanation'].trim() } : {}),
+        };
+    }
+    return undefined;
+}
+/**
+ * One compact summary line for a finished review: finding counts per
+ * priority plus the overall verdict, or a no-findings phrasing.
+ */
+export function reviewSummaryLine(conclusion) {
+    const counts = [0, 0, 0, 0];
+    let untagged = 0;
+    for (const finding of conclusion.findings) {
+        if (finding.priority === undefined)
+            untagged += 1;
+        else
+            counts[finding.priority] += 1;
+    }
+    const total = conclusion.findings.length;
+    const parts = [];
+    for (let level = 0; level <= 3; level += 1) {
+        if (counts[level] > 0)
+            parts.push(`P${level}×${counts[level]}`);
+    }
+    if (untagged > 0)
+        parts.push(t('review.summary.untagged', { n: untagged }));
+    const verdict = conclusion.overall === 'incorrect'
+        ? t('review.summary.incorrect')
+        : conclusion.overall === 'correct'
+            ? (total === 0 ? t('review.summary.correctClean') : t('review.summary.correct'))
+            : undefined;
+    if (total === 0) {
+        return verdict === undefined ? t('review.summary.noConclusion') : t('review.summary.zero', { verdict });
+    }
+    const params = { count: total, parts: parts.join(' ') };
+    return verdict === undefined ? t('review.summary.count', params) : t('review.summary.countVerdict', { ...params, verdict });
+}

package/vendor/tui/{types/history.d.ts → lib/history.mjs}

@@ -8,9 +8,11 @@
  * @module @deepseek-ai/dsh-tui/history
  */
 /** Maximum entries retained in the persistent history file and the local recall pool. */
-export declare const HISTORY_MAX_ENTRIES = 100;
+export const HISTORY_MAX_ENTRIES = 100;
 /** Encode one entry for the history file (JSON keeps multi-line drafts intact). */
-export declare function serializeHistoryEntry(text: string): string;
+export function serializeHistoryEntry(text) {
+    return JSON.stringify(text);
+}
 /**
  * Parse a persisted history file (one JSON entry per line): invalid lines
  * drop out, empty entries are ignored, adjacent duplicates collapse, and the
@@ -19,7 +21,26 @@ export declare function serializeHistoryEntry(text: string): string;
  * @param max - entry cap.
  * @returns persistent entries, oldest first.
  */
-export declare function parseHistoryFile(raw: string, max?: number): readonly string[];
+export function parseHistoryFile(raw, max = HISTORY_MAX_ENTRIES) {
+    const kept = [];
+    for (const line of raw.split('\n')) {
+        if (line === '')
+            continue;
+        let text;
+        try {
+            text = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof text !== 'string' || text === '')
+            continue;
+        if (kept.length > 0 && kept[kept.length - 1] === text)
+            continue;
+        kept.push(text);
+    }
+    return kept.slice(-max);
+}
 /**
  * The append unit for the persistent file: one JSON line, so a multi-line
  * draft still occupies exactly one physical line. Each submission appends
@@ -29,13 +50,17 @@ export declare function parseHistoryFile(raw: string, max?: number): readonly st
  * chunks, and the damaged line then drops out at the next parse —
  * recall tolerates the loss by design.
  */
-export declare function historyLine(text: string): string;
+export function historyLine(text) {
+    return serializeHistoryEntry(text) + '\n';
+}
 /**
  * Whether the file on disk differs from its canonical form (deduped and
  * capped). True means stale lines have accumulated and the next boot
  * should rewrite it once, atomically.
  */
-export declare function needsCompaction(raw: string, max?: number): boolean;
+export function needsCompaction(raw, max = HISTORY_MAX_ENTRIES) {
+    return serializeHistoryList(parseHistoryFile(raw, max)) !== raw;
+}
 /**
  * Record one in-session submission: empty text is ignored and an adjacent
  * duplicate collapses (Codex `record_local_submission` semantics). The local
@@ -45,7 +70,13 @@ export declare function needsCompaction(raw: string, max?: number): boolean;
  * @param max - the local pool cap.
  * @returns the updated local list.
  */
-export declare function recordLocalEntry(local: readonly string[], text: string, max?: number): readonly string[];
+export function recordLocalEntry(local, text, max = HISTORY_MAX_ENTRIES) {
+    if (text === '')
+        return local;
+    if (local.length > 0 && local[local.length - 1] === text)
+        return local;
+    return [...local, text].slice(-max);
+}
 /**
  * Serialize a capped entry list to the history file format (one JSON line
  * per entry, trailing newline). The boot-time compaction writes this
@@ -54,7 +85,11 @@ export declare function recordLocalEntry(local: readonly string[], text: string,
  * @param entries - the entries to persist, oldest first.
  * @returns the file content, '' for an empty list.
  */
-export declare function serializeHistoryList(entries: readonly string[]): string;
+export function serializeHistoryList(entries) {
+    if (entries.length === 0)
+        return '';
+    return entries.map(serializeHistoryEntry).join('\n') + '\n';
+}
 /**
  * Build the recall space, newest first: local entries, then persistent
  * entries whose text is not duplicated locally (the local copy wins and the
@@ -64,25 +99,13 @@ export declare function serializeHistoryList(entries: readonly string[]): string
  * @param local - this process's submissions, oldest first.
  * @returns recall entries, newest first.
  */
-export declare function recallEntries(persistent: readonly string[], local: readonly string[]): readonly string[];
-/** Shell-style recall navigation over a fixed recall space. */
-export interface RecallState {
-    /** Recall entries, newest first (frozen at navigation start). */
-    entries: readonly string[];
-    /** Current recall index; null when not browsing. */
-    index: number | null;
-    /** Draft saved when browsing started; restored on Down past the newest. */
-    savedDraft: string;
-    /** The recalled text currently in the composer (the boundary gate's anchor). */
-    lastRecalled: string | null;
+export function recallEntries(persistent, local) {
+    const localSet = new Set(local);
+    return [...persistent.filter(entry => !localSet.has(entry)), ...local].reverse();
 }
 /** Fresh navigation state over one recall space. */
-export declare function beginRecall(entries: readonly string[], draft: string): RecallState;
-/** The outcome of one recall step. */
-export interface RecallStep {
-    state: RecallState;
-    /** The text to place in the composer; undefined means "no movement". */
-    entry: string | undefined;
+export function beginRecall(entries, draft) {
+    return { entries, index: null, savedDraft: draft, lastRecalled: null };
 }
 /**
  * Move one entry older (Up, toward index +1 in the newest-first space). The
@@ -92,6 +115,26 @@ export interface RecallStep {
  * @param state - current navigation state.
  * @param draft - the composer text to preserve when browsing starts.
  */
-export declare function recallOlder(state: RecallState, draft: string): RecallStep;
+export function recallOlder(state, draft) {
+    if (state.index === null) {
+        const entry = state.entries[0];
+        if (entry === undefined)
+            return { state, entry: undefined };
+        return { state: { ...state, index: 0, savedDraft: draft, lastRecalled: entry }, entry };
+    }
+    if (state.index >= state.entries.length - 1)
+        return { state, entry: undefined };
+    const entry = state.entries[state.index + 1];
+    return { state: { ...state, index: state.index + 1, lastRecalled: entry }, entry };
+}
 /** Move one entry newer (Down, toward index 0); past the newest, browsing ends and the saved draft returns. */
-export declare function recallNewer(state: RecallState): RecallStep;
+export function recallNewer(state) {
+    if (state.index === null)
+        return { state, entry: undefined };
+    const next = state.index - 1;
+    if (next < 0) {
+        return { state: { ...state, index: null, lastRecalled: null }, entry: state.savedDraft };
+    }
+    const entry = state.entries[next];
+    return { state: { ...state, index: next, lastRecalled: entry }, entry };
+}

package/vendor/tui/{types/i18n.d.ts → lib/i18n.mjs}

@@ -8,32 +8,40 @@
  *
  * @module @deepseek-ai/dsh-tui/i18n
  */
-import { type MessageKey } from './locales/en.ts';
-export type { MessageKey } from './locales/en.ts';
-/** Selectable interface languages: English (default) and Chinese. */
-export type LanguageName = 'en' | 'zh';
+import { en } from './locales/en.mjs';
+import { zh } from './locales/zh.mjs';
 /** Valid language names for argument parsing. */
-export declare const LANGUAGE_NAMES: readonly LanguageName[];
-/** One language's picker row. */
-export interface LanguageDescriptor {
-    readonly id: LanguageName;
-    readonly label: string;
-}
+export const LANGUAGE_NAMES = ['en', 'zh'];
 /** The /language picker rows in canonical order. */
-export declare const LANGUAGES: readonly LanguageDescriptor[];
+export const LANGUAGES = [
+    { id: 'en', label: 'English' },
+    { id: 'zh', label: '中文' },
+];
+const CATALOGS = { en, zh };
+/** The language in force. */
+let activeName = 'en';
 /**
  * Parse a persisted or typed language name: only 'en' and 'zh' survive;
  * anything else falls back to English.
  */
-export declare function parseLanguageName(value: unknown): LanguageName;
+export function parseLanguageName(value) {
+    return value === 'zh' ? 'zh' : 'en';
+}
 /** The language name in force. */
-export declare function getLanguage(): LanguageName;
+export function getLanguage() {
+    return activeName;
+}
 /** Switch the active language; the next render paints with the new catalog. */
-export declare function setLanguage(name: LanguageName): void;
+export function setLanguage(name) {
+    activeName = name;
+}
 /**
  * One message from the active catalog, with `{n}`-style placeholders filled
  * from the params record. Unknown placeholders stay literal; a missing key
  * falls back to the English entry so a catalog gap degrades visibly but
  * never crashes.
  */
-export declare function t(key: MessageKey, params?: Readonly<Record<string, string | number>>): string;
+export function t(key, params = {}) {
+    const template = CATALOGS[activeName][key] ?? en[key];
+    return template.replace(/\{(\w+)\}/gu, (whole, name) => params[name] === undefined ? whole : String(params[name]));
+}