Update app.js

app.js

@@ -4,6 +4,465 @@ import fs from 'fs';
 import path from 'path';
 import { createClient } from '@supabase/supabase-js';
 
+// ==========================================
+// 1. CONFIGURATION & SETUP
+// ==========================================
+const PORT = 7860;
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_SERVICE_KEY;
+const REMOTE_SERVER_URL = process.env.REMOTE_AI_URL || "http://localhost:11434"; 
+const FRONT_URL = process.env.FRONT_URL;
+const CRON_REGISTRY_URL = process.env.CRON_REGISTRY_URL || "http://localhost:7861"; 
+const CRON_SECRET = process.env.CRON_SECRET || "default_secret";
+
+// --- MODEL CONFIGURATION ---
+const SMART_MODEL_ID = "claude"; 
+const FAST_MODEL_ID = "gpt-5-mini"; 
+
+if (!SUPABASE_URL || !SUPABASE_KEY) {
+    console.error("FATAL: Missing Supabase URL or Service Key.");
+    process.exit(1);
+}
+
+const app = express();
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+app.use(express.json({ limit: '50mb' }));
+app.use(cors());
+
+// ==========================================
+// 2. PROMPT MANAGEMENT
+// ==========================================
+let prompts = {}; 
+try {
+    const promptsPath = path.resolve('./prompts.json');
+    if (fs.existsSync(promptsPath)) {
+        prompts = JSON.parse(fs.readFileSync(promptsPath, 'utf8'));
+        console.log("✅ Prompts loaded.");
+    } else {
+        throw new Error("prompts.json not found");
+    }
+} catch (e) {
+    console.error("❌ Prompt Load Error:", e.message);
+    process.exit(1);
+}
+
+// ==========================================
+// 3. STATE MANAGER
+// ==========================================
+const activeProjects = new Map();
+
+const StateManager = {
+    getHistory: async (projectId) => {
+        if (activeProjects.has(projectId)) {
+            const cached = activeProjects.get(projectId);
+            cached.lastActive = Date.now();
+            return cached.history;
+        }
+
+        const { data: chunks, error } = await supabase
+            .from('message_chunks')
+            .select('*')
+            .eq('project_id', projectId)
+            .order('chunk_index', { ascending: false })
+            .limit(10);
+
+        if (error) return [];
+        const fullHistory = (chunks || []).reverse().flatMap(c => c.payload || []);
+        
+        activeProjects.set(projectId, { history: fullHistory, lastActive: Date.now(), isFrozen: false });
+        return fullHistory;
+    },
+
+    addHistory: async (projectId, role, text) => {
+        const newMessage = { role, parts: [{ text }] };
+
+        if (activeProjects.has(projectId)) {
+            const project = activeProjects.get(projectId);
+            project.history.push(newMessage);
+            project.lastActive = Date.now();
+            if (role === 'user') project.isFrozen = false; 
+        }
+
+        try {
+            const { data: latestChunk } = await supabase
+                .from('message_chunks')
+                .select('id, chunk_index, payload')
+                .eq('project_id', projectId)
+                .order('chunk_index', { ascending: false })
+                .limit(1)
+                .single();
+
+            const currentPayload = (latestChunk?.payload) || [];
+
+            if (latestChunk && currentPayload.length < 20) {
+                await supabase.from('message_chunks').update({ 
+                    payload: [...currentPayload, newMessage] 
+                }).eq('id', latestChunk.id);
+            } else {
+                await supabase.from('message_chunks').insert({
+                    project_id: projectId,
+                    lead_id: projectId,
+                    chunk_index: (latestChunk?.chunk_index ?? -1) + 1,
+                    payload: [newMessage]
+                });
+            }
+
+            if (role === 'user') await supabase.from('leads').update({ is_frozen: false }).eq('id', projectId);
+        } catch (e) { console.error("History Sync Error", e); }
+    },
+    
+    isFrozen: async (projectId) => {
+        if (activeProjects.has(projectId)) return activeProjects.get(projectId).isFrozen;
+        const { data } = await supabase.from('leads').select('is_frozen').eq('id', projectId).single();
+        return data?.is_frozen || false;
+    },
+
+    setFrozen: async (projectId, status) => {
+        if (activeProjects.has(projectId)) activeProjects.get(projectId).isFrozen = status;
+        await supabase.from('leads').update({ is_frozen: status }).eq('id', projectId);
+    }
+};
+
+// ==========================================
+// 4. AI ENGINE
+// ==========================================
+const callAI = async (history, input, contextData, systemPrompt, projectContext, modelId) => {
+    let contextStr = "";
+    try { contextStr = JSON.stringify(contextData, null, 2); } catch {}
+
+    const recentHistory = history.slice(-10).map(m => 
+        `${m.role === 'model' ? 'Assistant' : 'User'}: ${m.parts?.[0]?.text || ""}`
+    ).join('\n');
+
+    const fullPrompt = `System: ${systemPrompt}\n\n${projectContext}\n\n[HISTORY]:\n${recentHistory}\n\n[CONTEXT]: ${contextStr}\n\nUser: ${input}\nAssistant:`;
+
+    try {
+        const response = await fetch(`${REMOTE_SERVER_URL}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ model: modelId, prompt: fullPrompt, system_prompt: systemPrompt })
+        });
+
+        if (!response.ok) throw new Error("AI API Error");
+        const result = await response.json();
+        return { text: result.data || result.text || "", usage: result.usage };
+    } catch (e) {
+        return { text: "<notification>AI Unreachable</notification>", usage: {} };
+    }
+};
+
+// ==========================================
+// 5. COMMAND & CRON LOGIC
+// ==========================================
+function extractCommands(text) {
+    const commands = [];
+    const parse = (regex, type, isJson = true) => {
+        let match;
+        regex.lastIndex = 0;
+        // Added 'gi' flags for case-insensitive and global multiline matching
+        while ((match = regex.exec(text)) !== null) {
+            let rawPayload = match[1].trim();
+            try {
+                if (isJson) {
+                    commands.push({ type, payload: JSON.parse(rawPayload) });
+                } else {
+                    commands.push({ type, payload: rawPayload });
+                }
+            } catch (e) { 
+                console.error(`⚠️ Parse Error (${type}):`, e.message);
+                
+                // BULLETPROOF FALLBACK: If AI spits raw markdown instead of JSON, rescue it.
+                if (type === 'create_thrust') {
+                    console.log(`[FALLBACK] Rescuing invalid JSON as raw markdown...`);
+                    commands.push({ 
+                        type, 
+                        payload: { 
+                            title: "System Thrust", 
+                            markdown_content: rawPayload, 
+                            tasks: [] 
+                        } 
+                    });
+                }
+            }
+        }
+    };
+
+    parse(/<thrust_create>([\s\S]*?)<\/thrust_create>/gi, 'create_thrust');
+    parse(/<timeline_log>([\s\S]*?)<\/timeline_log>/gi, 'log_timeline');
+    parse(/<notification>([\s\S]*?)<\/notification>/gi, 'notification', false);
+    parse(/<update_requirements>([\s\S]*?)<\/update_requirements>/gi, 'update_requirements', false);
+    parse(/<schedule_briefing>([\s\S]*?)<\/schedule_briefing>/gi, 'schedule_briefing');
+    parse(/<freeze_project>([\s\S]*?)<\/freeze_project>/gi, 'freeze_project', false); 
+    parse(/<thrust_complete>([\s\S]*?)<\/thrust_complete>/gi, 'thrust_complete', false); 
+
+    return commands;
+}
+
+async function registerMorningCron(projectId, offset) {
+    const now = new Date();
+    const target = new Date(now);
+    const targetUtcHour = 6 - offset; 
+
+    target.setUTCHours(targetUtcHour, 0, 0, 0); 
+    if (target <= now) target.setDate(target.getDate() + 1); 
+
+    const delayMs = target.getTime() - now.getTime();
+    const intervalMs = 24 * 60 * 60 * 1000; 
+
+    console.log(`⏰ Scheduling Briefing for ${projectId}. Next run in ${(delayMs/1000/60).toFixed(1)} mins.`);
+
+    await fetch(`${CRON_REGISTRY_URL}/register`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            secret: CRON_SECRET,
+            jobId: `briefing_${projectId}`,
+            intervalMs: intervalMs, 
+            initialDelay: delayMs,
+            webhookUrl: `https://everydaytok-thrust-core-server.hf.space/automated-briefing`,
+            leadId: projectId, 
+            payload: { projectId, timezoneOffset: offset }
+        })
+    }).catch(e => console.error("Cron Reg Error", e));
+}
+
+async function executeCommands(userId, projectId, commands) {
+    let flags = { shouldReload: false, thrustComplete: false };
+
+    for (const cmd of commands) {
+        console.log(`[CMD] ${cmd.type} -> Project: ${projectId}`);
+
+        try {
+            if (cmd.type === 'create_thrust') {
+                const { data: thrust } = await supabase.from('thrusts').insert({
+                    lead_id: projectId,
+                    title: cmd.payload.title,
+                    markdown_content: cmd.payload.markdown_content,
+                    status: 'active'
+                }).select().single();
+
+                if (thrust && cmd.payload.tasks && cmd.payload.tasks.length > 0) {
+                    const tasks = cmd.payload.tasks.map(t => ({ thrust_id: thrust.id, title: t }));
+                    await supabase.from('thrust_tasks').insert(tasks);
+                }
+                flags.shouldReload = true;
+            }
+
+            if (cmd.type === 'log_timeline') {
+                await supabase.from('timeline_events').insert({
+                    lead_id: projectId,
+                    title: cmd.payload.title,
+                    description: cmd.payload.description,
+                    type: (cmd.payload.type || 'system').toLowerCase(),
+                });
+                flags.shouldReload = true;
+            }
+
+            if (cmd.type === 'update_requirements') {
+                await supabase.from('leads').update({ requirements_doc: cmd.payload }).eq('id', projectId);
+                flags.shouldReload = true;
+            }
+
+            if (cmd.type === 'schedule_briefing') {
+                const offset = cmd.payload.timezone_offset || 0;
+                await registerMorningCron(projectId, offset);
+            }
+
+            if (cmd.type === 'freeze_project') {
+                const isFrozen = cmd.payload === 'true';
+                await StateManager.setFrozen(projectId, isFrozen);
+                console.log(`❄️ Project ${projectId} Frozen: ${isFrozen}`);
+            }
+
+            if (cmd.type === 'thrust_complete') {
+                flags.thrustComplete = true; 
+            }
+
+            if (cmd.type === 'notification' && FRONT_URL) {
+                fetch(`${FRONT_URL}/internal/notify`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ user_id: userId, type: 'toast', message: cmd.payload })
+                }).catch(() => {});
+            }
+
+        } catch (e) { console.error("Exec Error", e); }
+    }
+    return flags;
+}
+
+// ==========================================
+// 6. ENDPOINTS
+// ==========================================
+
+// --- INIT ---
+app.post('/init-project', async (req, res) => {
+    const { userId, name, description, localPath } = req.body;
+    
+    const { data: lead, error } = await supabase.from('leads').insert({
+        user_id: userId, name, description, local_path: localPath, status: 'active', requirements_doc: "Init..."
+    }).select().single();
+
+    if (error || !lead) return res.status(500).json({ error: "Failed to create project" });
+
+    res.json({ success: true, leadId: lead.id });
+
+    // Run AI processing in background
+    setImmediate(async () => {
+        try {
+            const initInput = `PROJECT: ${name}\nDESC: ${description}\nTask: Init PRD, First Thrust, Schedule Morning Briefing.`;
+            const aiResult = await callAI([], initInput, {}, prompts.init_system_prompt, "", SMART_MODEL_ID);
+            
+            // Explicitly force a success notification command so the UI reacts
+            aiResult.text += `\n<notification>Project '${name}' initialized successfully!</notification>`;
+            
+            await StateManager.addHistory(lead.id, 'user', initInput);
+            await StateManager.addHistory(lead.id, 'model', aiResult.text);
+            
+            const cmds = extractCommands(aiResult.text);
+            await executeCommands(userId, lead.id, cmds);
+        } catch (err) {
+            console.error("❌ Background Init Failed:", err);
+            // Notify frontend of failure
+            if (FRONT_URL) {
+                fetch(`${FRONT_URL}/internal/notify`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ user_id: userId, type: 'toast', message: "Initialization AI Error." })
+                }).catch(() => {});
+            }
+        }
+    });
+});
+
+// --- MAIN PROCESS ---
+app.post('/process', async (req, res) => {
+    const { userId, projectId, prompt, context, task_type = 'chat' } = req.body;
+
+    if (task_type === 'chat') await StateManager.setFrozen(projectId, false);
+
+    let selectedModel = (task_type === 'log_ingestion') ? FAST_MODEL_ID : SMART_MODEL_ID;
+    let sysPrompt = (task_type === 'log_ingestion') ? prompts.log_analyst_prompt : prompts.director_system_prompt;
+
+    try {
+        const { data: lead } = await supabase.from('leads').select('requirements_doc').eq('id', projectId).single();
+        const { data: activeThrust } = await supabase.from('thrusts')
+            .select('title, tasks:thrust_tasks(title, status)')
+            .eq('lead_id', projectId)
+            .eq('status', 'active')
+            .order('created_at', { ascending: false })
+            .limit(1)
+            .single();
+        
+        const { data: timeline } = await supabase.from('timeline_events')
+            .select('title, type, description, created_at')
+            .eq('lead_id', projectId)
+            .order('created_at', { ascending: false })
+            .limit(10); 
+
+        const projectContext = `
+        [PRD]: ${lead?.requirements_doc?.substring(0, 3000)}...
+        
+        [CURRENT THRUST]: 
+        ${activeThrust ? JSON.stringify(activeThrust, null, 2) : "None"}
+
+        [RECENT TIMELINE]:
+        ${JSON.stringify(timeline || [], null, 2)}
+        `;
+
+        const history = await StateManager.getHistory(projectId);
+        if (task_type === 'chat') await StateManager.addHistory(projectId, 'user', prompt);
+
+        let aiResult = await callAI(history, prompt, context, sysPrompt, projectContext, selectedModel);
+        let cmds = extractCommands(aiResult.text);
+        let flags = await executeCommands(userId, projectId, cmds);
+
+        if (flags.thrustComplete && task_type === 'log_ingestion') {
+            console.log(`🚀 Thrust Complete detected by Analyst. Escalating to Director...`);
+            
+            const escalationPrompt = "The previous thrust is complete based on logs. Generate the next Thrust immediately to keep momentum.";
+            const smartResult = await callAI(history, escalationPrompt, context, prompts.director_system_prompt, projectContext, SMART_MODEL_ID);
+            
+            aiResult.text += `\n\n[DIRECTOR INTERVENTION]:\n${smartResult.text}`;
+            
+            const smartCmds = extractCommands(smartResult.text);
+            await executeCommands(userId, projectId, smartCmds);
+            
+            await StateManager.addHistory(projectId, 'model', aiResult.text);
+        } else {
+            await StateManager.addHistory(projectId, 'model', aiResult.text);
+        }
+
+        const cleanText = aiResult.text.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, '').trim();
+        res.json({ text: cleanText, should_reload: flags.shouldReload });
+
+    } catch (e) {
+        console.error(e);
+        res.status(500).json({ error: "Processing Error" });
+    }
+});
+
+// --- AUTOMATED MORNING BRIEFING ---
+app.post('/automated-briefing', async (req, res) => {
+    const { projectId } = req.body;
+    console.log(`☀️ Morning Briefing Triggered: ${projectId}`);
+
+    try {
+        const isFrozen = await StateManager.isFrozen(projectId);
+        
+        const { data: lastThrust } = await supabase.from('thrusts')
+            .select('created_at')
+            .eq('lead_id', projectId)
+            .order('created_at', { ascending: false })
+            .limit(1)
+            .single();
+
+        const lastThrustDate = lastThrust ? new Date(lastThrust.created_at).getDate() : 0;
+        const todayDate = new Date().getDate();
+
+        if (isFrozen) return res.json({ status: "skipped_frozen" });
+        if (lastThrustDate === todayDate) return res.json({ status: "skipped_exists" });
+
+        const prompt = "It is 6 AM. Generate the Morning Briefing (New Thrust). If the project has been idle, use <freeze_project>true</freeze_project> after this.";
+        
+        const { data: lead } = await supabase.from('leads').select('*').eq('id', projectId).single();
+        const { data: timeline } = await supabase.from('timeline_events')
+            .select('*').eq('lead_id', projectId).order('created_at', { ascending: false }).limit(5);
+
+        const projectContext = `[PRD]: ${lead.requirements_doc}\n[TIMELINE]: ${JSON.stringify(timeline)}`;
+        const history = await StateManager.getHistory(projectId);
+        
+        const aiResult = await callAI(history, prompt, {}, prompts.director_system_prompt, projectContext, SMART_MODEL_ID);
+        
+        await StateManager.addHistory(projectId, 'model', aiResult.text);
+        const cmds = extractCommands(aiResult.text);
+        await executeCommands(lead.user_id, projectId, cmds);
+
+        await StateManager.setFrozen(projectId, true); 
+
+        res.json({ success: true });
+
+    } catch (e) {
+        console.error("Morning Briefing Error", e);
+        res.status(500).json({ error: e.message });
+    }
+});
+
+app.get('/', async (req, res) => {
+   res.status(200).json({ status: "Alive" });
+});
+
+app.listen(PORT, () => {
+  console.log(`✅ Core Online: ${PORT} | Smart: ${SMART_MODEL_ID} | Fast: ${FAST_MODEL_ID}`);
+});
+
+/* import express from 'express';
+import cors from 'cors';
+import fs from 'fs';
+import path from 'path';
+import { createClient } from '@supabase/supabase-js';
+
 
 // ==========================================
 // 1. CONFIGURATION & SETUP
@@ -468,4 +927,5 @@ app.listen(PORT, () => {
   console.log(`CRON_REGISTRY_URL ${CRON_REGISTRY_URL}`);
   console.log(`CRON_SECRET ${CRON_SECRET}`);
   
-});
+});
+*/