pacatui 0.1.0

package/src/components/index.ts

@@ -0,0 +1,17 @@
+export { Header } from "./Header.tsx";
+export { StatusBar } from "./StatusBar.tsx";
+export { ProjectList } from "./ProjectList.tsx";
+export { TaskList } from "./TaskList.tsx";
+export { Dashboard } from "./Dashboard.tsx";
+export { HelpView } from "./HelpView.tsx";
+export { SettingsView, SETTINGS_COUNT } from "./SettingsView.tsx";
+export { InputModal, ConfirmModal } from "./InputModal.tsx";
+export { ProjectModal } from "./ProjectModal.tsx";
+export { Timer, formatDurationHuman } from "./Timer.tsx";
+export { ProjectSelectModal, StopTimerModal } from "./TimerModals.tsx";
+export { SplashScreen } from "./SplashScreen.tsx";
+export { TimesheetView } from "./TimesheetView.tsx";
+export { CustomerModal } from "./CustomerModal.tsx";
+export { CustomerSelectModal } from "./CustomerSelectModal.tsx";
+export { EditTimeEntryModal } from "./EditTimeEntryModal.tsx";
+export { CreateInvoiceModal } from "./CreateInvoiceModal.tsx";

package/src/db.ts

@@ -0,0 +1,629 @@
+import { PrismaClient } from "../generated/prisma/client.ts";
+import { PrismaLibSql } from "@prisma/adapter-libsql";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// Ensure the .paca directory exists in user's home
+const pacaDir = join(homedir(), ".paca");
+if (!existsSync(pacaDir)) {
+  mkdirSync(pacaDir, { recursive: true });
+}
+
+// Database path
+export const DB_PATH = join(pacaDir, "paca.db");
+
+// Create adapter factory
+const adapterFactory = new PrismaLibSql({
+  url: `file:${DB_PATH}`,
+});
+
+// Create Prisma client with adapter
+export const db = new PrismaClient({ adapter: adapterFactory });
+
+// Initialize database connection
+export async function initDatabase() {
+  try {
+    await db.$connect();
+    return true;
+  } catch (error) {
+    console.error("Failed to connect to database:", error);
+    return false;
+  }
+}
+
+// Disconnect from database
+export async function closeDatabase() {
+  await db.$disconnect();
+}
+
+// Status sort order: in_progress first, then todo, then done
+const STATUS_ORDER: Record<string, number> = {
+  in_progress: 0,
+  todo: 1,
+  done: 2,
+};
+
+const sortByStatus = <T extends { status: string; priority: string; createdAt: Date }>(tasks: T[]): T[] => {
+  const priorityOrder: Record<string, number> = { urgent: 0, high: 1, medium: 2, low: 3 };
+  return [...tasks].sort((a, b) => {
+    const statusDiff = (STATUS_ORDER[a.status] ?? 99) - (STATUS_ORDER[b.status] ?? 99);
+    if (statusDiff !== 0) return statusDiff;
+    const priorityDiff = (priorityOrder[a.priority] ?? 99) - (priorityOrder[b.priority] ?? 99);
+    if (priorityDiff !== 0) return priorityDiff;
+    return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+  });
+};
+
+// Clean up old completed tasks (completed more than N days ago)
+export async function cleanupOldCompletedTasks(daysOld = 3) {
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+
+  const result = await db.task.deleteMany({
+    where: {
+      status: "done",
+      completedAt: { lt: cutoffDate },
+    },
+  });
+
+  return result.count;
+}
+
+// Project operations
+export const projects = {
+  async getAll(includeArchived = false) {
+    return db.project.findMany({
+      where: includeArchived ? {} : { archived: false },
+      orderBy: { name: "asc" },
+      include: {
+        tasks: {
+          select: {
+            id: true,
+            status: true,
+          },
+        },
+        customer: true,
+      },
+    });
+  },
+
+  async getById(id: string) {
+    const project = await db.project.findUnique({
+      where: { id },
+      include: {
+        tasks: true,
+        customer: true,
+      },
+    });
+    if (project) {
+      project.tasks = sortByStatus(project.tasks);
+    }
+    return project;
+  },
+
+  async create(data: {
+    name: string;
+    description?: string;
+    color?: string;
+    hourlyRate?: number;
+  }) {
+    return db.project.create({ data });
+  },
+
+  async update(
+    id: string,
+    data: {
+      name?: string;
+      description?: string;
+      color?: string;
+      hourlyRate?: number | null;
+      archived?: boolean;
+    },
+  ) {
+    return db.project.update({ where: { id }, data });
+  },
+
+  async archive(id: string) {
+    return db.project.update({ where: { id }, data: { archived: true } });
+  },
+
+  async unarchive(id: string) {
+    return db.project.update({ where: { id }, data: { archived: false } });
+  },
+
+  async delete(id: string) {
+    return db.project.delete({ where: { id } });
+  },
+
+  async setCustomer(projectId: string, customerId: string | null) {
+    return db.project.update({
+      where: { id: projectId },
+      data: { customerId },
+      include: { customer: true },
+    });
+  },
+};
+
+// Task operations
+export const tasks = {
+  async getByProject(projectId: string) {
+    const result = await db.task.findMany({
+      where: { projectId },
+      include: {
+        tags: {
+          include: { tag: true },
+        },
+      },
+    });
+    return sortByStatus(result);
+  },
+
+  async getAll() {
+    const result = await db.task.findMany({
+      include: {
+        project: true,
+        tags: {
+          include: { tag: true },
+        },
+      },
+    });
+    return sortByStatus(result);
+  },
+
+  async create(data: {
+    title: string;
+    description?: string;
+    projectId: string;
+    priority?: string;
+    dueDate?: Date;
+  }) {
+    return db.task.create({ data });
+  },
+
+  async update(
+    id: string,
+    data: {
+      title?: string;
+      description?: string;
+      status?: string;
+      priority?: string;
+      dueDate?: Date | null;
+    },
+  ) {
+    const updateData: Record<string, unknown> = { ...data };
+    if (data.status === "done") {
+      updateData.completedAt = new Date();
+    } else if (data.status && data.status !== "done") {
+      updateData.completedAt = null;
+    }
+    return db.task.update({ where: { id }, data: updateData });
+  },
+
+  async toggleStatus(id: string) {
+    const task = await db.task.findUnique({ where: { id } });
+    if (!task) return null;
+
+    const statusCycle: Record<string, string> = {
+      todo: "in_progress",
+      in_progress: "done",
+      done: "todo",
+    };
+
+    const newStatus = statusCycle[task.status] || "todo";
+    return this.update(id, { status: newStatus });
+  },
+
+  async delete(id: string) {
+    return db.task.delete({ where: { id } });
+  },
+};
+
+// Tag operations
+export const tags = {
+  async getAll() {
+    return db.tag.findMany({
+      orderBy: { name: "asc" },
+    });
+  },
+
+  async create(data: { name: string; color?: string }) {
+    return db.tag.create({ data });
+  },
+
+  async addToTask(taskId: string, tagId: string) {
+    return db.taskTag.create({
+      data: { taskId, tagId },
+    });
+  },
+
+  async removeFromTask(taskId: string, tagId: string) {
+    return db.taskTag.delete({
+      where: { taskId_tagId: { taskId, tagId } },
+    });
+  },
+};
+
+// Stats for dashboard
+export const stats = {
+  async getDashboardStats() {
+    const [
+      totalProjects,
+      activeProjects,
+      totalTasks,
+      todoTasks,
+      inProgressTasks,
+      doneTasks,
+      overdueTasks,
+    ] = await Promise.all([
+      db.project.count(),
+      db.project.count({ where: { archived: false } }),
+      db.task.count(),
+      db.task.count({ where: { status: "todo" } }),
+      db.task.count({ where: { status: "in_progress" } }),
+      db.task.count({ where: { status: "done" } }),
+      db.task.count({
+        where: {
+          status: { not: "done" },
+          dueDate: { lt: new Date() },
+        },
+      }),
+    ]);
+
+    return {
+      totalProjects,
+      activeProjects,
+      archivedProjects: totalProjects - activeProjects,
+      totalTasks,
+      todoTasks,
+      inProgressTasks,
+      doneTasks,
+      overdueTasks,
+      completionRate:
+        totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0,
+    };
+  },
+
+  async getRecentActivity(limit = 10) {
+    const tasks = await db.task.findMany({
+      take: limit * 2, // Fetch more to ensure good coverage after sorting
+      orderBy: { updatedAt: "desc" },
+      include: {
+        project: {
+          select: { name: true, color: true },
+        },
+      },
+    });
+
+    // Sort by status (in_progress -> todo -> done), then by updatedAt within each group
+    return tasks
+      .sort((a, b) => {
+        const statusDiff = (STATUS_ORDER[a.status] ?? 99) - (STATUS_ORDER[b.status] ?? 99);
+        if (statusDiff !== 0) return statusDiff;
+        return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+      })
+      .slice(0, limit);
+  },
+
+  async getTimeStats() {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+
+    const weekStart = new Date(today);
+    weekStart.setDate(weekStart.getDate() - weekStart.getDay());
+
+    const monthStart = new Date(today.getFullYear(), today.getMonth(), 1);
+
+    const [todayEntries, weekEntries, monthEntries] = await Promise.all([
+      db.timeEntry.findMany({
+        where: { startTime: { gte: today }, endTime: { not: null } },
+      }),
+      db.timeEntry.findMany({
+        where: { startTime: { gte: weekStart }, endTime: { not: null } },
+      }),
+      db.timeEntry.findMany({
+        where: { startTime: { gte: monthStart }, endTime: { not: null } },
+      }),
+    ]);
+
+    const calcDuration = (
+      entries: { startTime: Date; endTime: Date | null }[],
+    ) =>
+      entries.reduce((sum, e) => {
+        if (!e.endTime) return sum;
+        return (
+          sum +
+          (new Date(e.endTime).getTime() - new Date(e.startTime).getTime())
+        );
+      }, 0);
+
+    return {
+      todayMs: calcDuration(todayEntries),
+      weekMs: calcDuration(weekEntries),
+      monthMs: calcDuration(monthEntries),
+    };
+  },
+};
+
+// Time entry operations
+export const timeEntries = {
+  async getRunning() {
+    return db.timeEntry.findFirst({
+      where: { endTime: null },
+      include: {
+        project: {
+          select: { id: true, name: true, color: true, hourlyRate: true },
+        },
+      },
+    });
+  },
+
+  async start(projectId: string) {
+    // Stop any existing running timer first
+    const running = await this.getRunning();
+    if (running) {
+      await this.stop(running.id, "Timer stopped automatically");
+    }
+
+    return db.timeEntry.create({
+      data: {
+        projectId,
+        startTime: new Date(),
+      },
+      include: {
+        project: {
+          select: { id: true, name: true, color: true, hourlyRate: true },
+        },
+      },
+    });
+  },
+
+  async stop(id: string, description?: string) {
+    return db.timeEntry.update({
+      where: { id },
+      data: {
+        endTime: new Date(),
+        description,
+      },
+      include: {
+        project: {
+          select: { id: true, name: true, color: true, hourlyRate: true },
+        },
+      },
+    });
+  },
+
+  async getByProject(projectId: string, limit = 50) {
+    return db.timeEntry.findMany({
+      where: { projectId, endTime: { not: null } },
+      orderBy: { startTime: "desc" },
+      take: limit,
+    });
+  },
+
+  async getRecent(limit = 10) {
+    return db.timeEntry.findMany({
+      where: { endTime: { not: null } },
+      orderBy: { startTime: "desc" },
+      take: limit,
+      include: {
+        project: {
+          select: { id: true, name: true, color: true, hourlyRate: true },
+        },
+      },
+    });
+  },
+
+  async delete(id: string) {
+    return db.timeEntry.delete({ where: { id } });
+  },
+
+  async getProjectTotalTime(projectId: string) {
+    const entries = await db.timeEntry.findMany({
+      where: { projectId, endTime: { not: null } },
+    });
+
+    return entries.reduce((sum, e) => {
+      if (!e.endTime) return sum;
+      return (
+        sum + (new Date(e.endTime).getTime() - new Date(e.startTime).getTime())
+      );
+    }, 0);
+  },
+
+  async getUninvoiced() {
+    return db.timeEntry.findMany({
+      where: {
+        invoiceId: null,
+        endTime: { not: null },
+      },
+      orderBy: { startTime: "desc" },
+      include: {
+        project: {
+          select: {
+            id: true,
+            name: true,
+            color: true,
+            hourlyRate: true,
+            customer: true,
+          },
+        },
+      },
+    });
+  },
+
+  async update(
+    id: string,
+    data: { startTime?: Date; endTime?: Date; description?: string },
+  ) {
+    return db.timeEntry.update({
+      where: { id },
+      data,
+      include: {
+        project: {
+          select: {
+            id: true,
+            name: true,
+            color: true,
+            hourlyRate: true,
+            customer: true,
+          },
+        },
+      },
+    });
+  },
+
+  async markInvoiced(ids: string[], invoiceId: string) {
+    return db.timeEntry.updateMany({
+      where: { id: { in: ids } },
+      data: { invoiceId },
+    });
+  },
+};
+
+// Settings operations
+export const settings = {
+  async get(key: string): Promise<string | null> {
+    const setting = await db.setting.findUnique({ where: { key } });
+    return setting?.value ?? null;
+  },
+
+  async set(key: string, value: string): Promise<void> {
+    await db.setting.upsert({
+      where: { key },
+      update: { value },
+      create: { key, value },
+    });
+  },
+
+  async getAll(): Promise<Record<string, string>> {
+    const allSettings = await db.setting.findMany();
+    return Object.fromEntries(allSettings.map((s) => [s.key, s.value]));
+  },
+
+  async getAppSettings() {
+    const all = await this.getAll();
+    return {
+      businessName: all.businessName ?? "",
+      stripeApiKey: all.stripeApiKey ?? "",
+      timezone: all.timezone ?? "auto",
+    };
+  },
+};
+
+// Customer operations
+export const customers = {
+  async getAll() {
+    return db.customer.findMany({
+      orderBy: { name: "asc" },
+    });
+  },
+
+  async getById(id: string) {
+    return db.customer.findUnique({ where: { id } });
+  },
+
+  async create(data: { name: string; email: string }) {
+    return db.customer.create({ data });
+  },
+
+  async update(id: string, data: { name?: string; email?: string; stripeCustomerId?: string | null }) {
+    return db.customer.update({ where: { id }, data });
+  },
+
+  async delete(id: string) {
+    return db.customer.delete({ where: { id } });
+  },
+
+  async updateStripeId(id: string, stripeCustomerId: string) {
+    return db.customer.update({
+      where: { id },
+      data: { stripeCustomerId },
+    });
+  },
+};
+
+// Invoice operations
+export const invoices = {
+  async create(data: {
+    projectId: string;
+    customerId: string;
+    totalHours: number;
+    totalAmount: number;
+    timeEntryIds: string[];
+  }) {
+    const { timeEntryIds, ...invoiceData } = data;
+
+    // Create invoice and link time entries in a transaction
+    return db.$transaction(async (tx) => {
+      const invoice = await tx.invoice.create({ data: invoiceData });
+
+      // Link time entries to this invoice
+      await tx.timeEntry.updateMany({
+        where: { id: { in: timeEntryIds } },
+        data: { invoiceId: invoice.id },
+      });
+
+      return invoice;
+    });
+  },
+
+  async updateStripeId(id: string, stripeInvoiceId: string) {
+    return db.invoice.update({
+      where: { id },
+      data: { stripeInvoiceId },
+    });
+  },
+
+  async getByProject(projectId: string) {
+    return db.invoice.findMany({
+      where: { projectId },
+      orderBy: { createdAt: "desc" },
+      include: {
+        customer: true,
+        timeEntries: true,
+      },
+    });
+  },
+
+  async getByCustomer(customerId: string) {
+    return db.invoice.findMany({
+      where: { customerId },
+      orderBy: { createdAt: "desc" },
+      include: {
+        project: true,
+        timeEntries: true,
+      },
+    });
+  },
+
+  async getAll() {
+    return db.invoice.findMany({
+      orderBy: { createdAt: "desc" },
+      include: {
+        project: true,
+        customer: true,
+        timeEntries: true,
+      },
+    });
+  },
+};
+
+// Database import/export operations
+export const database = {
+  async exportToFile(targetPath: string): Promise<void> {
+    const { copyFileSync } = await import("fs");
+    copyFileSync(DB_PATH, targetPath);
+  },
+
+  async importFromFile(sourcePath: string): Promise<void> {
+    const { copyFileSync, existsSync } = await import("fs");
+    if (!existsSync(sourcePath)) {
+      throw new Error("Source file does not exist");
+    }
+    // Close connection, copy file, reconnect
+    await db.$disconnect();
+    copyFileSync(sourcePath, DB_PATH);
+    await db.$connect();
+  },
+};

