whale-igniter 1.1.0

package/dist/scanner/tailwindMapper.js

@@ -0,0 +1,58 @@
+/**
+ * Pixel → Tailwind class mapper.
+ *
+ * The scanner reads classes and produces pixel values; this module does
+ * the reverse, so the generator can write code that respects the
+ * project's foundations using the canonical Tailwind names instead of
+ * arbitrary-value escape hatches.
+ *
+ * When the exact px value doesn't have a Tailwind class (e.g. grid=5px,
+ * but Tailwind has no `p-1.25`), we fall back to the arbitrary value
+ * syntax (`p-[5px]`). That's worse than a token class but better than
+ * silently rounding.
+ */
+const SPACING_PX_TO_SUFFIX = {
+    0: "0", 1: "px", 2: "0.5", 4: "1", 6: "1.5", 8: "2", 10: "2.5", 12: "3",
+    14: "3.5", 16: "4", 20: "5", 24: "6", 28: "7", 32: "8", 36: "9", 40: "10",
+    44: "11", 48: "12", 56: "14", 64: "16", 80: "20", 96: "24", 112: "28",
+    128: "32", 144: "36", 160: "40", 176: "44", 192: "48", 208: "52", 224: "56",
+    240: "60", 256: "64", 288: "72", 320: "80", 384: "96"
+};
+const RADIUS_PX_TO_SUFFIX = {
+    0: "none",
+    2: "sm",
+    4: "", // bare `rounded`
+    6: "md",
+    8: "lg",
+    12: "xl",
+    16: "2xl",
+    24: "3xl",
+    9999: "full"
+};
+export function spacingClass(prefix, px) {
+    const suffix = SPACING_PX_TO_SUFFIX[px];
+    if (suffix !== undefined)
+        return `${prefix}-${suffix}`;
+    return `${prefix}-[${px}px]`;
+}
+export function radiusClass(prefix, px) {
+    const suffix = RADIUS_PX_TO_SUFFIX[px];
+    if (suffix !== undefined) {
+        return suffix === "" ? prefix : `${prefix}-${suffix}`;
+    }
+    return `${prefix}-[${px}px]`;
+}
+/**
+ * Pick the most common color name to use as the project accent. We
+ * fall back to "blue" because that's Tailwind's de facto convention
+ * and matches the default `accent` in whale's config.
+ */
+export function accentColorFamily(accent) {
+    if (!accent)
+        return "blue";
+    const known = ["slate", "gray", "zinc", "neutral", "stone", "red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose"];
+    const lower = accent.toLowerCase();
+    if (known.includes(lower))
+        return lower;
+    return "blue";
+}

package/dist/scanner/tailwindScanner.js

