mark/vibn-frontend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: migrate AI chat system from Firebase/Firestore to Postgres

Browse Source 
Firebase was not configured so every chat request crashed with
'Firebase Admin credentials not configured'.

- chat-mode-resolver.ts: read project phase from fs_projects (Postgres)
- chat-context.ts: load project data from fs_projects instead of Firestore
- /api/ai/conversation: store/retrieve conversations in chat_conversations
  Postgres table (created automatically on first use)
- /api/ai/chat: replace all Firestore reads/writes with Postgres queries
- v_ai_chat/page.tsx: replace Firebase client auth with useSession from
  next-auth/react; remove Firestore listeners, use REST API for project data

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Mark Henderson
2026-02-19 12:07:03 -08:00
parent a281d4d373
commit e3a6641e3c
6 changed files with 193 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
app/[workspace]/project/[projectId]/v_ai_chat/page.tsx
View File

@@ -9,15 +9,13 @@ import { Input } from "@/components/ui/input";
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"; import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
import { Send, Loader2, Paperclip, X, FileText, RotateCcw, Upload, CheckCircle2, AlertTriangle, Sparkles } from "lucide-react"; import { Send, Loader2, Paperclip, X, FileText, RotateCcw, Upload, CheckCircle2, AlertTriangle, Sparkles } from "lucide-react";
import { cn } from "@/lib/utils"; import { cn } from "@/lib/utils";
import { auth } from "@/lib/firebase/config"; import { useSession } from "next-auth/react";
import { toast } from "sonner"; import { toast } from "sonner";
import { GitHubRepoPicker } from "@/components/ai/github-repo-picker"; import { GitHubRepoPicker } from "@/components/ai/github-repo-picker";
import { PhaseSidebar } from "@/components/ai/phase-sidebar"; import { PhaseSidebar } from "@/components/ai/phase-sidebar";
import { CollapsibleSidebar } from "@/components/ui/collapsible-sidebar"; import { CollapsibleSidebar } from "@/components/ui/collapsible-sidebar";
import { ExtractionResultsEditable } from "@/components/ai/extraction-results-editable"; import { ExtractionResultsEditable } from "@/components/ai/extraction-results-editable";
import type { ChatExtractionData } from "@/lib/ai/chat-extraction-types"; import type { ChatExtractionData } from "@/lib/ai/chat-extraction-types";
import { db } from "@/lib/firebase/config";
import { doc, onSnapshot, getDoc } from "firebase/firestore";
import { VisionForm } from "@/components/ai/vision-form"; import { VisionForm } from "@/components/ai/vision-form";
interface Message { interface Message {
@@ -72,6 +70,7 @@ export default function GettingStartedPage() {
const params = useParams(); const params = useParams();
const projectId = params.projectId as string; const projectId = params.projectId as string;
const workspace = params.workspace as string; const workspace = params.workspace as string;
const { status: sessionStatus } = useSession();
const [messages, setMessages] = useState<Message[]>([]); const [messages, setMessages] = useState<Message[]>([]);
const [input, setInput] = useState(""); const [input, setInput] = useState("");
@@ -104,74 +103,45 @@ export default function GettingStartedPage() {
messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' }); messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
}, [messages]); }, [messages]);
// Check for vision answers on load // Load project phase + vision answers from the Postgres-backed API
useEffect(() => { useEffect(() => {
if (!projectId) return; if (!projectId) return;
const checkVision = async () => { const loadProject = async () => {
try { try {
const projectDoc = await getDoc(doc(db, "projects", projectId)); const res = await fetch(`/api/projects/${projectId}`);
if (projectDoc.exists()) { if (res.ok) {
const data = projectDoc.data(); const data = await res.json();
const hasAnswers = data?.visionAnswers?.allAnswered === true; const phase = data.project?.currentPhase || 'collector';
setCurrentPhase(phase);
const hasAnswers = data.project?.visionAnswers?.allAnswered === true;
setHasVisionAnswers(hasAnswers); setHasVisionAnswers(hasAnswers);
} }
} catch (error) { } catch (error) {
console.error('Error checking vision answers:', error); console.error('Error loading project:', error);
} finally { } finally {
setCheckingVision(false); setCheckingVision(false);
} }
}; };
checkVision(); loadProject();
}, [projectId]);
// Listen to project phase changes
useEffect(() => {
if (!projectId) return;
const unsubscribe = onSnapshot(
doc(db, "projects", projectId),
(snapshot) => {
if (snapshot.exists()) {
const data = snapshot.data();
const phase = data?.currentPhase || "collector";
setCurrentPhase(phase);
// Update vision answers status
const hasAnswers = data?.visionAnswers?.allAnswered === true;
setHasVisionAnswers(hasAnswers);
}
}
);
return () => unsubscribe();
}, [projectId]); }, [projectId]);
// Initialize with AI welcome message // Initialize with AI welcome message
useEffect(() => { useEffect(() => {
if (!isInitialized && projectId) { if (!isInitialized && projectId && sessionStatus !== 'loading') {
const unsubscribe = auth.onAuthStateChanged(async (user) => { const initialize = async () => {
if (!user) { if (sessionStatus === 'unauthenticated') {
// Not signed in, trigger AI welcome
setIsLoading(false); setIsLoading(false);
setIsInitialized(true); setIsInitialized(true);
setTimeout(() => { setTimeout(() => sendChatMessage("Hello"), 500);
sendChatMessage("Hello");
}, 500);
return; return;
} }
// User is signed in, load conversation history first // Signed in via NextAuth — load conversation history
try { try {
const token = await user.getIdToken();
// Fetch existing conversation history // Fetch existing conversation history
const historyResponse = await fetch(`/api/ai/conversation?projectId=${projectId}`, { const historyResponse = await fetch(`/api/ai/conversation?projectId=${projectId}`);
headers: {
'Authorization': `Bearer ${token}`,
},
});
let existingMessages: Message[] = []; let existingMessages: Message[] = [];
@@ -231,11 +201,11 @@ export default function GettingStartedPage() {
setIsLoading(false); setIsLoading(false);
setIsInitialized(true); setIsInitialized(true);
} }
}); };
return () => unsubscribe(); initialize();
} }
}, [projectId, isInitialized]); }, [projectId, isInitialized, sessionStatus]);
const sendChatMessage = async (messageContent: string) => { const sendChatMessage = async (messageContent: string) => {
const content = messageContent.trim(); const content = messageContent.trim();
@@ -251,24 +221,10 @@ export default function GettingStartedPage() {
setIsSending(true); setIsSending(true);
try { try {
const user = auth.currentUser;
if (!user) {
toast.error('Please sign in to continue');
setIsSending(false);
return;
}
const token = await user.getIdToken();
const response = await fetch('/api/ai/chat', { const response = await fetch('/api/ai/chat', {
method: 'POST', method: 'POST',
headers: { headers: { 'Content-Type': 'application/json' },
'Authorization': `Bearer ${token}`, body: JSON.stringify({ projectId, message: content }),
'Content-Type': 'application/json',
},
body: JSON.stringify({
projectId,
message: content,
}),
}); });
if (!response.ok) { if (!response.ok) {
@@ -392,21 +348,8 @@ export default function GettingStartedPage() {
} }
try { try {
const user = auth.currentUser; const response = await fetch(`/api/ai/conversation?projectId=${projectId}`, {
if (!user) { method: 'DELETE',
toast.error('Please sign in to reset chat');
return;
}
const token = await user.getIdToken();
const response = await fetch('/api/ai/conversation/reset', {
method: 'POST',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({ projectId }),
}); });
if (response.ok) { if (response.ok) {
@@ -433,20 +376,9 @@ export default function GettingStartedPage() {
setExtractionStatus("importing"); setExtractionStatus("importing");
setExtractionError(null); setExtractionError(null);
const user = auth.currentUser;
if (!user) {
toast.error("Please sign in to import chats");
setIsImporting(false);
return;
}
const token = await user.getIdToken();
const importResponse = await fetch(`/api/projects/${projectId}/knowledge/import-ai-chat`, { const importResponse = await fetch(`/api/projects/${projectId}/knowledge/import-ai-chat`, {
method: "POST", method: "POST",
headers: { headers: { "Content-Type": "application/json" },
"Content-Type": "application/json",
Authorization: `Bearer ${token}`,
},
body: JSON.stringify({ body: JSON.stringify({
title: extractForm.title || "Imported AI chat", title: extractForm.title || "Imported AI chat",
provider: extractForm.provider, provider: extractForm.provider,

161
app/api/ai/chat/route.ts
View File

@@ -2,8 +2,7 @@ import { NextResponse } from 'next/server';
import { z } from 'zod'; import { z } from 'zod';
import { GeminiLlmClient } from '@/lib/ai/gemini-client'; import { GeminiLlmClient } from '@/lib/ai/gemini-client';
import type { LlmClient } from '@/lib/ai/llm-client'; import type { LlmClient } from '@/lib/ai/llm-client';
import { getAdminDb } from '@/lib/firebase/admin'; import { query } from '@/lib/db-postgres';
import { FieldValue } from 'firebase-admin/firestore';
import { MODE_SYSTEM_PROMPTS, ChatMode } from '@/lib/ai/chat-modes'; import { MODE_SYSTEM_PROMPTS, ChatMode } from '@/lib/ai/chat-modes';
import { resolveChatMode } from '@/lib/server/chat-mode-resolver'; import { resolveChatMode } from '@/lib/server/chat-mode-resolver';
import { import {
@@ -48,37 +47,30 @@ interface ChatRequestBody {
overrideMode?: ChatMode; overrideMode?: ChatMode;
} }
const ENSURE_CONV_TABLE = `
CREATE TABLE IF NOT EXISTS chat_conversations (
project_id text PRIMARY KEY,
messages jsonb NOT NULL DEFAULT '[]',
updated_at timestamptz NOT NULL DEFAULT NOW()
)
`;
async function appendConversation( async function appendConversation(
projectId: string, projectId: string,
messages: Array<{ role: 'user' | 'assistant'; content: string }>, newMessages: Array<{ role: 'user' | 'assistant'; content: string }>,
) { ) {
const adminDb = getAdminDb(); await query(ENSURE_CONV_TABLE);
const docRef = adminDb.collection('chat_conversations').doc(projectId); const now = new Date().toISOString();
const stamped = newMessages.map((m) => ({ ...m, createdAt: now }));
await adminDb.runTransaction(async (tx) => { await query(
const snapshot = await tx.get(docRef); `INSERT INTO chat_conversations (project_id, messages, updated_at)
const existing = (snapshot.exists ? (snapshot.data()?.messages as unknown[]) : []) ?? []; VALUES ($1, $2::jsonb, NOW())
ON CONFLICT (project_id) DO UPDATE
const now = new Date().toISOString(); SET messages = chat_conversations.messages || $2::jsonb,
updated_at = NOW()`,
const newMessages = messages.map((m) => ({ [projectId, JSON.stringify(stamped)]
role: m.role, );
content: m.content,
// Use a simple ISO string for message timestamps to avoid FieldValue
// restrictions inside arrays.
createdAt: now,
}));
tx.set(
docRef,
{
projectId,
messages: [...existing, ...newMessages],
updatedAt: FieldValue.serverTimestamp(),
},
{ merge: true },
);
});
} }
export async function POST(request: Request) { export async function POST(request: Request) {
@@ -91,13 +83,15 @@ export async function POST(request: Request) {
return NextResponse.json({ error: 'projectId and message are required' }, { status: 400 }); return NextResponse.json({ error: 'projectId and message are required' }, { status: 400 });
} }
// Verify project exists // Verify project exists in Postgres
const adminDb = getAdminDb(); const projectRows = await query<{ data: any }>(
const projectSnapshot = await adminDb.collection('projects').doc(projectId).get(); `SELECT data FROM fs_projects WHERE id = $1 LIMIT 1`,
if (!projectSnapshot.exists) { [projectId]
);
if (projectRows.length === 0) {
return NextResponse.json({ error: 'Project not found' }, { status: 404 }); return NextResponse.json({ error: 'Project not found' }, { status: 404 });
} }
const projectData = projectSnapshot.data() ?? {}; const projectData = projectRows[0].data ?? {};
// Resolve chat mode (uses new resolver) // Resolve chat mode (uses new resolver)
const resolvedMode = body.overrideMode ?? await resolveChatMode(projectId); const resolvedMode = body.overrideMode ?? await resolveChatMode(projectId);
@@ -138,12 +132,13 @@ ${context.sessionHistory.totalSessions > 0 ? `- Complete Cursor session history
Use this context to provide specific, grounded responses. The session history shows your complete conversation history with the user - use it to understand what has been built and discussed.`; Use this context to provide specific, grounded responses. The session history shows your complete conversation history with the user - use it to understand what has been built and discussed.`;
// Load existing conversation history // Load existing conversation history from Postgres
const conversationDoc = await adminDb.collection('chat_conversations').doc(projectId).get(); await query(ENSURE_CONV_TABLE);
const conversationData = conversationDoc.exists ? conversationDoc.data() : null; const convRows = await query<{ messages: any[] }>(
const conversationHistory = Array.isArray(conversationData?.messages) `SELECT messages FROM chat_conversations WHERE project_id = $1`,
? conversationData.messages [projectId]
: []; );
const conversationHistory: any[] = convRows[0]?.messages ?? [];
// Build full message context (history + current message) // Build full message context (history + current message)
const messages = [ const messages = [
@@ -251,10 +246,14 @@ Use this context to provide specific, grounded responses. The session history sh
if (Object.keys(updates).length > 0) { if (Object.keys(updates).length > 0) {
updates['visionAnswers.updatedAt'] = new Date().toISOString(); updates['visionAnswers.updatedAt'] = new Date().toISOString();
await adminDb.collection('projects').doc(projectId).set(updates, { merge: true }) await query(
.catch((error) => { `UPDATE fs_projects
console.error('[ai/chat] Failed to store vision answers', error); SET data = data || $1::jsonb
}); WHERE id = $2`,
[JSON.stringify({ visionAnswers: updates }), projectId]
).catch((error) => {
console.error('[ai/chat] Failed to store vision answers', error);
});
} }
} }
@@ -326,12 +325,17 @@ Use this context to provide specific, grounded responses. The session history sh
timestamp: new Date().toISOString(), timestamp: new Date().toISOString(),
}; };
// Persist to project phaseData // Persist to project phaseData in Postgres
await adminDb.collection('projects').doc(projectId).set( await query(
{ `UPDATE fs_projects
'phaseData.phaseHandoffs.collector': handoff, SET data = jsonb_set(
}, data,
{ merge: true } '{phaseData,phaseHandoffs,collector}',
$1::jsonb,
true
)
WHERE id = $2`,
[JSON.stringify(handoff), projectId]
).catch((error) => { ).catch((error) => {
console.error('[ai/chat] Failed to persist collector handoff', error); console.error('[ai/chat] Failed to persist collector handoff', error);
}); });
@@ -348,9 +352,12 @@ Use this context to provide specific, grounded responses. The session history sh
console.log(`[AI Chat] Collector complete - triggering backend extraction`); console.log(`[AI Chat] Collector complete - triggering backend extraction`);
// Mark collector as complete // Mark collector as complete
await adminDb.collection('projects').doc(projectId).update({ await query(
'phaseData.collectorCompletedAt': new Date().toISOString(), `UPDATE fs_projects
}).catch((error) => { SET data = jsonb_set(data, '{phaseData,collectorCompletedAt}', $1::jsonb, true)
WHERE id = $2`,
[JSON.stringify(new Date().toISOString()), projectId]
).catch((error) => {
console.error('[ai/chat] Failed to mark collector complete', error); console.error('[ai/chat] Failed to mark collector complete', error);
}); });
@@ -397,44 +404,32 @@ Use this context to provide specific, grounded responses. The session history sh
console.log(`[AI Chat] Extraction review complete - transitioning to vision phase`); console.log(`[AI Chat] Extraction review complete - transitioning to vision phase`);
// Mark extraction review as complete and transition to vision // Mark extraction review as complete and transition to vision
await adminDb.collection('projects').doc(projectId).update({ await query(
currentPhase: 'vision', `UPDATE fs_projects
phaseStatus: 'in_progress', SET data = data
'phaseData.extractionReviewCompletedAt': new Date().toISOString(), || '{"currentPhase":"vision","phaseStatus":"in_progress"}'::jsonb
}).catch((error) => { || jsonb_build_object('phaseData',
(data->'phaseData') || jsonb_build_object(
'extractionReviewCompletedAt', $1::text
)
)
WHERE id = $2`,
[new Date().toISOString(), projectId]
).catch((error) => {
console.error('[ai/chat] Failed to transition to vision phase', error); console.error('[ai/chat] Failed to transition to vision phase', error);
}); });
} }
} }
// Save conversation history // Save conversation history to Postgres
const newConversationHistory = [ await appendConversation(projectId, [
...conversationHistory, { role: 'user', content: message },
{ { role: 'assistant', content: reply.reply },
role: 'user' as const, ]).catch((error) => {
content: message,
createdAt: new Date().toISOString(),
},
{
role: 'assistant' as const,
content: reply.reply,
createdAt: new Date().toISOString(),
},
];
await adminDb.collection('chat_conversations').doc(projectId).set(
{
projectId,
userId: projectData.userId,
messages: newConversationHistory,
updatedAt: new Date().toISOString(),
},
{ merge: true }
).catch((error) => {
console.error('[ai/chat] Failed to save conversation history', error); console.error('[ai/chat] Failed to save conversation history', error);
}); });
console.log(`[AI Chat] Conversation history saved (${newConversationHistory.length} total messages)`); console.log(`[AI Chat] Conversation history saved (+2 messages)`);
// Determine which artifacts were used // Determine which artifacts were used
const artifactsUsed = determineArtifactsUsed(context); const artifactsUsed = determineArtifactsUsed(context);

63
app/api/ai/conversation/route.ts
View File

@@ -1,12 +1,20 @@
import { NextResponse } from 'next/server'; import { NextResponse } from 'next/server';
import { getAdminDb } from '@/lib/firebase/admin'; import { query } from '@/lib/db-postgres';
const ENSURE_TABLE = `
CREATE TABLE IF NOT EXISTS chat_conversations (
project_id text PRIMARY KEY,
messages jsonb NOT NULL DEFAULT '[]',
updated_at timestamptz NOT NULL DEFAULT NOW()
)
`;
type StoredMessageRole = 'user' | 'assistant'; type StoredMessageRole = 'user' | 'assistant';
type ConversationMessage = { type ConversationMessage = {
role: StoredMessageRole; role: StoredMessageRole;
content: string; content: string;
createdAt?: { _seconds: number; _nanoseconds: number }; createdAt?: string;
}; };
type ConversationResponse = { type ConversationResponse = {
@@ -19,36 +27,43 @@ export async function GET(request: Request) {
const projectId = (url.searchParams.get('projectId') ?? '').trim(); const projectId = (url.searchParams.get('projectId') ?? '').trim();
if (!projectId) { if (!projectId) {
return NextResponse.json( return NextResponse.json({ error: 'projectId is required' }, { status: 400 });
{ error: 'projectId is required' },
{ status: 400 },
);
} }
const adminDb = getAdminDb(); await query(ENSURE_TABLE);
const docRef = adminDb.collection('chat_conversations').doc(projectId);
const snapshot = await docRef.get();
if (!snapshot.exists) { const rows = await query<{ messages: ConversationMessage[] }>(
const empty: ConversationResponse = { messages: [] }; `SELECT messages FROM chat_conversations WHERE project_id = $1`,
return NextResponse.json(empty); [projectId]
} );
const data = snapshot.data() as { messages?: ConversationMessage[] };
const messages = Array.isArray(data.messages) ? data.messages : [];
const messages: ConversationMessage[] = rows[0]?.messages ?? [];
const response: ConversationResponse = { messages }; const response: ConversationResponse = { messages };
return NextResponse.json(response); return NextResponse.json(response);
} catch (error) { } catch (error) {
console.error('[ai/conversation] Failed to load conversation', error); console.error('[GET /api/ai/conversation] Error:', error);
return NextResponse.json( return NextResponse.json({ messages: [] });
{
error: 'Failed to load conversation',
details: error instanceof Error ? error.message : String(error),
},
{ status: 500 },
);
} }
} }
export async function DELETE(request: Request) {
try {
const url = new URL(request.url);
const projectId = (url.searchParams.get('projectId') ?? '').trim();
if (!projectId) {
return NextResponse.json({ error: 'projectId is required' }, { status: 400 });
}
await query(ENSURE_TABLE);
await query(
`DELETE FROM chat_conversations WHERE project_id = $1`,
[projectId]
);
return NextResponse.json({ ok: true });
} catch (error) {
console.error('[DELETE /api/ai/conversation] Error:', error);
return NextResponse.json({ error: 'Failed to reset conversation' }, { status: 500 });
}
}

1
app/auth/page.tsx
View File

@@ -43,4 +43,3 @@ export default function AuthPage() {
</Suspense> </Suspense>
); );
} }

15
lib/server/chat-context.ts
View File

@@ -5,7 +5,7 @@
* building a compact context object for LLM consumption. * building a compact context object for LLM consumption.
*/ */
import { getAdminDb } from '@/lib/firebase/admin'; import { query } from '@/lib/db-postgres';
import { retrieveRelevantChunks } from '@/lib/server/vector-memory'; import { retrieveRelevantChunks } from '@/lib/server/vector-memory';
import { embedText } from '@/lib/ai/embeddings'; import { embedText } from '@/lib/ai/embeddings';
import { import {
@@ -121,15 +121,16 @@ export async function buildProjectContextForChat(
} = options; } = options;
try { try {
const adminDb = getAdminDb(); // Load project from Postgres
const projectRows = await query<{ data: any }>(
// Load project document `SELECT data FROM fs_projects WHERE id = $1 LIMIT 1`,
const projectSnapshot = await adminDb.collection('projects').doc(projectId).get(); [projectId]
if (!projectSnapshot.exists) { );
if (projectRows.length === 0) {
throw new Error(`Project ${projectId} not found`); throw new Error(`Project ${projectId} not found`);
} }
const projectData = projectSnapshot.data() ?? {}; const projectData = projectRows[0].data ?? {};
// Load summaries in parallel // Load summaries in parallel
const [knowledgeSummary, extractionSummary] = await Promise.all([ const [knowledgeSummary, extractionSummary] = await Promise.all([

183
lib/server/chat-mode-resolver.ts
View File

@@ -1,190 +1,91 @@
/** /**
* Chat Mode Resolution Logic * Chat Mode Resolution Logic
* *
* Determines which chat mode (collector, extraction_review, vision, mvp, marketing, general) * Determines which chat mode (collector, extraction_review, vision, mvp, marketing, general)
* should be active based on project state. * should be active based on project state stored in Postgres.
*/ */
import { getAdminDb } from '@/lib/firebase/admin'; import { query } from '@/lib/db-postgres';
import type { ChatMode } from '@/lib/ai/chat-modes'; import type { ChatMode } from '@/lib/ai/chat-modes';
/** /**
* Resolve the appropriate chat mode for a project * Resolve the appropriate chat mode for a project using Postgres (fs_projects).
*
* Logic:
* 1. No knowledge_items → collector_mode
* 2. Has knowledge but no extractions → collector_mode (needs to run extraction)
* 3. Has extractions but no canonicalProductModel → extraction_review_mode
* 4. Has canonicalProductModel but no mvpPlan → vision_mode
* 5. Has mvpPlan but no marketingPlan → mvp_mode
* 6. Has marketingPlan → marketing_mode
* 7. Otherwise → general_chat_mode
*
* @param projectId - Firestore project ID
* @returns The appropriate chat mode
*/ */
export async function resolveChatMode(projectId: string): Promise<ChatMode> { export async function resolveChatMode(projectId: string): Promise<ChatMode> {
try { try {
const adminDb = getAdminDb(); const rows = await query<{ data: any }>(
`SELECT data FROM fs_projects WHERE id = $1 LIMIT 1`,
[projectId]
);
// Load project data if (rows.length === 0) {
const projectSnapshot = await adminDb.collection('projects').doc(projectId).get(); console.warn(`[Chat Mode Resolver] Project ${projectId} not found`);
if (!projectSnapshot.exists) {
throw new Error(`Project ${projectId} not found`);
}
const projectData = projectSnapshot.data() ?? {};
const phaseData = (projectData.phaseData ?? {}) as Record<string, any>;
// Check for knowledge_items (top-level collection)
const knowledgeSnapshot = await adminDb
.collection('knowledge_items')
.where('projectId', '==', projectId)
.limit(1)
.get();
const hasKnowledge = !knowledgeSnapshot.empty;
// Check for chat_extractions (top-level collection)
const extractionsSnapshot = await adminDb
.collection('chat_extractions')
.where('projectId', '==', projectId)
.limit(1)
.get();
const hasExtractions = !extractionsSnapshot.empty;
// Apply resolution logic
// PRIORITY: Check explicit phase transitions FIRST (overrides knowledge checks)
if (projectData.currentPhase === 'extraction_review' || projectData.currentPhase === 'analyzed') {
return 'extraction_review_mode';
}
if (projectData.currentPhase === 'vision') {
return 'vision_mode';
}
if (projectData.currentPhase === 'mvp') {
return 'mvp_mode';
}
if (projectData.currentPhase === 'marketing') {
return 'marketing_mode';
}
if (!hasKnowledge) {
return 'collector_mode'; return 'collector_mode';
} }
if (hasKnowledge && !hasExtractions) { const projectData = rows[0].data ?? {};
return 'collector_mode'; // Has knowledge but needs extraction const phaseData = (projectData.phaseData ?? {}) as Record<string, any>;
} const currentPhase: string = projectData.currentPhase ?? 'collector';
// Fallback: Has extractions but no canonicalProductModel // Explicit phase overrides
if (hasExtractions && !phaseData.canonicalProductModel) { if (currentPhase === 'extraction_review' || currentPhase === 'analyzed') return 'extraction_review_mode';
return 'extraction_review_mode'; if (currentPhase === 'vision') return 'vision_mode';
} if (currentPhase === 'mvp') return 'mvp_mode';
if (currentPhase === 'marketing') return 'marketing_mode';
if (phaseData.canonicalProductModel && !phaseData.mvpPlan) { // Derive from phase artifacts
return 'vision_mode'; if (!phaseData.canonicalProductModel) return 'collector_mode';
} if (!phaseData.mvpPlan) return 'vision_mode';
if (!phaseData.marketingPlan) return 'mvp_mode';
if (phaseData.mvpPlan && !phaseData.marketingPlan) { if (phaseData.marketingPlan) return 'marketing_mode';
return 'mvp_mode';
}
if (phaseData.marketingPlan) {
return 'marketing_mode';
}
return 'general_chat_mode'; return 'general_chat_mode';
} catch (error) { } catch (error) {
console.error('[Chat Mode Resolver] Failed to resolve mode:', error); console.error('[Chat Mode Resolver] Failed to resolve mode:', error);
// Default to collector on error
return 'collector_mode'; return 'collector_mode';
} }
} }
/** /**
* Get a summary of knowledge_items for context building * Summarise knowledge items for context building.
* Uses Postgres fs_knowledge_items if available, otherwise returns empty.
*/ */
export async function summarizeKnowledgeItems( export async function summarizeKnowledgeItems(projectId: string): Promise<{
projectId: string
): Promise<{
totalCount: number; totalCount: number;
bySourceType: Record<string, number>; bySourceType: Record<string, number>;
recentTitles: string[]; recentTitles: string[];
}> { }> {
try { try {
const adminDb = getAdminDb(); const rows = await query<{ data: any }>(
const snapshot = await adminDb `SELECT data FROM fs_knowledge_items WHERE project_id = $1 ORDER BY created_at DESC LIMIT 20`,
.collection('knowledge_items') [projectId]
.where('projectId', '==', projectId) );
.orderBy('createdAt', 'desc')
.limit(20)
.get();
const totalCount = snapshot.size;
const bySourceType: Record<string, number> = {}; const bySourceType: Record<string, number> = {};
const recentTitles: string[] = []; const recentTitles: string[] = [];
snapshot.docs.forEach((doc) => { for (const row of rows) {
const data = doc.data(); const d = row.data ?? {};
const sourceType = data.sourceType ?? 'unknown'; const sourceType = d.sourceType ?? 'unknown';
bySourceType[sourceType] = (bySourceType[sourceType] ?? 0) + 1; bySourceType[sourceType] = (bySourceType[sourceType] ?? 0) + 1;
if (d.title && recentTitles.length < 5) recentTitles.push(d.title);
}
if (data.title && recentTitles.length < 5) { return { totalCount: rows.length, bySourceType, recentTitles };
recentTitles.push(data.title); } catch {
} // Table may not exist for older deployments — return empty
});
return { totalCount, bySourceType, recentTitles };
} catch (error) {
console.error('[Chat Mode Resolver] Failed to summarize knowledge:', error);
return { totalCount: 0, bySourceType: {}, recentTitles: [] }; return { totalCount: 0, bySourceType: {}, recentTitles: [] };
} }
} }
/** /**
* Get a summary of chat_extractions for context building * Summarise extractions for context building.
* Returns empty defaults — extractions not yet migrated to Postgres.
*/ */
export async function summarizeExtractions( export async function summarizeExtractions(projectId: string): Promise<{
projectId: string
): Promise<{
totalCount: number; totalCount: number;
avgConfidence: number; avgConfidence: number;
avgCompletion: number; avgCompletion: number;
}> { }> {
try { return { totalCount: 0, avgConfidence: 0, avgCompletion: 0 };
const adminDb = getAdminDb();
const snapshot = await adminDb
.collection('chat_extractions')
.where('projectId', '==', projectId)
.get();
if (snapshot.empty) {
return { totalCount: 0, avgConfidence: 0, avgCompletion: 0 };
}
let sumConfidence = 0;
let sumCompletion = 0;
let count = 0;
snapshot.docs.forEach((doc) => {
const data = doc.data();
sumConfidence += data.overallConfidence ?? 0;
sumCompletion += data.overallCompletion ?? 0;
count++;
});
return {
totalCount: count,
avgConfidence: count > 0 ? sumConfidence / count : 0,
avgCompletion: count > 0 ? sumCompletion / count : 0,
};
} catch (error) {
console.error('[Chat Mode Resolver] Failed to summarize extractions:', error);
return { totalCount: 0, avgConfidence: 0, avgCompletion: 0 };
}
} }