@rushinglabs/taskfile 0.2.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026, Darrien Rushing
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# Taskfile
+
+A simple todo list CLI, runnable via `npx`.
+
+## Usage
+
+```bash
+npx @rushinglabs/taskfile add "Buy milk"
+npx @rushinglabs/taskfile list
+npx @rushinglabs/taskfile remove 1
+```
+
+## Development
+
+```bash
+npm install
+```
+
+### Running commands against the dev instance
+
+There are a few ways to run the CLI locally while developing, without publishing anything.
+
+**Option 1: `ts-node` (no build step)**
+
+Runs the TypeScript source directly — fastest way to iterate:
+
+```bash
+npm run dev -- add "Buy milk"
+npm run dev -- list
+npm run dev -- remove 1
+```
+
+This starts the TUI via the development build.
+```bash
+npm run dev --
+```
+
+**Option 2: build once, run compiled output**
+
+Matches what actually ships:
+
+```bash
+npm run build
+node dist/index.js add "Buy milk"
+node dist/index.js list
+node dist/index.js remove 1
+```
+
+**Option 3: `npm link` (test the real `taskfile` command)**
+
+Simulates installing the package globally, so you can run it as `taskfile` from anywhere, the same way `npx` would invoke it:
+
+```bash
+npm run build
+npm link
+taskfile add "Buy milk"
+taskfile list
+```
+
+When you're done, remove the link with:
+
+```bash
+npm unlink -g @rushinglabs/taskfile
+```
+
+Tasks are stored at `~/.taskfile/tasks.json` regardless of which option you use.
+
+### Running tests
+
+```bash
+npm test
+```

package/dist/commands/add.js

@@ -0,0 +1,5 @@
+import { addTask, getDefaultListId } from "../store.js";
+export function addItem(text) {
+    const task = addTask(getDefaultListId(), text);
+    console.log(`Added task #${task.id}: ${task.text}`);
+}

package/dist/commands/list.js

@@ -0,0 +1,12 @@
+import { getDefaultListId, loadTasks } from "../store.js";
+export function listItems() {
+    const tasks = loadTasks(getDefaultListId());
+    if (tasks.length === 0) {
+        console.log("No tasks yet. Add one with `taskfile add <text>`.");
+        return;
+    }
+    for (const task of tasks) {
+        const marker = task.done ? "[x]" : "[ ]";
+        console.log(`${marker} #${task.id} ${task.text}`);
+    }
+}

package/dist/commands/remove.js

