dsh-hams 0.1.2 → 0.1.4

package/src/service/contracts.ts

@@ -1,193 +0,0 @@
-/**
- * HTTP 契约：统一信封、统一回执、错误码 → 界面文案。
- *
- * 形态只有一种（backend-design §9）：
- *   POST /hams/api/v1/<domain>/<command>
- * 字面精确匹配；进站顺序固定为「验来源与主机 → 解析主体 → 校验岗位 → 解析负载 →
- * 查幂等 → 领域命令事务 → 审计与游标 → 回执」。
- *
- * 这一层只做协议与映射，不碰 `ctx.webServer`——宿主注册要等 C2 实测（能不能读
- * Origin / 自定义头）之后再接，避免把没验证过的假设写进核心路径。
- */
-import type { HamsErrorCode } from '../domain/errors.ts'
-import { HamsError } from '../domain/errors.ts'
-import type { CommandContext, CommandReceipt } from './types.ts'
-
-export interface CommandEnvelope {
-  commandId: string
-  idempotencyKey?: string
-  objectId?: string
-  expectedRevision?: number
-  expectedEpoch?: number
-  payload?: unknown
-}
-
-export interface QueryResult<T = unknown> {
-  ok: true
-  data: T
-  correlationId: string
-}
-
-export interface ErrorResult {
-  ok: false
-  correlationId: string
-  error: {
-    code: HamsErrorCode
-    message: string
-    nextStep: string
-    detail?: unknown
-  }
-}
-
-export type HamsResponseBody = CommandReceipt | QueryResult | ErrorResult
-
-/**
- * 每个错误码对应的「下一步该做什么」——界面不许自己拼字符串，也不许只说「失败」。
- * 与 backend §9 的表格一一对应；用例会断言每个码都有文案。
- */
-export const NEXT_STEP: Record<HamsErrorCode, string> = {
-  VERSION_CONFLICT: '刷新后在最新版本上重做；你的输入不会丢',
-  EVIDENCE_CHANGED: '材料已变，请按新材料重新申请',
-  APPROVAL_EXPIRED: '这张审批已过期，请重新申请',
-  NOT_APPROVER: '只有申请时指定的审批人可以处理',
-  POLICY_DENIED: '确认岗位是否在岗、是否具备该能力；需要时找管理员授权',
-  STATE_INVALID: '刷新后重试；若状态已变，按当前状态里的可用动作操作',
-  EPOCH_STALE: '这次操作已因生命周期变化作废，请刷新后重来',
-  APPROVAL_REQUIRED: '先去申请关单，等有效审批通过',
-  EVIDENCE_INCOMPLETE: '补齐缺的证据后重新申请',
-  LEASE_LOST: '租约已被回收，运行结果记为未知，请核对后再重试',
-  IDEMPOTENCY_MISMATCH: '同一幂等键不能改载荷；请换一个幂等键重试',
-  CURSOR_EXPIRED: '游标已超出保留期，请重新拉取快照',
-  DATA_STALE: '数据源已过期，结论只能记「无法判断」',
-  EXTERNAL_RESULT_UNKNOWN: '外部动作结果不明，请去对账，不要直接重发',
-  HOST_CAPABILITY_MISSING: '宿主能力缺失，已按降级方式处理；详情见诊断页',
-}
-
-export function nextStepFor(code: HamsErrorCode): string {
-  return NEXT_STEP[code] ?? '联系管理员'
-}
-
-export interface ReceiptError {
-  code: HamsErrorCode
-  message: string
-  nextStep: string
-  detail?: unknown
-}
-
-/** 领域错误 → 回执错误块；非 HamsError 一律按 STATE_INVALID 处理，绝不把堆栈抛给界面。 */
-export function toReceiptError(error: unknown): ReceiptError {
-  if (error instanceof HamsError) {
-    return {
-      code: error.code,
-      message: error.message,
-      nextStep: error.nextStep ?? nextStepFor(error.code),
-      detail: error.detail,
-    }
-  }
-  return {
-    code: 'STATE_INVALID',
-    message: error instanceof Error ? error.message : String(error),
-    nextStep: nextStepFor('STATE_INVALID'),
-  }
-}
-
-export function rejectedReceipt(correlationId: string, error: unknown): CommandReceipt {
-  return {
-    ok: false,
-    status: 'rejected',
-    auditId: '',
-    correlationId,
-    error: toReceiptError(error),
-  }
-}
-
-export function errorResult(correlationId: string, error: unknown): ErrorResult {
-  const mapped = toReceiptError(error)
-  return { ok: false, correlationId, error: mapped }
-}
-
-// ───────────────────────── 负载校验 ─────────────────────────
-//
-// 这一版不引入 zod：需要的形状很少，手写校验更直白；校验失败统一走 STATE_INVALID，
-// 界面看到的是「这个请求不完整」，而不是 500。
-
-export class PayloadError extends HamsError {
-  constructor(message: string) {
-    super('STATE_INVALID', message, { nextStep: '检查请求参数后重试' })
-    this.name = 'PayloadError'
-  }
-}
-
-export function asObject(value: unknown, field: string): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    throw new PayloadError(`${field} 必须是对象`)
-  }
-  return value as Record<string, unknown>
-}
-
-export function asString(value: unknown, field: string, options: { allowEmpty?: boolean } = {}): string {
-  if (typeof value !== 'string') throw new PayloadError(`${field} 必须是字符串`)
-  if (!options.allowEmpty && value.trim().length === 0) throw new PayloadError(`${field} 不能为空`)
-  return value
-}
-
-export function optionalString(value: unknown, field: string): string | undefined {
-  if (value === undefined || value === null) return undefined
-  return asString(value, field, { allowEmpty: true })
-}
-
-export function asNumber(value: unknown, field: string): number {
-  const parsed = typeof value === 'number' ? value : Number(value)
-  if (!Number.isFinite(parsed)) throw new PayloadError(`${field} 必须是数字`)
-  return parsed
-}
-
-export function optionalNumber(value: unknown, field: string): number | undefined {
-  if (value === undefined || value === null) return undefined
-  return asNumber(value, field)
-}
-
-export function asArray<T = unknown>(value: unknown, field: string): T[] {
-  if (!Array.isArray(value)) throw new PayloadError(`${field} 必须是数组`)
-  return value as T[]
-}
-
-export function requireEnvelope(raw: unknown, options: { write: boolean; correlationId: string }): CommandEnvelope {
-  const body = asObject(raw, '请求体')
-  const commandId = asString(body.commandId, 'commandId')
-  const idempotencyKey = optionalString(body.idempotencyKey, 'idempotencyKey')
-  if (options.write && !idempotencyKey) {
-    // 写命令必须能重放：没有幂等键就无法保证「同一个请求只生效一次」。
-    throw new PayloadError(`写命令必须带 idempotencyKey（command ${commandId}）`)
-  }
-  const envelope: CommandEnvelope = {
-    commandId,
-    idempotencyKey,
-    objectId: optionalString(body.objectId, 'objectId'),
-    expectedRevision: optionalNumber(body.expectedRevision, 'expectedRevision'),
-    expectedEpoch: optionalNumber(body.expectedEpoch, 'expectedEpoch'),
-    payload: body.payload,
-  }
-  return envelope
-}
-
-export function toCommandContext(input: {
-  principalId: string
-  channel: CommandContext['channel']
-  correlationId: string
-  envelope: CommandEnvelope
-  authSubject?: string
-  hostPreset?: string
-  onBehalfOf?: string
-}): CommandContext {
-  return {
-    principalId: input.principalId,
-    channel: input.channel,
-    correlationId: input.correlationId,
-    idempotencyKey: input.envelope.idempotencyKey,
-    expectedRevision: input.envelope.expectedRevision,
-    authSubject: input.authSubject,
-    hostPreset: input.hostPreset,
-    onBehalfOf: input.onBehalfOf,
-  }
-}