@@ -0,0 +1,186 @@
+import fs from "fs-extra";
+import path from "node:path";
+// Tailwind's default spacing scale, in pixels. We use this when no tailwind.config is found.
+// Keys are the suffix used in classes (e.g. "4" in "p-4"), values are pixel sizes.
+const DEFAULT_SPACING_SCALE = {
+    "0": 0, "px": 1, "0.5": 2, "1": 4, "1.5": 6, "2": 8, "2.5": 10, "3": 12,
+    "3.5": 14, "4": 16, "5": 20, "6": 24, "7": 28, "8": 32, "9": 36, "10": 40,
+    "11": 44, "12": 48, "14": 56, "16": 64, "20": 80, "24": 96, "28": 112,
+    "32": 128, "36": 144, "40": 160, "44": 176, "48": 192, "52": 208, "56": 224,
+    "60": 240, "64": 256, "72": 288, "80": 320, "96": 384
+};
+// Tailwind's default radius scale.
+const DEFAULT_RADIUS_SCALE = {
+    none: 0, sm: 2, "": 4, md: 6, lg: 8, xl: 12, "2xl": 16, "3xl": 24, full: 9999
+};
+// Spacing-related class prefixes. The captured group is the value suffix.
+// Order matters — longer prefixes first to avoid `m-` matching `mt-`.
+const SPACING_PREFIXES = [
+    "px-", "py-", "pt-", "pb-", "pl-", "pr-", "ps-", "pe-", "p-",
+    "mx-", "my-", "mt-", "mb-", "ml-", "mr-", "ms-", "me-", "m-",
+    "gap-x-", "gap-y-", "gap-",
+    "space-x-", "space-y-"
+];
+// Radius prefixes — full first, then sided.
+const RADIUS_PREFIXES = [
+    "rounded-t-", "rounded-b-", "rounded-l-", "rounded-r-",
+    "rounded-tl-", "rounded-tr-", "rounded-bl-", "rounded-br-",
+    "rounded-"
+];
+// Bare radius class (`rounded`) with no suffix.
+const BARE_RADIUS = /^rounded$/;
+const COLOR_PREFIXES = ["bg-", "text-", "border-", "ring-", "fill-", "stroke-", "from-", "to-", "via-"];
+const BORDER_WIDTH = /^border(?:-[a-z]+)?(?:-(\d+))?$/;
+const RING_WIDTH = /^ring(?:-(\d+))?$/;
+const RING_OFFSET = /^ring-offset(?:-(\d+))?$/;
+const FONT_SIZE = /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/;
+const SHADOW = /^shadow(-[a-z0-9-]+)?$/;
+function stripVariantPrefixes(cls) {
+    // Tailwind variants like `hover:`, `md:`, `dark:`, `focus-visible:`.
+    // Multiple variants can stack: `dark:md:hover:p-4`. Take everything
+    // after the last `:`.
+    const lastColon = cls.lastIndexOf(":");
+    return lastColon >= 0 ? cls.slice(lastColon + 1) : cls;
+}
+function isNegative(value) {
+    // Tailwind allows negative spacing: `-mt-4`. The negative goes in front of the prefix.
+    return value.startsWith("-");
+}
+function parseArbitraryPx(value) {
+    // value example: "[10px]" or "[1.5rem]". Returns pixels.
+    const m = value.match(/^\[([0-9.]+)(px|rem|em)?\]$/);
+    if (!m)
+        return null;
+    const n = parseFloat(m[1]);
+    const unit = m[2] ?? "px";
+    if (unit === "px")
+        return n;
+    if (unit === "rem" || unit === "em")
+        return n * 16; // assume default root = 16
+    return null;
+}
+function classifyClass(cls) {
+    const stripped = stripVariantPrefixes(cls);
+    const neg = isNegative(stripped);
+    const base = neg ? stripped.slice(1) : stripped;
+    // Spacing
+    for (const prefix of SPACING_PREFIXES) {
+        if (base.startsWith(prefix)) {
+            const suffix = base.slice(prefix.length);
+            if (suffix.startsWith("[") && suffix.endsWith("]")) {
+                const px = parseArbitraryPx(suffix);
+                return { raw: cls, kind: "spacing", pxValue: px === null ? null : neg ? -px : px, colorToken: null, isArbitrary: true };
+            }
+            const scaled = DEFAULT_SPACING_SCALE[suffix];
+            return {
+                raw: cls,
+                kind: "spacing",
+                pxValue: scaled === undefined ? null : neg ? -scaled : scaled,
+                colorToken: null,
+                isArbitrary: false
+            };
+        }
+    }
+    // Radius
+    for (const prefix of RADIUS_PREFIXES) {
+        if (base.startsWith(prefix)) {
+            const suffix = base.slice(prefix.length);
+            if (suffix.startsWith("[") && suffix.endsWith("]")) {
+                return { raw: cls, kind: "radius", pxValue: parseArbitraryPx(suffix), colorToken: null, isArbitrary: true };
+            }
+            const scaled = DEFAULT_RADIUS_SCALE[suffix];
+            return {
+                raw: cls,
+                kind: "radius",
+                pxValue: scaled === undefined ? null : scaled,
+                colorToken: null,
+                isArbitrary: false
+            };
+        }
+    }
+    if (BARE_RADIUS.test(base)) {
+        return { raw: cls, kind: "radius", pxValue: DEFAULT_RADIUS_SCALE[""], colorToken: null, isArbitrary: false };
+    }
+    // Font size — must check before color because `text-sm` would also match the `text-` color prefix.
+    if (FONT_SIZE.test(base)) {
+        return { raw: cls, kind: "font-size", pxValue: null, colorToken: null, isArbitrary: false };
+    }
+    // Ring width / offset — match before color because `ring-` is in COLOR_PREFIXES too.
+    const ringMatch = base.match(RING_WIDTH);
+    if (ringMatch) {
+        const px = ringMatch[1] ? parseInt(ringMatch[1], 10) : 3; // tailwind default ring is 3px
+        return { raw: cls, kind: "border-width", pxValue: px, colorToken: null, isArbitrary: false };
+    }
+    const ringOffsetMatch = base.match(RING_OFFSET);
+    if (ringOffsetMatch) {
+        const px = ringOffsetMatch[1] ? parseInt(ringOffsetMatch[1], 10) : 0;
+        return { raw: cls, kind: "border-width", pxValue: px, colorToken: null, isArbitrary: false };
+    }
+    // Color
+    for (const prefix of COLOR_PREFIXES) {
+        if (base.startsWith(prefix)) {
+            const suffix = base.slice(prefix.length);
+            if (suffix.startsWith("[") && suffix.endsWith("]")) {
+                return { raw: cls, kind: "color", pxValue: null, colorToken: suffix, isArbitrary: true };
+            }
+            // bg-blue-500, bg-primary, bg-white, bg-transparent
+            return { raw: cls, kind: "color", pxValue: null, colorToken: suffix, isArbitrary: false };
+        }
+    }
+    // Border width
+    const borderMatch = base.match(BORDER_WIDTH);
+    if (borderMatch && !base.startsWith("border-t-") && !base.startsWith("border-b-")) {
+        const px = borderMatch[1] ? parseInt(borderMatch[1], 10) : 1;
+        return { raw: cls, kind: "border-width", pxValue: px, colorToken: null, isArbitrary: false };
+    }
+    // Shadow
+    if (SHADOW.test(base)) {
+        return { raw: cls, kind: "shadow", pxValue: null, colorToken: null, isArbitrary: false };
+    }
+    return null;
+}
+/**
+ * Aggregate Tailwind observations from a list of raw className strings.
+ * Each className string can contain multiple space-separated classes;
+ * we tokenize and classify each, then count occurrences.
+ */
+export function aggregateTailwind(classNameStrings) {
+    const map = new Map();
+    for (const str of classNameStrings) {
+        if (!str)
+            continue;
+        const tokens = str.split(/\s+/).filter(Boolean);
+        for (const tok of tokens) {
+            const obs = classifyClass(tok);
+            if (!obs)
+                continue;
+            const key = obs.raw;
+            const existing = map.get(key);
+            if (existing) {
+                existing.count += 1;
+            }
+            else {
+                map.set(key, { ...obs, count: 1 });
+            }
+        }
+    }
+    return Array.from(map.values()).sort((a, b) => b.count - a.count);
+}
+/**
+ * Try to read tailwind.config.{js,ts,mjs,cjs} to override default scales.
+ * We use a conservative approach: don't execute the file (no eval, no
+ * dynamic import — security and reliability), just check existence and
+ * report it in the inference.
+ *
+ * Properly reading the resolved Tailwind config requires running the
+ * tailwindcss preset machinery, which is out of scope for v0.8. The
+ * default scales catch ~95% of usage in our fixtures.
+ */
+export async function detectTailwindConfig(target) {
+    const candidates = ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs", "tailwind.config.cjs"];
+    for (const c of candidates) {
+        if (await fs.pathExists(path.join(target, c)))
+            return c;
+    }
+    return null;
+}

