dsh-git-changes 0.0.0-stage → 0.1.1

package/lib/host/assets.js

@@ -0,0 +1,161 @@
+/**
+ * Static route for the vendored Monaco AMD build.
+ *
+ * `ctx.webServer.register` routes carry no authentication of their own, so the
+ * handler applies the Host Connection fence first (fail closed when the service
+ * is unavailable), then resolves the request path against the package's
+ * `assets/vendor/monaco` directory with realpath containment.
+ */
+import { readFile, realpath, stat } from 'node:fs/promises'
+import { extname, isAbsolute, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * Prefix claimed by the plugin; namespaced to avoid any shipped route.
+ * NOTE: `ctx.webServer.match()` matches `pathname === prefix || pathname.startsWith(prefix + '/')`,
+ * so the registered prefix must NOT carry a trailing slash or nested files never match.
+ */
+export const VENDOR_PREFIX = '/dsh-git-changes/monaco'
+
+/** Content types present in the AMD build (js/css/ttf). */
+const VENDOR_MIME = {
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map': 'application/json; charset=utf-8',
+  '.ttf': 'font/ttf',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+}
+
+/**
+ * Apply the Connection request policy; returns the rejection status, or
+ * undefined when admitted. Never admits on a capability mismatch.
+ * @param {object} ctx host context
+ * @param {import('node:http').IncomingMessage} req request
+ * @returns {number | undefined}
+ */
+function rejectionOf(ctx, req) {
+  try {
+    const connection = ctx.connection
+    if (connection && typeof connection.requestRejection === 'function') {
+      const rejection = connection.requestRejection(req)
+      return rejection === 401 || rejection === 403 ? rejection : undefined
+    }
+  } catch {
+    /* fall through to fail-closed */
+  }
+  return 503
+}
+
+/**
+ * Serve one file under the Monaco vendor directory.
+ * @param {string} root absolute vendor root
+ * @param {import('node:http').IncomingMessage} req request
+ * @param {import('node:http').ServerResponse} res response
+ */
+async function serveVendor(root, req, res) {
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    res.statusCode = 405
+    res.end()
+    return
+  }
+  try {
+    const pathname = new URL(req.url ?? '/', 'http://localhost').pathname
+    if (pathname !== VENDOR_PREFIX && !pathname.startsWith(VENDOR_PREFIX + '/')) {
+      res.statusCode = 404
+      res.end()
+      return
+    }
+    let raw
+    try {
+      raw = decodeURIComponent(pathname.slice(VENDOR_PREFIX.length)).replace(/^\/+/, '')
+    } catch {
+      res.statusCode = 400
+      res.end()
+      return
+    }
+    if (!raw || raw.includes('\u0000')) {
+      res.statusCode = 404
+      res.end()
+      return
+    }
+    const segments = raw.split('/')
+    if (segments.some((segment) => segment === '' || segment === '.' || segment === '..')) {
+      res.statusCode = 403
+      res.end()
+      return
+    }
+    const canonicalRoot = await realpath(root)
+    const target = await realpath(resolve(canonicalRoot, raw))
+    const rel = relative(canonicalRoot, target)
+    if (!rel || rel.startsWith('..') || isAbsolute(rel)) {
+      res.statusCode = 403
+      res.end()
+      return
+    }
+    const info = await stat(target)
+    if (!info.isFile()) {
+      res.statusCode = 404
+      res.end()
+      return
+    }
+    const etag = 'W/"' + info.mtimeMs.toString(16) + '-' + info.size.toString(16) + '"'
+    res.setHeader('etag', etag)
+    res.setHeader('cache-control', 'private, max-age=3600')
+    if (req.headers['if-none-match'] === etag) {
+      res.statusCode = 304
+      res.end()
+      return
+    }
+    res.statusCode = 200
+    res.setHeader('content-type', VENDOR_MIME[extname(target).toLowerCase()] ?? 'application/octet-stream')
+    res.setHeader('content-length', info.size)
+    if (req.method === 'HEAD') {
+      res.end()
+      return
+    }
+    res.end(await readFile(target))
+  } catch {
+    if (!res.headersSent) res.statusCode = 404
+    res.end()
+  }
+}
+
+/**
+ * Register the authenticated Monaco asset prefix route.
+ * @param {object} ctx host plugin context
+ */
+export function registerVendorRoute(ctx) {
+  const root = fileURLToPath(new URL('../../assets/vendor/monaco/', import.meta.url))
+  const handler = (req, res) => {
+    const rejection = rejectionOf(ctx, req)
+    if (rejection !== undefined) {
+      res.statusCode = rejection
+      res.setHeader('cache-control', 'no-store')
+      res.end()
+      return
+    }
+    void serveVendor(root, req, res)
+  }
+  try {
+    const web = ctx.webServer
+    if (!web || typeof web.register !== 'function') {
+      ctx.logger?.warn?.('dsh-git-changes: webServer unavailable; Monaco assets cannot be served')
+      return
+    }
+    const dispose = web.register({ kind: 'prefix', path: VENDOR_PREFIX, handler })
+    ctx.effect(() => () => {
+      try {
+        dispose()
+      } catch {
+        /* webserver teardown may already own the route */
+      }
+    }, 'dsh-git-changes: Monaco vendor route')
+  } catch (error) {
+    ctx.logger?.warn?.(`dsh-git-changes: Monaco vendor route unavailable (${String(error)})`)
+  }
+}

