thinking-phrases 1.0.1 → 2.0.0

package/src/core/runner.ts

@@ -1,22 +1,27 @@
 import { resolve } from 'node:path';
-import process from 'node:process';
 import { execFileSync } from 'node:child_process';
+import process from 'node:process';
 import { outro, spinner } from '@clack/prompts';
 import pc from 'picocolors';
+
 import { DEFAULT_CONFIG, mergeConfig, parseArgs, readConfigFile, resolveConfigPath, validateConfig, writeConfigFile } from './config.js';
 import { buildModelArticlePhrases } from './githubModels.js';
 import {
   promptForConfigName,
-  promptForDynamicSchedulerAfterDryRun,
   promptForInteractiveOverrides,
   promptForPostDryRunAction,
   promptForStaticSchedulerAfterDryRun,
 } from './interactive.js';
+import { cacheModelResults, clearModelCache, getMergedPhrases, isSourceStale, markSourceFetched, partitionArticlesByModelCache, storePhrases } from './phraseCache.js';
 import { DEFAULT_SCHEDULER_INTERVAL_SECONDS, formatConfigPathForDisplay, getInstalledSchedulerInfo } from './scheduler.js';
 import { dynamicSources } from './sourceCatalog.js';
 import { getStaticPackByPath } from './staticPacks.js';
+import { TaskHealthTracker } from './taskHealth.js';
+import { formatArticlePhrase } from './phraseFormats.js';
 import type { ArticleItem, Config } from './types.js';
 import { dedupePhrases, loadDotEnv, logInfo, resolveSettingsPath, truncate } from './utils.js';
+
+import { hydrateArticleContent } from '../sources/rss.js';
 import { buildStockPhrase } from '../sources/stocks.js';
 import { removeVsCodeThinkingPhrases, writeVsCodeSettings } from '../sinks/vscodeSettings.js';
 
@@ -29,18 +34,17 @@ function buildBasicArticlePhrase(article: ArticleItem, config: Config): string |
     return null;
   }
 
