dsh-claude-move 0.2.1

package/lib/sources/codex/parser.mjs

@@ -0,0 +1,451 @@
+// SPDX-License-Identifier: Apache-2.0
+// lib/sources/codex/parser.mjs — Codex CLI 源解析器（四合一迁移向导，零 DSH 依赖）。
+//
+// 数据根定位（$CODEX_HOME / ~/.codex）→ 只读白名单 → 结构化扫描：
+//   - sessions/**/rollout-*.jsonl：流式逐行读（envelope {timestamp,type,payload}），
+//     产出会话条目（标题/消息/工具调用/畸形行计数），不整文件进内存；
+//   - skills/<name>/SKILL.md：classifySkill 判定兼容性（.system/README/MEMORY 跳过）；
+//   - memories/*.md：记忆条目；
+//   - AGENTS.md / CODEX.md：全局指令；
+//   - hooks/*/command.md：命令分类（纯提示词/含 shell）；hooks/*/prompt.md 与
+//     config.toml [commands]：钩子（不支持清单输入）。
+// 凭据与内部状态（auth.json、state_*.sqlite、logs_*.sqlite、history.jsonl、log/、
+// .tmp/、cache/、tmp/、shell_snapshots/、version.json）永不在白名单内。
+
+import path from 'node:path'
+import { homedir } from 'node:os'
+import { access, readFile, readdir } from 'node:fs/promises'
+import { createReadStream } from 'node:fs'
+import { createInterface } from 'node:readline'
+import {
+  assertAllowedRead,
+  digestText,
+  emptyDetection,
+  recordError,
+  truncateText,
+} from '../contract.mjs'
+import { classifySkill, skipSkillEntry } from '../../skill-migrate.mjs'
+import { classifyCommand } from '../../commands-migrate.mjs'
+
+export const source = 'codex'
+
+// rollout JSONL 文件名（sessions/**/rollout-*.jsonl）。
+const ROLLOUT_FILE_RE = /^rollout-.*\.jsonl$/
+
+/** Codex 数据根定位（$CODEX_HOME 优先，否则 ~/.codex）。 */
+export function locateHome(env = process.env, home = homedir()) {
+  return env.CODEX_HOME || path.join(home, '.codex')
+}
+
+/**
+ * 只读白名单：允许读取的绝对路径根列表。凭据/内部状态永不在内。
+ * @param home - Codex 数据根。
+ * @returns 绝对路径根数组（sessions/skills/hooks/memories 目录 + 三个文件）。
+ */
+export function whitelist(home) {
+  const h = path.resolve(String(home ?? ''))
+  return [
+    path.join(h, 'sessions'),
+    path.join(h, 'skills'),
+    path.join(h, 'hooks'),
+    path.join(h, 'memories'),
+    path.join(h, 'AGENTS.md'),
+    path.join(h, 'CODEX.md'),
+    path.join(h, 'config.toml'),
+  ]
+}
+
+/** ISO 时间戳 → 毫秒（parseTime 风格 Date.parse；非法返回 null）。 */
+function toMs(value) {
+  if (typeof value === 'string') {
+    const n = Date.parse(value)
+    if (Number.isFinite(n)) return n
+  } else if (typeof value === 'number' && Number.isFinite(value)) {
+    return value
+  }
+  return null
+}
+
+/** 首个非空人类文本：过滤 `<...>` 开头的 harness 注入块。 */
+function firstHumanText(payload) {
+  const content = payload && payload.content
+  if (!Array.isArray(content)) return null
+  for (const block of content) {
+    if (block && block.type === 'input_text' && typeof block.text === 'string') {
+      const text = block.text.trim()
+      if (text && !text.startsWith('<')) return text
+    }
+  }
+  return null
+}
+
+function isNotFound(err) {
+  return !!(err && err.code === 'ENOENT')
+}
+
+function throwIfAborted(signal) {
+  if (signal && signal.aborted) {
+    const err = new Error('扫描已中止')
+    err.name = 'AbortError'
+    throw err
+  }
+}
+
+function isAbort(err, signal) {
+  return !!(err && err.name === 'AbortError') || !!(signal && signal.aborted)
+}
+
+/** 相对路径 → 正斜杠 id（跨平台稳定）。 */
+function toPosix(rel) {
+  return String(rel).split(path.sep).join('/')
+}
+
+/** 路径存在性检查（不抛）。 */
+async function exists(p) {
+  try {
+    await access(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 读取单个白名单文件：越界/读取失败记入 errors；缺文件返回 null（不报错）。
+ * @returns `{ file, content }`；缺文件/失败返回 null。
+ */
+async function readOptional(detection, roots, file, scope, signal) {
+  throwIfAborted(signal)
+  let abs
+  try {
+    abs = assertAllowedRead(roots, file)
+  } catch (err) {
+    recordError(detection, scope, err)
+    return null
+  }
+  try {
+    const content = await readFile(abs, 'utf8')
+    return { file: abs, content }
+  } catch (err) {
+    if (isAbort(err, signal)) throw err
+    if (isNotFound(err)) return null
+    recordError(detection, scope, err)
+    return null
+  }
+}
+
+/** 流式逐行扫单个 rollout JSONL，统计会话条目（不整文件进内存）。 */
+async function scanSession(file, roots, signal) {
+  const abs = assertAllowedRead(roots, file)
+  let id = null
+  let cwd = null
+  let createdAt = null
+  let lastActivity = null
+  let title = null
+  let turns = 0
+  let messages = 0
+  let toolCalls = 0
+  let malformed = 0
+
+  const rl = createInterface({ input: createReadStream(abs), crlfDelay: Infinity })
+  for await (const line of rl) {
+    throwIfAborted(signal)
+    const text = line.trim()
+    if (!text) continue
+    let rec
+    try {
+      rec = JSON.parse(text)
+      if (rec === null || typeof rec !== 'object' || Array.isArray(rec)) {
+        throw new SyntaxError('record is not a JSON object')
+      }
+    } catch {
+      malformed++
+      continue
+    }
+
+    const ts = toMs(rec.timestamp)
+    if (ts != null) lastActivity = lastActivity == null ? ts : Math.max(lastActivity, ts)
+
+    const env = rec.type
+    const payload = rec.payload
+    if (env === 'session_meta' && payload) {
+      if (id == null && typeof payload.id === 'string') id = payload.id
+      if (cwd == null && typeof payload.cwd === 'string') cwd = payload.cwd
+      if (createdAt == null) {
+        const created = toMs(payload.timestamp)
+        if (created != null) createdAt = created
+      }
+      continue
+    }
+    if (env === 'turn_context' && payload) {
+      turns++
+      continue
+    }
+    if (env !== 'response_item' || !payload) continue
+
+    if (payload.type === 'message') {
+      if (payload.role === 'user' || payload.role === 'assistant') messages++
+      if (payload.role === 'user' && title == null) {
+        const human = firstHumanText(payload)
+        if (human) title = truncateText(human, 120)
+      }
+    } else if (payload.type === 'function_call' || payload.type === 'custom_tool_call') {
+      toolCalls++
+    }
+  }
+
+  return {
+    id: id || path.basename(abs),
+    file: abs,
+    turns,
+    messages,
+    toolCalls,
+    malformed,
+    format: 'rollout-jsonl',
+    ...(title ? { title } : {}),
+    ...(cwd ? { cwd } : {}),
+    ...(createdAt != null ? { createdAt } : {}),
+    ...(lastActivity != null ? { lastActivity } : {}),
+  }
+}
+
+async function scanSessions(detection, roots, home, signal) {
+  const dir = path.join(home, 'sessions')
+  throwIfAborted(signal)
+  let entries
+  try {
+    entries = await readdir(assertAllowedRead(roots, dir), { recursive: true })
+  } catch (err) {
+    if (isAbort(err, signal)) throw err
+    if (isNotFound(err)) return
+    recordError(detection, 'sessions', err)
+    return
+  }
+  for (const rel of entries) {
+    throwIfAborted(signal)
+    if (!ROLLOUT_FILE_RE.test(path.basename(rel))) continue
+    const file = path.join(dir, rel)
+    try {
+      detection.sessions.push(await scanSession(file, roots, signal))
+    } catch (err) {
+      if (isAbort(err, signal)) throw err
+      recordError(detection, 'session:' + file, err)
+    }
+  }
+}
+
+async function scanSkills(detection, roots, home, signal) {
+  const dir = path.join(home, 'skills')
+  throwIfAborted(signal)
+  let entries
+  try {
+    entries = await readdir(assertAllowedRead(roots, dir), { withFileTypes: true })
+  } catch (err) {
+    if (isAbort(err, signal)) throw err
+    if (isNotFound(err)) return
+    recordError(detection, 'skills', err)
+    return
+  }
+  for (const entry of entries) {
+    throwIfAborted(signal)
+    if (skipSkillEntry(entry.name)) continue
+    if (!entry.isDirectory()) continue
+    const skillFile = path.join(dir, entry.name, 'SKILL.md')
+    const read = await readOptional(detection, roots, skillFile, 'skill:' + skillFile, signal)
+    if (!read) continue
+    const classified = classifySkill(read.content)
+    detection.skills.push({
+      id: toPosix(path.relative(home, read.file)),
+      dir: path.dirname(read.file),
+      file: read.file,
+      name: classified.name || entry.name,
+      description: classified.description,
+      compatible: classified.compatible,
+      digest: digestText(read.content),
+    })
+  }
+}
+
+async function scanMemories(detection, roots, home, signal) {
+  const dir = path.join(home, 'memories')
+  throwIfAborted(signal)
+  let entries
+  try {
+    entries = await readdir(assertAllowedRead(roots, dir), { withFileTypes: true })
+  } catch (err) {
+    if (isAbort(err, signal)) throw err
+    if (isNotFound(err)) return
+    recordError(detection, 'memories', err)
+    return
+  }
+  for (const entry of entries) {
+    throwIfAborted(signal)
+    if (!entry.isFile() || !entry.name.endsWith('.md')) continue
+    const file = path.join(dir, entry.name)
+    const read = await readOptional(detection, roots, file, 'memory:' + file, signal)
+    if (!read) continue
+    detection.memories.push({
+      id: toPosix(path.relative(home, read.file)),
+      file: read.file,
+      kind: 'codex-memory',
+      bytes: Buffer.byteLength(read.content, 'utf8'),
+      digest: digestText(read.content),
+    })
+  }
+}
+
+async function scanInstructions(detection, roots, home, signal) {
+  const targets = [
+    ['AGENTS.md', 'agents-md'],
+    ['CODEX.md', 'codex-md'],
+  ]
+  for (const [name, kind] of targets) {
+    throwIfAborted(signal)
+    const file = path.join(home, name)
+    const read = await readOptional(detection, roots, file, name, signal)
+    if (!read) continue
+    detection.instructions.push({
+      id: toPosix(path.relative(home, read.file)),
+      file: read.file,
+      kind,
+      bytes: Buffer.byteLength(read.content, 'utf8'),
+      digest: digestText(read.content),
+    })
+  }
+}
+
+/** 去掉 TOML 行内注释（尊重双/单引号字符串）。 */
+function stripTomlComment(line) {
+  let quote = null
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i]
+    if (quote) {
+      if (ch === quote && line[i - 1] !== '\\') quote = null
+    } else if (ch === '"' || ch === "'") {
+      quote = ch
+    } else if (ch === '#') {
+      return line.slice(0, i)
+    }
+  }
+  return line
+}
+
+/** 去掉 TOML 字符串值的成对引号。 */
+function unquoteToml(value) {
+  const quoted = value.match(/^"([\s\S]*)"$|^'([\s\S]*)'$/)
+  if (!quoted) return value
+  return quoted[1] ?? quoted[2]
+}
+
+/** 最小 TOML 解析：提取 `[commands]` 段内的 `name = value` 条目。 */
+function parseTomlCommands(toml) {
+  const commands = []
+  const lines = String(toml ?? '').split(/\r?\n/)
+  let inCommands = false
+  for (const raw of lines) {
+    const line = stripTomlComment(raw).trim()
+    if (!line) continue
+    const section = line.match(/^\[([^\]]+)\]$/)
+    if (section) {
+      inCommands = section[1].trim() === 'commands'
+      continue
+    }
+    if (!inCommands) continue
+    const kv = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/)
+    if (!kv) continue
+    commands.push({ name: kv[1], value: unquoteToml(kv[2].trim()) })
+  }
+  return commands
+}
+
+async function scanConfigCommands(detection, roots, home, signal) {
+  const file = path.join(home, 'config.toml')
+  const read = await readOptional(detection, roots, file, 'config.toml', signal)
+  if (!read) return
+  let commands
+  try {
+    commands = parseTomlCommands(read.content)
+  } catch (err) {
+    recordError(detection, 'config.toml', err)
+    return
+  }
+  for (const cmd of commands) {
+    detection.hooks.push({
+      id: `config.toml:${cmd.name}`,
+      file: read.file,
+      kind: 'codex-hook',
+      matcher: cmd.name,
+      bytes: Buffer.byteLength(cmd.value, 'utf8'),
+    })
+  }
+}
+
+async function scanCommandsAndHooks(detection, roots, home, signal) {
+  const hooksDir = path.join(home, 'hooks')
+  throwIfAborted(signal)
+  let entries
+  try {
+    entries = await readdir(assertAllowedRead(roots, hooksDir), { withFileTypes: true })
+  } catch (err) {
+    if (isAbort(err, signal)) throw err
+    if (isNotFound(err)) entries = []
+    else {
+      recordError(detection, 'hooks', err)
+      entries = []
+    }
+  }
+
+  for (const entry of entries) {
+    throwIfAborted(signal)
+    if (!entry.isDirectory()) continue
+    const dir = path.join(hooksDir, entry.name)
+
+    const command = await readOptional(detection, roots, path.join(dir, 'command.md'), 'command:' + entry.name, signal)
+    if (command) {
+      const classified = classifyCommand(command.content, entry.name)
+      detection.commands.push({
+        id: toPosix(path.relative(home, command.file)),
+        file: command.file,
+        name: classified.name,
+        promptOnly: classified.promptOnly,
+        bytes: Buffer.byteLength(command.content, 'utf8'),
+        digest: digestText(command.content),
+      })
+    }
+
+    const prompt = await readOptional(detection, roots, path.join(dir, 'prompt.md'), 'prompt:' + entry.name, signal)
+    if (prompt) {
+      detection.hooks.push({
+        id: toPosix(path.relative(home, prompt.file)),
+        file: prompt.file,
+        kind: 'codex-hook',
+        bytes: Buffer.byteLength(prompt.content, 'utf8'),
+      })
+    }
+  }
+
+  await scanConfigCommands(detection, roots, home, signal)
+}
+
+/**
+ * 扫描 Codex 数据根为统一 Detection。
+ * @param home - 数据根目录。
+ * @param opts - `{ signal }`。
+ * @returns `{ source, home, homeExists, scannedAt, sessions, skills, memories,
+ *   instructions, commands, hooks, errors }`。
+ */
+export async function detect(home, { signal } = {}) {
+  const resolved = path.resolve(String(home ?? ''))
+  const detection = emptyDetection(source, resolved)
+  const roots = whitelist(resolved)
+  throwIfAborted(signal)
+  detection.homeExists = await exists(resolved)
+  if (!detection.homeExists) return detection
+
+  await scanSessions(detection, roots, resolved, signal)
+  await scanSkills(detection, roots, resolved, signal)
+  await scanMemories(detection, roots, resolved, signal)
+  await scanInstructions(detection, roots, resolved, signal)
+  await scanCommandsAndHooks(detection, roots, resolved, signal)
+  return detection
+}

