block-in-file 1.0.0

package/test/input.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+
+function get<T>(source: Partial<T>, defaults: Partial<T>, ...keys: (keyof T)[]) {
+  if (keys.length === 1) {
+    const key = keys[0];
+    const o = source[key];
+    return (o !== undefined ? o : defaults?.[key]) as unknown;
+  }
+  const o = Array.from({ length: keys.length });
+  for (const i in keys) {
+    o[i] = get(source, defaults, keys[i]);
+  }
+  return o;
+}
+
+function createOpt(
+  value: boolean | 0 | 1 | "file" | "block",
+  target: "file" | "block",
+): { create: boolean } | undefined {
+  return value === 1 || value === true || value === target ? { create: true } : undefined;
+}
+
+describe("input utilities", () => {
+  describe("get", () => {
+    const source: Partial<{ a: number; b: number; c: number }> = { a: 1, b: 2 };
+    const defaults: Partial<{ a: number; b: number; c: number }> = { a: 10, b: 20, c: 30 };
+
+    it.each([
+      { key: "a" as const, expected: 1 },
+      { key: "b" as const, expected: 2 },
+    ])("returns source value for key $key", ({ key, expected }) => {
+      expect(get(source, defaults, key)).toBe(expected);
+    });
+
+    it("falls back to defaults when source value missing", () => {
+      expect(get(source, defaults, "c")).toBe(30);
+    });
+
+    it("returns undefined when neither has value", () => {
+      expect(get(source, defaults, "d" as keyof typeof source)).toBeUndefined();
+    });
+
+    it("handles multiple keys, returning array", () => {
+      const result = get(source, defaults, "a", "b", "c");
+      expect(result).toEqual([1, 2, 30]);
+    });
+
+    it.each([
+      { source: {}, expected: 10 },
+      { source: source, expected: 1 },
+    ])("handles source value for key 'a'", ({ source: testSource, expected }) => {
+      expect(get(testSource, defaults, "a")).toBe(expected);
+    });
+
+    it("handles empty defaults", () => {
+      expect(get(source, {}, "a")).toBe(1);
+    });
+
+    it("prefers explicit undefined in source over default", () => {
+      const sourceWithUndefined: Partial<{ a: number; b: number; c: number }> = { a: undefined };
+      expect(get(sourceWithUndefined, defaults, "a")).toBe(10);
+    });
+  });
+
+  describe("createOpt", () => {
+    it.each([
+      { value: true as const, target: "file" as const, expected: { create: true } },
+      { value: true as const, target: "block" as const, expected: { create: true } },
+      { value: 1 as const, target: "file" as const, expected: { create: true } },
+      { value: 1 as const, target: "block" as const, expected: { create: true } },
+      { value: "file" as const, target: "file" as const, expected: { create: true } },
+      { value: "block" as const, target: "block" as const, expected: { create: true } },
+    ])("returns create:true when value=$value, target=$target", ({ value, target, expected }) => {
+      expect(createOpt(value, target)).toEqual(expected);
+    });
+
+    it.each([
+      { value: "file" as const, target: "block" as const },
+      { value: "block" as const, target: "file" as const },
+      { value: false as const, target: "file" as const },
+      { value: 0 as const, target: "file" as const },
+    ])("returns undefined when value=$value, target=$target", ({ value, target }) => {
+      expect(createOpt(value, target)).toBeUndefined();
+    });
+  });
+});

