ledger-converter-tui.ts

#!/usr/bin/env bun
/**
 * ledger-converter-tui.ts - Interactive TUI for Ledger Conversion
 *
 * Zero-dependency interactive terminal interface for converting QIF/CSV files
 * to Ledger format. Uses only built-in Bun/Node APIs.
 *
 * Features:
 * - Arrow key navigation for option selection
 * - Sample files as default input (examples/sample.qif, examples/sample.csv)
 * - Transaction preview before final output
 * - Back navigation (press 'b' or Escape)
 * - Output to stdout or save to file
 *
 * Usage:
 *   bun ledger-converter-tui.ts
 *
 * Build:
 *   bun build --compile --outfile=ledger-converter-tui ledger-converter-tui.ts
 */

import {
  colors,
  colorize,
  printHeader,
  printInfo,
  printSuccess,
  printError,
  printWarning,
  printBox,
  promptText,
  promptSelect,
  promptConfirm,
  isBack,
  createSpinner,
} from "./cli/tui";

import { parseQIF } from "./utils/qif_parser";
import { parseCSV } from "./utils/csv_parser";
import {
  qif2ledger,
  csv2ledger,
  formatLedgerTransaction,
  type LedgerTransaction,
} from "./utils/ledger_converter";

// ============================================================================
// Types
// ============================================================================

type InputFormat = "qif" | "csv";
type OutputDestination = "stdout" | "file";

interface ConversionState {
  format?: InputFormat;
  inputFile?: string;
  assetAccount?: string;
  outputDestination?: OutputDestination;
  outputFile?: string;
}

// ============================================================================
// File Utilities
// ============================================================================

async function fileExists(path: string): Promise<boolean> {
  try {
    await Bun.file(path).text();
    return true;
  } catch {
    return false;
  }
}

async function readFile(path: string): Promise<string> {
  return await Bun.file(path).text();
}

async function writeFile(path: string, content: string): Promise<void> {
  await Bun.write(path, content);
}

// ============================================================================
// Conversion Functions
// ============================================================================

function parseTransactions(
  content: string,
  format: InputFormat,
  assetAccount: string
): LedgerTransaction[] {
  const transactions: LedgerTransaction[] = [];

  if (format === "qif") {
    for (const qifTx of parseQIF(content)) {
      transactions.push(qif2ledger(qifTx, assetAccount));
    }
  } else {
    for (const csvTx of parseCSV(content)) {
      transactions.push(csv2ledger(csvTx, assetAccount));
    }
  }

  return transactions;
}

function formatAllTransactions(transactions: LedgerTransaction[]): string {
  return transactions.map(formatLedgerTransaction).join("\n");
}

// ============================================================================
// Preview Functions
// ============================================================================

function previewTransactions(
  transactions: LedgerTransaction[],
  count: number = 3
): void {
  const previewCount = Math.min(count, transactions.length);

  console.log();
  printInfo(`Preview of first ${previewCount} transaction(s):`);
  console.log();

  for (let i = 0; i < previewCount; i++) {
    const formatted = formatLedgerTransaction(transactions[i]);
    const lines = formatted.split("\n").filter((l) => l.trim());

    for (const line of lines) {
      if (line.match(/^\d{4}\/\d{2}\/\d{2}/)) {
        // Date line - highlight
        console.log(colorize(line, colors.cyan, colors.bold));
      } else if (line.startsWith("    ;")) {
        // Memo line
        console.log(colorize(line, colors.dim));
      } else if (line.includes("$")) {
        // Amount line - highlight the amount
        const [account, ...rest] = line.split("$");
        console.log(account + colorize("$" + rest.join("$"), colors.green));
      } else {
        console.log(line);
      }
    }
    console.log();
  }

  if (transactions.length > previewCount) {
    printInfo(`... and ${transactions.length - previewCount} more transaction(s)`);
    console.log();
  }
}

// ============================================================================
// Interactive Flow
// ============================================================================

async function selectFormat(): Promise<InputFormat | "back"> {
  const result = await promptSelect<InputFormat>("Select input format:", [
    { label: "QIF (Quicken Interchange Format)", value: "qif" },
    { label: "CSV (Comma-Separated Values)", value: "csv" },
  ]);

  if (isBack(result)) return "back";
  return result.value;
}

async function getInputFile(format: InputFormat): Promise<string | "back"> {
  const extension = format === "qif" ? ".qif" : ".csv";
  const defaultFile = format === "qif" ? "examples/sample.qif" : "examples/sample.csv";

  while (true) {
    const result = await promptText(`Enter path to ${format.toUpperCase()} file:`, defaultFile);

    if (isBack(result)) return "back";

    const path = result.value;

    if (!path) {
      printError("File path cannot be empty");
      continue;
    }

    // Expand home directory
    const expandedPath = path.startsWith("~")
      ? path.replace("~", process.env.HOME || "")
      : path;

    if (!(await fileExists(expandedPath))) {
      printError(`File not found: ${expandedPath}`);
      continue;
    }

    // Warn if extension doesn't match
    if (!expandedPath.toLowerCase().endsWith(extension)) {
      printWarning(`File doesn't have ${extension} extension, but will try to parse anyway`);
    }

    return expandedPath;
  }
}

