fix: auto-detect date format (DD/MM vs MM/DD) in CSV imports

Scans all date values in imported CSVs to determine whether the file
uses DD/MM/YYYY or MM/DD/YYYY format. When the format is ambiguous
(all day and month values are <= 12), shows an inline dropdown for the
user to choose. Bump version to 1.0.2.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeroclock",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Time tracking desktop application",
   "type": "module",
   "scripts": {

src-tauri/Cargo.lock

@@ -5743,7 +5743,7 @@ dependencies = [
 
 [[package]]
 name = "zeroclock"
-version = "1.0.0"
+version = "1.0.1"
 dependencies = [
  "chrono",
  "env_logger",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zeroclock"
-version = "1.0.0"
+version = "1.0.2"
 description = "A local time tracking app with invoicing"
 authors = ["you"]
 edition = "2021"

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "ZeroClock",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "identifier": "com.localtimetracker.app",
   "build": {
     "beforeDevCommand": "npm run dev",

src/App.vue

@@ -324,6 +324,8 @@ onMounted(async () => {
       if (settingsStore.settings.close_to_tray === 'true') {
         event.preventDefault()
         await win.hide()
+      } else {
+        await win.destroy()
       }
     })
   } catch (e) {

src/utils/import.ts

@@ -9,6 +9,23 @@ export interface ImportEntry {
   tags?: string[]
 }
 
+export type DateFormat = 'DMY' | 'MDY'
+export type DateDetectResult = DateFormat | 'ambiguous'
+
+export function detectDateFormat(rows: string[][], dateColIndex: number): DateDetectResult {
+  if (dateColIndex < 0) return 'ambiguous'
+  for (let i = 1; i < rows.length; i++) {
+    const val = (rows[i]?.[dateColIndex] || '').trim()
+    const match = val.match(/^(\d{1,2})[\/.](\d{1,2})[\/.](\d{2,4})$/)
+    if (!match) continue
+    const a = parseInt(match[1])
+    const b = parseInt(match[2])
+    if (a > 12) return 'DMY'
+    if (b > 12) return 'MDY'
+  }
+  return 'ambiguous'
+}
+
 export function parseCSV(text: string): string[][] {
   const lines = text.split('\n').filter(l => l.trim())
   return lines.map(line => {
@@ -31,6 +48,7 @@ export function parseCSV(text: string): string[][] {
 }
 
 export function parseDurationString(dur: string): number {
+  if (!dur) return 0
   // Handle HH:MM:SS, HH:MM, or decimal hours
   if (dur.includes(':')) {
     const parts = dur.split(':').map(Number)
@@ -42,26 +60,160 @@ export function parseDurationString(dur: string): number {
   return 0
 }
 
-export function mapTogglCSV(rows: string[][]): ImportEntry[] {
+// Parse locale-variable date strings into YYYY-MM-DD
-  // Toggl CSV format: Description, Project, Client, Task, Tag, Start date, Start time, End date, End time, Duration
+function parseFlexDate(dateStr: string, formatHint?: DateFormat): string {
-  const header = rows[0].map(h => h.toLowerCase())
+  if (!dateStr) return new Date().toISOString().split('T')[0]
-  const descIdx = header.findIndex(h => h.includes('description'))
+  const s = dateStr.trim()
-  const projIdx = header.findIndex(h => h.includes('project'))
+
-  const clientIdx = header.findIndex(h => h.includes('client'))
+  // YYYY-MM-DD (ISO)
-  const taskIdx = header.findIndex(h => h.includes('task'))
+  if (/^\d{4}-\d{1,2}-\d{1,2}$/.test(s)) {
-  const tagIdx = header.findIndex(h => h.includes('tag'))
+    const [y, m, d] = s.split('-')
-  const startDateIdx = header.findIndex(h => h.includes('start date'))
+    return `${y}-${m.padStart(2, '0')}-${d.padStart(2, '0')}`
-  const startTimeIdx = header.findIndex(h => h.includes('start time'))
+  }
-  const durationIdx = header.findIndex(h => h.includes('duration'))
+
+  // Slash or dot separated: could be MM/DD/YYYY, DD/MM/YYYY, DD.MM.YYYY
+  const match = s.match(/^(\d{1,2})[\/.](\d{1,2})[\/.](\d{2,4})$/)
+  if (match) {
+    let [, a, b, year] = match
+    if (year.length === 2) year = '20' + year
+    // If first part > 12, must be day-first (DD/MM/YYYY)
+    if (parseInt(a) > 12) return `${year}-${b.padStart(2, '0')}-${a.padStart(2, '0')}`
+    // If second part > 12, must be month-first (MM/DD/YYYY)
+    if (parseInt(b) > 12) return `${year}-${a.padStart(2, '0')}-${b.padStart(2, '0')}`
+    // Use format hint if provided
+    if (formatHint === 'DMY') return `${year}-${b.padStart(2, '0')}-${a.padStart(2, '0')}`
+    // Default to MDY
+    return `${year}-${a.padStart(2, '0')}-${b.padStart(2, '0')}`
+  }
+
+  // Last resort: try Date constructor
+  const d = new Date(s)
+  if (!isNaN(d.getTime())) return d.toISOString().split('T')[0]
+  return new Date().toISOString().split('T')[0]
+}
+
+// Parse 12h or 24h time strings into HH:MM:SS
+function parseFlexTime(timeStr: string): string {
+  if (!timeStr) return '00:00:00'
+  const s = timeStr.trim()
+
+  // 12-hour: "1:00 PM", "11:30:00 AM"
+  const ampm = s.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?\s*(AM|PM)$/i)
+  if (ampm) {
+    let hour = parseInt(ampm[1])
+    const min = ampm[2]
+    const sec = ampm[3] || '00'
+    const period = ampm[4].toUpperCase()
+    if (period === 'PM' && hour !== 12) hour += 12
+    if (period === 'AM' && hour === 12) hour = 0
+    return `${hour.toString().padStart(2, '0')}:${min}:${sec}`
+  }
+
+  // 24-hour: "13:00", "09:30:00"
+  const h24 = s.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/)
+  if (h24) {
+    return `${h24[1].padStart(2, '0')}:${h24[2]}:${h24[3] || '00'}`
+  }
+
+  return '00:00:00'
+}
+
+function safeDateTime(date: string, time?: string, dateFormat?: DateFormat): string {
+  const d = parseFlexDate(date, dateFormat)
+  const t = time ? parseFlexTime(time) : '00:00:00'
+  return `${d}T${t}`
+}
+
+export function findCol(header: string[], ...terms: string[]): number {
+  for (const term of terms) {
+    const idx = header.findIndex(h => h === term)
+    if (idx >= 0) return idx
+  }
+  for (const term of terms) {
+    const idx = header.findIndex(h => h.includes(term))
+    if (idx >= 0) return idx
+  }
+  return -1
+}
+
+function col(row: string[], idx: number): string {
+  return idx >= 0 ? (row[idx] || '') : ''
+}
+
+export function mapTogglCSV(rows: string[][], dateFormat?: DateFormat): ImportEntry[] {
+  const header = rows[0].map(h => h.toLowerCase().trim())
+  const descIdx = findCol(header, 'description')
+  const projIdx = findCol(header, 'project')
+  const clientIdx = findCol(header, 'client')
+  const taskIdx = findCol(header, 'task')
+  const tagIdx = findCol(header, 'tags', 'tag')
+  const startDateIdx = findCol(header, 'start date')
+  const startTimeIdx = findCol(header, 'start time')
+  const durationIdx = findCol(header, 'duration')
 
   return rows.slice(1).map(row => ({
-    project_name: row[projIdx] || 'Imported',
+    project_name: col(row, projIdx) || 'Imported',
-    client_name: clientIdx >= 0 ? row[clientIdx] : undefined,
+    client_name: col(row, clientIdx) || undefined,
-    task_name: taskIdx >= 0 ? row[taskIdx] : undefined,
+    task_name: col(row, taskIdx) || undefined,
-    description: descIdx >= 0 ? row[descIdx] : undefined,
+    description: col(row, descIdx) || undefined,
-    start_time: combineDateTime(row[startDateIdx], row[startTimeIdx]),
+    start_time: safeDateTime(col(row, startDateIdx), col(row, startTimeIdx) || undefined, dateFormat),
-    duration: durationIdx >= 0 ? parseDurationString(row[durationIdx]) : 0,
+    duration: parseDurationString(col(row, durationIdx)),
-    tags: tagIdx >= 0 && row[tagIdx] ? row[tagIdx].split(',').map(t => t.trim()) : undefined,
+    tags: tagIdx >= 0 && row[tagIdx] ? row[tagIdx].split(',').map(t => t.trim()).filter(Boolean) : undefined,
+  }))
+}
+
+export function mapClockifyCSV(rows: string[][], dateFormat?: DateFormat): ImportEntry[] {
+  const header = rows[0].map(h => h.toLowerCase().trim())
+  const descIdx = findCol(header, 'description')
+  const projIdx = findCol(header, 'project')
+  const clientIdx = findCol(header, 'client')
+  const taskIdx = findCol(header, 'task')
+  const tagIdx = findCol(header, 'tags', 'tag')
+  const startDateIdx = findCol(header, 'start date')
+  const startTimeIdx = findCol(header, 'start time')
+  // Prefer decimal duration - always a simple number, no format ambiguity
+  const durDecIdx = header.findIndex(h => h.includes('duration (decimal)'))
+  const durHIdx = header.findIndex(h => h.includes('duration (h)'))
+  const durPlainIdx = header.findIndex(h => h === 'duration')
+
+  return rows.slice(1).map(row => {
+    let duration = 0
+    if (durDecIdx >= 0 && row[durDecIdx]) {
+      duration = Math.round(parseFloat(row[durDecIdx]) * 3600)
+    } else if (durHIdx >= 0 && row[durHIdx]) {
+      duration = parseDurationString(row[durHIdx])
+    } else if (durPlainIdx >= 0 && row[durPlainIdx]) {
+      duration = parseDurationString(row[durPlainIdx])
+    }
+
+    return {
+      project_name: col(row, projIdx) || 'Imported',
+      client_name: col(row, clientIdx) || undefined,
+      task_name: col(row, taskIdx) || undefined,
+      description: col(row, descIdx) || undefined,
+      start_time: safeDateTime(col(row, startDateIdx), col(row, startTimeIdx) || undefined, dateFormat),
+      duration,
+      tags: tagIdx >= 0 && row[tagIdx] ? row[tagIdx].split(',').map(t => t.trim()).filter(Boolean) : undefined,
+    }
+  })
+}
+
+export function mapHarvestCSV(rows: string[][], dateFormat?: DateFormat): ImportEntry[] {
+  const header = rows[0].map(h => h.toLowerCase().trim())
+  const dateIdx = findCol(header, 'date')
+  const projIdx = header.findIndex(h => h === 'project')
+  const clientIdx = findCol(header, 'client')
+  const taskIdx = findCol(header, 'task')
+  const notesIdx = findCol(header, 'notes')
+  const hoursIdx = header.findIndex(h => h === 'hours')
+
+  return rows.slice(1).map(row => ({
+    project_name: col(row, projIdx) || 'Imported',
+    client_name: col(row, clientIdx) || undefined,
+    task_name: col(row, taskIdx) || undefined,
+    description: col(row, notesIdx) || undefined,
+    start_time: safeDateTime(col(row, dateIdx), undefined, dateFormat),
+    duration: hoursIdx >= 0 && row[hoursIdx] ? Math.round(parseFloat(row[hoursIdx]) * 3600) : 0,
   }))
 }
 
@@ -75,9 +227,3 @@ export function mapGenericCSV(rows: string[][], mapping: Record<string, number>)
     duration: mapping.duration >= 0 ? parseDurationString(row[mapping.duration]) : 0,
   }))
 }
-
-function combineDateTime(date: string, time: string): string {
-  if (!date) return new Date().toISOString()
-  if (!time) return new Date(date).toISOString()
-  return new Date(`${date} ${time}`).toISOString()
-}

src/views/Settings.vue

@@ -1445,6 +1445,32 @@
                 </table>
               </div>
 
+              <!-- Date format detection -->
+              <div v-if="importFormat !== 'json' && importFormat !== 'generic'" class="flex items-center gap-3 mb-3">
+                <template v-if="importDateDetected !== 'ambiguous'">
+                  <span class="text-[0.6875rem] text-text-tertiary">
+                    Date format detected: {{ importDateFormat === 'DMY' ? 'DD/MM/YYYY' : 'MM/DD/YYYY' }}
+                  </span>
+                  <button
+                    @click="importDateDetected = 'ambiguous'"
+                    class="text-[0.6875rem] text-accent hover:text-accent-hover transition-colors"
+                  >
+                    Change
+                  </button>
+                </template>
+                <template v-else>
+                  <label class="text-[0.6875rem] text-text-tertiary">Date format:</label>
+                  <div class="w-36">
+                    <AppSelect
+                      v-model="importDateFormat"
+                      :options="dateFormatOptions"
+                      label-key="label"
+                      value-key="value"
+                    />
+                  </div>
+                </template>
+              </div>
+
               <button
                 @click="executeImport"
                 :disabled="isImporting"
@@ -1541,7 +1567,7 @@ import AppSelect from '../components/AppSelect.vue'
 import AppShortcutRecorder from '../components/AppShortcutRecorder.vue'
 import AppTimePicker from '../components/AppTimePicker.vue'
 import { LOCALES, getCurrencies, getCurrencySymbol } from '../utils/locale'
-import { parseCSV, mapTogglCSV, mapGenericCSV, type ImportEntry } from '../utils/import'
+import { parseCSV, mapTogglCSV, mapClockifyCSV, mapHarvestCSV, mapGenericCSV, detectDateFormat, findCol, type ImportEntry, type DateFormat, type DateDetectResult } from '../utils/import'
 import { TIMER_FONTS, loadGoogleFont, loadAndApplyTimerFont } from '../utils/fonts'
 import { UI_FONTS, loadUIFont } from '../utils/uiFonts'
 import { useFocusTrap } from '../utils/focusTrap'
@@ -1978,10 +2004,18 @@ const importFileName = ref('')
 const importPreview = ref<string[][]>([])
 const importStatus = ref('')
 const isImporting = ref(false)
+const importDateDetected = ref<DateDetectResult>('ambiguous')
+const importDateFormat = ref<DateFormat>('MDY')
+
+const dateFormatOptions = [
+  { label: 'MM/DD/YYYY', value: 'MDY' },
+  { label: 'DD/MM/YYYY', value: 'DMY' },
+]
 
 const importFormats = [
   { label: 'Toggl CSV', value: 'toggl' },
   { label: 'Clockify CSV', value: 'clockify' },
+  { label: 'Harvest CSV', value: 'harvest' },
   { label: 'Generic CSV', value: 'generic' },
   { label: 'ZeroClock JSON', value: 'json' },
 ]
@@ -2357,8 +2391,23 @@ async function handleImportFile() {
 
     if (importFormat.value === 'json') {
       importPreview.value = []
+      importDateDetected.value = 'ambiguous'
+      importDateFormat.value = 'MDY'
     } else {
-      importPreview.value = parseCSV(content).slice(0, 6)
+      const allRows = parseCSV(content)
+      importPreview.value = allRows.slice(0, 6)
+
+      // Detect date format from CSV data
+      const header = allRows[0]?.map(h => h.toLowerCase().trim()) || []
+      let dateColIdx = -1
+      if (importFormat.value === 'harvest') {
+        dateColIdx = findCol(header, 'date')
+      } else {
+        dateColIdx = findCol(header, 'start date')
+      }
+      const detected = detectDateFormat(allRows, dateColIdx)
+      importDateDetected.value = detected
+      importDateFormat.value = detected === 'ambiguous' ? 'MDY' : detected
     }
   } catch (e) {
     console.error('Failed to read file:', e)
@@ -2379,8 +2428,13 @@ async function executeImport() {
       const rows = parseCSV(importFileContent.value)
       let entries: ImportEntry[]
 
-      if (importFormat.value === 'toggl' || importFormat.value === 'clockify') {
+      const df = importDateFormat.value
-        entries = mapTogglCSV(rows)
+      if (importFormat.value === 'toggl') {
+        entries = mapTogglCSV(rows, df)
+      } else if (importFormat.value === 'clockify') {
+        entries = mapClockifyCSV(rows, df)
+      } else if (importFormat.value === 'harvest') {
+        entries = mapHarvestCSV(rows, df)
       } else {
         entries = mapGenericCSV(rows, { project: 0, description: 1, start_time: 2, duration: 3, client: -1, task: -1 })
       }
@@ -2392,6 +2446,8 @@ async function executeImport() {
     importFileContent.value = ''
     importFileName.value = ''
     importPreview.value = []
+    importDateDetected.value = 'ambiguous'
+    importDateFormat.value = 'MDY'
   } catch (e) {
     importStatus.value = `Error: ${e}`
   } finally {