package/test/mode.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { execSync } from "node:child_process";
+
+describe("Mode functionality", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "blockinfile-mode-test-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  function runBlockInFile(args: string, input?: string): string {
+    const cwd = path.resolve(import.meta.dirname!, "..");
+    const cmd = `npx tsx block-in-file.ts ${args}`;
+    return execSync(cmd, {
+      cwd,
+      input,
+      encoding: "utf-8",
+    });
+  }
+
+  describe("mode=ensure (idempotent)", () => {
+    it("should create block when missing", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const input = "new block content";
+
+      const _result = runBlockInFile(`--mode ensure ${targetFile}`, input);
+      const content = await fs.readFile(targetFile, "utf-8");
+
+      expect(content).toContain(input);
+      expect(content).toContain("# blockinfile start");
+      expect(content).toContain("# blockinfile end");
+    });
+
+    it("should update block when content differs", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const initialContent = "initial content";
+      const updatedContent = "updated content";
+
+      await fs.writeFile(targetFile, `# blockinfile start\n${initialContent}\n# blockinfile end\n`);
+
+      const _result1 = runBlockInFile(`--mode ensure ${targetFile}`, updatedContent);
+      const content1 = await fs.readFile(targetFile, "utf-8");
+      expect(content1).toContain(updatedContent);
+      expect(content1).not.toContain(initialContent);
+
+      const _result2 = runBlockInFile(`--mode ensure ${targetFile}`, updatedContent);
+      const content2 = await fs.readFile(targetFile, "utf-8");
+
+      expect(content2).toContain(updatedContent);
+    });
+
+    it("should skip when content unchanged (idempotent)", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const input = "test content";
+
+      await fs.writeFile(targetFile, `# blockinfile start\n${input}\n# blockinfile end\n`);
+
+      const _result = runBlockInFile(`--mode ensure --debug ${targetFile}`, input);
+      const content = await fs.readFile(targetFile, "utf-8");
+
+      expect(content).toContain(input);
+      expect(_result).toContain("no changes needed");
+    });
+  });
+
+  describe("mode=only (create if missing)", () => {
+    it("should create block when missing", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const input = "new block content";
+
+      const _result = runBlockInFile(`--mode only ${targetFile}`, input);
+      const content = await fs.readFile(targetFile, "utf-8");
+
+      expect(content).toContain(input);
+      expect(content).toContain("# blockinfile start");
+      expect(content).toContain("# blockinfile end");
+    });
+
+    it("should skip when block already exists", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const initialContent = "initial content";
+      const differentContent = "different content";
+
+      await fs.writeFile(targetFile, `# blockinfile start\n${initialContent}\n# blockinfile end\n`);
+
+      const _result = runBlockInFile(`--mode only --debug ${targetFile}`, differentContent);
+      const content = await fs.readFile(targetFile, "utf-8");
+
+      expect(content).toContain(initialContent);
+      expect(content).not.toContain(differentContent);
+      expect(_result).toContain("block already exists");
+    });
+
+    it("should skip even if block content differs", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const initialContent = "version 1";
+      const newContent = "version 2";
+
+      await fs.writeFile(targetFile, `# blockinfile start\n${initialContent}\n# blockinfile end\n`);
+
+      const _result = runBlockInFile(`--mode only --debug ${targetFile}`, newContent);
+      const content = await fs.readFile(targetFile, "utf-8");
+
+      expect(content).toContain(initialContent);
+      expect(content).not.toContain(newContent);
+      expect(_result).toContain("block already exists");
+    });
+
+    it("should create when file exists but block missing", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const input = "block content";
+
+      await fs.writeFile(targetFile, "some existing content\n");
+
+      runBlockInFile(`--mode only ${targetFile}`, input);
+      const content = await fs.readFile(targetFile, "utf-8");
+
+      expect(content).toContain(input);
+      expect(content).toContain("some existing content");
+    });
+  });
+
+  describe("mode=none (legacy behavior)", () => {
+    it("should always attempt to insert/update block", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const content1 = "first content";
+      const content2 = "second content";
+
+      await fs.writeFile(targetFile, `# blockinfile start\n${content1}\n# blockinfile end\n`);
+
+      runBlockInFile(`--mode none ${targetFile}`, content2);
+      const fileContent = await fs.readFile(targetFile, "utf-8");
+
+      expect(fileContent).toContain(content2);
+    });
+
+    it("should be the default mode", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const input = "default behavior test";
+
+      runBlockInFile(`${targetFile}`, input);
+      const content = await fs.readFile(targetFile, "utf-8");
+
+      expect(content).toContain(input);
+    });
+  });
+
+  describe("mode with multiple files", () => {
+    it("should process all files correctly in ensure mode", async () => {
+      const file1 = path.join(tempDir, "file1.txt");
+      const file2 = path.join(tempDir, "file2.txt");
+      const file3 = path.join(tempDir, "file3.txt");
+      const input = "shared content";
+
+      await fs.writeFile(file1, `# blockinfile start\n${input}\n# blockinfile end\n`);
+
+      runBlockInFile(`--mode ensure ${file1} ${file2} ${file3}`, input);
+
+      const content1 = await fs.readFile(file1, "utf-8");
+      const content2 = await fs.readFile(file2, "utf-8");
+      const content3 = await fs.readFile(file3, "utf-8");
+
+      expect(content1).toContain(input);
+      expect(content2).toContain(input);
+      expect(content3).toContain(input);
+    });
+
+    it("should skip existing blocks in only mode across multiple files", async () => {
+      const file1 = path.join(tempDir, "file1.txt");
+      const file2 = path.join(tempDir, "file2.txt");
+      const input1 = "original content";
+      const input2 = "new content";
+
+      await fs.writeFile(file1, `# blockinfile start\n${input1}\n# blockinfile end\n`);
+
+      runBlockInFile(`--debug --mode only ${file1} ${file2}`, input2);
+
+      const content1 = await fs.readFile(file1, "utf-8");
+      const content2 = await fs.readFile(file2, "utf-8");
+
+      expect(content1).toContain(input1);
+      expect(content1).not.toContain(input2);
+      expect(content2).toContain(input2);
+    });
+  });
+});