package/lib/sources/contract.mjs

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: Apache-2.0
+// lib/sources/contract.mjs — 四源迁移共享契约（零 DSH 依赖）。
+//
+// 每个源在 lib/sources/<source>/ 下提供一个解析器（parser.mjs）与一个映射器
+// （mapper.mjs），两者都只依赖本契约与零依赖工具模块（convert.mjs 会话合成、
+// skill-migrate.mjs 技能兼容判定、commands-migrate.mjs 命令分类）。解析器负责
+// 数据根定位 + 只读白名单内的结构化扫描；映射器把清单变成迁移计划/不支持清单，
+// 纯函数、可独立单测。
+//
+// 解析器导出约定：
+//   export const source = 'codex'
+//   export function locateHome(env, home)   // 数据根定位（$CODEX_HOME / ~/.codex …）
+//   export function whitelist(home)         // 允许读取的绝对路径根列表（只读白名单）
+//   export async function detect(home, opts) // 结构化清单，形状见下
+//
+// 映射器导出约定：
+//   export function mapSource(source, detection, opts) → { plans, unsupported }
+
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+
+/** 支持的四个源标识（stable）。 */
+export const SOURCES = ['claude', 'codex', 'opencode', 'hermes']
+
+/** 会话类计划与文件类计划共用的幂等键前缀。 */
+export function planKey(source, kind, id) {
+  return `${source}:${kind}:${String(id ?? '')}`
+}
+
+/**
+ * 平台感知的路径包含判定（Windows 大小写不敏感）。
+ * @param root - 白名单根（绝对路径）。
+ * @param absPath - 待判定绝对路径。
+ * @returns boolean。
+ */
+export function isInsideRoot(root, absPath) {
+  const rel = path.relative(root, absPath)
+  if (rel === '' || rel === '.') return true
+  if (rel.startsWith('..') || path.isAbsolute(rel)) return false
+  return true
+}
+
+/**
+ * 只读白名单守卫：路径必须落在某个允许根内，否则大声失败（S1：绝不越界读隐私文件）。
+ * 每个源的 whitelist(home) 决定可读面；auth.json / state db / log / .env 等
+ * 凭据与内部状态永不出现在白名单里。
+ * @param roots - 允许根列表。
+ * @param absPath - 待读取的绝对路径。
+ * @returns 归一化后的绝对路径。
+ */
+export function assertAllowedRead(roots, absPath) {
+  const target = path.resolve(String(absPath ?? ''))
+  const ok = (roots ?? []).some((root) => isInsideRoot(root, target))
+  if (!ok) {
+    throw new Error(`读取越界（白名单外）：${target}`)
+  }
+  return target
+}
+
+/** 越界/失败文案的统一提取。 */
+export function errorText(err) {
+  if (err && typeof err.message === 'string') return err.message
+  return String(err)
+}
+
+/** 内容摘要（幂等比对）。 */
+export function digestText(text) {
+  return createHash('sha256').update(String(text ?? '')).digest('hex')
+}
+
+/** 标题截断（合成 fixture/映射器共用）。 */
+export function truncateText(text, max = 120) {
+  const s = String(text ?? '').trim().replace(/\s+/g, ' ')
+  return s.length <= max ? s : s.slice(0, max - 3).trimEnd() + '...'
+}
+
+/** 解析器统一返回的计数/错误骨架。 */
+export function emptyDetection(source, home) {
+  return {
+    source,
+    home,
+    homeExists: false,
+    scannedAt: new Date().toISOString(),
+    sessions: [],
+    skills: [],
+    memories: [],
+    instructions: [],
+    commands: [],
+    hooks: [],
+    errors: [],
+  }
+}
+
+/**
+ * 合并多源检测为一份索引（move_detect 全量输出）。
+ * @param detections - 各源 detect() 结果。
+ * @returns `{ sources: Detection[], stats: { sessions, skills, memories, instructions, commands, hooks } }`。
+ */
+export function mergeDetections(detections) {
+  const stats = { sessions: 0, skills: 0, memories: 0, instructions: 0, commands: 0, hooks: 0 }
+  for (const d of detections ?? []) {
+    stats.sessions += d.sessions?.length ?? 0
+    stats.skills += d.skills?.length ?? 0
+    stats.memories += d.memories?.length ?? 0
+    stats.instructions += d.instructions?.length ?? 0
+    stats.commands += d.commands?.length ?? 0
+    stats.hooks += d.hooks?.length ?? 0
+  }
+  return { sources: detections ?? [], stats }
+}
+
+/**
+ * 迁移计划形状（mapper 输出 / wizard 输入）：
+ * {
+ *   key,                       // 幂等键 = planKey(source, kind, id)
+ *   from,                      // 'claude'|'codex'|'opencode'|'hermes'（源标识）
+ *   kind,                      // 'session'|'skill'|'memory'|'instruction'|'command'|'hook'
+ *   action,                    // 'import-session'|'copy'|'convert-copy'|'append-section'|'register-command'|'unsupported'
+ *   source: { file?, dir?, name?, title?, ... },  // 源定位对象（与 from 区分，避免同名键覆盖）
+ *   target: { path?, sessionId?, commandName? },
+ *   digest?,                   // 文件类计划的内容摘要（幂等）
+ *   content?,                  // 生成内容（append-section / convert-copy）
+ *   companionDirs?,            // 技能伴随目录（复制整个技能目录时）
+ *   provider?, model?, title?, // session 类
+ *   reason?,                   // unsupported 原因（含建议）
+ * }
+ * @param source - 源标识。
+ * @param kind - 计划种类。
+ * @param id - 条目 id。
+ * @param extra - 其余字段（source 对象/action/target 等）。
+ * @returns 计划对象。
+ */
+export function makePlan(source, kind, id, extra = {}) {
+  return { key: planKey(source, kind, id), from: source, kind, ...extra }
+}
+
+/** 解析器统一的扫描错误记录。 */
+export function recordError(detection, scope, err) {
+  detection.errors.push({ scope, error: errorText(err) })
+}
+
+/** 源标识是否为受支持四源之一。 */
+export function isSourceName(value) {
+  return SOURCES.includes(value)
+}

