@realtimex/realtimex-alchemy 1.0.41 → 1.0.42

package/dist/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.42] - 2026-01-26
+
+### Added
+- **Transmute Engine**: Implemented the Transmute Engine with a new service, UI components, and database schema, enabling users to transform mined content into actionable formats.
+- **Discovery**: Filtered signals are now displayed directly in the DiscoveryTab upon category selection for faster access.
+- **Discovery**: Added aggregated signal category counts to the CategoryGrid for better high-level visibility.
+- **Content Intelligence**: Ported `ContentCleaner` to the main codebase and added support for handling gated web content, improving LLM processing reliability.
+
+### Improved
+- **Architecture**: Moved shared types to `src/lib/types.ts` for better code organization.
+- **SDK**: Updated `sdk.system.get_app_data_dir` calls to the standardized `sdk.getAppDataDir`.
+
 ## [1.0.41] - 2026-01-24
 
 ### Added

package/dist/api/index.js

@@ -7,6 +7,7 @@ import { AlchemistService } from './services/AlchemistService.js';
 import { LibrarianService } from './services/LibrarianService.js';
 import { CONFIG } from './config/index.js';
 import { EventService } from './services/EventService.js';
+import { transmuteService } from './services/TransmuteService.js';
 import { SupabaseService } from './services/SupabaseService.js';
 import { BrowserPathDetector } from './utils/BrowserPathDetector.js';
 import { ProcessingEventService } from './services/ProcessingEventService.js';