package/test/output.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { formatOutputs, generateDiff } from "../src/output.ts";
+
+describe("output utilities", () => {
+  describe("formatOutputs", () => {
+    it.each([
+      { outputs: ["line1", "line2", "line3"], dos: false, expected: "line1\nline2\nline3\n" },
+      { outputs: ["line1", "line2", "line3"], dos: true, expected: "line1\r\nline2\r\nline3\r\n" },
+      { outputs: ["line1", "line2"], dos: false, expected: "line1\nline2\n" },
+      { outputs: ["line1", "line2", ""], dos: false, expected: "line1\nline2\n" },
+      { outputs: [], dos: false, expected: "" },
+      { outputs: ["only line"], dos: false, expected: "only line\n" },
+      { outputs: ["line1", "", "line3"], dos: false, expected: "line1\n\nline3\n" },
+    ])("handles outputs: $outputs", ({ outputs, dos, expected }) => {
+      const result = formatOutputs(outputs, dos);
+      expect(result).toBe(expected);
+    });
+  });
+
+  describe("generateDiff", () => {
+    it("shows no changes for identical content", () => {
+      const content = "line1\nline2\n";
+      const diff = generateDiff(content, content, "test.txt");
+      expect(diff).toContain("--- test.txt");
+      expect(diff).toContain("+++ test.txt");
+      expect(diff).not.toContain("-line");
+      expect(diff).not.toContain("+line");
+    });
+
+    it.each([
+      { original: "line1\nline2\n", modified: "line1\nNEW\nline2\n", expected: "+NEW" },
+      { original: "line1\nOLD\nline2\n", modified: "line1\nline2\n", expected: "-OLD" },
+      { original: "line1\nOLD\nline2\n", modified: "line1\nNEW\nline2\n", expectedContains: ["-OLD", "+NEW"] },
+    ])("handles diff: $modified", ({ original, modified, expected, expectedContains }) => {
+      const diff = generateDiff(original, modified, "test.txt");
+      if (expected) {
+        expect(diff).toContain(expected);
+      }
+      if (expectedContains) {
+        expectedContains.forEach(str => expect(diff).toContain(str));
+      }
+    });
+  });
+});

