thinking-phrases 1.0.1

package/src/core/types.ts

@@ -0,0 +1,177 @@
+export type Mode = 'append' | 'replace';
+export type Target = 'auto' | 'insiders' | 'stable';
+export type HackerNewsFeed = 'top' | 'new' | 'best' | 'ask' | 'show' | 'jobs';
+export type EarthquakeOrder = 'time' | 'magnitude';
+export type WeatherSeverity = 'minor' | 'moderate' | 'severe' | 'extreme';
+export type GitHubActivityMode = 'repo-commits' | 'org-commits' | 'feed';
+export type GitHubFeedKind = 'timeline' | 'current-user-public' | 'current-user' | 'current-user-actor' | 'security-advisories' | 'organization' | 'custom-url';
+
+export interface FeedConfig {
+	url: string;
+	source?: string;
+}
+
+export interface PhraseFormatting {
+	includeSource: boolean;
+	includeTime: boolean;
+	maxLength: number;
+}
+
+export interface GitHubModelsConfig {
+	enabled: boolean;
+	model: string;
+	tokenEnvVar: string;
+	maxInputItems: number;
+	maxTokens: number;
+	maxPhrasesPerArticle: number;
+	temperature: number;
+	fetchArticleContent: boolean;
+	maxArticleContentLength: number;
+	systemPrompt?: string;
+}
+
+export interface StockQuoteConfig {
+	enabled: boolean;
+	symbols: string[];
+	includeMarketState: boolean;
+}
+
+export interface HackerNewsConfig {
+	enabled: boolean;
+	feed: HackerNewsFeed;
+	maxItems: number;
+	minScore: number;
+}
+
+export interface EarthquakeConfig {
+	enabled: boolean;
+	zipCode?: string;
+	minMagnitude: number;
+	windowHours: number;
+	limit: number;
+	place?: string;
+	radiusKm: number;
+	orderBy: EarthquakeOrder;
+}
+
+export interface WeatherAlertsConfig {
+	enabled: boolean;
+	zipCode?: string;
+	area?: string;
+	minimumSeverity: WeatherSeverity;
+	limit: number;
+}
+
+export interface CustomJsonConfig {
+	enabled: boolean;
+	url: string;
+	itemsPath?: string;
+	titleField: string;
+	contentField?: string;
+	linkField?: string;
+	sourceField?: string;
+	sourceLabel?: string;
+	dateField?: string;
+	idField?: string;
+	maxItems: number;
+}
+
+export interface GitHubActivityConfig {
+	enabled: boolean;
+	mode: GitHubActivityMode;
+	repo?: string;
+	org?: string;
+	branch?: string;
+	feedKind: GitHubFeedKind;
+	feedUrl?: string;
+	maxItems: number;
+	sinceHours: number;
+	tokenEnvVar: string;
+}
+
+export interface Config {
+	feeds: FeedConfig[];
+	limit: number;
+	mode: Mode;
+	target: Target;
+	settingsPath?: string;
+	verbose?: boolean;
+	debug?: boolean;
+	phraseFormatting: PhraseFormatting;
+	githubModels: GitHubModelsConfig;
+	stockQuotes: StockQuoteConfig;
+	hackerNews: HackerNewsConfig;
+	earthquakes: EarthquakeConfig;
+	weatherAlerts: WeatherAlertsConfig;
+	customJson: CustomJsonConfig;
+	githubActivity: GitHubActivityConfig;
+}
+
+export interface CliOverrides extends Partial<Config> {
+	dryRun?: boolean;
+	interactive?: boolean;
+	uninstall?: boolean;
+	createNewConfig?: boolean;
+	installScheduler?: boolean;
+	uninstallScheduler?: boolean;
+	schedulerIntervalSeconds?: number;
+	configPath?: string;
+	schedulerConfigPath?: string;
+	staticPackPath?: string;
+}
+
+export interface GitHubModelsResponse {
+	choices?: Array<{
+		message?: {
+			content?: string;
+		};
+	}>;
+}
+
+export interface ArticleItem {
+	type: 'article';
+	id: string;
+	title?: string;
+	displayPhrase?: string;
+	link?: string;
+	source?: string;
+	datetime?: string;
+	time?: string;
+	content?: string;
+	articleContent?: string;
+}
+
+export interface StockItem {
+	type: 'stock';
+	id: string;
+	symbol: string;
+	price: number;
+	currency?: string;
+	changePercent?: number;
+	marketLabel?: string;
+}
+
+export type PhraseItem = ArticleItem | StockItem;
+
+export interface PhraseSource {
+	type: string;
+	isEnabled(config: Config): boolean;
+	fetch(config: Config): Promise<PhraseItem[]>;
+}
+
+export interface InstalledSchedulerInfo {
+	installed: boolean;
+	label: string;
+	plistPath: string;
+	intervalSeconds?: number;
+	configPath?: string;
+}
+
+export interface StaticPackInfo {
+	name: string;
+	fileName: string;
+	path: string;
+	mode: Mode;
+	phrases: string[];
+}
+

