dsh-knit 0.23.1 → 0.24.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +76 -0
- package/README.en.md +36 -7
- package/README.md +30 -6
- package/SECURITY.md +5 -2
- package/package.json +3 -3
- package/src/client/client.js +295 -8
- package/src/host/changes.js +208 -0
- package/src/host/git.js +377 -0
- package/src/host/index.js +228 -5
- package/test/client.test.mjs +270 -4
- package/test/git-changes.test.mjs +1238 -0
- package/test/host-http.test.mjs +4 -58
- package/test/http-harness.mjs +79 -0
package/src/host/index.js
CHANGED
|
@@ -41,11 +41,16 @@ import { sharedIndexStore, headHashOf, refsShapeOk } from './index-store.js'
|
|
|
41
41
|
import {
|
|
42
42
|
createSemanticEngine, sharedSemanticStore, normalizeProviderConfig,
|
|
43
43
|
} from './semantic.js'
|
|
44
|
+
// v0.25:Git 变更关联检索。**只读、有界、默认关闭** —— `git.js` 只跑一条
|
|
45
|
+
// `git status --porcelain=v1 -z`(argv 是数组,绝不走 shell;写动词一个都没有),
|
|
46
|
+
// `changes.js` 把变更文件当种子去**已有的**关系事实表里取边,不发明关系。
|
|
47
|
+
import { createGitReader, MAX_REPORTED_FILES } from './git.js'
|
|
48
|
+
import { splitSeeds, ghostCandidates, projectChangeRelated, MAX_CHANGE_RELATED } from './changes.js'
|
|
44
49
|
// v0.14:上下文装配。同样由这里注入依赖(`list` / `read`),保持纯函数可单测。
|
|
45
50
|
// ⚠️ 这里**只 import `buildContext`**:Context Pack 的文本渲染只在 `tool.js` 的
|
|
46
51
|
// `renderToolText()` 里发生(模型看到的是那段文本,不是结构化 JSON)。曾经多导出一个
|
|
47
52
|
// `renderContextText` 却没人调用 —— 那是个会与 `tool.js` 漂移的第二渲染器,已删。
|
|
48
|
-
import { buildContext } from './context.js'
|
|
53
|
+
import { buildContext, sourceTypeOf } from './context.js'
|
|
49
54
|
// v0.20:内容片段层(Deep Context Retrieval)。**纯函数、不读盘**,
|
|
50
55
|
// 目录遍历与缓存全在本文件 —— 它只回答「这篇正文里哪几段相关」。
|
|
51
56
|
import { passageMatchesFor, passageTfOf, PASSAGE_WINDOW } from './passage.js'
|
|
@@ -1578,6 +1583,13 @@ let controlRegistry = createControlRegistry(null)
|
|
|
1578
1583
|
*/
|
|
1579
1584
|
let semanticEngine = createSemanticEngine({ store: null })
|
|
1580
1585
|
|
|
1586
|
+
/**
|
|
1587
|
+
* v0.25 · 进程内的 Git 读取器。**只有 `changes=1` 那一轮才会真的去跑 git** ——
|
|
1588
|
+
* 默认关闭意味着默认这条路上一个进程都不 spawn(用户需求 §三.3 的「不悄悄改变基础检索行为」)。
|
|
1589
|
+
* 缓存(8 秒)与「不是仓库」的负缓存都在它内部,见 `git.js`。
|
|
1590
|
+
*/
|
|
1591
|
+
const gitReader = createGitReader()
|
|
1592
|
+
|
|
1581
1593
|
/**
|
|
1582
1594
|
* v0.23 Phase A:跑一轮**有界**语义候选。
|
|
1583
1595
|
*
|
|
@@ -1837,7 +1849,7 @@ export async function scan(root, limit, options = {}) {
|
|
|
1837
1849
|
ordered = pool.map((doc) => ({ ...doc, score: null }))
|
|
1838
1850
|
}
|
|
1839
1851
|
|
|
1840
|
-
|
|
1852
|
+
const out = {
|
|
1841
1853
|
ok: true,
|
|
1842
1854
|
root,
|
|
1843
1855
|
// v0.19 修订:`root` 是会话自己那条路径(可能含符号链接,用于显示);
|
|
@@ -1865,6 +1877,11 @@ export async function scan(root, limit, options = {}) {
|
|
|
1865
1877
|
// 全量列表(未按 limit 切片)。**内部输入**:v0.17 的 lifecycle 需要「被读过但
|
|
1866
1878
|
// 不一定落在当前页」的文档的当前 mtime。由 `publicScanPayload()` 剥掉。
|
|
1867
1879
|
allDocs: ordered,
|
|
1880
|
+
// v0.25:**文档 + 代码**那一份语料(与类型档无关)。Git 变更关联要在「文档 ↔ 代码」
|
|
1881
|
+
// 之间找证据(`documents` / `imports` / `tests` 三类都跨档),而面板的档位把语料切开了;
|
|
1882
|
+
// 所以这里多带一份**不分档**的候选集给它。它只是一组引用(记录本身已在 `allDocs` 里),
|
|
1883
|
+
// 由 `publicScanPayload()` 剥掉,不下发。
|
|
1884
|
+
contextCorpus: collected.docs.concat(collected.code),
|
|
1868
1885
|
// v0.19 扫描计数(需求 §50 要报的那几个数:见到的 / 准入的 / 被排除的 / 生成噪声)
|
|
1869
1886
|
// 加上 `corpusSize`(本档语料的实际大小,即 `allDocs.length`)。
|
|
1870
1887
|
// **内部输入**,由 `publicScanPayload()` 剥掉 —— HTTP 响应形状一个键都不加。
|
|
@@ -1874,6 +1891,59 @@ export async function scan(root, limit, options = {}) {
|
|
|
1874
1891
|
semantic,
|
|
1875
1892
|
},
|
|
1876
1893
|
}
|
|
1894
|
+
// v0.25:记一份给独立接口复用(见 `corpusForChanges`)。**只写不读**,扫描语义不变。
|
|
1895
|
+
scanMemoState = { root, at: Date.now(), payload: out }
|
|
1896
|
+
return out
|
|
1897
|
+
}
|
|
1898
|
+
|
|
1899
|
+
/**
|
|
1900
|
+
* **最近一次扫描**的备忘(v0.25)。
|
|
1901
|
+
*
|
|
1902
|
+
* 存在的唯一理由是:Git 变更关联现在走**独立接口** `/knit/api/changes`,而它需要与
|
|
1903
|
+
* `/api/recent` **同一份**工作区语料。如果它自己再 `scan()` 一次,一轮轮询就会
|
|
1904
|
+
* **走两遍目录树**——那正是「不得因为两个请求重复扫描整个工作区」要禁掉的事。
|
|
1905
|
+
*
|
|
1906
|
+
* ⚠️ 这份备忘**只被独立接口读**,`scan()` 自己从不读它 ⇒ 扫描的语义一个字节没变
|
|
1907
|
+
* (同一进程里连续两次 `scan()` 依旧各自真扫,增量索引那套测试的前提因此不被动摇)。
|
|
1908
|
+
* TTL 与 `git.js` 的 `GIT_CACHE_TTL_MS`(8 s)**同窗**:一个快照窗口 = 一次扫描 + 一次 git。
|
|
1909
|
+
*/
|
|
1910
|
+
const SCAN_MEMO_TTL_MS = 8000
|
|
1911
|
+
let scanMemoState = null
|
|
1912
|
+
|
|
1913
|
+
/** 仅供测试:读当前备忘(`null` = 没有可复用的扫描)。 */
|
|
1914
|
+
export function scanMemo() {
|
|
1915
|
+
if (!scanMemoState) return null
|
|
1916
|
+
if (Date.now() - scanMemoState.at > SCAN_MEMO_TTL_MS) return null
|
|
1917
|
+
return { root: scanMemoState.root, at: scanMemoState.at }
|
|
1918
|
+
}
|
|
1919
|
+
|
|
1920
|
+
/** 仅供测试:清掉备忘,好把「复用」与「真扫」两条路分开断言。 */
|
|
1921
|
+
export function resetScanMemo() {
|
|
1922
|
+
scanMemoState = null
|
|
1923
|
+
}
|
|
1924
|
+
|
|
1925
|
+
/**
|
|
1926
|
+
* 仅供测试:清掉 **git 状态缓存**。
|
|
1927
|
+
*
|
|
1928
|
+
* 与 `resetScanMemo()` 配对使用:只证明「缓存热的时候看不见变化」是不够的 ——
|
|
1929
|
+
* 还要证明「缓存冷了变化就出现」。两条合起来才说明那个「看不见」是缓存造成的,
|
|
1930
|
+
* 而不是接口本来就对文件增删无感。
|
|
1931
|
+
*/
|
|
1932
|
+
export function resetGitReaderCache() {
|
|
1933
|
+
gitReader.reset()
|
|
1934
|
+
}
|
|
1935
|
+
|
|
1936
|
+
/**
|
|
1937
|
+
* 独立接口要的那份语料:**优先复用最近一次扫描**,没有(或过期)才真扫一遍。
|
|
1938
|
+
*
|
|
1939
|
+
* @param {string} root - 工作区根
|
|
1940
|
+
* @param {object} fallback - 真扫时用的参数(与 `/api/recent` 同一组:同参数才能命中同一份语料)
|
|
1941
|
+
* @returns {Promise<object>} `scan()` 的完整载荷
|
|
1942
|
+
*/
|
|
1943
|
+
export async function corpusForChanges(root, fallback) {
|
|
1944
|
+
const memo = scanMemoState
|
|
1945
|
+
if (memo && memo.root === root && Date.now() - memo.at <= SCAN_MEMO_TTL_MS) return memo.payload
|
|
1946
|
+
return scan(root, fallback.limit, fallback.options)
|
|
1877
1947
|
}
|
|
1878
1948
|
|
|
1879
1949
|
/**
|
|
@@ -1889,10 +1959,11 @@ export async function scan(root, limit, options = {}) {
|
|
|
1889
1959
|
*/
|
|
1890
1960
|
export function publicScanPayload(payload) {
|
|
1891
1961
|
if (!payload || typeof payload !== 'object') return payload
|
|
1892
|
-
const { ranked, task, allDocs, stats, ...rest } = payload
|
|
1962
|
+
const { ranked, task, allDocs, contextCorpus, stats, ...rest } = payload
|
|
1893
1963
|
void ranked
|
|
1894
1964
|
void task
|
|
1895
1965
|
void allDocs
|
|
1966
|
+
void contextCorpus
|
|
1896
1967
|
void stats
|
|
1897
1968
|
return rest
|
|
1898
1969
|
}
|
|
@@ -1986,7 +2057,122 @@ export async function buildContextFor(root, options = {}) {
|
|
|
1986
2057
|
// 「固定上下文」区(`pack.pinned`,来源 `manual`)—— 三层的连续编号规则因此一个字不动。
|
|
1987
2058
|
// 条目只从这一包现成的行里取,零新 I/O;固定了一篇但这一批里没有它,**不硬凑**。
|
|
1988
2059
|
// 显式传入的 `control` 优先(测试用),否则问进程内的控制状态 —— 与 `scan()` 同一条口径。
|
|
1989
|
-
|
|
2060
|
+
const withPin = applyPinOverride(pack, options.control || controlRegistry.controlOf(root))
|
|
2061
|
+
// ⚠️ v0.25(第二轮修订):**变更关联不在这里**。它不再往 Context Pack 里挂任何东西 ——
|
|
2062
|
+
// 「三层 + 固定区」就是这个函数的全部产出,与 v0.24 逐字相同(有测试守着)。
|
|
2063
|
+
// 变更关联走**独立的 `/knit/api/changes` 接口**(`changesPayload()`),
|
|
2064
|
+
// 因为它是「另一个问题的答案」,不是这一份包的第四条目录。
|
|
2065
|
+
return withPin
|
|
2066
|
+
}
|
|
2067
|
+
|
|
2068
|
+
/**
|
|
2069
|
+
* v0.25 · **Git 变更关联**:独立接口 `/knit/api/changes` 的载荷构造函数。
|
|
2070
|
+
*
|
|
2071
|
+
* 它**不碰** Context Pack:不改三层、不改固定区、不改编号、不改排序 —— 那份包由
|
|
2072
|
+
* `buildContextFor()` 原样产出,两条路径唯一的交汇点是「同一个工作区扫描结果」与
|
|
2073
|
+
* 「同一张关系事实表」。
|
|
2074
|
+
*
|
|
2075
|
+
* **数据结构是专用的**(不是 Context Pack 条目,也不复用 `provenance` / `reason` 那套词汇):
|
|
2076
|
+
*
|
|
2077
|
+
* ```
|
|
2078
|
+
* { ok, root, hostRoot, mode: 'changes',
|
|
2079
|
+
* git: { available, reason, filesTotal, truncated, files: [{rel, kinds[], origRel?}] },
|
|
2080
|
+
* links: [ { target, // 关联目标(工作区相对路径)
|
|
2081
|
+
* kind, source, // 目标自身的分类(宿主给,客户端不看扩展名)
|
|
2082
|
+
* title, summary, mtimeMs,
|
|
2083
|
+
* evidence: [ { origin, // **变更起点**:牵出这条关联的那个被改过的文件
|
|
2084
|
+
* type, // 关系类型:references | imports | tests | documents
|
|
2085
|
+
* dir, // 方向(见下):相对**目标**而言
|
|
2086
|
+
* line } ], // **真实存在时**才给行号;`tests` 是文件名约定 ⇒ null
|
|
2087
|
+
* evidenceTotal, types } ],
|
|
2088
|
+
* linksTotal, unresolved: [rel], outOfScope: [rel] }
|
|
2089
|
+
* ```
|
|
2090
|
+
*
|
|
2091
|
+
* ⚠️ `dir` 是必需的第五个字段,不是冗余:没有它,「`src/foo.ts` 与 `docs/guide.md` 之间的
|
|
2092
|
+
* `documents` 边」读起来会分不清**谁提到谁**(`dir='in'` = 起点指向目标;`dir='out'` = 目标
|
|
2093
|
+
* 指向起点)。它与 v0.21 行级证据里的 `dir` 逐字同源,所以客户端**不需要第二条渲染路径**。
|
|
2094
|
+
*
|
|
2095
|
+
* @param {string} root - 工作区根
|
|
2096
|
+
* @param {{corpus: Array<object>, changeSet?: object, gitReader?: object}} input
|
|
2097
|
+
* `corpus` = `scan()` 给的**不分档**候选集(文档 + 代码);`changeSet` 只在测试里注入
|
|
2098
|
+
* @returns {Promise<object>} 这个接口的完整载荷(**任何情况下都不抛**)
|
|
2099
|
+
*/
|
|
2100
|
+
export async function changesPayload(root, input = {}) {
|
|
2101
|
+
const corpus = Array.isArray(input.corpus) ? input.corpus : []
|
|
2102
|
+
const reader = input.gitReader && typeof input.gitReader.read === 'function' ? input.gitReader : gitReader
|
|
2103
|
+
const changeSet = input.changeSet && typeof input.changeSet === 'object'
|
|
2104
|
+
? input.changeSet
|
|
2105
|
+
: await reader.read(root)
|
|
2106
|
+
const git = {
|
|
2107
|
+
available: changeSet.available === true,
|
|
2108
|
+
reason: changeSet.reason || null,
|
|
2109
|
+
// 面板要说的第一句话是「你改了几个文件」。给出的是**解析后**的条数(截断时另标 truncated)。
|
|
2110
|
+
filesTotal: Number(changeSet.filesTotal) || 0,
|
|
2111
|
+
truncated: changeSet.truncated === true,
|
|
2112
|
+
files: (Array.isArray(changeSet.files) ? changeSet.files : []).slice(0, MAX_REPORTED_FILES)
|
|
2113
|
+
.map((f) => ({ rel: f.rel, kinds: Array.isArray(f.kinds) ? f.kinds : [], ...(f.origRel ? { origRel: f.origRel } : {}) })),
|
|
2114
|
+
}
|
|
2115
|
+
// ⚠️ 载荷里**不带 `root` / `hostRoot`**:它们是绝对文件系统路径,而客户端只用工作区相对
|
|
2116
|
+
// 路径就能定位每一篇(`target` / `origin` 都是 rel)。面板要从别处拿根路径就去问
|
|
2117
|
+
// `/api/recent`(它本来就有)—— 关联接口不重复暴露一遍绝对路径。
|
|
2118
|
+
const shell = { ok: true, mode: 'changes', git, links: [], linksTotal: 0, unresolved: [], outOfScope: [] }
|
|
2119
|
+
if (!git.available) return shell
|
|
2120
|
+
|
|
2121
|
+
const corpusRels = new Set(corpus.map((d) => String(d.rel)))
|
|
2122
|
+
const docOf = new Map(corpus.map((d) => [String(d.rel), d]))
|
|
2123
|
+
const { seeds, gone, outside, seedRels } = splitSeeds(changeSet, corpusRels)
|
|
2124
|
+
// ⚠️ 种子要**带上 `gone`**:删掉的测试文件照样牵着它的被测文件(那正是要答的问题),
|
|
2125
|
+
// 只是它自己不能当结果(`corpusRels` 里没有它)。
|
|
2126
|
+
if (seedRels.length === 0) return { ...shell, outOfScope: outside }
|
|
2127
|
+
|
|
2128
|
+
// 变更文件**自己不当结果**(这一区回答的是「还该看什么」)。
|
|
2129
|
+
// ⚠️ 与上一版的差别:这里**不再**排除「已经在三层里的条目」—— 那需要先有一份包才知道,
|
|
2130
|
+
// 而独立接口不该为了一个减法去装配一份三层。两边都出现不是重复:一个是「这一轮该先看什么」,
|
|
2131
|
+
// 一个是「我改的东西牵着谁」。客户端按 rel 去重(它手上两份都有)。
|
|
2132
|
+
const exclude = new Set(seeds)
|
|
2133
|
+
|
|
2134
|
+
// 已删除 / 重命名前的路径当种子时要有「空壳」候选,否则别人指向它的边解析不出来。
|
|
2135
|
+
// ⚠️ 没有 gone 时**不拼**这个数组 —— 那样候选集与装配层那一份逐字相同,
|
|
2136
|
+
// `relations.js` 的缓存(按候选集签名)能直接命中,省掉一次 10 ms 级的重算。
|
|
2137
|
+
const candidates = gone.length > 0 ? [...corpus, ...ghostCandidates(gone)] : corpus
|
|
2138
|
+
const facts = buildRelationFacts(candidates, { root })
|
|
2139
|
+
const projected = projectChangeRelated({
|
|
2140
|
+
seeds: seedRels, incident: facts.incident, itemRels: corpusRels, exclude, limit: MAX_CHANGE_RELATED,
|
|
2141
|
+
})
|
|
2142
|
+
const links = projected.related.map((row) => {
|
|
2143
|
+
const doc = docOf.get(row.rel)
|
|
2144
|
+
if (!doc) return null
|
|
2145
|
+
// 每条证据一行:起点 / 类型 / 方向 / 行号(`line` 没有就是 `null`,不省略 —— 专用结构里
|
|
2146
|
+
// 「这里没有行号」本身是信息,而 `tests` 那一类就是没有)。
|
|
2147
|
+
const evidence = row.evidence.map((e) => ({
|
|
2148
|
+
origin: e.other,
|
|
2149
|
+
type: e.type,
|
|
2150
|
+
dir: e.dir,
|
|
2151
|
+
line: Number.isInteger(e.line) ? e.line : null,
|
|
2152
|
+
}))
|
|
2153
|
+
return {
|
|
2154
|
+
target: row.rel,
|
|
2155
|
+
kind: doc.kind || KIND_DOCUMENT,
|
|
2156
|
+
source: sourceTypeOf(row.rel),
|
|
2157
|
+
title: doc.title || row.rel,
|
|
2158
|
+
summary: doc.summary == null ? '' : String(doc.summary),
|
|
2159
|
+
mtimeMs: Number.isFinite(doc.mtimeMs) ? doc.mtimeMs : 0,
|
|
2160
|
+
evidence,
|
|
2161
|
+
evidenceTotal: row.evidenceTotal,
|
|
2162
|
+
types: row.types,
|
|
2163
|
+
}
|
|
2164
|
+
}).filter(Boolean)
|
|
2165
|
+
return {
|
|
2166
|
+
...shell,
|
|
2167
|
+
links,
|
|
2168
|
+
linksTotal: projected.relatedTotal,
|
|
2169
|
+
// ⚠️ 两个计数**不许重复算同一篇**(写完当场被测试抓到过一次):
|
|
2170
|
+
// · `unresolved` 只说「在语料里、但一条证据都没有」的那些(= 查过了,没有);
|
|
2171
|
+
// · 语料之外的(删除的、重命名前的、这一档不认的后缀)只进 `outOfScope`(= 根本没得查)。
|
|
2172
|
+
// 它们仍然**当种子**用(`seedRels` 带着它们),只是不该被说成「查了没查到」。
|
|
2173
|
+
unresolved: projected.unresolved.filter((rel) => corpusRels.has(rel)),
|
|
2174
|
+
outOfScope: outside,
|
|
2175
|
+
}
|
|
1990
2176
|
}
|
|
1991
2177
|
|
|
1992
2178
|
/**
|
|
@@ -2816,6 +3002,9 @@ export function apply(ctx) {
|
|
|
2816
3002
|
const body = publicScanPayload(payload)
|
|
2817
3003
|
// v0.14:相关模式下顺带给出任务上下文分层。
|
|
2818
3004
|
// ⚠️ 带上 `context` 是**可选**的(老客户端忽略它),而 `docs` 一字未动。
|
|
3005
|
+
// ⚠️ v0.25(第二轮修订):**这里不再有任何 Git 变更关联**。`/api/recent` 的响应
|
|
3006
|
+
// 与 v0.24 逐字相同(`changes` 那个键根本不存在)—— 变更关联走独立的
|
|
3007
|
+
// `/knit/api/changes`。这条纪律有测试守着:常规检索请求里不许出现变更字段。
|
|
2819
3008
|
body.context = await contextPayload(root, payload, sort, kind)
|
|
2820
3009
|
// v0.21:面板要显示「固定了什么 / 排除了什么」(含恢复按钮),而这两份
|
|
2821
3010
|
// 是**用户动作的原始记录**,不是 Context Pack 的投影 —— 固定项本身在
|
|
@@ -2872,6 +3061,40 @@ export function apply(ctx) {
|
|
|
2872
3061
|
return
|
|
2873
3062
|
}
|
|
2874
3063
|
|
|
3064
|
+
if (url.pathname === `${ROUTE_PREFIX}/api/changes`) {
|
|
3065
|
+
/* v0.25 · **Git 变更关联**:独立接口。
|
|
3066
|
+
⚠️ 与 `/api/recent` 分开不是洁癖,是契约纪律:
|
|
3067
|
+
· `/api/recent` 的响应形状**一个键都不加**(与 v0.24 逐字相同)——
|
|
3068
|
+
它同时喂着「只要列表」的调用方,不该因为少数人打开的功能变重;
|
|
3069
|
+
· 这个接口有**自己的数据结构**(起点 / 目标 / 类型 / 行号),不借 Context Pack
|
|
3070
|
+
条目的词汇(`provenance` / `reason` / `relations`)—— 那套词汇属于三层,
|
|
3071
|
+
硬套过来就得扩工具 schema 的枚举,而工具契约不动。
|
|
3072
|
+
成本:**一次 git + 一次扫描**,而且两者都与 `/api/recent` **共用**——
|
|
3073
|
+
`corpusForChanges()` 复用最近一次扫描(8 s 同窗),`gitReader` 自己缓存 + 并发去重。
|
|
3074
|
+
关掉时客户端根本不请求这条路由 ⇒ 一个 git 进程都不 spawn。 */
|
|
3075
|
+
const limit = Math.min(Math.max(Number(url.searchParams.get('limit')) || 40, 1), 100)
|
|
3076
|
+
const sort = url.searchParams.get('sort') === 'time' ? 'time' : 'relevance'
|
|
3077
|
+
// ⚠️ **没有 `kind` 参数**(v0.25 收尾时删掉)。理由是可核验的:变更关联固定用
|
|
3078
|
+
// 「文档 + 代码」那一份**不分档**语料(`collectDocs()` 的结果与档位无关,
|
|
3079
|
+
// 档位只影响 `docs` 那一栏的输出),所以 `kind` 在这里**没有任何语义** ——
|
|
3080
|
+
// 留一个「看着像能过滤、实际什么都不做」的参数比没有它更糟。
|
|
3081
|
+
if (sort !== 'relevance') {
|
|
3082
|
+
// 时间序没有 Context Pack,也就没有「该一起看什么」这回事。如实说,不给空壳。
|
|
3083
|
+
sendJson(res, 200, {
|
|
3084
|
+
ok: true, mode: 'changes', sort,
|
|
3085
|
+
git: { available: false, reason: 'not-relevance-order', filesTotal: 0, truncated: false, files: [] },
|
|
3086
|
+
links: [], linksTotal: 0, unresolved: [], outOfScope: [],
|
|
3087
|
+
})
|
|
3088
|
+
return
|
|
3089
|
+
}
|
|
3090
|
+
const payload = await corpusForChanges(root, {
|
|
3091
|
+
limit,
|
|
3092
|
+
options: { session: sessionOf(webCtx, sessionId), sessionId, sort, kind: 'context' },
|
|
3093
|
+
})
|
|
3094
|
+
sendJson(res, 200, await changesPayload(root, { corpus: payload.contextCorpus }))
|
|
3095
|
+
return
|
|
3096
|
+
}
|
|
3097
|
+
|
|
2875
3098
|
if (url.pathname === `${ROUTE_PREFIX}/api/context`) {
|
|
2876
3099
|
// v0.14:独立的上下文接口。与 `/api/recent` 分开是为了**不让只想拿列表的
|
|
2877
3100
|
// 调用方被迫付引用图的钱** —— 面板走 recent 里的 `context` 字段,
|
|
@@ -2954,7 +3177,7 @@ export function apply(ctx) {
|
|
|
2954
3177
|
|
|
2955
3178
|
webCtx.effect(() => {
|
|
2956
3179
|
const unregister = webCtx.webServer.register({ kind: 'prefix', path: ROUTE_PREFIX, handler })
|
|
2957
|
-
console.log(`[${name}] route ready: ${ROUTE_PREFIX}/api/recent, ${ROUTE_PREFIX}/api/doc, ${ROUTE_PREFIX}/api/raw, ${ROUTE_PREFIX}/api/links, ${ROUTE_PREFIX}/api/context, ${ROUTE_PREFIX}/api/control (POST)`)
|
|
3180
|
+
console.log(`[${name}] route ready: ${ROUTE_PREFIX}/api/recent, ${ROUTE_PREFIX}/api/doc, ${ROUTE_PREFIX}/api/raw, ${ROUTE_PREFIX}/api/links, ${ROUTE_PREFIX}/api/context, ${ROUTE_PREFIX}/api/changes, ${ROUTE_PREFIX}/api/control (POST)`)
|
|
2958
3181
|
return () => unregister()
|
|
2959
3182
|
}, 'dsh-knit: host route')
|
|
2960
3183
|
})
|
package/test/client.test.mjs
CHANGED
|
@@ -4692,9 +4692,11 @@ test('v0.21.x 检索状态摘要:单行三组、竖线分隔、组内中点,
|
|
|
4692
4692
|
// ① 逐个格子的**原文**,以及分隔符的种类与位置 —— 顺序就是这条设计要传达的信息
|
|
4693
4693
|
// 用**直接子节点**(flattenUnder 会把状态格内部的按钮/箭头也压平 ⇒ 同一格数三次)
|
|
4694
4694
|
const seq = (pipe[0].children || []).map(textOf)
|
|
4695
|
+
// v0.25:第二组末尾多了一格「变更」(Git 变更关联的开关,**默认关**)。
|
|
4696
|
+
// 它不是新分组 —— 与「关系 / 固定」同属「这一份包里还装了什么」那一组。
|
|
4695
4697
|
assert.deepEqual(seq, [
|
|
4696
4698
|
'收集 4', '·', '排除 1', '·', '候选 3', '|',
|
|
4697
|
-
'BM25 检索›', '·', '关系 1 条', '·', '固定 1', '|',
|
|
4699
|
+
'BM25 检索›', '·', '关系 1 条', '·', '固定 1', '·', '变更', '|',
|
|
4698
4700
|
'入包 1',
|
|
4699
4701
|
], `三组 = 工作区候选 | 检索与调整 | 最终结果:${textOf(pipe[0])}`)
|
|
4700
4702
|
|
|
@@ -4705,10 +4707,11 @@ test('v0.21.x 检索状态摘要:单行三组、竖线分隔、组内中点,
|
|
|
4705
4707
|
assert.match(seq[6], /BM25 检索/, '零模型这条路要说出来')
|
|
4706
4708
|
assert.match(seq[8], /关系 1 条/, '关系 = 这一份包里带了几条关系证据')
|
|
4707
4709
|
assert.match(seq[10], /固定 1/, '固定 = 被固定、从三层移出进了固定区的篇数')
|
|
4708
|
-
assert.match(seq[12],
|
|
4710
|
+
assert.match(seq[12], /^变更$/, '变更 = Git 变更关联的开关(默认关:只写「变更」,不带数字)')
|
|
4711
|
+
assert.match(seq[14], /入包 1/, '入包 = 三层条目数(固定区不算)')
|
|
4709
4712
|
|
|
4710
4713
|
// ③ 分隔符恰好是 4 个中点 + 2 根竖线;箭头与「管道」时代的类名一个都不留
|
|
4711
|
-
assert.equal(seq.filter((s) => s === '·').length,
|
|
4714
|
+
assert.equal(seq.filter((s) => s === '·').length, 5, '组内中点:每组 n 格配 n-1 个')
|
|
4712
4715
|
assert.equal(seq.filter((s) => s === '|').length, 2, '组间竖线:三组两根')
|
|
4713
4716
|
assert.equal(byClass(nodes, 'knit-pipearrow').length, 0, '流程箭头已整体删除')
|
|
4714
4717
|
assert.ok(!/[↓→←↑]/.test(textOf(pipe[0])), `状态摘要里不许再出现箭头:${textOf(pipe[0])}`)
|
|
@@ -5348,7 +5351,8 @@ test('v0.23 Phase A:混合真的在跑时 —— 摘要那一格改口径并
|
|
|
5348
5351
|
assert.ok(seq.includes('BM25 + 语义补充›'), `实际生效的是混合,摘要就必须这么说:${seq.join(' / ')}`)
|
|
5349
5352
|
assert.ok(!seq.includes('BM25 检索›'), '不许在混合真的在跑时还写「词法检索」')
|
|
5350
5353
|
assert.ok(seq.includes('语义候选 3 条'), `可用时要如实给候选数:${seq.join(' / ')}`)
|
|
5351
|
-
|
|
5354
|
+
// v0.25:第二组末尾又多了一格「变更」⇒ 组内中点再 +1(4 → 5 → 6)
|
|
5355
|
+
assert.equal(seq.filter((t) => t === '·').length, 6, '语义那一格进第二组、再算上「变更」那一格 ⇒ 组内中点 6')
|
|
5352
5356
|
assert.equal(byExactClass(nodes, 'knit-retnote').length, 0, '混合在跑:没有「不可用」说明')
|
|
5353
5357
|
assert.equal(byExactClass(nodes, 'knit-semcfg').length, 0, '混合在跑:不展开配置区')
|
|
5354
5358
|
})
|
|
@@ -5532,3 +5536,265 @@ test('v0.23(2026-10-11):菜单的键盘关闭 —— Esc 收起菜单、
|
|
|
5532
5536
|
assert.equal(globalThis.window.localStorage.getItem('dsh-knit:retrieval') || 'lexical', 'lexical',
|
|
5533
5537
|
'Esc 只关菜单,不改检索模式')
|
|
5534
5538
|
})
|
|
5539
|
+
|
|
5540
|
+
/* ── v0.25:Git 变更关联(开关 + **独立接口**)────────────────────────
|
|
5541
|
+
⚠️ 第二轮修订:变更关联不再挂在 `/api/recent` 的 `context` 上,而是**独立接口**
|
|
5542
|
+
`/knit/api/changes`。所以这组用例要同时盯两件事:
|
|
5543
|
+
① 列表那条请求里**没有任何变更参数**(`changes=1` 不许再出现);
|
|
5544
|
+
② 开关打开后才发第二条请求,且它回的是**专用结构**(links/evidence),
|
|
5545
|
+
客户端要把它映射成可渲染的行。 */
|
|
5546
|
+
|
|
5547
|
+
/** `/knit/api/changes` 的**专用结构**载荷(宿主那一侧的真实形状)。 */
|
|
5548
|
+
function changesPayloadFixture(options = {}) {
|
|
5549
|
+
const {
|
|
5550
|
+
available = true, reason = null, filesTotal = 3, linksTotal = 1,
|
|
5551
|
+
links = [{
|
|
5552
|
+
target: 'test/semantic.test.mjs', kind: 'code', source: 'test',
|
|
5553
|
+
title: 'semantic.test.mjs', summary: '摘要 semantic.test.mjs', mtimeMs: Date.now(),
|
|
5554
|
+
evidence: [
|
|
5555
|
+
{ origin: 'src/host/semantic.js', type: 'tests', dir: 'out', line: null },
|
|
5556
|
+
{ origin: 'src/host/semantic.js', type: 'imports', dir: 'in', line: 30 },
|
|
5557
|
+
],
|
|
5558
|
+
evidenceTotal: 2, types: ['imports', 'tests'],
|
|
5559
|
+
}],
|
|
5560
|
+
unresolved = [], outOfScope = [],
|
|
5561
|
+
} = options
|
|
5562
|
+
return {
|
|
5563
|
+
ok: true, mode: 'changes',
|
|
5564
|
+
git: { available, reason, filesTotal, truncated: false, files: [{ rel: 'src/host/semantic.js', kinds: ['unstaged'] }] },
|
|
5565
|
+
links, linksTotal, unresolved, outOfScope,
|
|
5566
|
+
}
|
|
5567
|
+
}
|
|
5568
|
+
|
|
5569
|
+
/** 列表载荷 + 独立接口载荷:按 URL 分派(`/api/changes` 走第二条)。 */
|
|
5570
|
+
function installBoth(payload, changes) {
|
|
5571
|
+
return installFetch((url) => (url.includes('/api/links')
|
|
5572
|
+
? { ok: true, rel: 'x', incoming: [], outgoing: [], incomingTotal: 0, outgoingTotal: 0 }
|
|
5573
|
+
: (url.includes('/api/changes') ? changes : payload)))
|
|
5574
|
+
}
|
|
5575
|
+
|
|
5576
|
+
test('v0.25:列表请求**一个变更参数都不带** —— 独立接口之前,recent 上不该有它的痕迹', async () => {
|
|
5577
|
+
const { calls } = installBoth(v021Payload(), changesPayloadFixture())
|
|
5578
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
5579
|
+
harness.reset()
|
|
5580
|
+
harness.seed(['', 'relevance', 'doc'])
|
|
5581
|
+
let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
5582
|
+
await harness.flush()
|
|
5583
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
5584
|
+
await harness.flush()
|
|
5585
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
5586
|
+
assert.ok(calls.every((u) => !u.includes('changes=1')), `recent 上不许再带这个参数:${calls.join(' ')}`)
|
|
5587
|
+
assert.ok(!calls.some((u) => u.includes('/api/changes')), `默认关:连这条请求都不发:${calls.join(' ')}`)
|
|
5588
|
+
const chip = byExactClass(nodes, 'knit-pipe-changes')
|
|
5589
|
+
assert.equal(chip.length, 1, '开关那一格**关着也出现**(藏起来用户就永远打不开这个功能)')
|
|
5590
|
+
assert.equal(chip[0].props['aria-pressed'], 'false')
|
|
5591
|
+
assert.equal(textOf(chip[0]), '变更')
|
|
5592
|
+
assert.ok(!byExactClass(nodes, 'knit-tiername').map(textOf).includes('变更关联'), '关着时不许出现这一区')
|
|
5593
|
+
})
|
|
5594
|
+
|
|
5595
|
+
test('v0.25:打开开关 ⇒ 发**独立接口**请求、偏好落盘、专用结构渲染成一区', async () => {
|
|
5596
|
+
let payload = v021Payload()
|
|
5597
|
+
let changes = changesPayloadFixture({ available: false, reason: 'not-a-repo', filesTotal: 0, links: [], linksTotal: 0 })
|
|
5598
|
+
const { calls } = installBoth(payload, changes)
|
|
5599
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
5600
|
+
harness.reset()
|
|
5601
|
+
harness.seed(['', 'relevance', 'doc'])
|
|
5602
|
+
const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
5603
|
+
let nodes = render()
|
|
5604
|
+
await harness.flush()
|
|
5605
|
+
nodes = render()
|
|
5606
|
+
await harness.flush()
|
|
5607
|
+
nodes = render()
|
|
5608
|
+
|
|
5609
|
+
// 打开前宿主那条独立接口先回「读不到」—— 点开之后应当如实说原因,而不是假装有数字
|
|
5610
|
+
byExactClass(nodes, 'knit-pipe-changes')[0].props.onClick({ stopPropagation() {} })
|
|
5611
|
+
await harness.flush()
|
|
5612
|
+
nodes = render()
|
|
5613
|
+
await harness.flush()
|
|
5614
|
+
nodes = render()
|
|
5615
|
+
assert.ok(calls.some((u) => u.includes('/api/changes')), `打开后必须请求独立接口:${calls.join(' ')}`)
|
|
5616
|
+
assert.ok(calls.filter((u) => u.includes('/api/changes')).every((u) => !u.includes('changes=1')), '独立接口自己不需要那个参数')
|
|
5617
|
+
assert.equal(globalThis.window.localStorage.getItem('dsh-knit:changes'), '1', '偏好落盘')
|
|
5618
|
+
const chipOff = byExactClass(nodes, 'knit-pipe-changes')
|
|
5619
|
+
assert.equal(chipOff[0].props['aria-pressed'], 'true')
|
|
5620
|
+
assert.equal(textOf(chipOff[0]), '变更 —', '读不到时如实写「—」')
|
|
5621
|
+
assert.match(String(chipOff[0].props.title), /不是 Git 工作区/, '悬停要说清是哪一种失败')
|
|
5622
|
+
|
|
5623
|
+
// 再把独立接口切成「有货」—— 关联应当渲染成一区,且带证据。
|
|
5624
|
+
// ⚠️ 必须**重新装一次** fetch:responder 捕获的是调用那一刻的值,光改 `let` 变量它看不见。
|
|
5625
|
+
changes = changesPayloadFixture()
|
|
5626
|
+
const nextPayload = v021Payload()
|
|
5627
|
+
nextPayload.docs.push({
|
|
5628
|
+
path: '/p/test/semantic.test.mjs', rel: 'test/semantic.test.mjs', name: 'semantic.test.mjs',
|
|
5629
|
+
title: 'semantic.test.mjs', summary: '摘要 semantic.test.mjs', mtimeMs: Date.now(), score: 3,
|
|
5630
|
+
})
|
|
5631
|
+
installBoth(nextPayload, changes)
|
|
5632
|
+
await harness.flush()
|
|
5633
|
+
nodes = render()
|
|
5634
|
+
await harness.flush()
|
|
5635
|
+
nodes = render()
|
|
5636
|
+
const titles = byExactClass(nodes, 'knit-tiername').map(textOf)
|
|
5637
|
+
assert.ok(titles.includes('变更关联'), `这一区必须单独成区:${titles.join(' / ')}`)
|
|
5638
|
+
assert.ok(titles.indexOf('变更关联') < titles.indexOf('主要上下文'), '变更关联区排在主要上下文之前')
|
|
5639
|
+
const provs = byExactClass(nodes, 'knit-prov').map(textOf)
|
|
5640
|
+
assert.ok(provs.includes('变更关联'), `来源词必须能区分出来:${provs.join(' / ')}`)
|
|
5641
|
+
for (const text of provs) assert.ok(!/\d|%/.test(text), `来源词里不许出现数字或百分比:${text}`)
|
|
5642
|
+
// 证据来自**专用结构**的 evidence(起点 / 类型 / 行号),映射回既有那套弹层
|
|
5643
|
+
const numbered = byExactClass(nodes, 'knit-num').map(textOf)
|
|
5644
|
+
assert.equal(numbered.length, new Set(numbered).size, '编号不许重复')
|
|
5645
|
+
assert.ok(numbered.every((n) => /^0[1-9]$/.test(n)), `编号只给三层:${numbered.join(',')}`)
|
|
5646
|
+
})
|
|
5647
|
+
|
|
5648
|
+
test('v0.25 收尾:三种状态**互相可辨** —— 没变更 / 有变更但零关联 / 读不到', async () => {
|
|
5649
|
+
/* 这是收尾时补的那条纪律:`null` 只表示「功能没开」,**不许**用它表示失败 ——
|
|
5650
|
+
否则「读不到 git」和「没有变更」在界面上一模一样。三种状态各自的可见信号:
|
|
5651
|
+
· 没有变更 → 那一格写 `变更 0`,列表里**不出**这一区(干净树的绝大多数时候不该有噪音)
|
|
5652
|
+
· 有变更、零关联 → 那一格写 `变更 3`,列表里出**区头 + 提示句**(「3 个变更文件,没有找到关联证据」)
|
|
5653
|
+
· 读不到 → 那一格写 `变更 —`,悬停写明原因(git 原因 或 接口请求失败)
|
|
5654
|
+
三次各自独立挂载,免得状态互相污染。 */
|
|
5655
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
5656
|
+
const mount = async (changes) => {
|
|
5657
|
+
// 每次重新装 fetch:responder 捕获的是装那一刻的值
|
|
5658
|
+
installFetch((url) => (url.includes('/api/links')
|
|
5659
|
+
? { ok: true, rel: 'x', incoming: [], outgoing: [], incomingTotal: 0, outgoingTotal: 0 }
|
|
5660
|
+
: (url.includes('/api/changes') ? (() => { if (changes instanceof Error) throw changes; return changes })() : v021Payload())))
|
|
5661
|
+
// ⚠️ 偏好是**跨用例留存**的:上一个用例点过开关就会写 `'1'`。这里必须先明确置为关,
|
|
5662
|
+
// 否则下面那次「点一下」是把它关掉(第一版就这么错了,界面显示成「变更」)。
|
|
5663
|
+
globalThis.window.localStorage.setItem('dsh-knit:changes', '0')
|
|
5664
|
+
harness.reset()
|
|
5665
|
+
harness.seed(['', 'relevance', 'doc'])
|
|
5666
|
+
const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
5667
|
+
let nodes = render()
|
|
5668
|
+
await harness.flush()
|
|
5669
|
+
nodes = render()
|
|
5670
|
+
await harness.flush()
|
|
5671
|
+
nodes = render()
|
|
5672
|
+
byExactClass(nodes, 'knit-pipe-changes')[0].props.onClick({ stopPropagation() {} })
|
|
5673
|
+
await harness.flush()
|
|
5674
|
+
nodes = render()
|
|
5675
|
+
await harness.flush()
|
|
5676
|
+
return render()
|
|
5677
|
+
}
|
|
5678
|
+
|
|
5679
|
+
// ① 没有未提交的变更
|
|
5680
|
+
const clean = await mount(changesPayloadFixture({ filesTotal: 0, linksTotal: 0, links: [] }))
|
|
5681
|
+
let chip = byExactClass(clean, 'knit-pipe-changes')[0]
|
|
5682
|
+
assert.equal(textOf(chip), '变更 0', '没有变更要如实写 0(与「读不到」的「—」不同)')
|
|
5683
|
+
assert.match(String(chip.props.title), /0 个变更文件/, `悬停也要说清:${chip.props.title}`)
|
|
5684
|
+
assert.ok(!byExactClass(clean, 'knit-tiername').map(textOf).includes('变更关联'), '干净树里不出这一区(不要噪音)')
|
|
5685
|
+
|
|
5686
|
+
// ② 有变更,但一条关联证据都没有
|
|
5687
|
+
const none = await mount(changesPayloadFixture({ filesTotal: 3, linksTotal: 0, links: [] }))
|
|
5688
|
+
chip = byExactClass(none, 'knit-pipe-changes')[0]
|
|
5689
|
+
assert.equal(textOf(chip), '变更 3')
|
|
5690
|
+
const titles = byExactClass(none, 'knit-tiername').map(textOf)
|
|
5691
|
+
assert.ok(titles.includes('变更关联'), `有变更、没关联时也要出区头:${titles.join(' / ')}`)
|
|
5692
|
+
const hints = byExactClass(none, 'knit-tierhint').map(textOf)
|
|
5693
|
+
assert.ok(hints.some((h) => /3 个变更文件/.test(h) && /没有找到关联证据/.test(h)),
|
|
5694
|
+
`提示句要说明「有变更但没找到」:${hints.join(' / ')}`)
|
|
5695
|
+
assert.equal(byClass(none, 'knit-doc').length, byClass(clean, 'knit-doc').length,
|
|
5696
|
+
'这一区不带行 ⇒ 列表里的行数不变')
|
|
5697
|
+
|
|
5698
|
+
// ③ 读不到:宿主说得出的原因 —— **而且要在列表里直接看得见**(不只悬停)
|
|
5699
|
+
// 这条是真人反馈加上来的(2026-10-13):用户看到那一格写「变更 —」,
|
|
5700
|
+
// 读成了「这个数据没记录到」—— 原因只藏在 `title` 里,不悬停就看不见。
|
|
5701
|
+
const noRepo = await mount(changesPayloadFixture({ available: false, reason: 'not-a-repo', filesTotal: 0, links: [], linksTotal: 0 }))
|
|
5702
|
+
chip = byExactClass(noRepo, 'knit-pipe-changes')[0]
|
|
5703
|
+
assert.equal(textOf(chip), '变更 —', '读不到必须与「0 个变更」长得不一样')
|
|
5704
|
+
assert.match(String(chip.props.title), /不是 Git 工作区/, `悬停要写明宿主给的原因:${chip.props.title}`)
|
|
5705
|
+
const noRepoTitles = byExactClass(noRepo, 'knit-tiername').map(textOf)
|
|
5706
|
+
assert.ok(noRepoTitles.includes('变更关联'), `读不到时也要出区头(否则用户只看到一个「—」):${noRepoTitles.join(' / ')}`)
|
|
5707
|
+
const noRepoHints = byExactClass(noRepo, 'knit-tierhint').map(textOf)
|
|
5708
|
+
assert.ok(noRepoHints.some((h) => /读不到 Git 变更状态/.test(h) && /不是 Git 工作区/.test(h)),
|
|
5709
|
+
`原因要**直接写在列表里**,不能只靠悬停:${noRepoHints.join(' / ')}`)
|
|
5710
|
+
assert.equal(byClass(noRepo, 'knit-doc').length, byClass(clean, 'knit-doc').length, '这一区不带行')
|
|
5711
|
+
|
|
5712
|
+
// ④ 读不到:接口本身失败(这一条是收尾的重点 —— 原来它整段消失)
|
|
5713
|
+
const broke = await mount(new Error('boom'))
|
|
5714
|
+
chip = byExactClass(broke, 'knit-pipe-changes')[0]
|
|
5715
|
+
assert.equal(textOf(chip), '变更 —', '接口失败也要落在「—」上,不许静默')
|
|
5716
|
+
assert.match(String(chip.props.title), /接口请求失败/, `悬停要说清是请求失败:${chip.props.title}`)
|
|
5717
|
+
assert.ok(byExactClass(broke, 'knit-tierhint').map(textOf).some((h) => /接口请求失败/.test(h)),
|
|
5718
|
+
'接口失败的原因同样要直接写在列表里')
|
|
5719
|
+
// 无论哪三种,列表本身一个字节都不许坏
|
|
5720
|
+
for (const nodes of [clean, none, noRepo, broke]) {
|
|
5721
|
+
assert.ok(byClass(nodes, 'knit-doc').length > 0, '三个状态都不许带坏普通列表')
|
|
5722
|
+
assert.ok(byExactClass(nodes, 'knit-tiername').map(textOf).some((t) => t === '主要上下文' || t === '其他相关文档'),
|
|
5723
|
+
'Context Pack 照旧渲染')
|
|
5724
|
+
}
|
|
5725
|
+
})
|
|
5726
|
+
|
|
5727
|
+
test('v0.25 收尾:刚打开、第一次取数还没回来时 **不许**先写「原因未知」(那是假话)', async () => {
|
|
5728
|
+
// 「还没读到」与「读不到」是两件事:前者不该出任何结论,后者要写原因。
|
|
5729
|
+
// 这个区分靠 `changesData !== null` 把住 —— 去掉它,界面会在几十毫秒里先撒一句「原因未知」。
|
|
5730
|
+
installFetch((url) => (url.includes('/api/links')
|
|
5731
|
+
? { ok: true, rel: 'x', incoming: [], outgoing: [], incomingTotal: 0, outgoingTotal: 0 }
|
|
5732
|
+
: (url.includes('/api/changes') ? changesPayloadFixture({ available: false, reason: 'not-a-repo', filesTotal: 0, links: [], linksTotal: 0 }) : v021Payload())))
|
|
5733
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
5734
|
+
globalThis.window.localStorage.setItem('dsh-knit:changes', '0')
|
|
5735
|
+
harness.reset()
|
|
5736
|
+
harness.seed(['', 'relevance', 'doc'])
|
|
5737
|
+
const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
5738
|
+
let nodes = render()
|
|
5739
|
+
await harness.flush()
|
|
5740
|
+
nodes = render()
|
|
5741
|
+
await harness.flush()
|
|
5742
|
+
nodes = render()
|
|
5743
|
+
byExactClass(nodes, 'knit-pipe-changes')[0].props.onClick({ stopPropagation() {} })
|
|
5744
|
+
nodes = render() // ⚠️ **不等 flush**:这就是「请求还在路上」的那一帧
|
|
5745
|
+
const hints = byExactClass(nodes, 'knit-tierhint').map(textOf)
|
|
5746
|
+
assert.ok(!hints.some((h) => /原因未知/.test(h)),
|
|
5747
|
+
`那一帧不许给出任何原因(还没读到):${hints.join(' / ')}`)
|
|
5748
|
+
})
|
|
5749
|
+
|
|
5750
|
+
test('v0.25 收尾:变更行**不再贴理由码** —— 解释交给区标题 + 提示句 + 证据弹层', async () => {
|
|
5751
|
+
installBoth(v021Payload(), changesPayloadFixture())
|
|
5752
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
5753
|
+
globalThis.window.localStorage.setItem('dsh-knit:changes', '0')
|
|
5754
|
+
harness.reset()
|
|
5755
|
+
harness.seed(['', 'relevance', 'doc'])
|
|
5756
|
+
const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
5757
|
+
let nodes = render()
|
|
5758
|
+
await harness.flush()
|
|
5759
|
+
nodes = render()
|
|
5760
|
+
await harness.flush()
|
|
5761
|
+
nodes = render()
|
|
5762
|
+
byExactClass(nodes, 'knit-pipe-changes')[0].props.onClick({ stopPropagation() {} })
|
|
5763
|
+
await harness.flush()
|
|
5764
|
+
nodes = render()
|
|
5765
|
+
await harness.flush()
|
|
5766
|
+
nodes = render()
|
|
5767
|
+
|
|
5768
|
+
// 行右端的来源词还在(那是这一区的身份)
|
|
5769
|
+
assert.ok(byExactClass(nodes, 'knit-prov').map(textOf).includes('变更关联'))
|
|
5770
|
+
// 但每一行**不再**有「为什么在这里」那一行 —— 依据在弹层的证据行里(类型 + 起点 + 行号)
|
|
5771
|
+
const whyLines = byExactClass(nodes, 'knit-why').map(textOf)
|
|
5772
|
+
assert.ok(!whyLines.some((w) => /变更|改动/.test(w)), `变更行不该再贴理由码:${whyLines.join(' / ')}`)
|
|
5773
|
+
// 区里仍然说清「凭什么在这里」
|
|
5774
|
+
assert.ok(byExactClass(nodes, 'knit-tierhint').map(textOf).some((h) => /未提交的改动/.test(h)),
|
|
5775
|
+
'区头的提示句承担「为什么」')
|
|
5776
|
+
})
|
|
5777
|
+
|
|
5778
|
+
test('v0.25:开关那一格复用命中段那套视觉语言(源码级守卫)', async () => {
|
|
5779
|
+
const { readFileSync } = await import('node:fs')
|
|
5780
|
+
const { fileURLToPath } = await import('node:url')
|
|
5781
|
+
const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
|
|
5782
|
+
const start = source.indexOf('const CSS = `') + 'const CSS = `'.length
|
|
5783
|
+
const css = source.slice(start, source.indexOf('`', start)).replace(/\/\*[\s\S]*?\*\//g, '')
|
|
5784
|
+
assert.match(css, /\.knit-pipe-changes\{[^}]*background:var\(--knit-chip-bg/)
|
|
5785
|
+
assert.match(css, /\.knit-pipe-changes\{[^}]*border-radius:6px/)
|
|
5786
|
+
assert.match(css, /\.knit-pipe-changes\{[^}]*padding:1px 6px/)
|
|
5787
|
+
assert.match(css, /\.knit-pipe-changes\{[^}]*font-size:11px/)
|
|
5788
|
+
assert.match(css, /\.knit-pipe-changes\{[^}]*line-height:15px/)
|
|
5789
|
+
assert.ok(!/\.knit-pipe-changes\{[^}]*border-bottom/.test(css), '描边一根都没有(命中段也是)')
|
|
5790
|
+
assert.match(css, /\.knit-pipe-changes\[aria-pressed="true"\]\{color:var\(--dsw-alias-label-primary/)
|
|
5791
|
+
})
|
|
5792
|
+
|
|
5793
|
+
test('v0.25:客户端源码里**不许**再把变更关联挂到列表接口上', async () => {
|
|
5794
|
+
const { readFileSync } = await import('node:fs')
|
|
5795
|
+
const { fileURLToPath } = await import('node:url')
|
|
5796
|
+
const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
|
|
5797
|
+
assert.ok(source.includes("const CHANGES_API = '/knit/api/changes'"), '独立接口的地址要有一个真源')
|
|
5798
|
+
assert.ok(!source.includes('&changes=1'), '列表请求上不许再拼这个参数(整体删除,不是注释掉)')
|
|
5799
|
+
assert.ok(!source.includes('pack.changes'), '包上不再有这个字段(读它就是读了不存在的形状)')
|
|
5800
|
+
})
|