package/test/tag-merger.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from "vitest";
+import { mergeTags, replaceTags, applyTagMode } from "../src/tags/tag-merger.ts";
+
+describe("mergeTags", () => {
+  it("should merge new tags into existing tags", () => {
+    const existingTags = [{ name: "tag1", value: "value1" }];
+    const newTags = [{ name: "tag2", value: "value2" }];
+    const result = mergeTags(existingTags, newTags);
+    expect(result).toEqual([
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ]);
+  });
+
+  it("should update existing tags with new values", () => {
+    const existingTags = [{ name: "tag1", value: "value1" }];
+    const newTags = [{ name: "tag1", value: "newvalue" }];
+    const result = mergeTags(existingTags, newTags);
+    expect(result).toEqual([{ name: "tag1", value: "newvalue" }]);
+  });
+
+  it("should preserve tags not being updated", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ];
+    const newTags = [{ name: "tag1", value: "newvalue" }];
+    const result = mergeTags(existingTags, newTags);
+    expect(result).toEqual([
+      { name: "tag1", value: "newvalue" },
+      { name: "tag2", value: "value2" },
+    ]);
+  });
+
+  it("should handle empty existing tags", () => {
+    const existingTags: any[] = [];
+    const newTags = [{ name: "tag1", value: "value1" }];
+    const result = mergeTags(existingTags, newTags);
+    expect(result).toEqual([{ name: "tag1", value: "value1" }]);
+  });
+
+  it("should handle empty new tags", () => {
+    const existingTags = [{ name: "tag1", value: "value1" }];
+    const newTags: any[] = [];
+    const result = mergeTags(existingTags, newTags);
+    expect(result).toEqual([{ name: "tag1", value: "value1" }]);
+  });
+
+  it("should merge timestamp tags", () => {
+    const existingTags = [{ name: "timestamp", value: "1234567890" }];
+    const newTags = [{ name: "timestamp", value: "9876543210" }];
+    const result = mergeTags(existingTags, newTags);
+    expect(result).toEqual([{ name: "timestamp", value: "9876543210" }]);
+  });
+});
+
+describe("replaceTags", () => {
+  it("should replace all existing tags with new tags", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ];
+    const newTags = [{ name: "tag3", value: "value3" }];
+    const result = replaceTags(existingTags, newTags);
+    expect(result).toEqual([{ name: "tag3", value: "value3" }]);
+  });
+
+  it("should return new tags when existing tags are empty", () => {
+    const existingTags: any[] = [];
+    const newTags = [{ name: "tag1", value: "value1" }];
+    const result = replaceTags(existingTags, newTags);
+    expect(result).toEqual([{ name: "tag1", value: "value1" }]);
+  });
+
+  it("should return empty array when both are empty", () => {
+    const existingTags: any[] = [];
+    const newTags: any[] = [];
+    const result = replaceTags(existingTags, newTags);
+    expect(result).toEqual([]);
+  });
+
+  it("should clear all tags when new tags is empty", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ];
+    const newTags: any[] = [];
+    const result = replaceTags(existingTags, newTags);
+    expect(result).toEqual([]);
+  });
+});
+
+describe("applyTagMode", () => {
+  it("should apply merge mode by default", () => {
+    const existingTags = [{ name: "tag1", value: "value1" }];
+    const newTags = [{ name: "tag2", value: "value2" }];
+    const result = applyTagMode(existingTags, newTags, "merge");
+    expect(result).toEqual([
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ]);
+  });
+
+  it("should apply merge mode and preserve existing tags", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+      { name: "anchor-bof", value: "100" },
+    ];
+    const newTags = [{ name: "timestamp", value: "1234567890" }];
+    const result = applyTagMode(existingTags, newTags, "merge");
+    expect(result).toEqual([
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+      { name: "anchor-bof", value: "100" },
+      { name: "timestamp", value: "1234567890" },
+    ]);
+  });
+
+  it("should apply merge mode and update existing tags", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "timestamp", value: "1234567890" },
+    ];
+    const newTags = [{ name: "timestamp", value: "9876543210" }];
+    const result = applyTagMode(existingTags, newTags, "merge");
+    expect(result).toEqual([
+      { name: "tag1", value: "value1" },
+      { name: "timestamp", value: "9876543210" },
+    ]);
+  });
+
+  it("should apply replace mode", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ];
+    const newTags = [{ name: "tag3", value: "value3" }];
+    const result = applyTagMode(existingTags, newTags, "replace");
+    expect(result).toEqual([{ name: "tag3", value: "value3" }]);
+  });
+
+  it("should apply replace mode and clear all existing tags", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "timestamp", value: "1234567890" },
+      { name: "anchor-bof", value: "100" },
+    ];
+    const newTags = [{ name: "timestamp", value: "9876543210" }];
+    const result = applyTagMode(existingTags, newTags, "replace");
+    expect(result).toEqual([{ name: "timestamp", value: "9876543210" }]);
+  });
+
+  it("should handle empty new tags with merge mode", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ];
+    const newTags: any[] = [];
+    const result = applyTagMode(existingTags, newTags, "merge");
+    expect(result).toEqual([
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ]);
+  });
+
+  it("should handle empty new tags with replace mode", () => {
+    const existingTags = [
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ];
+    const newTags: any[] = [];
+    const result = applyTagMode(existingTags, newTags, "replace");
+    expect(result).toEqual([]);
+  });
+});