package/src/core/utils.ts

@@ -0,0 +1,312 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+import process from 'node:process';
+import type { Config, Target } from './types.js';
+
+export interface ZipLocation {
+  zipCode: string;
+  placeName: string;
+  state: string;
+  stateAbbreviation: string;
+  latitude: number;
+  longitude: number;
+}
+
+export const USER_AGENT = 'thinking-phrases/1.0 (+https://github.com/austenstone/thinking-phrases)';
+
+export function logInfo(config: Pick<Config, 'verbose'>, message: string): void {
+  if (config.verbose) {
+    console.log(`[phrases] ${message}`);
+  }
+}
+
+export function logDebug(config: Pick<Config, 'debug'>, message: string): void {
+  if (config.debug) {
+    console.log(`[phrases:debug] ${message}`);
+  }
+}
+
+export function loadDotEnv(filePath: string): void {
+  if (!existsSync(filePath)) {
+    return;
+  }
+
+  for (const line of readFileSync(filePath, 'utf8').split(/\r?\n/u)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue;
+    }
+
+    const separatorIndex = trimmed.indexOf('=');
+    if (separatorIndex <= 0) {
+      continue;
+    }
+
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const value = trimmed.slice(separatorIndex + 1).trim().replace(/^['"]|['"]$/gu, '');
+    if (!(key in process.env)) {
+      process.env[key] = value;
+    }
+  }
+}
+
+export function expandHome(filePath: string): string {
+  return filePath.startsWith('~/') ? join(homedir(), filePath.slice(2)) : filePath;
+}
+
+export function resolveSettingsPath(target: Target, explicitPath?: string): string {
+  if (explicitPath) {
+    const expanded = expandHome(explicitPath);
+    return isAbsolute(expanded) ? expanded : resolve(process.cwd(), expanded);
+  }
+
+  const home = homedir();
+  const appData = process.env.APPDATA ?? join(home, 'AppData', 'Roaming');
+  const candidates = {
+    insiders: [
+      join(home, 'Library', 'Application Support', 'Code - Insiders', 'User', 'settings.json'),
+      join(home, '.config', 'Code - Insiders', 'User', 'settings.json'),
+      join(appData, 'Code - Insiders', 'User', 'settings.json'),
+    ],
+    stable: [
+      join(home, 'Library', 'Application Support', 'Code', 'User', 'settings.json'),
+      join(home, '.config', 'Code', 'User', 'settings.json'),
+      join(appData, 'Code', 'User', 'settings.json'),
+    ],
+  };
+
+  const firstExisting = (paths: string[]) => paths.find(path => existsSync(path));
+
+  if (target === 'insiders') {
+    return firstExisting(candidates.insiders) ?? candidates.insiders[0];
+  }
+
+  if (target === 'stable') {
+    return firstExisting(candidates.stable) ?? candidates.stable[0];
+  }
+
+  return firstExisting([...candidates.insiders, ...candidates.stable]) ?? candidates.insiders[0];
+}
+
+export function truncate(input: string, maxLength: number): string {
+  if (input.length <= maxLength) {
+    return input;
+  }
+
+  return `${input.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+
+export function singleLine(input: string, maxLength = input.length): string {
+  return truncate(input.replace(/\s+/gu, ' ').trim(), maxLength);
+}
+
+export function decodeHtmlEntities(input: string): string {
+  const named: Record<string, string> = {
+    amp: '&',
+    apos: "'",
+    gt: '>',
+    lt: '<',
+    nbsp: ' ',
+    quot: '"',
+  };
+
+  return input.replace(/&(#x?[0-9a-f]+|[a-z]+);/giu, (match, entity: string) => {
+    const normalized = entity.toLowerCase();
+    if (normalized in named) {
+      return named[normalized];
+    }
+
+    if (!normalized.startsWith('#')) {
+      return match;
+    }
+
+    const isHex = normalized.startsWith('#x');
+    const codePoint = Number.parseInt(normalized.slice(isHex ? 2 : 1), isHex ? 16 : 10);
+    if (Number.isNaN(codePoint)) {
+      return match;
+    }
+
+    try {
+      return String.fromCodePoint(codePoint);
+    } catch {
+      return match;
+    }
+  });
+}
+
+export function stripHtml(input?: string): string | undefined {
+  if (!input) {
+    return undefined;
+  }
+
+  const cleaned = decodeHtmlEntities(input)
+    .replace(/<script\b[^>]*>[\s\S]*?<\/script>/giu, ' ')
+    .replace(/<style\b[^>]*>[\s\S]*?<\/style>/giu, ' ')
+    .replace(/<[^>]+>/gu, ' ')
+    .replace(/\s+/gu, ' ')
+    .trim();
+
+  return cleaned || undefined;
+}
+
+export function relativeTime(input?: string): string | undefined {
+  if (!input) {
+    return undefined;
+  }
+
+  const date = new Date(input);
+  if (Number.isNaN(date.getTime())) {
+    return undefined;
+  }
+
+  const minutes = Math.max(1, Math.round((Date.now() - date.getTime()) / 60_000));
+  if (minutes < 60) {
+    return `${minutes}m ago`;
+  }
+
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h ago`;
+  }
+
+  return `${Math.round(hours / 24)}d ago`;
+}
+
+export function dedupePhrases(phrases: string[]): string[] {
+  const seen = new Set<string>();
+  const unique: string[] = [];
+
+  for (const phrase of phrases) {
+    const normalized = phrase.toLowerCase();
+    if (seen.has(normalized)) {
+      continue;
+    }
+
+    seen.add(normalized);
+    unique.push(phrase);
+  }
+
+  return unique;
+}
+
+export function normalizeSymbols(symbols: string[]): string[] {
+  return Array.from(new Set(symbols.map(symbol => symbol.trim().toUpperCase()).filter(Boolean)));
+}
+
+export function normalizeUsZipCode(input?: string): string | undefined {
+  const digits = input?.replace(/\D+/gu, '').slice(0, 5);
+  return digits && digits.length === 5 ? digits : undefined;
+}
+
+export function isValidUsZipCode(input?: string): boolean {
+  return Boolean(normalizeUsZipCode(input));
+}
+
+export function formatPrice(value: number, currency?: string): string {
+  const normalizedCurrency = currency?.trim().toUpperCase() || 'USD';
+
+  try {
+    return new Intl.NumberFormat('en-US', {
+      style: 'currency',
+      currency: normalizedCurrency,
+      minimumFractionDigits: value < 1 ? 4 : 2,
+      maximumFractionDigits: value < 1 ? 4 : 2,
+    }).format(value);
+  } catch {
+    return `${value.toFixed(value < 1 ? 4 : 2)} ${normalizedCurrency}`;
+  }
+}
+
+export function formatSignedPercent(value?: number): string | undefined {
+  if (!Number.isFinite(value)) {
+    return undefined;
+  }
+
+  const normalizedValue = value as number;
+  const arrow = normalizedValue > 0 ? '▲' : normalizedValue < 0 ? '▼' : '•';
+  return `${arrow} ${Math.abs(normalizedValue).toFixed(2)}%`;
+}
+
+export async function fetchText(url: string, headers?: Record<string, string>): Promise<string> {
+  const response = await fetch(url, {
+    headers: { 'user-agent': USER_AGENT, ...(headers ?? {}) },
+    signal: AbortSignal.timeout(15_000),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Request failed for ${url} (${response.status})`);
+  }
+
+  return response.text();
+}
+
+export async function fetchJson<T>(url: string, headers?: Record<string, string>): Promise<T> {
+  const response = await fetch(url, {
+    headers: {
+      'user-agent': USER_AGENT,
+      accept: 'application/json',
+      ...(headers ?? {}),
+    },
+    signal: AbortSignal.timeout(15_000),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Request failed for ${url} (${response.status})`);
+  }
+
+  return response.json() as Promise<T>;
+}
+
+interface ZippopotamResponse {
+  country?: string;
+  'post code'?: string;
+  places?: Array<{
+    latitude?: string;
+    longitude?: string;
+    'place name'?: string;
+    state?: string;
+    'state abbreviation'?: string;
+  }>;
+}
+
+const zipLocationCache = new Map<string, Promise<ZipLocation>>();
+
+export async function fetchUsZipLocation(zipCode: string): Promise<ZipLocation> {
+  const normalizedZip = normalizeUsZipCode(zipCode);
+  if (!normalizedZip) {
+    throw new Error(`Invalid ZIP code: ${zipCode}`);
+  }
+
+  const cached = zipLocationCache.get(normalizedZip);
+  if (cached) {
+    return cached;
+  }
+
+  const lookupPromise = fetchJson<ZippopotamResponse>(`https://api.zippopotam.us/us/${normalizedZip}`)
+    .then(payload => {
+      const place = payload.places?.[0];
+      const latitude = Number(place?.latitude);
+      const longitude = Number(place?.longitude);
+
+      if (!place || !Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+        throw new Error(`Could not resolve ZIP code ${normalizedZip}`);
+      }
+
+      return {
+        zipCode: normalizedZip,
+        placeName: place['place name']?.trim() || normalizedZip,
+        state: place.state?.trim() || '',
+        stateAbbreviation: place['state abbreviation']?.trim().toUpperCase() || '',
+        latitude,
+        longitude,
+      } satisfies ZipLocation;
+    })
+    .catch(error => {
+      zipLocationCache.delete(normalizedZip);
+      throw error;
+    });
+
+  zipLocationCache.set(normalizedZip, lookupPromise);
+  return lookupPromise;
+}

