@stjoseph/prumo 0.4.3 → 0.5.0

package/README.md

@@ -33,7 +33,16 @@ workspace holding four applications, without either one carrying rules it has no
 ## Requirements
 
 Node 22.18 or later, pnpm 10.26 or later, and Docker for anything with an API. `prumo doctor` checks
-all of it. Prumo runs on macOS and Linux; Windows is not supported yet.
+all of it. Prumo runs on macOS, Linux and Windows.
+
+On Windows it runs natively: the project lives in a Windows folder, and the Windows Node and pnpm run it.
+Docker Desktop, with its WSL2 backend and set to Linux containers, is only where the database and the API's
+tests run.
+
+Inside a WSL distribution, with the distribution's own terminal, Node, pnpm and Docker, Prumo is on Linux, which is
+supported, though not tested on WSL specifically. Mixing the two is not supported: Windows tools, Prumo Desktop
+included, working on a project inside the WSL filesystem (`\\wsl$` or `\\wsl.localhost`).
+
 
 ## Running it
 
@@ -79,7 +88,7 @@ npx @stjoseph/prumo new my-api --types api --alone --single-tenant --email
 | `prumo new [name \| .]` | Generates a project |
 | `prumo db` | Inside a project with an API: creates the development database in Docker and writes its URL into `.env` |
 | `prumo clean` | Removes what the project needed only once, today the database setup, once the database exists. Only the Prumo version that generated the project cleans it |
-| `prumo doctor` | Checks Node, pnpm, git and Docker on this machine |
+| `prumo doctor` | Checks Node, pnpm, git and Docker on this machine, and that Docker runs Linux containers |
 | `prumo version` · `--version` · `-v` | Prints the CLI version |
 | `prumo help [command]` · `--help` | Lists the commands, or describes one |
 

package/dist/command.js

@@ -0,0 +1,17 @@
+import { spawnSync } from 'node:child_process';
+const windows = process.platform === 'win32';
+// Only what the CLI itself writes: no space, quote or shell operator, so one line means the same in any shell.
+const PLAIN = /^[\w@.:/={}-]+$/;
+// Runs a tool the CLI names, such as pnpm, git or docker. On Windows pnpm is a .cmd shim, which Node starts only
+// through a shell, and a shell given an argument list is deprecated (DEP0190), so there the command goes as one line.
+export function runCommand(command, args, options = {}) {
+    if (!windows) {
+        return spawnSync(command, args, options);
+    }
+    for (const part of [command, ...args]) {
+        if (!PLAIN.test(part)) {
+            throw new Error(`${part} cannot be passed through a shell unquoted`);
+        }
+    }
+    return spawnSync([command, ...args].join(' '), { ...options, shell: true });
+}

package/dist/compose.js

