klio 1.4.3 → 1.4.5

package/README.md

@@ -129,6 +129,15 @@ Then, instead using `--i` for the commands from above you can use `--wp <id>` i.
   - Example: `klio saturn --in 2` - Shows next 2 Saturn ingresses (note: slow planets may have limited future data)
   - Example: `klio mercury --in --d "15.03.2026"` - Shows next Mercury ingress from a specific date
 
+### Wikidata Integration
+
+- **Search for people with specific aspects**: `[planet1] [aspect-type] [planet2] --wiki <occupation> [limit]` - Searches Wikidata for people with specific astrological aspects
+  - **Available occupations**: authors, scientists, artists, musicians, politicians, actors, philosophers
+  - **Aspect types**: c (conjunction), o (opposition), s (square), t (trine), se (sextile), q (quincunx)
+  - **Example**: `klio moon c neptune --wiki authors 50` - Tries to find authors with Moon conjunct Neptune aspect with a limit of 50. Is faster but less common aspects are maybe not found with 50
+  - **Example**: `klio saturn s pluto --wiki scientists 100` - Finds scientists with Saturn square Pluto aspect
+  - **Example**: `klio sun t moon --wiki artists 200` - Finds artists with Sun trine Moon aspect
+
 ### AI Integration
 
 - **AI model selection**: `--ai <model>` - Sets a specific AI model (e.g., "google/gemma-3n-e4b") for LM Studio ([lmstudio.ai](https://lmstudio.ai))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klio",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "A CLI for astrological calculations",
   "main": "src/main.js",
   "bin": {

package/src/astrology/astrologyService.js

@@ -2544,19 +2544,16 @@ function calculateNextPlanetIngress(planetName, startDate = null, count = 1) {
                           isMediumSlowPlanet ? 6 : 
                           1; // Daily for very slow, 6-hourly for medium, hourly for fast
     
-    // Maximum search window (in days)
-    // For very slow planets, we need to search much further ahead
-    // Saturn: ~2.5 years per sign, so for multiple ingresses we need ~5-10 years
-    // Jupiter: ~1 year per sign, so for multiple ingresses we need ~3-5 years
-    // Uranus: ~7 years per sign, so we need ~15-20 years
-    // Neptune: ~13.75 years per sign, so we need ~25-30 years
-    // Pluto: ~20.7 years per sign, so we need ~35-40 years
-    // For fast planets (Moon, Mercury, Venus, Mars, Sun), we need a reasonable window per ingress
-    const fastPlanets = ['moon', 'mercury', 'venus', 'mars', 'sun'];
+    // Maximum search window (in days) - calculate based on planet and requested count
+    // Mars: ~2 months per sign, so for multiple ingresses we need ~count * 60 days
+    // Other fast planets (Moon, Mercury, Venus, Sun): 90 days is sufficient
+    const fastPlanets = ['moon', 'mercury', 'venus', 'sun'];
     const isFastPlanet = fastPlanets.includes(planetName);
+    const isMars = planetName === 'mars';
     
     const maxDays = isVerySlowPlanet ? 365 * 90 :
                     isMediumSlowPlanet ? 365 * 90 :
+                    isMars ? Math.min(365 * 5, 90 * count) : // Mars: up to 5 years or count * 3 months
                     isFastPlanet ? 90 :  // 30 days for fast planets (enough for multiple moon ingresses)
                     365 * 90; // Default for other planets
     const maxAttempts = maxDays * 24 / timeStepHours;
@@ -2599,15 +2596,18 @@ function calculateNextPlanetIngress(planetName, startDate = null, count = 1) {
         currentDate.setHours(currentDate.getHours() + 6); // Start 6 hours after ingress
       }
     } else {
-      const daysLimit = isVerySlowPlanet ? 365 * 40 : 
-                       isMediumSlowPlanet ? 365 * 5 : 
-                       isFastPlanet ? 30 : 
-                       60;
+      const daysLimit = isVerySlowPlanet ? 365 * 90 :
+                       isMediumSlowPlanet ? 365 * 90 :
+                       isMars ? Math.min(365 * 5, 90 * count) :
+                       isFastPlanet ? 90 :
+                       365 * 90;
       console.log(`Could not find ${planetName} ingress to ${signs[targetSignIndex]} within ${daysLimit} days`);
       if (isVerySlowPlanet) {
         console.log(`💡 Note: For very slow planets like ${planetName}, the ephemeris data may not extend far enough into the future.`);
       } else if (isMediumSlowPlanet) {
         console.log(`💡 Note: For medium-slow planets like ${planetName}, the ephemeris data may not extend far enough into the future.`);
+      } else if (isMars) {
+        console.log(`💡 Note: For Mars, the requested number of ingresses may be too high for the current search window.`);
       } else {
         console.log(`💡 Note: For ${planetName}, the requested number of ingresses may be too high.`);
       }

package/src/cli/cli.js

@@ -11,6 +11,15 @@ const swisseph = require('swisseph');
 const path = require('path');
 const fs = require('fs');
 
+// Wikidata service import
+let wikidataService = null;
+try {
+  wikidataService = require('../wikidata/wikidataService');
+} catch (error) {
+  // Wikidata service not available
+  console.debug('Wikidata service not available');
+}
+
 // GUI Server import
 let guiServer = null;
 try {
@@ -255,6 +264,7 @@ program
   .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('--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')
   .description('Shows astrological data for a planet')
@@ -1112,6 +1122,111 @@ program
       return;
     }
 
+    // Handle Wikidata people search if --wiki option is specified
+    if (options.wiki) {
+      // For the wiki command, the format is: planet1 aspectType planet2 --wiki <occupation> [limit]
+      // But the argument parsing is: planetArg=planet1, planet2=aspectType, and options.wiki=planet2
+      // We need to extract the occupation and planet2 from the remaining arguments
+      
+      if (!planetArg || !planet2 || !options.wiki) {
+        console.error('Error: Wikidata search requires format: planet1 aspectType planet2 --wiki <occupation> [limit]');
+        console.error('Example: klio saturn conjunction neptune --wiki authors');
+        console.error('Available occupations:', Object.keys(wikidataService.PREDEFINED_OCCUPATIONS || {}).join(', '));
+        process.exit(1);
+      }
+      
+      const planet1 = planetArg.toLowerCase();
+      const aspectType = planet2.toLowerCase();
+      
+      // The occupation is in options.wiki, but we need to find the actual planet2
+      // Let's look at the original arguments to parse this correctly
+      const args = process.argv.slice(2); // Skip 'node' and script name
+      
+      // Find the position of --wiki
+      const wikiIndex = args.findIndex(arg => arg === '--wiki');
+      if (wikiIndex === -1 || wikiIndex + 1 >= args.length) {
+        console.error('Error: Missing occupation after --wiki flag');
+        process.exit(1);
+      }
+      
+      const occupation = args[wikiIndex + 1].toLowerCase();
+      
+      // The planet2 should be the argument before --wiki
+      const planet2Name = args[wikiIndex - 1].toLowerCase();
+      
+      // Validate planets
+      if (planets[planet1] === undefined) {
+        console.error(`Error: Invalid planet '${planet1}'. Available planets: ${Object.keys(planets).join(', ')}`);
+        process.exit(1);
+      }
+      
+      if (planets[planet2Name] === undefined) {
+        console.error(`Error: Invalid planet '${planet2Name}'. Available planets: ${Object.keys(planets).join(', ')}`);
+        process.exit(1);
+      }
+      
+      // Validate aspect type (including shorthands)
+      const validAspects = ['conjunction', 'opposition', 'square', 'trine', 'sextile', 'quincunx', 'c', 'con', 'opp', 'sq', 'tri', 'sex', 'qui'];
+      if (!validAspects.includes(aspectType)) {
+        console.error(`Error: Invalid aspect type '${aspectType}'. Available aspects: ${['conjunction', 'opposition', 'square', 'trine', 'sextile', 'quincunx'].join(', ')}`);
+        console.error('Shorthands: c/con, opp, sq, tri, sex, qui');
+        process.exit(1);
+      }
+      
+      // Parse limit if provided (look for arguments after occupation)
+      let limit = 500;
+      if (wikiIndex + 2 < args.length) {
+        const limitArg = args[wikiIndex + 2];
+        if (!isNaN(limitArg) && parseInt(limitArg) > 0) {
+          limit = parseInt(limitArg);
+        }
+      }
+      
+      console.log(`🔍 Searching Wikidata for ${occupation} with ${planet1} ${aspectType} ${planet2Name} aspect...`);
+      console.log(`📊 Limit: ${limit} people`);
+      
+      if (!wikidataService) {
+        console.error('❌ Wikidata service is not available.');
+        process.exit(1);
+      }
+      
+      try {
+        const results = await wikidataService.findPeopleWithAspect(occupation, planet1, aspectType, planet2Name, limit);
+        
+        if (results.length === 0) {
+          console.log('No results found.');
+          return;
+        }
+        
+        // Display results in a table
+        console.log('\n📋 Results (sorted by orb, closest aspects first):');
+        console.log('================================================================================');
+        console.log('| #   | Name                          | Birth Date  | Aspect Type | Orb   | Wikidata Link                     |');
+        console.log('================================================================================');
+        
+        results.forEach((result, index) => {
+          const name = result.name.padEnd(28, ' ').substring(0, 28);
+          const birthDate = result.birthDate ? result.birthDate.substring(0, 10) : 'Unknown';
+          const aspectTypeDisplay = result.aspect.type.padEnd(11, ' ');
+          const orb = result.aspect.orb.padEnd(4, ' ');
+          const linkUrl = result.linkUrl || 'N/A';
+          
+          console.log(`| ${(index + 1).toString().padEnd(2)} | ${name} | ${birthDate} | ${aspectTypeDisplay} | ${orb}° | ${linkUrl} |`);
+        });
+        
+        console.log('================================================================================');
+        console.log(`\n📊 Found ${results.length} ${occupation} with ${planet1} ${aspectType} ${planet2Name} aspect.`);
+        console.log('🔗 Wikipedia search links are provided for each person.');
+        console.log('🎯 Results are sorted by orb (closest aspects first).');
+        
+      } catch (error) {
+        console.error('❌ Error searching Wikidata:', error.message);
+        process.exit(1);
+      }
+      
+      return;
+    }
+
     // For other options, a planet is required (except for --a or --s without planet)
     if (!planetArg && !options.a && !options.s) {
       console.error('Error: Planet is required for this operation.');

package/src/wikidata/wikidataService.js

@@ -0,0 +1,228 @@
+// Wikidata Service for fetching author data and checking astrological aspects
+const axios = require('axios');
+const { calculatePlanetComboAspects } = require('../astrology/astrologyService');
+
+// Wikidata SPARQL endpoint
+const WIKIDATA_SPARQL_ENDPOINT = 'https://query.wikidata.org/sparql';
+
+// Predefined occupations with their Wikidata Q IDs
+const PREDEFINED_OCCUPATIONS = {
+  'authors': 'wd:Q36180',      // Writer
+  'scientists': 'wd:Q901',     // Scientist  
+  'artists': 'wd:Q1028181',    // Visual artist
+  'musicians': 'wd:Q639669',   // Musician
+  'politicians': 'wd:Q82955',  // Politician
+  'actors': 'wd:Q33999',       // Actor
+  'philosophers': 'wd:Q4964182' // Philosopher
+};
+
+// Function to fetch people by occupation from Wikidata
+async function fetchPeopleByOccupation(occupation, limit = 500) {
+  try {
+    // Get the Wikidata Q ID for the occupation
+    const occupationQid = PREDEFINED_OCCUPATIONS[occupation.toLowerCase()];
+    
+    if (!occupationQid) {
+      console.error(`Error: Unknown occupation '${occupation}'. Available occupations: ${Object.keys(PREDEFINED_OCCUPATIONS).join(', ')}`);
+      return [];
+    }
+    
+    const query = `
+      SELECT DISTINCT ?person ?personLabel ?birthDate ?wikipediaLink WHERE {
+        ?person wdt:P31 wd:Q5;  # Instance of human
+               wdt:P106 ${occupationQid}.  # Specific occupation
+        
+        # Make birth date optional
+        OPTIONAL { ?person wdt:P569 ?birthDate. }
+        
+        # Get English Wikipedia article link
+        OPTIONAL { ?wikipediaArticle schema:about ?person ;
+                                  schema:isPartOf <https://en.wikipedia.org/> ;
+                                  schema:url ?wikipediaLink . }
+        
+        # Get label
+        SERVICE wikibase:label { bd:serviceParam wikibase:language "en". }
+      }
+      LIMIT ${limit}
+    `;
+
+    const response = await axios.get(WIKIDATA_SPARQL_ENDPOINT, {
+      params: {
+        query: query,
+        format: 'json'
+      },
+      headers: {
+        'Accept': 'application/sparql-results+json'
+      }
+    });
+
+    if (response.data && response.data.results && response.data.results.bindings) {
+      return response.data.results.bindings.map(binding => ({
+        name: binding.personLabel?.value || 'Unknown',
+        birthDate: binding.birthDate?.value || null,
+        wikidataId: binding.person.value.split('/').pop()
+      }));
+    }
+    
+    return [];
+  } catch (error) {
+    console.error('Error fetching people from Wikidata:', error.message);
+    return [];
+  }
+}
+
+// Backward compatibility function
+async function fetchAuthorsFromWikidata(limit = 500) {
+  return fetchPeopleByOccupation('authors', limit);
+}
+
+// Function to parse birth date and extract astrological data
+function parseBirthDate(birthDateString) {
+  if (!birthDateString) return null;
+  
+  try {
+    // Parse ISO date string (format: +YYYY-MM-DDThh:mm:ssZ or YYYY-MM-DDThh:mm:ssZ or +YYYY-MM-DD or YYYY-MM-DD or +YYYY-MM or YYYY-MM or +YYYY or YYYY)
+    const dateMatch = birthDateString.match(/^\+?(\d{4})(?:-(\d{1,2})(?:-(\d{1,2}))?)?/);
+    if (!dateMatch) return null;
+    
+    const year = parseInt(dateMatch[1]);
+    const month = dateMatch[2] ? parseInt(dateMatch[2]) : 1; // Default to January if month not specified
+    const day = dateMatch[3] ? parseInt(dateMatch[3]) : 1;   // Default to 1st if day not specified
+    
+    // Handle invalid month/day values (like 00 for century-level dates)
+    const validMonth = month === 0 ? 1 : month;
+    const validDay = day === 0 ? 1 : day;
+    
+    // Default time to noon if not specified
+    return {
+      year: year,
+      month: validMonth,
+      day: validDay,
+      hour: 12,
+      minute: 0
+    };
+  } catch (error) {
+    console.error('Error parsing birth date:', error.message);
+    return null;
+  }
+}
+
+// Aspect type mapping for shorthand support
+const ASPECT_SHORTHAND = {
+  'c': 'conjunction',
+  'o': 'opposition',
+  's': 'square',
+  't': 'trine',
+  'se': 'sextile',
+  'q': 'quincunx'
+};
+
+// Function to create a Wikipedia search URL from a person's name
+function createWikipediaSearchUrl(personName) {
+  // Create a Wikipedia search URL using the person's name
+  // This will take users to a search page where they can find the correct article
+  const encodedName = encodeURIComponent(personName);
+  return `https://en.wikipedia.org/wiki/Special:Search?search=${encodedName}`;
+}
+
+// Function to normalize aspect type (support shorthands)
+function normalizeAspectType(aspectType) {
+  const normalized = aspectType.toLowerCase();
+  return ASPECT_SHORTHAND[normalized] || normalized;
+}
+
+// Function to check if an author has a specific aspect in their natal chart
+function checkAuthorAspect(authorData, planet1, aspectType, planet2) {
+  if (!authorData.birthDateData) return null;
+  
+  try {
+    // Normalize aspect type to handle shorthands
+    const normalizedAspectType = normalizeAspectType(aspectType);
+    
+    // Calculate aspects for this author's birth chart
+    const aspects = calculatePlanetComboAspects([planet1, planet2], authorData.birthDateData, true);
+    
+    // Look for the specific aspect type
+    const matchingAspect = aspects.find(aspect => 
+      ((aspect.planet1 === planet1 && aspect.planet2 === planet2) || 
+       (aspect.planet1 === planet2 && aspect.planet2 === planet1)) &&
+      aspect.type.toLowerCase() === normalizedAspectType.toLowerCase()
+    );
+    
+    return matchingAspect || null;
+  } catch (error) {
+    console.error('Error checking aspect for author:', authorData.name, error.message);
+    return null;
+  }
+}
+
+// Main function to find people with specific aspects by occupation
+async function findPeopleWithAspect(occupation, planet1, aspectType, planet2, limit = 500) {
+  // Fetch people by occupation from Wikidata
+  const people = await fetchPeopleByOccupation(occupation, limit);
+  
+  if (people.length === 0) {
+    console.log(`No ${occupation} found in Wikidata.`);
+    return [];
+  }
+  
+  console.log(`Fetched ${people.length} ${occupation} from Wikidata. Checking aspects...`);
+  
+  // Process each person to check for the specified aspect
+  const results = [];
+  let processedCount = 0;
+  
+  for (const person of people) {
+    // Parse birth date
+    const birthDateData = parseBirthDate(person.birthDate);
+
+    
+    // Add birth date data to person object
+    person.birthDateData = birthDateData;
+    
+    // Check for the specific aspect
+    const aspect = checkAuthorAspect(person, planet1, aspectType, planet2);
+    
+    if (aspect) {
+      // Create Wikipedia search URL using the person's name
+      const linkUrl = createWikipediaSearchUrl(person.name);
+      
+      results.push({
+        name: person.name,
+        birthDate: person.birthDate,
+        linkUrl: linkUrl,
+        aspect: aspect,
+        birthDateData: person.birthDateData
+      });
+    }
+    
+    processedCount++;
+    if (processedCount % 50 === 0) {
+      console.log(`Processed ${processedCount}/${people.length} ${occupation}...`);
+    }
+  }
+  
+  console.log(`Found ${results.length} ${occupation} with ${planet1} ${aspectType} ${planet2} aspect.`);
+  
+  // Sort by orb (closest aspects first)
+  results.sort((a, b) => parseFloat(a.aspect.orb) - parseFloat(b.aspect.orb));
+  
+  return results;
+}
+
+// Backward compatibility function
+async function findAuthorsWithAspect(planet1, aspectType, planet2, limit = 500) {
+  return findPeopleWithAspect('authors', planet1, aspectType, planet2, limit);
+}
+
+module.exports = {
+  fetchAuthorsFromWikidata,
+  findAuthorsWithAspect,
+  fetchPeopleByOccupation,
+  findPeopleWithAspect,
+  parseBirthDate,
+  checkAuthorAspect,
+  normalizeAspectType,
+  ASPECT_SHORTHAND,
+  PREDEFINED_OCCUPATIONS
+};