@caozeal/dsh-next-git 0.1.4 → 0.1.6

package/src/ai-commit.js

@@ -2,8 +2,12 @@
  * git-manager — AI 提交信息生成。
  *
  * 流程：收集「已暂存 diff（为空则工作区 diff）→ 最近提交风格 → 调用默认模型的
- * llm.stream」→ 清理成一行提交信息。任何一步不可用都退回确定性文案（fallback），
- * 让面板始终能拿到一个可编辑的建议。
+ * llm.stream」→ 清理成「标题 + 可选正文」。任何一步不可用都退回确定性文案
+ * （fallback），让面板始终能拿到一条可编辑的建议。
+ *
+ * 系统提示词可由仓库自定义（git config dsh.commitPrompt），只替换「怎么写」的规则，
+ * 不改变「给模型看什么数据」——diff/文件/最近提交这条装配逻辑始终由本模块掌握，
+ * 避免用户把模板写坏后模型看不到 diff 而胡乱编造。
  */
 import { GitError } from './git.js'
 
@@ -11,11 +15,13 @@ const MAX_DIFF_CHARS = 12000
 /** 单次生成的 token 预算：reasoning 模型会先消耗思考 token，200 太小容易截断。 */
 const MAX_OUTPUT_TOKENS = 600
 
-const SYSTEM_PROMPT = [
+export const DEFAULT_SYSTEM_PROMPT = [
   '你是一个 Git 提交信息生成器。',
-  '只输出一行提交信息，不要解释、不要代码块、不要引号、不要句号结尾。',
-  '使用 Conventional Commits 风格（如 feat:/fix:/refactor:/docs:/chore:），',
-  '不超过 72 个字符。跟随仓库最近提交的语言：最近提交多为中文就用中文，否则用英文。',
+  '第一行是标题：Conventional Commits 风格（feat:/fix:/refactor:/docs:/chore: 等），不超过 72 个字符，不以句号结尾。',
+  '如果这次改动需要说明动机、影响面或取舍，空一行后写正文，正文每行不超过 72 个字符，可以分段。',
+  '改动很小、一句话能说清时不要硬凑正文。',
+  '不要解释、不要代码块、不要引号。',
+  '跟随仓库最近提交的语言：最近提交多为中文就用中文，否则用英文。',
 ].join('')
 
 /** 从 diff 与最近提交构造 user prompt。 */
@@ -48,6 +54,44 @@ export function sanitizeSubject(text) {
   return subject
 }
 
+/** 去掉整行的代码块围栏，保留内容。 */
+function stripFences(text) {
+  return String(text ?? '').replace(/^[ \t]*```[a-zA-Z0-9_-]*[ \t]*$/gm, '')
+}
+
+/**
+ * 清理模型输出的正文部分：去围栏、去首尾空行、去「正文：」这类前缀、限长。
+ * 不做逐行 trim——正文里的缩进（列表、代码片段）要保留。
+ * @param {string} text
+ * @returns {string}
+ */
+export function sanitizeBody(text) {
+  let value = stripFences(text).replace(/\r\n/g, '\n')
+  const lines = value.split('\n').map((line) => line.replace(/[ \t]+$/, ''))
+  while (lines.length > 0 && lines[0].trim() === '') lines.shift()
+  while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop()
+  let body = lines.join('\n').trim()
+  body = body.replace(/^(commit body|提交正文|正文)\s*[:：]\s*/i, '')
+  if (body.length > 2000) body = body.slice(0, 2000).trim()
+  return body
+}
+
+/**
+ * 把模型输出拆成「标题 + 正文」。
+ * 模型偶尔只给标题，也可能给「标题 / 空行 / 正文」，两种都要能吃下。
+ * @param {string} text
+ * @returns {{subject: string, body: string}}
+ */
+export function parseCommitMessage(text) {
+  const cleaned = stripFences(text).replace(/\r\n/g, '\n')
+  const lines = cleaned.split('\n')
+  let index = 0
+  while (index < lines.length && lines[index].trim() === '') index += 1
+  const subjectLine = index < lines.length ? lines[index] : ''
+  const rest = lines.slice(index + 1).join('\n')
+  return { subject: sanitizeSubject(subjectLine), body: sanitizeBody(rest) }
+}
+
 /** 最近提交是否以中文为主。 */
 function looksChinese(subjects) {
   const joined = subjects.join('')
@@ -104,8 +148,9 @@ export function fallbackSubject({ files, stagedCount, Chinese }) {
  *   signal?: AbortSignal,
  *   llm?: unknown,
  *   selection?: {provider?: string, model?: string, reasoningEffort?: string},
+ *   systemPrompt?: string,
  * }} options
- * @returns {Promise<{message: string, model: string|null, fallback: boolean}>}
+ * @returns {Promise<{message: string, subject: string, body: string, model: string|null, fallback: boolean}>}
  */
 export async function generateCommitMessage(options) {
   const {
@@ -117,6 +162,7 @@ export async function generateCommitMessage(options) {
     selection,
     files = [],
     stagedCount = 0,
+    systemPrompt = '',
   } = options
 
   const staged = await runGit(['diff', '--cached', '--no-color'], { cwd, signal, allowFailure: true })
@@ -144,13 +190,12 @@ export async function generateCommitMessage(options) {
 
   const canUseLlm = Boolean(llm && selection && selection.provider && selection.model && diff.trim())
   if (!canUseLlm) {
-    return {
-      message: fallbackSubject({ files: changedFiles, stagedCount, Chinese: chinese }),
-      model,
-      fallback: true,
-    }
+    const subject = fallbackSubject({ files: changedFiles, stagedCount, Chinese: chinese })
+    return { message: subject, subject, body: '', model, fallback: true }
   }
 
+  // 用户自定义提示词：只覆盖「怎么写」的规则，装配数据仍由 buildPrompt 负责。
+  const customPrompt = typeof systemPrompt === 'string' ? systemPrompt.trim().slice(0, 4000) : ''
   const prompt = buildPrompt({ diff, files: changedFiles, recent, hint })
   let text = ''
   try {
@@ -158,7 +203,7 @@ export async function generateCommitMessage(options) {
       provider: selection.provider,
       model: selection.model,
       reasoningEffort: selection.reasoningEffort,
-      system: SYSTEM_PROMPT,
+      system: customPrompt === '' ? DEFAULT_SYSTEM_PROMPT : customPrompt,
       messages: [{ role: 'user', content: [{ type: 'text', text: prompt }] }],
       maxTokens: MAX_OUTPUT_TOKENS,
       temperature: 0.2,
@@ -182,13 +227,11 @@ export async function generateCommitMessage(options) {
     throw new GitError(`模型生成失败：${message}`, { code: 'ai-unavailable' })
   }
 
-  const subject = sanitizeSubject(text)
-  if (!looksLikeSubject(subject)) {
-    return {
-      message: fallbackSubject({ files: changedFiles, stagedCount, Chinese: chinese }),
-      model,
-      fallback: true,
-    }
+  const parsed = parseCommitMessage(text)
+  if (!looksLikeSubject(parsed.subject)) {
+    const subject = fallbackSubject({ files: changedFiles, stagedCount, Chinese: chinese })
+    return { message: subject, subject, body: '', model, fallback: true }
   }
-  return { message: subject, model, fallback: false }
-}
+  const message = parsed.body === '' ? parsed.subject : parsed.subject + '\n\n' + parsed.body
+  return { message, subject: parsed.subject, body: parsed.body, model, fallback: false }
+}

package/src/git.js

@@ -290,7 +290,7 @@ export function parseStashes(raw) {
  * @param {string} raw
  * @returns {Array<{graph: string, hash: string|null, full: string|null, refs: string[], author: string, date: string, subject: string}>}
  */
-export function parseGraph(raw) {
+export function parseGraph(raw, options = {}) {
   /** @type {Array<object>} */
   const lines = []
   for (const line of String(raw ?? '').split('\n')) {
@@ -319,6 +319,19 @@ export function parseGraph(raw) {
       subject: fields.slice(5).join('\x1f'),
     })
   }
+  // 逐行算 lane 色号，Client 直接用；ref 色号与线条色号来自同一次分配，
+  // 保证「分支徽章」和「分支线」严格同色。
+  const colors = assignGraphColors(lines, options.width)
+  const assignments = assignRefColors(lines)
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]
+    line.colors = colors[index]
+    if (line.refs && line.refs.length > 0) {
+      const head = line.refs.find((ref) => String(ref).indexOf('HEAD') === 0)
+      const color = assignments.get(canonicalRef(head || line.refs[0]))
+      if (color !== undefined) line.refColor = color
+    }
+  }
   return lines
 }
 
@@ -334,6 +347,309 @@ export function parseLines(raw) {
     .filter((line) => line !== '')
 }
 
+
+/**
+ * 把一对「删除行 / 新增行」切成词级片段，供 diff 渲染高亮真正变化的词。
+ *
+ * 算法：先按「词 / 空白 / 标点」粗切成 token，再对两组 token 做 LCS，
+ * 未匹配的 token 才是变化部分。纯函数、无依赖、可单测。
+ *
+ * 注意：中文等无空格语言按字符切，否则整行会变成一个 token（等于没高亮）。
+ *
+ * @param {string} before 删除行的文本（不含前缀符号）
+ * @param {string} after 新增行的文本（不含前缀符号）
+ * @returns {{before: Array<{text: string, changed: boolean}>, after: Array<{text: string, changed: boolean}>}}
+ */
+export function diffInline(before, after) {
+  const left = tokenizeInline(String(before ?? ''))
+  const right = tokenizeInline(String(after ?? ''))
+  // 任一侧为空（纯增/纯删）或任一侧过长（高亮收益低、LCS 变慢）时整体标记为变化。
+  if (left.length === 0 || right.length === 0 || left.length + right.length > MAX_INLINE_TOKENS) {
+    return {
+      before: [{ text: left.join(''), changed: left.length > 0 }],
+      after: [{ text: right.join(''), changed: right.length > 0 }],
+    }
+  }
+  const matched = lcsMatches(left, right)
+  return {
+    before: groupInline(left, matched.left),
+    after: groupInline(right, matched.right),
+  }
+}
+
+/** 单行词级比较的 token 上限，超过就退化成整行高亮。 */
+const MAX_INLINE_TOKENS = 400
+
+/** 是否把该 codepoint 当作可独立成词的表意字符（CJK、假名、全角标点等）。 */
+function isIdeographic(code) {
+  return (
+    (code >= 0x3040 && code <= 0x30ff) || // 平假名 / 片假名
+    (code >= 0x3400 && code <= 0x4dbf) || // CJK 扩展 A
+    (code >= 0x4e00 && code <= 0x9fff) || // CJK 基本区
+    (code >= 0xf900 && code <= 0xfaff) || // CJK 兼容表意
+    (code >= 0xff00 && code <= 0xffef) || // 全角字符
+    (code >= 0xac00 && code <= 0xd7af) // 谚文
+  )
+}
+
+/** 把一行切成分隔 token：连续标识符、连续空白、单个标点/表意字符。 */
+function tokenizeInline(text) {
+  /** @type {string[]} */
+  const out = []
+  let buffer = ''
+  let mode = ''
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0
+    const next = /\s/.test(char) ? 'space' : isIdeographic(code) ? 'ideograph' : /[A-Za-z0-9_$]/.test(char) ? 'word' : 'punct'
+    if (next === 'ideograph') {
+      if (buffer) { out.push(buffer); buffer = '' }
+      out.push(char)
+      mode = ''
+      continue
+    }
+    if (next === mode) {
+      buffer += char
+      continue
+    }
+    if (buffer) out.push(buffer)
+    buffer = char
+    mode = next
+  }
+  if (buffer) out.push(buffer)
+  return out
+}
+
+/**
+ * 对左右 token 序列求最长公共子序列，返回两侧各自「被匹配上」的下标集合。
+ * 经典 DP；因为 MAX_INLINE_TOKENS 限制了规模，内存可以接受。
+ * @param {string[]} left
+ * @param {string[]} right
+ * @returns {{left: Set<number>, right: Set<number>}}
+ */
+function lcsMatches(left, right) {
+  const n = left.length
+  const m = right.length
+  /** @type {Uint16Array[]} */
+  const table = []
+  for (let i = 0; i <= n; i += 1) table.push(new Uint16Array(m + 1))
+  for (let i = n - 1; i >= 0; i -= 1) {
+    for (let j = m - 1; j >= 0; j -= 1) {
+      table[i][j] = left[i] === right[j]
+        ? table[i + 1][j + 1] + 1
+        : Math.max(table[i + 1][j], table[i][j + 1])
+    }
+  }
+  const matchedLeft = new Set()
+  const matchedRight = new Set()
+  let i = 0
+  let j = 0
+  while (i < n && j < m) {
+    if (left[i] === right[j]) {
+      matchedLeft.add(i)
+      matchedRight.add(j)
+      i += 1
+      j += 1
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      i += 1
+    } else {
+      j += 1
+    }
+  }
+  return { left: matchedLeft, right: matchedRight }
+}
+
+/**
+ * 把 token 按下标是否命中合并成连续片段，减少 DOM 节点数。
+ * @param {string[]} tokens
+ * @param {Set<number>} matched
+ * @returns {Array<{text: string, changed: boolean}>}
+ */
+function groupInline(tokens, matched) {
+  /** @type {Array<{text: string, changed: boolean}>} */
+  const out = []
+  for (let index = 0; index < tokens.length; index += 1) {
+    const changed = !matched.has(index)
+    const last = out[out.length - 1]
+    if (last && last.changed === changed) last.text += tokens[index]
+    else out.push({ text: tokens[index], changed })
+  }
+  return out
+}
+
+/**
+ * 在一个 hunk 的行序列上就地附加词级高亮片段。
+ *
+ * 配对策略：同一 hunk 内相邻的连续删除块与连续新增块「按下标逐行配对」——
+ * 这是 unified diff 的常见形态，也是用户直觉上认为「这一行改成了那一行」的对应关系。
+ * 多余的删除行或新增行保持整行高亮。
+ *
+ * @param {Array<{kind: string, text: string}>} lines
+ * @returns {Array<{kind: string, text: string, old?: number, new?: number, inline?: Array<{text: string, changed: boolean}>}>}
+ */
+export function attachInlineHunks(lines) {
+  const output = lines.map((line) => ({ ...line }))
+  let index = 0
+  while (index < output.length) {
+    if (output[index].kind !== 'del') {
+      index += 1
+      continue
+    }
+    let delEnd = index
+    while (delEnd < output.length && output[delEnd].kind === 'del') delEnd += 1
+    let addEnd = delEnd
+    while (addEnd < output.length && output[addEnd].kind === 'add') addEnd += 1
+    const delCount = delEnd - index
+    const addCount = addEnd - delEnd
+    const pairs = Math.min(delCount, addCount)
+    for (let offset = 0; offset < pairs; offset += 1) {
+      const delLine = output[index + offset]
+      const addLine = output[delEnd + offset]
+      const inline = diffInline(delLine.text, addLine.text)
+      // 只在真的存在可见差异时才挂片段，纯「整行替换」不额外包 span。
+      if (inline.before.length > 1 || inline.after.length > 1 ||
+          (inline.before[0] && inline.before[0].changed) || (inline.after[0] && inline.after[0].changed)) {
+        delLine.inline = inline.before
+        addLine.inline = inline.after
+      }
+    }
+    index = addEnd
+  }
+  return output
+}
+
+/** 提交图配色槽位数；Client 侧 CSS 提供 --gm-lane-0 .. --gm-lane-{N-1}。 */
+export const GRAPH_PALETTE_SIZE = 8
+
+/** 图表单格的连接语义：'|' 竖直、'/' 从 lane i 顶到 lane i-1 底、'\\' 从 lane i-1 顶到 lane i 底。 */
+function cellLink(char, lane) {
+  if (char === '|') return { top: lane, bottom: lane }
+  if (char === '/') return { top: lane, bottom: lane - 1 }
+  if (char === '\\') return { top: lane - 1, bottom: lane }
+  if (char === '*') return { top: lane, bottom: lane }
+  if (char === '_') return { top: lane, bottom: lane }
+  return null
+}
+
+/** 取图行第 lane 个字符；越界返回空格。 */
+function graphChar(text, lane) {
+  return lane >= 0 && lane < text.length ? text[lane] : ' '
+}
+
+/** 由分支名/远程名算出稳定色号：同名分支在任何仓库、任何一次打开都是同一种颜色。 */
+export function refColorIndex(ref) {
+  const name = String(ref ?? '')
+    .replace(/^HEAD -> /, '')
+    .replace(/^tag: /, '')
+    .replace(/^origin\//, '')
+  let hash = 0
+  for (let index = 0; index < name.length; index += 1) {
+    hash = (hash * 31 + name.charCodeAt(index)) % 100003
+  }
+  return hash % GRAPH_PALETTE_SIZE
+}
+
+/**
+ * 给提交图每一行算出 lane 的颜色号。
+ *
+ * 做法是模拟一条「颜色随线段流动」的轨道：每个格子有入口 lane 和出口 lane
+ * （见 {@link cellLink}），入口颜色沿线段流到出口，于是同一条分支线在跨行时
+ * 保持同色；分支点处新出现的线段取当前未被占用的色号，避免相邻两条线撞色。
+ *
+ * 有 ref（分支/tag）的提交点会强制使用该 ref 的稳定色，这样「分支自己的颜色」
+ * 和「分支名徽章的颜色」一致，滚到哪都能认出来。
+ *
+ * @param {Array<{graph: string, refs?: string[]}>} lines
+ * @param {number} [width] 参与绘制的 lane 数；省略时按实际最长图前缀推断
+ * @returns {Array<Array<number>>} 每行每个 lane 的色号
+ */
+export function assignGraphColors(lines, width) {
+  const rows = Array.isArray(lines) ? lines : []
+  let maxWidth = 0
+  for (const line of rows) {
+    const text = line && line.graph ? line.graph : ''
+    if (text.length > maxWidth) maxWidth = text.length
+  }
+  const cols = Number.isFinite(width) && width > 0 ? Math.min(width, maxWidth) : maxWidth
+  // 先给所有出现过的 ref 分配互不相同的色号（按首次出现顺序），而不是对名字取模。
+  // 取模在 8 色槽下约 1/8 概率撞色，两条分支同色会让整张图失去辨识度
+  // （实测 feat/streaming 与 fix/empty-input 就撞在同一个色号上）。
+  const refColors = assignRefColors(rows)
+  /** @type {Map<number, number>} */
+  let entering = new Map()
+  /** @type {Array<Array<number>>} */
+  const output = []
+  for (let row = 0; row < rows.length; row += 1) {
+    const text = rows[row] && rows[row].graph ? rows[row].graph : ''
+    const refs = rows[row] && Array.isArray(rows[row].refs) ? rows[row].refs : []
+    /** @type {Array<number>} */
+    const colors = new Array(cols).fill(-1)
+    /** @type {Map<number, number>} */
+    const next = new Map()
+    /** @type {Set<number>} */
+    const used = new Set()
+    for (let lane = 0; lane < cols; lane += 1) {
+      const link = cellLink(graphChar(text, lane), lane)
+      if (!link) continue
+      let color = entering.get(link.top)
+      if (color === undefined) {
+        // 新线段：挑一个这一行还没用过的色号，相邻线不会同色。
+        color = 0
+        for (let candidate = 0; candidate < GRAPH_PALETTE_SIZE; candidate += 1) {
+          if (!used.has(candidate)) { color = candidate; break }
+        }
+      }
+      used.add(color)
+      colors[lane] = color
+      if (!next.has(link.bottom)) next.set(link.bottom, color)
+    }
+    // 提交点：有 ref 时用该分支分配到的色号，并让它继续往下流。
+    if (refs.length > 0) {
+      const dot = text.indexOf('*')
+      if (dot >= 0 && dot < cols) {
+        const head = refs.find((ref) => String(ref).indexOf('HEAD') === 0)
+        const color = refColors.get(canonicalRef(head || refs[0]))
+        if (color !== undefined) {
+          colors[dot] = color
+          next.set(dot, color)
+        }
+      }
+    }
+    output.push(colors)
+    entering = next
+  }
+  return output
+}
+
+/**
+ * 给一组图行里出现过的每个 ref 分配色号（按首次出现顺序取模）。
+ * 顺序分配保证「同一屏里出现的分支一定不同色」，比按名字哈希取模更可靠。
+ * @param {Array<{refs?: string[]}>} rows
+ * @returns {Map<string, number>} 归一化分支名 → 色号
+ */
+function assignRefColors(rows) {
+  const out = new Map()
+  let cursor = 0
+  for (const row of rows) {
+    const refs = row && Array.isArray(row.refs) ? row.refs : []
+    for (const ref of refs) {
+      const name = canonicalRef(ref)
+      if (!name || out.has(name)) continue
+      out.set(name, cursor % GRAPH_PALETTE_SIZE)
+      cursor += 1
+    }
+  }
+  return out
+}
+
+/** 把 `HEAD -> main`、`tag: v1`、`origin/main` 归一成用于配色的分支名。 */
+function canonicalRef(ref) {
+  return String(ref ?? '')
+    .replace(/^HEAD -> /, '')
+    .replace(/^tag: /, '')
+    .replace(/^origin\//, '')
+    .trim()
+}
+
 const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/
 
 /**
@@ -395,5 +711,7 @@ export function parseUnifiedDiff(raw) {
       // 例如 `index abc..def 100644`、`--- a/x`、`+++ b/x` 等文件头：忽略。
     }
   }
+  // 每个 hunk 的行上附加词级高亮片段（纯展示数据，UI 可忽略）。
+  for (const hunk of hunks) hunk.lines = attachInlineHunks(hunk.lines)
   return { binary, additions, deletions, hunks }
-}
+}

package/src/operations.js

@@ -27,10 +27,17 @@ const DIFF_MAX_CHARS = 400000
 
 /** 支持的操作名。 */
 const OPS = [
-  'snapshot', 'graph', 'diff', 'stage', 'unstage', 'switchBranch', 'deleteBranch',
+  'snapshot', 'graph', 'diff', 'stage', 'unstage', 'discard', 'switchBranch', 'deleteBranch',
   'commit', 'fetch', 'pull', 'push', 'aiCommit',
+  'stashPush', 'stashPop', 'stashDrop', 'setCommitPrompt',
 ]
 
+/** 自定义提交提示词在 git config 里的键。用 git config 而不是新增工作区文件：
+ *  不污染 git status、不打扰 .gitignore，且天然区分本地/全局（写入用 --local，
+ *  读取走默认级联，所以用户可以先设一条全局默认再按仓库覆盖）。 */
+const COMMIT_PROMPT_KEY = 'dsh.commitPrompt'
+const COMMIT_PROMPT_MAX = 4000
+
 /** 只接受安全的 ref/远程名，避免被当作命令行选项。 */
 const SAFE_REF = /^[A-Za-z0-9._/-]+$/
 
@@ -160,10 +167,11 @@ export function createOperations(deps) {
         remotes: [],
         status: { clean: true, staged: [], unstaged: [], untracked: [], conflicted: [] },
         stashes: [],
+        commitPrompt: '',
       }
     }
     const root = resolved.root
-    const [statusRes, branchesRes, remotesRes, stashRes, headRes, urlRes] = await Promise.all([
+    const [statusRes, branchesRes, remotesRes, stashRes, headRes, urlRes, promptRes] = await Promise.all([
       runGit(['status', '--porcelain=v1', '-z', '--branch', '--untracked-files=all'], {
         cwd: root,
         signal,
@@ -178,6 +186,7 @@ export function createOperations(deps) {
       runGit(['stash', 'list', '--format=%gd%x00%s'], { cwd: root, signal, allowFailure: true }),
       runGit(['rev-parse', '--short', 'HEAD'], { cwd: root, signal, allowFailure: true }),
       runGit(['config', '--get', 'remote.origin.url'], { cwd: root, signal, allowFailure: true }),
+      runGit(['config', '--get', COMMIT_PROMPT_KEY], { cwd: root, signal, allowFailure: true }),
     ])
     const parsed = parsePorcelain(statusRes.stdout)
     const head = parseBranchHeader(parsed.branchLine)
@@ -209,6 +218,7 @@ export function createOperations(deps) {
       remotes,
       status: { clean, ...groups },
       stashes: parseStashes(stashRes.stdout),
+      commitPrompt: promptRes.code === 0 ? promptRes.stdout.trim() : '',
     }
   }
 
@@ -311,6 +321,31 @@ export function createOperations(deps) {
     return { output: joinOutput(result.stdout, result.stderr) }
   }
 
+  /**
+   * 丢弃改动。三种模式对应变更列表里的三个分组：
+   *   worktree  —— 未暂存（git restore --worktree）
+   *   untracked —— 未跟踪（git clean -f -d）
+   *   all       —— 已暂存，连暂存区一起回退（git restore --staged --worktree）
+   * 都不可恢复，前端必须二次确认后才调用。
+   */
+  async function discard(params, signal) {
+    const cwd = assertCwd(params.cwd)
+    const resolved = await repoRoot(cwd, signal)
+    const root = resolved.root
+    if (!root) throw new GitError(`当前目录不是 Git 仓库：${cwd}${resolved.error ? `（${resolved.error}）` : ''}`, { code: 'not-a-repo' })
+    const mode = params.mode
+    if (!['worktree', 'untracked', 'all'].includes(mode)) {
+      throw new GitError(`未知的丢弃模式：${String(mode)}`, { code: 'invalid-params' })
+    }
+    const paths = assertPaths(params.paths)
+    let args
+    if (mode === 'untracked') args = ['clean', '-f', '-d', '--', ...paths]
+    else if (mode === 'all') args = ['restore', '--staged', '--worktree', '--', ...paths]
+    else args = ['restore', '--worktree', '--', ...paths]
+    const result = await runGit(args, { cwd: root, signal, timeoutMs: timeouts.write })
+    return { output: joinOutput(result.stdout, result.stderr) }
+  }
+
   async function switchBranch(params, signal) {
     const cwd = assertCwd(params.cwd)
     const resolved = await repoRoot(cwd, signal)
@@ -429,6 +464,80 @@ export function createOperations(deps) {
     return { branch, output: joinOutput(result.stdout, result.stderr) }
   }
 
+  /** stash 索引只接受非负整数，避免拼进 stash@{...} 时被注入别的 ref。 */
+  function assertStashIndex(value, fallback) {
+    const raw = value === undefined || value === null ? fallback : value
+    const index = Number(raw)
+    if (!Number.isInteger(index) || index < 0 || index > 999) {
+      throw new GitError(`stash 索引非法：${String(raw)}`, { code: 'invalid-params' })
+    }
+    return index
+  }
+
+  async function stashPush(params, signal) {
+    const cwd = assertCwd(params.cwd)
+    const resolved = await repoRoot(cwd, signal)
+    const root = resolved.root
+    if (!root) throw new GitError(`当前目录不是 Git 仓库：${cwd}${resolved.error ? `（${resolved.error}）` : ''}`, { code: 'not-a-repo' })
+    const args = ['stash', 'push']
+    if (params.includeUntracked === true) args.push('-u')
+    const message = typeof params.message === 'string' ? params.message.trim().slice(0, 200) : ''
+    if (message !== '') args.push('-m', message)
+    const result = await runGit(args, { cwd: root, signal, timeoutMs: timeouts.write })
+    return { output: joinOutput(result.stdout, result.stderr) }
+  }
+
+  async function stashPop(params, signal) {
+    const cwd = assertCwd(params.cwd)
+    const resolved = await repoRoot(cwd, signal)
+    const root = resolved.root
+    if (!root) throw new GitError(`当前目录不是 Git 仓库：${cwd}${resolved.error ? `（${resolved.error}）` : ''}`, { code: 'not-a-repo' })
+    const index = assertStashIndex(params.index, 0)
+    const result = await runGit(['stash', 'pop', `stash@{${index}}`], {
+      cwd: root, signal, timeoutMs: timeouts.write,
+    })
+    return { output: joinOutput(result.stdout, result.stderr) }
+  }
+
+  async function stashDrop(params, signal) {
+    const cwd = assertCwd(params.cwd)
+    const resolved = await repoRoot(cwd, signal)
+    const root = resolved.root
+    if (!root) throw new GitError(`当前目录不是 Git 仓库：${cwd}${resolved.error ? `（${resolved.error}）` : ''}`, { code: 'not-a-repo' })
+    const index = assertStashIndex(params.index, 0)
+    const result = await runGit(['stash', 'drop', `stash@{${index}}`], {
+      cwd: root, signal, timeoutMs: timeouts.write,
+    })
+    return { output: joinOutput(result.stdout, result.stderr) }
+  }
+
+  /** 读写自定义提交提示词；传空串表示恢复默认。 */
+  async function setCommitPrompt(params, signal) {
+    const cwd = assertCwd(params.cwd)
+    const resolved = await repoRoot(cwd, signal)
+    const root = resolved.root
+    if (!root) throw new GitError(`当前目录不是 Git 仓库：${cwd}${resolved.error ? `（${resolved.error}）` : ''}`, { code: 'not-a-repo' })
+    const raw = typeof params.prompt === 'string' ? params.prompt : ''
+    if (raw.length > COMMIT_PROMPT_MAX) {
+      throw new GitError(`提示词过长（上限 ${COMMIT_PROMPT_MAX} 字）`, { code: 'invalid-params' })
+    }
+    const value = raw.trim()
+    if (value === '') {
+      // 没设过时 git config --unset 退出码非 0，不算失败。
+      await runGit(['config', '--local', '--unset', COMMIT_PROMPT_KEY], {
+        cwd: root, signal, timeoutMs: timeouts.write, allowFailure: true,
+      })
+    } else {
+      await runGit(['config', '--local', COMMIT_PROMPT_KEY, value], {
+        cwd: root, signal, timeoutMs: timeouts.write,
+      })
+    }
+    const read = await runGit(['config', '--get', COMMIT_PROMPT_KEY], {
+      cwd: root, signal, allowFailure: true,
+    })
+    return { prompt: read.code === 0 ? read.stdout.trim() : '' }
+  }
+
   async function aiCommit(params, signal) {
     const cwd = assertCwd(params.cwd)
     const resolved = await repoRoot(cwd, signal)
@@ -436,6 +545,10 @@ export function createOperations(deps) {
     if (!root) throw new GitError(`当前目录不是 Git 仓库：${cwd}${resolved.error ? `（${resolved.error}）` : ''}`, { code: 'not-a-repo' })
     const hint = typeof params.hint === 'string' ? params.hint.slice(0, 500) : ''
     const context = ai() ?? {}
+    const promptRes = await runGit(['config', '--get', COMMIT_PROMPT_KEY], {
+      cwd: root, signal, allowFailure: true,
+    })
+    const systemPrompt = promptRes.code === 0 ? promptRes.stdout : ''
     return generate({
       runGit: (args, options = {}) => runGit(args, {
         cwd: root,
@@ -448,6 +561,7 @@ export function createOperations(deps) {
       signal,
       llm: context.llm,
       selection: context.selection,
+      systemPrompt,
     })
   }
 
@@ -457,6 +571,7 @@ export function createOperations(deps) {
     diff,
     stage,
     unstage,
+    discard,
     switchBranch,
     deleteBranch,
     commit,
@@ -464,6 +579,10 @@ export function createOperations(deps) {
     pull,
     push,
     aiCommit,
+    stashPush,
+    stashPop,
+    stashDrop,
+    setCommitPrompt,
   }
 
   /**
@@ -507,4 +626,4 @@ export function createOperations(deps) {
   }
 
   return { handle, ops: [...OPS], runGit }
-}
+}