can1357
45bade9612
- Added fully-qualified anchor paths in chunk read output showing complete path hierarchy with CRC checksums. - Added exact chunk selector resolution with CRC validation to enforce canonical chunk paths in edit operations. - Added `?` selector option to read syntax-aware chunks by canonical path listing when anchor paths are unclear. - Improved tree-sitter range handling with `end_row_as_line()` function to correctly convert half-open ranges to 1-indexed line numbers. - Extracted anchor label logic into `chunk_anchor_label()` const function and consolidated style-based selection. - Removed --dev flag support from native build pipeline and dev:native npm scripts.
606 lines
21 KiB
TypeScript
606 lines
21 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it } from "bun:test";
|
|
import * as fs from "node:fs/promises";
|
|
import * as os from "node:os";
|
|
import * as path from "node:path";
|
|
import { _resetSettingsForTest, Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
|
|
import { getLanguageFromPath } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
|
|
import { EditTool } from "@oh-my-pi/pi-coding-agent/patch";
|
|
import { HASHLINE_NIBBLE_ALPHABET } from "@oh-my-pi/pi-coding-agent/patch/hashline";
|
|
import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
|
|
import { GrepTool } from "@oh-my-pi/pi-coding-agent/tools/grep";
|
|
import { ReadTool } from "@oh-my-pi/pi-coding-agent/tools/read";
|
|
import { resolveFileDisplayMode } from "@oh-my-pi/pi-coding-agent/utils/file-display-mode";
|
|
import { ChunkReadStatus, ChunkState } from "@oh-my-pi/pi-natives";
|
|
import { applyChunkEdits } from "../../src/tools/chunk-tree";
|
|
|
|
function getText(result: { content: Array<{ type: string; text?: string }> }): string {
|
|
return result.content
|
|
.filter(block => block.type === "text")
|
|
.map(block => block.text ?? "")
|
|
.join("\n");
|
|
}
|
|
|
|
function createSession(cwd: string): ToolSession {
|
|
return {
|
|
cwd,
|
|
hasUI: false,
|
|
getSessionFile: () => null,
|
|
getSessionSpawns: () => "*",
|
|
settings: Settings.isolated(),
|
|
};
|
|
}
|
|
|
|
function getChunkChecksum(source: string, language: string, chunkPath: string): string {
|
|
const chunk = ChunkState.parse(source, language).chunk(chunkPath);
|
|
if (!chunk) {
|
|
throw new Error(`Chunk not found in fixture: ${chunkPath}`);
|
|
}
|
|
return chunk.checksum;
|
|
}
|
|
|
|
function buildLargeTypescriptFixture(): string {
|
|
const body = Array.from({ length: 60 }, (_, index) => ` total += ${index};`).join("\n");
|
|
return `class Server {\n private handleError(err: Error): string {\n let total = 0;\n${body}\n return err.message + total;\n }\n}\n\nfunction main(): void {\n console.log("boot");\n}\n`;
|
|
}
|
|
|
|
describe("chunk mode tools", () => {
|
|
let tmpDir: string;
|
|
let originalEditVariant: string | undefined;
|
|
|
|
beforeEach(async () => {
|
|
tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "chunk-mode-test-"));
|
|
_resetSettingsForTest();
|
|
await Settings.init({ inMemory: true, cwd: tmpDir });
|
|
originalEditVariant = Bun.env.PI_EDIT_VARIANT;
|
|
Bun.env.PI_EDIT_VARIANT = "chunk";
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await fs.rm(tmpDir, { recursive: true, force: true });
|
|
_resetSettingsForTest();
|
|
if (originalEditVariant === undefined) {
|
|
delete Bun.env.PI_EDIT_VARIANT;
|
|
} else {
|
|
Bun.env.PI_EDIT_VARIANT = originalEditVariant;
|
|
}
|
|
});
|
|
|
|
it("reads a TypeScript file as a chunk listing in chunk mode", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
const result = await tool.execute("chunk-read-root", { path: filePath });
|
|
const text = getText(result);
|
|
|
|
expect(text).toContain("server.ts·");
|
|
expect(text).toContain("[class_Server#");
|
|
expect(text).toContain("[fn_main#");
|
|
expect(text).not.toContain("ck:");
|
|
});
|
|
|
|
it("disables hashline display mode across shared tool renderers in chunk mode", () => {
|
|
const displayMode = resolveFileDisplayMode(createSession(tmpDir));
|
|
|
|
expect(displayMode.hashLines).toBe(false);
|
|
expect(displayMode.lineNumbers).toBe(false);
|
|
});
|
|
|
|
it("reads a specific chunk path and previews large child leaves inline", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
const result = await tool.execute("chunk-read-branch", { path: `${filePath}:class_Server.fn_handleError` });
|
|
const text = getText(result);
|
|
|
|
expect(text).not.toContain("to expand ⋮");
|
|
expect(text).toContain("let total = 0;");
|
|
expect(text).toContain("29| total += 25;");
|
|
expect(text).toContain("return err.message + total;");
|
|
});
|
|
|
|
it("renders line-range reads as range-scoped chunk output", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
const result = await tool.execute("chunk-read-lines", { path: filePath, sel: "L2-L4" });
|
|
const text = getText(result);
|
|
|
|
expect(text).toContain("[Notice: chunk view scoped to requested lines L2-L4; non-overlapping lines omitted.]");
|
|
expect(text).toContain("server.ts·");
|
|
expect(text).toContain("[class_Server.fn_handleError#");
|
|
expect(text).toContain("[class_Server.fn_handleError.var_total#");
|
|
expect(text).toContain("3|");
|
|
expect(text).toContain("4|");
|
|
expect(text).not.toContain("⋯");
|
|
});
|
|
|
|
it("supports L selectors in the path fragment in chunk mode", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
const result = await tool.execute("chunk-read-lines-in-path", { path: `${filePath}:L2-L4` });
|
|
const text = getText(result);
|
|
|
|
expect(text).toContain("[Notice: chunk view scoped to requested lines L2-L4; non-overlapping lines omitted.]");
|
|
expect(text).toContain("server.ts·");
|
|
expect(text).toContain("[class_Server.fn_handleError#");
|
|
expect(text).toContain("[class_Server.fn_handleError.var_total#");
|
|
expect(text).toContain("[class_Server.fn_handleError.var_total#");
|
|
expect(text).toContain("3|");
|
|
});
|
|
|
|
it("ignores a chunk selector checksum suffix on read", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const staleChecksum = getChunkChecksum(originalSource, "typescript", "class_Server.fn_handleError");
|
|
await Bun.write(filePath, originalSource.replace(" return err.message + total;", " return err.message;"));
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
const result = await tool.execute("chunk-read-stale-checksum", {
|
|
path: `${filePath}:class_Server.fn_handleError#${staleChecksum}`,
|
|
});
|
|
const text = getText(result);
|
|
|
|
expect(text).toContain("server.ts:class_Server.fn_handleError·");
|
|
expect(text).not.toContain("[Warning: checksum #");
|
|
});
|
|
|
|
it("routes .tsx files to the TSX grammar in chunk mode", async () => {
|
|
const filePath = path.join(tmpDir, "component.tsx");
|
|
await Bun.write(filePath, 'export function App() { return <div className="ok">ok</div>; }\n');
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
const result = await tool.execute("chunk-read-tsx", { path: filePath });
|
|
const text = getText(result);
|
|
|
|
expect(text).toContain("component.tsx·");
|
|
expect(text).toContain("tsx");
|
|
expect(text).toContain("[fn_App#");
|
|
});
|
|
|
|
it("maps Handlebars and TLA+ file extensions for chunk mode", () => {
|
|
expect(getLanguageFromPath("/tmp/template.hbs")).toBe("handlebars");
|
|
expect(getLanguageFromPath("/tmp/template.hsb")).toBe("handlebars");
|
|
expect(getLanguageFromPath("/tmp/spec.tla")).toBe("tlaplus");
|
|
expect(getLanguageFromPath("/tmp/spec.tlaplus")).toBe("tlaplus");
|
|
});
|
|
|
|
it("annotates grep hits with chunk paths", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const tool = new GrepTool(createSession(tmpDir));
|
|
|
|
const result = await tool.execute("chunk-grep", {
|
|
pattern: "err\\.message",
|
|
path: filePath,
|
|
});
|
|
const text = getText(result);
|
|
|
|
expect(text).toContain("server.ts:class_Server.fn_handleError");
|
|
expect(text).toContain(".return>64|");
|
|
expect(text).toContain("err.message");
|
|
});
|
|
|
|
it("replaces a chunk using a copied selector in path", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const session = createSession(tmpDir);
|
|
const readTool = new ReadTool(session);
|
|
const editTool = new EditTool(session);
|
|
|
|
const branchRead = await readTool.execute("chunk-read-before-edit", {
|
|
path: `${filePath}:class_Server.fn_handleError`,
|
|
});
|
|
const branchText = getText(branchRead);
|
|
const checksum = new RegExp(
|
|
`server\\.ts:class_Server\\.fn_handleError[^\n]*#([${HASHLINE_NIBBLE_ALPHABET}]{4})`,
|
|
"i",
|
|
).exec(branchText)?.[1];
|
|
expect(checksum).toBeDefined();
|
|
|
|
const editResult = await editTool.execute("chunk-edit", {
|
|
path: filePath,
|
|
edits: [
|
|
{
|
|
target: `class_Server.fn_handleError#${checksum}`,
|
|
content: ` private handleError(err: Error): string {
|
|
return \`normalized:\${err.message}\`;
|
|
}
|
|
`,
|
|
},
|
|
],
|
|
} as never);
|
|
const editText = getText(editResult);
|
|
const updatedSource = await Bun.file(filePath).text();
|
|
|
|
expect(updatedSource).toContain("normalized:");
|
|
expect(updatedSource).not.toContain("total +=");
|
|
expect(editText).toContain("server.ts·");
|
|
expect(editText).toContain("@@ -3,62 +3,1 @@");
|
|
});
|
|
|
|
it("applies omitted-sel batch splices when the second operation uses the post-first checksum", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const chunkPath = "class_Server.fn_handleError";
|
|
const checksum = getChunkChecksum(originalSource, "typescript", chunkPath);
|
|
const afterFirst = applyChunkEdits({
|
|
source: originalSource,
|
|
language: "typescript",
|
|
cwd: tmpDir,
|
|
filePath,
|
|
operations: [
|
|
{
|
|
op: "replace",
|
|
sel: chunkPath,
|
|
crc: checksum,
|
|
line: 63,
|
|
endLine: 63,
|
|
content: "return err.message.toUpperCase() + total;",
|
|
},
|
|
],
|
|
}).diffSourceAfter;
|
|
const checksum2 = getChunkChecksum(afterFirst, "typescript", chunkPath);
|
|
|
|
await editTool.execute("chunk-edit-default-selector-batch", {
|
|
path: filePath,
|
|
edits: [
|
|
{
|
|
target: `${chunkPath}#${checksum}`,
|
|
line: 63,
|
|
end_line: 63,
|
|
content: "return err.message.toUpperCase() + total;",
|
|
},
|
|
{ target: `${chunkPath}#${checksum2}`, line: 3, end_line: 3, content: "let total = 1;" },
|
|
],
|
|
} as never);
|
|
|
|
const updatedSource = await Bun.file(filePath).text();
|
|
expect(updatedSource).toContain("let total = 1;");
|
|
expect(updatedSource).toContain("return err.message.toUpperCase() + total;");
|
|
});
|
|
|
|
it("rejects L0 selector as invalid", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
await expect(tool.execute("chunk-read-L0", { path: filePath, sel: "L0" })).rejects.toThrow(
|
|
/L0 is invalid.*1-indexed/,
|
|
);
|
|
});
|
|
|
|
it("rejects reversed line range selector", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
await expect(tool.execute("chunk-read-reversed", { path: filePath, sel: "L30-L20" })).rejects.toThrow(
|
|
/end must be >= start/,
|
|
);
|
|
});
|
|
|
|
it("accepts string content for chunk insert operations", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
|
|
await editTool.execute("chunk-edit-string-content", {
|
|
path: filePath,
|
|
edits: [{ target: "class_Server", op: "append", content: 'status(): string {\n return "ok";\n}\n' }],
|
|
} as never);
|
|
|
|
const updatedSource = await Bun.file(filePath).text();
|
|
expect(updatedSource).toContain("status(): string");
|
|
expect(updatedSource).toContain('return "ok";');
|
|
});
|
|
|
|
it("supports explicit absolute-line zero-width splices", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const chunkPath = "class_Server.fn_handleError";
|
|
const fileText = await Bun.file(filePath).text();
|
|
const checksum = getChunkChecksum(fileText, "typescript", chunkPath);
|
|
const afterInsertAfter = applyChunkEdits({
|
|
source: fileText,
|
|
language: "typescript",
|
|
cwd: tmpDir,
|
|
filePath,
|
|
operations: [
|
|
{
|
|
op: "replace",
|
|
sel: chunkPath,
|
|
crc: checksum,
|
|
line: 4,
|
|
endLine: 3,
|
|
content: "const end = Date.now();",
|
|
},
|
|
],
|
|
}).diffSourceAfter;
|
|
const checksum2 = getChunkChecksum(afterInsertAfter, "typescript", chunkPath);
|
|
|
|
// Zero-width splices at larger `end` run first (bottom-up) so line numbers stay stable.
|
|
await editTool.execute("chunk-edit-insert-lines", {
|
|
path: filePath,
|
|
edits: [
|
|
{ target: `${chunkPath}#${checksum}`, line: 4, end_line: 3, content: "const end = Date.now();" },
|
|
{ target: `${chunkPath}#${checksum2}`, line: 3, end_line: 2, content: "const start = Date.now();" },
|
|
],
|
|
} as never);
|
|
|
|
const updatedSource = await Bun.file(filePath).text();
|
|
expect(updatedSource).toContain(" const start = Date.now();");
|
|
expect(updatedSource).toContain(" const end = Date.now();");
|
|
expect(updatedSource).toContain(" let total = 0;");
|
|
});
|
|
|
|
it("treats empty replace content as delete", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const checksum = getChunkChecksum(originalSource, "typescript", "fn_main");
|
|
|
|
await editTool.execute("chunk-edit-empty-replace-delete", {
|
|
path: filePath,
|
|
edits: [{ target: `fn_main#${checksum}`, content: "" }],
|
|
});
|
|
|
|
const updatedSource = await Bun.file(filePath).text();
|
|
expect(updatedSource).not.toContain("function main(): void");
|
|
});
|
|
|
|
it("returns structured status for missing chunk reads", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
await Bun.write(filePath, buildLargeTypescriptFixture());
|
|
const tool = new ReadTool(createSession(tmpDir));
|
|
|
|
const result = await tool.execute("chunk-read-missing", {
|
|
path: `${filePath}:class_Server.fn_missing`,
|
|
});
|
|
|
|
expect(getText(result)).toContain("Chunk path not found");
|
|
expect(result.details?.chunk).toEqual({
|
|
status: ChunkReadStatus.NotFound,
|
|
selector: "class_Server.fn_missing",
|
|
});
|
|
});
|
|
|
|
it("rejects reversed splice ranges without changing the file", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const checksum = getChunkChecksum(originalSource, "typescript", "class_Server.fn_handleError");
|
|
|
|
await expect(
|
|
editTool.execute("chunk-edit-invalid-splice-range", {
|
|
path: filePath,
|
|
edits: [
|
|
{
|
|
target: `class_Server.fn_handleError#${checksum}`,
|
|
line: 5,
|
|
end_line: 2,
|
|
content: " let total = 1;",
|
|
},
|
|
],
|
|
}),
|
|
).rejects.toThrow(/Invalid line range L5-L2/);
|
|
|
|
expect(await Bun.file(filePath).text()).toBe(originalSource);
|
|
});
|
|
|
|
it("rolls back mixed-validity batches without changing the file", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
|
|
await expect(
|
|
editTool.execute("chunk-edit-batch-rollback", {
|
|
path: filePath,
|
|
edits: [
|
|
{ target: "class_Server", op: "append", content: ' status(): string {\n return "ok";\n }' },
|
|
{ target: "class_Server.fn_handleError#ZZZZ", op: "delete" },
|
|
],
|
|
}),
|
|
).rejects.toThrow(/No changes were saved/);
|
|
|
|
expect(await Bun.file(filePath).text()).toBe(originalSource);
|
|
});
|
|
|
|
it("leaves files unchanged when an edit is rejected for introducing parse errors", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const checksum = getChunkChecksum(originalSource, "typescript", "class_Server.fn_handleError");
|
|
|
|
await expect(
|
|
editTool.execute("chunk-edit-parse-reject", {
|
|
path: filePath,
|
|
edits: [
|
|
{
|
|
target: `class_Server.fn_handleError#${checksum}`,
|
|
content: " private handleError(err: Error): string {\n if (err) {\n",
|
|
},
|
|
],
|
|
}),
|
|
).rejects.toThrow(/Parse errors:[\s\S]*L\d+:C\d+/i);
|
|
|
|
expect(await Bun.file(filePath).text()).toBe(originalSource);
|
|
});
|
|
|
|
it("auto-accepts stale CRC in mixed batches on the same chunk", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const checksum = getChunkChecksum(originalSource, "typescript", "class_Server.fn_handleError");
|
|
|
|
const _result = await editTool.execute("chunk-edit-stale-mixed-batch", {
|
|
path: filePath,
|
|
edits: [
|
|
{
|
|
target: `class_Server.fn_handleError#${checksum}`,
|
|
content: " private handleError(err: Error): string {\n return err.message;\n }",
|
|
},
|
|
{
|
|
target: `class_Server.fn_handleError#${checksum}`,
|
|
line: 3,
|
|
end_line: 3,
|
|
content: " return err.message.toUpperCase();",
|
|
},
|
|
],
|
|
});
|
|
|
|
const updatedSource = await Bun.file(filePath).text();
|
|
expect(updatedSource).toContain("toUpperCase");
|
|
});
|
|
|
|
it("rejects missing CRC", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
|
|
await expect(
|
|
editTool.execute("chunk-edit-strong-crc", {
|
|
path: filePath,
|
|
edits: [
|
|
{
|
|
target: "class_Server.fn_handleError",
|
|
line: 3,
|
|
end_line: 3,
|
|
content: " let total = 1;",
|
|
},
|
|
],
|
|
}),
|
|
).rejects.toThrow(/Checksum required/);
|
|
expect(await Bun.file(filePath).text()).toBe(originalSource);
|
|
});
|
|
|
|
it("rejects non-canonical edit selectors", async () => {
|
|
const filePath = path.join(tmpDir, "server.ts");
|
|
const originalSource = buildLargeTypescriptFixture();
|
|
await Bun.write(filePath, originalSource);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const checksum = getChunkChecksum(originalSource, "typescript", "fn_main");
|
|
|
|
await expect(
|
|
editTool.execute("chunk-edit-prefix-resolve", {
|
|
path: filePath,
|
|
edits: [{ target: `main#${checksum}`, content: 'function main(): void {\n console.log("started");\n}\n' }],
|
|
}),
|
|
).rejects.toThrow(/Chunk path not found: "main"/);
|
|
expect(await Bun.file(filePath).text()).toBe(originalSource);
|
|
});
|
|
|
|
it("resolves root-only checksum targets to the file root", async () => {
|
|
const filePath = path.join(tmpDir, "CONTRIBUTING.md");
|
|
const source = `# Contributing to uLua
|
|
|
|
## Building and Testing
|
|
|
|
Use just.
|
|
|
|
## Code Style
|
|
|
|
Use clang-format.
|
|
`;
|
|
await Bun.write(filePath, source);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const language = getLanguageFromPath(filePath);
|
|
if (!language) {
|
|
throw new Error("expected markdown language");
|
|
}
|
|
const state = ChunkState.parse(source, language);
|
|
const root = state.root();
|
|
if (!root) {
|
|
throw new Error("expected root chunk");
|
|
}
|
|
expect(state.chunks().filter(chunk => chunk.checksum === root.checksum).length).toBeGreaterThan(1);
|
|
|
|
const _result = await editTool.execute("chunk-edit-root-checksum", {
|
|
path: filePath,
|
|
edits: [{ target: `#${root.checksum}`, line: 1, end_line: 1, content: "# Updated guide" }],
|
|
});
|
|
|
|
const updatedSource = await Bun.file(filePath).text();
|
|
expect(updatedSource.startsWith("# Updated guide\n")).toBe(true);
|
|
expect(updatedSource).toContain("## Building and Testing");
|
|
});
|
|
|
|
it("preserves sibling headings when replacing a whole markdown section", async () => {
|
|
const filePath = path.join(tmpDir, "CONTRIBUTING.md");
|
|
const source = [
|
|
"# Contributing to uLua",
|
|
"",
|
|
"## Building and Testing",
|
|
"",
|
|
"```bash",
|
|
"cmake -S . -B build",
|
|
"```",
|
|
"",
|
|
"## Code Style",
|
|
"",
|
|
"- Follow .clang-format.",
|
|
"",
|
|
"## Commit Messages",
|
|
"",
|
|
"- Use imperative mood.",
|
|
"",
|
|
].join("\n");
|
|
await Bun.write(filePath, source);
|
|
const session = createSession(tmpDir);
|
|
const editTool = new EditTool(session);
|
|
const language = getLanguageFromPath(filePath);
|
|
if (!language) {
|
|
throw new Error("expected markdown language");
|
|
}
|
|
const state = ChunkState.parse(source, language);
|
|
const building = state
|
|
.chunks()
|
|
.find(chunk => chunk.path === "section_Contributing_to_uLua.section_Building_and_Testing");
|
|
if (!building) {
|
|
throw new Error("expected section_Building_and_Testing chunk");
|
|
}
|
|
|
|
await editTool.execute("chunk-edit-section-replace", {
|
|
path: filePath,
|
|
edits: [
|
|
{
|
|
target: `${building.path}#${building.checksum}`,
|
|
content: "## Building and Testing\n\nUse `just verify` instead. It wraps cmake and ctest.\n",
|
|
},
|
|
],
|
|
});
|
|
|
|
const updatedSource = await Bun.file(filePath).text();
|
|
expect(updatedSource).toContain("## Code Style");
|
|
expect(updatedSource).toContain("## Commit Messages");
|
|
expect(updatedSource).toContain("Use `just verify`");
|
|
expect(updatedSource).not.toContain("cmake -S . -B build");
|
|
});
|
|
});
|