package/src/service/defaults.ts

@@ -1,182 +0,0 @@
-/**
- * 默认 bot：项目管理 / 数据分析。
- *
- * 两个 bot 是「开箱就能用」的底座，不是样例数据：
- * - 项目管理（`bot-pm`）是新项目默认的推进 bot：拆目标、派活、汇总；它没有审批/关单能力；
- * - 数据分析（`bot-data`）默认进入每个项目的群聊：查数、对比、给结论。
- *
- * 三条纪律：
- * 1. 幂等：按固定 id + 名字双查，已存在就不动（用户改过名字/配置也不覆盖）；
- * 2. 只补缺失：默认 bot 被退休/暂停后不自动复活，避免覆盖人的决定；
- * 3. 责任人必须是本机操作者（人）——bot 不能没有责任人，也不能归 bot。
- *
- * 这两个 bot 由宿主启动时调用 `ensureDefaultBots` 落库；测试里直接调用它。
- */
-import type { DatabaseSync } from 'node:sqlite'
-import { createHash } from 'node:crypto'
-import type { IdFactory } from '../domain/ids.ts'
-import { stateInvalid } from '../domain/errors.ts'
-
-export const DEFAULT_COORDINATOR_NAME = '项目管理'
-export const DEFAULT_ANALYST_NAME = '数据分析'
-export const DEFAULT_COORDINATOR_ID = 'bot-pm'
-export const DEFAULT_ANALYST_ID = 'bot-data'
-
-export interface DefaultBotSpec {
-  id: string
-  name: string
-  domain: string
-  role: 'coordinator' | 'executor'
-  responsibility: string
-  capabilities: string[]
-}
-
-export const DEFAULT_BOTS: readonly DefaultBotSpec[] = Object.freeze([
-  {
-    id: DEFAULT_COORDINATOR_ID,
-    name: DEFAULT_COORDINATOR_NAME,
-    domain: '通用',
-    role: 'coordinator',
-    responsibility:
-      '新项目默认推进 bot：把目标拆成工作项、在项目群里 @ 具体成员派活、汇总进展；改目标口径、审批与关单仍由人做。',
-    capabilities: [
-      'work_item.claim',
-      'work_item.execute',
-      'work_item.request_closure',
-      'evidence.append',
-      'check.evaluate',
-      'proposal.create',
-    ],
-  },
-  {
-    id: DEFAULT_ANALYST_ID,
-    name: DEFAULT_ANALYST_NAME,
-    domain: '通用',
-    role: 'executor',
-    responsibility:
-      '默认数据分析 bot：查指标与工作项数据、做对比、给结论并登记证据；不下市场判断、不批准关单。',
-    capabilities: [
-      'work_item.claim',
-      'work_item.execute',
-      'evidence.append',
-      'metric.record',
-      'connector.ingest',
-    ],
-  },
-])
-
-export interface DefaultBotResult {
-  created: { key: string; id: string; name: string }[]
-  existing: { key: string; id: string; name: string }[]
-}
-
-interface BotRow {
-  id: string
-  name: string
-  kind: string
-  status: string
-}
-
-function findBot(db: DatabaseSync, spec: DefaultBotSpec): BotRow | undefined {
-  // 固定 id 优先；同名只认全局成员（scope_project_id 为空），别把项目内临时 bot 当默认。
-  return db
-    .prepare(
-      `SELECT id, name, kind, status FROM member
-        WHERE id = ? OR (name = ? AND scope_project_id IS NULL)
-        ORDER BY CASE WHEN id = ? THEN 0 ELSE 1 END
-        LIMIT 1`,
-    )
-    .get(spec.id, spec.name, spec.id) as BotRow | undefined
-}
-
-/** 按成员 id 或默认名字找一个在岗的默认 bot。 */
-export function findDefaultBot(db: DatabaseSync, key: 'coordinator' | 'analyst'): BotRow | null {
-  const spec = key === 'coordinator' ? DEFAULT_BOTS[0] : DEFAULT_BOTS[1]
-  const row = findBot(db, spec)
-  return row && row.kind === 'bot' && row.status === 'active' ? row : null
-}
-
-/** 新项目没有显式指定推进 bot 时用它。找不到返回 null，不阻断建项目。 */
-export function defaultCoordinatorId(db: DatabaseSync): string | null {
-  return findDefaultBot(db, 'coordinator')?.id ?? null
-}
-
-/** 幂等创建两个默认 bot；已存在（同名或同 id）就跳过。 */
-export function ensureDefaultBots(db: DatabaseSync, ids: IdFactory, now: number, ownerHumanId: string): DefaultBotResult {
-  const owner = db.prepare('SELECT id, kind, status FROM member WHERE id = ?').get(ownerHumanId) as
-    | { id: string; kind: string; status: string }
-    | undefined
-  if (!owner || owner.kind !== 'human' || owner.status !== 'active') {
-    throw stateInvalid('默认 bot 的责任人必须是本机在岗的人')
-  }
-
-  const result: DefaultBotResult = { created: [], existing: [] }
-  const insertMember = db.prepare(
-    `INSERT INTO member (id, kind, name, domain, responsibility, role, status, current_version,
-                         owner_human_id, created_at, updated_at)
-     VALUES (?, 'bot', ?, ?, ?, ?, 'active', 1, ?, ?, ?)`,
-  )
-  const insertVersion = db.prepare(
-    `INSERT INTO member_version
-       (id, member_id, version, agent_preset, model, memory_scope_json, prompt_digest,
-        change_class, published_by, published_at)
-     VALUES (?, ?, 1, 'hams-bot', NULL, '{}', ?, 'major', ?, ?)`,
-  )
-  const grant = db.prepare(
-    'INSERT OR IGNORE INTO member_permission (member_id, capability, scope, granted_by, granted_at) VALUES (?, ?, ?, ?, ?)',
-  )
-
-  for (const spec of DEFAULT_BOTS) {
-    const existing = findBot(db, spec)
-    if (existing) {
-      result.existing.push({ key: spec.id, id: existing.id, name: existing.name })
-      continue
-    }
-    const digest = createHash('sha256').update(`${spec.name}\n${spec.responsibility}`).digest('hex').slice(0, 16)
-    insertMember.run(
-      spec.id,
-      spec.name,
-      spec.domain,
-      spec.responsibility,
-      spec.role,
-      ownerHumanId,
-      now,
-      now,
-    )
-    insertVersion.run(ids(), spec.id, digest, ownerHumanId, now)
-    for (const capability of spec.capabilities) grant.run(spec.id, capability, 'global', ownerHumanId, now)
-    result.created.push({ key: spec.id, id: spec.id, name: spec.name })
-  }
-  return result
-}
-
-/**
- * 新项目默认把数据分析 bot 拉进群：否则「@数据分析 去查一下」在开箱状态下无人可点。
- * 只补缺失，不复活被移出的人；推进 bot 自己不当群成员。
- */
-export function ensureDefaultAnalystInProject(
-  db: DatabaseSync,
-  projectId: string,
-  coordinatorId: string | null,
-  addedBy: string,
-  now: number,
-): { added: boolean; memberId: string | null } {
-  const analyst = findDefaultBot(db, 'analyst')
-  if (!analyst || analyst.id === coordinatorId) return { added: false, memberId: null }
-  const project = db.prepare('SELECT id, status FROM project WHERE id = ? AND deleted_at IS NULL').get(projectId) as
-    | { id: string; status: string }
-    | undefined
-  if (!project) return { added: false, memberId: null }
-  const existing = db
-    .prepare('SELECT removed_at FROM project_participant WHERE project_id = ? AND member_id = ?')
-    .get(projectId, analyst.id) as { removed_at: number | null } | undefined
-  if (existing && existing.removed_at === null) return { added: false, memberId: analyst.id }
-  db.prepare(
-    `INSERT INTO project_participant (project_id, member_id, kind, brief, added_by, added_at, removed_by, removed_at)
-     VALUES (?, ?, 'member', ?, ?, ?, NULL, NULL)
-     ON CONFLICT(project_id, member_id) DO UPDATE SET
-       kind = 'member', brief = excluded.brief, added_by = excluded.added_by,
-       added_at = excluded.added_at, removed_by = NULL, removed_at = NULL`,
-  ).run(projectId, analyst.id, '默认数据分析：查指标与工作项数据，出结论。', addedBy, now)
-  return { added: true, memberId: analyst.id }
-}

