Val Town Code SearchReturn to Val Town

26});
27
28// --- API Routes for Memories ---
29
30// GET /api/memories - Retrieve all memories
31app.get("/api/memories", async (c) => {
32  const memories = await getAllMemories();
33  return c.json(memories);
34});
35
36// POST /api/memories - Create a new memory
37app.post("/api/memories", async (c) => {
38  const body = await c.req.json<Omit<Memory, "id">>();
39  if (!body.text) {
44});
45
46// PUT /api/memories/:id - Update an existing memory
47app.put("/api/memories/:id", async (c) => {
48  const id = c.req.param("id");
49  const body = await c.req.json<Partial<Omit<Memory, "id">>>();
66});
67
68// DELETE /api/memories/:id - Delete a memory
69app.delete("/api/memories/:id", async (c) => {
70  const id = c.req.param("id");
71  try {
83// --- Blob Image Serving Routes ---
84
85// GET /api/images/:filename - Serve images from blob storage
86app.get("/api/images/:filename", async (c) => {
87  const filename = c.req.param("filename");
88

12      type="image/svg+xml"
13    />
14    <link rel="preconnect" href="https://fonts.googleapis.com" />
15    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
16    <link
17      href="https://fonts.googleapis.com/css2?family=Pixelify+Sans:wght@400..700&display=swap"
18      rel="stylesheet"
19    />

85  console.log(e.text);
86
87  // Get Anthropic API key from environment
88  const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
89  if (!apiKey) {
90    console.error("Anthropic API key is not configured for this val.");
91    return;
92  }
93
94  // Initialize Anthropic client
95  const anthropic = new Anthropic({ apiKey });
96
97  // Process each image attachment serially

92
93/**
94 * Format chat history for Anthropic API
95 */
96function formatChatHistoryForAI(history) {
321bot.on("message", async (ctx) => {
322  try {
323    // Get Anthropic API key from environment
324    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
325    if (!apiKey) {
326      console.error("Anthropic API key is not configured.");
327      ctx.reply(
328        "I apologize, but I'm not properly configured at the moment. Please inform the household administrator."
332
333    // Initialize Anthropic client
334    const anthropic = new Anthropic({ apiKey });
335
336    // Get message text and user info
502  // Set webhook if it is not set yet
503  if (!isEndpointSet) {
504    await bot.api.setWebhook(req.url, {
505      secret_token: SECRET_TOKEN,
506    });

27async function generateConciseWeatherSummary(weatherDay) {
28  try {
29    // Get API key from environment
30    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
31    if (!apiKey) {
32      console.error("Anthropic API key is not configured.");
33      return null;
34    }
35
36    // Initialize Anthropic client
37    const anthropic = new Anthropic({ apiKey });
38
39    const response = await anthropic.messages.create({

77async function generateFunFacts(previousFacts) {
78  try {
79    // Get API key from environment
80    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
81    if (!apiKey) {
82      console.error("Anthropic API key is not configured.");
83      return null;
84    }
85
86    // Initialize Anthropic client
87    const anthropic = new Anthropic({ apiKey });
88
89    // Format previous facts for the prompt

20### 2. HTTP Vals
21
22- Create web APIs and endpoints
23- Handle HTTP requests and responses
24- Example structure:
66- Generate code in TypeScript
67- Add appropriate TypeScript types and interfaces for all data structures
68- Prefer official SDKs or libraries than writing API calls directly
69- Ask the user to supply API or library documentation if you are at all unsure about it
70- **Never bake in secrets into the code** - always use environment variables
71- Include comments explaining complex logic (avoid commenting obvious operations)
190- For AI-generated images, use: `https://maxm-imggenurl.web.val.run/the-description-of-your-image`
191- **Storage:** DO NOT use the Deno KV module for storage
192- **Browser APIs:** DO NOT use the `alert()`, `prompt()`, or `confirm()` methods
193- **Weather Data:** Use open-meteo for weather data (doesn't require API keys) unless otherwise specified
194- **View Source:** Add a view source link with `import.meta.url.replace("esm.town", "val.town")` and include `target="_top"` attribute
195- **Error Debugging:** Add `<script src="https://esm.town/v/std/catch"></script>` to HTML to capture client-side errors
196- **Error Handling:** Only use try...catch when there's a clear local resolution; avoid catches that merely log or return 500s - let errors bubble up with full context
197- **Environment Variables:** Use `Deno.env.get('keyname')` and minimize their use - prefer APIs without keys
198- **Imports:** Use `https://esm.sh` for npm and Deno dependencies to ensure compatibility on server and browser
199- **Storage Strategy:** Only use backend storage if explicitly required; prefer simple static client-side sites
230
231### Backend (Hono) Best Practices
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:
251  });
252  ```
253- Create RESTful API routes for CRUD operations
254- Be careful with error handling as Hono tends to swallow errors
255- Always include this snippet at the top-level Hono app to re-throwing errors to see full stack traces:
268- Use React 18.2.0 consistently in all imports and the `@jsxImportSource` pragma
269- Follow the React component pattern from the example project
270- Handle API calls properly with proper error catching
271
272### Database Patterns
299   - For files in the project, use `readFile` helpers
300
3015. **API Design:**
302   - `fetch` handler is the entry point for HTTP vals
303   - Run the Hono app with `export default app.fetch // This is the entry point for HTTP vals`

10import { NotebookView } from "./NotebookView.tsx";
11
12const API_BASE = "/api/memories";
13const MEMORIES_PER_PAGE = 20; // Increased from 7 to 20 memories per page
14
90
91    // Fetch avatar image
92    fetch("/api/images/stevens.jpg")
93      .then((response) => {
94        if (response.ok) return response.blob();
104
105    // Fetch wood background
106    fetch("/api/images/wood.jpg")
107      .then((response) => {
108        if (response.ok) return response.blob();
133    setError(null);
134    try {
135      const response = await fetch(API_BASE);
136      if (!response.ok) {
137        throw new Error(`HTTP error! status: ${response.status}`);
176
177    try {
178      const response = await fetch(API_BASE, {
179        method: "POST",
180        headers: { "Content-Type": "application/json" },
199
200    try {
201      const response = await fetch(`${API_BASE}/${id}`, {
202        method: "DELETE",
203      });
231
232    try {
233      const response = await fetch(`${API_BASE}/${editingMemory.id}`, {
234        method: "PUT",
235        headers: { "Content-Type": "application/json" },
606    <div className="font-pixel text-[#f8f1e0]">
607      <style jsx>{`
608        @import url("https://fonts.googleapis.com/css2?family=Pixelify+Sans&display=swap");
609
610        @tailwind base;

10});
11
12// Helper function to fetch content from the getContent API
13async function fetchContentFromUrl(url) {
14  // This URL should be updated with the actual getContent API URL
15  const getContentApiUrl = "https://nulo--2b8a5f201aaf11f094a0569c3dd06744.web.val.run";
16  const encodedUrl = encodeURIComponent(url);
17  const response = await fetch(`${getContentApiUrl}/content/${encodedUrl}`);
18
19  if (!response.ok) {
26// Helper function to summarize content using OpenRouter (Gemini 2.0 Flash)
27async function summarizeWithGemini(content) {
28  const openRouterApiKey = Deno.env.get("OPENROUTER_API_KEY");
29  if (!openRouterApiKey) {
30    throw new Error("OpenRouter API key not configured");
31  }
32
33  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
34    method: "POST",
35    headers: {
36      "Authorization": `Bearer ${openRouterApiKey}`,
37      "Content-Type": "application/json",
38      "HTTP-Referer": "https://val.town", // Required by OpenRouter
57  if (!response.ok) {
58    const errorText = await response.text();
59    throw new Error(`OpenRouter API error: ${response.status} ${errorText}`);
60  }
61
219        </div>
220        
221        <h2>API Usage</h2>
222        <pre><code>GET /summarize/{encodeURIComponent('https://example.com')}</code></pre>
223        
225        <pre><code>GET /summarize/https%3A%2F%2Fwww.example.com</code></pre>
226        
227        <p>The API will cache results to improve performance on subsequent requests.</p>
228        
229        <p><a href="${import.meta.url.replace("esm.sh", "val.town")}" target="_top">View Source</a></p>
238    <html>
239      <head>
240        <title>Content Tools API</title>
241        <style>
242          body { font-family: system-ui, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; line-height: 1.6; }
248      </head>
249      <body>
250        <h1>Content Tools API</h1>
251        <p>Choose a tool to work with web content:</p>
252        

69        }
70
71        // Return plain markdown for API requests
72        return c.text(await blobb.text(), 200, {
73          "Content-Type": "text/markdown",
79    console.log(`Cache miss for ${url}, fetching from Firecrawl`);
80
81    // Get Firecrawl API token from environment variable
82    const apiToken = Deno.env.get("FIRECRAWL_API_TOKEN");
83    if (!apiToken) {
84      return c.text("API token not configured", 500);
85    }
86
87    // Call Firecrawl API
88    const response = await fetch("https://api.firecrawl.dev/v1/scrape", {
89      method: "POST",
90      headers: {
91        "Authorization": `Bearer ${apiToken}`,
92        "Content-Type": "application/json",
93      },
109    if (!response.ok) {
110      const errorText = await response.text();
111      console.error(`Firecrawl API error: ${response.status} ${errorText}`);
112      return c.text(`Failed to fetch content: ${response.status}`, 500);
113    }
158    }
159
160    // Return plain markdown for API requests
161    return c.text(markdownContent, 200, {
162      "Content-Type": "text/markdown",
174    <html>
175      <head>
176        <title>URL to Markdown API</title>
177        <style>
178          body { font-family: system-ui, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; line-height: 1.6; }
207      </head>
208      <body>
209        <h1>URL to Markdown API</h1>
210        <p>This API fetches content from a URL and returns it as markdown.</p>
211        
212        <div class="tools-nav">
227        </div>
228        
229        <h2>API Usage</h2>
230        <pre><code>GET /content/{encodeURIComponent('https://example.com')}</code></pre>
231        
233        <pre><code>GET /content/https%3A%2F%2Fwww.example.com</code></pre>
234        
235        <p>The API will cache results to improve performance on subsequent requests.</p>
236        
237        <p><a href="${import.meta.url.replace("esm.sh", "val.town")}" target="_top">View Source</a></p>