@johndimm/constellations 1.0.7 → 1.0.9

package/hooks/useSearchHandlers.ts

@@ -134,10 +134,22 @@ export function useSearchHandlers(options: UseSearchHandlersOptions) {
             // CRITICAL FIX: Only use kiosk domain context if the user hasn't provided a specific disambiguated term.
             // "Republic (Plato)" should NEVER get "Actors / Movies / TV" context.
             const hasDisambiguation = term.includes('(') && term.includes(')');
-            const wikiContext = (showControlPanel && !hasDisambiguation) ? selectedKioskDomain?.label : typeHint;
+            const wikiContext = [
+                !hasDisambiguation && showControlPanel ? selectedKioskDomain?.label : null,
+                typeHint,
+                type,
+            ].filter(Boolean).join(" ") || undefined;
 
             const wiki = await fetchWikipediaSummary(term, wikiContext);
-            const canonicalTitle = (wiki.title || term).trim();
+            let canonicalTitle = (wiki.title || term).trim();
+            const userFilmYear = term.match(/\((\d{4})\s*(?:film|movie|tv)/i)?.[1];
+            const wikiFilmYear = canonicalTitle.match(/\((\d{4})\s*(?:film|movie|tv)/i)?.[1];
+            if (userFilmYear && wikiFilmYear && userFilmYear !== wikiFilmYear) {
+                console.warn(
+                    `[Constellations] Wikipedia year mismatch for "${term}": got "${canonicalTitle}", keeping user term`
+                );
+                canonicalTitle = term.trim();
+            }
 
             // We no longer rewrite the user's query to the Wikipedia title.
             // This ensures "Republic (book)" stays as "Republic (book)" in the UI.
@@ -158,6 +170,7 @@ export function useSearchHandlers(options: UseSearchHandlersOptions) {
                 x: dim.width / 2,
                 y: dim.height / 2,
                 expanded: false,
+                year: wiki.year ?? undefined,
                 wikiSummary: wiki.extract || undefined,
                 classification_reasoning: reasoning,
                 atomic_type: chosenPair.atomicType,

package/host.ts

@@ -14,3 +14,4 @@ export { useFullPageConstellationsHost } from "./useFullPageConstellationsHost";
 export type { NowPlayingSnapshot } from "./useFullPageConstellationsHost";
 export { FullPageConstellationsHostLoading } from "./FullPageConstellationsHostShell";
 export { newChannelFromGraphNode } from "./utils/graphNodeToChannelNotes";
+export { filmWorkSearchTerm, extractYearFromFilmTitle } from "./utils/graphLogicUtils";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johndimm/constellations",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "type": "module",
   "main": "./index.tsx",
   "exports": {

package/services/aiUtils.ts

@@ -1,18 +1,93 @@
+/** Trim whitespace and optional wrapping quotes (common when pasting into Render/Vercel). */
+export function normalizeEnvSecret(raw: string | undefined | null): string {
+  if (raw == null) return "";
+  let s = String(raw).trim().replace(/^\uFEFF/, "");
+  if (
+    (s.startsWith('"') && s.endsWith('"')) ||
+    (s.startsWith("'") && s.endsWith("'"))
+  ) {
+    s = s.slice(1, -1).trim();
+  }
+  if (s.toLowerCase().startsWith("bearer ")) s = s.slice(7).trim();
+  // API keys must not contain whitespace; a mid-key line break keeps the last 4 chars "correct".
+  if (/^sk-/i.test(s)) s = s.replace(/\s+/g, "");
+  return s;
+}
+
+/** Node cache server: read secrets from process.env only (never import.meta build artifacts). */
+export function readServerEnv(...keys: string[]): string {
+  if (typeof process === "undefined" || !process.env) return "";
+  for (const key of keys) {
+    const v = normalizeEnvSecret(process.env[key]);
+    if (v) return v;
+  }
+  return "";
+}
+
+export function getOpenAiApiKey(): string {
+  if (typeof window === "undefined") {
+    return readServerEnv("VITE_OPENAI_API_KEY", "OPENAI_API_KEY");
+  }
+  return normalizeEnvSecret(readBundledEnv("VITE_OPENAI_API_KEY"));
+}
+
+/** OpenAI / OpenAI-compatible chat/completions request config (server-safe env reads). */
+export function getOpenAiCompatConfig(): {
+  apiKey: string;
+  baseUrl: string;
+  headers: Record<string, string>;
+} {
+  const apiKey = getOpenAiApiKey();
+  const baseUrlRaw =
+    typeof window === "undefined"
+      ? readServerEnv("VITE_OPENAI_BASE_URL", "OPENAI_BASE_URL")
+      : normalizeEnvSecret(readBundledEnv("VITE_OPENAI_BASE_URL"));
+  const baseUrl = (baseUrlRaw || "https://api.openai.com/v1").replace(/\/$/, "");
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+  };
+  const org = readServerEnv(
+    "VITE_OPENAI_ORG",
+    "OPENAI_ORG",
+    "VITE_OPENAI_ORGANIZATION",
+    "OPENAI_ORGANIZATION",
+  );
+  const project = readServerEnv("VITE_OPENAI_PROJECT", "OPENAI_PROJECT");
+  if (org) headers["OpenAI-Organization"] = org;
+  if (project) headers["OpenAI-Project"] = project;
+  return { apiKey, baseUrl, headers };
+}
+
+export function getDeepSeekApiKey(): string {
+  if (typeof window === "undefined") {
+    return readServerEnv("VITE_DEEPSEEK_API_KEY", "DEEPSEEK_API_KEY");
+  }
+  return normalizeEnvSecret(readBundledEnv("VITE_DEEPSEEK_API_KEY"));
+}
+
+export function getAnthropicApiKey(): string {
+  if (typeof window === "undefined") {
+    return readServerEnv("VITE_ANTHROPIC_API_KEY", "ANTHROPIC_API_KEY");
+  }
+  return normalizeEnvSecret(readBundledEnv("VITE_ANTHROPIC_API_KEY"));
+}
+
 /** Read a Vite-style env var from process (e.g. Next.js) or import.meta (Vite). */
 export function readBundledEnv(key: string): string {
-  const fromProcess = getEnvVar(key);
+  const fromProcess = normalizeEnvSecret(getEnvVar(key));
   if (fromProcess) return fromProcess;
   // Dual-bundler: Vite uses `VITE_*`; Next exposes the same values as `NEXT_PUBLIC_VITE_*`
   // (see apps/soundings/next.config `env`), not `NEXT_PUBLIC_*` with the `VITE_` infix stripped.
   const nextKey = key.startsWith("VITE_") ? `NEXT_PUBLIC_${key}` : key;
-  const alt = getEnvVar(nextKey);
+  const alt = normalizeEnvSecret(getEnvVar(nextKey));
   if (alt) return alt;
   try {
     // @ts-ignore
     if (typeof import.meta !== "undefined" && import.meta.env) {
       // @ts-ignore
       const v = import.meta.env[key];
-      if (v != null && String(v) !== "") return String(v);
+      if (v != null && String(v) !== "") return normalizeEnvSecret(String(v));
     }
   } catch {
     /* ignore */
@@ -25,17 +100,20 @@ export const getEnvVar = (name: string): string => {
   try {
     if (typeof process !== 'undefined' && process.env) {
       const val = process.env[name];
-      if (val) return val;
+      if (val != null && val !== "") return normalizeEnvSecret(val);
     }
   } catch (e) { }
 
+  // On the cache server, never fall back to import.meta (can embed stale client build keys).
+  if (typeof window === "undefined") return "";
+
   // Try import.meta.env (Vite / Browser)
   try {
     // @ts-ignore
     if (typeof import.meta !== 'undefined' && import.meta.env) {
       // @ts-ignore
       const val = import.meta.env[name];
-      if (val) return val;
+      if (val != null && val !== "") return normalizeEnvSecret(String(val));
     }
   } catch (e) { }
 

package/services/deepseekService.ts

@@ -1,6 +1,6 @@
 "use client";
 import { GeminiResponse, PersonWorksResponse, PathResponse } from "../types";
-import { parseJsonFromModelText, withTimeout, withRetry, getEnvCacheUrl, readBundledEnv, getLlmProvider, looksLikePersonName, getServerLlmModelOverride, getBrowserLlmModel, resolveAnthropicModel } from "./aiUtils";
+import { parseJsonFromModelText, withTimeout, withRetry, getEnvCacheUrl, readBundledEnv, readServerEnv, getLlmProvider, looksLikePersonName, getServerLlmModelOverride, getBrowserLlmModel, resolveAnthropicModel, getOpenAiCompatConfig, getDeepSeekApiKey, getAnthropicApiKey } from "./aiUtils";
 import type { LockedPair } from "./geminiService";
 
 export type { LockedPair };
@@ -8,6 +8,15 @@ export type { LockedPair };
 const TIMEOUT_MS = 60000;
 const CLASSIFY_TIMEOUT_MS = 15000;
 
+let loggedProviderKeyDiag = new Set<string>();
+
+function logProviderKeyOnce(provider: string, key: string) {
+  if (typeof window !== "undefined") return;
+  if (!key || loggedProviderKeyDiag.has(provider)) return;
+  loggedProviderKeyDiag.add(provider);
+  console.log(`[${provider}] API key loaded (…${key.slice(-4)}, len=${key.length})`);
+}
+
 function llmLogTag(): string {
   return `[${getLlmProvider()}]`;
 }
@@ -34,8 +43,9 @@ async function callAltLlm(system: string, user: string, timeoutMs = TIMEOUT_MS):
   const provider = getLlmProvider();
 
   if (provider === "anthropic") {
-    const key = readBundledEnv("VITE_ANTHROPIC_API_KEY");
-    if (!key) throw new Error("No VITE_ANTHROPIC_API_KEY set");
+    const key = getAnthropicApiKey();
+    if (!key) throw new Error("No VITE_ANTHROPIC_API_KEY or ANTHROPIC_API_KEY set");
+    logProviderKeyOnce("anthropic", key);
     const model = resolveAnthropicModel();
     const res = await fetch("https://api.anthropic.com/v1/messages", {
       method: "POST",
@@ -62,20 +72,30 @@ async function callAltLlm(system: string, user: string, timeoutMs = TIMEOUT_MS):
 
   // OpenAI-compatible: openai or deepseek
   const isOpenAI = provider === "openai";
+  const openAi = isOpenAI ? getOpenAiCompatConfig() : null;
   const baseUrl = isOpenAI
-    ? (readBundledEnv("VITE_OPENAI_BASE_URL") || "https://api.openai.com/v1")
-    : (readBundledEnv("VITE_DEEPSEEK_BASE_URL") || "https://api.deepseek.com/v1");
+    ? openAi!.baseUrl
+    : (typeof window === "undefined"
+        ? readServerEnv("VITE_DEEPSEEK_BASE_URL", "DEEPSEEK_BASE_URL")
+        : readBundledEnv("VITE_DEEPSEEK_BASE_URL")) || "https://api.deepseek.com/v1";
   const model = getServerLlmModelOverride() || (isOpenAI
-    ? (readBundledEnv("VITE_OPENAI_MODEL") || "gpt-4o-mini")
-    : (readBundledEnv("VITE_DEEPSEEK_MODEL") || "deepseek-chat"));
-  const key = isOpenAI
-    ? readBundledEnv("VITE_OPENAI_API_KEY")
-    : readBundledEnv("VITE_DEEPSEEK_API_KEY");
+    ? (typeof window === "undefined"
+        ? readServerEnv("VITE_OPENAI_MODEL", "OPENAI_MODEL")
+        : readBundledEnv("VITE_OPENAI_MODEL")) || "gpt-4o-mini"
+    : (typeof window === "undefined"
+        ? readServerEnv("VITE_DEEPSEEK_MODEL", "DEEPSEEK_MODEL")
+        : readBundledEnv("VITE_DEEPSEEK_MODEL")) || "deepseek-chat");
+  const key = isOpenAI ? openAi!.apiKey : getDeepSeekApiKey();
   if (!key) throw new Error(`No API key set for ${provider}`);
+  logProviderKeyOnce(provider, key);
+
+  const headers = isOpenAI
+    ? { ...openAi!.headers }
+    : { "Content-Type": "application/json", Authorization: `Bearer ${key}` };
 
   const res = await fetch(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
     method: "POST",
-    headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
+    headers,
     body: JSON.stringify({
       model,
       messages: [
@@ -87,6 +107,16 @@ async function callAltLlm(system: string, user: string, timeoutMs = TIMEOUT_MS):
   });
   if (!res.ok) {
     const err = await res.text();
+    if (res.status === 401 && isOpenAI) {
+      console.error("[openai] 401 — check key is active, billing, and base URL", {
+        baseUrl,
+        model,
+        keyLen: key.length,
+        keySuffix: key.slice(-4),
+        hasOpenAIOrganization: !!headers["OpenAI-Organization"],
+        hasOpenAIProject: !!headers["OpenAI-Project"],
+      });
+    }
     throw new Error(`${provider} API error (${res.status}): ${err}`);
   }
   const data = await res.json();

package/services/wikipediaService.ts

@@ -653,6 +653,10 @@ export const fetchWikipediaSummary = async (
     const baseQuery = query.replace(/\s*\(.*\)\s*/g, '').trim();
     const parenMatch = query.match(/\((.*)\)/);
     const paren = parenMatch ? parenMatch[1] : null;
+    const queryYear =
+      (paren || cleanQuery).match(/(\d{4})/)?.[1] ||
+      (context || "").match(/\b(18|19|20)\d{2}\b/)?.[0] ||
+      null;
 
     // We search for the base query but include the parenthetical as additional context
     // This is more robust than a literal search for "Republic (book)" which ranks partial matches poorly.
@@ -703,6 +707,14 @@ export const fetchWikipediaSummary = async (
           if (snippet.includes(parenLower)) s += 200;
         }
 
+        // Film/TV year disambiguation: "Django" + 1966 must not become Django (2017 film).
+        if (queryYear) {
+          const titleYear = title.match(/\((\d{4})\s*(?:film|movie|tv)/i)?.[1];
+          if (titleYear === queryYear) s += 5000;
+          else if (titleYear && titleYear !== queryYear) s -= 5000;
+          if (snippet.includes(queryYear)) s += 400;
+        }
+
         // Music disambiguation: prefer musician/band pages over generic title definitions.
         const musicCtx = contextIndicatesMusic(context);
         const bizCtx = contextIndicatesBusiness(context);

package/useFullPageConstellationsHost.ts

@@ -9,9 +9,9 @@ export type NowPlayingSnapshot = {
 };
 
 /** Append performer when a bare title is ambiguous (e.g. "Summertime" vs "In the Summertime"). */
-function nowPlayingSearchTerm(track: string, artist: string): string {
-  const t = track.trim();
-  const a = artist.trim();
+function nowPlayingSearchTerm(track: string | undefined, artist: string | undefined): string {
+  const t = (track ?? "").trim();
+  const a = (artist ?? "").trim();
   if (!t) return a;
   if (!a) return t;
   if (t.toLowerCase().includes(a.toLowerCase())) return t;
@@ -85,7 +85,7 @@ export function useFullPageConstellationsHost(input: {
     const album = snap?.album?.trim();
     const track = snap?.track?.trim();
     const artist = snap?.artist?.trim();
-    const searchTerm = nowPlayingSearchTerm(track, artist);
+    const searchTerm = nowPlayingSearchTerm(track ?? "", artist ?? "");
     const mergedExpand = [
       ...extra,
       ...(album ? [album] : []),

package/utils/graphLogicUtils.ts

@@ -14,6 +14,36 @@ export const looksLikeScreenWork = (title: string, desc?: string) => {
     );
 };
 
+/** Year from a Wikipedia-style title, e.g. "Django (1966 film)" → 1966 */
+export function extractYearFromFilmTitle(title: string): number | null {
+    const paren = title.match(/\((\d{4})\s*(?:film|movie|tv)/i);
+    if (paren) return parseInt(paren[1], 10);
+    const bare = title.match(/\b(18|19|20)\d{2}\b/);
+    return bare ? parseInt(bare[0], 10) : null;
+}
+
+/**
+ * Build a Wikipedia-friendly seed for films/TV (Trailer, etc.).
+ * "Django" + 1966 → "Django (1966 film)" so we don't land on Django (2017 film).
+ */
+export function filmWorkSearchTerm(
+    title: string,
+    year?: number | null,
+    type?: string | null
+): string {
+    const t = title.replace(/\s+/g, " ").trim();
+    if (!t) return t;
+    if (/\(\d{4}\s*(?:film|movie|tv)/i.test(t)) return t;
+    const y = year ?? extractYearFromFilmTitle(t);
+    if (!y) return t;
+    const base = t.replace(/\s*\([^)]*\)\s*$/, "").trim() || t;
+    const kind =
+        type === "tv" || /\b(tv series|television)\b/i.test(String(type || ""))
+            ? "TV series"
+            : "film";
+    return `${base} (${y} ${kind})`;
+}
+
 export const isBadListPage = (t?: string) => {
     const s = String(t || '').toLowerCase();
     if (!s) return false;