dsh-config-manager 0.1.78 → 0.1.80

package/lib/foreign/claude-sessions.js

@@ -21,12 +21,38 @@ const CLAUDE_MAX_TOKENS = 8192;
 function usageField(usage, key) {
     return typeof usage === 'object' && usage !== null ? usage[key] : undefined;
 }
+/**
+ * 推理块的类型名 = Claude Code **自己**写的两种：`thinking` 与 `redacted_thinking`。
+ *
+ * 为什么必须按类型名判定：`thinking` 块的正文在 **`thinking` 键**里（没有 `text` 字段），旧实现
+ * 沿「对象带 text 才算文本」的兜底把它变成一个**空文本块** —— 内容静默丢失，且那个空块还会多插入
+ * 一个换行。本仓其余 20+ 来源一律「推理不伪装成正文、只计数」（read-crush / read-opencode /
+ * read-qwen / read-pi / read-openclaw …），这里对齐同一口径；共享 IR 无 reasoning 承载位这件事
+ * 记在 docs/spec/known-gaps.md 的 F-01。
+ *
+ * **为什么不把 `{type:'reasoning', text:'…'}` 一并纳入**（如实记明，别当成漏掉）：
+ *  ① Claude Code 不写这种块（它是别的导出器的归一命名，各来源自己的解析器已各自计报）；
+ *  ② 共享 IR 的文本兜底分支（**对象带 `text` 就当文本块**）是**被逐字节回归钉住的既有行为**
+ *     （见 `blocksOf` 的注释），而这个块恰好命中它 —— 一并丢掉会让
+ *     `claude-sessions-bytes.test.ts` 的 `timestamps-numeric-and-unparsable` 一案从 728 字节
+ *     变成 722 字节（正文少一段 'r'）。那是**用户可见**的正文变化，按本轮的硬约束（既有语料
+ *     逐字一致）不由「修推理块静默丢弃」顺手引入。
+ *  ③ 要一并计报，改这一个数组即可，并同步更新该案基线（现行行为已被
+ *     `claude-sessions.test.ts` 的「reasoning 形状」用例显式钉住）。
+ */
+const REASONING_BLOCK_TYPES = ['thinking', 'redacted_thinking'];
+/** 推理块的占位（字段一律空：它不进 IR，只需被识别出来计数） */
+function reasoningBlock() {
+    return { kind: 'thinking', text: '', id: '', name: '', input: undefined, isError: false };
+}
 function blockOf(raw) {
     const rec = typeof raw === 'object' && raw !== null && !Array.isArray(raw) ? raw : undefined;
     if (rec === undefined) {
         return { kind: 'other', text: '', id: '', name: '', input: undefined, isError: false };
     }
     const rawType = irStr(rec['type']) ?? '';
+    if (REASONING_BLOCK_TYPES.includes(rawType))
+        return reasoningBlock();
     const id = irStr(rec['id']) ?? '';
     const name = irStr(rec['name']);
     const isText = rawType === 'text' || typeof rec['text'] === 'string';
@@ -126,6 +152,33 @@ export function parseClaudeSession(file, options, stats) {
 function typeOf(rec) {
     return irStr(rec['type']) ?? 'unknown';
 }
+/**
+ * 墙钟回落的**唯一**来源（缺陷 1 的修复）。
+ *
+ * 为什么必须只有一处：会话产物的字节里带 createdAt / 各行各列的时间；只要有一次 `Date.now()`
+ * 参与，同一来源两次转码的字节就必然不同 ⇒ DSH 侧「同内容 → Skip」永不成立、重复导入恒判
+ * Conflict。旧实现 parse 与 synthesize **各调一次** `Date.now()`（返回值还可能是两个不同的毫秒）。
+ *
+ * 回落链（前三级都是确定性的：同一输入 → 同一产物）：
+ *  ① `options.now`（调用方/测试显式给定；**保持最高优先级**，既有字节回归靠它稳定）；
+ *  ② 记录自身的最早可解析时间戳（会话文件里最权威的确定性来源）；
+ *  ③ `input.createdAtMs`（读盘层给的回落值：最早可解析记录时间，没有就给文件 mtime）；
+ *  ④ 都没有 → `Date.now()`，并**如实记账**（`timestampsFallback`）。
+ *
+ * 非法值（非安全整数 / 非有限数）一律当「没给」：DSH 对时间字段要求安全整数，宁可继续回落也
+ * 不写出一条会被拒读的行。
+ */
+function resolveWallClock(file, options, earliest) {
+    const explicit = irSafeTime(options.now);
+    if (explicit !== undefined)
+        return { now: explicit, fallback: false };
+    if (earliest !== undefined)
+        return { now: earliest, fallback: false };
+    const given = irSafeTime(file.createdAtMs);
+    if (given !== undefined)
+        return { now: given, fallback: false };
+    return { now: Date.now(), fallback: true };
+}
 /**
  * 解析入口：**只走一遍 JSON.parse**，把「记录 / cwd / 最早时间 / IR 消息 / 标题」一次算齐。
  *
@@ -137,37 +190,51 @@ function parseClaudeSessionText(file, options) {
     const records = parseJsonlObjects(file.text, stats);
     let cwd;
     let createdAt;
+    let sidechain = 0;
     for (const r of records) {
+        // 子代理记录（真实 Claude 的子代理对话就是 type=user/assistant + isSidechain:true）：
+        // 它们**不是父对话的回合**，混进来会静默改写父对话正文（设计文档 2026-10-04-foreign-import-v1.md:89
+        // 「不迁移 isSidechain 的子代理会话」，而旧实现连计数都没有）。
+        // 它们仍参与 cwd / 最早时间：子代理与父对话同属一份日志文件，cwd 与时间线是**文件级**事实。
+        if (r['isSidechain'] === true)
+            sidechain++;
         if (cwd === undefined)
             cwd = irStr(r['cwd']);
         createdAt = irEarlier(createdAt, irSafeTime(r['timestamp']));
     }
+    // 墙钟回落**只在这里解析一次**，转码入口复用 `now`（同一输入一次调用内不可能出现两个 Date.now()）
+    const wall = resolveWallClock(file, options, createdAt);
     const messages = [];
     let messageIndex = 0;
+    let thinking = 0;
     let firstUserText = '';
     for (const rec of records) {
         const type = typeOf(rec);
         if (type !== 'user' && type !== 'assistant')
             continue;
+        if (rec['isSidechain'] === true)
+            continue;
         const blocks = blocksOf(rec['message']);
-        const message = irMessageOf(rec, blocks, messageIndex);
+        // 推理块：先逐条计数，再**整块丢掉**（既不进 IR，也不留空文本块 —— 空块还会污染正文的换行串联）
+        thinking += blocks.filter((b) => b.kind === 'thinking').length;
+        const carried = blocks.filter((b) => b.kind !== 'thinking');
+        const message = irMessageOf(rec, carried, messageIndex);
         if (message === undefined)
             continue;
         messages.push(message);
         // 消息 id 的兜底序 = 「第几条已知消息」（重构前的序号语义，逐字节回归钉住）
         messageIndex++;
         if (type === 'user' && firstUserText === '') {
-            const text = irTextOfBlocks(blocks.map(irBlockOf));
+            const text = irTextOfBlocks(carried.map(irBlockOf));
             if (text.trim() !== '')
                 firstUserText = text;
         }
     }
-    const now = options.now ?? Date.now();
     return {
         session: {
             id: file.id,
             cwd: cwd ?? '',
-            createdAt: createdAt ?? now,
+            createdAt: createdAt ?? wall.now,
             records: records.length,
             messages,
         },
@@ -175,6 +242,10 @@ function parseClaudeSessionText(file, options) {
         cwd,
         unparsable: stats.unparsable,
         title: titleOf(records, firstUserText),
+        sidechain,
+        thinking,
+        now: wall.now,
+        wallClockFallback: wall.fallback,
     };
 }
 /* ---------------- ② ③ 合成 + 编码 ---------------- */
@@ -194,22 +265,33 @@ export function dshSessionLogName(version) {
     return version === 0 ? 'session.jsonl.zstd' : 'session.v' + version + '.jsonl.zstd';
 }
 export function transcodeClaudeSession(file, options) {
+    /**
+     * 非致命发现（会话照样产出）：记录里的 sessionId 与文件名 stem 不一致时**如实报码**，
+     * 但会话 id 仍以文件名 stem 为准（DSH 按「目录名 / 文件名」定位会话）。读盘层没给
+     * `recordSessionId`（老调用方）就什么都不报 —— 不猜。
+     */
+    const findings = [];
+    const recordSessionId = irStr(file.recordSessionId);
+    if (recordSessionId !== undefined && recordSessionId !== file.id) {
+        findings.push({ code: 'session-id-mismatch', origin: file.id });
+    }
     if (!SUPPORTED_DSH_SESSION_FORMAT_VERSIONS.includes(options.formatVersion)) {
-        return { skip: { code: 'session-format-unsupported', detail: String(options.formatVersion) } };
+        return { skip: { code: 'session-format-unsupported', detail: String(options.formatVersion) }, findings };
     }
     if (!isSafeIrId(file.id))
-        return { skip: { code: 'session-unsafe-id', detail: file.id } };
+        return { skip: { code: 'session-unsafe-id', detail: file.id }, findings };
     const parsed = parseClaudeSessionText(file, options);
     if (parsed.records.length === 0)
-        return { skip: { code: 'session-empty' } };
+        return { skip: { code: 'session-empty' }, findings };
     if (parsed.cwd === undefined)
-        return { skip: { code: 'session-missing-cwd', detail: file.id } };
+        return { skip: { code: 'session-missing-cwd', detail: file.id }, findings };
     // 有内容但一行都解析不出来：如实区分「空文件」与「解析不了」（诊断更准，不新增码 —— 两者
     // 在下游都是「这条会话没有产出」，区别只在忽略计数里可见）
     if (parsed.session.messages.length === 0 && parsed.unparsable > 0) {
-        return { skip: { code: 'session-unparsable', detail: file.id } };
+        return { skip: { code: 'session-unparsable', detail: file.id }, findings };
     }
-    const now = options.now ?? Date.now();
+    // 时间兜底**只有一处**（parseClaudeSessionText 里解析过一次）：这里绝不再调 Date.now()
+    const now = parsed.now;
     const stats = {
         ignored: {},
         userMessages: 0,
@@ -219,9 +301,18 @@ export function transcodeClaudeSession(file, options) {
     };
     if (parsed.unparsable > 0)
         irBump(stats.ignored, 'unparsable', parsed.unparsable);
-    // 未迁移的记录类型**逐类计数**（sidechain / attachment / queue-operation / system …）——
-    // IR 只承载 user/assistant 消息，所以这里按原始记录把其余类型补进忽略计数
+    // 推理块：共享 IR 没有承载位 → 计报，绝不伪装成正文（与其余 20+ 来源同口径）
+    if (parsed.thinking > 0)
+        irBump(stats.ignored, 'thinking', parsed.thinking);
+    // 子代理记录：不进 IR → 整类计报（detail 固定为 isSidechain）
+    if (parsed.sidechain > 0)
+        irBump(stats.ignored, 'isSidechain', parsed.sidechain);
+    // 未迁移的记录类型**逐类计数**（attachment / queue-operation / system …）——
+    // IR 只承载 user/assistant 消息，所以这里按原始记录把其余类型补进忽略计数。
+    // isSidechain 记录已整类记账（上一步），不在这里重复计数。
     for (const rec of parsed.records) {
+        if (rec['isSidechain'] === true)
+            continue;
         const type = typeOf(rec);
         if (type === 'user' || type === 'assistant')
             continue;
@@ -236,7 +327,7 @@ export function transcodeClaudeSession(file, options) {
         maxTokens: CLAUDE_MAX_TOKENS,
     }, stats, now);
     if (rows.length === 0)
-        return { skip: { code: 'session-empty' } };
+        return { skip: { code: 'session-empty' }, findings };
     const header = {
         type: 'session',
         version: options.formatVersion,
@@ -247,6 +338,11 @@ export function transcodeClaudeSession(file, options) {
         delegationDepth: 0,
     };
     const data = encodeDshSessionLog(header, rows);
+    // 结算类记账（与 ignored 分开放：ignored 的键会被下游翻成 unsupported-session-record 码）。
+    // 0 也写出来：调用方一眼能看出「这次转码是否确定性」，不需要靠键的有无去猜。
+    const counts = {
+        timestampsFallback: parsed.wallClockFallback ? 1 : 0,
+    };
     return {
         session: {
             id: file.id,
@@ -260,8 +356,10 @@ export function transcodeClaudeSession(file, options) {
                 toolCalls: stats.toolCalls,
                 toolResults: stats.toolResults,
                 ignored: stats.ignored,
+                counts,
             },
         },
+        findings,
     };
 }
 /** 帧拼接：首帧 = header 单行 JSON，之后每批事件一帧（与 DSH 的物理编码一致，帧带内容校验和） */

package/lib/foreign/read-claude-code.d.ts

@@ -1,24 +1,53 @@
-import type { ClaudeCodeInput, ForeignLimitOverrides, ForeignSkip } from './types.ts';
+import type { ClaudeCodeInput, ClaudeSkillInput, ForeignLimitOverrides, ForeignSkip } from './types.ts';
 export interface ClaudeCodeReadOptions {
     /** 用户 home（含 .claude 目录 / .claude.json） */
     homeDir: string;
+    /** 进程环境快照（只读）：只有 CLAUDE_CONFIG_DIR 参与判定，绝不读凭据类变量 */
+    env?: Readonly<Record<string, string | undefined>>;
+    /** 调用方**显式**给出的项目根（优先于 ~/.claude.json 的 projects 键；缺省 = 不猜任何项目） */
+    projectPaths?: readonly string[];
     /** 单文件读取上限（默认 8 MiB）；超过即不读，并如实计入 unreadable */
     maxFileBytes?: number;
     /** 单个 skill 目录的文件数上限（默认 200） */
     maxSkillFiles?: number;
-    /** 会话文件数上限（默认 500） */
+    /** 会话文件数上限（默认 500）；触顶报 source-unreadable/max-sessions-reached */
     maxSessionFiles?: number;
     /** 单个会话文件的上限（默认 32 MiB）；超限即不读并计入 unreadable，绝不截断 */
     maxSessionFileBytes?: number;
+    /** 项目扫描上限（默认 50）；触顶报 source-unreadable/max-projects-reached */
+    maxProjects?: number;
+    /** 插件数上限（默认 50，透传给 read-claude-plugins） */
+    maxPlugins?: number;
+    /** 单插件文件数上限（默认 200，透传给 read-claude-plugins） */
+    maxPluginFiles?: number;
     /** 可选上限覆盖（t36，装配层透传；缺省 = 上面各默认值逐字不变） */
     limits?: ForeignLimitOverrides;
 }
 export interface ClaudeCodeReadResult {
-    /** 是否找到 Claude Code 的痕迹（~/.claude 目录或 ~/.claude.json） */
+    /** 是否找到 Claude Code 的痕迹（配置目录或 ~/.claude.json） */
     found: boolean;
     input: ClaudeCodeInput;
     skipped: ForeignSkip[];
-    /** 读不到 / 超限 / JSON 解析失败的**相对路径**（不含任何内容） */
+    /** 读不到 / 超限 / JSON 解析失败的**相对路径**（不含任何内容、不含机器绝对路径） */
     unreadable: string[];
 }
+/** 技能目录读取的可选参数（用户级 / 项目级 / 插件级共用同一份口径） */
+export interface SkillDirReadOptions {
+    /** 单个技能目录的文件数上限 */
+    maxFiles: number;
+    /** 单文件字节上限 */
+    maxBytes: number;
+    /** 位置标签前缀（**包内相对标签**，绝不含机器路径） */
+    origin: string;
+    /** 发现写这里（符号链接跳过 / 条数触顶 / 字节超限） */
+    skips: ForeignSkip[];
+}
+/**
+ * 读一个 **skills 目录**（只压平一层：`<skills>/<技能名>/**`）。
+ *
+ * 三条不静默（缺陷 2 修复）：技能目录本身是符号链接 → source-unreadable + symlink-skipped；
+ * 条数触顶 → max-skill-files-reached；单文件超字节 → too-large。
+ * 结果按技能名排序（readdir 顺序在三个平台不同）。
+ */
+export declare function readSkillUnits(dir: string, opts: SkillDirReadOptions): Promise<ClaudeSkillInput[]>;
 export declare function readClaudeCode(opts: ClaudeCodeReadOptions): Promise<ClaudeCodeReadResult>;