ray-finance 0.2.0

package/site/src/app/pii-scramble.tsx

@@ -0,0 +1,190 @@
+"use client";
+
+import { useEffect, useRef, useState, useCallback } from "react";
+
+const CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@#$%&*";
+
+interface Segment {
+  text: string;
+  redacted?: string;
+}
+
+const LINES: Segment[][] = [
+  [
+    { text: "Sarah Chen", redacted: "[USER]" },
+    { text: " earns $85k at " },
+    { text: "Acme Corp", redacted: "[EMPLOYER]" },
+    { text: "." },
+  ],
+  [
+    { text: "James", redacted: "[PARTNER]" },
+    { text: " manages the household budget." },
+  ],
+  [{ text: "Checking balance: $4,802" }],
+  [{ text: "Visa balance: -$1,200 @ 22.99% APR" }],
+];
+
+// Collect all redactable segments in order
+const REDACTABLE: { lineIdx: number; segIdx: number }[] = [];
+LINES.forEach((line, lineIdx) => {
+  line.forEach((seg, segIdx) => {
+    if (seg.redacted) REDACTABLE.push({ lineIdx, segIdx });
+  });
+});
+
+function scrambleText(original: string, target: string, progress: number): string {
+  const len = Math.max(original.length, target.length);
+  let result = "";
+  for (let i = 0; i < len; i++) {
+    const charProgress = Math.min(1, Math.max(0, progress * len - i) / 3);
+    if (charProgress >= 1) {
+      result += target[i] ?? "";
+    } else if (charProgress > 0) {
+      result += CHARS[Math.floor(Math.random() * CHARS.length)];
+    } else {
+      result += original[i] ?? "";
+    }
+  }
+  return result;
+}
+
+function useInView(ref: React.RefObject<HTMLElement | null>, threshold = 0.5) {
+  const [inView, setInView] = useState(false);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (entry.isIntersecting) {
+          setInView(true);
+          observer.disconnect();
+        }
+      },
+      { threshold }
+    );
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [ref, threshold]);
+  return inView;
+}
+
+// Which word index is currently scrambling (-1 = not started, >= REDACTABLE.length = done)
+type AnimState = {
+  /** Index into REDACTABLE of the word currently animating */
+  activeWord: number;
+  /** 0..1 progress of the current word's scramble */
+  wordProgress: number;
+};
+
+export function PIIScramble() {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const inView = useInView(containerRef);
+  const [anim, setAnim] = useState<AnimState>({ activeWord: -1, wordProgress: 0 });
+
+  const done = anim.activeWord >= REDACTABLE.length;
+  const scrambling = anim.activeWord >= 0 && !done;
+
+  const runWord = useCallback((wordIdx: number) => {
+    const SCRAMBLE_DURATION = 800; // ms per word
+    const start = performance.now();
+
+    function tick() {
+      const elapsed = performance.now() - start;
+      const p = Math.min(1, elapsed / SCRAMBLE_DURATION);
+      setAnim({ activeWord: wordIdx, wordProgress: p });
+      if (p < 1) {
+        requestAnimationFrame(tick);
+      } else if (wordIdx + 1 < REDACTABLE.length) {
+        // Pause 500ms then start next word
+        setTimeout(() => runWord(wordIdx + 1), 500);
+      } else {
+        // All done
+        setAnim({ activeWord: REDACTABLE.length, wordProgress: 1 });
+      }
+    }
+    requestAnimationFrame(tick);
+  }, []);
+
+  useEffect(() => {
+    if (!inView) return;
+    // Initial delay before first word starts
+    const delay = setTimeout(() => runWord(0), 800);
+    return () => clearTimeout(delay);
+  }, [inView, runWord]);
+
+  function getSegmentDisplay(lineIdx: number, segIdx: number, seg: Segment): { text: string; color: string } {
+    if (!seg.redacted) {
+      return { text: seg.text, color: "text-stone-300" };
+    }
+
+    // Find this segment's index in the redactable list
+    const wordIdx = REDACTABLE.findIndex(r => r.lineIdx === lineIdx && r.segIdx === segIdx);
+
+    if (anim.activeWord < 0 || wordIdx > anim.activeWord) {
+      // Not yet reached — show original
+      return { text: seg.text, color: "text-red-400" };
+    }
+
+    if (wordIdx < anim.activeWord || done) {
+      // Already redacted
+      return { text: seg.redacted!, color: "text-lime-400" };
+    }
+
+    // Currently scrambling this word
+    return {
+      text: scrambleText(seg.text, seg.redacted!, anim.wordProgress),
+      color: "text-amber-300",
+    };
+  }
+
+  const statusLabel = done
+    ? "PII redacted before sending to AI"
+    : scrambling
+      ? "Redacting..."
+      : "Raw financial data";
+
+  return (
+    <div ref={containerRef} className="rounded-xl border border-stone-200 bg-white p-6 sm:p-8">
+      <div className="mb-6 flex items-center gap-3">
+        <div
+          className={`h-2 w-2 rounded-full transition-colors duration-300 ${
+            done
+              ? "bg-lime-400"
+              : scrambling
+                ? "bg-amber-400 animate-pulse"
+                : "bg-stone-300"
+          }`}
+        />
+        <p className="font-mono text-xs tracking-wide text-stone-400 uppercase">
+          {statusLabel}
+        </p>
+      </div>
+
+      <div className="rounded-lg bg-stone-950 p-4 sm:p-6 font-mono text-xs sm:text-sm leading-relaxed">
+        {LINES.map((segments, lineIdx) => (
+          <p key={lineIdx} className="text-stone-300">
+            {segments.map((seg, segIdx) => {
+              const { text, color } = getSegmentDisplay(lineIdx, segIdx, seg);
+              return (
+                <span key={segIdx} className={color}>
+                  {text}
+                </span>
+              );
+            })}
+          </p>
+        ))}
+      </div>
+
+      <div className="mt-4 flex items-center gap-4 text-xs text-stone-400">
+        <span className="flex items-center gap-1.5">
+          <span className="inline-block h-2 w-2 rounded-full bg-red-400" />
+          PII in local database
+        </span>
+        <span className="flex items-center gap-1.5">
+          <span className="inline-block h-2 w-2 rounded-full bg-lime-400" />
+          What the AI receives
+        </span>
+      </div>
+    </div>
+  );
+}