async function getAssetAccount(): Promise<string | "back"> {
  while (true) {
    const result = await promptText(
      "Enter asset account name:",
      "Assets:Checking"
    );

    if (isBack(result)) return "back";

    const account = result.value;

    if (!account) {
      printError("Account name cannot be empty");
      continue;
    }

    return account;
  }
}

async function selectOutputDestination(): Promise<OutputDestination | "back"> {
  const result = await promptSelect<OutputDestination>("Output to:", [
    { label: "Terminal (stdout)", value: "stdout" },
    { label: "File", value: "file" },
  ]);

  if (isBack(result)) return "back";
  return result.value;
}

async function getOutputFile(): Promise<string | "back"> {
  while (true) {
    const result = await promptText("Enter output file path:");

    if (isBack(result)) return "back";

    const path = result.value;

    if (!path) {
      printError("File path cannot be empty");
      continue;
    }

    // Expand home directory
    const expandedPath = path.startsWith("~")
      ? path.replace("~", process.env.HOME || "")
      : path;

    // Check if file exists and confirm overwrite
    if (await fileExists(expandedPath)) {
      const confirmResult = await promptConfirm(
        `File ${expandedPath} already exists. Overwrite?`,
        false
      );

      if (isBack(confirmResult)) return "back";
      if (!confirmResult.value) continue;
    }

    return expandedPath;
  }
}

// ============================================================================
// Main Flow (with back navigation)
// ============================================================================

async function main(): Promise<void> {
  console.log();
  printHeader("Ledger Converter");
  console.log();
  printInfo("Convert QIF or CSV files to Ledger-CLI format");
  printInfo("Press 'b' or Escape at any prompt to go back");
  console.log();

  const state: ConversionState = {};

  // Step 1: Select format
  step1: while (true) {
    const format = await selectFormat();
    if (format === "back") {
      printInfo("Already at the beginning. Press Ctrl+C to exit.");
      continue;
    }
    state.format = format;

    // Step 2: Get input file
    step2: while (true) {
      const inputFile = await getInputFile(state.format!);
      if (inputFile === "back") {
        continue step1; // Go back to format selection
      }
      state.inputFile = inputFile;

      // Step 3: Get asset account
      step3: while (true) {
        const assetAccount = await getAssetAccount();
        if (assetAccount === "back") {
          continue step2; // Go back to file selection
        }
        state.assetAccount = assetAccount;

        // Parse and preview
        console.log();
        const spinner = createSpinner("Parsing transactions...");

        let content: string;
        let transactions: LedgerTransaction[];

        try {
          content = await readFile(state.inputFile!);
          transactions = parseTransactions(
            content,
            state.format!,
            state.assetAccount!
          );
          spinner.stop(`Parsed ${transactions.length} transaction(s)`);
        } catch (error) {
          spinner.stop();
          printError(`Failed to parse file: ${error instanceof Error ? error.message : error}`);
          continue step2; // Go back to file selection
        }

        if (transactions.length === 0) {
          printWarning("No transactions found in file");
          continue step2;
        }

        // Preview transactions
        previewTransactions(transactions, 3);

        // Step 4: Confirm and select output
        step4: while (true) {
          const confirmResult = await promptConfirm("Proceed with conversion?", true);
          if (isBack(confirmResult)) {
            continue step3; // Go back to asset account
          }
          if (!confirmResult.value) {
            printInfo("Conversion cancelled");
            process.exit(0);
          }

          // Step 5: Select output destination
          step5: while (true) {
            const outputDest = await selectOutputDestination();
            if (outputDest === "back") {
              continue step4; // Go back to confirmation
            }
            state.outputDestination = outputDest;

            if (state.outputDestination === "file") {
              // Step 6: Get output file
              step6: while (true) {
                const outputFile = await getOutputFile();
                if (outputFile === "back") {
                  continue step5; // Go back to output destination
                }
                state.outputFile = outputFile;

                // Write to file
                console.log();
                const writeSpinner = createSpinner("Writing output file...");

                try {
                  const output = formatAllTransactions(transactions);
                  await writeFile(state.outputFile!, output);
                  writeSpinner.stop(`Saved to ${state.outputFile}`);
                } catch (error) {
                  writeSpinner.stop();
                  printError(
                    `Failed to write file: ${error instanceof Error ? error.message : error}`
                  );
                  continue step6;
                }

                // Done!
                console.log();
                printSuccess("Conversion complete!");
                console.log();
                printBox([
                  `Input:  ${state.inputFile}`,
                  `Format: ${state.format?.toUpperCase()}`,
                  `Output: ${state.outputFile}`,
                  `Transactions: ${transactions.length}`,
                ], "Summary");
                console.log();
                return;
              }
            } else {
              // Output to stdout
              console.log();
              console.log(colorize("─".repeat(60), colors.dim));
              console.log(formatAllTransactions(transactions));
              console.log(colorize("─".repeat(60), colors.dim));
              console.log();

              printSuccess("Conversion complete!");
              console.log();
              return;
            }
          }
        }
      }
    }
  }
}

// ============================================================================
// Entry Point
// ============================================================================

main().catch((error) => {
  printError(`Fatal error: ${error instanceof Error ? error.message : error}`);
  process.exit(1);
});