klio 1.4.9 → 1.5.1

package/src/cli/cliService.js

@@ -0,0 +1,1197 @@
+// CLI Service - Modular version of CLI functionality that can be imported
+// This allows the GUI to run commands without spawning child processes
+
+const { Command } = require('commander');
+const { planets, signs } = require('../astrology/astrologyConstants');
+const { showRetrogradePlanets } = require('../astrology/retrogradeService');
+const { getCurrentTimeInTimezone, showAspectFigures, analyzeElementDistribution, getTimezoneOffset, calculateJulianDayUTC, calculateHouses, getAstrologicalData, getPlanetHouse, showPlanetAspects, calculatePlanetAspects, getAllActiveAspects, showAllActiveAspects, getBirthDataFromConfig, getPersonDataFromConfig, detectAspectFigures, calculatePersonalTransits, showPersonalTransitAspects, showCombinedAnalysis, calculatePersonalTransitAspects, determineAspectPhase, getAspectAngle, getFutureAspects, getPastAspects, analyzeCSVWithDatetime, analyzeHouseDistributionSignificance, analyzeAspectDistributionSignificance, analyzeSignDistributionSignificance, calculateAspectStatistics, calculatePlanetComboAspects, showPlanetComboAspects, getCriticalPlanets, getHouseSystemCode, calculateNextPlanetIngress, calculateAstrologicalAngles, longitudeToSignDegree, calculateTransitFrequency } = require('../astrology/astrologyService');
+const { performSetup, showConfigStatus, loadConfig, setAIModel, askAIModel, setPerson1, setPerson2, setPerson, getPersonData, listPeople, deletePerson } = require('../config/configService');
+const { parseAppleHealthXML } = require('../health/healthService');
+const { analyzeStepsByPlanetSign, analyzeStressByPlanetAspects, analyzePlanetAspectsForSleep, analyzeLateNightAspects, analyzeAllNighterAspects } = require('../health/healthAnalysis');
+const { getFileCreationDate, parseDateToComponents } = require('../utils/fileUtils');
+const path = require('path');
+const fs = require('fs');
+
+// Import chart generation and downloads folder utilities
+let chartGenerator = null;
+let downloadsFolder = null;
+try {
+  chartGenerator = require('../utils/chartGenerator');
+  downloadsFolder = require('../utils/downloadsFolder');
+} catch (error) {
+  console.debug('Chart generation utilities not available');
+}
+
+// Wikidata service import
+let wikidataService = null;
+try {
+  wikidataService = require('../wikidata/wikidataService');
+} catch (error) {
+  // Wikidata service not available
+  console.debug('Wikidata service not available');
+}
+
+function getAspectTypeFullName(aspectType) {
+  const aspectNames = {
+    c: 'Conjunctions',
+    conjunction: 'Conjunctions',
+    o: 'Oppositions',
+    opposition: 'Oppositions',
+    s: 'Squares',
+    square: 'Squares',
+    t: 'Trines',
+    trine: 'Trines',
+    se: 'Sextiles',
+    sextile: 'Sextiles'
+  };
+
+  const key = aspectType ? aspectType.toLowerCase() : '';
+  return aspectNames[key] || aspectType;
+}
+
+function splitCommandArgs(commandString) {
+  const args = [];
+  let current = '';
+  let quoteChar = null;
+  let escaped = false;
+
+  for (let i = 0; i < commandString.length; i++) {
+    const char = commandString[i];
+
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === '\\') {
+      escaped = true;
+      continue;
+    }
+
+    if (quoteChar) {
+      if (char === quoteChar) {
+        quoteChar = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      quoteChar = char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (current.length) {
+        args.push(current);
+        current = '';
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current.length) {
+    args.push(current);
+  }
+
+  return args;
+}
+
+class CLIService {
+  constructor() {
+    this.program = new Command();
+    this.setupProgram();
+  }
+
+  setupProgram() {
+    this.program
+      .name('klio')
+      .description('A simple CLI for astrological data')
+      .version('1.0.0');
+
+    this.program
+      .argument('[planet]', 'First planet for astrological calculations')
+      .argument('[planet2]', 'Second planet for aspect calculations')
+      .allowExcessArguments(true)
+      .option('--hs <system>', 'House system (Placidus, Koch, Porphyry, Regiomontanus, Campanus, Equal, WholeSign, Gauquelin, Vehlow, Topocentric, Alcabitius, Morinus) - shows planet + house position')
+      .option('--hl <system>', 'House list (Placidus, Koch, Porphyry, Regiomontanus, Campanus, Equal, WholeSign, Gauquelin, Vehlow, Topocentric, Alcabitius, Morinus) - shows only house table')
+      .option('--d <date>', 'Use a specific date for calculations (Format: DD.MM.YYYY or "DD.MM.YYYY HH:MM")')
+      .option('--a', 'Shows all aspects of the planet')
+      .option('--k', 'Shows aspects between any planet combinations')
+      .option('--s', 'Shows all planet positions in a table with signs, degrees and houses')
+      .option('--apple <filepath>', 'Analyzes Apple Health Export XML file')
+      .option('--hypothesis <type>', 'Specifies the hypothesis to test (e.g. "sleep-moon", "steps-moon", "stress-moon")')
+      .option('--sleep', 'Analyzes sleep patterns with moon aspects')
+      .option('--steps', 'Analyzes step patterns with moon signs')
+      .option('--stress', 'Analyzes stress patterns with moon aspects based on HRV')
+      .option('--night', 'Analyzes late night sleep patterns (after 2am) and common aspects')
+      .option('--night-all', 'Analyzes all-nighter sleep patterns (04:00 and 06:00 starts)')
+      .option('--setup', 'Configures location and birth data for personalized calculations')
+      .option('--ai <model>', 'Sets a specific AI model (e.g. "google/gemma-3n-e4b")')
+      .option('--system <prompt>', 'Sets a custom system prompt for all AI requests')
+      .option('--rx', 'Shows all retrograde or stationary planets')
+      .option('--c', 'Shows all planets on critical degrees')
+      .option('--status', 'Shows the stored configuration data')
+      .option('--i', 'Uses the birth data from setup for calculations (short form)')
+      .option('--p1', 'Uses the data from person 1 for calculations')
+      .option('--p2', 'Uses the data from person 2 for calculations')
+      .option('--p3', 'Uses the data from person 3 for calculations')
+      .option('--p4', 'Uses the data from person 4 for calculations')
+      .option('--p5', 'Uses the data from person 5 for calculations')
+      .option('--p6', 'Uses the data from person 6 for calculations')
+      .option('--with-person <id>', 'Uses the data from a specific person ID for calculations')
+      .option('--wp <id>', 'Uses the data from a specific person ID for calculations (short form)')
+      .option('--up <id>', 'Uses the data from a specific person ID for calculations (short form)')
+      .option('--person1 <data>', 'Creates or updates person 1 (Format: "Location, Country, DD.MM.YYYY HH:MM")')
+      .option('--person2 <data>', 'Creates or updates person 2 (Format: "Location, Country, DD.MM.YYYY HH:MM")')
+      .option('--person <id> <data>', 'Creates or updates any person (Format: "Location, Country, DD.MM.YYYY HH:MM")')
+      .option('--people', 'Lists all saved persons')
+      .option('--delete-person <id>', 'Deletes a person')
+      .option('--t <days>', 'Time limit (e.g. 7d, 30d, 90d, 14d)')
+      .option('--p <prompt>', 'Asks a question to the AI model (e.g. "Which careers suit this position?")')
+      .option('--el', 'Shows the element distribution of planets in a horizontal chart')
+      .option('--af', 'Shows active aspect figures like T-squares, Grand Trines, etc.')
+      .option('--tra', 'Shows personal transits based on birth data')
+      .option('--tr', 'Shows personal transit aspects (Transit → Radix) (short form)')
+      .option('--v <count>', 'Shows past aspects between two planets (Format: --v <count> planet1 aspectType planet2)')
+      .option('--z <count>', 'Shows future aspects between two planets (Format: --z <count> planet1 aspectType planet2)')
+      .option('--csv <filepath>', 'Analyzes a CSV file with ISO-Datetime values or Unix timestamps')
+      .option('--filter <column:value>', 'Filters CSV data by column:value (e.g., --filter "Item:coffee")')
+      .option('--title <title>', 'Title for the chart image (generates PNG image when provided)')
+      .option('--in [count]', 'Shows next planet ingress (entering new sign). Optional count for multiple ingresses')
+      .option('--wiki <occupation>', 'Fetches people from Wikidata by occupation and checks for specific aspects (Format: planet1 aspectType planet2 --wiki <occupation> [limit])')
+      .option('--gui', 'Launches the web interface for command history (port 37421)')
+      .option('--gui-port <port>', 'Specify custom port for GUI server')
+      .option('--o', 'Shows how often this transit occurs in the sky (frequency calculation)')
+      .description('Shows astrological data for a planet')
+      .action(this.handleCommand.bind(this));
+  }
+
+  // Helper function to check if person data should be used (including new options)
+  shouldUsePersonData(options) {
+    return options.i || options.p1 || options.p2 || options.withPerson || options.wp || options.up;
+  }
+
+  // Helper function to determine which person data should be used
+  getPersonDataToUse(options) {
+    const userId = options._userId;
+    
+    // Check for direct person ID usage (e.g., --with-person john or --wp john or --up john)
+    if (options.withPerson) {
+      const personData = getPersonDataFromConfig(options.withPerson, userId);
+      if (!personData) {
+        throw new Error(`Person "${options.withPerson}" not found.`);
+      }
+      return { source: options.withPerson, data: personData };
+    }
+    if (options.wp) {
+      const personData = getPersonDataFromConfig(options.wp, userId);
+      if (!personData) {
+        throw new Error(`Person "${options.wp}" not found.`);
+      }
+      return { source: options.wp, data: personData };
+    }
+    if (options.up) {
+      const personData = getPersonDataFromConfig(options.up, userId);
+      if (!personData) {
+        throw new Error(`Person "${options.up}" not found.`);
+      }
+      return { source: options.up, data: personData };
+    }
+    
+    // Dynamic person names (e.g., --p3, --p4, etc.)
+    for (const [key, value] of Object.entries(options)) {
+      if (key.startsWith('p') && key.length > 1 && !isNaN(key.substring(1))) {
+        const personId = key.substring(1); // Extract the number
+        return { source: key, data: getPersonDataFromConfig(personId, userId) };
+      }
+    }
+    
+    if (options.p1) {
+      return { source: 'p1', data: getPersonDataFromConfig('p1', userId) };
+    } else if (options.p2) {
+      return { source: 'p2', data: getPersonDataFromConfig('p2', userId) };
+    } else if (options.p3) {
+      return { source: 'p3', data: getPersonDataFromConfig('p3', userId) };
+    } else if (options.p4) {
+      return { source: 'p4', data: getPersonDataFromConfig('p4', userId) };
+    } else if (options.p5) {
+      return { source: 'p5', data: getPersonDataFromConfig('p5', userId) };
+    } else if (options.p6) {
+      return { source: 'p6', data: getPersonDataFromConfig('p6', userId) };
+    } else if (options.i) {
+      return { source: 'birth', data: getPersonDataFromConfig('birth', userId) };
+    }
+    return { source: null, data: null };
+  }
+
+  // Helper function to check if birth data should be used (for backward compatibility only)
+  shouldUseBirthData(options) {
+    return options.i;
+  }
+
+  // Function to calculate the Julian Day in UTC
+  getJulianDay(customDate = null, useBirthData = false) {
+    let timezoneOffsetMinutes = 0;
+    const config = loadConfig();
+    
+    if (customDate) {
+      // Calculate the timezone offset
+      if (useBirthData && config && config.birthData && config.birthData.location) {
+        timezoneOffsetMinutes = getTimezoneOffset(customDate, config.birthData.location.timezone || 'Europe/Zurich');
+      } else if (config && config.currentLocation && config.currentLocation.timezone) {
+        timezoneOffsetMinutes = getTimezoneOffset(customDate, config.currentLocation.timezone);
+      } else {
+        timezoneOffsetMinutes = -new Date().getTimezoneOffset();
+      }
+      
+      return calculateJulianDayUTC(customDate, timezoneOffsetMinutes);
+    } else {
+      // Use the current time in the configured timezone
+      let now;
+      let timezone = 'Europe/Zurich'; // Default
+      
+      if (config && config.currentLocation && config.currentLocation.timezone) {
+        timezone = config.currentLocation.timezone;
+        try {
+          const moment = require('moment-timezone');
+          now = moment().tz(timezone);
+          console.log(`Using timezone: ${timezone}`);
+        } catch (error) {
+          console.log('Could not load moment-timezone, using local time');
+          now = require('moment')();
+        }
+      } else {
+        now = require('moment')();
+        console.log('No timezone configuration found, using local system time');
+      }
+      
+      timezoneOffsetMinutes = now.utcOffset();
+      return calculateJulianDayUTC({
+        year: now.year(),
+        month: now.month() + 1,
+        day: now.date(),
+        hour: now.hours(),
+        minute: now.minutes()
+      }, timezoneOffsetMinutes);
+    }
+  }
+
+  // Main command handler
+  async handleCommand(planetArg, planet2Arg, options, userId = null) {
+    // If planet2Arg is an object, it contains the options (commander behavior)
+    let planet2 = typeof planet2Arg === 'string' ? planet2Arg : null;
+    // Fix: Check for null explicitly since typeof null === 'object' in JavaScript
+    let actualOptions = (typeof planet2Arg === 'object' && planet2Arg !== null) ? planet2Arg : options;
+    
+    // Ensure actualOptions is an object
+    if (!actualOptions) {
+      actualOptions = {};
+    }
+    
+    // Store userId in the options for use in config functions
+    actualOptions._userId = userId;
+
+    // Capture output for GUI use
+    const output = [];
+    const originalConsoleLog = console.log;
+    const originalConsoleError = console.error;
+    
+    // Override console methods to capture output
+    const captureOnly = process.env.KLIO_CAPTURE_ONLY === '1';
+
+    console.log = (...args) => {
+      if (!captureOnly) {
+        originalConsoleLog(...args);
+      }
+      output.push(args.join(' '));
+    };
+    
+    console.error = (...args) => {
+      if (!captureOnly) {
+        originalConsoleError(...args);
+      }
+      output.push(args.join(' '));
+    };
+    
+    try {
+      // Handle GUI launch if --gui flag is specified
+      if (options.gui) {
+        throw new Error('GUI mode cannot be launched through CLI service');
+      }
+
+      // Show critical planets if --c option is specified (no planet required)
+      if (actualOptions.c) {
+        // Use person data if --p1, --p2 or --i option is specified
+        let customDate = null;
+        let personSource = null;
+        const personDataToUse = this.getPersonDataToUse(actualOptions);
+        
+        if (personDataToUse.data) {
+          customDate = personDataToUse.data;
+          personSource = personDataToUse.source;
+          
+          if (personSource === 'p1') {
+            console.log(`Using Person 1 data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else if (personSource === 'p2') {
+            console.log(`Using Person 2 data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else if (personSource.startsWith('p')) {
+            const personId = personSource.substring(1);
+            console.log(`Using Person ${personId} data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else {
+            console.log(`Using birth data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          }
+          
+          if (customDate.location) {
+            console.log(`Location: ${customDate.location.name}, ${customDate.location.country}`);
+          }
+        }
+        
+        // Use custom date if specified (overrides person data)
+        if (actualOptions.d) {
+          // Try to parse the date as DD.MM.YYYY or DD.MM.YYYY HH:MM
+          const dateRegex = /^(\d{1,2})\.(\d{1,2})\.(\d{4})(?:\s+(\d{1,2}):(\d{2}))?$/;
+          const match = actualOptions.d.match(dateRegex);
+          
+          if (match) {
+            const day = parseInt(match[1], 10);
+            const month = parseInt(match[2], 10);
+            const year = parseInt(match[3], 10);
+            const hour = match[4] ? parseInt(match[4], 10) : 12; // Default: 12 o'clock
+            const minute = match[5] ? parseInt(match[5], 10) : 0; // Default: 0 minutes
+            
+            // Check if the date is valid
+            const date = new Date(year, month - 1, day, hour, minute);
+            if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+              customDate = {
+                day: day,
+                month: month,
+                year: year,
+                hour: hour,
+                minute: minute
+              };
+              console.log(`Using custom date: ${day}.${month}.${year} ${hour}:${minute.toString().padStart(2, '0')}`);
+            } else {
+              console.error('Invalid date:', actualOptions.d);
+              console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+              return { success: false, output: output.join('\n') };
+            }
+          } else {
+            console.error('Invalid date:', actualOptions.d);
+            console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+            return { success: false, output: output.join('\n') };
+          }
+        }
+        
+        // If no custom date is specified, use current date
+        if (!customDate) {
+          const currentTime = getCurrentTimeInTimezone();
+          customDate = {
+            day: currentTime.day,
+            month: currentTime.month,
+            year: currentTime.year,
+            hour: currentTime.hour,
+            minute: currentTime.minute
+          };
+        }
+        
+        const criticalPlanets = getCriticalPlanets(customDate);
+        
+        if (criticalPlanets.length === 0) {
+          console.log('No planets on critical degrees found.');
+          return { success: true, output: output.join('\n') };
+        }
+        
+        console.log('================================================================================================================');
+        console.log('| Planet   | Sign     | Degree  | Type               | Interpretation                                  |');
+        console.log('================================================================================================================');
+        
+        criticalPlanets.forEach(planet => {
+          const planetName = planet.name.charAt(0).toUpperCase() + planet.name.slice(1);
+          const sign = planet.sign.padEnd(10, ' ');
+          const degree = planet.degree.padEnd(5, ' ');
+          const criticalType = planet.criticalType.padEnd(20, ' ');
+          const interpretation = planet.interpretation.padEnd(46, ' ');
+          console.log(`| ${planetName.padEnd(8)} | ${sign} | ${degree} | ${criticalType} | ${interpretation} |`);
+        });
+        
+        console.log('================================================================================================================');
+        if (this.shouldUseBirthData(actualOptions)) {
+          console.log('\nThis analysis is based on your birth chart.');
+        } else {
+          console.log('\nThis analysis is based on the current planet position.');
+        }
+        
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Show retrograde planets if --rx option is specified (no planet required)
+      if (actualOptions.rx) {
+        await showRetrogradePlanets(this.shouldUseBirthData(actualOptions));
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Show element distribution if --el option is specified (no planet required)
+      if (actualOptions.el) {
+        // Use person data if --p1, --p2 or --i option is specified
+        let customDate = null;
+        let useBirthData = false;
+        let personSource = null;
+        
+        const personDataToUse = this.getPersonDataToUse(actualOptions);
+        if (personDataToUse.data) {
+          customDate = personDataToUse.data;
+          personSource = personDataToUse.source;
+          useBirthData = personSource === 'birth'; // Only true for birth data
+          
+          if (personSource === 'p1') {
+            console.log(`Using Person 1 data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else if (personSource === 'p2') {
+            console.log(`Using Person 2 data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else if (personSource.startsWith('p')) {
+            const personId = personSource.substring(1);
+            console.log(`Using Person ${personId} data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else {
+            console.log(`Using birth data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          }
+          
+          if (customDate.location) {
+            console.log(`Location: ${customDate.location.name}, ${customDate.location.country}`);
+          }
+        }
+        // Use custom date if specified (overrides --p1, --p2 and --i options)
+        if (actualOptions.d) {
+          // Try to parse the date as DD.MM.YYYY or DD.MM.YYYY HH:MM
+          const dateRegex = /^(\d{1,2})\.(\d{1,2})\.(\d{4})(?:\s+(\d{1,2}):(\d{2}))?$/;
+          const match = actualOptions.d.match(dateRegex);
+          
+          if (match) {
+            const day = parseInt(match[1], 10);
+            const month = parseInt(match[2], 10);
+            const year = parseInt(match[3], 10);
+            const hour = match[4] ? parseInt(match[4], 10) : 12; // Default: 12 o'clock
+            const minute = match[5] ? parseInt(match[5], 10) : 0; // Default: 0 minutes
+            
+            // Check if the date is valid
+            const date = new Date(year, month - 1, day, hour, minute);
+            if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+              customDate = {
+                day: day,
+                month: month,
+                year: year,
+                hour: hour,
+                minute: minute
+              };
+              console.log(`Using custom date: ${day}.${month}.${year} ${hour}:${minute.toString().padStart(2, '0')}`);
+            } else {
+              console.error('Invalid date:', actualOptions.d);
+              console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+              return { success: false, output: output.join('\n') };
+            }
+          } else {
+            console.error('Invalid date:', actualOptions.d);
+            console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+            return { success: false, output: output.join('\n') };
+          }
+        }
+        
+        // If no custom date is specified, use current date
+        if (!customDate) {
+          const currentTime = getCurrentTimeInTimezone();
+          customDate = {
+            day: currentTime.day,
+            month: currentTime.month,
+            year: currentTime.year,
+            hour: currentTime.hour,
+            minute: currentTime.minute
+          };
+        }
+        
+        // Analyze and show element distribution
+        analyzeElementDistribution(customDate, useBirthData);
+        
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Show personal transits if --tra option is specified (no planet required)
+      if (actualOptions.tra) {
+        // Person data is required for transits
+        const personDataToUse = this.getPersonDataToUse(actualOptions);
+        if (!personDataToUse.data) {
+          console.error('Error: Personal transits require person data. Please run --setup or create a person with --person1/--person2.');
+          return { success: false, output: output.join('\n') };
+        }
+        
+        const birthData = personDataToUse.data;
+
+        // Use custom date if specified
+        let transitDate = null;
+        if (actualOptions.d) {
+          // Try to parse the date as DD.MM.YYYY or DD.MM.YYYY HH:MM
+          const dateRegex = /^(\d{1,2})\.(\d{1,2})\.(\d{4})(?:\s+(\d{1,2}):(\d{2}))?$/;
+          const match = actualOptions.d.match(dateRegex);
+          
+          if (match) {
+            const day = parseInt(match[1], 10);
+            const month = parseInt(match[2], 10);
+            const year = parseInt(match[3], 10);
+            const hour = match[4] ? parseInt(match[4], 10) : 12; // Default: 12 o'clock
+            const minute = match[5] ? parseInt(match[5], 10) : 0; // Default: 0 minutes
+            
+            // Check if the date is valid
+            const date = new Date(year, month - 1, day, hour, minute);
+            if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+              transitDate = {
+                day: day,
+                month: month,
+                year: year,
+                hour: hour,
+                minute: minute
+              };
+              console.log(`Using transit date: ${day}.${month}.${year} ${hour}:${minute.toString().padStart(2, '0')}`);
+            } else {
+              console.error('Invalid date:', actualOptions.d);
+              console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+              return { success: false, output: output.join('\n') };
+            }
+          } else {
+            console.error('Invalid date:', actualOptions.d);
+            console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+            return { success: false, output: output.join('\n') };
+          }
+        }
+
+        // Calculate personal transits
+        const transitData = await calculatePersonalTransits(transitDate, birthData);
+        
+        if (!transitData) {
+          console.error('Error calculating personal transits.');
+          return { success: false, output: output.join('\n') };
+        }
+
+        // Show person data
+        if (personDataToUse.source === 'p1') {
+          console.log(`Person 1 data: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+        } else if (personDataToUse.source === 'p2') {
+          console.log(`Person 2 data: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+        } else {
+          console.log(`Birth data: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+        }
+        if (birthData.location) {
+          console.log(`Location: ${birthData.location.name}, ${birthData.location.country}`);
+        }
+        
+        // Show transit date
+        const transitDateDisplay = transitDate || getCurrentTimeInTimezone();
+        console.log(`Transit date: ${transitDateDisplay.day}.${transitDateDisplay.month}.${transitDateDisplay.year} ${transitDateDisplay.hour}:${transitDateDisplay.minute.toString().padStart(2, '0')}`);
+        
+        console.log('\nPersonal transits (House System: Koch, based on birth ASC):');
+        console.log('================================================================================');
+        console.log('| Planet      | Transit Position      | Birth Position        | Transit House |');
+        console.log('================================================================================');
+        
+        // Show all planets with their transit and birth positions
+        for (const [name, data] of Object.entries(transitData.planets)) {
+          const planetNameFormatted = name.charAt(0).toUpperCase() + name.slice(1);
+          const transitPos = `${data.sign} ${data.degreeInSign}°`;
+          const birthPos = `${data.birthPosition.sign} ${data.birthPosition.degreeInSign}°`;
+          const transitHouse = data.transitHouse;
+          
+          console.log(`| ${planetNameFormatted.padEnd(11)} | ${transitPos.padEnd(22)} | ${birthPos.padEnd(22)} | ${transitHouse.toString().padEnd(11)} |`);
+        }
+        
+        console.log('================================================================================');
+        
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Show configuration status if --status option is specified (no planet required)
+      if (actualOptions.status) {
+        showConfigStatus(userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Perform setup if --setup option is specified (no planet required)
+      if (actualOptions.setup) {
+        await performSetup(userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Create/update person 1 if --person1 option is specified (no planet required)
+      if (actualOptions.person1) {
+        await setPerson1(actualOptions.person1, userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Create/update person 2 if --person2 option is specified (no planet required)
+      if (actualOptions.person2) {
+        await setPerson2(actualOptions.person2, userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // List people if --people option is specified (no planet required)
+      if (actualOptions.people) {
+        listPeople(userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Set AI model if --ai option is specified (no planet required)
+      if (actualOptions.ai) {
+        setAIModel(actualOptions.ai, userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Set system prompt if --system option is specified (no planet required)
+      if (actualOptions.system) {
+        const { setSystemPrompt } = require('../config/configService');
+        setSystemPrompt(actualOptions.system, userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Delete person if --delete-person option is specified (no planet required)
+      if (actualOptions.deletePerson) {
+        deletePerson(actualOptions.deletePerson, userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Create/update any person if --person option is specified (no planet required)
+      if (actualOptions.person) {
+        // The person option expects both id and data, but we need to handle the parsing
+        // For now, we'll assume the format is "id data" and split on first space
+        const personParts = actualOptions.person.split(' ');
+        const personId = personParts[0];
+        const personData = personParts.slice(1).join(' ');
+        
+        if (personId && personData) {
+          const { setPerson } = require('../config/configService');
+          await setPerson(personId, personData, userId);
+        } else {
+          console.error('Invalid format for --person option. Expected: --person <id> "Location, Country, DD.MM.YYYY HH:MM"');
+        }
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Show aspects if --a option is specified
+      if (actualOptions.a) {
+        // Use person data if --p1, --p2 or --i option is specified
+        let customDate = null;
+        let useBirthData = false;
+        let personSource = null;
+        
+        const personDataToUse = this.getPersonDataToUse(actualOptions);
+        if (personDataToUse.data) {
+          customDate = personDataToUse.data;
+          personSource = personDataToUse.source;
+          useBirthData = personSource === 'birth'; // Only true for birth data
+          
+          if (personSource === 'p1') {
+            console.log(`Using Person 1 data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else if (personSource === 'p2') {
+            console.log(`Using Person 2 data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else if (personSource.startsWith('p')) {
+            const personId = personSource.substring(1);
+            console.log(`Using Person ${personId} data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          } else {
+            console.log(`Using birth data: ${customDate.day}.${customDate.month}.${customDate.year} ${customDate.hour}:${customDate.minute.toString().padStart(2, '0')}`);
+          }
+          
+          if (customDate.location) {
+            console.log(`Location: ${customDate.location.name}, ${customDate.location.country}`);
+          }
+        }
+        // Use custom date if specified (overrides --p1, --p2 and --i options)
+        if (actualOptions.d) {
+          // Try to parse the date as DD.MM.YYYY or DD.MM.YYYY HH:MM
+          const dateRegex = /^(\d{1,2})\.(\d{1,2})\.(\d{4})(?:\s+(\d{1,2}):(\d{2}))?$/;
+          const match = actualOptions.d.match(dateRegex);
+          
+          if (match) {
+            const day = parseInt(match[1], 10);
+            const month = parseInt(match[2], 10);
+            const year = parseInt(match[3], 10);
+            const hour = match[4] ? parseInt(match[4], 10) : 12; // Default: 12 o'clock
+            const minute = match[5] ? parseInt(match[5], 10) : 0; // Default: 0 minutes
+            
+            // Check if the date is valid
+            const date = new Date(year, month - 1, day, hour, minute);
+            if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+              customDate = {
+                day: day,
+                month: month,
+                year: year,
+                hour: hour,
+                minute: minute
+              };
+              console.log(`Using custom date: ${day}.${month}.${year} ${hour}:${minute.toString().padStart(2, '0')}`);
+            } else {
+              console.error('Invalid date:', actualOptions.d);
+              console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+              return { success: false, output: output.join('\n') };
+            }
+          } else {
+            console.error('Invalid date:', actualOptions.d);
+            console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+            return { success: false, output: output.join('\n') };
+          }
+        }
+        
+        // If no custom date is specified, use current date
+        if (!customDate) {
+          const currentTime = getCurrentTimeInTimezone();
+          customDate = {
+            day: currentTime.day,
+            month: currentTime.month,
+            year: currentTime.year,
+            hour: currentTime.hour,
+            minute: currentTime.minute
+          };
+        }
+        
+        // If no planet is specified, show all active aspects for all planets
+        if (!planetArg) {
+          showAllActiveAspects(customDate, useBirthData);
+          
+          return { success: true, output: output.join('\n') };
+        }
+        
+        // Show aspects for the specific planet (with Huber orbs)
+        showPlanetAspects(planetArg, customDate, useBirthData, true);
+        
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Show table view of all planet positions if --s option is specified
+      if (actualOptions.s) {
+        // Use person data for house calculation if --p1, --p2 or --i option is specified
+        let customDate = null;
+        let birthData = null;
+        let houseSystem = actualOptions.hs ? actualOptions.hs.toLowerCase() : 'koch';
+        let personSource = null;
+        let useNatalPositions = false;
+        
+        // Check if person data should be used for house calculation
+        const personDataToUse = this.getPersonDataToUse(actualOptions);
+        if (personDataToUse.data) {
+          birthData = personDataToUse.data;
+          personSource = personDataToUse.source;
+          
+          if (personSource === 'p1') {
+            console.log(`Using Person 1 data for house calculation: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+          } else if (personSource === 'p2') {
+            console.log(`Using Person 2 data for house calculation: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+          } else if (personSource.startsWith('p')) {
+            const personId = personSource.substring(1);
+            console.log(`Using Person ${personId} data for house calculation: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+          } else {
+            console.log(`Using birth data for house calculation: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+          }
+          
+          if (birthData.location) {
+            console.log(`Location: ${birthData.location.name}, ${birthData.location.country}`);
+          }
+        } else {
+          console.log('No person data found. Using current location for house calculation.');
+        }
+        
+        // Use custom date if specified (for planet positions)
+        if (actualOptions.d) {
+          // Try to parse the date as DD.MM.YYYY or DD.MM.YYYY HH:MM
+          const dateRegex = /^(\d{1,2})\.(\d{1,2})\.(\d{4})(?:\s+(\d{1,2}):(\d{2}))?$/;
+          const match = actualOptions.d.match(dateRegex);
+          
+          if (match) {
+            const day = parseInt(match[1], 10);
+            const month = parseInt(match[2], 10);
+            const year = parseInt(match[3], 10);
+            const hour = match[4] ? parseInt(match[4], 10) : 12; // Default: 12 o'clock
+            const minute = match[5] ? parseInt(match[5], 10) : 0; // Default: 0 minutes
+            
+            // Check if the date is valid
+            const date = new Date(year, month - 1, day, hour, minute);
+            if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+              customDate = {
+                day: day,
+                month: month,
+                year: year,
+                hour: hour,
+                minute: minute
+              };
+              console.log(`Using custom date: ${day}.${month}.${year} ${hour}:${minute.toString().padStart(2, '0')}`);
+            } else {
+              console.error('Invalid date:', actualOptions.d);
+              console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+              return { success: false, output: output.join('\n') };
+            }
+          } else {
+            console.error('Invalid date:', actualOptions.d);
+            console.error('Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+            return { success: false, output: output.join('\n') };
+          }
+        }
+        
+        // If no custom date is specified, use current date
+        if (!customDate) {
+          const currentTime = getCurrentTimeInTimezone();
+          customDate = {
+            day: currentTime.day,
+            month: currentTime.month,
+            year: currentTime.year,
+            hour: currentTime.hour,
+            minute: currentTime.minute
+          };
+        }
+        
+        // Check if we should use natal positions (when --i is used without custom date)
+        if (this.shouldUseBirthData(actualOptions) && !actualOptions.d) {
+          useNatalPositions = true;
+          // customDate is already set to birth data from personDataToUse
+          console.log('Using natal positions from birth data.');
+        }
+        
+        const config = loadConfig();
+
+        // Function to calculate Julian Day in UTC for planet positions
+        const getJulianDayUTCForPlanets = () => {
+          let timezoneOffsetMinutes = 0;
+          
+          if (config && config.currentLocation && config.currentLocation.timezone) {
+            timezoneOffsetMinutes = getTimezoneOffset(customDate, config.currentLocation.timezone);
+          } else {
+            timezoneOffsetMinutes = -new Date().getTimezoneOffset();
+          }
+          
+          return calculateJulianDayUTC(customDate, timezoneOffsetMinutes);
+        };
+        
+        // Function to calculate Julian Day in UTC for house calculation
+        const getJulianDayUTCForHouses = () => {
+          let timezoneOffsetMinutes = 0;
+          
+          if (birthData && birthData.location) {
+            timezoneOffsetMinutes = getTimezoneOffset(birthData, birthData.location.timezone || 'Europe/Zurich');
+          } else if (config && config.currentLocation && config.currentLocation.timezone) {
+            timezoneOffsetMinutes = getTimezoneOffset(customDate, config.currentLocation.timezone);
+          } else {
+            timezoneOffsetMinutes = -new Date().getTimezoneOffset();
+          }
+          
+          return calculateJulianDayUTC(birthData ? birthData : customDate, timezoneOffsetMinutes);
+        };
+        
+        // Calculate houses if house system is specified
+        let houses = null;
+        if (houseSystem) {
+          try {
+            const julianDayForHouses = getJulianDayUTCForHouses();
+            const useBirthLocation = birthData !== null;
+            
+            houses = await calculateHouses(julianDayForHouses, getHouseSystemCode(houseSystem), useBirthLocation);
+          } catch (error) {
+            console.error('Error calculating houses:', error);
+          }
+        }
+        
+        // Show table view of all planet positions
+        console.log('Planet positions:');
+        console.log('================================================================================');
+        console.log('| Planet      | Sign        | Deg  | House | Dignity       | Element    |');
+        console.log('================================================================================');
+        
+        // Calculate positions of all planets
+        for (const [name, planetId] of Object.entries(planets)) {
+          const data = getAstrologicalData(name, customDate);
+          
+          // Determine the house if houses were calculated
+          let house = 'N/A';
+          if (houses) {
+            const planetLongitude = parseFloat(data.degreeInSign) + (signs.indexOf(data.sign) * 30);
+            house = getPlanetHouse(planetLongitude, houses.house);
+          }
+          
+          const planetNameFormatted = name.charAt(0).toUpperCase() + name.slice(1);
+          const signFormatted = data.sign.padEnd(10, ' ');
+          const degreeFormatted = data.degreeInSign.padEnd(5, ' ');
+          const houseFormatted = house.toString().padEnd(4, ' ');
+          const dignityFormatted = data.dignity.padEnd(12, ' ');
+          const elementFormatted = data.element.padEnd(9, ' ');
+          
+          console.log(`| ${planetNameFormatted.padEnd(11)} | ${signFormatted} | ${degreeFormatted}° | ${houseFormatted} | ${dignityFormatted} | ${elementFormatted} |`);
+        }
+        
+        console.log('================================================================================');
+        
+        // Show astrological angles if houses were calculated
+        if (houses) {
+          console.log('\nAstrological Angles:');
+          console.log('================================================================================');
+          console.log('| Angle | Sign        | Degree |');
+          console.log('================================================================================');
+          
+          const angles = calculateAstrologicalAngles(houses.house);
+          
+          // ASC (Ascendant)
+          const ascData = longitudeToSignDegree(angles.asc);
+          console.log(`| ASC   | ${ascData.sign.padEnd(10)} | ${ascData.degree.padEnd(6)}° |`);
+          
+          // MC (Medium Coeli/Midheaven)
+          const mcData = longitudeToSignDegree(angles.mc);
+          console.log(`| MC    | ${mcData.sign.padEnd(10)} | ${mcData.degree.padEnd(6)}° |`);
+          
+          // DESC (Descendant)
+          const descData = longitudeToSignDegree(angles.desc);
+          console.log(`| DESC  | ${descData.sign.padEnd(10)} | ${descData.degree.padEnd(6)}° |`);
+          
+          // IC (Imum Coeli)
+          const icData = longitudeToSignDegree(angles.ic);
+          console.log(`| IC    | ${icData.sign.padEnd(10)} | ${icData.degree.padEnd(6)}° |`);
+          
+          console.log('================================================================================');
+        }
+        
+        if (birthData) {
+          if (useNatalPositions) {
+            console.log('\nThis analysis shows your natal planet positions.');
+            console.log('The houses are based on your birth ASC (natal chart).');
+          } else {
+            console.log('\nThis analysis shows current planet positions in your birth houses.');
+            console.log('The houses are based on your birth ASC (personal transits).');
+          }
+        } else {
+          console.log('\nThis analysis is based on the current planet position.');
+        }
+        
+        if (houses) {
+          console.log(`House system: ${houseSystem.charAt(0).toUpperCase() + houseSystem.slice(1)}`);
+        }
+        
+        return { success: true, output: output.join('\n') };
+      }
+
+      if (actualOptions.v || actualOptions.z) {
+        const positionalArgs = actualOptions._positionalArgs || [];
+        let planet1 = positionalArgs[0] ? positionalArgs[0].toLowerCase() : null;
+        let aspectType = positionalArgs[1] ? positionalArgs[1].toLowerCase() : null;
+        let planet2 = positionalArgs[2] ? positionalArgs[2].toLowerCase() : null;
+        const countValue = actualOptions.v || actualOptions.z;
+        const count = parseInt(countValue, 10);
+
+        if (!planet1 || !aspectType || !planet2) {
+          const rawArgs = actualOptions._args || [];
+          const optionFlag = actualOptions.v ? '--v' : '--z';
+          const optionIndex = rawArgs.findIndex(arg => arg === optionFlag);
+          if (optionIndex !== -1 && rawArgs.length >= optionIndex + 5) {
+            planet1 = rawArgs[optionIndex + 2] ? rawArgs[optionIndex + 2].toLowerCase() : null;
+            aspectType = rawArgs[optionIndex + 3] ? rawArgs[optionIndex + 3].toLowerCase() : null;
+            planet2 = rawArgs[optionIndex + 4] ? rawArgs[optionIndex + 4].toLowerCase() : null;
+          }
+        }
+
+        if (!planet1 || !aspectType || !planet2) {
+          console.error('Error: Past/future aspects require two planets and an aspect type.');
+          console.error('Format: --v <count> planet1 aspectType planet2');
+          console.error('Example: --v 3 saturn c neptune');
+          return { success: false, output: output.join('\n') };
+        }
+
+        if (!Number.isFinite(count) || count <= 0) {
+          console.error('Error: Please provide a valid count for --v/--z.');
+          return { success: false, output: output.join('\n') };
+        }
+
+        if (!planets[planet1] || !planets[planet2]) {
+          console.error('Error: Invalid planets.');
+          console.error('Available planets:', Object.keys(planets).join(', '));
+          return { success: false, output: output.join('\n') };
+        }
+
+        const targetAngle = getAspectAngle(aspectType);
+        if (targetAngle === null) {
+          console.error('Error: Invalid aspect type.');
+          console.error('Available aspect types: c, o, s, t, se (conjunction, opposition, square, trine, sextile)');
+          return { success: false, output: output.join('\n') };
+        }
+
+        const aspectTypeFull = getAspectTypeFullName(aspectType);
+        const aspects = actualOptions.v
+          ? getPastAspects(planet1, planet2, aspectType, count)
+          : getFutureAspects(planet1, planet2, aspectType, count);
+        const heading = actualOptions.v ? 'Last' : 'Next';
+
+        console.log(`${heading} ${count} ${aspectTypeFull} between ${planet1} and ${planet2}:`);
+        console.log('================================================================================');
+        console.log('| Date                | Planet 1 Position      | Planet 2 Position      |');
+        console.log('================================================================================');
+
+        if (aspects.length === 0) {
+          console.log(actualOptions.v ? 'No past aspects found.' : 'No future aspects found.');
+        } else {
+          aspects.forEach(aspect => {
+            const dateStr = `${String(aspect.date.day).padStart(2, '0')}.${String(aspect.date.month).padStart(2, '0')}.${aspect.date.year}`;
+            const planet1Pos = `${aspect.planet1Position.padEnd(22, ' ')}`;
+            const planet2Pos = `${aspect.planet2Position.padEnd(22, ' ')}`;
+            console.log(`| ${dateStr.padEnd(18)} | ${planet1Pos} | ${planet2Pos} |`);
+          });
+        }
+
+        console.log('================================================================================');
+        console.log(`Found: ${aspects.length} exact ${aspectTypeFull}`);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Show normal planet info as default
+      const planet = planetArg ? planetArg.toLowerCase() : 'moon';
+      const data = getAstrologicalData(planet, null);
+      
+      console.log(`\nAstrological data for ${data.planet}:`);
+      console.log(`Sign: ${data.sign}`);
+      console.log(`Degree in sign: ${data.degreeInSign}°`);
+      console.log(`Dignity: ${data.dignity}`);
+      console.log(`Element: ${data.element}`);
+      console.log(`Decan: ${data.decan}\n`);
+      
+      return { success: true, output: output.join('\n') };
+      
+    } catch (error) {
+      console.error('Error executing command:', error.message);
+      return { success: false, output: output.join('\n') };
+    } finally {
+      // Restore original console methods
+      console.log = originalConsoleLog;
+      console.error = originalConsoleError;
+    }
+  }
+
+  // Method to execute a command programmatically
+  async executeCommand(commandString, userId = null) {
+    // Parse the command string into arguments
+    const args = splitCommandArgs(commandString);
+
+    if (args.includes('--help') || args.includes('-h')) {
+      const helpText = [
+        'Usage: [planet] [options]',
+        '',
+        'Options:',
+        '  --help, -h       Show this help',
+        '  --c              Critical degrees',
+        '  --rx             Retrograde planets',
+        '  --el             Element distribution',
+        '  --s              All planet positions',
+        '  --status         Show config',
+        '  --people         List people',
+        '  --setup          Configure via GUI',
+        '  --i              Use birth data',
+        '  --hs <system>    House system',
+        '  --hl <system>    House list',
+        '  --d <date>       Specific date (DD.MM.YYYY or "DD.MM.YYYY HH:MM")',
+        '  --a              Show aspects for planet',
+        '  --k              Show aspects between planets',
+        '  --af             Show active aspect figures',
+        '  --tr             Show personal transit aspects',
+        '  --v <count>      Past aspects (planet1 aspectType planet2)',
+        '  --z <count>      Future aspects (planet1 aspectType planet2)',
+        '  --in [count]     Next planet ingress',
+        '  --o              Transit frequency'
+      ].join('\n');
+      return { success: true, output: helpText };
+    }
+    
+    // Parse options manually since Commander.js doesn't easily allow capturing output
+    const options = {};
+    const positionalArgs = [];
+    const supportedOptions = new Set();
+    for (const option of this.program.options) {
+      if (option.long) {
+        supportedOptions.add(option.long.replace(/^--/, ''));
+      }
+      if (option.short) {
+        supportedOptions.add(option.short.replace(/^-/, ''));
+      }
+    }
+    
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      
+      if (arg.startsWith('--')) {
+        // Handle options
+        const optionName = arg.substring(2);
+
+        if (!supportedOptions.has(optionName)) {
+          return { success: false, output: `Unknown option: --${optionName}` };
+        }
+        
+        // Special handling for --v option which requires multiple arguments
+        if (optionName === 'v') {
+          // --v requires: count, planet1, aspectType, planet2
+          if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+            options[optionName] = args[i + 1]; // This is the count
+            
+            // Now we need to extract the next 3 arguments: planet1, aspectType, planet2
+            if (i + 2 < args.length && !args[i + 2].startsWith('--')) {
+              options['vPlanet1'] = args[i + 2];
+            }
+            if (i + 3 < args.length && !args[i + 3].startsWith('--')) {
+              options['vAspectType'] = args[i + 3];
+            }
+            if (i + 4 < args.length && !args[i + 4].startsWith('--')) {
+              options['vPlanet2'] = args[i + 4];
+            }
+            
+            i += 4; // Skip the next 4 arguments (count + 3 planets/aspects)
+          } else {
+            options[optionName] = true;
+          }
+        }
+        // Special handling for --z option which requires multiple arguments
+        else if (optionName === 'z') {
+          // --z requires: count, planet1, aspectType, planet2
+          if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+            options[optionName] = args[i + 1]; // This is the count
+            
+            // Now we need to extract the next 3 arguments: planet1, aspectType, planet2
+            if (i + 2 < args.length && !args[i + 2].startsWith('--')) {
+              options['zPlanet1'] = args[i + 2];
+            }
+            if (i + 3 < args.length && !args[i + 3].startsWith('--')) {
+              options['zAspectType'] = args[i + 3];
+            }
+            if (i + 4 < args.length && !args[i + 4].startsWith('--')) {
+              options['zPlanet2'] = args[i + 4];
+            }
+            
+            i += 4; // Skip the next 4 arguments (count + 3 planets/aspects)
+          } else {
+            options[optionName] = true;
+          }
+        }
+        // Handle other options with values
+        else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+          options[optionName] = args[i + 1];
+          i++; // Skip the next argument as it's the value
+        } else {
+          options[optionName] = true;
+        }
+      } else if (arg.startsWith('-')) {
+        // Handle short options (we'll skip these for simplicity)
+        // This is a simplified parser for the GUI use case
+      } else {
+        // Handle positional arguments
+        positionalArgs.push(arg);
+      }
+    }
+    
+    // Create a new instance to handle the command
+    const tempService = new CLIService();
+    const planetArg = positionalArgs[0] || null;
+    const planet2Arg = positionalArgs[1] || null;
+    options._positionalArgs = positionalArgs;
+    options._args = args;
+    
+    return tempService.handleCommand(planetArg, planet2Arg, options, userId);
+  }
+}
+
+module.exports = new CLIService();