package/src/hooks/usePaste.ts

@@ -0,0 +1,69 @@
+import { useEffect, useRef } from "react";
+import { useRenderer } from "@opentui/react";
+import type { InputRenderable, PasteEvent } from "@opentui/core";
+
+/**
+ * Hook to enable paste support for input components.
+ * Returns a ref that should be attached to the input element.
+ * When the input is focused and a paste event occurs, the text is inserted.
+ */
+export function usePaste() {
+	const renderer = useRenderer();
+	const inputRef = useRef<InputRenderable | null>(null);
+
+	useEffect(() => {
+		const handlePaste = (event: PasteEvent) => {
+			const input = inputRef.current;
+			if (input && input.focused) {
+				input.insertText(event.text);
+				event.preventDefault();
+			}
+		};
+
+		renderer.keyInput.on("paste", handlePaste);
+		return () => {
+			renderer.keyInput.off("paste", handlePaste);
+		};
+	}, [renderer]);
+
+	return inputRef;
+}
+
+/**
+ * Hook to enable paste support for multiple inputs.
+ * Call registerInput(name) to get a ref for each input.
+ * When a paste event occurs, it inserts text into the focused input.
+ */
+export function useMultiPaste() {
+	const renderer = useRenderer();
+	const inputRefs = useRef<Map<string, InputRenderable | null>>(new Map());
+
+	useEffect(() => {
+		const handlePaste = (event: PasteEvent) => {
+			for (const input of inputRefs.current.values()) {
+				if (input && input.focused) {
+					input.insertText(event.text);
+					event.preventDefault();
+					return;
+				}
+			}
+		};
+
+		renderer.keyInput.on("paste", handlePaste);
+		return () => {
+			renderer.keyInput.off("paste", handlePaste);
+		};
+	}, [renderer]);
+
+	const registerInput = (name: string) => {
+		return (ref: InputRenderable | null) => {
+			if (ref) {
+				inputRefs.current.set(name, ref);
+			} else {
+				inputRefs.current.delete(name);
+			}
+		};
+	};
+
+	return { registerInput };
+}