Release v2.4.0

.github/workflows/aur-check.yml

@@ -25,7 +25,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@v4
 
-      - name: Build the package
+      - name: Set up build user
         run: |
           set -euxo pipefail
           # makepkg refuses to run as root — build as an unprivileged user with
@@ -35,18 +35,45 @@ jobs:
           install -d -o builder -g builder /tmp/build
           cp packaging/aur/PKGBUILD packaging/aur/.SRCINFO /tmp/build/
           chown -R builder:builder /tmp/build
+
+      # The PKGBUILD always points at the upcoming release's tarball, which does
+      # not exist until that release is published. Skip the full build (which has
+      # to download it) when the asset isn't up yet, rather than failing — the
+      # metadata + .SRCINFO are still checked, and the real build runs once the
+      # release exists.
+      - name: Check whether the release asset is published
+        id: asset
+        run: |
+          set -uo pipefail
+          # shellcheck disable=SC1091
+          source packaging/aur/PKGBUILD
+          url="${source[0]#*::}"
+          echo "url=$url"
+          if curl -fsIL -o /dev/null "$url"; then
+            echo "exists=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "exists=false" >> "$GITHUB_OUTPUT"
+            echo "::notice title=AUR build skipped::Release asset not published yet ($url). PKGBUILD metadata + .SRCINFO are still validated; the full makepkg build runs once the release exists."
+          fi
+
+      - name: Build the package
+        if: steps.asset.outputs.exists == 'true'
+        run: |
+          set -euxo pipefail
           cd /tmp/build
           sudo -u builder makepkg -s --noconfirm --noprogressbar
           ls -la ./*.pkg.tar.*
 
       - name: Lint (non-blocking)
+        if: steps.asset.outputs.exists == 'true'
         run: |
           cd /tmp/build
           namcap PKGBUILD || true
           namcap ./*.pkg.tar.* || true
 
       - name: Verify .SRCINFO is in sync
         run: |
+          set -euxo pipefail
           cd /tmp/build
           sudo -u builder makepkg --printsrcinfo > .SRCINFO.generated
           if ! diff -u .SRCINFO .SRCINFO.generated; then

.github/workflows/release.yml

@@ -103,7 +103,7 @@ jobs:
             files+=("$file")
           done < <(
             find dist -maxdepth 1 -type f \
-              \( -name '*.dmg' -o -name '*.zip' -o -name '*.exe' -o -name '*.AppImage' -o -name '*.deb' -o -name '*.pacman' -o -name '*.blockmap' -o -name 'latest*.yml' -o -name 'latest*.yaml' \)
+              \( -name '*.dmg' -o -name '*.zip' -o -name '*.exe' -o -name '*.AppImage' -o -name '*.deb' -o -name '*.pacman' -o -name '*.tar.gz' -o -name '*.blockmap' -o -name 'latest*.yml' -o -name 'latest*.yaml' \)
           )
           if [ "${#files[@]}" -eq 0 ]; then
             echo "No release artifacts found in dist/" >&2

.gitignore

@@ -18,3 +18,8 @@ apps/server/bin
 data/
 /vault/
 /remotevault/
+# Nix build outputs
+result
+result-*
+# Release notes / launch copy are kept local only, never committed.
+docs/releases/

README.md

@@ -51,6 +51,8 @@ Pick whatever suits your distro:
   ```sh
   sudo apt install ./ZenNotes-<version>-linux-amd64.deb
   ```
+- **Nix / NixOS:**
+  Read [packaging/nix/README.md](packaging/nix/README.md) for installation instructions
 - **Any distro — AppImage:**
   ```sh
   chmod +x ZenNotes-<version>-linux-x86_64.AppImage
@@ -141,14 +143,29 @@ System folders still exist, but the vault model is more flexible now:
 
 The built-in folder labels are also customizable in the UI without changing the underlying internal ids.
 
-### Daily notes
+### Daily and weekly notes
 
-Daily notes are optional and can be enabled from Settings.
+Daily and weekly notes are optional and can be enabled from Settings.
 
-- when enabled, ZenNotes can open or create today's note automatically
-- the title is a simple ISO date like `2026-04-21`
-- daily notes live in a dedicated directory under your primary notes area
-- the default directory is `Daily Notes`
+- when enabled, ZenNotes can open or create today's daily note and this week's weekly note automatically
+- the default daily title is a simple ISO date like `2026-04-21`
+- the default weekly title is an ISO week title like `2026-W24`
+- date notes live in dedicated directories under your primary notes area
+- the default directories are `Daily Notes` and `Weekly Notes`
+- the directory and title can use date patterns such as `yyyy/MM-MMM` and `yyyy-MM-dd-EEE`
+- weekly title patterns can use ISO week tokens such as `yyyy-'W'ww`
+- localized month and weekday names can follow `system`, `en-US`, `pt-BR`, or another BCP 47 locale
+
+Supported date note pattern tokens:
+
+- `yyyy` / `yy` for `2026` / `26`
+- `M` / `MM` / `MMM` / `MMMM` for `6` / `06` / `Jun` / `June`
+- `d` / `dd` for `9` / `09`
+- `EEE` / `EEEE` for `Tue` / `Tuesday`
+- `w` / `ww` for ISO week numbers like `24`
+- single-quoted literals, such as `'Daily Notes'/yyyy/MM-MMM`
+
+Weekly notes render date tokens from the ISO week's Monday, and `yyyy` is the ISO week-year for weekly patterns.
 
 ### Editor and preview
 

apps/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/desktop",
   "productName": "ZenNotes",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "ZenNotes desktop shell",
   "private": true,
   "main": "./out/main/index.js",
@@ -191,6 +191,7 @@
     "electronVersion": "41.2.1",
     "electronUpdaterCompatibility": ">=2.16",
     "mac": {
+      "icon": "build/icon.icns",
       "category": "public.app-category.productivity",
       "hardenedRuntime": true,
       "gatekeeperAssess": false,
@@ -227,11 +228,28 @@
       "target": [
         "AppImage",
         "deb",
-        "pacman"
+        "pacman",
+        "tar.gz"
       ],
       "icon": "build/icons",
       "maintainer": "Adib Hanna <adibhanna@gmail.com>",
-      "category": "Office"
+      "category": "Office",
+      "extraResources": [
+        {
+          "from": "../../packaging/aur/arch-extras/zennotes.desktop",
+          "to": "arch-extras/zennotes.desktop"
+        },
+        {
+          "from": "build/icons",
+          "to": "arch-extras/icons"
+        }
+      ],
+      "extraFiles": [
+        {
+          "from": "../../LICENSE",
+          "to": "LICENSE"
+        }
+      ]
     },
     "deb": {
       "afterInstall": "build/after-install.sh"

apps/desktop/src/main/assets-migrate.test.ts

@@ -0,0 +1,67 @@
+import { mkdtemp, mkdir, rm, writeFile, access } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { migrateLooseAssets, listAssets } from './vault'
+
+const tempDirs: string[] = []
+
+async function makeVault(): Promise<string> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'zen-amig-'))
+  tempDirs.push(dir)
+  return dir
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((d) => rm(d, { recursive: true, force: true })))
+})
+
+const exists = (root: string, rel: string): Promise<boolean> =>
+  access(path.join(root, rel))
+    .then(() => true)
+    .catch(() => false)
+
+describe('migrateLooseAssets (#185 assets/ unification)', () => {
+  it('moves root-level attachments + legacy dirs into assets/, never notes or databases', async () => {
+    const root = await makeVault()
+    await writeFile(path.join(root, 'photo.png'), 'x', 'utf8')
+    await writeFile(path.join(root, 'note.md'), '# hi', 'utf8') // a note — must stay
+    await writeFile(path.join(root, 'books.csv'), 'id\n', 'utf8') // legacy db — must stay
+    await mkdir(path.join(root, 'attachements'), { recursive: true })
+    await writeFile(path.join(root, 'attachements', 'doc.pdf'), 'x', 'utf8')
+
+    const { moved, skipped } = await migrateLooseAssets(root)
+    expect(moved.sort()).toEqual(['assets/doc.pdf', 'assets/photo.png'])
+    expect(skipped).toEqual([])
+
+    expect(await exists(root, 'assets/photo.png')).toBe(true)
+    expect(await exists(root, 'assets/doc.pdf')).toBe(true)
+    expect(await exists(root, 'photo.png')).toBe(false)
+    expect(await exists(root, 'attachements')).toBe(false) // emptied + removed
+    // Notes and database files are untouched.
+    expect(await exists(root, 'note.md')).toBe(true)
+    expect(await exists(root, 'books.csv')).toBe(true)
+  })
+
+  it('skips a file whose basename already exists in assets/ (keeps refs unambiguous)', async () => {
+    const root = await makeVault()
+    await mkdir(path.join(root, 'assets'), { recursive: true })
+    await writeFile(path.join(root, 'assets', 'logo.png'), 'existing', 'utf8')
+    await writeFile(path.join(root, 'logo.png'), 'loose', 'utf8')
+
+    const { moved, skipped } = await migrateLooseAssets(root)
+    expect(moved).toEqual([])
+    expect(skipped).toEqual(['logo.png'])
+    expect(await exists(root, 'logo.png')).toBe(true) // left in place
+  })
+
+  it('is idempotent and surfaces migrated assets via listAssets', async () => {
+    const root = await makeVault()
+    await writeFile(path.join(root, 'pic.png'), 'x', 'utf8')
+    expect((await migrateLooseAssets(root)).moved).toEqual(['assets/pic.png'])
+    expect((await migrateLooseAssets(root)).moved).toEqual([])
+
+    const assets = await listAssets(root)
+    expect(assets.map((a) => a.path)).toContain('assets/pic.png')
+  })
+})

apps/desktop/src/main/databases-migrate.test.ts

@@ -0,0 +1,103 @@
+import { mkdtemp, mkdir, rm, writeFile, readFile, access } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { migrateLegacyDatabases } from './vault'
+import { readDatabase } from './databases'
+
+const tempDirs: string[] = []
+
+async function makeVault(): Promise<string> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'zen-dbmig-'))
+  tempDirs.push(dir)
+  await mkdir(path.join(dir, 'inbox'), { recursive: true })
+  return dir
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((d) => rm(d, { recursive: true, force: true })))
+})
+
+const exists = (p: string): Promise<boolean> =>
+  access(p)
+    .then(() => true)
+    .catch(() => false)
+
+// A minimal legacy database: loose `<Name>.csv` + co-located sidecar, with one
+// record-page note under the per-database `<Name>/` folder.
+async function seedLegacyDatabase(root: string): Promise<void> {
+  await writeFile(path.join(root, 'inbox', 'Books.csv'), 'id,Title\nr1,Dune\n', 'utf8')
+  await mkdir(path.join(root, 'inbox', 'Books'), { recursive: true })
+  await writeFile(path.join(root, 'inbox', 'Books', 'Dune.md'), '# Dune\n\nGreat book.', 'utf8')
+  const sidecar = {
+    version: 1,
+    idFieldId: 'f_id',
+    fields: [
+      { id: 'f_id', name: 'id', type: 'text', hidden: true },
+      { id: 'f_title', name: 'Title', type: 'text' }
+    ],
+    views: [{ id: 'v1', name: 'Table', type: 'table', filters: [], sorts: [] }],
+    activeViewId: 'v1',
+    pages: { r1: 'inbox/Books/Dune.md' }
+  }
+  await writeFile(
+    path.join(root, 'inbox', 'Books.csv.base.json'),
+    JSON.stringify(sidecar, null, 2),
+    'utf8'
+  )
+}
+
+describe('migrateLegacyDatabases (#185 .base reorg)', () => {
+  it('moves a legacy database into a self-contained .base folder', async () => {
+    const root = await makeVault()
+    await seedLegacyDatabase(root)
+
+    const count = await migrateLegacyDatabases(root)
+    expect(count).toBe(1)
+
+    const baseDir = path.join(root, 'inbox', 'Books.base')
+    expect(await exists(path.join(baseDir, 'data.csv'))).toBe(true)
+    expect(await exists(path.join(baseDir, 'schema.json'))).toBe(true)
+    expect(await exists(path.join(baseDir, 'Dune.md'))).toBe(true)
+
+    // Old files + per-database folder are gone.
+    expect(await exists(path.join(root, 'inbox', 'Books.csv'))).toBe(false)
+    expect(await exists(path.join(root, 'inbox', 'Books.csv.base.json'))).toBe(false)
+    expect(await exists(path.join(root, 'inbox', 'Books'))).toBe(false)
+
+    // schema.json stores the page path RELATIVE to the folder.
+    const schema = JSON.parse(await readFile(path.join(baseDir, 'schema.json'), 'utf8'))
+    expect(schema.pages).toEqual({ r1: 'Dune.md' })
+
+    // data.csv content is preserved.
+    expect(await readFile(path.join(baseDir, 'data.csv'), 'utf8')).toContain('Dune')
+  })
+
+  it('readDatabase resolves the migrated db and its pages to full paths', async () => {
+    const root = await makeVault()
+    await seedLegacyDatabase(root)
+    await migrateLegacyDatabases(root)
+
+    const doc = await readDatabase(root, 'inbox/Books.base/data.csv')
+    expect(doc.title).toBe('Books')
+    expect(doc.rows).toHaveLength(1)
+    // pages resolved back to full vault-relative paths on read.
+    expect(doc.pages?.r1).toBe('inbox/Books.base/Dune.md')
+  })
+
+  it('is idempotent — a second run migrates nothing and leaves data intact', async () => {
+    const root = await makeVault()
+    await seedLegacyDatabase(root)
+    expect(await migrateLegacyDatabases(root)).toBe(1)
+    expect(await migrateLegacyDatabases(root)).toBe(0)
+    expect(await exists(path.join(root, 'inbox', 'Books.base', 'data.csv'))).toBe(true)
+  })
+
+  it('leaves a plain CSV (no sidecar) untouched', async () => {
+    const root = await makeVault()
+    await writeFile(path.join(root, 'inbox', 'data-dump.csv'), 'a,b\n1,2\n', 'utf8')
+    expect(await migrateLegacyDatabases(root)).toBe(0)
+    expect(await exists(path.join(root, 'inbox', 'data-dump.csv'))).toBe(true)
+    expect(await exists(path.join(root, 'inbox', 'data-dump.base'))).toBe(false)
+  })
+})

apps/desktop/src/main/databases-walk.test.ts

@@ -0,0 +1,47 @@
+import { mkdtemp, mkdir, rm } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { createDatabase, createRecordPage } from './databases'
+import { listFolders, listNotes, listAssets } from './vault'
+
+const tempDirs: string[] = []
+
+async function makeVault(): Promise<string> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'zen-dbwalk-'))
+  tempDirs.push(dir)
+  await mkdir(path.join(dir, 'inbox'), { recursive: true })
+  return dir
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((d) => rm(d, { recursive: true, force: true })))
+})
+
+describe('vault walk treats a .base database as one unit (#185)', () => {
+  it('surfaces the database folder + record pages, hides data.csv/schema.json', async () => {
+    const root = await makeVault()
+    const doc = await createDatabase(root, 'inbox', '', 'Reading List')
+    expect(doc.path).toBe('inbox/Reading List.base/data.csv')
+    await createRecordPage(root, doc.path, 'Dune', '# Dune')
+
+    // The database appears as a folder node (the sidebar renders it as a database).
+    const folderEntries = await listFolders(root)
+    expect(folderEntries.some((f) => f.subpath === 'Reading List.base')).toBe(true)
+
+    // The record page is a note nested under the database folder.
+    const notes = await listNotes(root)
+    const page = notes.find((n) => n.path === 'inbox/Reading List.base/Dune.md')
+    expect(page).toBeTruthy()
+    expect(page?.folder).toBe('inbox')
+
+    // data.csv and schema.json never appear as assets or notes.
+    const assets = await listAssets(root)
+    expect(assets.some((a) => a.path.includes('.base'))).toBe(false)
+    expect(notes.some((n) => n.path.endsWith('data.csv') || n.path.endsWith('schema.json'))).toBe(
+      false
+    )
+    // The database folder is NOT descended into as ordinary subfolders.
+    expect(folderEntries.some((f) => f.subpath.startsWith('Reading List.base/'))).toBe(false)
+  })
+})