@@ -49,7 +49,10 @@ export async function copyTemplate(source, destination) {
 async function copyApp(templates, target, type) {
     const destination = join(target, 'apps', type);
     await copyTemplate(join(templates, type), destination);
-    await rm(join(destination, '.githooks'), { recursive: true, force: true });
+    // The workspace root carries both, for every app below it.
+    for (const rootOnly of ['.githooks', '.gitattributes']) {
+        await rm(join(destination, rootOnly), { recursive: true, force: true });
+    }
     return destination;
 }
 async function contractFiles(directory) {

package/dist/doctor.js

@@ -1,14 +1,15 @@
-import { spawnSync } from 'node:child_process';
+import { runCommand } from "./command.js";
 const NODE_FLOOR = [22, 18, 0];
 // Every generated workspace approves dependency builds with `allowBuilds`, which pnpm added in 10.26.0.
 const PNPM_FLOOR = [10, 26, 0];
-// On Windows pnpm is a .cmd shim, and Node starts one only through a shell.
-export const SHELL = process.platform === 'win32';
 export const systemProbe = {
     nodeVersion: process.versions.node,
     run: (command, args) => {
-        const result = spawnSync(command, args, { encoding: 'utf8', timeout: 10_000, shell: SHELL });
-        return { ok: result.error === undefined && result.status === 0, stdout: result.stdout ?? '' };
+        const result = runCommand(command, args, { encoding: 'utf8', timeout: 10_000 });
+        return {
+            ok: result.error === undefined && result.status === 0,
+            stdout: String(result.stdout ?? ''),
+        };
     },
 };
 function atLeast(version, floor) {
@@ -59,19 +60,25 @@ export async function doctor(probe = systemProbe) {
     });
     checks.push(...toolChecks(probe, ['pnpm', 'git']));
     const docker = probe.run('docker', ['--version']);
-    const dockerRunning = docker.ok && probe.run('docker', ['info']).ok;
+    const engine = docker.ok ? probe.run('docker', ['info', '--format', '{{.OSType}}']) : undefined;
+    const os = firstLine(engine?.stdout ?? '');
     checks.push({
         id: 'docker',
         label: 'Docker',
         required: false,
-        ...(dockerRunning
-            ? { status: 'ok', detail: firstLine(docker.stdout) }
-            : {
+        ...(engine?.ok !== true
+            ? {
                 status: 'warn',
                 detail: docker.ok
                     ? 'installed but not running; open Docker Desktop. The API runs its database and tests in it'
-                    : 'not found; install Docker Desktop. The API runs its database and tests in it',
-            }),
+                    : 'not found; install Docker Desktop, on Windows with the WSL2 backend. The API runs its database and tests in it',
+            }
+            : os !== 'linux'
+                ? {
+                    status: 'warn',
+                    detail: `running ${os || 'unknown'} containers; switch Docker Desktop to Linux containers. The API's Postgres image is a Linux one`,
+                }
+                : { status: 'ok', detail: firstLine(docker.stdout) }),
     });
     return { ready: checks.every((check) => !check.required || check.status === 'ok'), checks };
 }

package/dist/generate.js

@@ -1,11 +1,10 @@
-import { spawnSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { runCommand } from "./command.js";
 import { composeWorkspace, copyTemplate } from "./compose.js";
 import { writeContext } from "./context.js";
-import { SHELL } from "./doctor.js";
 import { applyFeatures, enabledFor } from "./features.js";
 import { setJsonc } from "./jsonc.js";
 import { schemeFor, targetProblem } from "./names.js";
@@ -78,10 +77,9 @@ function stopIfInterrupted() {
 function run(command, args, cwd, output) {
     stopIfInterrupted();
     // Under --json stdout belongs to the result document, so a child's output goes to stderr instead.
-    const result = spawnSync(command, args, {
+    const result = runCommand(command, args, {
         cwd,
         stdio: output === 'inherit' ? 'inherit' : ['ignore', 2, 2],
-        shell: SHELL,
     });
     // spawnSync holds the event loop, so the listener has not run yet; the child says it instead, either by dying of
     // the signal or, as pnpm does, by catching it and exiting with 130.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stjoseph/prumo",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Scaffolds a TypeScript project and ships it the conventions it follows, in a .prumo/ folder any AI assistant reads.",
   "keywords": [
     "scaffolding",
@@ -36,7 +36,7 @@
   "scripts": {
     "lint": "biome check",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run --dir test",
+    "test": "vitest run --dir test --test-timeout 30000",
     "prumo": "node src/cli.ts",
     "build": "tsc -p tsconfig.build.json && node scripts/copy-assets.mjs",
     "prepack": "pnpm build"

package/templates/api/.gitattributes

@@ -0,0 +1,2 @@
+# LF in every checkout, Windows included: Biome formats to LF and would otherwise flag every file.
+* text=auto eol=lf

package/templates/api/README.md

@@ -3,6 +3,8 @@
 ## Requirements
 
 Node 22.18 or later, pnpm 10.26 or later, and Docker Desktop running: the database and the tests both run in it.
+On Windows, Docker Desktop needs its WSL2 backend and Linux containers. Keep the project in a Windows folder, or
+work entirely inside a WSL distribution; Windows tools on a project inside the WSL filesystem are not supported.
 
 ## Running it
 

package/templates/api/scripts/database.mjs

@@ -267,7 +267,8 @@ async function main() {
 
   if (!values['skip-migrate']) {
     say('Migrating…')
-    if (spawnSync('pnpm', ['db:migrate'], { cwd: api, stdio: childStdio }).status !== 0) {
+    // One line through the shell: on Windows pnpm is a .cmd shim, which Node starts only that way.
+    if (spawnSync('pnpm db:migrate', { cwd: api, stdio: childStdio, shell: true }).status !== 0) {
       throw new Failure(
         'migrate_failed',
         '`pnpm db:migrate` failed. The database exists and .env points at it.',

package/templates/api/scripts/ports.mjs

@@ -171,13 +171,23 @@ async function taken(port) {
 function holders(port) {
   if (windows) {
     const lines = spawnSync('netstat', ['-ano'], { encoding: 'utf8' }).stdout ?? ''
-    const pids = new Set(
-      lines
-        .split('\n')
-        .filter((line) => /LISTENING/.test(line) && new RegExp(`[:.]${port}\\s`).test(line))
-        .map((line) => line.trim().split(/\s+/).at(-1))
-        .filter((pid) => pid !== undefined && pid !== '0'),
-    )
+    const pids = new Set()
+
+    // Windows translates the state column, so a listener is told by its remote address instead: only a socket that
+    // is listening has none, which netstat writes as port 0.
+    for (const line of lines.split('\n')) {
+      const [protocol, local, remote, ...rest] = line.trim().split(/\s+/)
+      const pid = rest.at(-1)
+
+      if (
+        protocol === 'TCP' &&
+        local?.endsWith(`:${port}`) &&
+        remote?.endsWith(':0') &&
+        pid !== '0'
+      ) {
+        pids.add(pid)
+      }
+    }
 
     return [...pids].map((pid) => ({ pid: Number(pid), command: commandOf(pid) }))
   }
@@ -194,9 +204,8 @@ function commandOf(pid) {
     : spawnSync('ps', ['-p', String(pid), '-o', 'comm='], { encoding: 'utf8' })
   const output = (result.stdout ?? '').trim()
 
-  return windows
-    ? (output.split(',')[0]?.replaceAll('"', '') ?? 'unknown')
-    : basename(output || 'unknown')
+  // tasklist answers a pid it does not know with a translated sentence, never with a quoted CSV row.
+  return windows ? (/^"([^"]*)"/.exec(output)?.[1] ?? 'unknown') : basename(output || 'unknown')
 }
 
 async function freed(port) {
@@ -213,7 +222,7 @@ async function freed(port) {
 async function stopHolders(port, found) {
   for (const { pid } of found) {
     if (windows) {
-      spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' })
+      terminate(processTree([pid]))
     } else {
       // The whole group, so that a shell's children go with it; a lone process when it leads no group.
       try {
@@ -319,41 +328,197 @@ async function settle(type) {
   throw new Failure('declined', 'Nothing was started.')
 }
 
-// Every process below one, as the system sees them right now.
-function processTree(pid) {
+// Windows has a precise answer to "what did this command start": a job object. A process created by a member of a job
+// is a member too, whatever became of its parent, so the job's member list holds everything the command started,
+// with no reading of the process tree to come too late. A PowerShell helper creates the job, puts this process in it
+// before the command starts, and lists the members when asked.
+const JOB_HELPER = `
+$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class PrumoJob {
+  [DllImport("kernel32.dll", SetLastError = true)] public static extern IntPtr CreateJobObject(IntPtr attributes, string name);
+  [DllImport("kernel32.dll", SetLastError = true)] public static extern IntPtr OpenProcess(uint access, bool inherit, uint id);
+  [DllImport("kernel32.dll", SetLastError = true)] public static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+  [DllImport("kernel32.dll", SetLastError = true)] public static extern bool SetConsoleCtrlHandler(IntPtr handler, bool ignore);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool QueryInformationJobObject(IntPtr job, int kind, IntPtr information, int length, IntPtr returned);
+  public static string Members(IntPtr job) {
+    int length = 8 + IntPtr.Size * 16384;
+    IntPtr list = Marshal.AllocHGlobal(length);
+    try {
+      if (!QueryInformationJobObject(job, 3, list, length, IntPtr.Zero)) { return ""; }
+      int count = Marshal.ReadInt32(list, 4);
+      string[] ids = new string[count];
+      for (int i = 0; i < count; i++) { ids[i] = Marshal.ReadIntPtr(list, 8 + i * IntPtr.Size).ToInt64().ToString(); }
+      return String.Join(" ", ids);
+    } finally {
+      Marshal.FreeHGlobal(list);
+    }
+  }
+}
+'@
+# Ctrl+C is for the command; the helper has to outlive it to list what is left.
+[void][PrumoJob]::SetConsoleCtrlHandler([IntPtr]::Zero, $true)
+$job = [PrumoJob]::CreateJobObject([IntPtr]::Zero, $null)
+$member = [PrumoJob]::OpenProcess(0x0101, $false, [uint32]$env:PRUMO_JOB_MEMBER)
+if ($job -eq [IntPtr]::Zero -or $member -eq [IntPtr]::Zero -or -not [PrumoJob]::AssignProcessToJobObject($job, $member)) { exit 1 }
+[Console]::Out.WriteLine('ready')
+while ($null -ne [Console]::In.ReadLine()) { [Console]::Out.WriteLine([PrumoJob]::Members($job)) }
+`
+
+// The job, or undefined where there is none: elsewhere than Windows, or when the helper could not make one, and then
+// the process tree read on a schedule is what is left.
+async function startJob() {
+  if (!windows) {
+    return undefined
+  }
+
+  const helper = spawn('powershell', ['-NoProfile', '-NonInteractive', '-Command', JOB_HELPER], {
+    stdio: ['pipe', 'pipe', 'ignore'],
+    windowsHide: true,
+    env: { ...process.env, PRUMO_JOB_MEMBER: String(process.pid) },
+  })
+  const lines = []
+  const waiting = []
+  let pending = ''
+
+  helper.on('error', () => {})
+  helper.stdin.on('error', () => {})
+  helper.stdout.setEncoding('utf8')
+  helper.stdout.on('data', (chunk) => {
+    const parts = (pending + chunk).split('\n')
+
+    pending = parts.pop() ?? ''
+    for (const line of parts) {
+      const resolve = waiting.shift()
+
+      if (resolve === undefined) {
+        lines.push(line.trim())
+      } else {
+        resolve(line.trim())
+      }
+    }
+  })
+
+  // A timer keeps this process alive while it waits, since the helper itself does not.
+  const next = (ms) =>
+    new Promise((resolve) => {
+      const line = lines.shift()
+
+      if (line !== undefined) {
+        resolve(line)
+        return
+      }
+
+      const timer = setTimeout(() => resolve(undefined), ms)
+
+      waiting.push((value) => {
+        clearTimeout(timer)
+        resolve(value)
+      })
+    })
+
+  if ((await next(60_000)) !== 'ready') {
+    helper.kill()
+    return undefined
+  }
+
+  helper.unref()
+  helper.stdin.unref?.()
+  helper.stdout.unref?.()
+
+  return {
+    members: async () => {
+      helper.stdin.write('list\n')
+
+      return ((await next(10_000)) ?? '')
+        .split(' ')
+        .map(Number)
+        .filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid)
+    },
+    close: () => helper.kill(),
+  }
+}
+
+// Ends exactly these processes on Windows, and nothing else. `taskkill /T` is never used: it follows the same parent
+// ids, which Windows does not keep honest, as processTree below explains.
+function terminate(pids) {
+  if (pids.length > 0) {
+    spawnSync('taskkill', ['/F', ...pids.flatMap((pid) => ['/PID', String(pid)])], {
+      stdio: 'ignore',
+      timeout: 60_000,
+    })
+  }
+}
+
+// Every process below the ones given, as the system sees them right now.
+//
+// On Windows a process keeps its parent's id after the parent exits, and the id is then given to the next process
+// that starts. A process of the run can so inherit the number that winlogon, dwm or csrss name as their parent, and a
+// tree followed by ids alone adopts them: on the CI runner that once stopped the session itself. A child is therefore
+// only taken as one when it started after its parent; a process that started before the one holding its parent's
+// number cannot be that process's child.
+function processTree(roots) {
   const listed = windows
     ? spawnSync(
         'powershell',
         [
           '-NoProfile',
+          '-NonInteractive',
           '-Command',
-          'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId)" }',
+          'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $(if ($_.CreationDate) { $_.CreationDate.ToFileTimeUtc() } else { 0 })" }',
         ],
-        { encoding: 'utf8' },
+        { encoding: 'utf8', timeout: 60_000 },
       )
-    : spawnSync('ps', ['-eo', 'pid=,ppid='], { encoding: 'utf8' })
-  const children = new Map()
+    : spawnSync('ps', ['-eo', 'pid=,ppid='], { encoding: 'utf8', timeout: 60_000 })
+  const started = new Map()
+  const links = []
 
   for (const line of (listed.stdout ?? '').split('\n')) {
-    const [child, parent] = line.trim().split(/\s+/).map(Number)
+    const [child, parent, created] = line.trim().split(/\s+/).map(Number)
 
     if (Number.isInteger(child) && Number.isInteger(parent)) {
+      links.push([child, parent])
+      started.set(child, created ?? 0)
+    }
+  }
+
+  const children = new Map()
+
+  for (const [child, parent] of links) {
+    const parentStarted = started.get(parent)
+    const honest = !windows || parentStarted === undefined || parentStarted <= started.get(child)
+
+    if (honest && child !== parent) {
       children.set(parent, [...(children.get(parent) ?? []), child])
     }
   }
 
   const tree = []
-  const pending = [pid]
+  const pending = [...roots]
 
   while (pending.length > 0) {
     const current = pending.shift()
 
-    tree.push(current)
-    pending.push(...(children.get(current) ?? []))
+    if (!tree.includes(current)) {
+      tree.push(current)
+      pending.push(...(children.get(current) ?? []))
+    }
   }
 
-  // Deepest first, so a parent does not restart what was just stopped.
-  return tree.reverse()
+  // Deepest first, so a parent does not restart what was just stopped. On Windows only what is running now: the number
+  // of a process that exited may already name another one.
+  return (windows ? tree.filter((pid) => started.has(pid)) : tree).reverse()
+}
+
+function alive(pid) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    return error.code === 'EPERM'
+  }
 }
 
 function signal(pid, sign) {
@@ -365,12 +530,18 @@ function signal(pid, sign) {
 // `pnpm -r --parallel` starts each app in a process group of its own, so the terminal's Ctrl+C reaches pnpm and
 // nothing below it. Whatever was started here is therefore stopped from here, and never anything else: the tree is
 // read before the first signal, while the processes still point at their parents.
-async function shutdown(child, ports, known) {
-  const tree = [...new Set([...processTree(child.pid), ...known])].reverse()
+async function shutdown(child, ports, known, job) {
+  // With a job its members are exactly what the command started. Without one, on Windows, the tree is also read from
+  // every process seen while the command ran, since a process keeps its parent's id after the parent exits; elsewhere
+  // an orphan moves to init, and below a dead pid there is only whatever reused the number.
+  const members = (await job?.members()) ?? []
+  const roots = windows && job === undefined ? [child.pid, ...known] : [child.pid]
+  const below = processTree(roots)
+  const tree = [...new Set([...below, ...known, ...members])].reverse()
   const stopped = []
 
   if (windows) {
-    spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore' })
+    terminate([...new Set([...below, ...members])])
   } else {
     for (const pid of tree) {
       signal(pid, 'SIGTERM')
@@ -387,6 +558,11 @@ async function shutdown(child, ports, known) {
         stopped.push(`${command} (pid ${pid}) on port ${port}`)
       }
 
+      // The port is released once the system has reaped what was killed, which is not at once.
+      if (ours.length > 0) {
+        await freed(port)
+      }
+
       if (theirs.length > 0) {
         say(`Port ${port} is still held by ${describe(theirs)}, which this project did not start.`)
       }
@@ -400,13 +576,18 @@ async function shutdown(child, ports, known) {
   return stopped
 }
 
-async function supervise(child, ports) {
+async function supervise(child, ports, job) {
   // Ctrl+C reaches the child through the terminal; this process only waits, and then makes sure nothing survived.
   // Once the child is gone, its own children answer to the system and no longer to it, so who they were is
   // remembered while they are still running: on a schedule, and again the moment the signal arrives.
   const known = new Set([child.pid])
+  // A job lists its members at the end, so with one there is nothing to remember on the way.
   const remember = () => {
-    for (const pid of processTree(child.pid)) {
+    if (job !== undefined) {
+      return
+    }
+
+    for (const pid of processTree([child.pid])) {
       known.add(pid)
     }
   }
@@ -432,6 +613,16 @@ async function supervise(child, ports) {
   remember()
   const watch = setInterval(remember, 2000)
 
+  // `pnpm -r --parallel` starts each app in a process group of its own, which the terminal's Ctrl+C never reaches, and
+  // a Ctrl+C right after the start comes before the workspace's ports.mjs has seen the apps. So an app's ports.mjs
+  // does not wait to be told: once whatever started it is gone, nobody is left to stop it, and it stops its own tree.
+  const parent = process.ppid
+  const orphaned = setInterval(() => {
+    if (!interrupted && !alive(parent)) {
+      interrupt('SIGTERM')
+    }
+  }, 250)
+
   let patience
   const code = await new Promise((done) => {
     child.once('error', () => done(1))
@@ -449,8 +640,11 @@ async function supervise(child, ports) {
   clearInterval(patience)
   clearTimeout(patience)
   clearInterval(watch)
+  clearInterval(orphaned)
+
+  const stopped = await shutdown(child, ports, known, job)
 
-  const stopped = await shutdown(child, ports, known)
+  job?.close()
 
   process.off('SIGINT', onInterrupt)
   process.off('SIGTERM', onTerminate)
@@ -459,17 +653,32 @@ async function supervise(child, ports) {
   return stopped
 }
 
+// On Windows the command is most often a .cmd shim, such as pnpm or vite, which Node starts only through a shell, and
+// a shell given an argument list is deprecated (DEP0190). So it gets one line, each part quoted when it needs it.
+function commandLine(parts) {
+  return parts
+    .map((part) => (/^[\w@+=:,./\\-]+$/.test(part) ? part : `"${part.replaceAll('"', '""')}"`))
+    .join(' ')
+}
+
 async function main() {
   const ports = {}
+  const [command, ...args] = positionals
 
-  for (const type of typesToCheck()) {
-    if (type !== undefined) {
-      ports[type] = await settle(type)
+  // PowerShell takes a few seconds to make the job, so it does while the ports are settled.
+  const starting = command === undefined ? undefined : startJob()
+
+  try {
+    for (const type of typesToCheck()) {
+      if (type !== undefined) {
+        ports[type] = await settle(type)
+      }
     }
+  } catch (error) {
+    ;(await starting)?.close()
+    throw error
   }
 
-  const [command, ...args] = positionals
-
   if (command === undefined) {
     return { ports }
   }
@@ -481,8 +690,12 @@ async function main() {
   const withPort = flag.flatMap((entry) =>
     entry === '--port' ? ['--port', String(ports[type])] : [entry],
   )
-  const child = spawn(command, [...args, ...withPort], { stdio: 'inherit', shell: windows })
-  const stopped = await supervise(child, Object.values(ports))
+  // Before the command starts, so that it and everything it starts are members from their first instant.
+  const job = await starting
+  const child = windows
+    ? spawn(commandLine([command, ...args, ...withPort]), { stdio: 'inherit', shell: true })
+    : spawn(command, [...args, ...withPort], { stdio: 'inherit' })
+  const stopped = await supervise(child, Object.values(ports), job)
 
   return { ports, ran: [command, ...args, ...withPort].join(' '), stopped }
 }

package/templates/mobile/.gitattributes

@@ -0,0 +1,2 @@
+# LF in every checkout, Windows included: Biome formats to LF and would otherwise flag every file.
+* text=auto eol=lf