package/test/tags.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from "vitest";
+import {
+  parseTags,
+  generateTag,
+  removeTags,
+  addTags,
+  stripTagsForMatching,
+} from "../src/tags/tag.ts";
+
+describe("tag parsing", () => {
+  it.each([
+    { line: "# block start [mytag]", expected: [{ name: "mytag", value: "" }] },
+    { line: "# block start [mytag:value]", expected: [{ name: "mytag", value: "value" }] },
+    { line: "# block start [timestamp:1770765014846000000]", expected: [{ name: "timestamp", value: "1770765014846000000" }] },
+    { line: "# block start [tag-name_1:value_test]", expected: [{ name: "tag-name_1", value: "value_test" }] },
+    { line: "# block-in-file start [tag:value]", expected: [{ name: "tag", value: "value" }] },
+  ])("should parse tags from $line", ({ line, expected }) => {
+    const tags = parseTags(line);
+    expect(tags).toEqual(expected);
+  });
+
+  it("should parse multiple tags", () => {
+    const line = "# block start [tag1:value1] [tag2:value2]";
+    const tags = parseTags(line);
+    expect(tags).toEqual([
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ]);
+  });
+
+  it("should parse tags with complex values", () => {
+    const line = "# block start [anchor-bof:100] [timestamp:1234567890]";
+    const tags = parseTags(line);
+    expect(tags).toEqual([
+      { name: "anchor-bof", value: "100" },
+      { name: "timestamp", value: "1234567890" },
+    ]);
+  });
+
+  it("should return empty array when no tags found", () => {
+    const line = "# block start";
+    const tags = parseTags(line);
+    expect(tags).toEqual([]);
+  });
+});
+
+describe("tag generation", () => {
+  it.each([
+    { name: "mytag", value: "", expected: "[mytag]" },
+    { name: "mytag", value: "value", expected: "[mytag:value]" },
+    { name: "timestamp", value: "1234567890", expected: "[timestamp:1234567890]" },
+  ])("should generate tag: $expected", ({ name, value, expected }) => {
+    const tag = generateTag(name, value);
+    expect(tag).toBe(expected);
+  });
+
+  it("should generate multiple tags by concatenation", () => {
+    const tag1 = generateTag("tag1", "value1");
+    const tag2 = generateTag("tag2", "value2");
+    const combined = `${tag1} ${tag2}`;
+    expect(combined).toBe("[tag1:value1] [tag2:value2]");
+  });
+});
+
+describe("tag removal", () => {
+  it.each([
+    { line: "# block start [mytag:value]", expected: "# block start" },
+    { line: "# block start [tag1:value1] [tag2:value2]", expected: "# block start" },
+    { line: "# block start", expected: "# block start" },
+    { line: "# block start [mytag]", expected: "# block start" },
+    { line: "# block start   [tag:value]   ", expected: "# block start" },
+  ])("should remove tags from: $line", ({ line, expected }) => {
+    const result = removeTags(line);
+    expect(result).toBe(expected);
+  });
+});
+
+describe("tag adding", () => {
+  it.each([
+    { line: "# block start", tags: [{ name: "mytag", value: "value" }], expected: "# block start [mytag:value]" },
+    { line: "# block start", tags: [{ name: "mytag", value: "" }], expected: "# block start [mytag]" },
+  ])("should add tags to: $line", ({ line, tags, expected }) => {
+    const result = addTags(line, tags);
+    expect(result).toBe(expected);
+  });
+
+  it("should add multiple tags to a line", () => {
+    const line = "# block start";
+    const tags = [
+      { name: "tag1", value: "value1" },
+      { name: "tag2", value: "value2" },
+    ];
+    const result = addTags(line, tags);
+    expect(result).toBe("# block start [tag1:value1] [tag2:value2]");
+  });
+
+  it("should not add tags if array is empty", () => {
+    const line = "# block start";
+    const tags: any[] = [];
+    const result = addTags(line, tags);
+    expect(result).toBe("# block start");
+  });
+});
+
+describe("tag stripping for matching", () => {
+  it.each([
+    { line: "# block start [tag:value]", expected: "# block start" },
+    { line: "# block start [tag1:value1] [tag2:value2]", expected: "# block start" },
+    { line: "# block start", expected: "# block start" },
+    { line: "# block-in-file start [timestamp:1234567890]", expected: "# block-in-file start" },
+    { line: "  # block start [tag:value]  ", expected: "# block start" },
+  ])("should strip tags from: $line", ({ line, expected }) => {
+    const result = stripTagsForMatching(line);
+    expect(result).toBe(expected);
+  });
+});