package/dist/selene/apiClient.js

@@ -0,0 +1,168 @@
+/**
+ * Selene API clients.
+ *
+ * Two providers, one abstraction. Native fetch — no SDK dependencies.
+ * SDKs add weight, version-lock us to one API shape, and pull in
+ * tokenizers and types we don't need. Both APIs are extremely simple
+ * for the single "send a prompt, get text back" use case, so we hit
+ * them directly.
+ *
+ * Errors are mapped to a normalised shape so the command layer can
+ * handle them uniformly. We deliberately surface the provider's own
+ * error message verbatim — those are usually accurate ("invalid_api_key",
+ * "model_not_found", rate limit, etc.) and editing them obscures the
+ * real cause.
+ */
+export async function callProvider(resolved, params) {
+    if (resolved.provider === "anthropic")
+        return callAnthropic(resolved, params);
+    if (resolved.provider === "openai")
+        return callOpenAI(resolved, params);
+    // Compile-time exhaustiveness check — if we add a provider, this errors.
+    const _exhaustive = resolved.provider;
+    return { ok: false, error: `Unknown provider: ${String(_exhaustive)}`, retryable: false };
+}
+// ---------------------------------------------------------------------------
+// Anthropic Messages API
+// ---------------------------------------------------------------------------
+async function callAnthropic(resolved, params) {
+    // We split the prompt: a stable "system" portion (project context +
+    // identity) would normally let Anthropic cache it, but we don't have
+    // a clean structural split here because the prompt builder produces
+    // a single Markdown blob. We send the whole thing as a single user
+    // message; that's correct, just not optimal for cache hits.
+    //
+    // Future: split promptBuilder output into {system, user} pieces and
+    // pass them separately to enable prompt caching. Out of scope here.
+    const body = {
+        model: resolved.model,
+        max_tokens: params.maxTokens,
+        temperature: params.temperature,
+        messages: [{ role: "user", content: params.prompt }]
+    };
+    try {
+        const resp = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": resolved.apiKey,
+                "anthropic-version": "2023-06-01"
+            },
+            body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+            const errText = await resp.text();
+            return {
+                ok: false,
+                status: resp.status,
+                error: `Anthropic ${resp.status}: ${errText.slice(0, 500)}`,
+                retryable: resp.status === 429 || resp.status >= 500
+            };
+        }
+        const data = (await resp.json());
+        // Anthropic returns content blocks; we concatenate the text ones.
+        const text = (data.content ?? [])
+            .filter((b) => b.type === "text")
+            .map((b) => b.text ?? "")
+            .join("")
+            .trim();
+        return {
+            ok: true,
+            text,
+            inputTokens: data.usage?.input_tokens ?? null,
+            outputTokens: data.usage?.output_tokens ?? null
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `Network error: ${message}`, retryable: true };
+    }
+}
+// ---------------------------------------------------------------------------
+// OpenAI Chat Completions API
+// ---------------------------------------------------------------------------
+async function callOpenAI(resolved, params) {
+    const body = {
+        model: resolved.model,
+        max_tokens: params.maxTokens,
+        temperature: params.temperature,
+        messages: [{ role: "user", content: params.prompt }]
+    };
+    try {
+        const resp = await fetch("https://api.openai.com/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${resolved.apiKey}`
+            },
+            body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+            const errText = await resp.text();
+            return {
+                ok: false,
+                status: resp.status,
+                error: `OpenAI ${resp.status}: ${errText.slice(0, 500)}`,
+                retryable: resp.status === 429 || resp.status >= 500
+            };
+        }
+        const data = (await resp.json());
+        const text = (data.choices?.[0]?.message?.content ?? "").trim();
+        return {
+            ok: true,
+            text,
+            inputTokens: data.usage?.prompt_tokens ?? null,
+            outputTokens: data.usage?.completion_tokens ?? null
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `Network error: ${message}`, retryable: true };
+    }
+}
+// ---------------------------------------------------------------------------
+// Cost estimation (very rough, off-by-design)
+// ---------------------------------------------------------------------------
+/**
+ * Rough token estimate from a prompt string. We assume ~4 chars/token,
+ * which is the rule of thumb for English Latin-script text. Code is
+ * denser (~3 chars/token); we err on the high side intentionally so
+ * cost estimates skew pessimistic.
+ *
+ * If you want real numbers, run `whale selene status --tokens` after
+ * calls and look at the actual usage; we record it.
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 3.5);
+}
+/**
+ * Pricing (USD per 1M tokens) for the default models. We deliberately
+ * don't hardcode every model — these are approximations for confirmCost
+ * messages, not invoices. Users should check the provider's pricing
+ * page for accuracy.
+ *
+ * Source: vendor pricing pages, accessed early 2026. Update opportunistically.
+ */
+const APPROX_PRICING = {
+    // Anthropic
+    "claude-sonnet-4-6": { input: 3.0, output: 15.0 },
+    "claude-opus-4-7": { input: 15.0, output: 75.0 },
+    "claude-haiku-4-5": { input: 1.0, output: 5.0 },
+    // OpenAI
+    "gpt-4.1": { input: 2.5, output: 10.0 },
+    "gpt-4.1-mini": { input: 0.4, output: 1.6 }
+};
+export function estimateCostUsd(model, inputTokens, expectedOutputTokens) {
+    // Try exact model match, then prefix match (handles e.g. "claude-opus-4-7-20260101").
+    let pricing = APPROX_PRICING[model];
+    if (!pricing) {
+        const prefix = Object.keys(APPROX_PRICING).find((k) => model.startsWith(k));
+        if (prefix)
+            pricing = APPROX_PRICING[prefix];
+    }
+    if (!pricing)
+        return null;
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (expectedOutputTokens / 1_000_000) * pricing.output;
+    return inputCost + outputCost;
+}

