thinking-phrases 1.0.1 → 2.0.0

package/src/core/interactive.ts

@@ -5,7 +5,7 @@ import { CONFIG_PATH, DEFAULT_CONFIG, mergeConfig, readConfigFile, resolveConfig
 import { discoverConfigProfiles, formatConfigPathForDisplay, getInstalledSchedulerInfo } from './scheduler.js';
 import { discoverStaticPacks } from './staticPacks.js';
 import type { CliOverrides, Config, FeedConfig } from './types.js';
-import { isValidUsZipCode, normalizeSymbols, normalizeUsZipCode } from './utils.js';
+import { detectZipFromIp, isValidUsZipCode, normalizeSymbols, normalizeUsZipCode } from './utils.js';
 
 interface InteractivePromptOptions {
 	showIntro?: boolean;
@@ -205,11 +205,16 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 	}
 
 	const installKind = await select({
-		message: 'What kind of thinking phrases do you want to install?',
+		message: installedScheduler?.installed
+			? 'What do you want to do with thinking phrases?'
+			: 'What kind of thinking phrases do you want to install?',
 		initialValue: 'dynamic',
 		options: [
 			{ value: 'dynamic', label: 'Dynamic phrases', hint: 'RSS, stocks, models, scheduler support' },
-			{ value: 'static', label: 'Static pack', hint: `${staticPacks.length} generated packs available` },
+			{ value: 'static', label: 'Static pack', hint: `${staticPacks.length} static packs available` },
+			...(installedScheduler?.installed
+				? [{ value: 'trigger', label: 'Trigger installed scheduler now', hint: 'Run the current launchd job immediately' }]
+				: []),
 			{ value: 'uninstall', label: 'Uninstall', hint: 'Remove thinking phrases and scheduler' },
 		],
 	});
@@ -218,6 +223,19 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		return cancelFlow('Interactive run cancelled. No settings were changed.');
 	}
 
