Add export subcommands and fix PDF layout

Export subcommands (export pdf, export json, export csv, export excel, export map):
- Wire up subcommands in cli.ts to call new cmdExport handler
- Create src/cli/commands/export.ts for single-format export
- Use outputDir default (./chat-to-map/output/) instead of hardcoded paths
- Export buildPdfConfig from steps/export.ts to avoid duplication

PDF layout fixes:
- Fix heading colors (reset to #000000 after gray activity details)
- Add divider lines between country sections with proper spacing
- Fix thumbnail layout breaking heading indentation (reset doc.x = 50)
- Add proper spacing for flat list and country-only grouping modes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ndbroadbent

src/cli.ts

@@ -13,6 +13,7 @@ import { cmdAnalyze } from './cli/commands/analyze'
 import { cmdClassify } from './cli/commands/classify'
 import { cmdConfig } from './cli/commands/config'
 import { cmdEmbed } from './cli/commands/embed'
+import { cmdExport } from './cli/commands/export'
 import { cmdFetchImageUrls } from './cli/commands/fetch-image-urls'
 import { cmdFetchImages } from './cli/commands/fetch-images'
 import { cmdFilter } from './cli/commands/filter'
@@ -31,9 +32,18 @@ async function main(): Promise<void> {
   try {
     switch (args.command) {
       case 'analyze':
+      case 'export':
         await cmdAnalyze(args, logger)
         break
 
+      case 'export-pdf':
+      case 'export-json':
+      case 'export-csv':
+      case 'export-excel':
+      case 'export-map':
+        await cmdExport(args, logger)
+        break
+
       case 'parse':
         await cmdParse(args, logger)
         break

src/cli/commands.ts

@@ -133,7 +133,7 @@ function addExportCommand(program: Command): void {
       .command('pdf')
       .description('Export activities to PDF')
       .argument('<input>', 'Chat export (.zip, directory, or .txt file)')
-      .option('-o, --output <file>', 'Output file path', './output/activities.pdf')
+      .option('-o, --output <file>', 'Output file path')
   )
     .option('--thumbnails', 'Include thumbnails in PDF')
     .option('--include-score', 'Show score in PDF output')
@@ -151,7 +151,7 @@ function addExportCommand(program: Command): void {
       .command('json')
       .description('Export activities to JSON')
       .argument('<input>', 'Chat export (.zip, directory, or .txt file)')
-      .option('-o, --output <file>', 'Output file path', './output/activities.json')
+      .option('-o, --output <file>', 'Output file path')
   )
 
   // export csv
@@ -160,7 +160,7 @@ function addExportCommand(program: Command): void {
       .command('csv')
       .description('Export activities to CSV')
       .argument('<input>', 'Chat export (.zip, directory, or .txt file)')
-      .option('-o, --output <file>', 'Output file path', './output/activities.csv')
+      .option('-o, --output <file>', 'Output file path')
   )
 
   // export excel
@@ -169,7 +169,7 @@ function addExportCommand(program: Command): void {
       .command('excel')
       .description('Export activities to Excel')
       .argument('<input>', 'Chat export (.zip, directory, or .txt file)')
-      .option('-o, --output <file>', 'Output file path', './output/activities.xlsx')
+      .option('-o, --output <file>', 'Output file path')
   )
 
   // export map - with map-specific options
@@ -178,7 +178,7 @@ function addExportCommand(program: Command): void {
       .command('map')
       .description('Export activities to interactive HTML map')
       .argument('<input>', 'Chat export (.zip, directory, or .txt file)')
-      .option('-o, --output <file>', 'Output file path', './output/map.html')
+      .option('-o, --output <file>', 'Output file path')
   ).option('--default-style <style>', 'Default map tile style (e.g. osm, satellite, terrain)')
 }
 

src/cli/commands/export.ts

@@ -0,0 +1,140 @@
+/**
+ * Export Command
+ *
+ * Runs the full pipeline and exports to a single format.
+ * Used by: export pdf, export json, export csv, export excel, export map
+ */
+
+import { writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import {
+  exportToCSV,
+  exportToExcel,
+  exportToJSON,
+  exportToMapHTML,
+  exportToPDF,
+  filterActivitiesForExport,
+  VERSION
+} from '../../index'
+import type { GeocodedActivity } from '../../types'
+import type { CLIArgs } from '../args'
+import { buildFilterOptions } from '../filter-options'
+import { initCommandContext } from '../helpers'
+import { ensureDir } from '../io'
+import type { Logger } from '../logger'
+import { buildPdfConfig } from '../steps/export'
+import { StepRunner } from '../steps/runner'
+
+function getDefaultFilename(format: string): string {
+  switch (format) {
+    case 'pdf':
+      return 'activities.pdf'
+    case 'json':
+      return 'activities.json'
+    case 'csv':
+      return 'activities.csv'
+    case 'excel':
+      return 'activities.xlsx'
+    case 'map':
+      return 'map.html'
+    default:
+      return `activities.${format}`
+  }
+}
+
+export async function cmdExport(args: CLIArgs, logger: Logger): Promise<void> {
+  const format = args.exportFormat
+  if (!format) {
+    logger.error('No export format specified')
+    process.exit(1)
+  }
+
+  const { ctx, config } = await initCommandContext(`Export ${format.toUpperCase()}`, args, logger)
+
+  const runner = new StepRunner(ctx, args, config, logger)
+
+  // Run pipeline through fetch-images to get thumbnails for PDF
+  const needsThumbnails = format === 'pdf' && args.pdfThumbnails
+  let thumbnails: Map<string, Buffer> | undefined
+
+  let geocoded: readonly GeocodedActivity[]
+
+  if (needsThumbnails) {
+    const result = await runner.run('fetchImages')
+    thumbnails = result.thumbnails
+    // Get geocoded activities from the runner
+    const geocodeResult = await runner.run('geocode')
+    geocoded = geocodeResult.activities
+  } else {
+    // Just run through geocode step
+    const result = await runner.run('geocode')
+    geocoded = result.activities
+  }
+
+  if (geocoded.length === 0) {
+    logger.error('No activities to export')
+    process.exit(1)
+  }
+
+  // Build filter options for this format
+  const filterOptions = buildFilterOptions(
+    format as 'pdf' | 'json' | 'csv' | 'excel' | 'map',
+    args,
+    config
+  )
+  const filtered = filterActivitiesForExport(geocoded, filterOptions)
+
+  if (filtered.length === 0) {
+    logger.log('⚠️  No activities match the filter criteria')
+  }
+
+  // Determine output path (use --output if provided, otherwise outputDir + default filename)
+  const outputPath = args.exportOutput ?? join(args.outputDir, getDefaultFilename(format))
+
+  // Ensure output directory exists
+  await ensureDir(dirname(outputPath))
+
+  // Export based on format
+  switch (format) {
+    case 'pdf': {
+      const pdfConfig = buildPdfConfig(args, config, args.input, thumbnails)
+      const pdfData = await exportToPDF(filtered, pdfConfig)
+      await writeFile(outputPath, pdfData)
+      logger.success(`Exported ${filtered.length} activities to ${outputPath}`)
+      break
+    }
+
+    case 'json': {
+      const metadata = { inputFile: args.input, messageCount: 0, version: VERSION }
+      const json = exportToJSON(filtered, metadata)
+      await writeFile(outputPath, json)
+      logger.success(`Exported ${filtered.length} activities to ${outputPath}`)
+      break
+    }
+
+    case 'csv': {
+      const csv = exportToCSV(filtered)
+      await writeFile(outputPath, csv)
+      logger.success(`Exported ${filtered.length} activities to ${outputPath}`)
+      break
+    }
+
+    case 'excel': {
+      const excel = await exportToExcel(filtered)
+      await writeFile(outputPath, excel)
+      logger.success(`Exported ${filtered.length} activities to ${outputPath}`)
+      break
+    }
+
+    case 'map': {
+      const html = exportToMapHTML(filtered, { title: 'Things To Do' })
+      await writeFile(outputPath, html)
+      logger.success(`Exported ${filtered.length} activities to ${outputPath}`)
+      break
+    }
+
+    default:
+      logger.error(`Unknown export format: ${format}`)
+      process.exit(1)
+  }
+}

src/cli/steps/export.ts

@@ -41,7 +41,7 @@ interface ExportOptions {
  * Build PDFConfig from CLI args and config.
  * Filtering is handled separately by buildFilterOptions.
  */
-function buildPdfConfig(
+export function buildPdfConfig(
   args: CLIArgs,
   config: Config | null,
   inputFile: string,

src/export/pdf.ts

@@ -52,7 +52,7 @@ function groupByCountry(activities: readonly GeocodedActivity[]): Map<string, Ge
   const groups = new Map<string, GeocodedActivity[]>()
 
   for (const a of activities) {
-    const country = a.country ?? 'Unknown'
+    const country = a.country ?? 'General'
     const existing = groups.get(country) ?? []
     existing.push(a)
     groups.set(country, existing)
@@ -250,6 +250,7 @@ function renderFlatList(
   config: PDFConfig,
   renderOptions: RenderOptions
 ): void {
+  doc.moveDown(2)
   renderActivityList(doc, activities, config, renderOptions, 'score')
 }
 
@@ -267,9 +268,11 @@ function renderCategorySection(
   if (doc.y > 700) doc.addPage()
 
   doc.moveDown(options.moveDown)
+  doc.x = 50 // Reset to left margin (thumbnails shift X position)
   doc
     .fontSize(options.fontSize)
     .font('Helvetica-Bold')
+    .fillColor('#000000')
     .text(`${CATEGORY_NAMES[category]} (${items.length})`)
   doc.moveDown(0.5)
 
@@ -299,49 +302,61 @@ function renderGroupedByCategory(
 }
 
 /**
- * Render activities grouped by country only.
+ * Render a horizontal divider line.
  */
-function renderGroupedByCountry(
+function renderDivider(doc: PDFKit.PDFDocument): void {
+  const y = doc.y + 32
+  doc.strokeColor('#cccccc').lineWidth(0.5).moveTo(50, y).lineTo(545, y).stroke()
+  doc.y = y + 8
+}
+
+/**
+ * Render a country section with heading and divider.
+ */
+function renderCountrySection(
   doc: PDFKit.PDFDocument,
-  activities: readonly GeocodedActivity[],
-  config: PDFConfig,
-  renderOptions: RenderOptions
+  country: string,
+  items: readonly GeocodedActivity[],
+  _config: PDFConfig,
+  _renderOptions: RenderOptions,
+  options: { fontSize: number; renderContent: () => void }
 ): void {
-  const grouped = groupByCountry(activities)
-  const countries = [...grouped.keys()].sort()
+  if (doc.y > 680) doc.addPage()
 
-  for (const country of countries) {
-    const items = grouped.get(country)
-    if (!items || items.length === 0) continue
+  renderDivider(doc)
 
-    if (doc.y > 700) doc.addPage()
-
-    doc.moveDown(1.5)
-    doc.fontSize(16).font('Helvetica-Bold').text(`${country} (${items.length})`)
-    doc.moveDown(0.5)
+  doc.moveDown(0.5)
+  doc.x = 50 // Reset to left margin (thumbnails shift X position)
+  doc
+    .fontSize(options.fontSize)
+    .font('Helvetica-Bold')
+    .fillColor('#000000')
+    .text(`${country} (${items.length})`)
 
-    renderActivityList(doc, items, config, renderOptions, 'score')
-  }
+  options.renderContent()
 }
 
 /**
- * Render categories within a country section.
+ * Render activities grouped by country only.
  */
-function renderCategoriesInCountry(
+function renderGroupedByCountry(
   doc: PDFKit.PDFDocument,
-  countryItems: readonly GeocodedActivity[],
+  activities: readonly GeocodedActivity[],
   config: PDFConfig,
   renderOptions: RenderOptions
 ): void {
-  const byCategory = groupByCategory(countryItems)
+  const grouped = groupByCountry(activities)
 
-  for (const category of VALID_CATEGORIES) {
-    const items = byCategory.get(category)
+  for (const country of [...grouped.keys()].sort()) {
+    const items = grouped.get(country)
     if (!items || items.length === 0) continue
 
-    renderCategorySection(doc, category, items, config, renderOptions, {
-      moveDown: 1,
-      fontSize: 14
+    renderCountrySection(doc, country, items, config, renderOptions, {
+      fontSize: 16,
+      renderContent: () => {
+        doc.moveDown(0.5)
+        renderActivityList(doc, items, config, renderOptions, 'score')
+      }
     })
   }
 }
@@ -356,18 +371,27 @@ function renderGroupedByCountryAndCategory(
   renderOptions: RenderOptions
 ): void {
   const byCountry = groupByCountry(activities)
-  const countries = [...byCountry.keys()].sort()
 
-  for (const country of countries) {
+  for (const country of [...byCountry.keys()].sort()) {
     const countryItems = byCountry.get(country)
     if (!countryItems || countryItems.length === 0) continue
 
-    if (doc.y > 680) doc.addPage()
+    const byCategory = groupByCategory(countryItems)
 
-    doc.moveDown(1.5)
-    doc.fontSize(18).font('Helvetica-Bold').text(`${country} (${countryItems.length})`)
+    renderCountrySection(doc, country, countryItems, config, renderOptions, {
+      fontSize: 18,
+      renderContent: () => {
+        for (const category of VALID_CATEGORIES) {
+          const items = byCategory.get(category)
+          if (!items || items.length === 0) continue
 
-    renderCategoriesInCountry(doc, countryItems, config, renderOptions)
+          renderCategorySection(doc, category, items, config, renderOptions, {
+            moveDown: 1,
+            fontSize: 14
+          })
+        }
+      }
+    })
   }
 }