opencode-line-endings 0.1.4

package/.github/workflows/publish.yml

@@ -0,0 +1,43 @@
+name: Publish to NPM
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '18.20.0'
+          registry-url: 'https://registry.npmjs.org'
+          cache: npm
+
+      - run: npm ci
+      - run: npm run build
+
+      - name: Verify version matches tag
+        run: |
+          TAG="${GITHUB_REF#refs/tags/}"
+          VERSION="${TAG#v}"
+          FILE_VERSION=$(node -p "require('./package.json').version")
+          if [ "$VERSION" != "$FILE_VERSION" ]; then
+            echo "Version mismatch: tag=$VERSION, package.json=$FILE_VERSION"
+            exit 1
+          fi
+
+      - name: Publish to NPM
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npm publish --access public --provenance
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marco von Rosenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# opencode-line-endings
+
+An [OpenCode](https://opencode.ai) plugin that enforces consistent line endings (LF or CRLF) on all file edits, independent of the platform OpenCode runs on.
+
+The primary use case is running OpenCode inside WSL while editing Windows files — the platform reports Linux (LF), but the files need CRLF line endings.
+
+## Installation
+
+OpenCode loads plugin **files** directly from the plugins directory (not subdirectories). The `editorconfig` dependency must be declared in a `package.json` in the config directory.
+
+### Project-level
+
+1. Copy `index.ts` into your project's plugins directory:
+
+```sh
+cp index.ts <project>/.opencode/plugins/line-endings.ts
+```
+
+2. Add the `editorconfig` dependency to `.opencode/package.json` (create it if it doesn't exist):
+
+```json
+{
+  "dependencies": {
+    "editorconfig": "^3.0.2"
+  }
+}
+```
+
+OpenCode runs `bun install` at startup to install these dependencies automatically.
+
+### Global
+
+1. Copy `index.ts` to the global plugins directory:
+
+```sh
+cp index.ts ~/.config/opencode/plugins/line-endings.ts
+```
+
+2. Add the dependency to `~/.config/opencode/package.json`:
+
+```json
+{
+  "dependencies": {
+    "editorconfig": "^3.0.2"
+  }
+}
+```
+
+### Via opencode.json (npm)
+
+If published to npm, add to your `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-line-endings"]
+}
+```
+
+## Configuration
+
+Line ending style is determined in this order:
+
+### 1. Environment variable (highest priority)
+
+```sh
+export OPENCODE_LINE_ENDINGS=crlf  # or lf
+```
+
+### 2. `.editorconfig`
+
+The plugin reads [`.editorconfig`](https://editorconfig.org) files, walking up the directory tree as per the spec. The `end_of_line` property is used:
+
+```ini
+# .editorconfig
+root = true
+
+[*]
+end_of_line = crlf
+```
+
+Per-pattern overrides work as expected:
+
+```ini
+[*.sh]
+end_of_line = lf
+
+[*.{cs,csproj,sln}]
+end_of_line = crlf
+```
+
+### 3. Default
+
+If neither the environment variable nor `.editorconfig` specifies a line ending style, the plugin defaults to **CRLF**.
+
+## How it works
+
+The plugin hooks into OpenCode's tool execution pipeline at two points:
+
+- **Before tool execution** (`tool.execute.before`): Transforms content in `write`, `edit`, and `multiedit` tool arguments before they reach disk. This ensures diffs shown to the user reflect the correct line endings.
+
+- **After file edits** (`file.edited` event): Re-reads the entire file and normalizes all line endings. This catches cases where partial edits produce mixed line endings (e.g., existing LF content with CRLF insertions from the edit tool).
+
+Binary files are skipped automatically based on file extension.
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,117 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import { parse } from "editorconfig"
+import fs from "fs"
+import path from "path"
+
+type LineEnding = "lf" | "crlf"
+
+function toLF(text: string): string {
+  return text.replaceAll("\r\n", "\n")
+}
+
+function toCRLF(text: string): string {
+  return toLF(text).replaceAll("\n", "\r\n")
+}
+
+function convert(text: string, ending: LineEnding): string {
+  if (ending === "crlf") return toCRLF(text)
+  return toLF(text)
+}
+
+const BINARY = new Set([
+  ".exe", ".dll", ".bin", ".so", ".dylib", ".o", ".a", ".lib",
+  ".zip", ".tar", ".gz", ".bz2", ".7z", ".rar", ".xz",
+  ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".ico",
+  ".tif", ".tiff", ".avif", ".heic", ".svg",
+  ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+  ".woff", ".woff2", ".ttf", ".otf", ".eot",
+  ".mp3", ".mp4", ".wav", ".avi", ".mov", ".mkv", ".webm",
+  ".flac", ".ogg", ".aac",
+  ".sqlite", ".db", ".wasm",
+])
+
+function binary(file: string): boolean {
+  return BINARY.has(path.extname(file).toLowerCase())
+}
+
+const SERVICE = "line-endings"
+
+const plugin: Plugin = async (ctx) => {
+  const cache = new Map()
+  const log = (level: "debug" | "info" | "warn" | "error", message: string, extra?: Record<string, unknown>) =>
+    ctx.client.app.log({ body: { service: SERVICE, level, message, extra } })
+
+  async function resolve(file: string): Promise<LineEnding> {
+    const env = process.env.OPENCODE_LINE_ENDINGS?.toLowerCase()
+    if (env === "lf" || env === "crlf") return env
+
+    try {
+      const config = await parse(file, { cache })
+      if (config.end_of_line === "lf") return "lf"
+      if (config.end_of_line === "crlf") return "crlf"
+    } catch {}
+
+    return "crlf"
+  }
+
+  function abs(file: string): string {
+    return path.isAbsolute(file) ? file : path.resolve(ctx.directory, file)
+  }
+
+  const env = process.env.OPENCODE_LINE_ENDINGS?.toLowerCase()
+  const source = (env === "lf" || env === "crlf") ? "env" : "editorconfig/default"
+  await log("info", `plugin loaded (source: ${source}, env: ${env ?? "unset"}, default: crlf)`)
+
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (input.tool === "write") {
+        if (!output.args.filePath || typeof output.args.content !== "string") return
+        const file = abs(output.args.filePath)
+        if (binary(file)) return
+        const ending = await resolve(file)
+        output.args.content = convert(output.args.content, ending)
+        await log("debug", `write -> ${ending}`, { file: output.args.filePath })
+      }
+
+      if (input.tool === "edit") {
+        if (!output.args.filePath || typeof output.args.newString !== "string") return
+        const file = abs(output.args.filePath)
+        if (binary(file)) return
+        const ending = await resolve(file)
+        output.args.newString = convert(output.args.newString, ending)
+        await log("debug", `edit -> ${ending}`, { file: output.args.filePath })
+      }
+
+      if (input.tool === "multiedit") {
+        if (!output.args.filePath || !Array.isArray(output.args.edits)) return
+        const file = abs(output.args.filePath)
+        if (binary(file)) return
+        const ending = await resolve(file)
+        for (const edit of output.args.edits) {
+          if (typeof edit.newString === "string") {
+            edit.newString = convert(edit.newString, ending)
+          }
+        }
+        await log("debug", `multiedit -> ${ending}`, { file: output.args.filePath, count: output.args.edits.length })
+      }
+    },
+
+    event: async ({ event }) => {
+      if (event.type !== "file.edited") return
+      const file = event.properties.file
+      if (!file || binary(file)) return
+
+      try {
+        const ending = await resolve(file)
+        const content = await fs.promises.readFile(file, "utf-8")
+        const converted = convert(content, ending)
+        if (content !== converted) {
+          await fs.promises.writeFile(file, converted, "utf-8")
+          await log("debug", `normalized full file -> ${ending}`, { file })
+        }
+      } catch {}
+    },
+  }
+}
+
+export default plugin

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "opencode-line-endings",
+  "version": "0.1.4",
+  "description": "OpenCode plugin that enforces consistent line endings (LF or CRLF) on file edits",
+  "type": "module",
+  "main": "index.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CodingMarco/opencode-line-endings.git"
+  },
+  "bugs": {
+    "url": "https://github.com/CodingMarco/opencode-line-endings/issues"
+  },
+  "homepage": "https://github.com/CodingMarco/opencode-line-endings#readme",
+  "dependencies": {
+    "@opencode-ai/plugin": "latest",
+    "editorconfig": "^3.0.2"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "line-endings",
+    "crlf",
+    "lf",
+    "editorconfig",
+    "wsl"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "npm run typecheck"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "typescript": "^5.9.3"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["index.ts"]
+}