@@ -418,6 +419,45 @@ const staticPath = process.env.ELECTRON_STATIC_PATH || path.join(__dirname, '..'
 if (fs.existsSync(staticPath)) {
     console.log(`[Alchemy] Serving UI from ${staticPath}`);
     app.use(express.static(staticPath));
+    // Transmute Engine Routes
+    app.post('/api/engines/:id/run', async (req, res) => {
+        try {
+            const userId = req.headers['x-user-id'];
+            const engineId = req.params.id;
+            if (!userId) {
+                return res.status(401).json({ error: 'Unauthorized: Missing User ID' });
+            }
+            console.log(`[API] Running Engine ${engineId} for user ${userId}`);
+            // Get valid Supabase client
+            const supabase = getAuthenticatedSupabase(req);
+            // Execute Pipeline
+            const asset = await transmuteService.runEngine(engineId, userId, supabase);
+            res.json(asset);
+        }
+        catch (error) {
+            console.error('[API] Engine run failed:', error);
+            res.status(500).json({ error: error.message || 'Engine run failed' });
+        }
+    });
+    app.get('/api/engines/:id/brief', async (req, res) => {
+        try {
+            const userId = req.headers['x-user-id'];
+            const engineId = req.params.id;
+            if (!userId) {
+                return res.status(401).json({ error: 'Unauthorized: Missing User ID' });
+            }
+            console.log(`[API] Fetching Engine Brief ${engineId} for user ${userId}`);
+            // Get valid Supabase client
+            const supabase = getAuthenticatedSupabase(req);
+            // Generate Brief
+            const brief = await transmuteService.getProductionBrief(engineId, userId, supabase);
+            res.json(brief);
+        }
+        catch (error) {
+            console.error('[API] Engine brief fetch failed:', error);
+            res.status(500).json({ error: error.message || 'Engine brief fetch failed' });
+        }
+    });
     // Client-side routing fallback (Bypass path-to-regexp error in Express 5)
     app.use((req, res, next) => {
         if (!req.path.startsWith('/api') && !req.path.startsWith('/events')) {

package/dist/api/lib/types.js

@@ -1 +1 @@
-export {};
+export * from '../../shared/types.js';

package/dist/api/services/AlchemistService.js

@@ -3,6 +3,7 @@ import { RouterService } from './RouterService.js';
 import { embeddingService } from './EmbeddingService.js';
 import { deduplicationService } from './DeduplicationService.js';
 import { SDKService } from './SDKService.js';
+import { ContentCleaner } from '../utils/contentCleaner.js';
 export class AlchemistService {
     processingEvents;
     router;
@@ -103,12 +104,27 @@ export class AlchemistService {
             try {
                 // 2. Extract Content via RouterService (Tier 1 → Tier 2 fallback)
                 let content = '';
+                let finalUrl = entry.url; // Default to entry URL
+                let isGatedContent = false;
                 try {
-                    const markdown = await this.router.extractContent(entry.url);
-                    if (markdown && markdown.length > 100) {
-                        // Truncate to avoid token limits (keep ~8000 chars)
-                        const truncated = markdown.length > 8000 ? markdown.substring(0, 8000) + '...' : markdown;
-                        content = `Page Title: ${entry.title}\nContent: ${truncated}`;
+                    const result = await this.router.extractContent(entry.url);
+                    let rawContent = result.content;
+                    finalUrl = result.finalUrl;
+                    if (rawContent && rawContent.length > 20) {
+                        // HIGHLIGHT: Payload Hygiene - Clean Markdown content after conversion
+                        // This strips JS/CSS patterns that survived Turndown
+                        const cleaned = ContentCleaner.cleanContent(rawContent);
+                        // Check if this is a login wall or paywall
+                        isGatedContent = ContentCleaner.isGatedContent(cleaned);
+                        if (isGatedContent) {
+                            console.log(`[AlchemistService] Gated content detected: ${entry.url}`);
+                            content = `Page Title: ${entry.title} (Login/paywall required - content not accessible)`;
+                        }
+                        else {
+                            // Truncate to avoid token limits (keep ~8000 chars)
+                            const truncated = cleaned.length > 10000 ? cleaned.substring(0, 10000) + '...' : cleaned;
+                            content = `Page Title: ${entry.title}\nContent: ${truncated}`;
+                        }
                     }
                     else {
                         content = `Page Title: ${entry.title} (Content unavailable or too short)`;
@@ -128,7 +144,7 @@ export class AlchemistService {
                     userId
                 }, supabase);
                 // 3. LLM Analysis
-                const response = await this.analyzeContent(content, entry.url, settings, learningContext);
+                const response = await this.analyzeContent(content, finalUrl, settings, learningContext);
                 const duration = Date.now() - startAnalysis;
                 // 4. Save Signal (ALWAYS save for Active Learning - Low scores = candidates for boost)
                 console.log(`[AlchemistService] Saving signal (${response.score}%)...`);
@@ -136,17 +152,21 @@ export class AlchemistService {
                     .from('signals')
                     .insert([{
                         user_id: userId,
-                        url: entry.url,
+                        url: finalUrl,
                         title: entry.title,
-                        score: response.score,
-                        summary: response.summary,
+                        score: isGatedContent ? Math.min(response.score, 20) : response.score, // Cap gated content at 20
+                        summary: isGatedContent ? 'Login or subscription required to access this content.' : response.summary,
                         category: response.category,
                         entities: response.entities,
                         tags: response.tags,
                         content: content,
-                        // Mark as dismissed if low score so it doesn't clutter main feed, 
-                        // but is available in "Low" filter
-                        is_dismissed: response.score < 50
+                        // Mark as dismissed if low score OR gated content
+                        is_dismissed: response.score < 50 || isGatedContent,
+                        metadata: {
+                            original_source_url: entry.url,
+                            resolved_at: new Date().toISOString(),
+                            is_gated: isGatedContent
+                        }
                     }])
                     .select()
                     .single();
@@ -170,7 +190,7 @@ export class AlchemistService {
                         stats.signals++;
                         // 5. Generate Embedding & Check for Duplicates (non-blocking)
                         if (settings.embedding_model && await embeddingService.isAvailable()) {
-                            this.processEmbedding(insertedSignal, settings, userId, supabase).catch((err) => {
+                            await this.processEmbedding(insertedSignal, settings, userId, supabase).catch((err) => {
                                 console.error('[AlchemistService] Embedding processing failed:', err);
                             });
                         }
@@ -178,7 +198,7 @@ export class AlchemistService {
                     else {
                         // Low Score: Emit Skipped (but it IS saved in DB now)
                         // Trigger metadata-based deduplication (no embedding) to merge tracking links/redirects
-                        this.processDeduplicationOnly(insertedSignal, settings, userId, supabase).catch((err) => {
+                        await this.processDeduplicationOnly(insertedSignal, settings, userId, supabase).catch((err) => {
                             console.error('[AlchemistService] Deduplication check failed:', err);
                         });
                         await this.processingEvents.log({
@@ -240,25 +260,44 @@ export class AlchemistService {
         const prompt = `
         Act as "The Alchemist", a high-level intelligence analyst.
         Analyze the following article value based on the content and the User's Interests.
-        
+
         ${learningContext}
-        
+
         Input:
         URL: ${url}
         Content: ${content}
-        
-        CRITICAL SCORING: 
-        High Score (80-100): Original research, concrete data points, contrarian insights, deep technical details, official documentation. MATCHES USER INTERESTS/BOOSTED TOPICS.
-        Medium Score (50-79): Significant Industry News (Mergers, IPOs, Major Releases), Decent summaries, useful aggregate news, tutorials, reference material.
-        Low Score (0-49): Marketing fluff, SEO clickbait, generic listicles, navigation menus only, login pages, site footers, OR MATCHES USER DISLIKES (Dismissed topics).
-        
+
+        CRITICAL RULES:
+
+        1. REJECT JUNK PAGES (Score = 0):
+           - Login pages, authentication walls, "sign in to continue"
+           - Navigation menus, site footers, cookie notices
+           - "Page not found", error pages, access denied
+           - App store pages, download prompts
+           - Empty or placeholder content
+           For these, return: score=0, category="Other", summary="[Login wall/Navigation page/etc]", tags=[], entities=[]
+
+        2. SCORING GUIDE:
+           - High (80-100): Original research, data, insights, technical depth. MATCHES USER INTERESTS.
+           - Medium (50-79): Industry news, tutorials, useful summaries.
+           - Low (1-49): Marketing fluff, clickbait, thin content, MATCHES USER DISLIKES.
+           - Zero (0): Junk pages per rule #1 above.
+
+        3. CATEGORY - MUST be exactly one of these 8 values:
+           "AI & ML", "Business", "Politics", "Technology", "Finance", "Crypto", "Science", "Other"
+           NEVER create custom categories. If unsure, use "Other".
+
+        4. TAGS - Only include meaningful topic tags like:
+           "machine learning", "startups", "regulations", "cybersecurity", "investing"
+           NEVER include: "login", "navigation", "authentication", "menu", "footer", "social media", "facebook", "meta"
+
         Return STRICT JSON:
         {
             "score": number (0-100),
-            "category": string (one of: AI & ML, Business, Politics, Technology, Finance, Crypto, Science, Other),
-            "summary": string (1-sentence concise gist),
-            "entities": string[],
-            "tags": string[] (3-5 relevant topic tags for categorization),
+            "category": string (MUST be one of the 8 categories above),
+            "summary": string (1-sentence concise gist, or "[Junk page]" if score=0),
+            "entities": string[] (people, companies, products mentioned),
+            "tags": string[] (3-5 TOPIC tags only, no platform/UI terms),
             "relevant": boolean (true if score > 50)
         }
         `;

package/dist/api/services/DeduplicationService.js

@@ -30,11 +30,13 @@ export class DeduplicationService {
             // 2. Title Match Check (Metadata Heuristic)
             // Useful for redirected URLs or tracking links where content is same but URL differs
             if (signal.title && signal.title.length > 10) {
+                // Normalize title by trimming and collapsing whitespace
+                const normalizedTitle = signal.title.trim().replace(/\s+/g, ' ');
                 const { data: titleMatch } = await supabase
                     .from('signals')
                     .select('id, score, title')
                     .eq('user_id', userId)
-                    .ilike('title', signal.title.trim()) // Case-insensitive match
+                    .ilike('title', normalizedTitle) // Case-insensitive match
                     .neq('id', signal.id || '00000000-0000-0000-0000-000000000000') // Don't match self
                     .order('created_at', { ascending: false })
                     .limit(1)
@@ -88,19 +90,34 @@ export class DeduplicationService {
         }
         // Calculate boosted score
         const mentionCount = (existing.mention_count || 1) + 1;
-        const scoreBoost = Math.min(mentionCount * 0.1, 0.5); // Max 50% boost
-        const newScore = Math.min(existing.score + scoreBoost, 10); // Cap at 10
+        // SIGNIFICANT FIX: Scale boost for 0-100 scale (was capped at 10)
+        const scoreBoost = Math.min(mentionCount * 2, 20);
+        const newScore = Math.min(Math.max(existing.score, newSignal.score) + scoreBoost, 100);
         // Combine summaries using LLM
         const combinedSummary = await this.combineSummaries(existing.summary, newSignal.summary, settings);
+        // Merge Entities and Tags (NEW: Prevent data loss)
+        const combinedEntities = [...new Set([...(existing.entities || []), ...(newSignal.entities || [])])];
+        const combinedTags = [...new Set([...(existing.tags || []), ...(newSignal.tags || [])])];
         // Track source URLs in metadata
         const existingUrls = existing.metadata?.source_urls || [existing.url];
         const sourceUrls = [...new Set([...existingUrls, newSignal.url])]; // Deduplicate URLs
+        // URL Promotion: If new signal has a 'better' URL (longer and doesn't look masked), promote it
+        let promotedUrl = existing.url;
+        const isExistingMasked = existing.url.includes('t.co') || existing.url.length < 25;
+        const isNewBetter = !newSignal.url.includes('t.co') && newSignal.url.length > 25;
+        if (isExistingMasked && isNewBetter) {
+            console.log(`[Deduplication] Promoting new direct URL: ${newSignal.url} over masked: ${existing.url}`);
+            promotedUrl = newSignal.url;
+        }
         // Update existing signal
         const { error: updateError } = await supabase
             .from('signals')
             .update({
+            url: promotedUrl,
             score: newScore,
             summary: combinedSummary,
+            entities: combinedEntities, // Merge entities
+            tags: combinedTags, // Merge tags
             mention_count: mentionCount,
             metadata: {
                 ...existing.metadata,

package/dist/api/services/MinerService.js

@@ -232,7 +232,8 @@ export class MinerService {
                 visit_count: row.visit_count || 1,
                 // Normalize back to Unix Ms for internal storage/usage
                 last_visit_time: this.toUnixMs(row.last_visit_time, source.browser),
-                browser: source.browser
+                browser: source.browser,
+                source: source.label || 'browser_history'
             }));
             // Log filtering stats
             if (skippedDuplicates > 0 || skippedNonContent > 0 || skippedBlacklist > 0) {

package/dist/api/services/RouterService.js

@@ -2,19 +2,36 @@ import axios from 'axios';
 import puppeteer from 'puppeteer';
 import TurndownService from 'turndown';
 import { EventService } from './EventService.js';
+import { ContentCleaner } from '../utils/contentCleaner.js';
 export class RouterService {
     turndown = new TurndownService();
     events = EventService.getInstance();
     async extractContent(url) {
         this.events.emit({ type: 'router', message: `Attempting Tier 1 Extraction (Axios): ${url.substring(0, 30)}...` });
+        let finalUrl = url;
         try {
             // Tier 1: Fast Fetch
             const response = await axios.get(url, { timeout: 5000 });
-            const html = response.data;
-            const markdown = this.turndown.turndown(html);
+            // Capture final URL after redirects
+            if (response.request?.res?.responseUrl) {
+                finalUrl = response.request.res.responseUrl;
+            }
+            else if (response.request?._redirectable?._currentUrl) {
+                // Robust fallback for axios/node environment
+                finalUrl = response.request._redirectable._currentUrl;
+            }
+            else if (response.config?.url && !response.config.url.includes('t.co')) {
+                // Heuristic: If axios didn't capture responseUrl but config.url is different from input
+                // and it's not the same shortener, it might be the final one.
+                // But usually responseUrl is the reliable one.
+            }
+            const rawHtml = response.data;
+            // Payload Hygiene: Sanitize HTML before Markdown conversion
+            const sanitizedHtml = ContentCleaner.sanitizeHtml(rawHtml);
+            const markdown = this.turndown.turndown(sanitizedHtml);
             if (markdown.length > 500) {
-                this.events.emit({ type: 'router', message: `Tier 1 Success (${markdown.length} chars)` });
-                return markdown;
+                this.events.emit({ type: 'router', message: `Tier 1 Success (${markdown.length} chars) -> ${finalUrl.substring(0, 30)}...` });
+                return { content: markdown, finalUrl };
             }
         }
         catch (e) {
@@ -25,12 +42,16 @@ export class RouterService {
         try {
             const browser = await puppeteer.launch({ headless: true });
             const page = await browser.newPage();
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
+            await page.setViewport({ width: 1280, height: 800 });
+            const response = await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
+            // Capture final URL from page object
+            finalUrl = page.url();
             const content = await page.content();
+            const sanitizedHtml = ContentCleaner.sanitizeHtml(content);
             await browser.close();
-            const markdown = this.turndown.turndown(content);
-            this.events.emit({ type: 'router', message: `Tier 2 Success (${markdown.length} chars)` });
-            return markdown;
+            const markdown = this.turndown.turndown(sanitizedHtml);
+            this.events.emit({ type: 'router', message: `Tier 2 Success (${markdown.length} chars) -> ${finalUrl.substring(0, 30)}...` });
+            return { content: markdown, finalUrl };
         }
         catch (e) {
             this.events.emit({ type: 'router', message: `Tier 2 Failed: ${e.message}` });

package/dist/api/services/SDKService.js

@@ -1,4 +1,6 @@
 import { RealtimeXSDK } from '@realtimex/sdk';
+import os from 'os';
+import path from 'path';
 /**
  * Centralized SDK Service
  * Manages RealTimeX SDK initialization and provides singleton access
@@ -121,4 +123,37 @@ export class SDKService {
             clearTimeout(timeoutHandle);
         }
     }
+    /**
+     * Trigger a Desktop Agent via Webhook
+     * Use this to delegate tasks to the RealTimeX Desktop app
+     */
+    static async triggerAgent(event, payload) {
+        const sdk = this.getSDK();
+        if (!sdk) {
+            throw new Error('RealTimeX SDK not linked. Cannot trigger desktop agent.');
+        }
+        console.log(`[SDKService] Triggering Agent Event: ${event}`);
+        // Use the existing webhook trigger capability
+        // @ts-ignore - internal SDK method
+        await sdk.webhook.trigger(event, payload);
+    }
+    /**
+     * Get the App Data Directory from the SDK
+     * Used for constructing absolute system paths for the "Drop Zone"
+     */
+    static async getAppDataDir() {
+        const sdk = this.getSDK();
+        if (!sdk) {
+            throw new Error('RealTimeX SDK not linked. Cannot get app data dir.');
+        }
+        try {
+            // @ts-ignore - SDK method for getting app data directory
+            return await sdk.getAppDataDir();
+        }
+        catch (error) {
+            console.warn('[SDKService] getAppDataDir failed, using fallback path');
+            // Cross-platform fallback: ~/RealTimeX/Alchemy/data
+            return path.join(os.homedir(), 'RealTimeX', 'Alchemy', 'data');
+        }
+    }
 }

package/dist/api/services/TransmuteService.js

@@ -0,0 +1,250 @@
+import path from 'path';
+import os from 'os';
+import { SDKService } from './SDKService.js';
+import { ContentCleaner } from '../utils/contentCleaner.js';
+export class TransmuteService {
+    /**
+     * Run a specific engine pipeline
+     */
+    async runEngine(engineId, userId, supabase) {
+        console.log(`[Transmute] Running engine ${engineId}...`);
+        // 1. Fetch Engine Config
+        const { data: engine, error } = await supabase
+            .from('engines')
+            .select('*')
+            .eq('id', engineId)
+            .single();
+        if (error || !engine) {
+            throw new Error(`Engine not found: ${error?.message}`);
+        }
+        // 2. Fetch Context (Signals)
+        const signals = await this.fetchContextSignals(userId, engine.config, supabase);
+        if (signals.length === 0) {
+            console.warn('[Transmute] No signals found for context');
+        }
+        // Branch logic: Local vs Desktop
+        const executionMode = engine.config.execution_mode || 'local';
+        if (executionMode === 'desktop') {
+            // DELEGATION FLOW
+            console.log('[Transmute] Delegating to Desktop Agent...');
+            // 3a. Create Pending Asset
+            const assetStub = await this.saveAsset(engine, null, signals, userId, supabase, 'pending');
+            // 3b. Construct Stateless Brief (Optimized)
+            const brief = await this.generateProductionBrief(engine, signals, userId, assetStub.id, supabase);
+            // 3c. Trigger Agent
+            try {
+                await SDKService.triggerAgent('alchemy.create_asset', brief);
+                // 3d. Update status to processing
+                await supabase
+                    .from('assets')
+                    .update({ status: 'processing' })
+                    .eq('id', assetStub.id);
+                return { ...assetStub, status: 'processing' };
+            }
+            catch (error) {
+                console.error('[Transmute] Failed to trigger desktop agent:', error);
+                await supabase
+                    .from('assets')
+                    .update({ status: 'failed', error_message: error.message })
+                    .eq('id', assetStub.id);
+                throw error;
+            }
+        }
+        else {
+            // LOCAL LLM FLOW (Legacy)
+            // 3. Generate Content (LLM)
+            const content = await this.generateAssetContent(engine, signals);
+            // 4. Save Asset
+            const asset = await this.saveAsset(engine, content, signals, userId, supabase, 'completed');
+            // 5. Update Engine Status
+            await supabase
+                .from('engines')
+                .update({ last_run_at: new Date().toISOString() })
+                .eq('id', engineId);
+            console.log(`[Transmute] Engine run complete. Asset created: ${asset.id}`);
+            return asset;
+        }
+    }
+    /**
+     * Get the production brief for inspection (doesn't trigger run)
+     */
+    async getProductionBrief(engineId, userId, supabase) {
+        // 1. Fetch Engine Config
+        const { data: engine, error } = await supabase
+            .from('engines')
+            .select('*')
+            .eq('id', engineId)
+            .single();
+        if (error || !engine) {
+            throw new Error(`Engine not found: ${error?.message}`);
+        }
+        // 2. Fetch Context (Signals)
+        const signals = await this.fetchContextSignals(userId, engine.config, supabase);
+        // 3. Generate Stateless Brief
+        return this.generateProductionBrief(engine, signals, userId, 'preview-mode', supabase);
+    }
+    /**
+     * Generate a stateless production brief for the Desktop Studio
+     * Optimized for token efficiency and high quality directives
+     */
+    async generateProductionBrief(engine, signals, userId, assetId, supabase) {
+        // 1. Fetch User Persona (for personalization)
+        const { data: persona } = await supabase
+            .from('user_personas')
+            .select('interest_summary, anti_patterns')
+            .eq('user_id', userId)
+            .maybeSingle();
+        // 2. Fetch App Data Dir for absolute path (Drop Zone)
+        // Cross-platform fallback: ~/RealTimeX/Alchemy/data
+        let appDataDir = path.join(os.homedir(), 'RealTimeX', 'Alchemy', 'data');
+        try {
+            appDataDir = await SDKService.getAppDataDir();
+        }
+        catch (e) {
+            console.warn('[Transmute] Could not fetch app data dir from SDK, using fallback');
+        }
+        // 3. Map Signals to brief format with CLEANED content and DIRECT urls
+        const signalsBrief = signals.map(s => {
+            // Aggregated all known URLs for this signal
+            const sourceUrls = s.metadata?.source_urls || [s.url];
+            const uniqueUrls = [...new Set([s.url, ...sourceUrls])];
+            // Pick the "best" URL: Prioritize long URLs and avoid shortened ones
+            // Filter out 't.co' and pick longest as heuristic for final article
+            const unmaskedUrls = uniqueUrls.filter(u => !u.includes('t.co') && !u.includes('bit.ly'));
+            const bestUrl = unmaskedUrls.length > 0
+                ? unmaskedUrls.reduce((a, b) => a.length > b.length ? a : b)
+                : s.url;
+            return {
+                title: s.title,
+                summary: s.summary,
+                url: bestUrl, // Best Available (Resolved) URL
+                source_urls: uniqueUrls, // All associated direct URLs
+                // Use ContentCleaner to strip JS/CSS noise
+                content: s.content ? ContentCleaner.cleanContent(s.content) : undefined
+            };
+        });
+        // 4. Construct high-fidelity System Prompt
+        let systemPrompt = "You are a specialized AI content creator.";
+        if (engine.type === 'newsletter') {
+            systemPrompt = "You are a senior tech editor. Write a newsletter summarizing the provided context. Use a professional, insight-driven tone. Structure with 'The Big Story' followed by 'Quick Hits'.";
+        }
+        else if (engine.type === 'thread') {
+            systemPrompt = "You are a viral storyteller. Create an engaging X/Twitter thread based on the top signal provided. Use hook-driven writing and informative formatting.";
+        }
+        else if (engine.type === 'audio') {
+            systemPrompt = "You are a podcast scriptwriter. Create a natural, conversational script based on the signals provided. The goal is a 5-minute daily update for a busy professional.";
+        }
+        const filename = `transmute_${engine.type}_${assetId}.md`;
+        const systemPath = path.join(appDataDir, 'assets', filename);
+        // 5. Construct the self-contained JSON
+        return {
+            agent_name: `alchemy-${engine.type}`,
+            auto_run: true,
+            raw_data: {
+                job_id: assetId,
+                context: {
+                    title: `${engine.title} - ${new Date().toLocaleDateString()}`,
+                    signals: signalsBrief,
+                    user_persona: persona ? {
+                        interest_summary: persona.interest_summary,
+                        anti_patterns: persona.anti_patterns
+                    } : undefined
+                },
+                directives: {
+                    prompt: engine.config.custom_prompt || "Create a high-quality asset based on the provided context.",
+                    system_prompt: systemPrompt,
+                    ...engine.config,
+                    engine_type: engine.type,
+                    execution_mode: 'desktop'
+                },
+                output_config: {
+                    target_asset_id: assetId,
+                    filename: filename,
+                    system_path: systemPath
+                }
+            }
+        };
+    }
+    /**
+     * Fetch relevant signals based on engine configuration
+     */
+    async fetchContextSignals(userId, config, supabase) {
+        let query = supabase
+            .from('signals')
+            .select('*')
+            .eq('user_id', userId)
+            .order('score', { ascending: false })
+            .limit(10);
+        if (config.category && config.category !== 'All') {
+            query = query.eq('category', config.category);
+        }
+        const { data } = await query;
+        return (data || []);
+    }
+    /**
+     * Generate the asset content using LLM
+     */
+    async generateAssetContent(engine, signals) {
+        // Construct Context String
+        const contextStr = signals.map(s => `- [${s.score}] ${s.title}\n  Summary: ${s.summary}\n  URL: ${s.url}`).join('\n\n');
+        // Select System Prompt based on Engine Type
+        let systemPrompt = "You are an expert editor.";
+        let userPrompt = "";
+        if (engine.config.custom_prompt) {
+            systemPrompt = engine.config.custom_prompt;
+            userPrompt = `Context:\n${contextStr}`;
+        }
+        else if (engine.type === 'newsletter') {
+            systemPrompt = "You are a curator writing a daily newsletter. Tone: Professional but engaging.";
+            userPrompt = `Write a newsletter based on these top stories:\n\n${contextStr}\n\nFormat:\n# Title\n\n## Deep Dive (Top Story)\n...\n\n## Quick Hits\n...`;
+        }
+        else if (engine.type === 'thread') {
+            systemPrompt = "You are a social media growth expert. Write viral threads.";
+            userPrompt = `Create a Twitter/X thread based on this top signal:\n${contextStr}\n\nFormat: 1 tweet per block.`;
+        }
+        else {
+            userPrompt = `Synthesize these signals into a report:\n\n${contextStr}`;
+        }
+        // Call LLM via SDK
+        const sdk = SDKService.getSDK();
+        if (!sdk) {
+            throw new Error('RealTimeX SDK not available. Please ensure the desktop app is running.');
+        }
+        // Use engine config for model/provider if available, else defaults
+        const provider = engine.config.llm_provider || 'realtimexai';
+        const model = engine.config.llm_model || 'gpt-4o-mini';
+        const response = await sdk.llm.chat([
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: userPrompt }
+        ], {
+            provider,
+            model
+        });
+        return response.response?.content || "Failed to generate content.";
+    }
+    /**
+     * Save the generated asset to DB
+     */
+    async saveAsset(engine, content, sourceSignals, userId, supabase, status = 'completed') {
+        const { data, error } = await supabase
+            .from('assets')
+            .insert({
+            user_id: userId,
+            engine_id: engine.id,
+            title: `${engine.title} - ${new Date().toLocaleDateString()}`,
+            type: 'markdown', // Default to markdown for now
+            content: content,
+            status: status,
+            metadata: {
+                source_signal_count: sourceSignals.length,
+                source_signals: sourceSignals.map(s => s.id)
+            }
+        })
+            .select()
+            .single();
+        if (error)
+            throw error;
+        return data;
+    }
+}
+export const transmuteService = new TransmuteService();