package/lib/host/commit-message.js

@@ -0,0 +1,158 @@
+/**
+ * AI commit-message generation for the Git review panel.
+ *
+ * The Host owns the credentials and the model route, so the browser half never
+ * sees a provider key. We reuse the DSH `llm` service with the user's default
+ * model and stream one short completion; nothing here writes to the repository.
+ */
+
+/** Diff characters handed to the model (tail clipped, never mid-line). */
+const DIFF_MAX_CHARS = 16000
+/** Upper bound for one generated message. */
+const MESSAGE_MAX_CHARS = 2000
+/** Subject length cap enforced on the client commit box too. */
+const SUBJECT_MAX_CHARS = 120
+/** Generation timeout. */
+const GENERATE_TIMEOUT_MS = 60000
+
+const SYSTEM_PROMPT = [
+  '你负责根据 unified diff 生成 Git 提交信息。只输出提交信息本身，必须使用简体中文。',
+  '格式遵循 Conventional Commits：`<type>(<scope>): <摘要>`，type 取 feat/fix/refactor/perf/docs/test/build/chore 之一，scope 可选。',
+  '首行只能有一行，不超过 50 个中文字符（硬上限 72 字符），用祈使语气，句尾不加句号。',
+  '需要时在空行后写正文：用中文短句说明改了什么、为什么，每行约 72 字符换行。',
+  '不要输出 markdown 围栏、引号、解释或「提交信息：」之类标签；即使 diff 全是英文代码，描述也必须用中文。',
+].join(' ')
+
+/** Whether the text contains at least one CJK ideograph. */
+function hasChinese(text) {
+  return /[\u3400-\u9fff]/.test(String(text || ''))
+}
+
+/**
+ * Clip one diff to the model input budget without exceeding it.
+ * @param {string} text unified diff text
+ * @returns {string} clipped text
+ */
+function clipDiff(text) {
+  const value = String(text || '')
+  if (value.length <= DIFF_MAX_CHARS) return value
+  return value.slice(0, DIFF_MAX_CHARS) + '\n... (diff truncated)'
+}
+
+/**
+ * Normalize whatever the model returned into a commit message.
+ * @param {string} raw raw model text
+ * @returns {string} sanitized message (possibly empty)
+ */
+export function sanitizeCommitMessage(raw) {
+  let text = String(raw || '').replace(/\r\n?/g, '\n').trim()
+  text = text.replace(/^```[a-zA-Z0-9_-]*\n?/, '').replace(/\n?```$/, '').trim()
+  if (
+    (text.startsWith('"') && text.endsWith('"')) ||
+    (text.startsWith('`') && text.endsWith('`')) ||
+    (text.startsWith('“') && text.endsWith('”'))
+  ) {
+    text = text.slice(1, -1).trim()
+  }
+  text = text.replace(/^(commit message|message|提交信息|commit)\s*[:：]\s*/i, '').trim()
+  if (text === '') return ''
+  const lines = text.split('\n')
+  const subject = (lines.shift() || '').trim().slice(0, SUBJECT_MAX_CHARS)
+  const body = lines.join('\n').replace(/\n{3,}/g, '\n\n').trim()
+  const message = [subject, body].filter(Boolean).join('\n\n')
+  return message.slice(0, MESSAGE_MAX_CHARS)
+}
+
+/**
+ * Resolve the provider/model route to generate with.
+ * @param {object} ctx Host context
+ * @returns {{provider:string, model:string}|null} resolved selection
+ */
+function resolveModel(ctx) {
+  const selection = ctx.get('agentDefaultModel')?.currentSelection?.()
+  const provider = selection && typeof selection.provider === 'string' ? selection.provider : ''
+  const model = selection && typeof selection.model === 'string' ? selection.model : ''
+  if (provider === '' || model === '') return null
+  return { provider, model }
+}
+
+/**
+ * Generate a commit message from the staged (or unstaged) changes.
+ * @param {object} ctx Host context
+ * @param {{git:import('./git.js').GitRunner, cwd:string, signal?:AbortSignal}} request request facts
+ * @returns {Promise<object>} `{ok:true, message}` or `{ok:false, code, detail?}`
+ */
+export async function generateCommitMessage(ctx, request) {
+  const { git, cwd, signal } = request
+  const llm = ctx.get('llm')
+  if (!llm || typeof llm.stream !== 'function') return { ok: false, code: 'llm-unavailable' }
+  const model = resolveModel(ctx)
+  if (!model) return { ok: false, code: 'model-unavailable' }
+
+  const staged = await git.run(['diff', '--cached', '--no-color', '--no-ext-diff', '--no-textconv', '-U3', '--', '.'], { cwd, signal })
+  if (staged.exitCode !== 0) return { ok: false, code: 'diff-failed', detail: staged.stderr.trim().slice(0, 400) }
+  let diff = staged.stdout
+  if (diff.trim() === '') {
+    const unstaged = await git.run(['diff', '--no-color', '--no-ext-diff', '--no-textconv', '-U3', '--', '.'], { cwd, signal })
+    if (unstaged.exitCode !== 0) return { ok: false, code: 'diff-failed', detail: unstaged.stderr.trim().slice(0, 400) }
+    diff = unstaged.stdout
+  }
+  if (diff.trim() === '') return { ok: false, code: 'no-changes' }
+
+  const userText = '为下面的 diff 写一条提交信息（简体中文，遵循 Conventional Commits 规范）：\n\n' + clipDiff(diff)
+  const attempt = async (system, text) => {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), GENERATE_TIMEOUT_MS)
+    const composite = typeof AbortSignal.any === 'function' && signal
+      ? AbortSignal.any([signal, controller.signal])
+      : controller.signal
+    let output = ''
+    let failure = null
+    try {
+      const stream = llm.stream({
+        provider: model.provider,
+        model: model.model,
+        system,
+        messages: [{
+          role: 'user',
+          content: [{ type: 'text', text }],
+        }],
+        temperature: 0.2,
+        maxTokens: 400,
+        signal: composite,
+      })
+      for await (const chunk of stream) {
+        if (!chunk) continue
+        if (chunk.type === 'text-delta' && typeof chunk.text === 'string') output += chunk.text
+        else if (chunk.type === 'finish' && chunk.reason && chunk.reason.kind === 'error') failure = chunk.reason.failure
+        else if (chunk.type === 'finish' && chunk.reason && chunk.reason.kind === 'aborted') failure = chunk.reason.failure
+      }
+    } catch (error) {
+      return { output: '', failure: null, error }
+    } finally {
+      clearTimeout(timeout)
+    }
+    return { output, failure, error: null }
+  }
+
+  let result = await attempt(SYSTEM_PROMPT, userText)
+  if (result.error && !signal?.aborted) {
+    return { ok: false, code: 'generate-failed', detail: String(result.error?.message || result.error).slice(0, 400) }
+  }
+  let message = sanitizeCommitMessage(result.output)
+  // Some models still answer English for an English diff; retry once with an
+  // explicit Chinese-only instruction before giving up.
+  if (message !== '' && !hasChinese(message)) {
+    const strict = '重要：提交信息必须使用简体中文，禁止输出英文描述。\n\n' + userText
+    result = await attempt(SYSTEM_PROMPT, strict)
+    if (result.error && !signal?.aborted) {
+      return { ok: false, code: 'generate-failed', detail: String(result.error?.message || result.error).slice(0, 400) }
+    }
+    message = sanitizeCommitMessage(result.output)
+  }
+  if (signal?.aborted) return { ok: false, code: 'aborted' }
+  if (message === '') {
+    return { ok: false, code: 'generate-failed', detail: result.failure?.message ? String(result.failure.message).slice(0, 400) : 'empty completion' }
+  }
+  return { ok: true, message }
+}