package/src/sinks/vscodeSettings.ts

@@ -0,0 +1,44 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { applyEdits, modify } from 'jsonc-parser';
+import type { Mode } from '../core/types.js';
+
+export function writeVsCodeSettings(settingsPath: string, phrases: string[], mode: Mode): void {
+  const initialText = existsSync(settingsPath) ? readFileSync(settingsPath, 'utf8') : '{}\n';
+  const edits = modify(
+    initialText,
+    ['chat.agent.thinking.phrases'],
+    { mode, phrases },
+    {
+      formattingOptions: {
+        insertSpaces: true,
+        tabSize: 2,
+        eol: '\n',
+      },
+    },
+  );
+
+  const updatedText = applyEdits(initialText, edits);
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, updatedText.endsWith('\n') ? updatedText : `${updatedText}\n`, 'utf8');
+}
+
+export function removeVsCodeThinkingPhrases(settingsPath: string): boolean {
+  const initialText = existsSync(settingsPath) ? readFileSync(settingsPath, 'utf8') : '{}\n';
+  const edits = modify(initialText, ['chat.agent.thinking.phrases'], undefined, {
+    formattingOptions: {
+      insertSpaces: true,
+      tabSize: 2,
+      eol: '\n',
+    },
+  });
+
+  if (edits.length === 0) {
+    return false;
+  }
+
+  const updatedText = applyEdits(initialText, edits);
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, updatedText.endsWith('\n') ? updatedText : `${updatedText}\n`, 'utf8');
+  return true;
+}

