pacatui 0.1.0

package/src/index.tsx

@@ -0,0 +1,75 @@
+#!/usr/bin/env bun
+import { createCliRenderer, type CliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import { App } from "./App.tsx";
+import { initDatabase, closeDatabase, cleanupOldCompletedTasks, DB_PATH } from "./db.ts";
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname } from "path";
+
+let renderer: CliRenderer | null = null;
+
+async function main() {
+  // Check if database exists, if not run migration
+  if (!existsSync(DB_PATH)) {
+    console.log("Initializing Paca database...");
+    try {
+      // Run prisma migration
+      const projectDir = dirname(dirname(import.meta.path));
+      execSync(`cd "${projectDir}" && bunx prisma migrate deploy`, {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          DATABASE_URL: `file:${DB_PATH}`,
+        },
+      });
+      console.log("Database initialized successfully!");
+    } catch (error) {
+      console.error("Failed to initialize database:", error);
+      process.exit(1);
+    }
+  }
+
+  // Initialize database connection
+  const connected = await initDatabase();
+  if (!connected) {
+    console.error("Failed to connect to database");
+    process.exit(1);
+  }
+
+  // Clean up tasks that have been done for more than 3 days
+  await cleanupOldCompletedTasks(3);
+
+  // Handle cleanup on exit - must stop renderer to restore terminal state
+  const cleanup = async () => {
+    if (renderer) {
+      renderer.stop();
+    }
+    await closeDatabase();
+    // Give renderer time to finish, then reset terminal and exit
+    setTimeout(() => {
+      try {
+        require("child_process").spawnSync("reset", [], { stdio: "inherit" });
+      } catch {}
+      process.exit(0);
+    }, 50);
+  };
+
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+
+  // Create and start the TUI
+  try {
+    renderer = await createCliRenderer({
+      exitOnCtrlC: false,
+    });
+
+    createRoot(renderer).render(<App />);
+  } catch (error) {
+    console.error("Failed to start Paca:", error);
+    await closeDatabase();
+    process.exit(1);
+  }
+}
+
+main();

package/src/stripe.ts

