Update app.js

app.js

@@ -7,17 +7,17 @@ import { createClient } from '@supabase/supabase-js';
 // ==========================================
 // 1. CONFIGURATION & SETUP
 // ==========================================
-const PORT = 7860;
+const PORT = 7862;
 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"; // Defaulting to local Ollama/LMStudio if env missing
+const REMOTE_SERVER_URL = process.env.REMOTE_AI_URL || "http://localhost:11434"; // Defaulting to local if env missing
 const FRONT_URL = process.env.FRONT_URL;
-const CRON_REGISTRY_URL = process.env.CRON_REGISTRY_URL || "http://localhost:7861"; // URL of the Cron Server
+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"; 
+const SMART_MODEL_ID = "gpt-4-turbo"; 
+const FAST_MODEL_ID = "gpt-3.5-turbo"; 
 
 if (!SUPABASE_URL || !SUPABASE_KEY) {
     console.error("FATAL: Missing Supabase URL or Service Key.");
@@ -34,7 +34,6 @@ app.use(cors());
 // 2. PROMPT MANAGEMENT
 // ==========================================
 let prompts = {}; 
-// Load synchronously on boot
 try {
     const promptsPath = path.resolve('./prompts.json');
     if (fs.existsSync(promptsPath)) {
@@ -72,7 +71,7 @@ const StateManager = {
         if (error) return [];
         const fullHistory = (chunks || []).reverse().flatMap(c => c.payload || []);
         
-        // Initialize Cache with default frozen state (false) if not known, will update from DB later
+        // Initialize Cache with default frozen state (false)
         activeProjects.set(projectId, { history: fullHistory, lastActive: Date.now(), isFrozen: false });
         return fullHistory;
     },
@@ -122,7 +121,6 @@ const StateManager = {
         } catch (e) { console.error("History Sync Error", e); }
     },
     
-    // Check frozen state from DB
     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();
@@ -140,7 +138,6 @@ const StateManager = {
 // ==========================================
 
 const callAI = async (history, input, contextData, systemPrompt, projectContext, modelId) => {
-    // Construct Context
     let contextStr = "";
     try { contextStr = JSON.stringify(contextData, null, 2); } catch {}
 
@@ -166,7 +163,7 @@ const callAI = async (history, input, contextData, systemPrompt, projectContext,
 };
 
 // ==========================================
-// 5. LOGIC & COMMANDS
+// 5. COMMAND & CRON LOGIC
 // ==========================================
 
 function extractCommands(text) {
@@ -186,25 +183,26 @@ function extractCommands(text) {
     parse(/<notification>([\s\S]*?)<\/notification>/g, 'notification', false);
     parse(/<update_requirements>([\s\S]*?)<\/update_requirements>/g, 'update_requirements', false);
     parse(/<schedule_briefing>([\s\S]*?)<\/schedule_briefing>/g, 'schedule_briefing');
-    parse(/<freeze_project>([\s\S]*?)<\/freeze_project>/g, 'freeze_project', false); // expecting "true"
-    parse(/<thrust_complete>([\s\S]*?)<\/thrust_complete>/g, 'thrust_complete', false); // expecting "true"
+    parse(/<freeze_project>([\s\S]*?)<\/freeze_project>/g, 'freeze_project', false); 
+    parse(/<thrust_complete>([\s\S]*?)<\/thrust_complete>/g, 'thrust_complete', false); 
 
     return commands;
 }
 
-// Register Cron Helper
+// Logic: Calculate delay until 6AM user time, register Cron with that initial delay
 async function registerMorningCron(projectId, offset) {
-    // 1. Calculate time until next 6 AM
     const now = new Date();
     const target = new Date(now);
     
-    // Adjust logic: Find 6 AM in user's timezone relative to UTC
-    // Simple approach: Calculate ms delay
-    target.setUTCHours(6 - offset, 0, 0, 0); 
+    // Logic: 6 AM relative to user offset.
+    // E.g., Offset -5 (EST). UTC is 11 AM when EST is 6 AM.
+    // Target UTC hour = 6 - offset.
+    const targetUtcHour = 6 - offset; 
+
+    target.setUTCHours(targetUtcHour, 0, 0, 0); 
     
     if (target <= now) {
-        // If 6AM passed today, schedule for tomorrow
-        target.setDate(target.getDate() + 1);
+        target.setDate(target.getDate() + 1); // Move to tomorrow
     }
 
     const delayMs = target.getTime() - now.getTime();
@@ -212,14 +210,6 @@ async function registerMorningCron(projectId, offset) {
 
     console.log(`⏰ Scheduling Briefing for ${projectId}. Next run in ${(delayMs/1000/60).toFixed(1)} mins.`);
 
-    // 2. Call Cron Registry (One time set for specific start, then interval)
-    // Note: The simple registry provided uses setInterval. To sync to 6AM exactly, 
-    // we register a job that fires in 'delayMs', which then executes logic and re-registers itself 
-    // OR simply use 24h interval starting NOW if close enough. 
-    
-    // Better strategy for this specific "Morning" requirement with a simple setInterval registry:
-    // We register a job with delayMs. The payload tells the Core "Setup Daily Loop".
-    
     await fetch(`${CRON_REGISTRY_URL}/register`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -227,7 +217,8 @@ async function registerMorningCron(projectId, offset) {
             secret: CRON_SECRET,
             jobId: `briefing_${projectId}`,
             intervalMs: intervalMs, 
-            webhookUrl: `http://localhost:${PORT}/automated-briefing`, // Self-call
+            initialDelay: delayMs, // Send delay to Cron Server
+            webhookUrl: `http://localhost:${PORT}/automated-briefing`,
             payload: { projectId, timezoneOffset: offset }
         })
     }).catch(e => console.error("Cron Reg Error", e));
@@ -282,7 +273,7 @@ async function executeCommands(userId, projectId, commands) {
             }
 
             if (cmd.type === 'thrust_complete') {
-                flags.thrustComplete = true; // Signals Core to trigger Smart Model
+                flags.thrustComplete = true; // Signal for escalation
             }
 
             if (cmd.type === 'notification' && FRONT_URL) {
@@ -306,14 +297,12 @@ async function executeCommands(userId, projectId, commands) {
 app.post('/init-project', async (req, res) => {
     const { userId, name, description, localPath } = req.body;
     
-    // Create DB Entry
     const { data: lead } = await supabase.from('leads').insert({
         user_id: userId, name, description, local_path: localPath, status: 'active', requirements_doc: "Init..."
     }).select().single();
 
     res.json({ success: true, leadId: lead.id });
 
-    // Background Process
     setImmediate(async () => {
         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);
@@ -333,13 +322,12 @@ app.post('/process', async (req, res) => {
     // 1. Unfreeze if user interacts
     if (task_type === 'chat') await StateManager.setFrozen(projectId, false);
 
-    // 2. Select Model
-    // Logic: Log ingestion uses Fast model. If Fast model says "Thrust Complete", we switch to Smart.
+    // 2. Select Model (Log Ingestion = Fast, High Level = Smart)
     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 {
-        // Fetch Context (PRD + Current Thrust)
+        // 3. Build Context (God View: PRD + Timeline + Active Thrust)
         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)')
@@ -348,46 +336,52 @@ app.post('/process', async (req, res) => {
             .order('created_at', { ascending: false })
             .limit(1)
             .single();
+        
+        // FETCH TIMELINE (Restored functionality)
+        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); // Look at last 10 events for context
 
         const projectContext = `
-        [PRD]: ${lead?.requirements_doc?.substring(0, 2000)}...
-        [CURRENT THRUST]: ${activeThrust ? JSON.stringify(activeThrust) : "None"}
+        [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);
 
-        // 3. AI Execution
+        // 4. AI Execution
         let aiResult = await callAI(history, prompt, context, sysPrompt, projectContext, selectedModel);
-        
-        // 4. Command Execution
         let cmds = extractCommands(aiResult.text);
         let flags = await executeCommands(userId, projectId, cmds);
 
         // 5. AUTO-ESCALATION (Fast -> Smart)
-        // If Log Analyst says thrust is done, we immediately call the Smart Director to generate the next one.
+        // Logic: Analyst determines thrust is done via logs -> Triggers Director to set new Aim.
         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.";
-            // Call Smart Model (No history of logs, just the context that it's done)
+            // Call Smart Model
             const smartResult = await callAI(history, escalationPrompt, context, prompts.director_system_prompt, projectContext, SMART_MODEL_ID);
             
-            // Append Smart response
             aiResult.text += `\n\n[DIRECTOR INTERVENTION]:\n${smartResult.text}`;
             
             const smartCmds = extractCommands(smartResult.text);
             await executeCommands(userId, projectId, smartCmds);
             
-            // Save history
             await StateManager.addHistory(projectId, 'model', aiResult.text);
         } else {
             await StateManager.addHistory(projectId, 'model', aiResult.text);
         }
 
-        // Clean output
         const cleanText = aiResult.text.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, '').trim();
-
         res.json({ text: cleanText, should_reload: flags.shouldReload });
 
     } catch (e) {
@@ -402,10 +396,8 @@ app.post('/automated-briefing', async (req, res) => {
     console.log(`☀️ Morning Briefing Triggered: ${projectId}`);
 
     try {
-        // 1. Check Freeze State
         const isFrozen = await StateManager.isFrozen(projectId);
         
-        // Check when the last thrust was made. If made today, skip.
         const { data: lastThrust } = await supabase.from('thrusts')
             .select('created_at')
             .eq('lead_id', projectId)
@@ -416,7 +408,7 @@ app.post('/automated-briefing', async (req, res) => {
         const lastThrustDate = lastThrust ? new Date(lastThrust.created_at).getDate() : 0;
         const todayDate = new Date().getDate();
 
-        // LOGIC: If frozen, DO NOT generate. If thrust made today, DO NOT generate.
+        // Prevent generating if project is dead (frozen) or if generated recently
         if (isFrozen) {
             console.log(`Skipping briefing: Project Frozen.`);
             return res.json({ status: "skipped_frozen" });
@@ -426,24 +418,25 @@ app.post('/automated-briefing', async (req, res) => {
             return res.json({ status: "skipped_exists" });
         }
 
-        // 2. Generate Briefing
+        // Generate Briefing
         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.";
         
-        // Use Process endpoint logic internally
-        // We create a fake "request" to process
-        // Ideally refactor logic out, but for now calling AI directly:
+        // Manually build context context for the automated call
         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, `[PRD]: ${lead.requirements_doc}`, SMART_MODEL_ID);
+        const aiResult = await callAI(history, prompt, {}, prompts.director_system_prompt, projectContext, SMART_MODEL_ID);
         
-        // 3. Save & Execute
         await StateManager.addHistory(projectId, 'model', aiResult.text);
         const cmds = extractCommands(aiResult.text);
         await executeCommands(lead.user_id, projectId, cmds);
 
-        // 4. Force Freeze (Morning briefings lock the project until user returns)
-        // This ensures we don't pile up briefings on an abandoned project.
+        // Morning briefings set the project to Frozen state until user returns
+        // This prevents the AI from generating 30 briefings for an abandoned project
         await StateManager.setFrozen(projectId, true); 
 
         res.json({ success: true });