package/dist/selene/cache.js

@@ -0,0 +1,68 @@
+/**
+ * On-disk cache for Selene API responses.
+ *
+ * Why: identical prompts run in quick succession (re-running a command,
+ * iterating on a workflow) shouldn't pay twice. The cache key is the
+ * sha256 of (model + prompt), so any meaningful change to either
+ * invalidates. TTL defaults to 7 days; old files are pruned lazily on
+ * read.
+ *
+ * Caveats. We cache the *response text*, not usage tokens or cost — those
+ * are zero on a cache hit. We don't cache failures. If the user wants
+ * a fresh call, they can pass --no-cache or delete the cache dir.
+ */
+import path from "node:path";
+import fs from "fs-extra";
+import { createHash } from "node:crypto";
+const CACHE_DIR_REL = ".whale/selene/cache";
+const DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+function cacheKey(model, prompt) {
+    return createHash("sha256").update(`${model}\n${prompt}`).digest("hex").slice(0, 32);
+}
+export async function readCache(target, model, prompt, ttlMs = DEFAULT_TTL_MS) {
+    const key = cacheKey(model, prompt);
+    const file = path.join(target, CACHE_DIR_REL, `${key}.json`);
+    if (!(await fs.pathExists(file)))
+        return null;
+    try {
+        const entry = (await fs.readJson(file));
+        const ageMs = Date.now() - new Date(entry.storedAt).getTime();
+        if (ageMs > ttlMs) {
+            // Expired — clean up lazily so the cache doesn't grow unbounded.
+            await fs.remove(file).catch(() => undefined);
+            return null;
+        }
+        return entry.text;
+    }
+    catch {
+        // Corrupt file — remove and treat as miss.
+        await fs.remove(file).catch(() => undefined);
+        return null;
+    }
+}
+export async function writeCache(target, model, prompt, text) {
+    const key = cacheKey(model, prompt);
+    const dir = path.join(target, CACHE_DIR_REL);
+    await fs.ensureDir(dir);
+    const entry = {
+        key,
+        model,
+        text,
+        storedAt: new Date().toISOString()
+    };
+    await fs.writeJson(path.join(dir, `${key}.json`), entry, { spaces: 2 });
+}
+export async function clearCache(target) {
+    const dir = path.join(target, CACHE_DIR_REL);
+    if (!(await fs.pathExists(dir)))
+        return 0;
+    const files = await fs.readdir(dir);
+    let removed = 0;
+    for (const f of files) {
+        if (f.endsWith(".json")) {
+            await fs.remove(path.join(dir, f));
+            removed += 1;
+        }
+    }
+    return removed;
+}