package/lib/host/files-index.js

@@ -0,0 +1,206 @@
+/**
+ * Read-only workspace index + text search for Quick Open and Search.
+ *
+ * Both surfaces walk the session workspace through `workspaceFiles.list` and
+ * read through `workspaceFiles.readBytes`; nothing is written and every walk is
+ * bounded by depth, entry count, file size, and total scan budget.
+ */
+
+/** Directories never indexed (dependency/build/VCS noise). */
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', '.hg', '.svn', 'dist', 'build', 'out', '.next', '.nuxt',
+  '.cache', '.turbo', '.parcel-cache', 'target', 'obj', 'bin', 'vendor', '.venv',
+  'venv', '__pycache__', '.idea', '.vscode', 'coverage', '.dsh', '.pnpm-store',
+])
+
+/** File extensions never read by search. */
+const BINARY_EXT = new Set([
+  'png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'ico', 'pdf', 'zip', 'gz', 'tgz', '7z', 'rar',
+  'tar', 'exe', 'dll', 'so', 'dylib', 'woff', 'woff2', 'ttf', 'otf', 'eot', 'mp3', 'mp4',
+  'mov', 'avi', 'webm', 'sqlite', 'db', 'class', 'jar', 'wasm', 'o', 'obj', 'a', 'lib', 'pdb',
+  'bcmap', 'pfb', 'zstd', 'zst', 'asar',
+])
+
+const INDEX_TTL_MS = 30000
+const MAX_FILES = 8000
+const MAX_DEPTH = 14
+const MAX_ENTRIES_PER_DIR = 2000
+const MAX_SEARCH_FILES = 1500
+const MAX_SEARCH_BYTES = 24 * 1024 * 1024
+const MAX_FILE_BYTES = 512 * 1024
+const MAX_RESULTS = 200
+const SEARCH_TIME_BUDGET_MS = 8000
+
+/**
+ * Join a parent posix path and a child name.
+ * @param {string} parent parent path ('' for root)
+ * @param {string} name child name
+ * @returns {string}
+ */
+export function joinPath(parent, name) {
+  return parent === '' ? name : parent + '/' + name
+}
+
+/**
+ * Whether a file name is searchable text.
+ * @param {string} name basename
+ * @returns {boolean}
+ */
+function searchableName(name) {
+  const dot = name.toLowerCase().lastIndexOf('.')
+  if (dot < 0) return true
+  return !BINARY_EXT.has(name.toLowerCase().slice(dot + 1))
+}
+
+/**
+ * Per-session cached workspace file index (paths only, cwd-relative posix).
+ */
+export class WorkspaceIndex {
+  /**
+   * @param {object} ctx Host context
+   * @param {number} [ttlMs] cache lifetime
+   */
+  constructor(ctx, ttlMs = INDEX_TTL_MS) {
+    this.ctx = ctx
+    this.ttlMs = ttlMs
+    this.cache = new Map()
+  }
+
+  /**
+   * Drop one session's cached index.
+   * @param {string} sessionId session identity
+   */
+  invalidate(sessionId) {
+    this.cache.delete(sessionId)
+  }
+
+  /**
+   * Walk the workspace breadth-first under the given caps.
+   * @param {{sessionId:string, workspaceRoot:string}} scope workspace scope
+   * @param {AbortSignal} signal cancellation
+   * @returns {Promise<{files:string[], truncated:boolean}>}
+   */
+  async walk(scope, signal) {
+    const files = []
+    const queue = [{ dir: '', depth: 0 }]
+    let truncated = false
+    while (queue.length > 0) {
+      if (signal?.aborted) throw new Error('aborted')
+      const next = queue.shift()
+      let listing
+      try {
+        listing = await this.ctx.workspaceFiles.list(scope, next.dir === '' ? scope.workspaceRoot : next.dir, signal)
+      } catch {
+        continue
+      }
+      const entries = Array.isArray(listing?.entries) ? listing.entries.slice(0, MAX_ENTRIES_PER_DIR) : []
+      if (listing?.truncated === true || entries.length < (listing?.entries?.length ?? 0)) truncated = true
+      for (const entry of entries) {
+        const child = joinPath(next.dir, String(entry.name))
+        if (entry.type === 'directory') {
+          if (SKIP_DIRS.has(String(entry.name).toLowerCase())) continue
+          if (next.depth + 1 > MAX_DEPTH) {
+            truncated = true
+            continue
+          }
+          queue.push({ dir: child, depth: next.depth + 1 })
+        } else if (entry.type === 'file') {
+          files.push(child)
+          if (files.length >= MAX_FILES) {
+            truncated = true
+            return { files, truncated }
+          }
+        }
+      }
+    }
+    return { files, truncated }
+  }
+
+  /**
+   * Cached index read.
+   * @param {{sessionId:string, workspaceRoot:string}} scope workspace scope
+   * @param {AbortSignal} signal cancellation
+   * @param {boolean} [force] bypass cache
+   * @returns {Promise<{files:string[], truncated:boolean, cached:boolean}>}
+   */
+  async get(scope, signal, force = false) {
+    const key = scope.sessionId + '\n' + scope.workspaceRoot
+    const now = Date.now()
+    const hit = this.cache.get(key)
+    if (!force && hit && now - hit.at < this.ttlMs) return { files: hit.files, truncated: hit.truncated, cached: true }
+    const walked = await this.walk(scope, signal)
+    this.cache.set(key, { at: now, files: walked.files, truncated: walked.truncated })
+    return { ...walked, cached: false }
+  }
+}
+
+/**
+ * Case-insensitive substring search across indexed text files.
+ * @param {object} ctx Host context
+ * @param {WorkspaceIndex} index workspace index
+ * @param {{sessionId:string, workspaceRoot:string}} scope workspace scope
+ * @param {{query:string, limit?:number, signal?:AbortSignal}} options search options
+ * @returns {Promise<{results:Array<object>, scanned:number, truncated:boolean, elapsedMs:number}>}
+ */
+export async function searchWorkspace(ctx, index, scope, options) {
+  const query = String(options.query || '').trim()
+  if (query.length === 0) return { results: [], scanned: 0, truncated: false, elapsedMs: 0 }
+  const limit = Math.min(MAX_RESULTS, Math.max(1, Number(options.limit) || MAX_RESULTS))
+  const startedAt = Date.now()
+  const signal = options.signal
+  const walk = await index.get(scope, signal)
+  const results = []
+  let scanned = 0
+  let bytes = 0
+  let truncated = walk.truncated
+  const needle = query.toLowerCase()
+  for (const path of walk.files) {
+    if (signal?.aborted) break
+    if (Date.now() - startedAt > SEARCH_TIME_BUDGET_MS) {
+      truncated = true
+      break
+    }
+    if (results.length >= limit) {
+      truncated = true
+      break
+    }
+    if (!searchableName(path)) continue
+    if (scanned >= MAX_SEARCH_FILES) {
+      truncated = true
+      break
+    }
+    scanned += 1
+    let read
+    try {
+      read = await ctx.workspaceFiles.readBytes(scope, path, {}, signal)
+    } catch {
+      continue
+    }
+    if (!read || !(read.data instanceof Uint8Array)) continue
+    if (read.data.byteLength > MAX_FILE_BYTES) {
+      truncated = true
+      continue
+    }
+    bytes += read.data.byteLength
+    if (bytes > MAX_SEARCH_BYTES) {
+      truncated = true
+      break
+    }
+    const text = new TextDecoder('utf-8', { fatal: false }).decode(read.data)
+    if (text.indexOf('\u0000') >= 0) continue
+    const lines = text.split(/\r\n|\r|\n/)
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+      const line = lines[lineIndex]
+      const at = line.toLowerCase().indexOf(needle)
+      if (at < 0) continue
+      results.push({
+        path,
+        line: lineIndex + 1,
+        column: at + 1,
+        text: line.length > 240 ? line.slice(0, 240) + '…' : line,
+      })
+      if (results.length >= limit) break
+    }
+  }
+  return { results, scanned, truncated, elapsedMs: Date.now() - startedAt }
+}