package/site/src/app/reveal.tsx

@@ -0,0 +1,29 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+
+export function Reveal({ children, className = "" }: { children: React.ReactNode; className?: string }) {
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (entry.isIntersecting) {
+          el.classList.add("visible");
+          observer.disconnect();
+        }
+      },
+      { threshold: 0.15 }
+    );
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, []);
+
+  return (
+    <div ref={ref} className={`reveal ${className}`}>
+      {children}
+    </div>
+  );
+}

package/site/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": { "@/*": ["./src/*"] }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/src/ai/agent.ts

@@ -0,0 +1,106 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type Database from "better-sqlite3-multiple-ciphers";
+import { config, useManaged, RAY_PROXY_BASE } from "../config.js";
+import { buildSystemPrompt } from "./system-prompt.js";
+import { toolDefinitions, executeTool } from "./tools.js";
+import { getConversationHistory, saveMessage } from "./memory.js";
+import { logToolCall } from "./audit.js";
+import { redact, unredact } from "./redactor.js";
+
+const anthropic = new Anthropic(
+  useManaged()
+    ? { apiKey: config.rayApiKey, baseURL: `${RAY_PROXY_BASE}/ai` }
+    : { apiKey: config.anthropicKey }
+);
+
+function supportsThinking(model: string): boolean {
+  return /sonnet-4|opus-4/i.test(model);
+}
+
+export async function handleMessage(
+  db: Database.Database,
+  userMessage: string
+): Promise<string> {
+  // Save incoming message
+  saveMessage(db, "user", userMessage);
+
+  // Load conversation context
+  const history = getConversationHistory(db, 20);
+
+  // Build system prompt and redact PII before sending to API
+  const systemPrompt = redact(buildSystemPrompt(db));
+
+  // Build messages array from history, redacting PII
+  const messages: Anthropic.MessageParam[] = history.map(h => ({
+    role: h.role as "user" | "assistant",
+    content: redact(h.content),
+  }));
+
+  // Ensure last message is the current user message
+  if (messages.length === 0 || messages[messages.length - 1].content !== userMessage) {
+    messages.push({ role: "user", content: redact(userMessage) });
+  }
+
+  // Extended thinking config
+  const useThinking = config.thinkingBudget > 0 && supportsThinking(config.model);
+
+  try {
+    // Build API params
+    const apiParams: any = {
+      model: config.model,
+      max_tokens: useThinking ? 16000 : 4096,
+      system: systemPrompt,
+      tools: toolDefinitions,
+      messages,
+    };
+
+    if (useThinking) {
+      apiParams.thinking = {
+        type: "enabled",
+        budget_tokens: config.thinkingBudget,
+      };
+    }
+
+    // Initial API call
+    let response = await anthropic.messages.create(apiParams);
+
+    // Agentic tool loop
+    while (response.stop_reason === "tool_use") {
+      // Filter out thinking blocks before adding to messages
+      const assistantContent = response.content.filter(
+        (b: any) => b.type !== "thinking"
+      ) as Anthropic.ContentBlock[];
+      messages.push({ role: "assistant", content: assistantContent });
+
+      const toolResults: Anthropic.ToolResultBlockParam[] = [];
+
+      for (const block of assistantContent) {
+        if (block.type === "tool_use") {
+          const result = await executeTool(db, block.name, block.input);
+          logToolCall(db, block.name, block.input, result, response.usage?.output_tokens);
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: block.id,
+            content: redact(result),
+          });
+        }
+      }
+
+      messages.push({ role: "user", content: toolResults });
+
+      response = await anthropic.messages.create(apiParams);
+    }
+
+    // Extract text response (filter out thinking blocks), restore PII for display
+    const textBlocks = response.content.filter((b: any) => b.type === "text");
+    const responseText = unredact(textBlocks.map((b: any) => b.text).join("\n"));
+
+    // Save assistant response
+    saveMessage(db, "assistant", responseText);
+
+    return responseText || "I looked into that but couldn't formulate a response. Could you try rephrasing?";
+  } catch (error: any) {
+    console.error("AI agent error:", error.message);
+    return "Sorry, I had trouble processing that. Could you try again?";
+  }
+}

package/src/ai/audit.ts

@@ -0,0 +1,11 @@
+import type Database from "better-sqlite3-multiple-ciphers";
+
+export function logToolCall(db: Database.Database, toolName: string, inputParams: any, resultSummary: string, tokensUsed?: number): void {
+  db.prepare(
+    `INSERT INTO ai_audit_log (tool_name, input_params, result_summary, tokens_used) VALUES (?, ?, ?, ?)`
+  ).run(toolName, JSON.stringify(inputParams), resultSummary.slice(0, 500), tokensUsed || null);
+}
+
+export function getAuditLog(db: Database.Database, limit = 50): any[] {
+  return db.prepare(`SELECT * FROM ai_audit_log ORDER BY id DESC LIMIT ?`).all(limit);
+}

package/src/ai/context.ts

@@ -0,0 +1,93 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+
+const CONTEXT_PATH = resolve(homedir(), ".ray", "context.md");
+
+export function getContextPath(): string {
+  return CONTEXT_PATH;
+}
+
+export function readContext(): string {
+  if (!existsSync(CONTEXT_PATH)) return "";
+  try {
+    return readFileSync(CONTEXT_PATH, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+export function writeContext(content: string): void {
+  const dir = resolve(homedir(), ".ray");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(CONTEXT_PATH, content, "utf-8");
+}
+
+export function isContextEmpty(): boolean {
+  const content = readContext();
+  if (!content || content.trim().length === 0) return true;
+  // Check if it still has placeholder text (template hasn't been filled)
+  const placeholders = ["(Add income sources", "(Linked accounts will appear", "(Add financial goals", "(Add current financial strategy", "(Log important financial decisions", "(Track action items"];
+  const filledSections = placeholders.filter(p => !content.includes(p)).length;
+  // Consider empty if most sections still have placeholder text
+  return filledSections < 2;
+}
+
+export function replaceContextSection(section: string, content: string): void {
+  let current = readContext();
+  if (!current) {
+    writeContext(`## ${section}\n${content}\n`);
+    return;
+  }
+
+  const sectionHeader = `## ${section}`;
+  const sectionIdx = current.indexOf(sectionHeader);
+
+  if (sectionIdx !== -1) {
+    // Find the next ## heading after this section
+    const afterHeader = sectionIdx + sectionHeader.length;
+    const nextSectionIdx = current.indexOf("\n## ", afterHeader);
+    const before = current.slice(0, afterHeader);
+    const after = nextSectionIdx !== -1 ? current.slice(nextSectionIdx) : "";
+    current = `${before}\n${content}\n${after}`;
+  } else {
+    // Insert before ## Open Items if it exists, otherwise append
+    const openItemsIdx = current.indexOf("## Open Items");
+    if (openItemsIdx !== -1) {
+      current = `${current.slice(0, openItemsIdx)}${sectionHeader}\n${content}\n\n${current.slice(openItemsIdx)}`;
+    } else {
+      current = `${current.trimEnd()}\n\n${sectionHeader}\n${content}\n`;
+    }
+  }
+
+  writeContext(current);
+}
+
+export function createContextTemplate(userName: string): void {
+  if (existsSync(CONTEXT_PATH)) return; // don't overwrite existing
+
+  const template = `# Financial Context for ${userName}
+
+## Family
+- ${userName}
+
+## Income
+- (Add income sources and amounts)
+
+## Accounts
+- (Linked accounts will appear after syncing)
+
+## Goals
+- (Add financial goals)
+
+## Strategy
+- (Add current financial strategy and priorities)
+
+## Key Decisions
+- (Log important financial decisions here)
+
+## Open Items
+- (Track action items and follow-ups)
+`;
+  writeContext(template);
+}