@@ -0,0 +1,15 @@
+import { removeTask } from "../store.js";
+export function removeItem(id) {
+    const result = removeTask(id);
+    if (result.status === "not-found") {
+        console.error(`No task found with id #${id}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (result.status === "blocked") {
+        console.error(result.reason);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`Removed task #${result.task.id}: ${result.task.text}`);
+}

package/dist/index.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+process.removeAllListeners("warning");
+process.on("warning", (warning) => {
+    if (warning.name === "ExperimentalWarning" && /SQLite/i.test(warning.message)) {
+        return;
+    }
+    console.warn(warning);
+});
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { addItem } from "./commands/add.js";
+import { removeItem } from "./commands/remove.js";
+import { listItems } from "./commands/list.js";
+import { runTui } from "./tui/index.js";
+const packageDir = dirname(fileURLToPath(import.meta.url));
+const { version } = JSON.parse(readFileSync(join(packageDir, "../package.json"), "utf8"));
+const program = new Command();
+program.name("taskfile").description("A simple todo list CLI").version(version);
+program
+    .command("add <text...>")
+    .description("Add a new task")
+    .action((text) => {
+    addItem(text.join(" "));
+});
+program
+    .command("remove <id>")
+    .description("Remove a task by id")
+    .action((id) => {
+    removeItem(Number(id));
+});
+program
+    .command("list")
+    .description("List all tasks")
+    .action(() => {
+    listItems();
+});
+program
+    .command("tui", { isDefault: true, hidden: true })
+    .description("Launch the interactive TUI")
+    .action(async () => {
+    if (!process.stdin.isTTY) {
+        program.help();
+        return;
+    }
+    await runTui();
+});
+await program.parseAsync();

package/dist/settings.js

@@ -0,0 +1,74 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+export const SNAPSHOT_RETENTION_OPTIONS = [
+    "1-week",
+    "1-month",
+    "3-months",
+    "6-months",
+    "12-months",
+    "forever",
+];
+const DEFAULT_SETTINGS = {
+    width: 120,
+    height: 40,
+    progressAnimation: true,
+    lastActiveListId: null,
+    dailySnapshotsEnabled: true,
+    dailySnapshotRetention: "12-months",
+};
+const WIDTH_RANGE = { min: 40, max: 300 };
+const HEIGHT_RANGE = { min: 10, max: 100 };
+function isValidRetention(value) {
+    return typeof value === "string" && SNAPSHOT_RETENTION_OPTIONS.includes(value);
+}
+function clamp(value, range) {
+    return Math.min(Math.max(Math.round(value), range.min), range.max);
+}
+function getStoreDir() {
+    return path.join(os.homedir(), ".taskfile");
+}
+function getSettingsFile() {
+    return path.join(getStoreDir(), "settings.json");
+}
+export function loadSettings() {
+    const settingsFile = getSettingsFile();
+    if (!fs.existsSync(settingsFile)) {
+        return { ...DEFAULT_SETTINGS };
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(settingsFile, "utf-8"));
+        return {
+            width: typeof parsed.width === "number" ? clamp(parsed.width, WIDTH_RANGE) : DEFAULT_SETTINGS.width,
+            height: typeof parsed.height === "number" ? clamp(parsed.height, HEIGHT_RANGE) : DEFAULT_SETTINGS.height,
+            progressAnimation: typeof parsed.progressAnimation === "boolean" ? parsed.progressAnimation : DEFAULT_SETTINGS.progressAnimation,
+            lastActiveListId: typeof parsed.lastActiveListId === "number" ? parsed.lastActiveListId : DEFAULT_SETTINGS.lastActiveListId,
+            dailySnapshotsEnabled: typeof parsed.dailySnapshotsEnabled === "boolean"
+                ? parsed.dailySnapshotsEnabled
+                : DEFAULT_SETTINGS.dailySnapshotsEnabled,
+            dailySnapshotRetention: isValidRetention(parsed.dailySnapshotRetention)
+                ? parsed.dailySnapshotRetention
+                : DEFAULT_SETTINGS.dailySnapshotRetention,
+        };
+    }
+    catch {
+        return { ...DEFAULT_SETTINGS };
+    }
+}
+export function saveSettings(update) {
+    const current = loadSettings();
+    const next = {
+        width: update.width !== undefined ? clamp(update.width, WIDTH_RANGE) : current.width,
+        height: update.height !== undefined ? clamp(update.height, HEIGHT_RANGE) : current.height,
+        progressAnimation: update.progressAnimation !== undefined ? update.progressAnimation : current.progressAnimation,
+        lastActiveListId: update.lastActiveListId !== undefined ? update.lastActiveListId : current.lastActiveListId,
+        dailySnapshotsEnabled: update.dailySnapshotsEnabled !== undefined ? update.dailySnapshotsEnabled : current.dailySnapshotsEnabled,
+        dailySnapshotRetention: update.dailySnapshotRetention !== undefined ? update.dailySnapshotRetention : current.dailySnapshotRetention,
+    };
+    const storeDir = getStoreDir();
+    if (!fs.existsSync(storeDir)) {
+        fs.mkdirSync(storeDir, { recursive: true });
+    }
+    fs.writeFileSync(getSettingsFile(), JSON.stringify(next, null, 2));
+    return next;
+}

package/dist/snapshots.js

@@ -0,0 +1,97 @@
+import { getDb, loadLists, loadTasks } from "./store.js";
+const RETENTION_DAYS = {
+    "1-week": 7,
+    "1-month": 30,
+    "3-months": 90,
+    "6-months": 180,
+    "12-months": 365,
+};
+function localDateString(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+export function captureSnapshot(date) {
+    const db = getDb();
+    const createdAt = new Date().toISOString();
+    const snapshotInfo = db.prepare("INSERT INTO snapshots (date, createdAt) VALUES (?, ?)").run(date, createdAt);
+    const snapshotId = Number(snapshotInfo.lastInsertRowid);
+    const lists = loadLists();
+    lists.forEach((list, listOrderIndex) => {
+        const listInfo = db
+            .prepare("INSERT INTO snapshot_lists (snapshotId, name, createdAt, orderIndex) VALUES (?, ?, ?, ?)")
+            .run(snapshotId, list.name, list.createdAt, listOrderIndex);
+        const snapshotListId = Number(listInfo.lastInsertRowid);
+        const originalToSnapshotTaskId = new Map();
+        loadTasks(list.id).forEach((task, taskOrderIndex) => {
+            const parentSnapshotTaskId = task.parentId === null ? null : (originalToSnapshotTaskId.get(task.parentId) ?? null);
+            const taskInfo = db
+                .prepare(`INSERT INTO snapshot_tasks
+             (snapshotListId, text, done, priority, parentSnapshotTaskId, createdAt, orderIndex)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                .run(snapshotListId, task.text, task.done ? 1 : 0, task.priority ? 1 : 0, parentSnapshotTaskId, task.createdAt, taskOrderIndex);
+            originalToSnapshotTaskId.set(task.id, Number(taskInfo.lastInsertRowid));
+        });
+    });
+}
+export function captureSnapshotIfNeeded(settings) {
+    if (!settings.dailySnapshotsEnabled)
+        return;
+    const today = localDateString(new Date());
+    const existing = getDb().prepare("SELECT id FROM snapshots WHERE date = ?").get(today);
+    if (existing)
+        return;
+    captureSnapshot(today);
+}
+export function pruneSnapshots(retention) {
+    if (retention === "forever")
+        return;
+    const cutoff = localDateString(new Date(Date.now() - RETENTION_DAYS[retention] * 24 * 60 * 60 * 1000));
+    const db = getDb();
+    db.prepare(`DELETE FROM snapshot_tasks WHERE snapshotListId IN (
+       SELECT id FROM snapshot_lists WHERE snapshotId IN (SELECT id FROM snapshots WHERE date < ?)
+     )`).run(cutoff);
+    db.prepare("DELETE FROM snapshot_lists WHERE snapshotId IN (SELECT id FROM snapshots WHERE date < ?)").run(cutoff);
+    db.prepare("DELETE FROM snapshots WHERE date < ?").run(cutoff);
+}
+export function runStartupSnapshotMaintenance(settings) {
+    pruneSnapshots(settings.dailySnapshotRetention);
+    captureSnapshotIfNeeded(settings);
+}
+export function listSnapshots() {
+    const rows = getDb().prepare("SELECT id, date FROM snapshots ORDER BY date DESC").all();
+    return rows.map((row) => ({ id: row.id, date: row.date }));
+}
+export function loadSnapshotDetail(id) {
+    const db = getDb();
+    const snapshot = db.prepare("SELECT id, date FROM snapshots WHERE id = ?").get(id);
+    if (!snapshot)
+        return undefined;
+    const listRows = db
+        .prepare("SELECT id, name FROM snapshot_lists WHERE snapshotId = ? ORDER BY orderIndex")
+        .all(id);
+    const lists = listRows.map((listRow) => {
+        const taskRows = db
+            .prepare(`SELECT id, snapshotListId, text, done, priority, parentSnapshotTaskId, createdAt
+         FROM snapshot_tasks WHERE snapshotListId = ? ORDER BY orderIndex`)
+            .all(listRow.id);
+        const tasks = taskRows.map((row) => ({
+            id: row.id,
+            text: row.text,
+            done: !!row.done,
+            parentId: row.parentSnapshotTaskId,
+            priority: !!row.priority,
+            listId: row.snapshotListId,
+            createdAt: row.createdAt,
+        }));
+        return { name: listRow.name, tasks };
+    });
+    return { id: snapshot.id, date: snapshot.date, lists };
+}
+export function deleteSnapshot(id) {
+    const db = getDb();
+    db.prepare(`DELETE FROM snapshot_tasks WHERE snapshotListId IN (SELECT id FROM snapshot_lists WHERE snapshotId = ?)`).run(id);
+    db.prepare("DELETE FROM snapshot_lists WHERE snapshotId = ?").run(id);
+    db.prepare("DELETE FROM snapshots WHERE id = ?").run(id);
+}

package/dist/store.js

@@ -0,0 +1,253 @@
+import { DatabaseSync } from "node:sqlite";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+let db;
+let dbPath;
+function getStoreDir() {
+    return path.join(os.homedir(), ".taskfile");
+}
+function getStoreFile() {
+    return path.join(getStoreDir(), "tasks.db");
+}
+function rowToTask(row) {
+    return {
+        id: row.id,
+        text: row.text,
+        done: !!row.done,
+        parentId: row.parentId,
+        priority: !!row.priority,
+        listId: row.listId,
+        createdAt: row.createdAt,
+    };
+}
+function rowToList(row) {
+    return { id: row.id, name: row.name, createdAt: row.createdAt };
+}
+function ensureSchema(database) {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS lists (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      createdAt TEXT NOT NULL
+    )
+  `);
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      text TEXT NOT NULL,
+      done INTEGER NOT NULL DEFAULT 0,
+      createdAt TEXT NOT NULL,
+      parentId INTEGER REFERENCES tasks(id),
+      priority INTEGER NOT NULL DEFAULT 0,
+      listId INTEGER REFERENCES lists(id)
+    )
+  `);
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS snapshots (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      date TEXT NOT NULL UNIQUE,
+      createdAt TEXT NOT NULL
+    )
+  `);
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS snapshot_lists (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      snapshotId INTEGER NOT NULL REFERENCES snapshots(id),
+      name TEXT NOT NULL,
+      createdAt TEXT NOT NULL,
+      orderIndex INTEGER NOT NULL
+    )
+  `);
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS snapshot_tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      snapshotListId INTEGER NOT NULL REFERENCES snapshot_lists(id),
+      text TEXT NOT NULL,
+      done INTEGER NOT NULL DEFAULT 0,
+      priority INTEGER NOT NULL DEFAULT 0,
+      parentSnapshotTaskId INTEGER REFERENCES snapshot_tasks(id),
+      createdAt TEXT NOT NULL,
+      orderIndex INTEGER NOT NULL
+    )
+  `);
+    const columns = database.prepare("PRAGMA table_info(tasks)").all();
+    const hasParentId = columns.some((column) => column.name === "parentId");
+    if (!hasParentId) {
+        database.exec("ALTER TABLE tasks ADD COLUMN parentId INTEGER REFERENCES tasks(id)");
+    }
+    const hasPriority = columns.some((column) => column.name === "priority");
+    if (!hasPriority) {
+        database.exec("ALTER TABLE tasks ADD COLUMN priority INTEGER NOT NULL DEFAULT 0");
+    }
+    const hasListId = columns.some((column) => column.name === "listId");
+    if (!hasListId) {
+        database.exec("ALTER TABLE tasks ADD COLUMN listId INTEGER REFERENCES lists(id)");
+    }
+    const { count } = database.prepare("SELECT COUNT(*) AS count FROM lists").get();
+    let defaultListId;
+    if (count === 0) {
+        const createdAt = new Date().toISOString();
+        const info = database.prepare("INSERT INTO lists (name, createdAt) VALUES (?, ?)").run("Todos", createdAt);
+        defaultListId = Number(info.lastInsertRowid);
+    }
+    else {
+        const first = database.prepare("SELECT id FROM lists ORDER BY id LIMIT 1").get();
+        defaultListId = first.id;
+    }
+    database.prepare("UPDATE tasks SET listId = ? WHERE listId IS NULL").run(defaultListId);
+}
+export function getDb() {
+    const currentPath = getStoreFile();
+    if (db && dbPath === currentPath) {
+        return db;
+    }
+    if (db) {
+        db.close();
+    }
+    const storeDir = getStoreDir();
+    if (!fs.existsSync(storeDir)) {
+        fs.mkdirSync(storeDir, { recursive: true });
+    }
+    db = new DatabaseSync(currentPath);
+    ensureSchema(db);
+    dbPath = currentPath;
+    return db;
+}
+export function loadTasks(listId) {
+    const rows = getDb()
+        .prepare(`SELECT id, text, done, parentId, priority, listId, createdAt FROM tasks
+       WHERE listId = ?
+       ORDER BY
+         (SELECT priority FROM tasks p WHERE p.id = COALESCE(tasks.parentId, tasks.id)) DESC,
+         COALESCE(parentId, id),
+         parentId IS NOT NULL,
+         priority DESC,
+         id`)
+        .all(listId);
+    return rows.map(rowToTask);
+}
+export function addTask(listId, text, parentId = null) {
+    const createdAt = new Date().toISOString();
+    const info = getDb()
+        .prepare("INSERT INTO tasks (text, done, createdAt, parentId, listId) VALUES (?, 0, ?, ?, ?)")
+        .run(text, createdAt, parentId, listId);
+    return { id: Number(info.lastInsertRowid), text, done: false, parentId, priority: false, listId, createdAt };
+}
+export function loadLists() {
+    const rows = getDb().prepare("SELECT id, name, createdAt FROM lists ORDER BY id").all();
+    return rows.map(rowToList);
+}
+export function createList(name) {
+    const trimmed = name.trim();
+    const createdAt = new Date().toISOString();
+    const info = getDb().prepare("INSERT INTO lists (name, createdAt) VALUES (?, ?)").run(trimmed, createdAt);
+    return { id: Number(info.lastInsertRowid), name: trimmed, createdAt };
+}
+export function renameList(id, name) {
+    const row = getDb().prepare("SELECT id, name, createdAt FROM lists WHERE id = ?").get(id);
+    if (!row) {
+        return { status: "not-found" };
+    }
+    const trimmed = name.trim();
+    if (trimmed.length === 0) {
+        return { status: "blocked", reason: "List name cannot be empty." };
+    }
+    getDb().prepare("UPDATE lists SET name = ? WHERE id = ?").run(trimmed, id);
+    return { status: "ok", list: { ...rowToList(row), name: trimmed } };
+}
+export function getDefaultListId() {
+    return loadLists()[0].id;
+}
+export function removeTask(id) {
+    const row = getDb()
+        .prepare("SELECT id, text, done, parentId, priority, listId, createdAt FROM tasks WHERE id = ?")
+        .get(id);
+    if (!row) {
+        return { status: "not-found" };
+    }
+    if (row.parentId === null) {
+        const { count } = getDb()
+            .prepare("SELECT COUNT(*) AS count FROM tasks WHERE parentId = ?")
+            .get(id);
+        if (count > 0) {
+            return { status: "blocked", reason: "Delete all sub-items first." };
+        }
+    }
+    getDb().prepare("DELETE FROM tasks WHERE id = ?").run(id);
+    return { status: "ok", task: rowToTask(row) };
+}
+export function toggleTask(id) {
+    const row = getDb()
+        .prepare("SELECT id, text, done, parentId, priority, listId, createdAt FROM tasks WHERE id = ?")
+        .get(id);
+    if (!row) {
+        return { status: "not-found" };
+    }
+    const nextDone = !row.done;
+    if (nextDone && row.parentId === null) {
+        const { count } = getDb()
+            .prepare("SELECT COUNT(*) AS count FROM tasks WHERE parentId = ? AND done = 0")
+            .get(id);
+        if (count > 0) {
+            return { status: "blocked", reason: "Complete all sub-items before completing this item." };
+        }
+    }
+    getDb()
+        .prepare("UPDATE tasks SET done = ? WHERE id = ?")
+        .run(nextDone ? 1 : 0, id);
+    if (!nextDone && row.parentId !== null) {
+        getDb().prepare("UPDATE tasks SET done = 0 WHERE id = ? AND done = 1").run(row.parentId);
+    }
+    const updated = getDb()
+        .prepare("SELECT id, text, done, parentId, priority, listId, createdAt FROM tasks WHERE id = ?")
+        .get(id);
+    return { status: "ok", task: rowToTask(updated) };
+}
+export function updateTask(id, text) {
+    const row = getDb()
+        .prepare("SELECT id, text, done, parentId, priority, listId, createdAt FROM tasks WHERE id = ?")
+        .get(id);
+    if (!row) {
+        return { status: "not-found" };
+    }
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return { status: "blocked", reason: "Task text cannot be empty." };
+    }
+    getDb().prepare("UPDATE tasks SET text = ? WHERE id = ?").run(trimmed, id);
+    return { status: "ok", task: { ...rowToTask(row), text: trimmed } };
+}
+// Counts all tasks flat, ignoring parentId (main items and sub-items count equally).
+export function computeProgress(tasks) {
+    const total = tasks.length;
+    const done = tasks.filter((task) => task.done).length;
+    const percent = total === 0 ? 0 : Math.round((done / total) * 100);
+    return { done, total, percent };
+}
+export function hasSubItems(id) {
+    const { count } = getDb()
+        .prepare("SELECT COUNT(*) AS count FROM tasks WHERE parentId = ?")
+        .get(id);
+    return count > 0;
+}
+export function setPriority(id, priority) {
+    const row = getDb()
+        .prepare("SELECT id, text, done, parentId, priority, listId, createdAt FROM tasks WHERE id = ?")
+        .get(id);
+    if (!row) {
+        return { status: "not-found" };
+    }
+    getDb()
+        .prepare("UPDATE tasks SET priority = ? WHERE id = ?")
+        .run(priority ? 1 : 0, id);
+    if (row.parentId === null) {
+        getDb()
+            .prepare("UPDATE tasks SET priority = ? WHERE parentId = ?")
+            .run(priority ? 1 : 0, id);
+    }
+    const updated = getDb()
+        .prepare("SELECT id, text, done, parentId, priority, listId, createdAt FROM tasks WHERE id = ?")
+        .get(id);
+    return { status: "ok", task: rowToTask(updated) };
+}

package/dist/tui/AddTaskInput.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text } from "ink";
+import TextInput from "ink-text-input";
+export function AddTaskInput({ onSubmit, label = "New task: ", initialValue = "", }) {
+    const [value, setValue] = useState(initialValue);
+    return (_jsxs(Box, { children: [_jsx(Text, { children: label }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: (text) => {
+                    const trimmed = text.trim();
+                    if (trimmed.length > 0) {
+                        onSubmit(trimmed);
+                    }
+                } })] }));
+}