synthos 0.1.0

package/src/pages.ts

@@ -0,0 +1,55 @@
+import {checkIfExists, listFiles, loadFile, saveFile} from './files';
+import path from 'path';
+
+// Page State Cache
+const _pages: { [name: string]: string } = {};
+
+export async function listPages(pagesFolder: string, fallbackPagesFolder: string): Promise<string[]> {
+    // Load all pages from primary pages folder
+    const all = (await listFiles(pagesFolder)).filter(file => file.endsWith('.html'));
+
+    // Add pages from fallback pages folder that don't already exist
+    (await listFiles(fallbackPagesFolder)).forEach(file => {
+        if (file.endsWith('.html') && !all.includes(file)) {
+            all.push(file);
+        }
+    });
+
+    // Remove .html and sort all files
+    const sorted = all.map(file => file.substring(0, file.length - 5)).sort();
+    
+    // Move [templates] to end of array
+    const pages = sorted.filter(page => !page.startsWith('['));
+    const templates = sorted.filter(page => page.startsWith('['));
+    pages.push(...templates);
+
+    return pages;
+}
+
+export async function loadPageState(pagesFolder: string, name: string, reset: boolean): Promise<string|undefined> {
+    if (!_pages[name] || reset) {
+        // Check for file to exist
+        const filename = path.join(pagesFolder, `${name}.html`);
+        if (!(await checkIfExists(filename))) {
+            return undefined;
+        }
+
+        // Load file
+        _pages[name] = await loadFile(filename);
+    }
+
+    return _pages[name];
+}
+
+export function normalizePageName(name: string|undefined): string|undefined {
+    return typeof name == 'string' && name.length > 0 ? name.replace(/[^a-z0-9\-_\[\]\(\)\{\}@#\$%&]/gi, '_').toLowerCase() : undefined;
+}
+
+export async function savePageState(pagesFolder: string, name: string, content: string): Promise<void> {
+    _pages[name] = content;
+    await saveFile(path.join(pagesFolder, `${name}.html`), content);
+}
+
+export function updatePageState(name: string, content: string): void {
+    _pages[name] = content;
+}

package/src/scripts.ts

@@ -0,0 +1,130 @@
+import { AgentCompletion, variableToString } from 'agentm-core';
+import { spawn } from 'child_process';
+import path from 'path';
+import { loadFile, listFiles, checkIfExists } from './files';
+
+export interface ExecuteScriptArgs {
+    pagesFolder: string;
+    scriptId: string;
+    variables: Record<string, string>;
+}
+
+export interface ExecuteScriptResponse {
+    output: string;
+    errors: string[];
+}
+
+export async function listScripts(pagesFolder: string): Promise<string> {
+    if (!scriptsList) {
+        let list: string[] = [];
+        const folder = path.join(pagesFolder, 'scripts');
+        if (await checkIfExists(folder)) {
+            const files = (await listFiles(folder)).filter(f => f.endsWith('.json'));
+            for (const file of files) {
+                const script = await loadFile(path.join(folder, file));
+                if (script) {
+                    try {
+                        const parsed = JSON.parse(script) as ParsedScript;
+                        const description = parsed.description ? `description: ${parsed.description}\n` : '';
+                        const request = parsed.variables ? `request: ${parsed.variables}\n` : '';
+                        const response = parsed.response ? `response: ${parsed.response}` : 'response: string';
+                        list.push(`POST /api/scripts/${parsed.id}\n${description}${request}${response}`);
+                    } catch (err) {
+                        console.error(err);
+                    }
+                }
+            }
+        }
+
+        // Cache the list
+        scriptsList = list.join('\n\n');
+    }
+
+    return scriptsList;
+}
+
+export function clearCachedScripts(): void {
+    scriptsList = undefined;
+}
+
+
+export async function executeScript(args: ExecuteScriptArgs): Promise<AgentCompletion<ExecuteScriptResponse>> {
+    const { pagesFolder, scriptId, variables } = args;
+
+    // Load the script
+    const script = await loadFile(path.join(pagesFolder, `scripts`, `${scriptId}.json`));
+    if (!script) {
+        return { completed: false, error: new Error(`Script not found: ${scriptId}`) };
+    }
+
+    // Parse the script
+    let parsed: ParsedScript;
+    try {
+        parsed = JSON.parse(script) as ParsedScript;
+    } catch (err) {
+        return { completed: false, error: err as Error };
+    }
+
+    // Substitute variables
+    const commandText = composeArguments(parsed.command, variables);
+    console.log(`Executing: ${commandText}`);
+    
+    // Split into an array while honoring double quotes
+    const argv = commandText.match(/"[^"]*"|\S+/g) || [];
+    if (argv.length === 0) {
+        return { completed: false, error: new Error('No command specified') };
+    }
+
+    // Execute the process
+    try {
+        const command = argv.shift() as string;
+        const value = await spawnProcess(command, argv);
+    
+        return { completed: true, value };
+    } catch (err: unknown) {
+        return { completed: false, error: err as Error };
+    }
+}
+
+let scriptsList: string|undefined = undefined;
+
+interface ParsedScript {
+    id: string;
+    type: 'command';
+    command: string;
+    description?: string;
+    variables?: string;
+    response?: string;
+}
+
+function spawnProcess(command: string, args: string[]): Promise<ExecuteScriptResponse> {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { shell: true });
+
+        let output = '';
+        const errors: string[] = [];
+
+        child.stdout.on('data', (data) => {
+            output += data;
+        });
+
+        child.stderr.on('data', (data) => {
+            errors.push(data.toString());
+        });
+
+        child.on('close', (code) => {
+            resolve({ output, errors });
+        });
+
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+
+function composeArguments(template: string, variables: Record<string, any>): string {
+    return template.replace(/{{\s*([^}\s]+)\s*}}/g, (match, name) => {
+        // Convert the variable to a string and replace double quotes and line feeds with spaces
+        return variableToString(variables[name]);
+    });
+}

package/src/service/createCompletePrompt.ts

@@ -0,0 +1,40 @@
+import {anthropic, completePrompt, logCompletePrompt, openai} from 'agentm-core';
+import { loadSettings } from '../settings';
+
+export const availableModels = [
+    'claude-3-5-sonnet-20240620',
+    'gpt-4o-mini',
+    'gpt-4o-2024-08-06',
+    'o1-mini',
+    'o1-preview'
+];
+
+export async function createCompletePrompt(pagesFolder: string, model?: string): Promise<completePrompt> {
+    // Get configuration settings
+    const settings = await loadSettings(pagesFolder);
+    if (!settings.serviceApiKey) {
+        throw new Error('OpenAI API key not configured');
+    }
+
+    // Validate model
+    model = model || settings.model;
+    if (!model) {
+        throw new Error('Model not configured');
+    }
+
+    // Create completion functions
+    let modelInstance: completePrompt;
+    const apiKey = settings.serviceApiKey;
+    if (model.startsWith('claude-')) {
+        modelInstance = anthropic({apiKey, model});
+    } else {
+        modelInstance = openai({apiKey, model});
+    }
+
+    // Return new model instance
+    if (settings.logCompletions) {
+        return logCompletePrompt(modelInstance, true);
+    } else {
+        return modelInstance;
+    }
+}

package/src/service/generateImage.ts

@@ -0,0 +1,101 @@
+import OpenAI from "openai";
+import { AgentCompletion, RequestError } from "agentm-core";
+import { loadFile } from "../files";
+import path from "path";
+
+/**
+ * Arguments to configure an OpenAI chat model.
+ */
+export interface OpenaiGenerateImageArgs {
+    /**
+     * OpenAI API key to use for completions.
+     */
+    apiKey: string;
+
+    /**
+     * Prompt to use for generating image.
+     */
+    prompt: string;
+
+    /**
+     * Requested size of the generated image.
+     */
+    shape: 'square' | 'landscape' | 'portrait';
+
+    /**
+     * Requested quality of the generated image.
+     */
+    quality: 'standard' | 'hd';
+
+    /**
+     * Style of the generated image.
+     */
+    style: 'vivid' | 'natural';
+}
+
+export interface GeneratedImage {
+    url: string;
+}
+
+export function generateDefaultImage(): Promise<AgentCompletion<GeneratedImage>> {
+    if (!_defaultImage) {
+        _defaultImage = new Promise<AgentCompletion<GeneratedImage>>(async resolve => {
+            const file = await loadFile(path.join(__dirname, '../../defaultImage.json'));
+            const value = JSON.parse(file) as GeneratedImage;
+            resolve({ completed: true, value });
+        });
+    }
+
+    return _defaultImage;
+}
+
+export async function generateImage(args: OpenaiGenerateImageArgs): Promise<AgentCompletion<GeneratedImage>> {
+    const { apiKey, prompt, shape, quality, style } = args;
+
+    // Create client
+    const client = new OpenAI({ apiKey });
+
+    // Identify image size
+    let size: "1024x1024" | "1792x1024" | "1024x1792";
+    switch (shape) {
+        case 'square':
+        default:
+            size = "1024x1024";
+            break;
+        case 'landscape':
+            size = "1792x1024";
+            break;
+        case 'portrait':
+            size = "1024x1792";
+            break;
+    }
+
+    try {
+        const response = await client.images.generate({
+            model: "dall-e-3",
+            response_format: "b64_json",
+            n: 1,
+            prompt,
+            size,
+            quality,
+            style
+        });
+    
+        if (response.data.length > 0 && response.data[0].b64_json !== undefined) {
+            const url = `data:image/png;base64,${response.data[0].b64_json}`
+            return { completed: true, value: { url } };
+        } else {
+            return { completed: false, error: new Error('No image URL returned') };
+        }
+    } catch (err: unknown) {
+        let error: Error;
+        if (err instanceof OpenAI.APIError && err.status !== undefined) {
+            error = new RequestError(err.message, err.status, err.name);
+        } else {
+            error = err as Error;
+        }
+        return { completed: false, error };
+    }
+}
+
+let _defaultImage: Promise<AgentCompletion<GeneratedImage>> | undefined;

package/src/service/index.ts

@@ -0,0 +1,7 @@
+export * from './createCompletePrompt';
+export * from './requiresSettings';
+export * from './generateImage';
+export * from './server';
+export * from './transformPage';
+export * from './useApiRoutes';
+export * from './usePageRoutes';

package/src/service/requiresSettings.ts

@@ -0,0 +1,22 @@
+import { hasConfiguredSettings, loadSettings, Settings } from "../settings";
+
+
+export async function requiresSettings(res: any, folder: string, cb: (settings: Settings) => Promise<void>) {
+    try {
+        // Ensure settings configured
+        const isConfigured = await hasConfiguredSettings(folder);
+        if (!isConfigured) {
+            res.status(400).send('Settings not configured');
+            return;
+        }
+
+        // Load settings
+        const settings = await loadSettings(folder);
+
+        // Call the callback
+        await cb(settings);
+    } catch (err: unknown) {
+        console.error(err);
+        res.status(500).send((err as Error).message);
+    }
+}

package/src/service/server.ts

@@ -0,0 +1,26 @@
+import express, {Application} from 'express';
+import { usePageRoutes } from './usePageRoutes';
+import { useApiRoutes } from './useApiRoutes';
+import { SynthOSConfig } from '../init';
+import { useDataRoutes } from './useDataRoutes';
+
+export function server(config: SynthOSConfig): Application {
+    const app = express();
+    
+    // Middleware to parse URL-encoded data (form data)
+    app.use(express.urlencoded({ extended: true }));
+
+    // Middleware to parse JSON data
+    app.use(express.json());
+
+    // Page handling routes
+    usePageRoutes(config, app);
+
+    // API routes
+    useApiRoutes(config, app);
+
+    // Data routes
+    useDataRoutes(config, app);
+    
+    return app;
+}

package/src/service/transformPage.ts

@@ -0,0 +1,135 @@
+import { AgentArgs, AgentCompletion, generateObject, JsonSchema, SystemMessage, UserMessage } from "agentm-core";
+import { listScripts } from "../scripts";
+
+export interface TransformPageArgs extends AgentArgs {
+    pagesFolder: string;
+    pageState: string;
+    message: string;
+    maxTokens: number;
+    instructions?: string;
+}
+
+export async function transformPage(args: TransformPageArgs): Promise<AgentCompletion<string>> {
+    // Get list of registered scripts
+    const scripts = await listScripts(args.pagesFolder);
+    const serverScripts = scripts.length > 0 ? `<SERVER_SCRIPTS>\n${scripts}\n\n` : '';
+
+    // Define system message
+    const { pageState, message, maxTokens, completePrompt } = args;
+    const system: SystemMessage = {
+        role: 'system',
+        content: `<CURRENT_PAGE>\n${pageState}\n\n<SERVER_APIS>\n${serverAPIs}\n\n${serverScripts}<USER_MESSAGE>\n${message}`
+    };
+
+    // Create prompt
+    const instructions = args.instructions ? `\n\n<INSTRUCTIONS>\n${args.instructions}` : '';
+    const prompt: UserMessage = {
+        role: 'user',
+        content: `${goal}${instructions}`
+    };
+
+    // Complete prompt
+    const result = await completePrompt({ prompt, system, maxTokens });
+    if (result.completed) {
+        // Find html content
+        let start = result.value.indexOf(`<!DOCTYPE`);
+        start = start >= 0 ? start : result.value.indexOf('<html');
+        const end = result.value.lastIndexOf('</html>');
+        if (start >= 0 && end >= start) {
+            const value = result.value.substring(start, end + 7);
+            return { completed: true, value };
+        } else {
+            return { completed: false, error: new Error('Failed to find html content') };
+        }
+    } else {
+        return { completed: false, error: result.error };
+    }
+}
+
+export async function transformPageAsObject(args: TransformPageArgs): Promise<AgentCompletion<string>> {
+    // Get list of registered scripts
+    const scripts = await listScripts(args.pagesFolder);
+    const serverScripts = scripts.length > 0 ? `<SERVER_SCRIPTS>\n${scripts}\n\n` : '';
+
+    // Provide additional context
+    const { pageState, message, maxTokens, instructions, completePrompt, shouldContinue } = args;
+    const context = `<CURRENT_PAGE>\n${pageState}\n\n<SERVER_APIS>\n${serverAPIs}\n\n${serverScripts}<USER_MESSAGE>\n${message}`;
+
+    // Generate next page
+    const result = await generateObject<HtmlPage>({ goal, jsonSchema, maxTokens, context, instructions, completePrompt, shouldContinue });
+    if (result.completed) {
+        return { completed: true, value: result.value?.content! };
+    } else {
+        return { completed: false, error: result.error };
+    }
+}
+
+// Define output shape
+interface HtmlPage {
+    content: string;
+}
+
+const jsonSchema: JsonSchema = {
+    name: 'HtmlPage',
+    schema: {
+        type: 'object',
+        properties: {
+            content: {
+                type: 'string',
+                description: 'html page content to return'
+            }
+        },
+        required: ['content'],
+        additionalProperties: false
+    },
+    strict: true
+};
+
+const goal =
+`Generate a new web page that represents the next state of the chat based on the users message.
+Append the the users message and a brief response from the AI to the chat panel.
+Maintain the full conversation history in the chat panel unless asked to clear it.
+Any details or visualizations should be rendered to the viewer panel.
+The basic layout structure of the page needs to be maintained.
+You're free to write any additional CSS or JavaScript to enhance the page.
+Write an explication of your reasoning or any hidden thoughts to the thoughts div.
+If the user asks to create something like an app, tool, game, or ui create it in the viewer panel.
+If the user asks to draw something use canvas to draw it in the viewer panel.
+Always return the full html content of the page.`;
+
+const serverAPIs =
+`GET /api/data/:table
+description: Retrieve all rows from a table
+response: Array of JSON rows [{ id: string, ... }]
+
+GET /api/data/:table/:id
+description: Retrieve a single row from a table
+response: JSON row { id: string, ... }
+
+POST /api/data/:table
+description: Replaces or adds a single row to a table and returns the row
+request: JSON row { id?: string, ... }
+response: { id: string, ... }
+
+DELETE /api/data/:table/:id
+description: Delete a single row from a table
+response: { success: true }
+
+POST /api/generate/image
+description: Generate an image based on a prompt
+request: { prompt: string, shape: 'square' | 'portrait' | 'landscape', style: 'vivid' | 'natural' }
+response: { url: string }
+
+POST /api/generate/completion
+description: Generates a text completion based on a prompt
+request: { prompt: string, temperature?: number }
+response: { answer: string, explanation: string }
+
+GET /api/pages
+description: Retrieve a list of all pages
+response: Array of page names [string]
+
+POST /api/scripts/:id
+description: Execute a script with the passed in variables
+request: { [key: string]: string }
+response: string`;

package/src/service/useApiRoutes.ts

@@ -0,0 +1,95 @@
+import { listPages } from "../pages";
+import {loadSettings, saveSettings } from "../settings";
+import { Application } from 'express';
+import { SynthOSConfig } from "../init";
+import { availableModels, createCompletePrompt } from "./createCompletePrompt";
+import { generateDefaultImage, generateImage } from "./generateImage";
+import { chainOfThought } from "agentm-core";
+import { requiresSettings } from "./requiresSettings";
+import { executeScript } from "../scripts";
+
+export function useApiRoutes(config: SynthOSConfig, app: Application): void {
+    // List pages
+    app.get('/api/pages', async (req, res) => {
+        const pages = await listPages(config.pagesFolder, config.requiredPagesFolder);
+        res.json(pages);
+    });
+
+    // Define a route to return settings
+    app.get('/api/settings', async (req, res) => {
+        const settings = await loadSettings(config.pagesFolder);
+        res.json({...settings, availableModels});
+    });
+
+    // Define a route to save settings
+    app.post('/api/settings', async (req, res) => {
+        try {
+            // Covert non-string values
+            const settings = req.body as Record<string, any>;
+            if (typeof settings.maxTokens === 'string') {
+                settings.maxTokens = parseInt(settings.maxTokens);
+            }
+            if (typeof settings.logCompletions === 'string') {
+                settings.logCompletions = settings.logCompletions === 'true';
+            }
+
+            // Save settings
+            await saveSettings(config.pagesFolder, settings);
+            res.redirect('/home');
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).send((err as Error).message);
+        }
+    });
+
+    // Define a route to generate an image
+    app.post('/api/generate/image', async (req, res) => {
+        await requiresSettings(res, config.pagesFolder, async (settings) => {
+            const { prompt, shape, style } = req.body;
+            const { serviceApiKey, imageQuality, model } = settings;
+            const response = model.startsWith('gpt-') ?
+                await generateImage({ apiKey: serviceApiKey, prompt, shape, quality: imageQuality, style }) :
+                await generateDefaultImage();
+            if (response.completed) {
+                res.json(response.value);
+            } else {
+                res.status(500).send(response.error?.message);
+            }
+        });
+    });
+
+    // Define a route to generate a completion using chain-of-thought
+    app.post('/api/generate/completion', async (req, res) => {
+        await requiresSettings(res, config.pagesFolder, async (settings) => {
+            const { prompt, temperature } = req.body;
+            const { maxTokens } = settings;
+            const completePrompt = await createCompletePrompt(config.pagesFolder, req.body.model);
+            const response = await chainOfThought({ question: prompt, temperature, maxTokens, completePrompt });
+            if (response.completed) {
+                res.json(response.value ?? {});
+            } else {
+                console.error(response.error);
+                res.status(500).send(response.error?.message);
+            }
+        });
+    });
+
+    // Define a route for running configured scripts
+    app.post('/api/scripts/:id', async (req, res) => {
+        await requiresSettings(res, config.pagesFolder, async (settings) => {
+            const { id } = req.params;
+            const pagesFolder = config.pagesFolder;
+            const scriptId = id;
+            const response = await executeScript({ pagesFolder, scriptId, variables: req.body });
+            if (response.completed) {
+                // Return the response as text
+                const value = (response.value?.output ?? (response.value?.errors ?? []).join('\n')).trim();
+                res.set('Content-Type', 'text/plain');
+                res.send(value);
+            } else {
+                console.error(response.error);
+                res.status(500).send(response.error);
+            }
+        });
+    });
+}