-  const parts: string[] = [];
-  if (config.phraseFormatting.includeSource && article.source?.trim()) {
-    parts.push(article.source.trim());
-  }
-
-  parts.push(article.title.trim());
-
-  if (config.phraseFormatting.includeTime && article.time?.trim()) {
-    parts.push(article.time.trim());
-  }
-
-  return truncate(parts.join(' — '), config.phraseFormatting.maxLength);
+  return truncate(
+    formatArticlePhrase(
+      { source: article.source, title: article.title, time: article.time },
+      {
+        includeSource: config.phraseFormatting.includeSource,
+        includeTime: config.phraseFormatting.includeTime,
+        template: config.phraseFormatting.templates?.article,
+      },
+    ),
+    config.phraseFormatting.maxLength,
+  );
 }
 
 function buildBasicArticlePhrases(articles: ArticleItem[], config: Config): string[] {
@@ -66,6 +70,11 @@ function uninstallMacScheduler(): void {
   execFileSync('zsh', [uninstallPath], { stdio: 'inherit' });
 }
 
+function triggerMacSchedulerNow(): void {
+  const triggerPath = resolve(process.cwd(), 'scripts/trigger-thinking-phrases-scheduler.zsh');
+  execFileSync('zsh', [triggerPath], { stdio: 'inherit' });
+}
+
 function syncGitHubLookbackToScheduler(config: Config, intervalSeconds: number): Config {
   if (!config.githubActivity.enabled) {
     return config;
@@ -91,6 +100,8 @@ export async function runDynamicPhrases(): Promise<void> {
   const args = parseArgs(process.argv.slice(2));
   const isInteractive = Boolean(args.interactive);
   let uninstall = Boolean(args.uninstall);
+  const clearCache = Boolean(args.clearCache);
+  let triggerSchedulerNow = Boolean(args.triggerSchedulerNow);
   let createNewConfig = Boolean(args.createNewConfig);
   let dryRun = Boolean(args.dryRun);
   let installScheduler = Boolean(args.installScheduler);
@@ -101,6 +112,12 @@ export async function runDynamicPhrases(): Promise<void> {
   let configPath: string | undefined = resolveConfigPath(args.configPath);
   let fileConfig = configPath ? readConfigFile(configPath) : {};
   let config = mergeConfig(DEFAULT_CONFIG, fileConfig, args);
+
+  if (clearCache) {
+    clearModelCache();
+    logInfo(config, 'Model cache cleared');
+  }
+
   let interactivePass = 0;
   const interactiveSpinner = isInteractive ? spinner({ indicator: 'timer' }) : null;
   let interactiveSpinnerActive = false;
@@ -151,6 +168,7 @@ export async function runDynamicPhrases(): Promise<void> {
 
       interactivePass += 1;
       uninstall = Boolean(interactiveOverrides.uninstall);
+      triggerSchedulerNow = Boolean(interactiveOverrides.triggerSchedulerNow);
       createNewConfig = Boolean(interactiveOverrides.createNewConfig);
       dryRun = Boolean(interactiveOverrides.dryRun);
       installScheduler = Boolean(interactiveOverrides.installScheduler);
@@ -165,12 +183,27 @@ export async function runDynamicPhrases(): Promise<void> {
 
     const settingsPath = resolveSettingsPath(config.target, config.settingsPath);
 
+    if (triggerSchedulerNow) {
+      if (process.platform !== 'darwin') {
+        throw new Error('Scheduler triggering is currently only available on macOS.');
+      }
+
+      const installedScheduler = getInstalledSchedulerInfo();
+      if (!installedScheduler.installed) {
+        throw new Error('No macOS scheduler is currently installed.');
+      }
+
+      console.log(pc.cyan('Triggering macOS launchd scheduler now...'));
+      triggerMacSchedulerNow();
+      return;
+    }
+
     if (uninstall) {
       const removedThinkingPhrases = removeVsCodeThinkingPhrases(settingsPath);
       if (removedThinkingPhrases) {
-        console.log(pc.green(`Removed chat.agent.thinking.phrases from ${settingsPath}`));
+        console.log(pc.green(`Removed chat.agent.thinking.phrases from "${settingsPath}"`));
       } else {
-        console.log(pc.dim(`No chat.agent.thinking.phrases entry found in ${settingsPath}`));
+        console.log(pc.dim(`No chat.agent.thinking.phrases entry found in "${settingsPath}"`));
       }
 
       if (process.platform === 'darwin') {
@@ -194,7 +227,7 @@ export async function runDynamicPhrases(): Promise<void> {
       }
 
       if (dryRun) {
-        console.log(pc.bold(pc.cyan(`Dry run only — would write ${pack.phrases.length} phrases from ${pack.name} to ${settingsPath}`)));
+        console.log(pc.bold(pc.cyan(`Dry run only — would write ${pack.phrases.length} phrases from ${pack.name} to "${settingsPath}"`)));
         console.log(pc.dim('Preview:'));
         for (const phrase of pack.phrases.slice(0, 5)) {
           console.log(`${pc.green('•')} ${phrase}`);
@@ -228,7 +261,7 @@ export async function runDynamicPhrases(): Promise<void> {
       }
 
       writeVsCodeSettings(settingsPath, pack.phrases, pack.mode);
-      console.log(pc.green(`Updated ${settingsPath}`));
+      console.log(pc.green(`Updated "${settingsPath}"`));
       console.log(pc.bold(`Installed static pack ${pack.name} with ${pack.phrases.length} phrases.`));
 
       if (uninstallScheduler && process.platform === 'darwin') {
@@ -249,127 +282,227 @@ export async function runDynamicPhrases(): Promise<void> {
 
     validateConfig(config);
 
-    const enabledSources = dynamicSources.filter(source => source.isEnabled(config));
-    logInfo(config, `Running ${enabledSources.length} dynamic source(s)`);
-
-    let phrases: string[];
+    const healthTracker = new TaskHealthTracker({
+      dryRun,
+      configPath,
+      settingsPath,
+    });
 
     try {
-      startInteractiveProgress(`Fetching ${enabledSources.length} dynamic source${enabledSources.length === 1 ? '' : 's'}`);
-      const sourceItems = (await Promise.all(enabledSources.map(source => source.fetch(config)))).flat();
-      const articles = sourceItems.filter((item): item is ArticleItem => item.type === 'article');
-      const stocks = sourceItems.filter(item => item.type === 'stock');
-
-      startInteractiveProgress(`Preparing ${sourceItems.length} fetched item${sourceItems.length === 1 ? '' : 's'}`);
-      const stockPhrases = dedupePhrases(stocks.map(stock => buildStockPhrase(stock, config)));
-      const fallbackArticlePhrases = buildBasicArticlePhrases(articles, config);
-      const articlePhrases = config.githubModels.enabled && articles.length > 0
-        ? await buildModelArticlePhrases(articles, config, {
-            onProgress: startInteractiveProgress,
-          }).catch((error: unknown) => {
-            const message = error instanceof Error ? error.message : String(error);
-            console.warn(`GitHub Models formatting skipped — ${message}`);
-            startInteractiveProgress('GitHub Models unavailable, falling back to feed phrases');
-            return fallbackArticlePhrases;
+      const enabledSources = dynamicSources.filter(source => source.isEnabled(config));
+      // In dry-run or interactive mode, fetch everything regardless of intervals
+      const respectIntervals = !dryRun && !isInteractive;
+      const sourcesToFetch = respectIntervals
+        ? enabledSources.filter(source => {
+            const stale = isSourceStale(source.type, config);
+            if (!stale) {
+              logInfo(config, `Skipping ${source.type} — interval not elapsed`);
+            }
+
+            return stale;
           })
-        : fallbackArticlePhrases;
-
-      phrases = dedupePhrases([...stockPhrases, ...articlePhrases]);
-      stopInteractiveProgress(dryRun ? `Dry run ready — generated ${phrases.length} phrases` : `Generated ${phrases.length} phrases`);
-    } catch (error) {
-      failInteractiveProgress('Dynamic run failed');
-      throw error;
-    }
-
-    if (phrases.length === 0) {
-      throw new Error('No thinking phrases were generated from the configured sources.');
-    }
+        : enabledSources;
+
+      healthTracker.setSources(enabledSources.map(source => source.type));
+      healthTracker.setPhase('fetching-sources', `Running ${sourcesToFetch.length} of ${enabledSources.length} source${enabledSources.length === 1 ? '' : 's'}`);
+      logInfo(config, `Running ${sourcesToFetch.length} of ${enabledSources.length} enabled source(s) (${enabledSources.length - sourcesToFetch.length} skipped — not yet stale)`);
+
+      startInteractiveProgress(`Fetching ${sourcesToFetch.length} dynamic source${sourcesToFetch.length === 1 ? '' : 's'}`);
+      const sourceResults = await Promise.all(
+        sourcesToFetch.map(async source => {
+          healthTracker.startSource(source.type);
+          try {
+            const items = await source.fetch(config);
+            markSourceFetched(source.type);
+            healthTracker.completeSource(source.type, items.length);
+            return { type: source.type, items };
+          } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : String(error);
+            healthTracker.failSource(source.type, message);
+            throw error;
+          }
+        }),
+      );
+
+      // Build phrases per-source and persist to the phrase store
+      let totalArticles = 0;
+      let totalStocks = 0;
+      for (const { type, items } of sourceResults) {
+        const articles = items.filter((item): item is ArticleItem => item.type === 'article');
+        const stocks = items.filter(item => item.type === 'stock');
+        totalArticles += articles.length;
+        totalStocks += stocks.length;
+
+        startInteractiveProgress(`Preparing ${items.length} item${items.length === 1 ? '' : 's'} from ${type}`);
+        healthTracker.setPhase('formatting-phrases', `Preparing ${items.length} item${items.length === 1 ? '' : 's'} from ${type}`);
+
+        const stockPhrases = dedupePhrases(stocks.map(stock => buildStockPhrase(stock, config)));
+
+        // Articles with skipModelRewrite keep their displayPhrase as-is (e.g. weather conditions)
+        const modelEligible = articles.filter(a => !a.skipModelRewrite);
+        const preFormatted = articles.filter(a => a.skipModelRewrite);
+        const preFormattedPhrases = buildBasicArticlePhrases(preFormatted, config);
+
+        const hydratedArticles = config.githubModels.enabled && config.githubModels.fetchArticleContent
+          ? await hydrateArticleContent(modelEligible, config)
+          : modelEligible;
+
+        const fallbackArticlePhrases = buildBasicArticlePhrases(hydratedArticles, config);
+        let articlePhrases: string[];
+        if (config.githubModels.enabled && hydratedArticles.length > 0) {
+          const { uncached, cachedPhrases } = partitionArticlesByModelCache(hydratedArticles, config);
+          if (uncached.length === 0) {
+            logInfo(config, `All ${type} articles already in model cache — skipping GitHub Models API`);
+            articlePhrases = cachedPhrases.length > 0 ? cachedPhrases : fallbackArticlePhrases;
+          } else {
+            try {
+              const newPhrases = await buildModelArticlePhrases(uncached, config, {
+                sourceType: type,
+                onProgress: (message: string) => {
+                  startInteractiveProgress(message);
+                  healthTracker.setPhase('formatting-phrases', message);
+                },
+                onPhrases: (phrases: string[]) => {
+                  const latest = phrases[phrases.length - 1];
+                  if (latest) {
+                    const truncated = latest.length > 100 ? latest.slice(0, 100) + '…' : latest;
+                    startInteractiveProgress(`${pc.dim('•')} ${truncated}`);
+                  }
+                },
+              });
+              cacheModelResults(uncached, newPhrases, config);
+              articlePhrases = [...cachedPhrases, ...newPhrases];
+            } catch (error: unknown) {
+              const message = error instanceof Error ? error.message : String(error);
+              const warning = `GitHub Models formatting skipped for ${type} — ${message}`;
+              logInfo(config, warning);
+              healthTracker.addWarning(warning);
+              startInteractiveProgress('GitHub Models unavailable, falling back to feed phrases');
+              healthTracker.setPhase('formatting-phrases', 'GitHub Models unavailable, falling back to feed phrases');
+              articlePhrases = cachedPhrases.length > 0 ? [...cachedPhrases, ...fallbackArticlePhrases] : fallbackArticlePhrases;
+            }
+          }
+        } else {
+          articlePhrases = fallbackArticlePhrases;
+        }
 
-    if (dryRun) {
-      console.log(pc.bold(pc.cyan(`Dry run only — would write ${phrases.length} phrases to ${settingsPath}`)));
-      console.log(pc.dim('Preview:'));
-      for (const phrase of phrases.slice(0, 5)) {
-        console.log(`${pc.green('•')} ${phrase}`);
+        articlePhrases = dedupePhrases([...preFormattedPhrases, ...articlePhrases]);
+        const sourcePhrases = dedupePhrases([...stockPhrases, ...articlePhrases]);
+        storePhrases(type, sourcePhrases);
+        logInfo(config, `Stored ${sourcePhrases.length} phrases for ${type}`);
       }
 
-      if (!isInteractive) {
+      // Merge all stored phrases (freshly fetched + retained from previous runs)
+      // Fair round-robin ensures every source gets representation
+      const phrases = dedupePhrases(getMergedPhrases(config.limit));
+      stopInteractiveProgress(dryRun ? `Dry run ready — generated ${phrases.length} phrases` : `Generated ${phrases.length} phrases`);
+      if (phrases.length === 0 && sourcesToFetch.length === 0) {
+        logInfo(config, 'All sources still fresh — nothing to update this cycle');
+        healthTracker.succeed({ sourceCount: 0, articleCount: 0, stockCount: 0, phraseCount: 0 }, 'All sources still fresh');
         return;
       }
 
-      const nextAction = await promptForPostDryRunAction('dynamic phrases');
-      if (!nextAction || nextAction === 'exit') {
-        outro(pc.yellow('Interactive run finished after preview. No settings were changed.'));
-        return;
+      if (phrases.length === 0) {
+        throw new Error('No thinking phrases were generated from the configured sources.');
       }
 
-      if (nextAction === 'edit') {
-        continue;
-      }
+      const summary = {
+        sourceCount: enabledSources.length,
+        articleCount: totalArticles,
+        stockCount: totalStocks,
+        phraseCount: phrases.length,
+      };
 
-      dryRun = false;
-      if (process.platform === 'darwin') {
-        const schedulerOverrides = await promptForDynamicSchedulerAfterDryRun();
-        if (!schedulerOverrides) {
+      if (dryRun) {
+        console.log(pc.bold(pc.cyan(`Dry run only — would write ${phrases.length} phrases to "${settingsPath}"`)));
+        console.log(pc.dim('Preview:'));
+        for (const phrase of phrases.slice(0, 5)) {
+          console.log(`${pc.green('•')} ${phrase}`);
+        }
+
+        if (!isInteractive) {
+          healthTracker.succeed(summary, `Dry run generated ${phrases.length} phrases`);
           return;
         }
 
-        installScheduler = Boolean(schedulerOverrides.installScheduler);
-        schedulerIntervalSeconds = schedulerOverrides.schedulerIntervalSeconds ?? schedulerIntervalSeconds;
+        const nextAction = await promptForPostDryRunAction('dynamic phrases');
+        if (!nextAction || nextAction === 'exit') {
+          healthTracker.succeed(summary, `Dry run generated ${phrases.length} phrases`);
+          outro(pc.yellow('Interactive run finished after preview. No settings were changed.'));
+          return;
+        }
+
+        if (nextAction === 'edit') {
+          healthTracker.succeed(summary, `Dry run generated ${phrases.length} phrases`);
+          continue;
+        }
+
+        dryRun = false;
+        healthTracker.setDryRun(false);
+        // Scheduler config was already collected upfront in promptForInteractiveOverrides
         config = syncGitHubLookbackToScheduler(config, schedulerIntervalSeconds);
+
+        outro(pc.green('Installing dynamic phrases…'));
       }
 
-      outro(pc.green('Installing dynamic phrases…'));
-    }
+      if (isInteractive) {
+        if (createNewConfig) {
+          const namedConfigPath = await promptForConfigName(config);
+          if (!namedConfigPath) {
+            outro(pc.yellow('Interactive run cancelled. No settings were changed.'));
+            return;
+          }
 
-    if (isInteractive) {
-      if (createNewConfig) {
-        const namedConfigPath = await promptForConfigName(config);
-        if (!namedConfigPath) {
-          outro(pc.yellow('Interactive run cancelled. No settings were changed.'));
-          return;
+          configPath = resolveConfigPath(namedConfigPath);
+          schedulerConfigPath = namedConfigPath;
+          createNewConfig = false;
         }
 
-        configPath = resolveConfigPath(namedConfigPath);
-        schedulerConfigPath = namedConfigPath;
-        createNewConfig = false;
-      }
+        if (!configPath) {
+          throw new Error('Interactive config path was not resolved before save.');
+        }
 
-      if (!configPath) {
-        throw new Error('Interactive config path was not resolved before save.');
+        writeConfigFile(configPath, config);
+        console.log(pc.dim(`Saved dynamic config → ${formatConfigPathForDisplay(configPath)}`));
       }
 
-      writeConfigFile(configPath, config);
-      console.log(pc.dim(`Saved dynamic config → ${formatConfigPathForDisplay(configPath)}`));
-    }
-
-    writeVsCodeSettings(settingsPath, phrases, config.mode);
-    console.log(pc.green(`Updated ${settingsPath}`));
-    console.log(
-      pc.bold(
-        `Replaced thinking phrases with ${phrases.length} phrases from ${enabledSources.length} source(s)${config.githubModels.enabled ? ' using GitHub Models formatting when available' : ''}`,
-      ),
-    );
-
-    if (installScheduler && process.platform === 'darwin') {
-      config = syncGitHubLookbackToScheduler(config, schedulerIntervalSeconds);
-      const resolvedSchedulerConfigPath = resolveConfigPath(schedulerConfigPath ?? configPath ?? args.configPath);
-      writeConfigFile(resolvedSchedulerConfigPath, config);
-      console.log(pc.cyan(`Installing macOS launchd scheduler for every ${schedulerIntervalSeconds} seconds...`));
-      installMacScheduler(schedulerIntervalSeconds, resolvedSchedulerConfigPath);
-      console.log(pc.green(`Scheduler installed for every ${schedulerIntervalSeconds} seconds using ${resolvedSchedulerConfigPath}.`));
-    }
+      healthTracker.setPhase('writing-settings', `Writing ${phrases.length} phrases to VS Code settings`);
+      writeVsCodeSettings(settingsPath, phrases, config.mode);
+      console.log(pc.green(`Updated "${settingsPath}"`));
+      console.log(
+        pc.bold(
+          `Replaced thinking phrases with ${phrases.length} phrases from ${enabledSources.length} source(s)${config.githubModels.enabled ? ' using GitHub Models formatting when available' : ''}`,
+        ),
+      );
+
+      if (installScheduler && process.platform === 'darwin') {
+        healthTracker.setPhase('updating-scheduler', `Installing macOS scheduler for every ${schedulerIntervalSeconds} seconds`);
+        config = syncGitHubLookbackToScheduler(config, schedulerIntervalSeconds);
+        const resolvedSchedulerConfigPath = resolveConfigPath(schedulerConfigPath ?? configPath ?? args.configPath);
+        writeConfigFile(resolvedSchedulerConfigPath, config);
+        console.log(pc.cyan(`Installing macOS launchd scheduler for every ${schedulerIntervalSeconds} seconds...`));
+        installMacScheduler(schedulerIntervalSeconds, resolvedSchedulerConfigPath);
+        console.log(pc.green(`Scheduler installed for every ${schedulerIntervalSeconds} seconds using ${resolvedSchedulerConfigPath}.`));
+      }
 
-    if (process.platform === 'darwin') {
-      const installedScheduler = getInstalledSchedulerInfo();
-      if (installedScheduler.installed) {
-        console.log(
-          pc.dim(
-            `Scheduler status: installed${installedScheduler.intervalSeconds ? ` every ${installedScheduler.intervalSeconds}s` : ''} → ${formatConfigPathForDisplay(installedScheduler.configPath ?? configPath ?? resolveConfigPath(args.configPath))}`,
-          ),
-        );
+      if (process.platform === 'darwin') {
+        const installedScheduler = getInstalledSchedulerInfo();
+        if (installedScheduler.installed) {
+          console.log(
+            pc.dim(
+              `Scheduler status: installed${installedScheduler.intervalSeconds ? ` every ${installedScheduler.intervalSeconds}s` : ''} → ${formatConfigPathForDisplay(installedScheduler.configPath ?? configPath ?? resolveConfigPath(args.configPath))}`,
+            ),
+          );
+        }
       }
-    }
 
-    return;
+      healthTracker.succeed(summary, `Completed run with ${phrases.length} phrases from ${enabledSources.length} source(s)`);
+      return;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failInteractiveProgress('Dynamic run failed');
+      healthTracker.fail(message);
+      throw error;
+    }
   }
 }

package/src/core/scheduler.ts

@@ -5,7 +5,7 @@ import type { InstalledSchedulerInfo } from './types.js';
 
 export const SCHEDULER_LABEL = 'com.austenstone.thinking-phrases.rss';
 export const INSTALLED_PLIST_PATH = join(homedir(), 'Library', 'LaunchAgents', `${SCHEDULER_LABEL}.plist`);
-export const DEFAULT_SCHEDULER_INTERVAL_SECONDS = 300;
+export const DEFAULT_SCHEDULER_INTERVAL_SECONDS = 60;
 
 const IGNORED_DIRECTORIES = new Set(['.git', 'dist', 'node_modules', 'out']);