thoth-cli 0.2.21 → 0.2.23

package/dist/bin.js

@@ -19,6 +19,10 @@ import {
   formatSolarArc,
   formatSolarReturn,
   formatSynastry,
+  formatTarotCard,
+  formatTarotDeck,
+  formatTarotDraw,
+  formatTarotSpreads,
   formatTransitScan,
   formatTransits,
   horary,
@@ -31,10 +35,14 @@ import {
   solarArc,
   solarReturn,
   synastry,
+  tarotCard,
+  tarotDeck,
+  tarotDraw,
+  tarotSpreads,
   transit,
   transitScan,
   version
-} from "./chunk-QND56LGZ.js";
+} from "./chunk-X7IGMJUH.js";
 
 // src/bin.ts
 import { Command } from "commander";
@@ -796,7 +804,62 @@ program.command("ephemeris-multi").description("Get ephemeris for multiple bodie
     console.log(formatEphemerisMulti(result));
   }
 });
+program.command("tarot").alias("draw").description("Draw tarot cards (cryptographic randomness)").option("-s, --spread <spread>", "Spread: single, 3-card, celtic, horseshoe, relationship, decision", "single").option("-q, --question <question>", "Question for the reading").option("-n, --count <count>", "Number of cards (for custom spread)", parseInt).option("--no-reversals", "Disable reversed cards").option("--json", "Output raw JSON").action(async (options) => {
+  const spinner = ora("Shuffling the deck...").start();
+  const result = await tarotDraw({
+    spread: options.spread,
+    question: options.question,
+    count: options.count,
+    reversals: options.reversals
+  });
+  spinner.stop();
+  if (isError(result)) {
+    console.error(chalk.red("Error: " + result.error));
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatTarotDraw(result));
+  }
+});
+program.command("tarot-card <card>").alias("card").description("Look up a tarot card by name or number").option("--json", "Output raw JSON").action(async (card, options) => {
+  const result = await tarotCard(card);
+  if (isError(result)) {
+    console.error(chalk.red("Error: " + result.error));
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatTarotCard(result));
+  }
+});
+program.command("tarot-deck").alias("deck").description("List tarot cards").option("-f, --filter <filter>", "Filter: major, minor, wands, cups, swords, pentacles").option("--json", "Output raw JSON").action(async (options) => {
+  const result = await tarotDeck(options.filter);
+  if (isError(result)) {
+    console.error(chalk.red("Error: " + result.error));
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatTarotDeck(result));
+  }
+});
+program.command("tarot-spreads").alias("spreads").description("List available tarot spreads").option("--json", "Output raw JSON").action(async (options) => {
+  const result = await tarotSpreads();
+  if (isError(result)) {
+    console.error(chalk.red("Error: " + result.error));
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatTarotSpreads(result));
+  }
+});
 console.log(chalk.dim(""));
-console.log(chalk.yellow("  \u{1315D}") + chalk.dim(" thoth-cli v0.2.21"));
+console.log(chalk.yellow("  \u{1315D}") + chalk.dim(" thoth-cli v0.2.23"));
 console.log(chalk.dim(""));
 program.parse();

package/dist/{chunk-QND56LGZ.js → chunk-X7IGMJUH.js}

@@ -514,6 +514,25 @@ async function ephemerisMulti(options) {
   if (options.lng !== void 0) args.push("--lng", String(options.lng));
   return execute("ephemeris-multi", args);
 }
+async function tarotDraw(options) {
+  const args = [];
+  if (options.count) args.push("--count", String(options.count));
+  if (options.spread) args.push("--spread", options.spread);
+  if (options.question) args.push("--question", options.question);
+  if (options.reversals === false) args.push("--no-reversals");
+  return execute("tarot-draw", args);
+}
+async function tarotCard(identifier) {
+  return execute("tarot-card", [identifier]);
+}
+async function tarotDeck(filter) {
+  const args = [];
+  if (filter) args.push("--filter", filter);
+  return execute("tarot-deck", args);
+}
+async function tarotSpreads() {
+  return execute("tarot-spreads", []);
+}
 
 // src/lib/format.ts
 import chalk from "chalk";
