fix: preserve capture-format spacing for insert-at-end (#1119)

* fix: preserve insert-at-end capture spacing

* fix: align create-if-not-found insert-at-end spacing

Author: chhoumann

src/formatters/captureChoiceFormatter-frontmatter.test.ts

@@ -363,6 +363,165 @@ describe('CaptureChoiceFormatter insert after blank lines', () => {
   });
 });
 
+describe('CaptureChoiceFormatter insert after end-of-section spacing', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    (global as any).navigator = {
+      clipboard: {
+        readText: vi.fn().mockResolvedValue(''),
+      },
+    };
+  });
+
+  const createFormatter = () => {
+    const app = createMockApp();
+    const plugin = {
+      settings: {
+        enableTemplatePropertyTypes: false,
+        globalVariables: {},
+        showCaptureNotification: false,
+        showInputCancellationNotification: true,
+      },
+    } as any;
+    const formatter = new CaptureChoiceFormatter(app, plugin);
+    const file = createTFile('EndOfSection.md');
+
+    return { app, formatter, file };
+  };
+
+  const createInsertAfterChoice = (
+    after: string,
+    overrides: Partial<ICaptureChoice['insertAfter']> = {},
+  ): ICaptureChoice =>
+    createChoice({
+      insertAfter: {
+        enabled: true,
+        after,
+        insertAtEnd: true,
+        considerSubsections: false,
+        createIfNotFound: false,
+        createIfNotFoundLocation: '',
+        inline: false,
+        replaceExisting: false,
+        blankLineAfterMatchMode: 'auto',
+        ...overrides,
+      },
+    });
+
+  it('preserves trailing format spacing across repeated insert-at-end captures at EOF', async () => {
+    const { formatter, file } = createFormatter();
+    const choice = createInsertAfterChoice('# Journal');
+    const initial = ['# Journal', '', '10:00', 'Some data', ''].join('\n');
+
+    const first = await formatter.formatContentWithFile(
+      '18:11\nTest\n\n',
+      choice,
+      initial,
+      file,
+    );
+
+    const second = await formatter.formatContentWithFile(
+      '18:12\nTest2\n\n',
+      choice,
+      first,
+      file,
+    );
+
+    expect(second).toBe(
+      ['# Journal', '', '10:00', 'Some data', '18:11', 'Test', '', '18:12', 'Test2', '', ''].join('\n'),
+    );
+  });
+
+  it('keeps expected spacing for leading-newline capture formats', async () => {
+    const { formatter, file } = createFormatter();
+    const choice = createInsertAfterChoice('# Journal');
+    const initial = ['# Journal', '', '10:00', 'Some data', ''].join('\n');
+
+    const first = await formatter.formatContentWithFile(
+      '\n18:11\nTest3',
+      choice,
+      initial,
+      file,
+    );
+
+    const second = await formatter.formatContentWithFile(
+      '\n18:12\nTest4',
+      choice,
+      first,
+      file,
+    );
+
+    expect(second).toBe(
+      ['# Journal', '', '10:00', 'Some data', '', '18:11', 'Test3', '', '18:12', 'Test4'].join('\n'),
+    );
+  });
+
+  it('preserves spacing for non-heading insert-at-end targets at EOF', async () => {
+    const { formatter, file } = createFormatter();
+    const choice = createInsertAfterChoice('Target');
+    const initial = ['Target', 'Existing', ''].join('\n');
+
+    const first = await formatter.formatContentWithFile(
+      'One\n\n',
+      choice,
+      initial,
+      file,
+    );
+
+    const second = await formatter.formatContentWithFile(
+      'Two\n\n',
+      choice,
+      first,
+      file,
+    );
+
+    expect(second).toBe(['Target', 'Existing', 'One', '', 'Two', '', ''].join('\n'));
+  });
+
+  it('does not change behavior when insert-at-end is disabled', async () => {
+    const { formatter, file } = createFormatter();
+    const choice = createInsertAfterChoice('# Journal', { insertAtEnd: false });
+    const initial = ['# Journal', '', '10:00', 'Some data', ''].join('\n');
+
+    const result = await formatter.formatContentWithFile(
+      '18:13\nTest5\n\n',
+      choice,
+      initial,
+      file,
+    );
+
+    expect(result).toBe(
+      ['# Journal', '', '18:13', 'Test5', '', '10:00', 'Some data', ''].join('\n'),
+    );
+  });
+
+  it('uses EOF spacing logic when create-if-not-found inserts at cursor with insert-at-end', async () => {
+    const { app, formatter, file } = createFormatter();
+    const choice = createInsertAfterChoice('# Missing', {
+      createIfNotFound: true,
+      createIfNotFoundLocation: 'cursor',
+    });
+    (app.workspace.getActiveViewOfType as any).mockReturnValue({
+      editor: {
+        getCursor: vi.fn().mockReturnValue({ line: 0, ch: 0 }),
+        getSelection: vi.fn().mockReturnValue(''),
+      },
+    });
+    const initial = ['# Journal', '', '10:00', 'Some data', '', ''].join('\n');
+
+    const result = await formatter.formatContentWithFile(
+      '18:14\nTest6\n\n',
+      choice,
+      initial,
+      file,
+    );
+
+    expect(result).toBe(
+      ['# Journal', '', '10:00', 'Some data', '', '# Missing', '18:14', 'Test6', '', ''].join('\n'),
+    );
+  });
+});
+
 describe('CaptureChoiceFormatter insert after inline', () => {
   beforeEach(() => {
     vi.resetAllMocks();

src/formatters/captureChoiceFormatter.ts

@@ -263,6 +263,37 @@ export class CaptureChoiceFormatter extends CompleteFormatter {
 		return position;
 	}
 
+	private findInsertAfterPositionAtSectionEnd(
+		lines: string[],
+		sectionEndIndex: number,
+		body: string,
+	): number {
+		if (sectionEndIndex < 0) return sectionEndIndex;
+
+		let position = sectionEndIndex;
+		let i = sectionEndIndex + 1;
+
+		while (i < lines.length && lines[i].trim().length === 0) {
+			position = i;
+			i++;
+		}
+
+		// Preserve current behavior when there are no trailing blank lines or when
+		// blanks are followed by content (e.g. before a new heading).
+		if (position === sectionEndIndex || i !== lines.length) {
+			return sectionEndIndex;
+		}
+
+		// split("\n") keeps a trailing empty string when content ends in "\n".
+		// We keep one trailing slot so the next insertion preserves capture spacing
+		// without introducing an extra blank line before the inserted text.
+		if (body.endsWith("\n")) {
+			return Math.max(sectionEndIndex, position - 1);
+		}
+
+		return position;
+	}
+
 	private async insertAfterHandler(formatted: string) {
 		// Use centralized location formatting for selector strings
 		const targetString: string = await this.formatLocationString(
@@ -299,7 +330,11 @@ export class CaptureChoiceFormatter extends CompleteFormatter {
 				!!this.choice.insertAfter.considerSubsections,
 			);
 
-			targetPosition = endOfSectionIndex ?? fileContentLines.length - 1;
+			targetPosition = this.findInsertAfterPositionAtSectionEnd(
+				fileContentLines,
+				endOfSectionIndex ?? fileContentLines.length - 1,
+				this.fileContent,
+			);
 		} else {
 			const blankLineMode =
 				this.choice.insertAfter?.blankLineAfterMatchMode ?? "auto";
@@ -431,7 +466,11 @@ export class CaptureChoiceFormatter extends CompleteFormatter {
 						!!this.choice.insertAfter.considerSubsections,
 					);
 
-					targetPosition = endOfSectionIndex ?? fileContentLines.length - 1;
+					targetPosition = this.findInsertAfterPositionAtSectionEnd(
+						fileContentLines,
+						endOfSectionIndex ?? fileContentLines.length - 1,
+						this.fileContent,
+					);
 				}
 
 				const newFileContent = this.insertTextAfterPositionInBody(