+	if (installKind === 'trigger') {
+		note(
+			[
+				`${pc.bold('Action')}    ${pc.green('trigger installed scheduler now')}`,
+				`${pc.bold('Scheduler')} ${pc.cyan(installedScheduler?.label ?? 'com.austenstone.thinking-phrases.rss')}`,
+				`${pc.bold('Config')}     ${pc.yellow(formatConfigPathForDisplay(installedScheduler?.configPath ?? CONFIG_PATH))}`,
+			].join('\n'),
+			'Run summary',
+		);
+
+		return finishFlow({ triggerSchedulerNow: true }, 'Triggering installed scheduler…');
+	}
+
 	if (installKind === 'uninstall') {
 		note(
 			[
@@ -330,10 +348,10 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 
 	const isNewConfig = selectedConfigOption === '__new__';
 	const selectedConfigPath = isNewConfig ? undefined : selectedConfigOption;
-	let selectedConfig = selectedConfigPath
+	const selectedConfig = selectedConfigPath
 		? mergeConfig(DEFAULT_CONFIG, readConfigFile(resolveConfigPath(selectedConfigPath)), {})
 		: DEFAULT_CONFIG;
-	let startWithNoSourcesSelected = isNewConfig;
+	const startWithNoSourcesSelected = isNewConfig;
 
 	const selectedSources = await multiselect({
 		message: 'Which sources do you want to use?',
@@ -424,7 +442,6 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		}
 
 		overrides.feeds = parseCsv(keepExistingValue(feedInput, existingFeeds)).map(url => ({ url } satisfies FeedConfig));
-
 	}
 
 	if (useStocks) {
@@ -432,6 +449,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const symbolInput = await text({
 			message: 'Stock symbols',
 			placeholder: existingSymbols || 'MSFT NVDA TSLA',
+			initialValue: existingSymbols,
 			validate(value) {
 				return normalizeSymbols(parseSymbolInput(keepExistingValue(value, existingSymbols))).length > 0
 					? undefined
@@ -465,11 +483,17 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const existingZipCode = selectedConfig.earthquakes.zipCode?.trim()
 			|| selectedConfig.weatherAlerts.zipCode?.trim()
 			|| '';
+
+		// Auto-detect ZIP from IP if not already configured
+		const detectedZip = existingZipCode || await detectZipFromIp();
+		const defaultZip = detectedZip || '';
+
 		const zipCodeInput = await text({
 			message: useEarthquakes && useWeatherAlerts ? 'ZIP code for local earthquake + weather lookups' : useEarthquakes ? 'ZIP code for local earthquake lookups' : 'ZIP code for local weather lookups',
-			placeholder: existingZipCode || '33312',
+			placeholder: defaultZip || '33312',
+			initialValue: defaultZip,
 			validate(value) {
-				const zipCode = normalizeUsZipCode(keepExistingValue(value, existingZipCode));
+				const zipCode = normalizeUsZipCode(keepExistingValue(value, defaultZip));
 				return zipCode && isValidUsZipCode(zipCode) ? undefined : 'Enter a valid 5-digit US ZIP code.';
 			},
 		});
@@ -478,7 +502,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 			return cancelFlow('Interactive run cancelled. No settings were changed.');
 		}
 
-		resolvedZipCode = normalizeUsZipCode(keepExistingValue(zipCodeInput, existingZipCode));
+		resolvedZipCode = normalizeUsZipCode(keepExistingValue(zipCodeInput, defaultZip));
 	}
 
 	if (useHackerNews) {
@@ -563,6 +587,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonUrl = await text({
 			message: 'JSON endpoint URL',
 			placeholder: existingJsonUrl || 'https://example.com/api/articles.json',
+			initialValue: existingJsonUrl,
 			validate(value) {
 				const resolvedValue = keepExistingValue(value, existingJsonUrl);
 				if (!resolvedValue.trim()) {
@@ -586,6 +611,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonItemsPath = await text({
 			message: 'Array path inside the JSON payload',
 			placeholder: existingItemsPath || 'items',
+			initialValue: existingItemsPath,
 		});
 
 		if (isCancel(customJsonItemsPath)) {
@@ -596,6 +622,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonTitleField = await text({
 			message: 'Title field path',
 			placeholder: existingTitleField || 'title',
+			initialValue: existingTitleField,
 			validate(value) {
 				return keepExistingValue(value, existingTitleField).trim() ? undefined : 'Enter a field path for the title.';
 			},
@@ -609,6 +636,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonContentField = await text({
 			message: 'Optional content field path',
 			placeholder: existingContentField || 'summary',
+			initialValue: existingContentField,
 		});
 
 		if (isCancel(customJsonContentField)) {
@@ -619,6 +647,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonLinkField = await text({
 			message: 'Optional link field path',
 			placeholder: existingLinkField || 'url',
+			initialValue: existingLinkField,
 		});
 
 		if (isCancel(customJsonLinkField)) {
@@ -629,6 +658,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonSourceField = await text({
 			message: 'Optional source field path',
 			placeholder: existingSourceField || 'source.name',
+			initialValue: existingSourceField,
 		});
 
 		if (isCancel(customJsonSourceField)) {
@@ -639,6 +669,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonSourceLabel = await text({
 			message: 'Fallback source label',
 			placeholder: existingSourceLabel || 'My API',
+			initialValue: existingSourceLabel,
 		});
 
 		if (isCancel(customJsonSourceLabel)) {
@@ -649,6 +680,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonDateField = await text({
 			message: 'Optional published date field path',
 			placeholder: existingDateField || 'publishedAt',
+			initialValue: existingDateField,
 		});
 
 		if (isCancel(customJsonDateField)) {
@@ -659,6 +691,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonIdField = await text({
 			message: 'Optional unique ID field path',
 			placeholder: existingIdField || 'id',
+			initialValue: existingIdField,
 		});
 
 		if (isCancel(customJsonIdField)) {
@@ -669,6 +702,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		const customJsonLimit = await text({
 			message: 'How many JSON items should be included?',
 			placeholder: existingJsonLimit,
+			initialValue: existingJsonLimit,
 			validate(value) {
 				const parsed = Number(keepExistingValue(value, existingJsonLimit));
 				return Number.isInteger(parsed) && parsed > 0 ? undefined : 'Enter a positive integer.';
@@ -895,24 +929,6 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 		};
 	}
 
-	if (useRss) {
-		const existingLimit = String(selectedConfig.limit);
-		const limitInput = await text({
-			message: 'How many RSS items should be considered?',
-			initialValue: existingLimit,
-			validate(value) {
-				const parsed = Number(keepExistingValue(value, existingLimit));
-				return Number.isInteger(parsed) && parsed > 0 ? undefined : 'Enter a positive integer.';
-			},
-		});
-
-		if (isCancel(limitInput)) {
-			return cancelFlow('Interactive run cancelled. No settings were changed.');
-		}
-
-		overrides.limit = Number(keepExistingValue(limitInput, existingLimit));
-	}
-
 	overrides.mode = 'replace';
 
 	const shouldDryRun = await confirm({
@@ -926,29 +942,12 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 
 	overrides.dryRun = shouldDryRun;
 
-	if (!overrides.dryRun && process.platform === 'darwin') {
+	// Always collect scheduler config upfront so the user isn't blocked after a long run
+	if (process.platform === 'darwin') {
 		overrides.installScheduler = true;
 		overrides.schedulerConfigPath = selectedConfigPath;
-
-		const existingInterval = String(installedScheduler?.intervalSeconds ?? 300);
-		const intervalInput = await text({
-			message: installedScheduler?.installed
-				? 'How often should the scheduler run? Enter interval in seconds'
-				: 'How often should it run? Enter interval in seconds',
-			placeholder: '300',
-			initialValue: existingInterval,
-			validate(value) {
-				const parsed = Number(keepExistingValue(value, existingInterval));
-				return Number.isInteger(parsed) && parsed > 0 ? undefined : 'Enter a positive integer in seconds.';
-			},
-		});
-
-		if (isCancel(intervalInput)) {
-			return cancelFlow('Interactive run cancelled. No settings were changed.');
-		}
-
-		overrides.schedulerIntervalSeconds = Number(keepExistingValue(intervalInput, existingInterval));
-	} else if (!overrides.dryRun && process.platform !== 'darwin') {
+		overrides.schedulerIntervalSeconds = installedScheduler?.intervalSeconds ?? 60;
+	} else if (!overrides.dryRun) {
 		note(
 			pc.dim('Scheduler install is currently only wired for macOS launchd. Settings will still be written.'),
 			'Scheduler',
@@ -969,7 +968,7 @@ export async function promptForInteractiveOverrides(config: Config, options: Int
 			`${pc.bold('Models')}   ${overrides.githubModels?.enabled ? pc.magenta('enabled') : pc.dim('disabled')}`,
 				`${pc.bold('Mode')}     ${pc.yellow(overrides.mode ?? selectedConfig.mode)}`,
 			`${pc.bold('Action')}   ${overrides.dryRun ? pc.blue('preview only') : pc.green('write settings')}`,
-			`${pc.bold('Schedule')} ${overrides.installScheduler ? pc.green(`every ${overrides.schedulerIntervalSeconds ?? 300}s`) : pc.dim('not installing')}`,
+			`${pc.bold('Schedule')} ${overrides.installScheduler ? pc.green(`every ${overrides.schedulerIntervalSeconds ?? 60}s (per-source intervals in config)`) : pc.dim('not installing')}`,
 			`${pc.bold('Config')}   ${isNewConfig ? pc.cyan('new config (auto-name if blank)') : pc.cyan(selectedConfigPath ?? '')}`,
 		].join('\n'),
 		'Run summary',
@@ -1016,26 +1015,9 @@ export async function promptForConfigName(config: Pick<Config, 'feeds' | 'stockQ
 export async function promptForDynamicSchedulerAfterDryRun(): Promise<Pick<CliOverrides, 'installScheduler' | 'schedulerIntervalSeconds'> | null> {
 	const installedScheduler = process.platform === 'darwin' ? getInstalledSchedulerInfo() : null;
 
-	const existingInterval = String(installedScheduler?.intervalSeconds ?? 300);
-	const intervalInput = await text({
-		message: installedScheduler?.installed
-			? 'How often should the scheduler run? Enter interval in seconds'
-			: 'How often should it run? Enter interval in seconds',
-		placeholder: '300',
-		initialValue: existingInterval,
-		validate(value) {
-			const parsed = Number(keepExistingValue(value, existingInterval));
-			return Number.isInteger(parsed) && parsed > 0 ? undefined : 'Enter a positive integer in seconds.';
-		},
-	});
-
-	if (isCancel(intervalInput)) {
-		return null;
-	}
-
 	return {
 		installScheduler: true,
-		schedulerIntervalSeconds: Number(keepExistingValue(intervalInput, existingInterval)),
+		schedulerIntervalSeconds: installedScheduler?.intervalSeconds ?? 60,
 	};
 }
 

package/src/core/phraseCache.ts

@@ -0,0 +1,242 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import type { ArticleItem, Config } from './types.js';
+import { logDebug, logInfo } from './utils.js';
+
+const CACHE_DIR = join(homedir(), '.cache', 'thinking-phrases');
+const SOURCE_TIMESTAMPS_FILE = join(CACHE_DIR, 'source-timestamps.json');
+const MODEL_CACHE_FILE = join(CACHE_DIR, 'model-cache.json');
+const DEFAULT_CACHE_TTL_SECONDS = 604800; // 7 days
+
+type SourceTimestamps = Record<string, number>;
+
+interface ModelCacheEntry {
+  phrases: string[];
+  cachedAt: number; // epoch ms
+}
+
+type ModelCache = Record<string, ModelCacheEntry>;
+
+function ensureCacheDir(): void {
+  if (!existsSync(CACHE_DIR)) {
+    mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+
+function readJson<T>(filePath: string, fallback: T): T {
+  if (!existsSync(filePath)) {
+    return fallback;
+  }
+
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8')) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath: string, data: unknown): void {
+  ensureCacheDir();
+  writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+// --- Source fetch interval tracking ---
+
+function readSourceTimestamps(): SourceTimestamps {
+  return readJson<SourceTimestamps>(SOURCE_TIMESTAMPS_FILE, {});
+}
+
+function writeSourceTimestamps(timestamps: SourceTimestamps): void {
+  writeJson(SOURCE_TIMESTAMPS_FILE, timestamps);
+}
+
+/**
+ * Returns the configured fetchIntervalSeconds for a given source type.
+ * RSS feeds use a top-level `rssFetchIntervalSeconds` since each feed doesn't
+ * map 1:1 to a source config block.
+ */
+export function getSourceIntervalSeconds(sourceType: string, config: Config): number {
+  switch (sourceType) {
+    case 'rss': return config.rssFetchIntervalSeconds;
+    case 'stocks': return config.stockQuotes.fetchIntervalSeconds ?? 60;
+    case 'hacker-news': return config.hackerNews.fetchIntervalSeconds ?? 300;
+    case 'earthquakes': return config.earthquakes.fetchIntervalSeconds ?? 1800;
+    case 'weather-alerts': return config.weatherAlerts.fetchIntervalSeconds ?? 1800;
+    case 'custom-json': return config.customJson.fetchIntervalSeconds ?? 3600;
+    case 'github-activity': return config.githubActivity.fetchIntervalSeconds ?? 300;
+    default: return 300;
+  }
+}
+
+/**
+ * Check whether a source should be fetched based on its per-source interval.
+ * Returns true if the source is stale (interval elapsed) or has never been fetched.
+ */
+export function isSourceStale(sourceType: string, config: Config): boolean {
+  const timestamps = readSourceTimestamps();
+  const lastFetch = timestamps[sourceType];
+  if (lastFetch === undefined) {
+    return true;
+  }
+
+  const intervalMs = getSourceIntervalSeconds(sourceType, config) * 1000;
+  const elapsed = Date.now() - lastFetch;
+  return elapsed >= intervalMs;
+}
+
+/**
+ * Record that a source was successfully fetched right now.
+ */
+export function markSourceFetched(sourceType: string): void {
+  const timestamps = readSourceTimestamps();
+  timestamps[sourceType] = Date.now();
+  writeSourceTimestamps(timestamps);
+}
+
+// --- Model result deduplication cache ---
+
+function readModelCache(): ModelCache {
+  return readJson<ModelCache>(MODEL_CACHE_FILE, {});
+}
+
+function writeModelCache(cache: ModelCache): void {
+  writeJson(MODEL_CACHE_FILE, cache);
+}
+
+export function clearModelCache(): void {
+  ensureCacheDir();
+  writeJson(MODEL_CACHE_FILE, {});
+}
+
+/**
+ * Prune model cache entries older than the configured TTL.
+ */
+function pruneModelCache(cache: ModelCache, ttlSeconds: number): ModelCache {
+  const cutoff = Date.now() - ttlSeconds * 1000;
+  const pruned: ModelCache = {};
+  for (const [id, entry] of Object.entries(cache)) {
+    if (entry.cachedAt >= cutoff) {
+      pruned[id] = entry;
+    }
+  }
+
+  return pruned;
+}
+
+/**
+ * Split articles into those that need model processing and those that already
+ * have cached phrases. Returns the cached phrases for the already-processed ones.
+ */
+export function partitionArticlesByModelCache(
+  articles: ArticleItem[],
+  config: Config,
+): { uncached: ArticleItem[]; cachedPhrases: string[] } {
+  const ttl = config.githubModels.cacheTtlSeconds ?? DEFAULT_CACHE_TTL_SECONDS;
+  const cache = pruneModelCache(readModelCache(), ttl);
+  const uncached: ArticleItem[] = [];
+  const cachedPhrases: string[] = [];
+
+  for (const article of articles) {
+    const entry = cache[article.id];
+    if (entry) {
+      logDebug(config, `Model cache hit for "${article.title ?? article.id}"`);
+      cachedPhrases.push(...entry.phrases);
+    } else {
+      uncached.push(article);
+    }
+  }
+
+  logInfo(config, `Model cache: ${cachedPhrases.length} cached phrases, ${uncached.length} articles need processing`);
+  return { uncached, cachedPhrases };
+}
+
+/**
+ * Save model-generated phrases keyed by article ID so we never re-process them.
+ * Maps each phrase back to its source article via a simple index-based heuristic:
+ * phrases are distributed round-robin across the input articles.
+ *
+ * For better accuracy, call this per-chunk where articles and phrases align tightly.
+ */
+export function cacheModelResults(articles: ArticleItem[], phrases: string[], config: Config): void {
+  const ttl = config.githubModels.cacheTtlSeconds ?? DEFAULT_CACHE_TTL_SECONDS;
+  const cache = pruneModelCache(readModelCache(), ttl);
+  const maxPerArticle = config.githubModels.maxPhrasesPerArticle;
+
+  // Best-effort: assign phrases to articles in order, up to maxPhrasesPerArticle each
+  let phraseIndex = 0;
+  for (const article of articles) {
+    const articlePhrases: string[] = [];
+    while (phraseIndex < phrases.length && articlePhrases.length < maxPerArticle) {
+      articlePhrases.push(phrases[phraseIndex]);
+      phraseIndex += 1;
+    }
+
+    cache[article.id] = { phrases: articlePhrases, cachedAt: Date.now() };
+  }
+
+  // Overflow phrases (more output than articles) are dropped — they'd accumulate
+  // under unique keys and never get reused.
+
+  writeModelCache(cache);
+}
+
+// --- Phrase store (merge across fetch intervals) ---
+
+const PHRASE_STORE_FILE = join(CACHE_DIR, 'phrase-store.json');
+
+type PhraseStore = Record<string, {
+  phrases: string[];
+  updatedAt: number;
+}>;
+
+function readPhraseStore(): PhraseStore {
+  return readJson<PhraseStore>(PHRASE_STORE_FILE, {});
+}
+
+function writePhraseStore(store: PhraseStore): void {
+  writeJson(PHRASE_STORE_FILE, store);
+}
+
+/**
+ * Persist phrases for a source type so they survive across runs
+ * where the source isn't re-fetched (interval not elapsed).
+ */
+export function storePhrases(sourceType: string, phrases: string[]): void {
+  const store = readPhraseStore();
+  store[sourceType] = { phrases, updatedAt: Date.now() };
+  writePhraseStore(store);
+}
+
+/**
+ * Merge stored phrases with fair round-robin distribution across sources.
+ * Each source contributes proportionally so no single source dominates.
+ */
+export function getMergedPhrases(limit: number): string[] {
+  const store = readPhraseStore();
+  const entries = Object.values(store).filter(e => e.phrases.length > 0);
+  if (entries.length === 0) return [];
+
+  const result: string[] = [];
+  const perSource = Math.max(1, Math.ceil(limit / entries.length));
+
+  // First pass: give each source its fair share
+  for (const entry of entries) {
+    result.push(...entry.phrases.slice(0, perSource));
+  }
+
+  // Second pass: fill remaining slots from sources that have more
+  if (result.length < limit) {
+    for (const entry of entries) {
+      const remaining = entry.phrases.slice(perSource);
+      for (const phrase of remaining) {
+        if (result.length >= limit) break;
+        if (!result.includes(phrase)) {
+          result.push(phrase);
+        }
+      }
+    }
+  }
+
+  return result.slice(0, limit);
+}