@jlmarcos99/todos 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,138 @@
-# Temporary Holding Version
+# Todos
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A keyboard-first task manager and daily work log for the terminal, built with
+TypeScript and [@earendil-works/pi-tui](https://github.com/earendil-works/pi/tree/main/packages/tui).
+Task data lives in a global per-user folder and can optionally sync to a Git remote.
+
+## Requirements
+
+- Node.js 22.19 or newer
+- Git installed and configured only when you choose remote synchronization
+- An interactive terminal for the TUI
+
+## Install and initialize
+
+Install the published CLI globally (Node.js 22.19 or newer):
+
+```sh
+npm install --global @jlmarcos99/todos
+todos
+```
+
+The first launch creates a local vault automatically. Use `todos init` when you
+want to choose a data folder or configure a Git remote.
+
+To run from a checkout, install dependencies and compile the CLI:
+
+```sh
+npm install
+npm run build
+npm link
+todos
+```
+
+On first launch, `todos` creates a global data folder with a starter vault and
+opens the TUI in local-only mode. `todos init` is optional; run it when you want
+to choose a data folder or link a remote during setup. You can also link a
+remote later with `todos link <url>`. Use SSH authentication or a Git credential
+helper; URLs containing embedded credentials are rejected.
+
+To choose a custom folder:
+
+```sh
+todos init --data-dir /path/to/todos
+```
+
+Without the global `todos` command, use `npm run init` to configure the store
+from this checkout.
+
+The folder can also be selected with the `TODOS_DATA_DIR` environment variable.
+The initialized path is saved in the user's configuration directory and is used
+regardless of the current working directory.
+
+## Commands
+
+```text
+todos                              Create the first vault if needed, then open the TUI
+todos init [--local|--remote URL]  Configure the global store
+todos link <url>                   Link or synchronize a Git remote
+todos unlink [--yes]               Remove the remote, keeping local history
+todos status                       Show the data path, vault count and remote
+todos vault create <name> [about]  Create an additional vault
+todos --help                       Show command help
+```
+
+`--data-dir <path>` can also be used with `todos` to open a specific store.
+The default data paths are:
+
+- Linux: `$XDG_DATA_HOME/jmtodos` or `~/.local/share/jmtodos`
+- macOS: `~/Library/Application Support/JMTodos`
+- Windows: `%LOCALAPPDATA%/JMTodos`
+
+Configuration is kept separately using each platform's config directory.
+
+## TUI workflow
+
+- **Tasks** shows open tasks and tasks completed within the last 24 hours.
+- **Daily** shows tasks with activity on the selected local date and the previous
+  date, with progress notes directly below each task.
+- **History** shows tasks completed more than 24 hours ago.
+
+Press `a` to add a task, `s` to start it, `n` to add a progress note, and Space
+to complete or reopen it. Press `V` to create another vault. `Tab` switches
+vaults. Press `r` to synchronize; in local-only mode it prompts for a Git remote
+URL and links the current vault store. Changes are saved locally before Git is
+contacted; an offline remote leaves them saved and marked pending.
+
+| Key | Action |
+| --- | --- |
+| `j` / `k` or ↓ / ↑ | Move selection; scroll in activity |
+| `gg` / `G` | First / last task or activity line |
+| Tab / Shift+Tab | Next / previous vault |
+| `h` / `l` or ← / → | Previous / next view |
+| `1` / `2` / `3` | Tasks / Daily / History |
+| Space | Complete / reopen selected task |
+| `s` | Start working on selected task |
+| `n` | Add a progress note |
+| Enter | Read task activity |
+| `[` / `]` | Previous / next Daily window |
+| `t` | Today's Daily |
+| `a` / `V` | Add task / create vault |
+| `/` | Search the current view |
+| `r` | Sync, or link a remote in local-only mode |
+| Escape / `?` | Cancel, clear search / help |
+| `q` / Ctrl+C | Quit |
+
+Notes and status changes are timestamped activity records. Daily groups them by
+the user's local calendar date; historical entries are not rewritten by later
+task changes.
+
+## Development
+
+```sh
+npm run dev        # Build and run the compiled app
+npm run typecheck  # TypeScript checks
+npm run build      # Compile the CLI into dist/
+npm test           # Build, then run tests from app/tests
+npm run start:prod # Run the compiled CLI
+```
+
+## Releases
+
+Run `npm run changeset` to add a Changeset for each user-facing change.
+Changesets opens a version pull
+request against `master`; merging that version pull request publishes the
+package through GitHub Actions. The release workflow publishes through the
+`NPM_TOKEN` GitHub Actions secret, following the setup used by BareWT. Create a
+granular npm access token with package write access and **Bypass 2FA** enabled,
+then add it in the `todos` repository under Settings → Secrets and variables →
+Actions as `NPM_TOKEN`. The package publishes with npm provenance. In GitHub,
+also allow Actions to create pull requests in Settings → Actions → General so
+Changesets can open version pull requests. Merging a version pull request to
+`master` publishes the package; the included initial patch Changeset prepares
+version `1.0.1`.
+
+Source is organized under `app/src`: `config` resolves user paths, `storage`
+owns JSON records and atomic writes, `application` owns task operations,
+`sync` wraps system Git, `cli` handles commands, and `tui` handles terminal input
+and rendering. Existing UI tests are kept under `app/tests`.

package/dist/app/src/app.js

@@ -0,0 +1,39 @@
+import { ProcessTerminal, TUI } from '@earendil-works/pi-tui';
+import { TodoScreen } from "./tui/screen.js";
+export const App = {
+    async init(options) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.error('Open Todos in an interactive terminal: npm start');
+            process.exitCode = 1;
+            return;
+        }
+        const terminal = new ProcessTerminal();
+        const tui = new TUI(terminal);
+        let stopped = false;
+        let timer;
+        const quit = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            clearInterval(timer);
+            screen?.dispose();
+            tui.stop();
+            terminal.write('\x1b[?1049l');
+            process.off('SIGINT', quit);
+            process.off('SIGTERM', quit);
+        };
+        const screen = new TodoScreen({
+            now: () => new Date(), rows: () => terminal.rows,
+            redraw: () => tui.requestRender(), quit,
+            vaults: options.vaults, tasks: options.tasks, sync: options.sync, refresh: options.refresh,
+        });
+        terminal.write('\x1b[?1049h\x1b[H');
+        tui.addChild(screen);
+        tui.setFocus(screen);
+        process.on('SIGINT', quit);
+        process.on('SIGTERM', quit);
+        tui.start();
+        // Re-evaluate the 24-hour boundary even while the keyboard is idle.
+        timer = setInterval(() => tui.requestRender(), 1_000);
+    },
+};