@@ -0,0 +1,163 @@
+import Stripe from "stripe";
+
+// Get or create Stripe customer, returns Stripe customer ID
+export async function getOrCreateStripeCustomer(
+  apiKey: string,
+  customer: { name: string; email: string; stripeCustomerId: string | null },
+): Promise<string> {
+  const stripe = new Stripe(apiKey);
+
+  // If we already have a Stripe customer ID, verify it exists
+  if (customer.stripeCustomerId) {
+    try {
+      await stripe.customers.retrieve(customer.stripeCustomerId);
+      return customer.stripeCustomerId;
+    } catch {
+      // Customer was deleted in Stripe, create new one
+    }
+  }
+
+  // Search by email first
+  const existing = await stripe.customers.list({ email: customer.email, limit: 1 });
+  if (existing.data[0]) {
+    return existing.data[0].id;
+  }
+
+  // Create new customer
+  const newCustomer = await stripe.customers.create({
+    name: customer.name,
+    email: customer.email,
+  });
+  return newCustomer.id;
+}
+
+// Line item for invoice creation
+export interface InvoiceLineItem {
+  description: string;
+  hours: number;
+  rate: number;
+  startTime: Date;
+  endTime: Date;
+}
+
+// Create draft invoice with line items
+export async function createDraftInvoice(
+  apiKey: string,
+  stripeCustomerId: string,
+  projectName: string,
+  lineItems: InvoiceLineItem[],
+): Promise<string> {
+  const stripe = new Stripe(apiKey);
+
+  // Create pending invoice items first (they'll be collected into the invoice)
+  for (const item of lineItems) {
+    const amount = Math.round(item.hours * item.rate * 100); // Stripe uses cents
+    if (amount <= 0) continue; // Skip zero-amount items
+
+    // Format hours with 2 decimal places
+    const hoursFormatted = item.hours.toFixed(2);
+
+    // Format start and end times
+    const formatTime = (date: Date) => date.toLocaleString("en-US", {
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true,
+    });
+
+    const timeRange = `${formatTime(item.startTime)} - ${formatTime(item.endTime)}`;
+
+    // Format: "4.75 hour(s) :: Project Name :: Description"
+    const description = `${hoursFormatted} hour(s) :: ${projectName} :: ${item.description}`;
+
+    await stripe.invoiceItems.create({
+      customer: stripeCustomerId,
+      amount,
+      currency: "usd",
+      description,
+      metadata: {
+        project: projectName,
+        start_time: item.startTime.toISOString(),
+        end_time: item.endTime.toISOString(),
+        time_range: timeRange,
+        hours: hoursFormatted,
+      },
+    });
+  }
+
+  // Create invoice - this will automatically include all pending invoice items
+  const invoice = await stripe.invoices.create({
+    customer: stripeCustomerId,
+    auto_advance: false, // Keep as draft
+    collection_method: "send_invoice",
+    days_until_due: 30,
+    pending_invoice_items_behavior: "include",
+  });
+
+  return invoice.id;
+}
+
+// Invoice display type
+export interface StripeInvoiceItem {
+  id: string;
+  number: string | null;
+  customerName: string | null;
+  customerEmail: string | null;
+  status: string;
+  amount: number;
+  currency: string;
+  created: Date;
+  dueDate: Date | null;
+  hostedUrl: string | null;
+  dashboardUrl: string;
+}
+
+export interface ListInvoicesResult {
+  invoices: StripeInvoiceItem[];
+  hasMore: boolean;
+  nextCursor: string | null;
+}
+
+// List invoices from Stripe with pagination
+export async function listInvoices(
+  apiKey: string,
+  limit = 25,
+  startingAfter?: string,
+): Promise<ListInvoicesResult> {
+  const stripe = new Stripe(apiKey);
+
+  const params: Stripe.InvoiceListParams = {
+    limit,
+    expand: ["data.customer"],
+  };
+
+  if (startingAfter) {
+    params.starting_after = startingAfter;
+  }
+
+  const response = await stripe.invoices.list(params);
+
+  const invoices: StripeInvoiceItem[] = response.data.map((inv) => {
+    const customer = inv.customer as Stripe.Customer | null;
+    return {
+      id: inv.id,
+      number: inv.number,
+      customerName: customer?.name ?? null,
+      customerEmail: customer?.email ?? null,
+      status: inv.status ?? "unknown",
+      amount: inv.amount_due / 100, // Convert from cents
+      currency: inv.currency,
+      created: new Date(inv.created * 1000),
+      dueDate: inv.due_date ? new Date(inv.due_date * 1000) : null,
+      hostedUrl: inv.hosted_invoice_url ?? null,
+      dashboardUrl: `https://dashboard.stripe.com/invoices/${inv.id}`,
+    };
+  });
+
+  return {
+    invoices,
+    hasMore: response.has_more,
+    nextCursor: response.data.length > 0 ? response.data[response.data.length - 1]?.id ?? null : null,
+  };
+}

package/src/types.ts

