pacioli 1.0.1

package/src/index.ts

@@ -0,0 +1,250 @@
+#!/usr/bin/env bun
+
+/**
+ * CLI Invoice Generator
+ * Main entry point
+ */
+
+import { fileExists, readJSON, getOutputPath } from "./utils";
+import {
+  validateInvoice,
+  validateQuotation,
+  validateReceipt,
+  validateFreelancerConfig,
+  validateCustomer,
+  type DocumentData,
+  type FreelancerConfig,
+  type Customer,
+} from "./validator";
+import { generatePDF } from "./generator";
+import {
+  getNextDocumentNumber,
+  incrementDocumentCounter,
+} from "./metadata";
+
+const VALID_TYPES = ["invoice", "quotation", "receipt"] as const;
+type DocumentType = (typeof VALID_TYPES)[number];
+
+/**
+ * Print usage information
+ */
+function printUsage() {
+  console.log(`
+CLI Invoice Generator
+
+Usage:
+  bun run generate <type> <input-json> --customer <customer-json> [options]
+
+Arguments:
+  <type>           Document type: invoice, quotation, or receipt
+  <input-json>     Path to JSON data file
+  --customer       Path to customer JSON file (required)
+
+Options:
+  --output <path>   Custom output PDF path (default: output/{type}-{number}.pdf)
+  --profile <path>  Path to freelancer profile (default: config/freelancer.json)
+  --help            Show this help message
+
+Examples:
+  bun run generate invoice data/invoice-001.json --customer customers/acme-corp.json
+  bun run generate quotation data/quote-001.json --customer customers/demo.json --output custom/path.pdf
+  bun run generate receipt data/receipt-001.json --customer customers/test.json --profile config/freelancer.json
+  `);
+}
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args: string[]) {
+  const options: {
+    type?: DocumentType;
+    inputPath?: string;
+    customerPath?: string;
+    outputPath?: string;
+    configPath: string;
+    help: boolean;
+  } = {
+    configPath: "config/freelancer.json",
+    help: false,
+  };
+
+  // Check for help flag
+  if (args.includes("--help") || args.includes("-h")) {
+    options.help = true;
+    return options;
+  }
+
+  // Get positional arguments
+  const positionalArgs = args.filter((arg) => !arg.startsWith("--"));
+
+  if (positionalArgs.length >= 2) {
+    const type = positionalArgs[0];
+    if (VALID_TYPES.includes(type as DocumentType)) {
+      options.type = type as DocumentType;
+    }
+    options.inputPath = positionalArgs[1];
+  }
+
+  // Parse options
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+
+    if (arg === "--customer" && nextArg) {
+      options.customerPath = nextArg;
+      i++;
+    } else if (arg === "--output" && nextArg) {
+      options.outputPath = nextArg;
+      i++;
+    } else if (arg === "--profile" && nextArg) {
+      options.configPath = nextArg;
+      i++;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    printUsage();
+    process.exit(0);
+  }
+
+  const options = parseArgs(args);
+
+  if (options.help) {
+    printUsage();
+    process.exit(0);
+  }
+
+  // Validate arguments
+  if (!options.type) {
+    console.error("Error: Invalid or missing document type");
+    console.error(
+      `Valid types: ${VALID_TYPES.join(", ")}`
+    );
+    process.exit(1);
+  }
+
+  if (!options.inputPath) {
+    console.error("Error: Input JSON file path is required");
+    printUsage();
+    process.exit(1);
+  }
+
+  if (!options.customerPath) {
+    console.error("Error: Customer JSON file path is required (use --customer)");
+    printUsage();
+    process.exit(1);
+  }
+
+  // Check if input file exists
+  if (!(await fileExists(options.inputPath))) {
+    console.error(`Error: Input file not found: ${options.inputPath}`);
+    process.exit(1);
+  }
+
+  // Check if customer file exists
+  if (!(await fileExists(options.customerPath))) {
+    console.error(`Error: Customer file not found: ${options.customerPath}`);
+    process.exit(1);
+  }
+
+  // Check if profile file exists
+  if (!(await fileExists(options.configPath))) {
+    console.error(`Error: Profile file not found: ${options.configPath}`);
+    console.error(
+      "Tip: Copy config/freelancer.example.json to config/freelancer.json"
+    );
+    process.exit(1);
+  }
+
+  try {
+    console.log(`📄 Generating ${options.type}...`);
+
+    // Load freelancer profile
+    console.log(`📋 Loading profile from ${options.configPath}...`);
+    const config = await readJSON<FreelancerConfig>(options.configPath);
+
+    // Validate profile
+    const configValidation = validateFreelancerConfig(config);
+    if (!configValidation.valid) {
+      console.error("Error: Invalid freelancer profile:");
+      configValidation.errors.forEach((err) => console.error(`  - ${err}`));
+      process.exit(1);
+    }
+
+    // Load customer data
+    console.log(`👤 Loading customer from ${options.customerPath}...`);
+    const customer = await readJSON<Customer>(options.customerPath);
+
+    // Validate customer
+    const customerValidation = validateCustomer(customer);
+    if (!customerValidation.valid) {
+      console.error("Error: Invalid customer data:");
+      customerValidation.errors.forEach((err) => console.error(`  - ${err}`));
+      process.exit(1);
+    }
+
+    // Load document data
+    console.log(`📋 Loading data from ${options.inputPath}...`);
+    const data = await readJSON<DocumentData>(options.inputPath);
+
+    // Validate document data based on type
+    let validation;
+    switch (options.type) {
+      case "invoice":
+        validation = validateInvoice(data);
+        break;
+      case "quotation":
+        validation = validateQuotation(data);
+        break;
+      case "receipt":
+        validation = validateReceipt(data);
+        break;
+    }
+
+    if (!validation.valid) {
+      console.error(`Error: Invalid ${options.type} data:`);
+      validation.errors.forEach((err) => console.error(`  - ${err}`));
+      process.exit(1);
+    }
+
+    // Handle auto-numbering
+    let resolvedDocumentNumber = data.documentNumber;
+    if (data.documentNumber === "auto") {
+      console.log(`🔢 Generating next document number...`);
+      resolvedDocumentNumber = await getNextDocumentNumber(options.type);
+      data.documentNumber = resolvedDocumentNumber;
+      console.log(`✓ Document number: ${resolvedDocumentNumber}`);
+    }
+
+    // Determine output path
+    const outputPath = getOutputPath(
+      options.type,
+      resolvedDocumentNumber,
+      options.outputPath
+    );
+
+    // Generate PDF
+    console.log(`🔨 Generating PDF...`);
+    await generatePDF(options.type, data, customer, config, outputPath);
+
+    // Update metadata counter after successful generation
+    await incrementDocumentCounter(options.type, resolvedDocumentNumber);
+
+    console.log(`\n✅ Success! PDF saved to: ${outputPath}`);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+// Run main
+main();

package/src/metadata.ts

@@ -0,0 +1,174 @@
+/**
+ * Document metadata management for auto-numbering
+ */
+
+import { fileExists } from "./utils";
+
+export interface DocumentTypeMetadata {
+  lastNumber: number;
+  prefix: string;
+  year: number;
+  month: number;
+}
+
+export interface Metadata {
+  invoice: DocumentTypeMetadata;
+  quotation: DocumentTypeMetadata;
+  receipt: DocumentTypeMetadata;
+}
+
+const METADATA_PATH = ".metadata.json";
+
+/**
+ * Get default metadata structure
+ */
+function getDefaultMetadata(): Metadata {
+  const now = new Date();
+  const currentYear = now.getFullYear();
+  const currentMonth = now.getMonth() + 1; // 1-12
+
+  return {
+    invoice: {
+      lastNumber: 0,
+      prefix: "INV",
+      year: currentYear,
+      month: currentMonth,
+    },
+    quotation: {
+      lastNumber: 0,
+      prefix: "QT",
+      year: currentYear,
+      month: currentMonth,
+    },
+    receipt: {
+      lastNumber: 0,
+      prefix: "REC",
+      year: currentYear,
+      month: currentMonth,
+    },
+  };
+}
+
+/**
+ * Read metadata from file
+ */
+export async function readMetadata(): Promise<Metadata> {
+  try {
+    if (await fileExists(METADATA_PATH)) {
+      const file = Bun.file(METADATA_PATH);
+      const data = await file.json();
+
+      // Validate and return metadata
+      return data as Metadata;
+    }
+  } catch (error) {
+    console.warn("Warning: Could not read metadata file, using defaults");
+  }
+
+  return getDefaultMetadata();
+}
+
+/**
+ * Write metadata to file
+ */
+export async function writeMetadata(metadata: Metadata): Promise<void> {
+  try {
+    await Bun.write(METADATA_PATH, JSON.stringify(metadata, null, 2));
+  } catch (error) {
+    throw new Error(`Failed to write metadata: ${error}`);
+  }
+}
+
+/**
+ * Generate next document number for a given type
+ */
+export async function getNextDocumentNumber(
+  type: "invoice" | "quotation" | "receipt"
+): Promise<string> {
+  const metadata = await readMetadata();
+  const typeMetadata = metadata[type];
+  const now = new Date();
+  const currentYear = now.getFullYear();
+  const currentMonth = now.getMonth() + 1; // 1-12
+
+  // Reset counter if year or month has changed
+  if (typeMetadata.year !== currentYear || typeMetadata.month !== currentMonth) {
+    typeMetadata.year = currentYear;
+    typeMetadata.month = currentMonth;
+    typeMetadata.lastNumber = 0;
+  }
+
+  // Increment counter
+  const nextNumber = typeMetadata.lastNumber + 1;
+
+  // Format: PREFIX-YYYYMM-00N (e.g., INV-202410-001)
+  const yearMonth = `${currentYear}${String(currentMonth).padStart(2, "0")}`;
+  const documentNumber = `${typeMetadata.prefix}-${yearMonth}-${String(nextNumber).padStart(3, "0")}`;
+
+  return documentNumber;
+}
+
+/**
+ * Update metadata after successful document generation
+ */
+export async function incrementDocumentCounter(
+  type: "invoice" | "quotation" | "receipt",
+  documentNumber: string
+): Promise<void> {
+  const metadata = await readMetadata();
+  const typeMetadata = metadata[type];
+  const now = new Date();
+  const currentYear = now.getFullYear();
+  const currentMonth = now.getMonth() + 1; // 1-12
+
+  // Reset counter if year or month has changed
+  if (typeMetadata.year !== currentYear || typeMetadata.month !== currentMonth) {
+    typeMetadata.year = currentYear;
+    typeMetadata.month = currentMonth;
+    typeMetadata.lastNumber = 0;
+  }
+
+  // Extract number from document number (e.g., "INV-202410-005" -> 5)
+  const match = documentNumber.match(/-(\d+)$/);
+  if (match && match[1]) {
+    const number = parseInt(match[1], 10);
+    // Only update if this number is higher than current
+    if (number > typeMetadata.lastNumber) {
+      typeMetadata.lastNumber = number;
+    }
+  }
+
+  await writeMetadata(metadata);
+}
+
+/**
+ * Initialize metadata file if it doesn't exist
+ */
+export async function initMetadata(): Promise<void> {
+  if (!(await fileExists(METADATA_PATH))) {
+    const defaultMetadata = getDefaultMetadata();
+    await writeMetadata(defaultMetadata);
+    console.log("✓ Created .metadata.json with default values");
+  } else {
+    console.log("✓ .metadata.json already exists");
+  }
+}
+
+/**
+ * Reset counter for a specific document type
+ */
+export async function resetCounter(
+  type: "invoice" | "quotation" | "receipt"
+): Promise<void> {
+  const metadata = await readMetadata();
+  const now = new Date();
+  const currentYear = now.getFullYear();
+  const currentMonth = now.getMonth() + 1; // 1-12
+
+  metadata[type].lastNumber = 0;
+  metadata[type].year = currentYear;
+  metadata[type].month = currentMonth;
+
+  await writeMetadata(metadata);
+  console.log(`✓ Reset ${type} counter to 0 for ${currentYear}-${String(currentMonth).padStart(2, "0")}`);
+}

package/src/utils.ts

@@ -0,0 +1,110 @@
+/**
+ * Utility functions for invoice generation
+ */
+
+export interface LineItem {
+  description: string;
+  quantity: number;
+  unit: string;
+  unitPrice: number;
+}
+
+export interface CalculationResult {
+  subtotal: number;
+  taxAmount: number;
+  total: number;
+}
+
+/**
+ * Calculate subtotal, tax, and total from line items
+ */
+export function calculateTotals(
+  items: LineItem[],
+  taxRate: number,
+  taxType: "withholding" | "vat"
+): CalculationResult {
+  const subtotal = items.reduce(
+    (sum, item) => sum + item.quantity * item.unitPrice,
+    0
+  );
+
+  const taxAmount = subtotal * taxRate;
+
+  let total: number;
+  if (taxType === "withholding") {
+    // Withholding tax is deducted from subtotal
+    total = subtotal - taxAmount;
+  } else {
+    // VAT is added to subtotal
+    total = subtotal + taxAmount;
+  }
+
+  return {
+    subtotal,
+    taxAmount,
+    total,
+  };
+}
+
+/**
+ * Format number with Thai thousand separators
+ */
+export function formatNumber(num: number, decimals: number = 2): string {
+  return num.toFixed(decimals).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+
+/**
+ * Convert Gregorian date to Buddhist Era (BE) format
+ */
+export function formatDateThai(dateString: string): string {
+  const date = new Date(dateString);
+
+  const thaiMonths = [
+    "มกราคม", "กุมภาพันธ์", "มีนาคม", "เมษายน",
+    "พฤษภาคม", "มิถุนายน", "กรกฎาคม", "สิงหาคม",
+    "กันยายน", "ตุลาคม", "พฤศจิกายน", "ธันวาคม"
+  ];
+
+  const day = date.getDate();
+  const month = thaiMonths[date.getMonth()];
+  const yearBE = date.getFullYear() + 543; // Convert to Buddhist Era
+
+  return `${day} ${month} ${yearBE}`;
+}
+
+/**
+ * Validate file path exists
+ */
+export async function fileExists(path: string): Promise<boolean> {
+  try {
+    const file = Bun.file(path);
+    return await file.exists();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Read and parse JSON file
+ */
+export async function readJSON<T>(path: string): Promise<T> {
+  const file = Bun.file(path);
+  return await file.json();
+}
+
+/**
+ * Get output file path
+ */
+export function getOutputPath(
+  type: string,
+  documentNumber: string,
+  customOutput?: string
+): string {
+  if (customOutput) {
+    return customOutput;
+  }
+
+  // Default: output/{type}-{number}.pdf
+  const filename = `${type}-${documentNumber}.pdf`;
+  return `output/${filename}`;
+}