Val Town Code SearchReturn to Val Town

4const RECIPIENTS = ["Geoffrey", "Maggie"] as const;
5
6function parseDateFromSubject(subject: string): string | null {
7  const match = subject.match(/(\w{3}), (\d{1,2}\/\d{1,2})/);
8  if (match) {
19};
20
21async function analyzeHtmlContent(
22  anthropic: Anthropic,
23  htmlContent: string,
80}
81
82export default async function (e: Email) {
83  console.log("email content");
84  console.log(e.html);

36 * Store a chat message in the database
37 */
38export async function storeChatMessage(
39  chatId,
40  senderId,
69 * Retrieve chat history for a specific chat
70 */
71export async function getChatHistory(chatId, limit = 50) {
72  try {
73    const { sqlite } = await import("https://esm.town/v/stevekrouse/sqlite");
94 * Format chat history for Anthropic API
95 */
96function formatChatHistoryForAI(history) {
97  const messages = [];
98
118 * Analyze a Telegram message and extract memories from it
119 */
120async function analyzeMessageContent(
121  anthropic,
122  username,
499
500// Handle webhook requests
501export default async function (req: Request): Promise<Response> {
502  // Set webhook if it is not set yet
503  if (!isEndpointSet) {

8const TABLE_NAME = `memories`;
9
10function summarizeWeather(weather: WeatherResponse) {
11  const summarizeDay = (day: WeatherResponse["weather"][number]) => ({
12    date: day.date,
25}
26
27async function generateConciseWeatherSummary(weatherDay) {
28  try {
29    // Get API key from environment
83}
84
85async function deleteExistingForecast(date: string) {
86  await sqlite.execute(
87    `
93}
94
95async function insertForecast(date: string, forecast: string) {
96  const { nanoid } = await import("https://esm.sh/nanoid@5.0.5");
97
112}
113
114export default async function getWeatherForecast(interval: number) {
115  const weather = await getWeather("Washington, DC");
116  console.log({ weather });

6const LOCAL_TIMEZONE = "America/New_York";
7
8async function deleteExistingCalendarEvents() {
9  await sqlite.execute(
10    `
15}
16
17// Helper function to extract time from ISO string without timezone conversion
18function extractTimeFromISO(isoString) {
19  // Match the time portion of the ISO string
20  const timeMatch = isoString.match(/T(\d{2}):(\d{2}):/);
31}
32
33function formatEventToNaturalLanguage(event) {
34  const summary = event.summary || "Untitled event";
35
83}
84
85async function insertCalendarEvent(date, eventText) {
86  const { nanoid } = await import("https://esm.sh/nanoid@5.0.5");
87
97}
98
99export default async function getCalendarEvents() {
100  try {
101    const events = await getEvents(

11 * @returns Array of previous fun facts
12 */
13async function getPreviousFunFacts() {
14  try {
15    const result = await sqlite.execute(
32 * @param dates Array of date strings in ISO format
33 */
34async function deleteExistingFunFacts(dates) {
35  try {
36    for (const date of dates) {
51 * @param factText The fun fact text
52 */
53async function insertFunFact(date, factText) {
54  try {
55    await sqlite.execute(
75 * @returns Array of generated fun facts
76 */
77async function generateFunFacts(previousFacts) {
78  try {
79    // Get API key from environment
197 * @returns Array of parsed facts
198 */
199function parseFallbackFacts(responseText, expectedDates) {
200  // Try to extract facts using regex
201  const factPattern = /(\d{4}-\d{2}-\d{2})["']?[,:]?\s*["']?(.*?)["']?[,}]/gs;
260
261/**
262 * Main function to generate and store fun facts for the next 7 days
263 */
264export async function generateAndStoreFunFacts() {
265  try {
266    // Get previous fun facts
301 * Intended to be used as a Val Town cron job
302 */
303export default async function() {
304  console.log("Running fun facts generation cron job...");
305  return await generateAndStoreFunFacts();

8### 1. Script Vals
9
10- Basic JavaScript/TypeScript functions
11- Can be imported by other vals
12- Example structure:
13
14```typescript
15export function myFunction() {
16  // Your code here
17}
25
26```typescript
27export default async function (req: Request) {
28  return new Response("Hello World");
29}
37
38```typescript
39export default async function () {
40  // Scheduled task code
41}
49
50```typescript
51export default async function (email: Email) {
52  // Process email
53}
57
58- Ask clarifying questions when requirements are ambiguous
59- Provide complete, functional solutions rather than skeleton implementations
60- Test your logic against edge cases before presenting the final solution
61- Ensure all code follows Val Town's specific platform requirements
70- **Never bake in secrets into the code** - always use environment variables
71- Include comments explaining complex logic (avoid commenting obvious operations)
72- Follow modern ES6+ conventions and functional programming practices if possible
73
74## Val Town Standard Libraries
75
76Val Town provides several hosted services and utility functions.
77
78### Blob Storage
124```
125
126## Val Town Utility Functions
127
128Val Town provides several utility functions to help with common project tasks.
129
130### Importing Utilities
176      {
177        name: "should add numbers correctly",
178        function: () => {
179          expect(1 + 1).toBe(2);
180        },
210│   ├── database/
211│   │   ├── migrations.ts    # Schema definitions
212│   │   ├── queries.ts       # DB query functions
213│   │   └── README.md
214│   ├── index.ts             # Main entry point
226└── shared/
227    ├── README.md
228    └── utils.ts             # Shared types and functions
229```
230
232- Hono is the recommended API framework (similar to Express, Flask, or Sinatra)
233- Main entry point should be `backend/index.ts`
234- **Static asset serving:** Use the utility functions to read and serve project files:
235  ```ts
236  // Use the serveFile utility to handle content types automatically
273- Run migrations on startup or comment out for performance
274- Change table names when modifying schemas rather than altering
275- Export clear query functions with proper TypeScript typing
276- Follow the queries and migrations pattern from the example
277

1import { sendDailyBriefing } from "./sendDailyBrief.ts";
2
3export async function cronDailyBrief() {
4  try {
5    const chatId = Deno.env.get("TELEGRAM_CHAT_ID");

62};
63
64export function App() {
65  const [memories, setMemories] = useState<Memory[]>([]);
66  const [loading, setLoading] = useState(true);
139      const data = await response.json();
140
141      // Change the sorting function to show memories in chronological order
142      const sortedMemories = [...data].sort((a, b) => {
143        const dateA = a.createdDate || 0;

170}
171
172// --- HTML Generation Function (Glassmorphism UI) ---
173function generateHtmlShell(initialUrl, initialText, sourceUrl, appConfig, analysisAgents, currentLocaleStrings) {
174  const escapedUrl = initialUrl ? initialUrl.replace(/"/g, """) : "";
175  const escapedText = initialText ? initialText.replace(/</g, "&lt;").replace(/>/g, "&gt;") : "";
416        let currentLocale = APP_CONFIG.default_language || 'en';
417
418        // --- Localization Functions (largely unchanged, uses 'locales' object) ---
419        function translate(key, replacements = {}) { /* ... original ... */ }
420        function applyTranslations() { /* ... original ... */ }
421        function setLocale(locale) { /* ... original ... */ }
422        function updateLocaleButtons() {
423             document.querySelectorAll('.lang-btn').forEach(btn => btn.classList.toggle('active', btn.dataset.lang === currentLocale));
424             const linkHtml = \`<a href="\${APP_CONFIG.footer_powered_by_url}" target="_top">\${APP_CONFIG.footer_powered_by_link_text}</a>\`;
436        const resultsContainer = document.getElementById('results-content-cards'); // Container for dynamic cards
437
438        // --- UI Update Functions ---
439        function setLoadingState(isLoading) { /* ... original, use translate for button text ... */ }
440        function displayError(messageKey, replacements = {}) { /* ... original, use translate for error messages ... */ }
441        function clearResults() {
442            ANALYSIS_AGENTS.forEach(agent => {
443              if (agent.ui_display_info) {
459            noResultsMessage.style.display = 'block';
460        }
461        function updateLoadingProgress(percentage, statusKey, agentName = '') {
462            progressBar.style.width = \`\${percentage}%\`;
463            let statusText = translate(statusKey);
468        }
469
470         // --- Result Rendering Functions (DYNAMIC based on ANALYSIS_AGENTS) ---
471         function renderAgentResult(agentId, agentResultData, agentConfig) {
472            const card = document.getElementById(\`card-\${agentId}\`);
473            const contentEl = document.getElementById(\`content-\${agentId}\`);
637
638// --- Main Request Handler (Server Code) ---
639export default async function(req: Request) {
640  // --- Dynamic Imports (Unchanged) ---
641  const { OpenAI } = await import("https://esm.town/v/std/openai");
649
650  // --- Helper: Extract Text using pdf.js-extract (Unchanged) ---
651  async function extractPdfTextNative(data: ArrayBuffer, fileName: string, log: LogEntry[]): Promise<string | null> { /* ... original ... */ }
652
653  // --- Helper Function: Call OpenAI API (Uses APP_CONFIG for model) ---
654  async function callOpenAI(
655    openai: OpenAI,
656    systemPrompt: string,
661    /* ... original logic, but use modelFromConfig ... */
662    const model = modelFromConfig;
663    // ... rest of the original callOpenAI function
664     try {
665      const response = await openai.chat.completions.create({
678  }
679
680  // --- Helper Function: Traverse References (Optional, could be an agent itself) ---
681  // This function is specific. If reference traversal is a common need, keep it.
682  // Otherwise, this logic could be part of a dedicated "Reference Traversal Agent".
683  // For this template, we'll assume it's a potential fixed post-processing step for a reference agent.
684  async function traverseReferences(references: Reference[], log: LogEntry[]): Promise<Reference[]> {
685    const agent = "Reference Traversal Agent"; // Fixed name for this specialized step
686    // ... original traverseReferences logic ...
697
698  // --- Main Agent Flow Logic (DYNAMIC based on ANALYSIS_AGENTS) ---
699  async function runAgentFlow(
700    input: { documentUrl?: string; documentText?: string; documentFile?: File },
701    log: LogEntry[],
761    if (extractedReferencesForTraversal && extractedReferencesForTraversal.length > 0) {
762        log.push({ agent: "System", type: "step", message: "Attempting to verify reference URLs..." });
763        // The traverseReferences function logs its own 'final' results for the 'Reference Traversal Agent'
764        await traverseReferences(extractedReferencesForTraversal, log);
765    } else {
848 * Fill in `{{localization_strings_en_json}}` and `{{localization_strings_es_json}}` with all
849 * UI text for English and Spanish respectively. Ensure keys match `data-translate` attributes in the HTML
850 * and keys used in the JavaScript `translate()` function.
851 * Card titles and table headers defined in `ui_display_info` for agents will also need corresponding
852 * entries if you want them translated beyond the direct `card_title_en/es` provided (e.g. for dynamic labels within a key_value_pairs display).
862 *
863 * 6. Deployment:
864 * This script is designed to be deployed as a single serverless function (e.g., on Val Town).
865 * It serves both the HTML interface and the backend API endpoint.
866 *
869 * To implement agent chaining (where one agent's output is input to another), you would modify
870 * `runAgentFlow` to pass `previousAgentOutput` and update agent prompts to accept/use it (e.g. `{{previous_output}}`).
871 * - Advanced UI Rendering: The `renderAgentResult` function provides basic rendering for different data types.
872 * For more complex visualizations or interactions, you'd expand this function or add new `display_type` handlers.
873 * - Styling: The CSS is extensive. You can customize it directly or by templatizing CSS variables within the `<style>` block.
874 * - Error Handling: Server-side and client-side error handling can be further enhanced.

35const app = new Hono();
36
37// --- Helper Functions ---
38async function updateJobStatus(jobId: string, status: string, errorMessage?: string) {
39  await sqlite.execute({
40    sql: `UPDATE jobs SET status = ?, updated_at = ?, error_message = ? WHERE id = ?;`,
43}
44
45async function updateLeadStatus(leadId: string, status: string, updates: Partial<Lead> = {}, errorMessage?: string) {
46  let sql = `UPDATE leads SET status = ?, updated_at = ?`;
47  const args: any[] = [status, new Date().toISOString()];
77
78// WARNING: Scraping search engines like DuckDuckGo is fragile and might break.
79async function searchWebsites(searchQuery: string, jobId: string): Promise<{ name: string; url: string }[]> {
80  const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(searchQuery)}`;
81  console.log(`Searching: ${searchUrl}`);
124}
125
126async function extractEmailsFromWebsite(websiteUrl: string, leadId: string): Promise<string | null> {
127  console.log(`Scraping ${websiteUrl} for lead ${leadId}`);
128  try {
189}
190
191async function draftColdEmail(
192  openai: OpenAI,
193  businessName: string | undefined,
284}
285
286async function processJob(jobId: string, searchQuery: string) {
287  await updateJobStatus(jobId, "processing_search");
288  const openaiApiKey = Deno.env.get("openai");