synthos 0.7.1 → 0.8.0

package/tests/files.spec.ts

@@ -0,0 +1,233 @@
+import assert from 'assert';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import path from 'path';
+import {
+    checkIfExists,
+    ensureFolderExists,
+    saveFile,
+    loadFile,
+    deleteFile,
+    listFiles,
+    listFolders,
+    copyFile,
+    copyFiles,
+    copyFolderRecursive,
+    deleteFolder,
+} from '../src/files';
+
+let tmpDir: string;
+
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'synthos-test-'));
+});
+
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// checkIfExists
+// ---------------------------------------------------------------------------
+
+describe('checkIfExists', () => {
+    it('returns true for an existing file', async () => {
+        const file = path.join(tmpDir, 'exists.txt');
+        await fs.writeFile(file, 'hi');
+        assert.strictEqual(await checkIfExists(file), true);
+    });
+
+    it('returns false for a non-existing file', async () => {
+        assert.strictEqual(await checkIfExists(path.join(tmpDir, 'nope.txt')), false);
+    });
+
+    it('returns true for an existing directory', async () => {
+        assert.strictEqual(await checkIfExists(tmpDir), true);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// ensureFolderExists
+// ---------------------------------------------------------------------------
+
+describe('ensureFolderExists', () => {
+    it('creates a new folder', async () => {
+        const dir = path.join(tmpDir, 'new-folder');
+        await ensureFolderExists(dir);
+        const stat = await fs.stat(dir);
+        assert.ok(stat.isDirectory());
+    });
+
+    it('creates nested folders recursively', async () => {
+        const dir = path.join(tmpDir, 'a', 'b', 'c');
+        await ensureFolderExists(dir);
+        const stat = await fs.stat(dir);
+        assert.ok(stat.isDirectory());
+    });
+
+    it('does not throw if folder already exists', async () => {
+        await ensureFolderExists(tmpDir);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// saveFile / loadFile roundtrip
+// ---------------------------------------------------------------------------
+
+describe('saveFile / loadFile', () => {
+    it('writes and reads back the same content', async () => {
+        const file = path.join(tmpDir, 'round.txt');
+        await saveFile(file, 'hello world');
+        const content = await loadFile(file);
+        assert.strictEqual(content, 'hello world');
+    });
+
+    it('handles unicode content', async () => {
+        const file = path.join(tmpDir, 'unicode.txt');
+        const text = '日本語テスト 🎉';
+        await saveFile(file, text);
+        assert.strictEqual(await loadFile(file), text);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// deleteFile
+// ---------------------------------------------------------------------------
+
+describe('deleteFile', () => {
+    it('removes an existing file', async () => {
+        const file = path.join(tmpDir, 'del.txt');
+        await fs.writeFile(file, 'bye');
+        await deleteFile(file);
+        assert.strictEqual(await checkIfExists(file), false);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// listFiles
+// ---------------------------------------------------------------------------
+
+describe('listFiles', () => {
+    it('returns files with extensions', async () => {
+        await fs.writeFile(path.join(tmpDir, 'a.txt'), '');
+        await fs.writeFile(path.join(tmpDir, 'b.json'), '');
+        const files = await listFiles(tmpDir);
+        assert.ok(files.includes('a.txt'));
+        assert.ok(files.includes('b.json'));
+    });
+
+    it('filters out dot-files', async () => {
+        await fs.writeFile(path.join(tmpDir, '.hidden'), '');
+        await fs.writeFile(path.join(tmpDir, 'visible.txt'), '');
+        const files = await listFiles(tmpDir);
+        assert.ok(!files.includes('.hidden'));
+        assert.ok(files.includes('visible.txt'));
+    });
+
+    it('filters out directories (no dot in name)', async () => {
+        await fs.mkdir(path.join(tmpDir, 'subdir'));
+        await fs.writeFile(path.join(tmpDir, 'file.txt'), '');
+        const files = await listFiles(tmpDir);
+        assert.ok(!files.includes('subdir'));
+        assert.ok(files.includes('file.txt'));
+    });
+});
+
+// ---------------------------------------------------------------------------
+// listFolders
+// ---------------------------------------------------------------------------
+
+describe('listFolders', () => {
+    it('returns only directories', async () => {
+        await fs.mkdir(path.join(tmpDir, 'dirA'));
+        await fs.mkdir(path.join(tmpDir, 'dirB'));
+        await fs.writeFile(path.join(tmpDir, 'file.txt'), '');
+        const folders = await listFolders(tmpDir);
+        assert.ok(folders.includes('dirA'));
+        assert.ok(folders.includes('dirB'));
+        assert.ok(!folders.includes('file.txt'));
+    });
+
+    it('filters out dot-directories', async () => {
+        await fs.mkdir(path.join(tmpDir, '.hidden'));
+        await fs.mkdir(path.join(tmpDir, 'visible'));
+        const folders = await listFolders(tmpDir);
+        assert.ok(!folders.includes('.hidden'));
+        assert.ok(folders.includes('visible'));
+    });
+});
+
+// ---------------------------------------------------------------------------
+// copyFile
+// ---------------------------------------------------------------------------
+
+describe('copyFile', () => {
+    it('copies a file to a destination folder', async () => {
+        const src = path.join(tmpDir, 'src.txt');
+        const destDir = path.join(tmpDir, 'dest');
+        await fs.writeFile(src, 'content');
+        await copyFile(src, destDir);
+        const copied = await fs.readFile(path.join(destDir, 'src.txt'), 'utf8');
+        assert.strictEqual(copied, 'content');
+    });
+
+    it('creates the destination folder if it does not exist', async () => {
+        const src = path.join(tmpDir, 'src2.txt');
+        const destDir = path.join(tmpDir, 'new-dest');
+        await fs.writeFile(src, 'data');
+        await copyFile(src, destDir);
+        assert.strictEqual(await checkIfExists(destDir), true);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// copyFiles
+// ---------------------------------------------------------------------------
+
+describe('copyFiles', () => {
+    it('copies all files from source to destination folder', async () => {
+        const srcDir = path.join(tmpDir, 'src-dir');
+        const destDir = path.join(tmpDir, 'dest-dir');
+        await fs.mkdir(srcDir);
+        await fs.writeFile(path.join(srcDir, 'a.txt'), 'aaa');
+        await fs.writeFile(path.join(srcDir, 'b.txt'), 'bbb');
+
+        await copyFiles(srcDir, destDir);
+
+        assert.strictEqual(await fs.readFile(path.join(destDir, 'a.txt'), 'utf8'), 'aaa');
+        assert.strictEqual(await fs.readFile(path.join(destDir, 'b.txt'), 'utf8'), 'bbb');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// copyFolderRecursive
+// ---------------------------------------------------------------------------
+
+describe('copyFolderRecursive', () => {
+    it('copies a folder tree recursively', async () => {
+        const srcDir = path.join(tmpDir, 'tree');
+        await fs.mkdir(path.join(srcDir, 'sub'), { recursive: true });
+        await fs.writeFile(path.join(srcDir, 'root.txt'), 'root');
+        await fs.writeFile(path.join(srcDir, 'sub', 'child.txt'), 'child');
+
+        const destDir = path.join(tmpDir, 'tree-copy');
+        await copyFolderRecursive(srcDir, destDir);
+
+        assert.strictEqual(await fs.readFile(path.join(destDir, 'root.txt'), 'utf8'), 'root');
+        assert.strictEqual(await fs.readFile(path.join(destDir, 'sub', 'child.txt'), 'utf8'), 'child');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// deleteFolder
+// ---------------------------------------------------------------------------
+
+describe('deleteFolder', () => {
+    it('removes a folder and its contents', async () => {
+        const dir = path.join(tmpDir, 'to-delete');
+        await fs.mkdir(dir);
+        await fs.writeFile(path.join(dir, 'f.txt'), '');
+        await deleteFolder(dir);
+        assert.strictEqual(await checkIfExists(dir), false);
+    });
+});

package/tests/fireworksai.spec.ts

@@ -0,0 +1,92 @@
+import assert from 'assert';
+import { resolveFireworksModel, buildFireworksRequest, extractJSON } from '../src/models/fireworksai';
+import { PromptCompletionArgs } from '../src/models/types';
+
+// ---------------------------------------------------------------------------
+// resolveFireworksModel
+// ---------------------------------------------------------------------------
+
+describe('resolveFireworksModel', () => {
+    it('maps known short names to full paths', () => {
+        assert.strictEqual(
+            resolveFireworksModel('fireworks-glm-5'),
+            'accounts/fireworks/models/glm-5',
+        );
+        assert.strictEqual(
+            resolveFireworksModel('fireworks-minimax-m2p5'),
+            'accounts/fireworks/models/minimax-m2p5',
+        );
+    });
+
+    it('passes through unknown model names unchanged', () => {
+        assert.strictEqual(resolveFireworksModel('custom-model'), 'custom-model');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// buildFireworksRequest
+// ---------------------------------------------------------------------------
+
+describe('buildFireworksRequest', () => {
+    const baseArgs: PromptCompletionArgs = {
+        prompt: { role: 'user', content: 'Hello' },
+    };
+
+    it('builds messages from system + history + prompt', () => {
+        const args: PromptCompletionArgs = {
+            ...baseArgs,
+            system: { role: 'system', content: 'Be helpful' },
+            history: [
+                { role: 'user', content: 'Hi' },
+                { role: 'assistant', content: 'Hey' },
+            ],
+        };
+        const { messages } = buildFireworksRequest(args, 0.0);
+        assert.strictEqual(messages.length, 4);
+        assert.strictEqual(messages[0].role, 'system');
+        assert.strictEqual(messages[0].content, 'Be helpful');
+        assert.strictEqual(messages[3].role, 'user');
+        assert.strictEqual(messages[3].content, 'Hello');
+    });
+
+    it('appends JSON instruction to user content in jsonMode', () => {
+        const args: PromptCompletionArgs = { ...baseArgs, jsonMode: true };
+        const { messages, useJson } = buildFireworksRequest(args, 0.0);
+        const last = messages[messages.length - 1];
+        assert.ok(last.content.includes('Respond with valid JSON only'));
+        assert.strictEqual(useJson, true);
+    });
+
+    it('does not append JSON instruction in plain mode', () => {
+        const { messages, useJson } = buildFireworksRequest(baseArgs, 0.0);
+        const last = messages[messages.length - 1];
+        assert.ok(!last.content.includes('JSON'));
+        assert.strictEqual(useJson, false);
+    });
+
+    it('uses default temperature when none specified', () => {
+        const { temperature } = buildFireworksRequest(baseArgs, 0.5);
+        assert.strictEqual(temperature, 0.5);
+    });
+
+    it('uses args temperature when specified', () => {
+        const args: PromptCompletionArgs = { ...baseArgs, temperature: 0.9 };
+        const { temperature } = buildFireworksRequest(args, 0.5);
+        assert.strictEqual(temperature, 0.9);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// extractJSON (moved from providers.spec.ts for completeness)
+// ---------------------------------------------------------------------------
+
+describe('extractJSON (fireworksai)', () => {
+    it('extracts JSON from markdown code fences', () => {
+        const input = '```json\n{"key": "value"}\n```';
+        assert.strictEqual(extractJSON(input), '{"key": "value"}');
+    });
+
+    it('returns original text when no JSON found', () => {
+        assert.strictEqual(extractJSON('no json here'), 'no json here');
+    });
+});

package/tests/logCompletePrompt.spec.ts

@@ -0,0 +1,74 @@
+import assert from 'assert';
+import { logCompletePrompt } from '../src/models/logCompletePrompt';
+import { AgentCompletion, PromptCompletionArgs } from '../src/models/types';
+
+/** Build a minimal PromptCompletionArgs for testing. */
+function makeArgs(content = 'test'): PromptCompletionArgs {
+    return { prompt: { role: 'user', content } };
+}
+
+describe('logCompletePrompt', () => {
+    // Capture console.log output during each test
+    let logs: string[];
+    let origLog: typeof console.log;
+
+    beforeEach(() => {
+        logs = [];
+        origLog = console.log;
+        console.log = (...args: any[]) => { logs.push(args.join(' ')); };
+    });
+
+    afterEach(() => {
+        console.log = origLog;
+    });
+
+    it('passes args through to inner function and returns its result', async () => {
+        const expected: AgentCompletion<string> = { completed: true, value: 'hello' };
+        let received: PromptCompletionArgs | undefined;
+        const inner = async (args: PromptCompletionArgs) => { received = args; return expected; };
+        const wrapped = logCompletePrompt(inner);
+        const args = makeArgs('my prompt');
+        const result = await wrapped(args);
+        assert.strictEqual(result, expected);
+        assert.strictEqual(received, args);
+    });
+
+    it('handles completed result with string value (logs green)', async () => {
+        const inner = async () => ({ completed: true, value: 'output text' } as AgentCompletion<string>);
+        const wrapped = logCompletePrompt(inner);
+        await wrapped(makeArgs());
+        assert.ok(logs.some(l => l.includes('output text')));
+        // Check for green ANSI code
+        assert.ok(logs.some(l => l.includes('\x1b[32m')));
+    });
+
+    it('handles completed result with object value (JSON.stringify)', async () => {
+        const inner = async () => ({ completed: true, value: { a: 1 } } as AgentCompletion<any>);
+        const wrapped = logCompletePrompt(inner);
+        await wrapped(makeArgs());
+        assert.ok(logs.some(l => l.includes('"a": 1')));
+    });
+
+    it('handles failed result with error (logs red)', async () => {
+        const inner = async () => ({ completed: false, error: new Error('boom') } as AgentCompletion<string>);
+        const wrapped = logCompletePrompt(inner);
+        await wrapped(makeArgs());
+        assert.ok(logs.some(l => l.includes('boom')));
+        // Check for red ANSI code
+        assert.ok(logs.some(l => l.includes('\x1b[31m')));
+    });
+
+    it('respects logDetails flag (separator line)', async () => {
+        const inner = async () => ({ completed: true, value: 'ok' } as AgentCompletion<string>);
+        const wrapped = logCompletePrompt(inner, true);
+        await wrapped(makeArgs());
+        assert.ok(logs.some(l => l.includes('─')));
+    });
+
+    it('does not log separator when logDetails is false', async () => {
+        const inner = async () => ({ completed: true, value: 'ok' } as AgentCompletion<string>);
+        const wrapped = logCompletePrompt(inner, false);
+        await wrapped(makeArgs());
+        assert.ok(!logs.some(l => l.includes('─')));
+    });
+});

package/tests/migrations.spec.ts

@@ -0,0 +1,169 @@
+import assert from 'assert';
+import { postProcessV2, migratePage } from '../src/migrations';
+import { AgentCompletion, PromptCompletionArgs } from '../src/models/types';
+
+// ---------------------------------------------------------------------------
+// postProcessV2
+// ---------------------------------------------------------------------------
+
+describe('postProcessV2', () => {
+    const baseV2 = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Test</title>
+    <script src="/api/theme-info.js"></script>
+    <link rel="stylesheet" href="/api/theme.css">
+    <style>
+        .my-class { color: red; }
+    </style>
+</head>
+<body>
+    <div class="viewer-panel">Content</div>
+</body>
+</html>`;
+
+    it('injects theme-info.js when missing', () => {
+        const html = `<html><head><title>Test</title></head><body></body></html>`;
+        const result = postProcessV2(html);
+        assert.ok(result.includes('src="/api/theme-info.js"'));
+    });
+
+    it('does not duplicate theme-info.js when already present', () => {
+        const result = postProcessV2(baseV2);
+        const matches = result.match(/theme-info\.js/g);
+        assert.strictEqual(matches?.length, 1);
+    });
+
+    it('injects theme.css when missing', () => {
+        const html = `<html><head><title>Test</title></head><body></body></html>`;
+        const result = postProcessV2(html);
+        assert.ok(result.includes('href="/api/theme.css"'));
+    });
+
+    it('does not duplicate theme.css when already present', () => {
+        const result = postProcessV2(baseV2);
+        const matches = result.match(/theme\.css/g);
+        assert.strictEqual(matches?.length, 1);
+    });
+
+    it('strips shared CSS selectors from style blocks', () => {
+        const html = `<html><head><style>
+.chat-panel { background: black; }
+.viewer-panel { padding: 10px; }
+.my-custom { color: blue; }
+</style></head><body></body></html>`;
+        const result = postProcessV2(html);
+        assert.ok(!result.includes('.chat-panel {'));
+        assert.ok(!result.includes('.viewer-panel {'));
+        assert.ok(result.includes('.my-custom'));
+    });
+
+    it('removes empty style blocks after stripping', () => {
+        const html = `<html><head><style>
+.chat-panel { background: black; }
+</style></head><body></body></html>`;
+        const result = postProcessV2(html);
+        // The style block should be removed since it only had shared CSS
+        assert.ok(!result.includes('<style>'));
+    });
+
+    it('removes empty script blocks (no src)', () => {
+        const html = `<html><head></head><body><script>   </script></body></html>`;
+        const result = postProcessV2(html);
+        // Empty script should be removed
+        assert.ok(!result.includes('<script>   </script>'));
+    });
+
+    it('preserves script blocks with src attribute', () => {
+        const html = `<html><head><script src="/api/theme-info.js"></script></head><body></body></html>`;
+        const result = postProcessV2(html);
+        assert.ok(result.includes('src="/api/theme-info.js"'));
+    });
+
+    it('preserves page-specific CSS', () => {
+        const html = `<html><head><style>
+.chat-panel { background: black; }
+.game-canvas { width: 100%; height: 100%; }
+</style></head><body></body></html>`;
+        const result = postProcessV2(html);
+        assert.ok(result.includes('.game-canvas'));
+    });
+
+    // -- Additional postProcessV2 edge cases --------------------------------
+
+    it('restores chat panel with default when entirely missing (no original)', () => {
+        const html = `<html><head><title>Test</title></head><body><div class="viewer-panel">Content</div></body></html>`;
+        const result = postProcessV2(html);
+        assert.ok(result.includes('id="chatForm"'));
+        assert.ok(result.includes('class="chat-panel"'));
+        assert.ok(result.includes('id="chatInput"'));
+    });
+
+    it('restores chat form when panel exists but form missing', () => {
+        const html = `<html><head><title>Test</title></head><body>
+            <div class="chat-panel"><div class="chat-messages"></div></div>
+            <div class="viewer-panel">Content</div>
+        </body></html>`;
+        const result = postProcessV2(html);
+        assert.ok(result.includes('id="chatForm"'));
+    });
+
+    it('injects #thoughts div when missing', () => {
+        const html = `<html><head><title>Test</title></head><body>
+            <div class="chat-panel">
+                <form id="chatForm"><input id="chatInput"></form>
+            </div>
+        </body></html>`;
+        const result = postProcessV2(html);
+        assert.ok(result.includes('id="thoughts"'));
+    });
+
+    it('ensures #loadingOverlay inside .viewer-panel', () => {
+        const html = `<html><head><title>Test</title></head><body>
+            <div class="chat-panel"><form id="chatForm"><input id="chatInput"></form></div>
+            <div class="viewer-panel">Content</div>
+        </body></html>`;
+        const result = postProcessV2(html);
+        // loadingOverlay should be present inside viewer-panel
+        assert.ok(result.includes('id="loadingOverlay"'));
+        // Quick structural check: loadingOverlay appears after viewer-panel opens
+        const vpIdx = result.indexOf('class="viewer-panel"');
+        const olIdx = result.indexOf('id="loadingOverlay"');
+        assert.ok(vpIdx < olIdx);
+    });
+
+    it('moves #loadingOverlay inside .viewer-panel when it is outside', () => {
+        const html = `<html><head><title>Test</title></head><body>
+            <div class="chat-panel"><form id="chatForm"><input id="chatInput"></form></div>
+            <div id="loadingOverlay" class="loading-overlay"><div class="spinner"></div></div>
+            <div class="viewer-panel">Content</div>
+        </body></html>`;
+        const result = postProcessV2(html);
+        // loadingOverlay should now be inside viewer-panel
+        const vpIdx = result.indexOf('class="viewer-panel"');
+        const olIdx = result.indexOf('id="loadingOverlay"');
+        assert.ok(vpIdx < olIdx);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// migratePage
+// ---------------------------------------------------------------------------
+
+describe('migratePage', () => {
+    it('returns input unchanged when fromVersion === toVersion', async () => {
+        const html = '<html>unchanged</html>';
+        const stub = async () => ({ completed: true, value: '' } as AgentCompletion<string>);
+        const result = await migratePage(html, 2, 2, stub);
+        assert.strictEqual(result, html);
+    });
+
+    it('throws when no migration exists for version', async () => {
+        const stub = async () => ({ completed: true, value: '' } as AgentCompletion<string>);
+        await assert.rejects(
+            () => migratePage('<html></html>', 99, 100, stub),
+            /No migration defined for version 99/,
+        );
+    });
+});

package/tests/openai.spec.ts

@@ -0,0 +1,71 @@
+import assert from 'assert';
+import { buildOpenAIRequest } from '../src/models/openai';
+import { PromptCompletionArgs } from '../src/models/types';
+
+describe('buildOpenAIRequest', () => {
+    const baseArgs: PromptCompletionArgs = {
+        prompt: { role: 'user', content: 'Hello' },
+    };
+
+    it('builds input from history + prompt', () => {
+        const args: PromptCompletionArgs = {
+            ...baseArgs,
+            history: [
+                { role: 'user', content: 'Hi' },
+                { role: 'assistant', content: 'Hey' },
+            ],
+        };
+        const { input } = buildOpenAIRequest(args);
+        assert.strictEqual(input.length, 3);
+        assert.strictEqual(input[2].content, 'Hello');
+    });
+
+    it('appends "Return JSON." when jsonMode and no "json" in input', () => {
+        const args: PromptCompletionArgs = {
+            ...baseArgs,
+            jsonMode: true,
+        };
+        const { input } = buildOpenAIRequest(args);
+        const last = input[input.length - 1];
+        assert.ok(last.content.includes('Return JSON.'));
+    });
+
+    it('does not append "Return JSON." when input already contains "json"', () => {
+        const args: PromptCompletionArgs = {
+            prompt: { role: 'user', content: 'Return this as json please' },
+            jsonMode: true,
+        };
+        const { input } = buildOpenAIRequest(args);
+        const last = input[input.length - 1];
+        assert.ok(!last.content.includes('Return JSON.'));
+    });
+
+    it('returns json_schema text config when jsonSchema provided', () => {
+        const schema = { type: 'object', properties: { x: { type: 'number' } } };
+        const args: PromptCompletionArgs = {
+            ...baseArgs,
+            jsonSchema: schema,
+        };
+        const { text } = buildOpenAIRequest(args);
+        assert.ok(text);
+        assert.strictEqual(text.format.type, 'json_schema');
+        assert.strictEqual(text.format.name, 'response');
+        assert.strictEqual(text.format.strict, true);
+        assert.deepStrictEqual(text.format.schema, schema);
+    });
+
+    it('returns json_object text config when jsonMode (no schema)', () => {
+        const args: PromptCompletionArgs = {
+            ...baseArgs,
+            jsonMode: true,
+        };
+        const { text } = buildOpenAIRequest(args);
+        assert.ok(text);
+        assert.strictEqual(text.format.type, 'json_object');
+    });
+
+    it('returns no text config for plain text', () => {
+        const { text } = buildOpenAIRequest(baseArgs);
+        assert.strictEqual(text, undefined);
+    });
+});