@restregular/dsh-memory 0.11.0 → 0.11.1
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 +20 -0
- package/README.md +12 -7
- package/lib/provider/apply.js +7 -0
- package/lib/provider/index.js +116 -4
- package/lib/provider/scope.js +61 -1
- package/lib/tools/index.js +4 -4
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -2,6 +2,26 @@
|
|
|
2
2
|
|
|
3
3
|
本项目的版本记录。安装 id 与 npm 版本一一对应。
|
|
4
4
|
|
|
5
|
+
## 0.11.1 — 项目作用域路径写法统一
|
|
6
|
+
|
|
7
|
+
- **事故**:0.7.0 引入 `memory_save({ path })` 时只削掉末尾分隔符,于是 Windows 上 `D:/repo` 与
|
|
8
|
+
`D:\repo` 算成两个 `project:` 键、落成两个 scope 文件(sha1 不同)。写入用的是正斜杠,
|
|
9
|
+
而会话读路径用的是宿主给的 `header.cwd`(反斜杠),那份记忆在工作区里**永远读不到**,
|
|
10
|
+
面板/清单里还会出现两个同名绝对路径。
|
|
11
|
+
- **写路径统一**:`canonicalWorkspacePath()` 只做"绝不可能指向另一个目录"的改写 ——
|
|
12
|
+
Windows 绝对路径统一分隔符、消掉 `.`/`..` 与末尾分隔符、盘符大写;POSIX 路径原样;
|
|
13
|
+
非绝对路径不动(不拿 profile 目录去猜)。工具 `path` 参数、显式 `project:<路径>`、
|
|
14
|
+
宿主会话 cwd 三处都过这一遍,读写口径一致。
|
|
15
|
+
- **历史数据自愈**:启动(Cordis 装配)时 `reconcileScopes()` 按 `projectScopeIdentity()`
|
|
16
|
+
把"同一目录的不同写法"并到规范键:记录按 id 迁移(向量维度匹配时一起搬)、别名跟着走、
|
|
17
|
+
迁空的 scope 文件由 flush 删除。只有变体存在时也会改名,否则会话读规范键仍然看不到。
|
|
18
|
+
每进程只跑一次;多进程并发由 flush 的"锁内重读 + 只合并本进程增量"兜底。
|
|
19
|
+
- **读路径**:`listSync`(注入用)也过规范化,避免"工具读得到、注入读不到"。
|
|
20
|
+
- 新增 `scope-path-variants.test.ts`(写法归一、`path` 参数、历史分叉合并、`discoverScopes` 顺带合并)
|
|
21
|
+
并调整既有导入/导出测试到规范写法。
|
|
22
|
+
- 已知限制:仅大小写不同的项目键(`D:\Repo` vs `D:\repo`)不会在写入时折叠,按记录数归到同一个
|
|
23
|
+
scope 后,下次启动若出现新的写法差异仍会再合并一次;分隔符差异(本次事故)已完全统一。
|
|
24
|
+
|
|
5
25
|
## 0.11.0 — 更名「记忆系统」+ README 重写
|
|
6
26
|
|
|
7
27
|
- 插件显示名从「长期记忆」改为「记忆系统」(en: **Memory System**),覆盖插件列表、设置侧栏、左侧栏入口与面板标题。
|
package/README.md
CHANGED
|
@@ -16,7 +16,7 @@ JSONL 落盘 · 本机向量检索 · 五个模型工具 · 自动召回 · 硬
|
|
|
16
16
|
[npm 包](https://www.npmjs.com/package/@restregular/dsh-memory) · [问题反馈](https://github.com/RestRegular/dsh-memory/issues) · [更新日志](https://github.com/RestRegular/dsh-memory/blob/main/CHANGELOG.md)
|
|
17
17
|
|
|
18
18
|
> **它解决的不是「存一段文本」,而是「让模型在该记的时候记住、该用的时候用上」。**
|
|
19
|
-
>
|
|
19
|
+
> 记忆默认只落在本机;没有向量服务也能工作——检索自动退化为词法,不产生任何网络请求。
|
|
20
20
|
|
|
21
21
|

|
|
22
22
|
|
|
@@ -27,7 +27,7 @@ JSONL 落盘 · 本机向量检索 · 五个模型工具 · 自动召回 · 硬
|
|
|
27
27
|
| 新会话从零开始,换个窗口就问不出上次的结论 | 结论落成记忆;新会话第一步注入摘要,之后每轮按问题召回 |
|
|
28
28
|
| 同一个坑反复踩,上次查到的命令又要再查一遍 | 发布 / 部署 / 工具失败等行为会触发定向召回;查到的做法直接复用 |
|
|
29
29
|
| 写了规则没人执行,改过的规则旧会话不知道 | `kind: rule` 进系统提示常驻段;新增或编辑会补一条提醒 |
|
|
30
|
-
| 云端记忆不可控,敏感内容不敢写 | 全部本地 JSONL
|
|
30
|
+
| 云端记忆不可控,敏感内容不敢写 | 全部本地 JSONL;写入前过凭据扫描;检索默认不联网 |
|
|
31
31
|
|
|
32
32
|
它也不是「把聊天记录整段塞给模型」:每条记忆是一句自洽的话,按作用域、类型和重要度管理;
|
|
33
33
|
召回有 token 预算与去重,旧结论可以用 `supersedes` 标注修正,而不是悄悄覆盖。
|
|
@@ -64,8 +64,8 @@ JSONL 落盘 · 本机向量检索 · 五个模型工具 · 自动召回 · 硬
|
|
|
64
64
|
|
|
65
65
|
### 向量服务
|
|
66
66
|
|
|
67
|
-
在本机托管 `llama-server
|
|
68
|
-
|
|
67
|
+
在本机托管 `llama-server`,下载运行时与模型;内置清单为每个模型配好 `dims` 与 `pooling`,
|
|
68
|
+
避免维度写错导致向量通道静默失效。按硬件推荐,也支持自定义 GGUF。
|
|
69
69
|
|
|
70
70
|

|
|
71
71
|
|
|
@@ -86,12 +86,12 @@ npm i @restregular/dsh-memory
|
|
|
86
86
|
name: '@restregular/dsh-memory'
|
|
87
87
|
```
|
|
88
88
|
|
|
89
|
-
|
|
89
|
+
**不写任何配置就能用**:检索退化为词法,不产生任何网络请求。需要语义检索时,
|
|
90
90
|
在面板「服务 → 向量服务」里一键装本机后端即可。
|
|
91
91
|
|
|
92
92
|
> 宿主只允许**一个包名、一个解析源**,所以本插件是「一个包 + 一条 entry + 面板与服务端同包」。
|
|
93
93
|
> 拆成两个包会触发 `resolves from multiple active Loader sources`,客户端图组合失败,
|
|
94
|
-
>
|
|
94
|
+
> 桌面端直接起不来。这段设计约束写在下面的折叠块里,不影响使用。
|
|
95
95
|
|
|
96
96
|
<details>
|
|
97
97
|
<summary>为什么是一个包(给想改结构的人)</summary>
|
|
@@ -374,12 +374,17 @@ npm run verify # 构建到 .verify/,不落 packages/
|
|
|
374
374
|
当前工作区,普通每轮召回按 `inject.extraScopes` 配置),并检查标签是否真的命中。用 `GET /memory/api/audit?session=<id>` 可以看到触发原因、
|
|
375
375
|
候选、去重与各通道预算。
|
|
376
376
|
|
|
377
|
+
**作用域列表里出现两个同名路径 / 用 `path` 存的记忆工作区里看不到**
|
|
378
|
+
0.11.0 及以前,`D:/repo` 与 `D:\repo` 会被当成两个项目作用域(写的人用正斜杠、会话读的是宿主给的反斜杠)。
|
|
379
|
+
0.11.1 起路径写法统一,首次启动会把历史分叉合并到规范键(记录、别名都跟着走,旧文件删除)。
|
|
380
|
+
|
|
377
381
|
**数据怎么备份**
|
|
378
382
|
复制整个 `<storeDir>`;或用面板导出 JSON。导入会按当前模型重新嵌入,不携带旧向量。
|
|
379
383
|
|
|
380
384
|
## 更新日志
|
|
381
385
|
|
|
382
|
-
- **0.11.
|
|
386
|
+
- **0.11.1** —— 修复项目作用域因路径写法不同而分叉:`D:/repo` 与 `D:\repo` 统一成同一个键,历史分叉首次启动自动合并。
|
|
387
|
+
- **0.11.0** —— 插件显示名改为「记忆系统」,重写 README 并更新截图;无 API / 配置 / 数据格式变更。
|
|
383
388
|
- **0.10.1** —— 深色模式开关跟随宿主 token,修复白点融进白轨道。
|
|
384
389
|
- **0.10.0** —— 多进程安全写入、向量身份加入 pooling、读路径能看到其它进程的新写入。
|
|
385
390
|
|
package/lib/provider/apply.js
CHANGED
|
@@ -27,6 +27,13 @@ export class CordisMemoryService extends Service {
|
|
|
27
27
|
constructor(ctx , config = {}) {
|
|
28
28
|
super(ctx, 'memory')
|
|
29
29
|
this.impl = new LocalMemoryService(config)
|
|
30
|
+
// 0.11.1:同一个目录因为 `D:/x` 与 `D:\x` 写法不同而分叉成两个 scope 的历史数据,
|
|
31
|
+
// 在装配期合并一次(每进程一次;失败只影响合并,不影响读写)。
|
|
32
|
+
try {
|
|
33
|
+
this.impl.reconcileScopes()
|
|
34
|
+
} catch {
|
|
35
|
+
// 合并失败:两个 scope 继续并存(读写仍然正常),不阻断插件加载
|
|
36
|
+
}
|
|
30
37
|
ctx.effect(() => () => this.impl.flushSync())
|
|
31
38
|
this.attachRerank(ctx, config)
|
|
32
39
|
}
|
package/lib/provider/index.js
CHANGED
|
@@ -16,8 +16,10 @@
|
|
|
16
16
|
|
|
17
17
|
import { MemoryStore, scopeFileName, } from './store.js'
|
|
18
18
|
import {
|
|
19
|
+
canonicalWorkspacePath,
|
|
19
20
|
isCustomScope,
|
|
20
21
|
normalizeScopeInput,
|
|
22
|
+
projectScopeIdentity,
|
|
21
23
|
resolveCurrentScopes,
|
|
22
24
|
scopeKind,
|
|
23
25
|
scopeTier,
|
|
@@ -490,6 +492,8 @@ export class LocalMemoryService {
|
|
|
490
492
|
projectScope
|
|
491
493
|
/** 上次发现磁盘 scope 的时间(限流用;0 = 还没发现过)。 */
|
|
492
494
|
discoveredAt = 0
|
|
495
|
+
/** "同一目录不同写法"的项目作用域是否已经合并过(每个进程只做一次)。 */
|
|
496
|
+
scopesReconciled = false
|
|
493
497
|
/** 作用域别名(project:<路径> → 显示名),落盘 <storeDir>/scopes.json。 */
|
|
494
498
|
names
|
|
495
499
|
/** 注入设置(面板「设置」标签页可改;落盘在 <storeDir>/settings.json)。 */
|
|
@@ -608,15 +612,16 @@ export class LocalMemoryService {
|
|
|
608
612
|
* 默认排除已被 supersede 的旧记录;需要历史/审计时显式 includeSuperseded。
|
|
609
613
|
*/
|
|
610
614
|
listSync(input = {}) {
|
|
615
|
+
const wanted = (input.scopes ?? []).map((scope) => this.canonicalScope(scope))
|
|
611
616
|
const seen = new Set ()
|
|
612
617
|
const stores = []
|
|
613
|
-
for (const scope of
|
|
618
|
+
for (const scope of wanted) {
|
|
614
619
|
if (seen.has(scope)) continue
|
|
615
620
|
seen.add(scope)
|
|
616
621
|
const s = this.store.peek(scope)
|
|
617
622
|
if (s) stores.push(s)
|
|
618
623
|
}
|
|
619
|
-
const retired = input.includeSuperseded ? new Set () : new Set(this.supersededIds(
|
|
624
|
+
const retired = input.includeSuperseded ? new Set () : new Set(this.supersededIds(wanted))
|
|
620
625
|
const out = []
|
|
621
626
|
for (const s of stores) {
|
|
622
627
|
for (const rec of s.records.values()) {
|
|
@@ -1738,9 +1743,21 @@ export class LocalMemoryService {
|
|
|
1738
1743
|
return this.names.scopeOf(name)
|
|
1739
1744
|
}
|
|
1740
1745
|
|
|
1741
|
-
/**
|
|
1746
|
+
/**
|
|
1747
|
+
* 作用域键归一:自定义名可能是别名 → 转回真实键;`project:<路径>` 统一路径写法。
|
|
1748
|
+
*
|
|
1749
|
+
* 项目键必须过 `canonicalWorkspacePath`:工具层的 `path`、模型显式给的
|
|
1750
|
+
* `project:D:/x`、面板 HTTP 写入都从这里落盘,同一个目录不能因为 `/` 与 `\` 的差别
|
|
1751
|
+
* 变成两个 scope(0.11.1;读路径的键来自 resolveCurrentScopes,也走同一套规范化)。
|
|
1752
|
+
*/
|
|
1742
1753
|
canonicalScope(scope ) {
|
|
1743
|
-
if (scope === 'global' || scope.startsWith('
|
|
1754
|
+
if (scope === 'global' || scope.startsWith('session:')) return scope
|
|
1755
|
+
if (scope.startsWith('project:')) {
|
|
1756
|
+
const path = scope.slice('project:'.length)
|
|
1757
|
+
if (path === '') return scope
|
|
1758
|
+
const canonical = canonicalWorkspacePath(path)
|
|
1759
|
+
return (canonical === path ? scope : `project:${canonical}`)
|
|
1760
|
+
}
|
|
1744
1761
|
return (this.names.scopeOf(scope) ) ?? scope
|
|
1745
1762
|
}
|
|
1746
1763
|
|
|
@@ -1790,10 +1807,105 @@ export class LocalMemoryService {
|
|
|
1790
1807
|
} catch {
|
|
1791
1808
|
// 发现失败不影响读写,清单里少几个而已
|
|
1792
1809
|
}
|
|
1810
|
+
try {
|
|
1811
|
+
this.reconcileScopes()
|
|
1812
|
+
} catch {
|
|
1813
|
+
// 合并失败同样不影响读写:留着两个 scope 也比丢数据强
|
|
1814
|
+
}
|
|
1793
1815
|
}
|
|
1794
1816
|
return this.knownScopes()
|
|
1795
1817
|
}
|
|
1796
1818
|
|
|
1819
|
+
/**
|
|
1820
|
+
* 把"同一个目录的不同写法"合并成一个项目作用域(0.11.1,每个进程只跑一次)。
|
|
1821
|
+
*
|
|
1822
|
+
* 0.7.0 引入 `memory_save({ path })` 之后, `D:/repositories/x` 与 `D:\repositories\x`
|
|
1823
|
+
* 会落成两个 scope 文件;工作区里的会话用宿主给的 `header.cwd`,于是另一份里的记忆
|
|
1824
|
+
* 永远读不到(面板里还会看到两个同名作用域)。写入侧已在 `canonicalScope` 统一写法,
|
|
1825
|
+
* 这里负责把**历史数据**并到规范键上:
|
|
1826
|
+
* - 同组的判定走 `projectScopeIdentity`(Windows 盘符路径再折叠大小写,POSIX 不动);
|
|
1827
|
+
* - 目标键优先选"写法已经规范"的那一个,其次记录多的(稳定时按键名);**只有变体存在时
|
|
1828
|
+
* 改名**到规范键(否则会话读规范键、永远看不到这份记忆);
|
|
1829
|
+
* - 记录按 id 并入目标(目标已有同 id 就跳过);向量长度与当前配置一致时一起搬;
|
|
1830
|
+
* - 别名跟着走(目标没有别名时才接管),迁空的 scope 由 flush 顺手删掉文件。
|
|
1831
|
+
* 多进程并发时,flush 的"锁内重新读盘 + 只合并本进程增量"兜底:这里只发 upsert/delete,
|
|
1832
|
+
* 不会把别的进程刚写的内容覆盖掉。
|
|
1833
|
+
*/
|
|
1834
|
+
reconcileScopes() {
|
|
1835
|
+
if (this.scopesReconciled) return { merged: 0 }
|
|
1836
|
+
this.scopesReconciled = true
|
|
1837
|
+
// 直接调用(装配期)时还没有发现过磁盘 scope:先发现,否则只能看到已加载的那两个,
|
|
1838
|
+
// 合并会漏、而且这唯一一次机会被浪费掉。
|
|
1839
|
+
if (this.discoveredAt === 0) {
|
|
1840
|
+
this.discoveredAt = Date.now()
|
|
1841
|
+
try {
|
|
1842
|
+
this.store.loadDiscovered()
|
|
1843
|
+
} catch {
|
|
1844
|
+
// 发现失败:清单少几个,不影响读写
|
|
1845
|
+
}
|
|
1846
|
+
}
|
|
1847
|
+
const groups = new Map ()
|
|
1848
|
+
for (const store of this.store.allScopes()) {
|
|
1849
|
+
if (!store.scope.startsWith('project:')) continue
|
|
1850
|
+
const path = store.scope.slice('project:'.length)
|
|
1851
|
+
if (path === '') continue
|
|
1852
|
+
const identity = projectScopeIdentity(path)
|
|
1853
|
+
const list = groups.get(identity)
|
|
1854
|
+
const entry = { scope: store.scope, store, records: store.records.size }
|
|
1855
|
+
if (list === undefined) groups.set(identity, [entry])
|
|
1856
|
+
else list.push(entry)
|
|
1857
|
+
}
|
|
1858
|
+
let merged = 0
|
|
1859
|
+
for (const list of groups.values()) {
|
|
1860
|
+
const canonicalOf = (scope ) =>
|
|
1861
|
+
`project:${canonicalWorkspacePath(scope.slice('project:'.length))}`
|
|
1862
|
+
// 1) 写法已经规范的优先 2) 记录多的 3) 键名字典序(稳定,避免每次合并目标漂移)
|
|
1863
|
+
list.sort((a, b) =>
|
|
1864
|
+
Number(canonicalOf(b.scope) === b.scope) - Number(canonicalOf(a.scope) === a.scope)
|
|
1865
|
+
|| b.records - a.records
|
|
1866
|
+
|| a.scope.localeCompare(b.scope))
|
|
1867
|
+
const targetScope = list[0] .scope
|
|
1868
|
+
// 只有变体存在时(用 path 参数写进来的记忆,会话还没写过那个目录)也要**改名**:
|
|
1869
|
+
// 会话读的是规范键,不改名等于这份记忆永远看不见。改名后 records 一条不少。
|
|
1870
|
+
const canonicalTarget = canonicalOf(targetScope)
|
|
1871
|
+
const finalTarget = canonicalTarget === targetScope ? targetScope : canonicalTarget
|
|
1872
|
+
const sources = list.filter((entry) => entry.scope !== finalTarget)
|
|
1873
|
+
if (sources.length === 0) continue
|
|
1874
|
+
const targetStore = this.store.scope(finalTarget)
|
|
1875
|
+
for (const source of sources) {
|
|
1876
|
+
for (const record of [...source.store.records.values()]) {
|
|
1877
|
+
if (!targetStore.records.has(record.id)) {
|
|
1878
|
+
targetStore.insert({ ...record, scope: finalTarget })
|
|
1879
|
+
const vector = source.store.vectors.get(record.id)
|
|
1880
|
+
// 向量只有在维度与当前配置一致时才可信(换过模型/池化的边车已被 loadScope 校验过,
|
|
1881
|
+
// 这里再按维度兜一层);搬不动的留给回填/重启后重新嵌入。
|
|
1882
|
+
if (vector !== undefined && vector.length === this.cfg.vector.dims) {
|
|
1883
|
+
targetStore.setVector(record.id, vector)
|
|
1884
|
+
}
|
|
1885
|
+
}
|
|
1886
|
+
source.store.remove(record.id)
|
|
1887
|
+
}
|
|
1888
|
+
const alias = this.names.nameOf(source.scope)
|
|
1889
|
+
if (alias !== undefined) {
|
|
1890
|
+
this.names.release(source.scope)
|
|
1891
|
+
if (this.names.nameOf(finalTarget) === undefined) {
|
|
1892
|
+
try {
|
|
1893
|
+
this.names.claim(finalTarget, alias)
|
|
1894
|
+
} catch {
|
|
1895
|
+
// 名字已被别的 scope 占用 → 放弃别名(路径本身仍可引用)
|
|
1896
|
+
}
|
|
1897
|
+
}
|
|
1898
|
+
}
|
|
1899
|
+
merged += 1
|
|
1900
|
+
}
|
|
1901
|
+
}
|
|
1902
|
+
if (merged > 0) {
|
|
1903
|
+
this.store.flush()
|
|
1904
|
+
console.warn(`[dsh-memory-local] 已合并 ${merged} 个"同一目录不同写法"的项目作用域`)
|
|
1905
|
+
}
|
|
1906
|
+
return { merged }
|
|
1907
|
+
}
|
|
1908
|
+
|
|
1797
1909
|
/** Force a synchronous flush (dispose/HMR path). */
|
|
1798
1910
|
flushSync() {
|
|
1799
1911
|
if (this.maintenanceTimer) {
|
package/lib/provider/scope.js
CHANGED
|
@@ -19,6 +19,7 @@
|
|
|
19
19
|
* `foo:bar` 会与保留前缀撞成同一个键空间,用户也能靠它伪造 `project:` 键。
|
|
20
20
|
*/
|
|
21
21
|
import { createHash } from 'node:crypto'
|
|
22
|
+
import { posix, win32 } from 'node:path'
|
|
22
23
|
import { isCustomScopeKey } from './store.js'
|
|
23
24
|
|
|
24
25
|
/** 作用域键:除 'global' 外的形态由 resolveCurrentScopes / normalizeScopeInput 产生。 */
|
|
@@ -185,6 +186,62 @@ export function scopeTier(scope ) {
|
|
|
185
186
|
/** 写路径遇到只读 scope 时的错误码('all' 不能写)。 */
|
|
186
187
|
export const SCOPE_NOT_WRITABLE = 'SCOPE_NOT_WRITABLE'
|
|
187
188
|
|
|
189
|
+
// ------------------------------------------------------------------ 项目键的路径写法
|
|
190
|
+
|
|
191
|
+
/** `D:\x` / `D:/x` / `\\server\share` —— 只有这些才按 Windows 语义处理。 */
|
|
192
|
+
const WINDOWS_ABSOLUTE = /^(?:[A-Za-z]:[\\/]|\\\\)/u
|
|
193
|
+
/** Windows 盘符路径(`D:` 后跟分隔符);UNC 没有盘符,单独判。 */
|
|
194
|
+
const DRIVE_PATH = /^[A-Za-z]:[\\/]/u
|
|
195
|
+
const POSIX_ABSOLUTE = /^\//u
|
|
196
|
+
|
|
197
|
+
/**
|
|
198
|
+
* 项目作用域里的**路径规范形**:同一个目录只允许一种写法。
|
|
199
|
+
*
|
|
200
|
+
* 为什么需要:Windows 上 `D:/repositories/dsh-memory` 与 `D:\repositories\dsh-memory`
|
|
201
|
+
* 是同一个目录,但 `project:<路径>` 是字符串键、落盘文件名是它的 SHA-1 —— 两种写法会
|
|
202
|
+
* 变成两个 scope 文件。用 `memory_save({ path })` 写进去的记忆,同一个工作区里的会话
|
|
203
|
+
* (键来自宿主 `session.header.cwd`,反斜杠形式)再也读不到,而且注入 / 面板里会看到
|
|
204
|
+
* 两个"同名"作用域绝对路径。
|
|
205
|
+
*
|
|
206
|
+
* 只做**绝不可能指向另一个目录**的改写:
|
|
207
|
+
* - Windows 绝对路径走 `win32.resolve`:分隔符统一成 `\`、消掉 `.`/`..` 与末尾分隔符,
|
|
208
|
+
* 盘符统一大写(`d:\x` → `D:\x`);
|
|
209
|
+
* - POSIX 绝对路径走 `posix.resolve`(同样消掉 `.`/`..` 与末尾分隔符);
|
|
210
|
+
* - 非绝对路径**原样返回**(不能拿 process.cwd() 去猜:那是 DSH 的 profile 目录);
|
|
211
|
+
* - 大小写除盘符外**不动** —— 既有 scope 文件是按原始大小写做 SHA-1 的,擅自小写会让
|
|
212
|
+
* 旧数据"消失"。只是大小写不同的重复键由 `projectScopeIdentity` 识别、由 provider
|
|
213
|
+
* 在发现作用域时合并。
|
|
214
|
+
*/
|
|
215
|
+
export function canonicalWorkspacePath(value ) {
|
|
216
|
+
const trimmed = value.trim()
|
|
217
|
+
if (WINDOWS_ABSOLUTE.test(trimmed)) {
|
|
218
|
+
const resolved = win32.resolve(trimmed)
|
|
219
|
+
const driveFixed = DRIVE_PATH.test(resolved)
|
|
220
|
+
? resolved.replace(/^([a-z]):/u, (_, drive ) => `${drive.toUpperCase()}:`)
|
|
221
|
+
: resolved
|
|
222
|
+
return stripTrailingSeparators(driveFixed, win32)
|
|
223
|
+
}
|
|
224
|
+
if (POSIX_ABSOLUTE.test(trimmed)) return stripTrailingSeparators(posix.resolve(trimmed), posix)
|
|
225
|
+
return trimmed.replace(/[\\/]+$/u, '') || trimmed
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
function stripTrailingSeparators(path , impl ) {
|
|
229
|
+
// 根(`D:\` / `/`)本身就是一个合法的 scope 路径,不能剥成 `D:`。
|
|
230
|
+
if (path === impl.parse(path).root) return path
|
|
231
|
+
const stripped = path.replace(/[\\/]+$/u, '')
|
|
232
|
+
return stripped === '' ? path : stripped
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
/**
|
|
236
|
+
* 判断两个项目键是否指向"同一个目录":规范形之后,Windows 盘符路径再折叠大小写
|
|
237
|
+
* (Windows 文件系统不区分大小写)。POSIX 路径保留大小写 —— 在 Linux 上
|
|
238
|
+
* `/Users/a` 与 `/users/a` 是两个不同的目录。
|
|
239
|
+
*/
|
|
240
|
+
export function projectScopeIdentity(path ) {
|
|
241
|
+
const canonical = canonicalWorkspacePath(path)
|
|
242
|
+
return WINDOWS_ABSOLUTE.test(canonical) ? canonical.toLowerCase() : canonical
|
|
243
|
+
}
|
|
244
|
+
|
|
188
245
|
// ------------------------------------------------------------------ 当前会话 / 当前项目
|
|
189
246
|
|
|
190
247
|
/** 宿主 agent 上我们真正会碰到的那几个字段(其余一律不碰)。 */
|
|
@@ -235,7 +292,10 @@ export function resolveCurrentScopes(agent , opts
|
|
|
235
292
|
// 而 DSH 服务进程的 process.cwd() 是**profile 目录**(~/.dsh/profiles/<name>),
|
|
236
293
|
// 与工作区无关 —— 0.5.5 及以前把 `project:${process.cwd()}` 当成"配置"先传进来,
|
|
237
294
|
// 结果所有项目的项目级记忆都挤进同一个桶,`project:` 这个作用域等于失效。
|
|
238
|
-
|
|
295
|
+
// 路径再过一遍 canonicalWorkspacePath:宿主若给出 `D:/x` / 带尾部分隔符的写法,
|
|
296
|
+
// 与 path 参数、显式 project:<路径> 落到同一个 scope(0.11.1)。
|
|
297
|
+
const projectPath = cwd ?? stripProjectPrefix(opts.projectScope) ?? process.cwd()
|
|
298
|
+
const project = `project:${canonicalWorkspacePath(projectPath)}`
|
|
239
299
|
return sessionId !== undefined ? { session: `session:${sessionId}`, project } : { project }
|
|
240
300
|
}
|
|
241
301
|
|
package/lib/tools/index.js
CHANGED
|
@@ -12,7 +12,7 @@
|
|
|
12
12
|
*/
|
|
13
13
|
|
|
14
14
|
import { isAbsolute, resolve } from 'node:path'
|
|
15
|
-
import { normalizeScopeInput, resolveScopeRef } from '../provider/scope.js'
|
|
15
|
+
import { canonicalWorkspacePath, normalizeScopeInput, resolveScopeRef } from '../provider/scope.js'
|
|
16
16
|
|
|
17
17
|
/** Shape each tool shares: JSON-schema parameters + canonical output value. */
|
|
18
18
|
|
|
@@ -163,15 +163,15 @@ function resolveScope(
|
|
|
163
163
|
|
|
164
164
|
/**
|
|
165
165
|
* `path` → 绝对工作区路径。相对路径按会话 cwd 解析(拿不到就按进程 cwd),
|
|
166
|
-
*
|
|
166
|
+
* 再走 `canonicalWorkspacePath` 统一写法 —— 同一个目录必须只有一种 scope 键,
|
|
167
|
+
* 否则 `project:<路径>` 会分叉(`D:/x` 与 `D:\x` 曾是两个 scope,见 0.11.1)。
|
|
167
168
|
*/
|
|
168
169
|
function resolveWorkspacePath(raw , agent ) {
|
|
169
170
|
const value = raw.trim()
|
|
170
171
|
if (value === '') throw new MemoryToolError('PATH_INVALID', 'path 不能为空')
|
|
171
172
|
const cwd = (agent )?.session?.header?.cwd
|
|
172
173
|
const base = typeof cwd === 'string' && cwd.length > 0 ? cwd : process.cwd()
|
|
173
|
-
|
|
174
|
-
return full.replace(/[\\/]+$/u, '') || full
|
|
174
|
+
return canonicalWorkspacePath(isAbsolute(value) ? value : resolve(base, value))
|
|
175
175
|
}
|
|
176
176
|
|
|
177
177
|
export function memorySaveTool(opts ) {
|