package/src/sources/customJson.ts

@@ -0,0 +1,174 @@
+import type { ArticleItem, Config, PhraseSource } from '../core/types.js';
+import { fetchJson, logInfo, relativeTime, stripHtml, truncate } from '../core/utils.js';
+
+type PathSegment = number | string;
+
+const PATH_SEGMENT_PATTERN = /(?:^|\.)([^.[\]]+)|\[(\d+|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\]/gu;
+
+function parsePathSegments(path: string): PathSegment[] {
+  const normalizedPath = path.trim();
+  if (!normalizedPath) {
+    return [];
+  }
+
+  const segments: PathSegment[] = [];
+
+  for (const match of normalizedPath.matchAll(PATH_SEGMENT_PATTERN)) {
+    const [, dotSegment, bracketSegment] = match;
+    if (dotSegment) {
+      segments.push(dotSegment);
+      continue;
+    }
+
+    if (!bracketSegment) {
+      continue;
+    }
+
+    if (/^\d+$/u.test(bracketSegment)) {
+      segments.push(Number(bracketSegment));
+      continue;
+    }
+
+    segments.push(bracketSegment.slice(1, -1));
+  }
+
+  return segments;
+}
+
+function getPathValue(input: unknown, path?: string): unknown {
+  if (!path?.trim()) {
+    return input;
+  }
+
+  const segments = parsePathSegments(path);
+  let current: unknown = input;
+
+  for (const segment of segments) {
+    if (typeof segment === 'number') {
+      if (!Array.isArray(current)) {
+        return undefined;
+      }
+
+      current = current[segment];
+      continue;
+    }
+
+    if (!current || typeof current !== 'object') {
+      return undefined;
+    }
+
+    current = (current as Record<string, unknown>)[segment];
+  }
+
+  return current;
+}
+
+function readStringValue(input: unknown, path?: string): string | undefined {
+  const value = getPathValue(input, path);
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed || undefined;
+  }
+
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+
+  return undefined;
+}
+
+function toIsoDate(value: unknown): string | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const milliseconds = value >= 1_000_000_000_000 ? value : value >= 1_000_000_000 ? value * 1000 : NaN;
+    if (!Number.isFinite(milliseconds)) {
+      return undefined;
+    }
+
+    return new Date(milliseconds).toISOString();
+  }
+
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  if (/^\d+(\.\d+)?$/u.test(trimmed)) {
+    return toIsoDate(Number(trimmed));
+  }
+
+  const parsed = new Date(trimmed);
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed.toISOString();
+}
+
+function buildDefaultSourceLabel(url: string): string {
+  try {
+    return new URL(url).hostname.replace(/^www\./u, '');
+  } catch {
+    return 'Custom JSON';
+  }
+}
+
+function resolveItems(payload: unknown, path?: string): unknown[] {
+  const resolved = getPathValue(payload, path);
+  if (Array.isArray(resolved)) {
+    return resolved;
+  }
+
+  if (!path?.trim() && Array.isArray(payload)) {
+    return payload;
+  }
+
+  throw new Error(`Custom JSON items path did not resolve to an array${path?.trim() ? `: ${path}` : ''}`);
+}
+
+export async function fetchCustomJsonArticles(config: Config): Promise<ArticleItem[]> {
+  if (!config.customJson.enabled) {
+    return [];
+  }
+
+  logInfo(config, `Fetching custom JSON items from ${config.customJson.url}`);
+  const payload = await fetchJson<unknown>(config.customJson.url);
+  const items = resolveItems(payload, config.customJson.itemsPath).slice(0, config.customJson.maxItems);
+  const defaultSource = config.customJson.sourceLabel?.trim() || buildDefaultSourceLabel(config.customJson.url);
+
+  return items.flatMap((item, index) => {
+    if (!item || typeof item !== 'object') {
+      return [];
+    }
+
+    const title = readStringValue(item, config.customJson.titleField);
+    if (!title) {
+      return [];
+    }
+
+    const content = stripHtml(readStringValue(item, config.customJson.contentField));
+    const datetime = toIsoDate(getPathValue(item, config.customJson.dateField));
+    const link = readStringValue(item, config.customJson.linkField);
+    const source = readStringValue(item, config.customJson.sourceField) ?? defaultSource;
+    const id = readStringValue(item, config.customJson.idField)
+      ?? link
+      ?? `${config.customJson.url}#${index}:${title}`;
+
+    return [{
+      type: 'article' as const,
+      id: `custom-json:${id}`,
+      title,
+      link,
+      source,
+      datetime,
+      time: relativeTime(datetime),
+      content,
+      articleContent: content ? truncate(content, config.githubModels.maxArticleContentLength) : undefined,
+    }];
+  });
+}
+
+export const customJsonSource: PhraseSource = {
+  type: 'custom-json',
+  isEnabled: config => config.customJson.enabled,
+  fetch: fetchCustomJsonArticles,
+};