package/src/service/deliverables.ts

@@ -1,240 +0,0 @@
-/**
- * 项目交付物：把项目推进过程中 bot 工作区里生成的文件归集出来看。
- *
- * 两类来源（与会话适配器的工作目录约定一致）：
- * - 工作项：`<dataDir>/bots/<memberId>/work/<workItemId>/…`（只认本项目的工作项）；
- * - 项目群聊：`<dataDir>/bots/<memberId>/chats/chat-project-<projectId>/…` 与
- *   `chats/chat-group-<projectId>-<memberId>/…`（推进 bot 与群成员在群里写下的东西）。
- * 只读扫描；预览只读文本且限制大小，绝不返回二进制内容。
- */
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
-import path from 'node:path'
-import type { DatabaseSync } from 'node:sqlite'
-import { HamsError } from '../domain/errors.ts'
-
-export interface DeliverableItem {
-  /** 相对 dataDir 的路径，作为稳定 id，也用于预览时再次校验。 */
-  relPath: string
-  projectId: string
-  workItemId: string
-  workItemTitle: string
-  workItemStatus: string
-  memberId: string
-  memberName: string
-  /** work = 工作项产物；chat = 项目群聊产物。 */
-  source: 'work' | 'chat'
-  /** 工作项标题或「项目群聊」。 */
-  label: string
-  name: string
-  size: number
-  mtime: number
-}
-
-export interface DeliverableList {
-  items: DeliverableItem[]
-  truncated: boolean
-  /** 扫描过的项目工作项数，便于界面解释「为什么是空的」。 */
-  workItems: number
-}
-
-export interface DeliverableFile {
-  relPath: string
-  name: string
-  size: number
-  mtime: number
-  binary: boolean
-  truncated: boolean
-  content: string
-}
-
-const MAX_FILES = 500
-const MAX_DEPTH = 6
-const MAX_PREVIEW_BYTES = 256 * 1024
-const SKIP_DIRS = new Set(['node_modules', '.git', '.cache', '.venv', '__pycache__'])
-
-interface WorkItemRef {
-  id: string
-  title: string
-  status: string
-}
-
-function workItemsOfProject(db: DatabaseSync, projectId: string): WorkItemRef[] {
-  return db
-    .prepare('SELECT id, title, status FROM work_item WHERE project_id = ? ORDER BY updated_at DESC')
-    .all(projectId) as WorkItemRef[]
-}
-
-function memberNames(db: DatabaseSync): Map<string, string> {
-  const rows = db.prepare("SELECT id, name FROM member WHERE kind = 'bot'").all() as { id: string; name: string }[]
-  return new Map(rows.map((row) => [row.id, row.name]))
-}
-
-function walk(root: string, relRoot: string, onFile: (rel: string, size: number, mtime: number) => void, budget: { left: number }, depth = 0): void {
-  if (budget.left <= 0 || depth > MAX_DEPTH) return
-  let entries: ReturnType<typeof readdirSync>
-  try {
-    entries = readdirSync(root, { withFileTypes: true })
-  } catch {
-    return
-  }
-  for (const entry of entries) {
-    if (budget.left <= 0) return
-    if (entry.isSymbolicLink()) continue
-    const full = path.join(root, entry.name)
-    if (entry.isDirectory()) {
-      if (SKIP_DIRS.has(entry.name)) continue
-      walk(full, `${relRoot}/${entry.name}`, onFile, budget, depth + 1)
-      continue
-    }
-    if (!entry.isFile()) continue
-    let stat
-    try {
-      stat = statSync(full)
-    } catch {
-      continue
-    }
-    budget.left -= 1
-    onFile(`${relRoot}/${entry.name}`, stat.size, stat.mtimeMs)
-  }
-}
-
-export function listDeliverables(options: { db: DatabaseSync; dataDir: string; projectId: string; limit?: number }): DeliverableList {
-  const dataDir = path.resolve(options.dataDir)
-  const botsRoot = path.join(dataDir, 'bots')
-  const workItems = workItemsOfProject(options.db, options.projectId)
-  if (!existsSync(botsRoot)) return { items: [], truncated: false, workItems: workItems.length }
-  const names = memberNames(options.db)
-  const budget = { left: Math.min(Math.max(options.limit ?? MAX_FILES, 1), MAX_FILES) }
-  const items: DeliverableItem[] = []
-  let truncated = false
-  for (const memberId of readdirSync(botsRoot)) {
-    const memberDir = path.join(botsRoot, memberId)
-    let isDir = false
-    try {
-      isDir = statSync(memberDir).isDirectory()
-    } catch {
-      isDir = false
-    }
-    if (!isDir) continue
-    for (const item of workItems) {
-      const workDir = path.join(memberDir, 'work', item.id)
-      if (!existsSync(workDir)) continue
-      const relBase = `bots/${memberId}/work/${item.id}`
-      walk(workDir, relBase, (relPath, size, mtime) => {
-        items.push({
-          relPath,
-          projectId: options.projectId,
-          workItemId: item.id,
-          workItemTitle: item.title,
-          workItemStatus: item.status,
-          memberId,
-          memberName: names.get(memberId) || memberId,
-          source: 'work',
-          label: item.title,
-          name: path.posix.basename(relPath),
-          size,
-          mtime: Math.round(mtime),
-        })
-      }, budget)
-      if (budget.left <= 0) {
-        truncated = true
-        break
-      }
-    }
-    if (truncated) break
-    // 项目群聊产物：chats/chat-project-<pid>/ 与 chats/chat-group-<pid>-<memberId>/
-    const chatsDir = path.join(memberDir, 'chats')
-    if (!existsSync(chatsDir)) continue
-    for (const chatEntry of readdirSync(chatsDir)) {
-      const isProjectChat = chatEntry === `chat-project-${options.projectId}`
-        || chatEntry.startsWith(`chat-group-${options.projectId}-`)
-      if (!isProjectChat) continue
-      const chatDir = path.join(chatsDir, chatEntry)
-      let isDir = false
-      try {
-        isDir = statSync(chatDir).isDirectory()
-      } catch {
-        isDir = false
-      }
-      if (!isDir) continue
-      const relBase = `bots/${memberId}/chats/${chatEntry}`
-      walk(chatDir, relBase, (relPath, size, mtime) => {
-        items.push({
-          relPath,
-          projectId: options.projectId,
-          workItemId: '',
-          workItemTitle: '',
-          workItemStatus: '',
-          memberId,
-          memberName: names.get(memberId) || memberId,
-          source: 'chat',
-          label: '项目群聊',
-          name: path.posix.basename(relPath),
-          size,
-          mtime: Math.round(mtime),
-        })
-      }, budget)
-      if (budget.left <= 0) {
-        truncated = true
-        break
-      }
-    }
-    if (truncated) break
-  }
-  items.sort((a, b) => b.mtime - a.mtime)
-  return { items, truncated, workItems: workItems.length }
-}
-
-export function readDeliverable(options: {
-  db: DatabaseSync
-  dataDir: string
-  projectId: string
-  relPath: string
-}): DeliverableFile {
-  const dataDir = path.resolve(options.dataDir)
-  const botsRoot = path.join(dataDir, 'bots')
-  const raw = String(options.relPath || '').trim()
-  if (!raw) throw new HamsError('STATE_INVALID', '缺少文件路径')
-  if (path.isAbsolute(raw)) throw new HamsError('POLICY_DENIED', '只接受项目工作区内的相对路径')
-  const resolved = path.resolve(dataDir, raw)
-  const base = botsRoot + path.sep
-  if (!resolved.startsWith(base)) throw new HamsError('POLICY_DENIED', '只允许看 bot 工作区里的文件')
-  const parts = path.relative(dataDir, resolved).split(path.sep)
-  // bots/<memberId>/work/<workItemId>/... 或 bots/<memberId>/chats/<chatKey>/...
-  if (parts.length < 5 || parts[0] !== 'bots') {
-    throw new HamsError('POLICY_DENIED', '路径不在交付物目录约定内')
-  }
-  if (parts[2] === 'work') {
-    const workItemId = parts[3]
-    const owned = options.db
-      .prepare('SELECT 1 AS ok FROM work_item WHERE id = ? AND project_id = ?')
-      .get(workItemId, options.projectId) as { ok: number } | undefined
-    if (!owned) throw new HamsError('POLICY_DENIED', '这个文件不属于当前项目的工作项')
-  } else if (parts[2] === 'chats') {
-    const chatKey = parts[3]
-    const isProjectChat = chatKey === `chat-project-${options.projectId}`
-      || chatKey.startsWith(`chat-group-${options.projectId}-`)
-    if (!isProjectChat) throw new HamsError('POLICY_DENIED', '这个文件不属于当前项目的群聊工作区')
-  } else {
-    throw new HamsError('POLICY_DENIED', '路径不在交付物目录约定内')
-  }
-  let stat
-  try {
-    stat = statSync(resolved)
-  } catch {
-    throw new HamsError('STATE_INVALID', '文件不存在或已移走')
-  }
-  if (!stat.isFile()) throw new HamsError('STATE_INVALID', '不是普通文件')
-  const readBytes = Math.min(stat.size, MAX_PREVIEW_BYTES)
-  const buffer = readFileSync(resolved).subarray(0, readBytes)
-  const binary = buffer.subarray(0, Math.min(buffer.length, 8192)).includes(0)
-  return {
-    relPath: path.relative(dataDir, resolved).split(path.sep).join('/'),
-    name: path.posix.basename(resolved),
-    size: stat.size,
-    mtime: Math.round(stat.mtimeMs),
-    binary,
-    truncated: stat.size > readBytes,
-    content: binary ? '' : buffer.toString('utf8'),
-  }
-}