fix(tools): create new files with the platform-native line ending

A newly created file used LF whenever the model's content carried no CRLF, so
files written on Windows ended up with LF endings while native tooling uses
CRLF. Existing files were unaffected: their recorded line endings already win.

platformLineEnding() (file-utils) now supplies the default for created files,
mirroring the existing detectLineEndings() helper for reads. On LF platforms
this is a no-op.

Tests cover the CRLF/LF branches of the helper, a created file matching the
platform ending, and an existing CRLF file keeping its endings.

Author: sonderhq

packages/core/src/common/file-utils.ts

@@ -1,4 +1,5 @@
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import type { FileState, FileLineEnding } from "./state";
 
@@ -17,6 +18,20 @@ export function detectLineEndings(value: string): FileLineEnding {
   return value.includes("\r\n") ? "CRLF" : "LF";
 }
 
+/**
+ * Line ending a newly created file should use: the platform-native one.
+ *
+ * Created files have no existing EOL to preserve, and models emit LF-only text.
+ * Writing that verbatim produces LF files on Windows, where native tooling (and
+ * the files the user's editor creates) use CRLF. Existing files are unaffected:
+ * their recorded line endings still win in the write handler.
+ *
+ * @param eol platform line ending, injectable for tests
+ */
+export function platformLineEnding(eol: string = os.EOL): FileLineEnding {
+  return eol === "\r\n" ? "CRLF" : "LF";
+}
+
 export function detectEncoding(buffer: Buffer): BufferEncoding {
   if (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) {
     return "utf16le";

packages/core/src/tests/write-handler-line-endings.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, test } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import type { ToolExecutionContext } from "../tools/executor";
+import { handleReadTool } from "../tools/read-handler";
+import { handleWriteTool } from "../tools/write-handler";
+import { platformLineEnding } from "../common/file-utils";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+});
+
+function createTempWorkspace(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "deepcode-line-endings-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function createContext(sessionId: string, projectRoot: string): ToolExecutionContext {
+  return {
+    sessionId,
+    projectRoot,
+    toolCall: {
+      id: "test-tool-call",
+      type: "function",
+      function: {
+        name: "write",
+        arguments: "{}",
+      },
+    },
+  };
+}
+
+test("platformLineEnding reports CRLF only on Windows-style platforms", () => {
+  assert.equal(platformLineEnding("\r\n"), "CRLF");
+  assert.equal(platformLineEnding("\n"), "LF");
+});
+
+test("a newly created file uses the platform-native line ending", async () => {
+  // Models emit LF-only text. A created file has no existing EOL to preserve, so it
+  // should follow the platform: CRLF on Windows, matching what native tooling writes.
+  const workspace = createTempWorkspace();
+  const filePath = path.join(workspace, "created.txt");
+
+  await handleWriteTool({ file_path: filePath, content: "one\ntwo" }, createContext("create-eol", workspace));
+
+  const expected = platformLineEnding() === "CRLF" ? "one\r\ntwo" : "one\ntwo";
+  assert.equal(fs.readFileSync(filePath, "utf8"), expected);
+});
+
+test("an existing CRLF file keeps its line endings when rewritten with LF content", async () => {
+  const workspace = createTempWorkspace();
+  const filePath = path.join(workspace, "existing.txt");
+  fs.writeFileSync(filePath, "one\r\ntwo\r\n", "utf8");
+  const context = createContext("keep-eol", workspace);
+
+  await handleReadTool({ file_path: filePath }, context);
+  await handleWriteTool({ file_path: filePath, content: "one\ntwo\n" }, context);
+
+  assert.equal(fs.readFileSync(filePath, "utf8"), "one\r\ntwo\r\n");
+});

packages/core/src/tools/write-handler.ts

@@ -6,6 +6,7 @@ import {
   ensureParentDirectory,
   hasFileChangedSinceState,
   normalizeContent,
+  platformLineEnding,
   readTextFileWithMetadata,
   writeTextFile,
 } from "../common/file-utils";
@@ -96,7 +97,8 @@ export async function handleWriteTool(
 
         const existingMetadata = existingFile ? readTextFileWithMetadata(filePath) : null;
         const encoding = existingMetadata?.encoding ?? "utf8";
-        const lineEndings = existingMetadata?.lineEndings ?? (input.content.includes("\r\n") ? "CRLF" : "LF");
+        const lineEndings =
+          existingMetadata?.lineEndings ?? (input.content.includes("\r\n") ? "CRLF" : platformLineEnding());
         const diffPreview = buildDiffPreview(filePath, existingMetadata?.content ?? null, normalizedContent);
         context.signal?.throwIfAborted();
         context.onBeforeFileMutation?.(filePath);