Val Town Code SearchReturn to Val Town

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;

45`;
46
47function getYesterdayDateRange(): { startDate: string; endDate: string } {
48  const now = new Date();
49  const yesterday = new Date(now.setDate(now.getDate() - 1));
56}
57
58export async function exec(interval: Interval) {
59  const apiKey = Deno.env.get("LINEAR_API_KEY");
60  if (!apiKey) {
132  });
133
134  function determineMatchedContext(
135    history: any[],
136    startDate: string,

46};
47
48function encodeGame(game: Game): string {
49  return btoa(JSON.stringify(game));
50}
51function decodeGame(encoded: string): Game {
52  try {
53    return JSON.parse(atob(encoded));
56  }
57}
58function nextStateEncoded(url, game: Game, action: string): string | undefined {
59  const next = nextState(game, action);
60  return next ? `https://${url}/${encodeGame(next)}` : undefined;
61}
62function nextState(game: Game, action: string): Game | undefined {
63  // TODO - check if action is valid and return null if not, ie no link
64  const { answer, guesses, currentGuess } = game;
88}
89
90function rightPad(str: string, length: number): string {
91  return str + " ".repeat(length - str.length);
92}
93
94function letterColor({ answer, guesses }: Game, letter: string): string {
95  if (guesses.some((guess) => [...guess].some((x, i) => x === letter && answer[i] === letter))) {
96    return GREEN;
107}
108
109async function handler(req: Request): Promise<Response> {
110  const url = new URL(req.url);
111  if (url.pathname === "/") {
246}
247
248function generateWordleBoardSVG({ guesses, answer, currentGuess }) {
249  const GREEN = "#6aaa64";
250  const YELLOW = "#c9b458";

2import { google } from "npm:googleapis";
3
4export async function getAccessToken(accountId: string, bearer = Deno.env.get("pipedream")) {
5  const response = await fetchJSON(
6    `https://api.pipedream.com/v1/accounts/${accountId}?include_credentials=1`,
10}
11
12export function googleService(service: string, accessToken: string) {
13  return google[service]({
14    version: "v3",
19}
20
21export async function pipeDreamGoogle(service: string, accountId: string, bearer = Deno.env.get("pipedream")) {
22  const accessToken = await getAccessToken(accountId, bearer);
23  return googleService(service, accessToken);

3Pipedream offers an Accounts API to handle OAuth for you, automatically, and for free. [How to do it is covered in this guide](https://docs.val.town/integrations/google-sheets/#use-pipedreams-accounts-api).
4
5The helper functions below can make it easier to work with various Google API. For example, I used them like so to get all my free/busy times for this week from all my google calendars:
6
7```ts
11const calendar = await pipeDreamGoogle("calendar", accountId);
12
13// Function to get free/busy information
14async function getFreeBusyTimes(calendarId: string) {
15  const now = new Date();
16  const startOfWeek = new Date(now);

4import { DateTime } from "https://esm.sh/luxon@3.4.4";
5
6export async function testDailyBrief() {
7  try {
8    const testChatId = Deno.env.get("TEST_TELEGRAM_CHAT_ID");

2// Run this script manually to create the database table
3
4export default async function setupTelegramChatDb() {
5  try {
6    // Import SQLite module

13} from "../memoryUtils.ts";
14
15async function generateBriefingContent(anthropic, memories, today, isSunday) {
16  try {
17    const weekdaysHelp = generateWeekDays(today);
96}
97
98export async function sendDailyBriefing(chatId?: string, today?: DateTime) {
99  // Get API keys from environment
100  const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
135  const lastSunday = today.startOf("week").minus({ days: 1 });
136
137  // Fetch relevant memories using the utility function
138  const memories = await getRelevantMemories();
139
216}
217
218function generateWeekDays(today) {
219  let output = [];
220
239// console.log(weekDays);
240
241// Export a function that calls sendDailyBriefing with no parameters
242// This maintains backward compatibility with existing cron jobs
243export default async function (overrideToday?: DateTime) {
244  return await sendDailyBriefing(undefined, overrideToday);
245}