package/dist/app/src/application/operation-queue.js

@@ -0,0 +1,9 @@
+/** Serializes refresh and mutation work within this process. */
+export class OperationQueue {
+    tail = Promise.resolve();
+    run(operation) {
+        const result = this.tail.then(operation, operation);
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+}

package/dist/app/src/application/task-service.js

@@ -0,0 +1,146 @@
+import { randomUUID } from 'node:crypto';
+/** Owns task mutations and persists each record before notifying sync. */
+export class TaskService {
+    store;
+    onChange;
+    transaction;
+    vaults = [];
+    onReload;
+    constructor(store, onChange = () => undefined, transaction) {
+        this.store = store;
+        this.onChange = onChange;
+        this.transaction = transaction;
+    }
+    setVaults(vaults) { this.vaults = vaults; }
+    setOnReload(callback) { this.onReload = callback; }
+    async createVault(name, description = '') {
+        if (!this.store)
+            throw new Error('Vault creation needs a persistent store.');
+        return this.runChange(`Created vault: ${name}`, () => this.store.createVault(name, description));
+    }
+    async addTask(vault, name, date) {
+        const cleanName = name.trim();
+        if (!cleanName)
+            return undefined;
+        const task = { id: randomUUID(), name: cleanName, status: 'todo', date };
+        await this.runChange(`Added task: ${cleanName}`, async () => {
+            const currentVault = this.resolveVault(vault);
+            currentVault.tasks.push(task);
+            try {
+                if (this.store)
+                    await this.store.saveTask(currentVault.id, task);
+            }
+            catch (error) {
+                currentVault.tasks.splice(currentVault.tasks.indexOf(task), 1);
+                throw error;
+            }
+        });
+        return task;
+    }
+    async startTask(vault, task, date) {
+        await this.runChange(`Started task: ${task.name}`, async () => {
+            const currentVault = this.resolveVault(vault);
+            const currentTask = this.resolveTask(currentVault, task);
+            if (currentTask.status !== 'in-progress')
+                await this.applyStatusChange(currentVault, currentTask, 'in-progress', 'started', date);
+        });
+    }
+    async toggleTask(vault, task, date) {
+        await this.runChange(`Updated task: ${task.name}`, async () => {
+            const currentVault = this.resolveVault(vault);
+            const currentTask = this.resolveTask(currentVault, task);
+            if (currentTask.status === 'done')
+                await this.applyStatusChange(currentVault, currentTask, 'todo', 'reopened', date);
+            else
+                await this.applyStatusChange(currentVault, currentTask, 'done', 'completed', date);
+        });
+    }
+    async addProgressNote(vault, task, note, date) {
+        const cleanNote = note.trim();
+        if (!cleanNote)
+            return;
+        await this.runChange(`Added progress note to: ${task.name}`, async () => {
+            const currentVault = this.resolveVault(vault);
+            const currentTask = this.resolveTask(currentVault, task);
+            const oldStatus = currentTask.status;
+            if (currentTask.status === 'todo')
+                currentTask.status = 'in-progress';
+            const activity = {
+                id: randomUUID(), taskId: currentTask.id, taskName: currentTask.name, date,
+                kind: 'note', status: currentTask.status, note: cleanNote,
+            };
+            let taskWasSaved = false;
+            try {
+                if (this.store) {
+                    await this.store.saveTask(currentVault.id, currentTask);
+                    taskWasSaved = true;
+                    await this.store.saveActivity(currentVault.id, activity);
+                }
+            }
+            catch (error) {
+                currentTask.status = oldStatus;
+                if (taskWasSaved && this.store)
+                    await this.store.saveTask(currentVault.id, currentTask).catch(() => undefined);
+                throw error;
+            }
+            currentVault.activity.push(activity);
+        });
+    }
+    async applyStatusChange(vault, task, status, kind, date) {
+        const previousStatus = task.status;
+        const previousCompletedAt = task.completedAt;
+        const activity = { id: randomUUID(), taskId: task.id, taskName: task.name, date, kind, status };
+        task.status = status;
+        if (status === 'done')
+            task.completedAt = date;
+        else
+            delete task.completedAt;
+        let taskWasSaved = false;
+        try {
+            if (this.store) {
+                await this.store.saveTask(vault.id, task);
+                taskWasSaved = true;
+                await this.store.saveActivity(vault.id, activity);
+            }
+        }
+        catch (error) {
+            task.status = previousStatus;
+            if (previousCompletedAt)
+                task.completedAt = previousCompletedAt;
+            else
+                delete task.completedAt;
+            if (taskWasSaved && this.store)
+                await this.store.saveTask(vault.id, task).catch(() => undefined);
+            throw error;
+        }
+        vault.activity.push(activity);
+    }
+    async runChange(description, operation) {
+        if (this.transaction) {
+            return this.transaction(description, operation, async () => {
+                if (!this.store)
+                    return;
+                const vaults = await this.store.loadVaults();
+                if (this.onReload)
+                    this.onReload(vaults);
+                else
+                    this.setVaults(vaults);
+            });
+        }
+        const result = await operation();
+        await this.onChange(description);
+        return result;
+    }
+    resolveVault(reference) {
+        const vault = this.vaults.find(item => item.id === reference.id);
+        if (!vault)
+            throw new Error(`Vault ${reference.name} is no longer available. Refresh and try again.`);
+        return vault;
+    }
+    resolveTask(vault, reference) {
+        const task = vault.tasks.find(item => item.id === reference.id);
+        if (!task)
+            throw new Error(`Task ${reference.name} is no longer available. Refresh and try again.`);
+        return task;
+    }
+}

package/dist/app/src/cli/format.js

@@ -0,0 +1,6 @@
+export function formatSyncState(state) {
+    const labels = {
+        'local-only': 'Local only', syncing: 'Syncing…', synced: 'No local sync pending', pending: 'Pending sync', error: 'Sync error',
+    };
+    return labels[state];
+}

package/dist/app/src/cli/prompts.js

@@ -0,0 +1,15 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+export async function ask(question, defaultValue = '') {
+    const terminal = createInterface({ input: stdin, output: stdout });
+    try {
+        return (await terminal.question(`${question}${defaultValue ? ` [${defaultValue}]` : ''}: `)).trim() || defaultValue;
+    }
+    finally {
+        terminal.close();
+    }
+}
+export async function confirm(question, defaultYes = false) {
+    const answer = (await ask(`${question} (${defaultYes ? 'Y/n' : 'y/N'})`)).toLowerCase();
+    return answer ? answer === 'y' || answer === 'yes' : defaultYes;
+}

package/dist/app/src/cli.js

@@ -0,0 +1,174 @@
+import path from 'node:path';
+import { loadConfig, saveConfig } from "./config/config.js";
+import { assertDataDirectoryIsolated, currentDataDirectory } from "./config/paths.js";
+import { ask, confirm } from "./cli/prompts.js";
+import { StoreRepository } from "./storage/store.js";
+import { GitRepository } from "./sync/git-repository.js";
+import { SyncService } from "./sync/sync-service.js";
+import { OperationQueue } from "./application/operation-queue.js";
+import { TaskService } from "./application/task-service.js";
+import { App } from "./app.js";
+import { formatSyncState } from "./cli/format.js";
+const HELP = `Todos — keyboard-first task manager
+
+Usage:
+  todos [--data-dir <path>]           Open the task manager
+  todos init [--local | --remote URL] [--data-dir <path>]  Configure the store
+  todos link <url>                    Link the local store to a Git remote
+  todos unlink [--yes]                Remove the remote and keep local history
+  todos status                        Show the store and sync configuration
+  todos vault create <name> [about]   Create another vault
+  todos --help
+`;
+export async function main(args = process.argv.slice(2)) {
+    try {
+        await dispatch(args);
+    }
+    catch (error) {
+        console.error(`Todos: ${error.message}`);
+        process.exitCode = 1;
+    }
+}
+async function dispatch(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(HELP);
+        return;
+    }
+    const command = args[0];
+    if (command === 'init')
+        return initialize(args.slice(1));
+    if (command === 'link')
+        return link(args[1]);
+    if (command === 'unlink')
+        return unlink(args.includes('--yes'));
+    if (command === 'status')
+        return status();
+    if (command === 'vault' && args[1] === 'create')
+        return createVault(args.slice(2));
+    if (command && !command.startsWith('-'))
+        throw new Error(`Unknown command: ${command}\nRun todos --help for usage.`);
+    const override = optionValue(args, '--data-dir');
+    await openApp(override);
+}
+async function initialize(args) {
+    if (args.includes('--local') && optionValue(args, '--remote'))
+        throw new Error('Choose either --local or --remote, not both.');
+    const override = optionValue(args, '--data-dir');
+    const config = await loadConfig();
+    const dataDirectory = path.resolve(override || process.env.TODOS_DATA_DIR || config.dataDirectory || currentDataDirectory());
+    await assertDataDirectoryIsolated(dataDirectory);
+    const store = new StoreRepository(dataDirectory);
+    const wasInitialized = await store.isInitialized();
+    if (!wasInitialized) {
+        await store.initialize();
+        console.log(`Created your Todos store at ${dataDirectory}`);
+    }
+    else {
+        console.log(`Todos is already initialized at ${dataDirectory}`);
+    }
+    await saveConfig({ dataDirectory });
+    let remote = optionValue(args, '--remote');
+    const localOnly = args.includes('--local');
+    const git = new GitRepository(dataDirectory);
+    const linkedRemote = await git.remoteUrl();
+    if (!remote && !linkedRemote && !localOnly && process.stdin.isTTY && process.stdout.isTTY) {
+        if (await confirm('Link this store to a Git remote now?', false))
+            remote = await ask('Git remote URL');
+    }
+    if (remote) {
+        console.log(`Git remote: ${redactRemote(remote)}`);
+        await new SyncService(git, new OperationQueue()).linkRemote(remote);
+        console.log('Remote linked. Run `todos` to open the TUI.');
+    }
+    else if (linkedRemote)
+        console.log(`Git remote already linked: ${redactRemote(linkedRemote)}`);
+    else
+        console.log('Local-only mode enabled. Link a remote later with `todos link <url>`.');
+}
+async function link(url) {
+    if (!url)
+        throw new Error('Usage: todos link <url>');
+    const { store, sync, dataDirectory } = await context();
+    if (!(await store.isInitialized()))
+        throw new Error('Run `todos init` before linking a remote.');
+    await store.loadVaults();
+    console.log(`Linking data in ${dataDirectory}`);
+    console.log(`Git remote: ${redactRemote(url)}`);
+    await sync.linkRemote(url);
+    console.log('Remote linked and task data synchronized.');
+}
+async function unlink(yes) {
+    const { sync, dataDirectory, git } = await context();
+    if (!(await git.hasRemote())) {
+        console.log(`No remote is linked. Data remains at ${dataDirectory}`);
+        return;
+    }
+    if (!yes) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY)
+            throw new Error('Use `todos unlink --yes` in a non-interactive terminal.');
+        if (!(await confirm(`Remove the Git remote from ${dataDirectory}? Local files and history remain.`, false)))
+            return;
+    }
+    await sync.unlink();
+    console.log('Remote unlinked. Local files and Git history remain.');
+}
+async function status() {
+    const { store, git, dataDirectory } = await context();
+    const initialized = await store.isInitialized();
+    const vaults = initialized ? await store.loadVaults() : [];
+    const remote = await git.remoteUrl();
+    const syncState = await git.syncState();
+    console.log(`Data directory: ${dataDirectory}`);
+    console.log(`Initialized: ${initialized ? 'yes' : 'no (run todos init)'}`);
+    console.log(`Vaults: ${vaults.length}`);
+    console.log(`Git remote: ${remote ? redactRemote(remote) : 'none (local only)'}`);
+    console.log(`Sync: ${formatSyncState(syncState)}`);
+}
+async function createVault(args) {
+    const name = args[0];
+    if (!name)
+        throw new Error('Usage: todos vault create <name> [about]');
+    const { store, sync } = await context();
+    if (!(await store.isInitialized()))
+        throw new Error('Run `todos init` first.');
+    const vault = await store.createVault(name, args.slice(1).join(' '));
+    await sync.commitAndPush(`Created vault ${vault.name}`);
+    console.log(`Created vault ${vault.name}.`);
+}
+async function openApp(override) {
+    const { store, git, sync, dataDirectory } = await context(override);
+    if (!(await store.isInitialized())) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new Error('Open Todos in an interactive terminal; `todos` will create the first local vault automatically.');
+        }
+        await store.initialize();
+        await saveConfig({ dataDirectory });
+        console.log(`Created your first Todos vault at ${dataDirectory} (local-only).`);
+    }
+    await sync.syncBeforeRead();
+    const vaults = await store.loadVaults();
+    const tasks = new TaskService(store, undefined, (description, operation, afterSync) => sync.mutateAndSync(description, operation, afterSync));
+    await App.init({ vaults, tasks, refresh: async () => {
+            return sync.refresh(async () => {
+                const current = await store.loadVaults();
+                tasks.setVaults(current);
+                return current;
+            });
+        }, sync });
+}
+async function context(override) {
+    const config = await loadConfig();
+    const dataDirectory = path.resolve(override || process.env.TODOS_DATA_DIR || config.dataDirectory || currentDataDirectory());
+    await assertDataDirectoryIsolated(dataDirectory);
+    const store = new StoreRepository(dataDirectory);
+    const git = new GitRepository(dataDirectory);
+    const queue = new OperationQueue();
+    return { store, git, sync: new SyncService(git, queue), dataDirectory };
+}
+function optionValue(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function redactRemote(remote) {
+    return remote.replace(/(https?:\/\/)[^/@\s]+@/gi, '$1[credentials]@');
+}

package/dist/app/src/config/config.js

@@ -0,0 +1,25 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { writeJsonAtomically } from "../storage/atomic-file.js";
+import { currentConfigDirectory, currentDataDirectory } from "./paths.js";
+export function configFilePath() {
+    return path.join(currentConfigDirectory(), 'config.json');
+}
+export async function loadConfig() {
+    try {
+        const parsed = JSON.parse(await readFile(configFilePath(), 'utf8'));
+        if (typeof parsed === 'object' && parsed !== null && 'dataDirectory' in parsed && typeof parsed.dataDirectory === 'string') {
+            return { dataDirectory: parsed.dataDirectory };
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw new Error(`Could not read Todos configuration: ${error.message}`);
+    }
+    return { dataDirectory: currentDataDirectory() };
+}
+export async function saveConfig(config) {
+    const file = configFilePath();
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await writeJsonAtomically(file, config);
+}

package/dist/app/src/config/paths.js

@@ -0,0 +1,95 @@
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { lstat, realpath } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+export function resolveDataDirectory(platform, env, home, override) {
+    if (override) {
+        const api = platform === 'win32' ? path.win32 : path.posix;
+        return api.isAbsolute(override) ? api.normalize(override) : api.resolve(home, override);
+    }
+    if (platform === 'win32')
+        return path.win32.join(absoluteWinPath(env.LOCALAPPDATA) || path.win32.join(home, 'AppData', 'Local'), 'JMTodos');
+    if (platform === 'darwin')
+        return path.posix.join(home, 'Library', 'Application Support', 'JMTodos');
+    return path.posix.join(absolutePosixPath(env.XDG_DATA_HOME) || path.posix.join(home, '.local', 'share'), 'jmtodos');
+}
+export function resolveConfigDirectory(platform, env, home) {
+    if (platform === 'win32')
+        return path.win32.join(absoluteWinPath(env.APPDATA) || path.win32.join(home, 'AppData', 'Roaming'), 'JMTodos');
+    if (platform === 'darwin')
+        return path.posix.join(home, 'Library', 'Preferences', 'JMTodos');
+    return path.posix.join(absolutePosixPath(env.XDG_CONFIG_HOME) || path.posix.join(home, '.config'), 'jmtodos');
+}
+export function currentDataDirectory(env = process.env) {
+    const home = process.platform === 'win32' ? env.USERPROFILE || env.HOME : env.HOME || env.USERPROFILE;
+    return resolveDataDirectory(process.platform, env, home || homedir(), env.TODOS_DATA_DIR);
+}
+export function currentConfigDirectory(env = process.env) {
+    const home = process.platform === 'win32' ? env.USERPROFILE || env.HOME : env.HOME || env.USERPROFILE;
+    return resolveConfigDirectory(process.platform, env, home || homedir());
+}
+export async function assertDataDirectoryIsolated(directory) {
+    let current = path.dirname(fileURLToPath(import.meta.url));
+    let checkoutRoot;
+    while (true) {
+        try {
+            await lstat(path.join(current, '.git'));
+            checkoutRoot = await realpath(current);
+            break;
+        }
+        catch { /* Keep walking toward the filesystem root. */ }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    if (!checkoutRoot)
+        return;
+    let unresolved = path.resolve(directory);
+    const suffix = [];
+    while (true) {
+        let existing;
+        try {
+            existing = await realpath(unresolved);
+        }
+        catch {
+            const parent = path.dirname(unresolved);
+            if (parent === unresolved)
+                return;
+            suffix.unshift(path.basename(unresolved));
+            unresolved = parent;
+            continue;
+        }
+        const target = path.resolve(existing, ...suffix);
+        const relative = path.relative(checkoutRoot, target);
+        if (relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative))) {
+            throw new Error('The Todos data folder cannot be inside the application checkout. Choose a global or separate data folder.');
+        }
+        let ancestor = existing;
+        while (true) {
+            let hasGitDirectory = false;
+            try {
+                await lstat(path.join(ancestor, '.git'));
+                hasGitDirectory = true;
+            }
+            catch { /* Not a Git worktree root. */ }
+            if (hasGitDirectory) {
+                if (path.resolve(ancestor) !== path.resolve(target)) {
+                    throw new Error('The Todos data folder cannot be inside a Git worktree. Choose an isolated data folder.');
+                }
+                break;
+            }
+            const parent = path.dirname(ancestor);
+            if (parent === ancestor)
+                break;
+            ancestor = parent;
+        }
+        return;
+    }
+}
+function absoluteWinPath(value) {
+    return value && path.win32.isAbsolute(value) ? value : undefined;
+}
+function absolutePosixPath(value) {
+    return value && path.posix.isAbsolute(value) ? value : undefined;
+}

package/dist/app/src/model/activity.js

@@ -0,0 +1 @@
+export {};