@@ -1434,6 +1453,159 @@ function formatEphemerisMulti(result) {
   lines.push("");
   return lines.join("\n");
 }
+var TAROT_COLORS = {
+  major: chalk.hex("#FFD700"),
+  // Gold for Major Arcana
+  wands: chalk.hex("#FF4500"),
+  // Fire - Orange Red
+  cups: chalk.hex("#4169E1"),
+  // Water - Royal Blue
+  swords: chalk.hex("#E0E0E0"),
+  // Air - Silver
+  pentacles: chalk.hex("#228B22")
+  // Earth - Forest Green
+};
+function getTarotColor(card) {
+  if (card.arcana === "major") return TAROT_COLORS.major;
+  return TAROT_COLORS[card.suit] || chalk.white;
+}
+function getSuitSymbol(suit) {
+  const symbols = {
+    wands: "\u{1F702}",
+    // Fire alchemical symbol
+    cups: "\u{1F704}",
+    // Water alchemical symbol
+    swords: "\u{1F701}",
+    // Air alchemical symbol
+    pentacles: "\u{1F703}"
+    // Earth alchemical symbol
+  };
+  return symbols[suit] || "";
+}
+function formatTarotDraw(result) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold.hex("#9932CC")("\u{1F3B4} TAROT READING"));
+  lines.push(`   ${chalk.dim("Spread:")} ${result.spread_name}`);
+  if (result.question) {
+    lines.push(`   ${chalk.dim("Question:")} "${result.question}"`);
+  }
+  lines.push(`   ${chalk.dim("Entropy:")} ${result.entropy_source}`);
+  lines.push(`   ${chalk.dim("Time:")} ${result.timestamp}`);
+  lines.push("");
+  lines.push(chalk.bold.cyan("\u2500\u2500 THE CARDS \u2500\u2500"));
+  lines.push("");
+  for (const card of result.cards) {
+    const color = getTarotColor(card);
+    const reversed = card.reversed ? chalk.red(" \u211E REVERSED") : "";
+    const suitSymbol = card.suit ? ` ${getSuitSymbol(card.suit)}` : "";
+    lines.push(`   ${chalk.bold.white(`[${card.position}] ${card.position_name}`)}`);
+    lines.push(`   ${color(card.name)}${suitSymbol}${reversed}`);
+    if (card.arcana === "major") {
+      const details = [];
+      if (card.hebrew) details.push(card.hebrew);
+      if (card.planet) details.push(`\u2609 ${card.planet}`);
+      if (card.zodiac) details.push(`\u2648 ${card.zodiac}`);
+      if (card.element) details.push(`\u25B3 ${card.element}`);
+      if (details.length > 0) {
+        lines.push(`   ${chalk.dim(details.join(" | "))}`);
+      }
+    } else {
+      const details = [];
+      if (card.element) details.push(`${card.element}`);
+      if (card.sephira) details.push(card.sephira);
+      if (card.theme) details.push(card.theme);
+      if (details.length > 0) {
+        lines.push(`   ${chalk.dim(details.join(" | "))}`);
+      }
+    }
+    const keywords = card.reversed ? card.keywords_reversed : card.keywords_upright;
+    if (keywords && keywords.length > 0) {
+      const keywordStr = keywords.slice(0, 5).join(", ");
+      lines.push(`   ${chalk.italic(keywordStr)}`);
+    }
+    lines.push("");
+  }
+  lines.push(chalk.dim("\u2500".repeat(60)));
+  lines.push(chalk.dim("   The cards are cast. The interpretation is yours."));
+  lines.push("");
+  return lines.join("\n");
+}
+function formatTarotCard(card) {
+  const lines = [];
+  const color = getTarotColor(card);
+  lines.push("");
+  lines.push(color(`\u{1F3B4} ${card.name}`));
+  lines.push(`   ${chalk.dim("Number:")} ${card.number} | ${chalk.dim("Arcana:")} ${card.arcana}`);
+  if (card.arcana === "major") {
+    if (card.hebrew) lines.push(`   ${chalk.dim("Hebrew:")} ${card.hebrew} | ${chalk.dim("Path:")} ${card.path}`);
+    if (card.planet) lines.push(`   ${chalk.dim("Planet:")} ${card.planet}`);
+    if (card.zodiac) lines.push(`   ${chalk.dim("Zodiac:")} ${card.zodiac}`);
+    if (card.element) lines.push(`   ${chalk.dim("Element:")} ${card.element}`);
+  } else {
+    lines.push(`   ${chalk.dim("Suit:")} ${card.suit} (${card.element})`);
+    lines.push(`   ${chalk.dim("Rank:")} ${card.rank} | ${chalk.dim("Sephira:")} ${card.sephira}`);
+    lines.push(`   ${chalk.dim("Theme:")} ${card.theme}`);
+  }
+  lines.push("");
+  lines.push(chalk.bold.green("   Upright:"));
+  lines.push(`   ${card.keywords_upright.join(", ")}`);
+  lines.push("");
+  lines.push(chalk.bold.red("   Reversed:"));
+  lines.push(`   ${card.keywords_reversed.join(", ")}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatTarotDeck(result) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold.hex("#9932CC")(`\u{1F3B4} TAROT DECK (${result.count} cards)`));
+  if (result.filter) {
+    lines.push(`   Filter: ${result.filter}`);
+  }
+  lines.push("");
+  const majors = result.cards.filter((c) => c.arcana === "major");
+  const wands = result.cards.filter((c) => c.suit === "wands");
+  const cups = result.cards.filter((c) => c.suit === "cups");
+  const swords = result.cards.filter((c) => c.suit === "swords");
+  const pentacles = result.cards.filter((c) => c.suit === "pentacles");
+  if (majors.length > 0) {
+    lines.push(TAROT_COLORS.major("\u2500\u2500 MAJOR ARCANA \u2500\u2500"));
+    for (const card of majors) {
+      lines.push(`   ${String(card.number).padStart(2)}. ${card.name}`);
+    }
+    lines.push("");
+  }
+  const suits = [
+    { name: "WANDS", cards: wands, color: TAROT_COLORS.wands, symbol: "\u{1F702}" },
+    { name: "CUPS", cards: cups, color: TAROT_COLORS.cups, symbol: "\u{1F704}" },
+    { name: "SWORDS", cards: swords, color: TAROT_COLORS.swords, symbol: "\u{1F701}" },
+    { name: "PENTACLES", cards: pentacles, color: TAROT_COLORS.pentacles, symbol: "\u{1F703}" }
+  ];
+  for (const suit of suits) {
+    if (suit.cards.length > 0) {
+      lines.push(suit.color(`\u2500\u2500 ${suit.symbol} ${suit.name} \u2500\u2500`));
+      for (const card of suit.cards) {
+        lines.push(`   ${String(card.number).padStart(2)}. ${card.name}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function formatTarotSpreads(result) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold.hex("#9932CC")("\u{1F3B4} AVAILABLE SPREADS"));
+  lines.push("");
+  for (const spread of result.spreads) {
+    lines.push(chalk.bold(`   ${spread.name} (${spread.id})`));
+    lines.push(`   ${chalk.dim(spread.description)}`);
+    lines.push(`   Cards: ${spread.count} \u2014 ${spread.positions.join(" \u2192 ")}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
 
 // src/types.ts
 function isError(result) {
@@ -1458,6 +1630,10 @@ export {
   moonExtended,
   transitScan,
   ephemerisMulti,
+  tarotDraw,
+  tarotCard,
+  tarotDeck,
+  tarotSpreads,
   getZodiacSymbol,
   getPlanetSymbol,
   getAspectSymbol,
@@ -1478,5 +1654,9 @@ export {
   formatMoonExtended,
   formatTransitScan,
   formatEphemerisMulti,
+  formatTarotDraw,
+  formatTarotCard,
+  formatTarotDeck,
+  formatTarotSpreads,
   isError
 };

package/dist/index.d.ts

@@ -498,6 +498,59 @@ interface ThothError {
 }
 type ThothResult<T> = T | ThothError;
 declare function isError<T extends object>(result: ThothResult<T>): result is ThothError;
+interface TarotCard {
+    number: number;
+    name: string;
+    arcana: 'major' | 'minor';
+    suit?: string;
+    rank?: string;
+    hebrew?: string;
+    path?: number;
+    element?: string;
+    planet?: string;
+    zodiac?: string;
+    domain?: string;
+    sephira?: string;
+    theme?: string;
+    keywords_upright: string[];
+    keywords_reversed: string[];
+    reversed?: boolean;
+    position?: number;
+    position_name?: string;
+}
+interface TarotDrawResult {
+    type: string;
+    timestamp: string;
+    entropy_source: string;
+    question?: string;
+    spread: string;
+    spread_name: string;
+    cards: TarotCard[];
+    total_cards: number;
+}
+interface TarotDrawOptions {
+    count?: number;
+    spread?: string;
+    question?: string;
+    reversals?: boolean;
+}
+interface TarotDeckResult {
+    type: string;
+    filter?: string;
+    count: number;
+    cards: TarotCard[];
+}
+interface TarotSpread {
+    id: string;
+    name: string;
+    count: number;
+    positions: string[];
+    description: string;
+}
+interface TarotSpreadsResult {
+    type: string;
+    spreads: TarotSpread[];
+}
 interface ScoreOptions {
     year1: number;
     month1: number;
@@ -747,6 +800,22 @@ declare function transitScan(options: TransitScanOptions): Promise<ThothResult<T
  * Get multi-body ephemeris over a date range
  */
 declare function ephemerisMulti(options: EphemerisMultiOptions): Promise<ThothResult<EphemerisMultiResult>>;
+/**
+ * Draw tarot cards with cryptographic randomness
+ */
+declare function tarotDraw(options: TarotDrawOptions): Promise<ThothResult<TarotDrawResult>>;
+/**
+ * Look up a specific tarot card
+ */
+declare function tarotCard(identifier: string): Promise<ThothResult<TarotCard>>;
+/**
+ * Get tarot deck (optionally filtered)
+ */
+declare function tarotDeck(filter?: string): Promise<ThothResult<TarotDeckResult>>;
+/**
+ * List available tarot spreads
+ */
+declare function tarotSpreads(): Promise<ThothResult<TarotSpreadsResult>>;
 
 /**
  * Output formatting utilities
@@ -833,5 +902,21 @@ declare function formatTransitScan(result: any): string;
  * Format multi-body ephemeris
  */
 declare function formatEphemerisMulti(result: any): string;
+/**
+ * Format a tarot draw result
+ */
+declare function formatTarotDraw(result: any): string;
+/**
+ * Format a single tarot card lookup
+ */
+declare function formatTarotCard(card: any): string;
+/**
+ * Format tarot deck listing
+ */
+declare function formatTarotDeck(result: any): string;
+/**
+ * Format available spreads
+ */
+declare function formatTarotSpreads(result: any): string;
 
-export { type Aspect, type ChartOptions, type ChartResult, type CompositeOptions, type CompositeResult, type DirectedPlanet, type EphemerisMultiOptions, type EphemerisMultiResult, type EphemerisOptions, type EphemerisPosition, type EphemerisRangeOptions, type EphemerisRangeResult, type EphemerisResult, type HoraryHouse, type HoraryOptions, type HoraryResult, type House, type LunarPhase, type LunarReturnOptions, type LunarReturnResult, type MoonAspect, type MoonExtendedOptions, type MoonExtendedResult, type MoonOptions, type MoonResult, type Planet, type ProgressionsOptions, type ProgressionsResult, type RetrogradeStation, type ScoreOptions, type ScoreResult, type SignChange, type SolarArcOptions, type SolarArcResult, type SolarReturnOptions, type SolarReturnResult, type SynastryOptions, type SynastryResult, type ThothError, type ThothResult, type TransitOptions, type TransitResult, type TransitScanOptions, type TransitScanResult, chart, composite, ephemeris, ephemerisMulti, ephemerisRange, formatChart, formatComposite, formatDegrees, formatEphemeris, formatEphemerisMulti, formatEphemerisRange, formatHorary, formatLunarReturn, formatMoon, formatMoonExtended, formatProgressions, formatScore, formatSolarArc, formatSolarReturn, formatSynastry, formatTransitScan, formatTransits, getAspectSymbol, getPlanetSymbol, getZodiacSymbol, horary, isError, lunarReturn, moon, moonExtended, progressions, score, solarArc, solarReturn, synastry, transit, transitScan, version };
+export { type Aspect, type ChartOptions, type ChartResult, type CompositeOptions, type CompositeResult, type DirectedPlanet, type EphemerisMultiOptions, type EphemerisMultiResult, type EphemerisOptions, type EphemerisPosition, type EphemerisRangeOptions, type EphemerisRangeResult, type EphemerisResult, type HoraryHouse, type HoraryOptions, type HoraryResult, type House, type LunarPhase, type LunarReturnOptions, type LunarReturnResult, type MoonAspect, type MoonExtendedOptions, type MoonExtendedResult, type MoonOptions, type MoonResult, type Planet, type ProgressionsOptions, type ProgressionsResult, type RetrogradeStation, type ScoreOptions, type ScoreResult, type SignChange, type SolarArcOptions, type SolarArcResult, type SolarReturnOptions, type SolarReturnResult, type SynastryOptions, type SynastryResult, type TarotCard, type TarotDeckResult, type TarotDrawOptions, type TarotDrawResult, type TarotSpread, type TarotSpreadsResult, type ThothError, type ThothResult, type TransitOptions, type TransitResult, type TransitScanOptions, type TransitScanResult, chart, composite, ephemeris, ephemerisMulti, ephemerisRange, formatChart, formatComposite, formatDegrees, formatEphemeris, formatEphemerisMulti, formatEphemerisRange, formatHorary, formatLunarReturn, formatMoon, formatMoonExtended, formatProgressions, formatScore, formatSolarArc, formatSolarReturn, formatSynastry, formatTarotCard, formatTarotDeck, formatTarotDraw, formatTarotSpreads, formatTransitScan, formatTransits, getAspectSymbol, getPlanetSymbol, getZodiacSymbol, horary, isError, lunarReturn, moon, moonExtended, progressions, score, solarArc, solarReturn, synastry, tarotCard, tarotDeck, tarotDraw, tarotSpreads, transit, transitScan, version };

package/dist/index.js

@@ -19,6 +19,10 @@ import {
   formatSolarArc,
   formatSolarReturn,
   formatSynastry,
+  formatTarotCard,
+  formatTarotDeck,
+  formatTarotDraw,
+  formatTarotSpreads,
   formatTransitScan,
   formatTransits,
   getAspectSymbol,
@@ -34,10 +38,14 @@ import {
   solarArc,
   solarReturn,
   synastry,
+  tarotCard,
+  tarotDeck,
+  tarotDraw,
+  tarotSpreads,
   transit,
   transitScan,
   version
-} from "./chunk-QND56LGZ.js";
+} from "./chunk-X7IGMJUH.js";
 export {
   chart,
   composite,
@@ -59,6 +67,10 @@ export {
   formatSolarArc,
   formatSolarReturn,
   formatSynastry,
+  formatTarotCard,
+  formatTarotDeck,
+  formatTarotDraw,
+  formatTarotSpreads,
   formatTransitScan,
   formatTransits,
   getAspectSymbol,
@@ -74,6 +86,10 @@ export {
   solarArc,
   solarReturn,
   synastry,
+  tarotCard,
+  tarotDeck,
+  tarotDraw,
+  tarotSpreads,
   transit,
   transitScan,
   version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-cli",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "𓅝 Astrological calculations from the command line. Swiss Ephemeris precision. Built for humans and agents.",
   "author": "AKLO <aklo@aklolabs.com>",
   "license": "MIT",