Skip to content

Commit 477f1e9

Browse files
committed
feat(task): per-task file observation registry (A2, #1375)
1 parent 2c1582b commit 477f1e9

5 files changed

Lines changed: 200 additions & 0 deletions

File tree

‎src/core/task/Task.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,7 @@ import { ToolRepetitionDetector } from "../tools/ToolRepetitionDetector"
103103
import { restoreTodoListForTask } from "../tools/UpdateTodoListTool"
104104
import { FileContextTracker } from "../context-tracking/FileContextTracker"
105105
import { RooIgnoreController } from "../ignore/RooIgnoreController"
106+
import { ObservationRegistry } from "./observationRegistry"
106107
import { RooProtectedController } from "../protect/RooProtectedController"
107108
import { type AssistantMessageContent, presentAssistantMessage } from "../assistant-message"
108109
import { NativeToolCallParser } from "../assistant-message/NativeToolCallParser"
@@ -181,6 +182,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
181182
readonly parentTask: Task | undefined = undefined
182183
readonly taskNumber: number
183184
readonly workspacePath: string
185+
readonly observationRegistry = new ObservationRegistry()
184186

185187
/**
186188
* The mode associated with this task. Persisted across sessions
Lines changed: 72 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
import { describe, it, expect, vi } from "vitest"
2+
3+
import { ObservationRegistry } from "../observationRegistry"
4+
5+
describe("ObservationRegistry", () => {
6+
it("observe → get returns the recorded version and observedAt", () => {
7+
const reg = new ObservationRegistry()
8+
reg.observe("/a/b/c.ts", "1:2:300:4000000000:5000000000")
9+
10+
const obs = reg.get("/a/b/c.ts")
11+
expect(obs).toBeDefined()
12+
expect(obs!.version).toBe("1:2:300:4000000000:5000000000")
13+
expect(typeof obs!.observedAt).toBe("number")
14+
})
15+
16+
it("re-observe replaces the entry with a fresh observedAt", () => {
17+
vi.useFakeTimers()
18+
const reg = new ObservationRegistry()
19+
reg.observe("/a/b/c.ts", "v1")
20+
const first = reg.get("/a/b/c.ts")!
21+
expect(first.version).toBe("v1")
22+
23+
vi.advanceTimersByTime(50)
24+
reg.observe("/a/b/c.ts", "v2")
25+
const second = reg.get("/a/b/c.ts")!
26+
expect(second.version).toBe("v2")
27+
expect(second.observedAt).toBeGreaterThan(first.observedAt)
28+
29+
vi.useRealTimers()
30+
})
31+
32+
it("has returns true for observed paths, false otherwise", () => {
33+
const reg = new ObservationRegistry()
34+
reg.observe("/x.ts", "t1")
35+
expect(reg.has("/x.ts")).toBe(true)
36+
expect(reg.has("/y.ts")).toBe(false)
37+
})
38+
39+
it("size reflects the number of observed entries", () => {
40+
const reg = new ObservationRegistry()
41+
expect(reg.size).toBe(0)
42+
reg.observe("/a.ts", "t1")
43+
reg.observe("/b.ts", "t2")
44+
expect(reg.size).toBe(2)
45+
})
46+
47+
it("clear removes all entries and resets size to 0", () => {
48+
const reg = new ObservationRegistry()
49+
reg.observe("/a.ts", "t1")
50+
reg.observe("/b.ts", "t2")
51+
reg.clear()
52+
expect(reg.size).toBe(0)
53+
expect(reg.get("/a.ts")).toBeUndefined()
54+
expect(reg.has("/b.ts")).toBe(false)
55+
})
56+
57+
it("get on empty registry returns undefined", () => {
58+
const reg = new ObservationRegistry()
59+
expect(reg.get("/any.ts")).toBeUndefined()
60+
})
61+
62+
it("separate instances are independent — observing in one does not appear in the other", () => {
63+
const regA = new ObservationRegistry()
64+
const regB = new ObservationRegistry()
65+
regA.observe("/shared.ts", "v1")
66+
expect(regA.get("/shared.ts")).toBeDefined()
67+
expect(regB.get("/shared.ts")).toBeUndefined()
68+
regB.observe("/shared.ts", "v2")
69+
expect(regA.get("/shared.ts")!.version).toBe("v1")
70+
expect(regB.get("/shared.ts")!.version).toBe("v2")
71+
})
72+
})
Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
/**
2+
* Per-task file observation registry (upstream epic #1375, phase A2).
3+
*
4+
* Each Task owns its own instance so parent and subtask observations are
5+
* independent. The S4 guarded-write will compare these versions against the
6+
* token recomputed pre-write to detect stale reads or file replacement.
7+
*
8+
* Pure in-memory — zero I/O, no dependencies. No behavior change in this PR:
9+
* observations are recorded but not consulted.
10+
*/
11+
12+
export interface FileObservation {
13+
/** Version token derived from on-disk fs.stat (bigint mode). */
14+
version: string
15+
/** Millisecond timestamp when the observation was recorded. */
16+
observedAt: number
17+
}
18+
19+
export class ObservationRegistry {
20+
private readonly entries = new Map<string, FileObservation>()
21+
22+
/**
23+
* Record an observation for a file at its absolute path.
24+
*
25+
* Re-observing replaces the entry with a fresh observedAt timestamp and
26+
* the new version token.
27+
*/
28+
observe(absolutePath: string, version: string): void {
29+
this.entries.set(absolutePath, { version, observedAt: Date.now() })
30+
}
31+
32+
get(absolutePath: string): FileObservation | undefined {
33+
return this.entries.get(absolutePath)
34+
}
35+
36+
has(absolutePath: string): boolean {
37+
return this.entries.has(absolutePath)
38+
}
39+
40+
clear(): void {
41+
this.entries.clear()
42+
}
43+
44+
get size(): number {
45+
return this.entries.size
46+
}
47+
}

‎src/core/tools/ReadFileTool.ts‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@ import type { ReadFileParams, ReadFileMode, ReadFileToolParams, FileEntry, LineR
1616
import { isLegacyReadFileParams, type ClineSayTool } from "@roo-code/types"
1717

1818
import { Task } from "../task/Task"
19+
import { computeVersionToken } from "../../utils/versionToken"
1920
import { formatResponse } from "../prompts/responses"
2021
import { RecordSource } from "../context-tracking/FileContextTrackerTypes"
2122
import { isPathOutsideWorkspace } from "../../utils/pathUtils"
@@ -220,6 +221,11 @@ export class ReadFileTool extends BaseTool<"read_file"> {
220221

221222
await task.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource)
222223

224+
// A2 (plan #33 / epic #1375): record the observed on-disk version for the future write guard.
225+
// A stat failure leaves the target unobserved and never fails the read.
226+
const version = await computeVersionToken(fullPath).catch(() => undefined)
227+
if (version) task.observationRegistry.observe(fullPath, version)
228+
223229
updateFileResult(relPath, {
224230
nativeContent: `File: ${relPath}\n${result}`,
225231
})

‎src/core/tools/__tests__/readFileTool.spec.ts‎

Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,10 +13,14 @@
1313
*/
1414

1515
import path from "path"
16+
import type { Stats } from "fs"
1617

1718
import { isBinaryFile } from "isbinaryfile"
1819

1920
import { readFileTool, ReadFileTool } from "../ReadFileTool"
21+
import type { Task } from "../../task/Task"
22+
import { ObservationRegistry } from "../../task/observationRegistry"
23+
import { computeVersionToken } from "../../../utils/versionToken"
2024
import { formatResponse } from "../../prompts/responses"
2125
import {
2226
validateImageForProcessing,
@@ -136,13 +140,15 @@ interface MockTaskOptions {
136140
rooIgnoreAllowed?: boolean
137141
maxImageFileSize?: number
138142
maxTotalImageSize?: number
143+
observationRegistry?: import("../../task/observationRegistry").ObservationRegistry
139144
}
140145

141146
function createMockTask(options: MockTaskOptions = {}) {
142147
const { supportsImages = false, rooIgnoreAllowed = true, maxImageFileSize = 5, maxTotalImageSize = 20 } = options
143148

144149
return {
145150
cwd: "/test/workspace",
151+
observationRegistry: options.observationRegistry,
146152
api: {
147153
getModel: vi.fn().mockReturnValue({
148154
info: { supportsImages },
@@ -1489,5 +1495,72 @@ describe("ReadFileTool", () => {
14891495

14901496
expect(mockTask.didToolFailInCurrentTurn).toBe(true)
14911497
})
1498+
1499+
describe("observation registry", () => {
1500+
it("records an observation on successful read of an existing file", async () => {
1501+
const mockTask = createMockTask({
1502+
observationRegistry: new ObservationRegistry(),
1503+
})
1504+
const callbacks = createMockCallbacks()
1505+
1506+
// Override the beforeEach default stat mock with proper BigIntStats.
1507+
mockedFsStat.mockResolvedValue({
1508+
isDirectory: () => false,
1509+
dev: BigInt(1),
1510+
ino: BigInt(2),
1511+
size: BigInt(300),
1512+
mtimeNs: BigInt(4_000_000_000n),
1513+
ctimeNs: BigInt(5_000_000_000n),
1514+
// Cast: the mock only implements the members the tool and versionToken read.
1515+
} as unknown as Stats)
1516+
mockedIsBinaryFile.mockResolvedValue(false)
1517+
1518+
// Spy on observe to capture the exact key used (Windows path.resolve may use backslashes).
1519+
const reg = mockTask.observationRegistry!
1520+
const observeSpy = vi.spyOn(reg, "observe")
1521+
1522+
// Cast: the mock task only implements the members ReadFileTool.execute touches.
1523+
await readFileTool.execute({ path: "existing.ts" }, mockTask as unknown as Task, callbacks)
1524+
1525+
// Verify the tool called observe exactly once with a valid token.
1526+
expect(observeSpy).toHaveBeenCalledTimes(1)
1527+
const [calledPath, calledVersion] = observeSpy.mock.calls[0]
1528+
expect(calledPath).toContain("existing.ts")
1529+
expect(calledVersion).toMatch(/^\d+:\d+:\d+:\d+:\d+$/)
1530+
1531+
// Verify get() returns the same data using the spy-captured key.
1532+
const obs = reg.get(calledPath)
1533+
expect(obs).toBeDefined()
1534+
expect(obs!.version).toBe(calledVersion)
1535+
})
1536+
1537+
it("a failed read (absent path) leaves the registry size 0 and does not throw", async () => {
1538+
const mockTask = createMockTask({
1539+
observationRegistry: new ObservationRegistry(),
1540+
})
1541+
const callbacks = createMockCallbacks()
1542+
1543+
mockedFsReadFile.mockRejectedValue(new Error("ENOENT"))
1544+
1545+
// Cast: the mock task only implements the members ReadFileTool.execute touches.
1546+
await readFileTool.execute({ path: "missing.ts" }, mockTask as unknown as Task, callbacks)
1547+
1548+
// observationRegistry is guaranteed present because we passed it in createMockTask.
1549+
const reg = mockTask.observationRegistry
1550+
expect(reg).toBeDefined()
1551+
expect(reg!.size).toBe(0)
1552+
})
1553+
1554+
it("two separate Task-owned registries are independent", async () => {
1555+
const regA = new ObservationRegistry()
1556+
const regB = new ObservationRegistry()
1557+
regA.observe("/shared.ts", "v1")
1558+
expect(regA.get("/shared.ts")!.version).toBe("v1")
1559+
expect(regB.get("/shared.ts")).toBeUndefined()
1560+
regB.observe("/shared.ts", "v2")
1561+
expect(regA.get("/shared.ts")!.version).toBe("v1")
1562+
expect(regB.get("/shared.ts")!.version).toBe("v2")
1563+
})
1564+
})
14921565
})
14931566
})

0 commit comments

Comments
 (0)