package/dist/selene/clipboard.js

@@ -0,0 +1,56 @@
+/**
+ * Copy text to the system clipboard without an npm dependency.
+ *
+ * We try in order: pbcopy (macOS), clip.exe (Windows / WSL), wl-copy
+ * (Wayland), xclip (X11), xsel (X11). If none works the function
+ * returns false; the caller should then print the text so the user can
+ * still copy it manually.
+ *
+ * Reasoning: every clipboard npm package adds a dependency and forces
+ * the user to think about install. For a CLI tool whose hot path is
+ * "generate a prompt the user pastes elsewhere", a 50-line shell-out
+ * approach is more robust and has zero install cost.
+ */
+import { spawn } from "node:child_process";
+function platformStrategies() {
+    const p = process.platform;
+    if (p === "darwin")
+        return [{ cmd: "pbcopy", args: [] }];
+    if (p === "win32")
+        return [{ cmd: "clip.exe", args: [] }];
+    // Linux / *nix: try Wayland first, then X11.
+    return [
+        { cmd: "wl-copy", args: [] },
+        { cmd: "xclip", args: ["-selection", "clipboard"] },
+        { cmd: "xsel", args: ["--clipboard", "--input"] }
+    ];
+}
+async function tryCopy(strategy, text) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(ok);
+        };
+        try {
+            const child = spawn(strategy.cmd, strategy.args, { stdio: ["pipe", "ignore", "ignore"] });
+            child.on("error", () => finish(false));
+            child.on("close", (code) => finish(code === 0));
+            child.stdin.write(text);
+            child.stdin.end();
+        }
+        catch {
+            finish(false);
+        }
+    });
+}
+export async function copyToClipboard(text) {
+    for (const strat of platformStrategies()) {
+        const ok = await tryCopy(strat, text);
+        if (ok)
+            return true;
+    }
+    return false;
+}