@groeponline/pi-wishcraft 0.17.3

package/src/working-vibes/storage.ts

@@ -0,0 +1,357 @@
+// storage.ts
+// AI-generated contextual working messages that match a user's preferred theme/vibe.
+// Holds settings/config persistence, on-disk vibe file storage, and the shared
+// module-level state (matching powerline-footer pattern).
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { getAgentPath } from "../paths/agent-dirs.ts";
+
+export type VibeMode = "generate" | "file";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Constants
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const DEFAULT_MODEL = "openai-codex/gpt-5.4-mini";
+
+export const DEFAULT_PROMPT = `Generate a 2-4 word "{theme}" themed loading message ending in "...".
+
+Task: {task}
+
+Be creative and unexpected. Avoid obvious/clichéd phrases for this theme.
+The message should hint at the task using theme vocabulary.
+{exclude}
+Output only the message, nothing else.`;
+
+export const BATCH_PROMPT = `Generate {count} unique 2-4 word loading messages for a "{theme}" theme.
+Each message should end with "..."
+Be creative, varied, and thematic. No duplicates.
+Output one message per line, nothing else. No numbering, no bullets.`;
+
+export const VIBE_SYSTEM_PROMPT =
+  "You generate short themed loading messages and reply with the requested text only.";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface VibeConfig {
+  theme: string | null; // null = disabled
+  mode: VibeMode; // "generate" (on-demand) or "file" (pre-generated)
+  modelSpec: string; // default: "openai-codex/gpt-5.4-mini"
+  fallback: string; // default: "Working"
+  timeout: number; // default: 3000ms
+  refreshInterval: number; // default: 30000ms (30s)
+  promptTemplate: string; // template with {theme}, {task}, {exclude} placeholders
+  maxLength: number; // default: 65 chars
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Module-level State
+// ═══════════════════════════════════════════════════════════════════════════
+
+// Recent vibes tracking (to avoid repetition in generate mode)
+export const MAX_RECENT_VIBES = 5;
+
+// Shared mutable state, kept as a single object so other modules can read and
+// mutate it (via property assignment) while still importing a stable binding.
+export const vibeState = {
+  config: loadConfig(),
+  extensionCtx: null as ExtensionContext | null,
+  currentGeneration: null as AbortController | null,
+  isStreaming: false,
+  lastVibeTime: 0,
+
+  // File-based mode state
+  vibeCache: [] as string[], // Cached vibes from file
+  vibeCacheTheme: null as string | null, // Theme the cache is for
+  vibeSeed: Date.now(), // Seed for deterministic shuffle
+  vibeIndex: 0, // Current position in shuffled list
+
+  recentVibes: [] as string[],
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Configuration Management
+// ═══════════════════════════════════════════════════════════════════════════
+
+function getSettingsPath(): string {
+  return getAgentPath("settings.json");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readSettingsForLoad(): Record<string, unknown> {
+  const settingsPath = getSettingsPath();
+
+  try {
+    if (!existsSync(settingsPath)) {
+      return {};
+    }
+
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (!isRecord(parsed)) {
+      console.debug(
+        `[working-vibes] Ignoring non-object settings at ${settingsPath}`,
+      );
+      return {};
+    }
+
+    return parsed;
+  } catch (error) {
+    console.debug(
+      `[working-vibes] Failed to load settings from ${settingsPath}:`,
+      error,
+    );
+    return {};
+  }
+}
+
+function readSettingsForWrite(scope: string): Record<string, unknown> | null {
+  const settingsPath = getSettingsPath();
+
+  if (!existsSync(settingsPath)) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (!isRecord(parsed)) {
+      console.debug(
+        `[working-vibes] Refusing to write ${scope}: settings at ${settingsPath} is not an object`,
+      );
+      return null;
+    }
+
+    return parsed;
+  } catch (error) {
+    console.debug(
+      `[working-vibes] Failed to parse settings while writing ${scope} at ${settingsPath}:`,
+      error,
+    );
+    return null;
+  }
+}
+
+function persistSettings(
+  settings: Record<string, unknown>,
+  scope: string,
+): boolean {
+  const settingsPath = getSettingsPath();
+
+  try {
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    return true;
+  } catch (error) {
+    console.debug(
+      `[working-vibes] Failed to persist ${scope} to ${settingsPath}:`,
+      error,
+    );
+    return false;
+  }
+}
+
+export function loadConfig(): VibeConfig {
+  const settings = readSettingsForLoad();
+
+  // Handle "off" in settings.json (same as null/disabled)
+  const rawTheme =
+    typeof settings.workingVibe === "string" ? settings.workingVibe : null;
+  const theme = rawTheme?.toLowerCase() === "off" ? null : rawTheme;
+
+  // Validate mode setting
+  const rawMode = settings.workingVibeMode;
+  const mode: VibeMode =
+    rawMode === "file" || rawMode === "generate" ? rawMode : "generate";
+
+  const refreshSeconds =
+    typeof settings.workingVibeRefreshInterval === "number" &&
+    Number.isFinite(settings.workingVibeRefreshInterval)
+      ? Math.max(0, settings.workingVibeRefreshInterval)
+      : 30;
+
+  const maxLength =
+    typeof settings.workingVibeMaxLength === "number" &&
+    Number.isFinite(settings.workingVibeMaxLength)
+      ? Math.max(4, Math.floor(settings.workingVibeMaxLength))
+      : 65;
+
+  return {
+    theme,
+    mode,
+    modelSpec:
+      typeof settings.workingVibeModel === "string"
+        ? settings.workingVibeModel
+        : DEFAULT_MODEL,
+    fallback:
+      typeof settings.workingVibeFallback === "string"
+        ? settings.workingVibeFallback
+        : "Working",
+    timeout: 3000,
+    refreshInterval: refreshSeconds * 1000,
+    promptTemplate:
+      typeof settings.workingVibePrompt === "string"
+        ? settings.workingVibePrompt
+        : DEFAULT_PROMPT,
+    maxLength,
+  };
+}
+
+export function saveConfig(): boolean {
+  const settings = readSettingsForWrite("workingVibe");
+  if (!settings) {
+    return false;
+  }
+
+  if (vibeState.config.theme === null) {
+    delete settings.workingVibe;
+  } else {
+    settings.workingVibe = vibeState.config.theme;
+  }
+
+  return persistSettings(settings, "workingVibe");
+}
+
+export function saveModelConfig(): boolean {
+  const settings = readSettingsForWrite("workingVibeModel");
+  if (!settings) {
+    return false;
+  }
+
+  if (vibeState.config.modelSpec === DEFAULT_MODEL) {
+    delete settings.workingVibeModel;
+  } else {
+    settings.workingVibeModel = vibeState.config.modelSpec;
+  }
+
+  return persistSettings(settings, "workingVibeModel");
+}
+
+export function saveModeConfig(): boolean {
+  const settings = readSettingsForWrite("workingVibeMode");
+  if (!settings) {
+    return false;
+  }
+
+  if (vibeState.config.mode === "generate") {
+    delete settings.workingVibeMode;
+  } else {
+    settings.workingVibeMode = vibeState.config.mode;
+  }
+
+  return persistSettings(settings, "workingVibeMode");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// File-Based Vibe Management
+// ═══════════════════════════════════════════════════════════════════════════
+
+function getVibesDir(): string {
+  return getAgentPath("vibes");
+}
+
+function toVibeFileSlug(theme: string): string {
+  const slug = theme
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^[-_]+|[-_]+$/g, "");
+
+  return slug || "theme";
+}
+
+export function getVibeFilePath(theme: string): string {
+  const filename = `${toVibeFileSlug(theme)}.txt`;
+  return join(getVibesDir(), filename);
+}
+
+export function loadVibesFromFile(theme: string): string[] {
+  const filePath = getVibeFilePath(theme);
+  if (!existsSync(filePath)) return [];
+
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return content
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0 && line.endsWith("..."));
+  } catch (error) {
+    console.debug(
+      `[working-vibes] Failed to load vibe file ${filePath}:`,
+      error,
+    );
+    return [];
+  }
+}
+
+export function saveVibesToFile(theme: string, vibes: string[]): void {
+  const vibesDir = getVibesDir();
+  const filePath = getVibeFilePath(theme);
+
+  // Ensure directory exists
+  if (!existsSync(vibesDir)) {
+    mkdirSync(vibesDir, { recursive: true });
+  }
+
+  writeFileSync(filePath, vibes.join("\n"));
+}
+
+// Mulberry32 PRNG - fast, deterministic, good distribution
+function mulberry32(seed: number): () => number {
+  return function () {
+    let t = (seed += 0x6d2b79f5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// Get vibe at index using seeded shuffle (no-repeat until all used)
+function getVibeAtIndex(vibes: string[], index: number, seed: number): string {
+  if (vibes.length === 0) return `${vibeState.config.fallback}...`;
+
+  // For small lists or when we've cycled through, just use modulo
+  const effectiveIndex = index % vibes.length;
+
+  // Create deterministic shuffle using seed
+  const rng = mulberry32(seed);
+  const indices = Array.from({ length: vibes.length }, (_, i) => i);
+
+  // Fisher-Yates shuffle with seeded RNG
+  for (let i = indices.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    [indices[i], indices[j]] = [indices[j], indices[i]];
+  }
+
+  return vibes[indices[effectiveIndex]];
+}
+
+export function getNextVibeFromFile(): string {
+  if (!vibeState.config.theme) return `${vibeState.config.fallback}...`;
+
+  // Load/reload cache if theme changed
+  if (vibeState.vibeCacheTheme !== vibeState.config.theme) {
+    vibeState.vibeCache = loadVibesFromFile(vibeState.config.theme);
+    vibeState.vibeCacheTheme = vibeState.config.theme;
+    vibeState.vibeSeed = Date.now(); // New seed for new theme
+    vibeState.vibeIndex = 0;
+  }
+
+  if (vibeState.vibeCache.length === 0) {
+    return `${vibeState.config.fallback}...`;
+  }
+
+  const vibe = getVibeAtIndex(
+    vibeState.vibeCache,
+    vibeState.vibeIndex,
+    vibeState.vibeSeed,
+  );
+  vibeState.vibeIndex++;
+  return vibe;
+}

package/theme.example.json

@@ -0,0 +1,24 @@
+{
+  "colors": {
+    "model": "#d787af",
+    "shellMode": "accent",
+    "path": "#00afaf",
+    "gitDirty": "warning",
+    "gitClean": "success",
+    "thinking": "thinkingOff",
+    "thinkingMinimal": "thinkingMinimal",
+    "thinkingLow": "thinkingLow",
+    "thinkingMedium": "thinkingMedium",
+    "context": "dim",
+    "contextWarn": "warning",
+    "contextError": "error",
+    "cost": "text",
+    "tokens": "muted",
+    "separator": "dim",
+    "border": "borderMuted"
+  },
+  "icons": {
+    "auto": "↯",
+    "warning": ""
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "allowImportingTsExtensions": true
+  },
+  "include": ["*.ts", "bash-mode/**/*.ts", "queue/**/*.ts", "src/**/*.ts"]
+}