Val Town Code SearchReturn to Val Town

236export default async function server(request: Request): Promise<Response> {
237  if (request.method === "POST") {
238    const { OpenAI } = await import("https://esm.town/v/std/openai");
239    const openai = new OpenAI();
240
241    const { question } = await request.json();
242
243    const completion = await openai.chat.completions.create({
244      messages: [
245        {

7- `index.ts` - Main API entry point with Hono framework (HTTP trigger)
8- `database.ts` - SQLite database operations for storing resumes and job requirements
9- `parser.ts` - Resume parsing logic using OpenAI's GPT models
10- `scorer.ts` - Candidate scoring algorithms and feedback generation
11

1import { OpenAI } from "https://esm.town/v/std/openai";
2import type { Resume, JobRequirement, ScoringResult, ParsedResumeData } from "../shared/types";
3import { calculateSimilarity } from "../shared/utils";
4
5const openai = new OpenAI();
6
7/**
197    `;
198
199    const completion = await openai.chat.completions.create({
200      messages: [{ role: "user", content: prompt }],
201      model: "gpt-4o-mini",

1import { OpenAI } from "https://esm.town/v/std/openai";
2import type { ParsedResumeData } from "../shared/types";
3
4const openai = new OpenAI();
5
6/**
7 * Parses resume text using OpenAI to extract structured information
8 */
9export async function parseResume(resumeText: string): Promise<ParsedResumeData> {
48    `;
49
50    const completion = await openai.chat.completions.create({
51      messages: [{ role: "user", content: prompt }],
52      model: "gpt-4o-mini",
57    const content = completion.choices[0]?.message?.content;
58    if (!content) {
59      throw new Error("Failed to get a response from OpenAI");
60    }
61
104    `;
105
106    const completion = await openai.chat.completions.create({
107      messages: [{ role: "user", content: prompt }],
108      model: "gpt-4o-mini",
113    const content = completion.choices[0]?.message?.content;
114    if (!content) {
115      throw new Error("Failed to get a response from OpenAI");
116    }
117

5## Features
6
7- Resume text analysis using OpenAI's GPT models
8- Keyword extraction and skills matching
9- Candidate scoring and ranking
40## Technologies Used
41
42- OpenAI API for natural language processing
43- SQLite for data storage
44- Hono for backend API

6import { SyntaxHighlighter } from "./components/SyntaxHighlighter.ts";
7import { DebugConsole } from "./components/DebugConsole.ts";
8import { OpenAIConnector } from "../shared/OpenAIConnector.ts";
9import { ThemeManager } from "./components/ThemeManager.ts";
10import { ConfettiManager } from "./components/ConfettiManager.ts";
18  const syntaxHighlighter = new SyntaxHighlighter();
19  const debugConsole = new DebugConsole();
20  const openAIConnector = new OpenAIConnector();
21  const themeManager = new ThemeManager();
22  const confettiManager = new ConfettiManager();
27  
28  // Set up all event handlers
29  setupFormHandling(tokenizer, scriptEditor, syntaxHighlighter, openAIConnector, confettiManager, textFormatter);
30  setupTokenCounter(tokenizer);
31  setupTemplateSelector(templateManager);
32  setupAdvancedOptions(openAIConnector, debugConsole);
33  setupResultActions(scriptEditor, textFormatter);
34  setupHistoryModal(historyManager, scriptEditor);
51  scriptEditor: ScriptEditor, 
52  syntaxHighlighter: SyntaxHighlighter,
53  openAIConnector: OpenAIConnector,
54  confettiManager: ConfettiManager,
55  textFormatter: TextFormatter
144      const apiKeyInput = document.getElementById("apiKey") as HTMLInputElement;
145      if (apiKeyInput && apiKeyInput.value && localStorage.getItem("useDirectApi") === "true") {
146        // Process directly with OpenAI API
147        const prompt = createPromptForScriptType(
148          text, 
153        );
154        
155        const response = await openAIConnector.createChatCompletion({
156          model,
157          messages: [{ role: "user", content: prompt }],
314
315// Set up advanced options
316function setupAdvancedOptions(openAIConnector: OpenAIConnector, debugConsole: DebugConsole) {
317  const advancedOptionsBtn = document.getElementById("advancedOptionsBtn") as HTMLButtonElement;
318  const advancedOptions = document.getElementById("advancedOptions") as HTMLDivElement;
350    
351    if (!apiKey.startsWith("sk-")) {
352      alert("Invalid API key format. OpenAI API keys start with 'sk-'");
353      return;
354    }
356    try {
357      // Set the API key in the connector
358      openAIConnector.setApiKey(apiKey);
359      
360      // Store the preference (but not the key itself)

318            <div class="md:col-span-3">
319              <div class="flex items-center justify-between">
320                <label for="apiKey" class="block text-sm font-medium text-gray-700 dark:text-gray-300">OpenAI API Key (Optional)</label>
321                <span class="text-xs text-gray-500 dark:text-gray-400">Direct API connection</span>
322              </div>
649    
650    <footer class="mt-8 text-center text-sm text-gray-500 dark:text-gray-400">
651      <p>Powered by OpenAI GPT-4 • <a href="#" id="viewSourceLink" target="_top" class="text-indigo-600 dark:text-indigo-400 hover:underline">View Source</a></p>
652    </footer>
653  </div>

16      // Call AI service with your private API key
17      // Replace with your actual AI service URL
18      const aiResponse = await fetch("https://api.openai.com/v1/chat/completions", {
19        method: "POST",
20        headers: {

1# Script Improver Pro
2
3A Val Town application that processes large scripts through OpenAI's GPT-4 model to make them clearer, more concise, and better written.
4
5## Features
10- Combines processed outputs seamlessly
11- Simple, responsive UI with token counting and progress tracking
12- **Direct OpenAI API Connection** - Use your own API key for direct processing
13- **Debug Console** - View API requests, responses, and token usage
14- **Script Type Detection** - Automatically identifies screenplay, technical, marketing, academic, or creative content
211. The user pastes their script into the text area and provides optional instructions
222. The application splits the text into chunks of approximately 3330 tokens each
233. Each chunk is processed sequentially through OpenAI's GPT-4 model
244. The processed chunks are combined, handling overlaps to avoid duplication
255. The improved script is displayed to the user
28
29- `/index.ts` - Main HTTP endpoint and route handler
30- `/backend/processor.ts` - Text processing logic and OpenAI integration
31- `/backend/openaiProxy.ts` - Server-side proxy for OpenAI API calls
32- `/backend/scriptTypeDetector.ts` - Automatic script type detection
33- `/shared/tokenizer.ts` - Advanced token counting and text chunking
34- `/shared/OpenAIConnector.ts` - Direct OpenAI API connection handling
35- `/frontend/index.html` - Main HTML template
36- `/frontend/index.ts` - Frontend JavaScript logic
42- **Backend**: Hono.js for HTTP routing
43- **Frontend**: Vanilla TypeScript with Tailwind CSS
44- **AI**: OpenAI GPT-4 for text processing
45- **Styling**: Tailwind CSS for responsive design
46- **Syntax Highlighting**: highlight.js for code highlighting
512. Select script type or use auto-detection
523. Choose an instruction template or write custom instructions
534. (Optional) Set your OpenAI API key for direct processing
545. Click "Improve Script" to process
556. View, compare, and download the improved script
58
59### Direct API Connection
60You can use your own OpenAI API key for direct processing, bypassing the server proxy. This can be useful for:
61- Processing very large scripts
62- Using custom model parameters
80## Limitations
81
82- Token counting is approximate and may not exactly match OpenAI's tokenizer
83- Very large scripts may take longer to process
84- The quality of improvements depends on the clarity of instructions and the quality of the input script

1import { OpenAI } from "https://esm.town/v/std/openai";
2import { Tokenizer } from "../shared/tokenizer.ts";
3import { blob } from "https://esm.town/v/std/blob";
4
5// Use the standard OpenAI library for server-side processing
6const openai = new OpenAI();
7const tokenizer = new Tokenizer();
8
12const OVERLAP_TOKENS = 250;
13
14// OpenAI model configuration
15const DEFAULT_MODEL = "gpt-4o";
16const DEFAULT_TEMPERATURE = 0.7;
17
18/**
19 * Process large text by splitting into chunks and sending to OpenAI
20 */
21export async function processLargeText(
71    }
72    
73    // Process with OpenAI
74    const processedChunk = await processChunkWithOpenAI(
75      chunk, 
76      contextualInstructions, 
287
288/**
289 * Process a single chunk with OpenAI
290 */
291async function processChunkWithOpenAI(
292  chunk: string, 
293  instructions: string, 
307    for (let attempt = 0; attempt < 3; attempt++) {
308      try {
309        const completion = await openai.chat.completions.create({
310          model: config.model,
311          messages: [{ role: "user", content: prompt }],