package/lib/sources/hermes/mapper.mjs

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+// lib/sources/hermes/mapper.mjs — Hermes 源映射器（四合一迁移向导，纯函数）。
+//
+// 清单 → 迁移计划：
+//   - skills → copy（兼容：name+description 齐备，内容直拷，只改落点目录名）或
+//     convert-copy（不兼容：合成 frontmatter 后写入 SKILL.md）。
+//   - memories（MEMORY.md / USER.md，§ 分隔条目）→ append-section（DSH 全局
+//     AGENTS.md 管理段，每文件一个独立段，内容原样迁移）。
+
+import { readFileSync } from 'node:fs'
+import { assertAllowedRead, planKey } from '../contract.mjs'
+import { defaultAgentsMdPath } from '../../agmd-section.mjs'
+import { skillTargetPath, kebabName } from '../../skill-migrate.mjs'
+import { whitelist } from './parser.mjs'
+
+/**
+ * 映射 Hermes 检测清单为迁移计划。
+ * @param source - 'hermes'。
+ * @param detection - hermes/parser.mjs 的 detect() 输出。
+ * @param opts - `{ skillsDir, agentsMdPath }`；agentsMdPath 缺省 defaultAgentsMdPath()。
+ * @returns `{ plans, errors }`。
+ */
+export function mapSource(source, detection, opts = {}) {
+  const plans = []
+  const errors = []
+  const agentsMdPath = opts.agentsMdPath ?? defaultAgentsMdPath()
+  const skillsDir = opts.skillsDir
+  const roots = whitelist(detection.home)
+
+  for (const skill of detection.skills ?? []) {
+    plans.push({
+      key: planKey(source, 'skill', skill.id),
+      from: source,
+      kind: 'skill',
+      action: skill.compatible ? 'copy' : 'convert-copy',
+      source: { file: skill.file, dir: skill.dir, name: skill.name },
+      target: { path: skillTargetPath(skillsDir, kebabName(skill.name)) },
+      digest: skill.digest,
+    })
+  }
+
+  for (const memory of detection.memories ?? []) {
+    try {
+      const content = readFileSync(assertAllowedRead(roots, memory.file), 'utf8')
+      plans.push({
+        key: planKey(source, 'memory', memory.id),
+        from: source,
+        kind: 'memory',
+        action: 'append-section',
+        source: { file: memory.file, kind: memory.kind },
+        target: { path: agentsMdPath },
+        content,
+        digest: memory.digest,
+      })
+    } catch (err) {
+      errors.push(`memory:${memory.file}: ${String((err && err.message) || err)}`)
+    }
+  }
+
+  return { plans, errors }
+}