@@ -0,0 +1,361 @@
+import type {
+	Project,
+	Task,
+	Tag,
+	TimeEntry,
+	Customer,
+	Invoice,
+} from "../generated/prisma/client.ts";
+
+export type { Project, Task, Tag, TimeEntry, Customer, Invoice };
+
+export type TaskStatus = "todo" | "in_progress" | "done";
+export type TaskPriority = "low" | "medium" | "high" | "urgent";
+
+export interface ProjectWithTasks extends Project {
+	tasks: Task[];
+}
+
+export interface ProjectWithTaskCounts extends Project {
+	tasks: { id: string; status: string }[];
+}
+
+export interface TaskWithTags extends Task {
+	tags: { tag: Tag }[];
+}
+
+export interface TaskWithProject extends Task {
+	project: Project;
+	tags: { tag: Tag }[];
+}
+
+export type View =
+	| "dashboard"
+	| "projects"
+	| "tasks"
+	| "settings"
+	| "help"
+	| "timesheets"
+	| "invoices";
+
+export type Panel = "projects" | "tasks" | "details";
+
+export interface AppState {
+	currentView: View;
+	activePanel: Panel;
+	selectedProjectId: string | null;
+	selectedTaskId: string | null;
+	showArchived: boolean;
+	inputMode: InputMode | null;
+}
+
+export type InputMode =
+	| "create_project"
+	| "edit_project"
+	| "create_task"
+	| "edit_task"
+	| "edit_dashboard_task"
+	| "confirm_delete"
+	| "stop_timer"
+	| "select_timer_project"
+	| "search"
+	| "edit_business_name"
+	| "edit_stripe_key"
+	| "edit_timezone"
+	| "confirm_import"
+	| "edit_time_entry"
+	| "create_invoice"
+	| "confirm_delete_time_entry"
+	| "create_customer"
+	| "edit_customer"
+	| "select_customer";
+
+export interface RunningTimer {
+	id: string;
+	startTime: Date;
+	project: {
+		id: string;
+		name: string;
+		color: string;
+		hourlyRate: number | null;
+	};
+}
+
+export interface TimeEntryWithProject extends TimeEntry {
+	project: {
+		id: string;
+		name: string;
+		color: string;
+		hourlyRate: number | null;
+	};
+}
+
+export interface TimeStats {
+	todayMs: number;
+	weekMs: number;
+	monthMs: number;
+}
+
+export interface AppSettings {
+	businessName: string;
+	stripeApiKey: string;
+	timezone: string; // IANA timezone (e.g., "America/New_York") or "auto" for system detection
+}
+
+// Get the system's detected timezone
+export function getSystemTimezone(): string {
+	return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+
+// Get the effective timezone (resolves "auto" to system timezone)
+export function getEffectiveTimezone(settings: AppSettings): string {
+	if (!settings.timezone || settings.timezone === "auto") {
+		return getSystemTimezone();
+	}
+	return settings.timezone;
+}
+
+// Format a date for display in the given timezone
+export function formatDateInTimezone(
+	date: Date | string,
+	timezone: string,
+): string {
+	if (!date) return "";
+	const dateObj = date instanceof Date ? date : new Date(date);
+	if (isNaN(dateObj.getTime())) return "";
+
+	try {
+		return dateObj.toLocaleDateString("en-US", {
+			timeZone: timezone,
+			month: "short",
+			day: "numeric",
+		});
+	} catch {
+		return dateObj.toLocaleDateString("en-US", {
+			month: "short",
+			day: "numeric",
+		});
+	}
+}
+
+// Format a time for display in the given timezone
+export function formatTimeInTimezone(
+	date: Date | string,
+	timezone: string,
+): string {
+	if (!date) return "";
+	const dateObj = date instanceof Date ? date : new Date(date);
+	if (isNaN(dateObj.getTime())) return "";
+
+	try {
+		return dateObj.toLocaleTimeString("en-US", {
+			timeZone: timezone,
+			hour: "numeric",
+			minute: "2-digit",
+			hour12: true,
+		});
+	} catch {
+		return dateObj.toLocaleTimeString("en-US", {
+			hour: "numeric",
+			minute: "2-digit",
+			hour12: true,
+		});
+	}
+}
+
+// Format a date-time for editing (YYYY-MM-DD HH:MM) in the given timezone
+export function formatDateTimeForEdit(
+	date: Date | string,
+	timezone: string,
+): string {
+	if (!date) return "";
+
+	const dateObj = date instanceof Date ? date : new Date(date);
+	if (isNaN(dateObj.getTime())) return "";
+
+	try {
+		const formatter = new Intl.DateTimeFormat("en-CA", {
+			timeZone: timezone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			hour12: false,
+		});
+		const parts = formatter.formatToParts(dateObj);
+		const get = (type: string) =>
+			parts.find((p) => p.type === type)?.value || "";
+		return `${get("year")}-${get("month")}-${get("day")} ${get("hour")}:${get("minute")}`;
+	} catch {
+		// Fallback to local time if timezone is invalid
+		const year = dateObj.getFullYear();
+		const month = String(dateObj.getMonth() + 1).padStart(2, "0");
+		const day = String(dateObj.getDate()).padStart(2, "0");
+		const hours = String(dateObj.getHours()).padStart(2, "0");
+		const minutes = String(dateObj.getMinutes()).padStart(2, "0");
+		return `${year}-${month}-${day} ${hours}:${minutes}`;
+	}
+}
+
+// Parse a date-time string (YYYY-MM-DD HH:MM) in the given timezone
+export function parseDateTimeInTimezone(
+	input: string,
+	timezone: string,
+): Date | null {
+	const match = input.match(/^(\d{4})-(\d{2})-(\d{2})\s+(\d{1,2}):(\d{2})$/);
+	if (!match || !match[1] || !match[2] || !match[3] || !match[4] || !match[5]) {
+		return null;
+	}
+
+	const [, year, month, day, hour, minute] = match;
+	const dateStr = `${year}-${month}-${day}T${hour.padStart(2, "0")}:${minute}:00`;
+
+	try {
+		// Use Intl to get the offset for this date in the target timezone
+		const testDate = new Date(dateStr + "Z"); // Parse as UTC first
+		const formatter = new Intl.DateTimeFormat("en-US", {
+			timeZone: timezone,
+			timeZoneName: "shortOffset",
+		});
+
+		// Get parts to find the offset
+		const parts = formatter.formatToParts(testDate);
+		const offsetPart =
+			parts.find((p) => p.type === "timeZoneName")?.value || "";
+
+		// Parse offset like "GMT-5" or "GMT+5:30"
+		const offsetMatch = offsetPart.match(/GMT([+-]?)(\d+)(?::(\d+))?/);
+		let offsetMinutes = 0;
+		if (offsetMatch) {
+			const sign = offsetMatch[1] === "-" ? -1 : 1;
+			const hours = parseInt(offsetMatch[2] || "0", 10);
+			const minutes = parseInt(offsetMatch[3] || "0", 10);
+			offsetMinutes = sign * (hours * 60 + minutes);
+		}
+
+		// Create the date by adjusting for the timezone offset
+		const utcDate = new Date(dateStr + "Z");
+		utcDate.setMinutes(utcDate.getMinutes() - offsetMinutes);
+
+		if (isNaN(utcDate.getTime())) {
+			return null;
+		}
+		return utcDate;
+	} catch {
+		// Fallback: parse as local time if timezone is invalid
+		const localDate = new Date(
+			parseInt(year),
+			parseInt(month) - 1,
+			parseInt(day),
+			parseInt(hour),
+			parseInt(minute),
+		);
+		if (isNaN(localDate.getTime())) {
+			return null;
+		}
+		return localDate;
+	}
+}
+
+export interface DashboardStats {
+	totalProjects: number;
+	activeProjects: number;
+	archivedProjects: number;
+	totalTasks: number;
+	todoTasks: number;
+	inProgressTasks: number;
+	doneTasks: number;
+	overdueTasks: number;
+	completionRate: number;
+}
+
+export interface TimesheetGroup {
+	project: {
+		id: string;
+		name: string;
+		color: string;
+		hourlyRate: number | null;
+		customer: Customer | null;
+	};
+	entries: TimeEntryWithProject[];
+	totalMs: number;
+	totalAmount: number;
+}
+
+export interface ProjectWithCustomer extends Project {
+	customer: Customer | null;
+}
+
+export interface TimeEntryWithInvoice extends TimeEntry {
+	invoiceId: string | null;
+	project: {
+		id: string;
+		name: string;
+		color: string;
+		hourlyRate: number | null;
+		customer: Customer | null;
+	};
+}
+
+export const STATUS_LABELS: Record<TaskStatus, string> = {
+	todo: "To Do",
+	in_progress: "In Progress",
+	done: "Done",
+};
+
+export const STATUS_ICONS: Record<TaskStatus, string> = {
+	todo: "○",
+	in_progress: "◐",
+	done: "●",
+};
+
+export const PRIORITY_LABELS: Record<TaskPriority, string> = {
+	low: "Low",
+	medium: "Medium",
+	high: "High",
+	urgent: "Urgent",
+};
+
+export const PRIORITY_COLORS: Record<TaskPriority, string> = {
+	low: "gray",
+	medium: "blue",
+	high: "yellow",
+	urgent: "red",
+};
+
+export const PROJECT_COLORS = [
+	"#3b82f6", // Blue
+	"#10b981", // Green
+	"#f59e0b", // Amber
+	"#ef4444", // Red
+	"#8b5cf6", // Purple
+	"#ec4899", // Pink
+	"#06b6d4", // Cyan
+	"#f97316", // Orange
+];
+
+export const COLORS = {
+	bg: "#171623",
+	border: "#777777",
+	borderOff: "#444444",
+	selectedRowBg: "#3325b4",
+	textPrimary: "#e0e0e0",
+	textSecondary: "#94a3b8",
+	accent: "#3b82f6",
+};
+
+// Stripe invoice data for display
+export interface StripeInvoiceDisplay {
+	id: string;
+	number: string | null;
+	customerName: string | null;
+	customerEmail: string | null;
+	status: string;
+	amount: number;
+	currency: string;
+	created: Date;
+	dueDate: Date | null;
+	hostedUrl: string | null;
+	pdfUrl: string | null;
+}