@minnai/create-aura-app 0.0.12 → 0.0.15

package/templates/starter/src/src/components/TourGuide/useTourEngine.ts

@@ -1,376 +0,0 @@
-import { useState, useEffect, useRef, useCallback } from 'react';
-import { flux } from '@minnai/aura/flux/index';
-
-// Types for tour flow
-interface TourCommand {
-    say?: string;
-    spawn?: string;
-    props?: any;
-    wait?: string;
-    match?: string | string[];
-    air?: string;
-    onError?: string;
-    do?: string;
-    label?: string;
-    goto?: string;
-}
-
-interface TourStep {
-    step: string;
-    run: TourCommand[];
-}
-
-interface TourFlow {
-    name: string;
-    projectId: string;
-    steps: TourStep[];
-}
-
-interface TourState {
-    currentStep: string;
-    commandIndex: number;
-    waiting: boolean;
-}
-
-export function useTourEngine(flow: TourFlow, projectId: string) {
-    const [state, setState] = useState<TourState>({
-        currentStep: 'IDLE',
-        commandIndex: 0,
-        waiting: false
-    });
-
-    const initialized = useRef(false);
-    const timers = useRef<any[]>([]);
-
-    // Initialize from saved metadata
-    useEffect(() => {
-        if (projectId !== flow.projectId) {
-            setState(s => ({ ...s, currentStep: 'DONE' }));
-            return;
-        }
-
-        const unsubscribe = flux.subscribe((action: any) => {
-            if (action.type === 'METADATA_LOADED' && !initialized.current) {
-                const saved = action.payload.tourState as TourState;
-                console.log('[TourEngine] Restored:', saved || 'Starting fresh');
-                if (saved && saved.currentStep !== 'DONE') {
-                    setState(saved);
-                } else {
-                    setState({ currentStep: 'INIT', commandIndex: 0, waiting: false });
-                }
-                initialized.current = true;
-            }
-        });
-
-        // Fail-safe
-        const timer = setTimeout(() => {
-            if (!initialized.current) {
-                console.log('[TourEngine] No metadata, starting fresh');
-                setState({ currentStep: 'INIT', commandIndex: 0, waiting: false });
-                initialized.current = true;
-            }
-        }, 1500);
-
-        return () => {
-            unsubscribe();
-            clearTimeout(timer);
-        };
-    }, [projectId, flow.projectId]);
-
-    // Persist state
-    useEffect(() => {
-        if (state.currentStep !== 'IDLE' && state.currentStep !== 'DONE') {
-            flux.dispatch({
-                type: 'SYNC_METADATA',
-                payload: { tourState: state },
-                to: 'controller'
-            });
-        }
-    }, [state]);
-
-    // Say helper
-    const say = useCallback(async (text: string) => {
-        flux.dispatch({
-            type: 'SAY',
-            payload: { text, role: 'assistant' },
-            to: 'all'
-        });
-        const wordCount = text.split(/\s+/).length;
-        const delay = wordCount * 333 + 666;
-        await new Promise(resolve => {
-            const timer = setTimeout(resolve, delay);
-            timers.current.push(timer);
-        });
-    }, []);
-
-    // Execute a single command
-    const executeCommand = useCallback(async (cmd: TourCommand): Promise<string | null> => {
-        if (cmd.say) {
-            await say(cmd.say);
-            return null;
-        }
-
-        if (cmd.spawn) {
-            flux.dispatch({
-                type: 'ADD_CHAT_MESSAGE',
-                payload: {
-                    role: 'assistant',
-                    content: '',
-                    attachment: { id: cmd.spawn, props: cmd.props || {} }
-                },
-                to: 'all'
-            });
-            return null;
-        }
-
-        if (cmd.do === 'toggle_task') {
-            flux.dispatch({
-                type: 'TOGGLE_TASK',
-                payload: { label: cmd.label, completed: true },
-                to: 'all'
-            });
-            return null;
-        }
-
-        if (cmd.do === 'confetti') {
-            flux.dispatch({ type: 'SHOW_CONFETTI', payload: {}, to: 'tasks-air' });
-            return null;
-        }
-
-        if (cmd.goto) {
-            return cmd.goto;
-        }
-
-        if (cmd.wait) {
-            // Return signal to wait
-            return 'WAIT';
-        }
-
-        return null;
-    }, [say]);
-
-    // Run current step
-    useEffect(() => {
-        if (state.currentStep === 'IDLE' || state.currentStep === 'DONE' || state.waiting) {
-            return;
-        }
-
-        const step = flow.steps.find(s => s.step === state.currentStep);
-        if (!step) {
-            console.error('[TourEngine] Step not found:', state.currentStep);
-            return;
-        }
-
-        let cancelled = false;
-
-        const runCommands = async () => {
-            let i = state.commandIndex;
-
-            while (i < step.run.length && !cancelled) {
-                const cmd = step.run[i];
-
-                // Handle wait commands - need to pause and listen
-                if (cmd.wait) {
-                    setState(s => ({ ...s, commandIndex: i, waiting: true }));
-                    return; // Stop execution, wait for event
-                }
-
-                const result = await executeCommand(cmd);
-
-                if (result && result !== 'WAIT') {
-                    // goto command - switch step
-                    setState({ currentStep: result, commandIndex: 0, waiting: false });
-                    return;
-                }
-
-                i++;
-            }
-
-            // Reached end of step without goto
-            if (i >= step.run.length) {
-                setState(s => ({ ...s, currentStep: 'DONE' }));
-            }
-        };
-
-        runCommands();
-
-        return () => {
-            cancelled = true;
-            timers.current.forEach(t => clearTimeout(t));
-            timers.current = [];
-        };
-    }, [state.currentStep, state.commandIndex, state.waiting, flow, executeCommand]);
-
-    // Event listener for wait conditions
-    useEffect(() => {
-        if (!state.waiting) return;
-
-        const step = flow.steps.find(s => s.step === state.currentStep);
-        if (!step) return;
-
-        const cmd = step.run[state.commandIndex];
-        if (!cmd || !cmd.wait) return;
-
-        const unsubscribe = flux.subscribe((action: any) => {
-            let matched = false;
-            let errorStep: string | null = null;
-
-            // task_toggled - wait for TOGGLE_TASK or TASK_COMPLETED
-            if (cmd.wait === 'task_toggled') {
-                // Listen for the actual toggle/completion event
-                if (action.type === 'TOGGLE_TASK' || action.type === 'TASK_COMPLETED') {
-                    const label = action.payload?.label?.toLowerCase() ||
-                        action.payload?.taskLabel?.toLowerCase() || '';
-                    matched = label.includes((cmd.match as string)?.toLowerCase() || '');
-                }
-
-                // Also intercept CHAT_PROMPT and dispatch TOGGLE_TASK if intent matches
-                if (action.type === 'CHAT_PROMPT') {
-                    const text = action.payload?.text?.toLowerCase() || '';
-                    const matchStr = (cmd.match as string)?.toLowerCase() || '';
-                    const toggleIntents = ['complete', 'done', 'finish', 'check', 'mark', 'toggle'];
-                    const hasIntent = toggleIntents.some(i => text.includes(i));
-                    const hasMatch = matchStr.split(' ').some(word => text.includes(word));
-
-                    if (hasIntent && hasMatch) {
-                        console.log('[TourEngine] Intercepting chat for toggle:', cmd.match);
-                        // Dispatch TOGGLE_TASK - this will trigger TasksAIR which will dispatch TASK_COMPLETED
-                        queueMicrotask(() => {
-                            flux.dispatch({
-                                type: 'TOGGLE_TASK',
-                                payload: { label: cmd.match, completed: true },
-                                to: 'all'
-                            });
-                        });
-                    }
-                }
-
-                // Listen for explicit TASK_COMPLETED event
-                if (action.type === 'TASK_COMPLETED') {
-                    console.log('[TourEngine] TASK_COMPLETED received:', action.payload);
-                    const matchStr = (cmd.match as string)?.toLowerCase() || '';
-                    const matchIndex = parseInt(matchStr, 10);
-                    const isIndexMatch = !isNaN(matchIndex) && action.payload?.taskOrder === matchIndex;
-                    console.log('[TourEngine] Match logic - matchStr:', matchStr, 'matchIndex:', matchIndex, 'taskOrder:', action.payload?.taskOrder, 'isIndexMatch:', isIndexMatch);
-
-                    const label = action.payload?.taskLabel?.toLowerCase() || '';
-                    const isTextMatch = label.includes(matchStr);
-                    console.log('[TourEngine] Match logic - label:', label, 'isTextMatch:', isTextMatch);
-
-                    if (isIndexMatch || isTextMatch) {
-                        console.log('[TourEngine] Task completion matched!');
-                        matched = true;
-                    }
-                }
-
-                // Listen for state updates from tasks-air (fallback/verification)
-                if (action.type === 'UPDATE_STATE' && action.payload?.airId === 'tasks-air') {
-                    const tasks = action.payload?.tasks || [];
-                    const matchStr = (cmd.match as string)?.toLowerCase() || '';
-                    const matchIndex = parseInt(matchStr, 10);
-
-                    if (!isNaN(matchIndex)) {
-                        // Check by index
-                        if (tasks[matchIndex] && tasks[matchIndex].completed) {
-                            matched = true;
-                        }
-                    } else {
-                        // Check by label
-                        const targetTask = tasks.find((t: any) => t.label?.toLowerCase().includes(matchStr));
-                        if (targetTask && targetTask.completed) {
-                            matched = true;
-                        }
-                    }
-                }
-            }
-
-            // task_added - wait for ADD_TASK or TASK_ADDED
-            if (cmd.wait === 'task_added') {
-                if (action.type === 'ADD_TASK' || action.type === 'TASK_ADDED') {
-                    const label = action.payload?.label?.toLowerCase() || '';
-                    matched = label.includes((cmd.match as string)?.toLowerCase() || '');
-                }
-
-                // Intercept CHAT_PROMPT for add task intent
-                if (action.type === 'CHAT_PROMPT') {
-                    const text = action.payload?.text?.toLowerCase() || '';
-                    const addIntents = ['add task', 'add a task', 'create task', 'new task'];
-                    const hasIntent = addIntents.some(i => text.includes(i));
-
-                    if (hasIntent) {
-                        // Extract task label from text (after "add task:" or similar)
-                        const colonIdx = text.indexOf(':');
-                        const taskLabel = colonIdx > -1 ? text.substring(colonIdx + 1).trim() : text.replace(/add\s*(a\s*)?task\s*/i, '').trim();
-
-                        if (taskLabel) {
-                            console.log('[TourEngine] Intercepting chat for add task:', taskLabel);
-                            // Check if added task matches what we're waiting for
-                            if (taskLabel.includes((cmd.match as string)?.toLowerCase() || '')) {
-                                matched = true;
-                            }
-                        }
-                    }
-                }
-            }
-
-            // air_spawned - wait for AIR to appear in Space
-            if (cmd.wait === 'air_spawned') {
-                console.log('[TourEngine] Waiting for air_spawned:', cmd.air, 'Got action:', action.type);
-                const types = ['SPAWN_AIR', 'WINDOW_SPAWNED', 'ADD_WINDOW', 'ADD_CHAT_MESSAGE'];
-                if (types.includes(action.type)) {
-                    const p = action.payload;
-                    const ids = [p.id, p.manifestId, p.props?.id, p.attachment?.id].filter(Boolean);
-                    console.log('[TourEngine] Checking ids:', ids, 'for air:', cmd.air);
-                    matched = ids.some((id: string) => id.includes(cmd.air || ''));
-                    if (matched) console.log('[TourEngine] air_spawned matched!');
-                }
-                // Also check controller state response
-                if (action.type === 'CONTROLLER_STATE') {
-                    const windows = action.payload.windows || [];
-                    console.log('[TourEngine] Checking CONTROLLER_STATE windows:', windows);
-                    matched = windows.some((w: any) =>
-                        w.manifestId?.includes(cmd.air || '') || w.id?.includes(cmd.air || '')
-                    );
-                    if (matched) console.log('[TourEngine] air_spawned matched from CONTROLLER_STATE!');
-                }
-            }
-
-            // air_success - wait for UPDATE_STATE from specific AIR
-            if (cmd.wait === 'air_success') {
-                console.log('[TourEngine] Waiting for air_success:', cmd.air, 'Got action:', action.type, action.payload);
-                if (action.type === 'AIR_ERROR' && action.payload.airId?.includes(cmd.air || '')) {
-                    console.log('[TourEngine] AIR_ERROR detected, jumping to error step:', cmd.onError);
-                    errorStep = cmd.onError || null;
-                }
-                if (action.type === 'UPDATE_STATE' && action.payload.airId?.includes(cmd.air || '')) {
-                    console.log('[TourEngine] air_success matched!');
-                    matched = true;
-                }
-            }
-
-            if (errorStep) {
-                setState({ currentStep: errorStep, commandIndex: 0, waiting: false });
-            } else if (matched) {
-                setState(s => ({
-                    ...s,
-                    commandIndex: s.commandIndex + 1,
-                    waiting: false
-                }));
-            }
-        });
-
-        // For air_spawned, request controller state to check if already in space
-        // Also immediately check if it's already spawned by looking at recent actions
-        if (cmd.wait === 'air_spawned') {
-            flux.dispatch({ type: 'REQUEST_CONTROLLER_STATE', payload: {}, to: 'controller' });
-            // Give a small delay to ensure the air has time to mount and dispatch events
-            setTimeout(() => {
-                flux.dispatch({ type: 'REQUEST_CONTROLLER_STATE', payload: {}, to: 'controller' });
-            }, 300);
-        }
-
-        return unsubscribe;
-    }, [state.waiting, state.currentStep, state.commandIndex, flow]);
-
-    return state;
-}

package/templates/starter/src/src/index.css

@@ -1,68 +0,0 @@
-:root {
-  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
-  line-height: 1.5;
-  font-weight: 400;
-
-  color-scheme: light dark;
-  color: rgba(255, 255, 255, 0.87);
-  background-color: #242424;
-
-  font-synthesis: none;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-a {
-  font-weight: 500;
-  color: #646cff;
-  text-decoration: inherit;
-}
-a:hover {
-  color: #535bf2;
-}
-
-body {
-  margin: 0;
-  display: flex;
-  place-items: center;
-  min-width: 320px;
-  min-height: 100vh;
-}
-
-h1 {
-  font-size: 3.2em;
-  line-height: 1.1;
-}
-
-button {
-  border-radius: 8px;
-  border: 1px solid transparent;
-  padding: 0.6em 1.2em;
-  font-size: 1em;
-  font-weight: 500;
-  font-family: inherit;
-  background-color: #1a1a1a;
-  cursor: pointer;
-  transition: border-color 0.25s;
-}
-button:hover {
-  border-color: #646cff;
-}
-button:focus,
-button:focus-visible {
-  outline: 4px auto -webkit-focus-ring-color;
-}
-
-@media (prefers-color-scheme: light) {
-  :root {
-    color: #213547;
-    background-color: #ffffff;
-  }
-  a:hover {
-    color: #747bff;
-  }
-  button {
-    background-color: #f9f9f9;
-  }
-}

package/templates/starter/src/src/main.tsx

@@ -1,10 +0,0 @@
-import { StrictMode } from 'react'
-import { createRoot } from 'react-dom/client'
-import './index.css'
-import App from './App.tsx'
-
-createRoot(document.getElementById('root')!).render(
-  <StrictMode>
-    <App />
-  </StrictMode>,
-)

package/templates/starter/src/src/services/AnalyticsService.ts

@@ -1,181 +0,0 @@
-import { initializeApp } from "firebase/app";
-import { getAnalytics, logEvent as firebaseLogEvent, Analytics } from "firebase/analytics";
-import { getPerformance, trace, FirebasePerformance, PerformanceTrace } from "firebase/performance";
-import { flux } from '@minnai/aura/flux/index';
-
-// Community Firebase Config (fallback when user doesn't provide their own)
-const communityFirebaseConfig = {
-    apiKey: "AIzaSyBxP1CkhBFaHFDX9HcVQurcBDVzzFruc4k",
-    authDomain: "saga-9dd98.firebaseapp.com",
-    projectId: "saga-9dd98",
-    storageBucket: "saga-9dd98.firebasestorage.app",
-    messagingSenderId: "723636478082",
-    appId: "1:723636478082:web:68b2fa0eb2010706e2549b",
-    measurementId: "G-67DEXLGRDQ"
-};
-
-declare global {
-    interface Window {
-        __ANALYTICS_LOGS__: any[];
-    }
-}
-
-export class AnalyticsService {
-    private analytics: Analytics | null = null;
-    private performance: FirebasePerformance | null = null;
-    private currentTrace: PerformanceTrace | null = null;
-    private ttvTrace: PerformanceTrace | null = null;
-    private TTV_START_KEY = 'aura_ttv_start';
-
-    constructor(userConfig?: any) {
-        // 1. Try User Config (Environment Variables)
-        const envConfig = {
-            apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
-            authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
-            projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
-            appId: import.meta.env.VITE_FIREBASE_APP_ID,
-            measurementId: import.meta.env.VITE_FIREBASE_MEASUREMENT_ID
-        };
-
-        const configToUse = (envConfig.apiKey) ? envConfig : (userConfig || communityFirebaseConfig);
-
-        try {
-            if (configToUse.apiKey && !configToUse.apiKey.includes("Dummy")) {
-                const app = initializeApp(configToUse);
-                this.analytics = getAnalytics(app);
-                this.performance = getPerformance(app);
-                console.log("[Analytics] Service Initialized (" + (envConfig.apiKey ? "User" : "Community") + ")");
-            } else {
-                console.log("[Analytics] No valid config found. Telemetry disabled.");
-            }
-
-            // Always setup listeners for local debugging/TTV, or if analytics is active
-            if (this.analytics || import.meta.env.DEV) {
-                this.setupListeners();
-            }
-        } catch (e) {
-            console.warn("[Analytics] Initialization failed", e);
-        }
-    }
-
-    private setupListeners() {
-        // Listen to Aura Signals via Flux
-        flux.subscribe((msg: any) => {
-            // 1. Trace Generation Latency
-            if (msg.type === 'CHAT_PROMPT') {
-                // Stop existing if any (user spammed send)
-                this.stopTrace(this.currentTrace);
-                this.currentTrace = this.startTrace('air_generation_latency');
-            }
-
-            // 2. Stop Trace on AIR Spawn (Success)
-            if (msg.type === 'SPAWN_AIR' || msg.type === 'WINDOW_SPAWNED') {
-                this.log('air_generated', {
-                    air_type: msg.payload.id || msg.payload.manifestId,
-                    success: true
-                });
-
-                // Stop Generation Trace
-                if (this.currentTrace) {
-                    this.currentTrace.putAttribute('air_id', msg.payload.id || msg.payload.manifestId || 'unknown');
-                    this.stopTrace(this.currentTrace);
-                    this.currentTrace = null;
-                }
-
-                this.completeTTVTimer();
-            }
-            // We can add more listeners here (e.g. Errors)
-        });
-    }
-
-    public log(eventName: string, params?: any) {
-        // Log to local global array for verification
-        if (!window.__ANALYTICS_LOGS__) {
-            window.__ANALYTICS_LOGS__ = [];
-        }
-        window.__ANALYTICS_LOGS__.push({ event: eventName, params, timestamp: Date.now() });
-
-        // Always log in DEV mode for visibility, even if Analytics is disabled/misconfigured
-        if (import.meta.env.DEV) {
-            console.log(`[Analytics] ${this.analytics ? 'Sent' : 'Skipped (No Key)'}: ${eventName}`, params);
-        }
-
-        if (this.analytics) {
-            try {
-                firebaseLogEvent(this.analytics, eventName, params);
-            } catch (e) {
-                // Ignore send errors
-            }
-        }
-    }
-
-    public startTrace(name: string): PerformanceTrace | null {
-        if (this.performance) {
-            const t = trace(this.performance, name);
-            t.start();
-            if (import.meta.env.DEV) {
-                console.log(`[Analytics] Trace Started: ${name}`);
-            }
-            return t;
-        }
-        return null;
-    }
-
-    public stopTrace(t: PerformanceTrace | null) {
-        if (t) {
-            t.stop();
-            if (import.meta.env.DEV) {
-                console.log(`[Analytics] Trace Stopped: ${t.getAttribute('name') || 'unknown'}`);
-            }
-        }
-    }
-
-    public startTTVTimer() {
-        if (!sessionStorage.getItem(this.TTV_START_KEY)) {
-            const now = Date.now();
-            sessionStorage.setItem(this.TTV_START_KEY, now.toString());
-            console.log('[Analytics] TTV Timer Started at', now);
-
-            // Start Trace for TTV
-            this.ttvTrace = this.startTrace('time_to_value_trace');
-        }
-    }
-
-    public completeTTVTimer() {
-        const startStr = sessionStorage.getItem(this.TTV_START_KEY);
-        if (startStr) {
-            const start = parseInt(startStr, 10);
-            const end = Date.now();
-            const duration = end - start;
-
-            this.log('time_to_value', { duration_ms: duration, duration_sec: duration / 1000 });
-            console.log(`[Analytics] TTV Complete: ${duration}ms`);
-
-            // Stop Trace for TTV
-            if (this.ttvTrace) {
-                this.ttvTrace.putAttribute('duration_sec', (duration / 1000).toString());
-                this.stopTrace(this.ttvTrace);
-                this.ttvTrace = null;
-            }
-
-            // Clear so we only track first time to value per session/refresh logic if desired
-            // For now, let's keep it to allow multiple measurements or clear it? 
-            // Usually TTV is once per session.
-            sessionStorage.removeItem(this.TTV_START_KEY);
-        }
-    }
-
-    public logLogin(method: string) {
-        this.log('login', { method });
-    }
-
-    public logSignup(method: string) {
-        this.log('sign_up', { method });
-    }
-
-    public logPageView(page_path: string) {
-        this.log('page_view', { page_path });
-    }
-}
-
-export const analyticsService = new AnalyticsService();

package/templates/starter/src/src/types/ContextHandler.ts

@@ -1,13 +0,0 @@
-export interface ContextHandler {
-    /**
-     * Returns the current context/state of the AIR.
-     * This is used by the Intent Planner to understand what the user is looking at.
-     */
-    getContext(): Promise<any>;
-
-    /**
-     * List of capabilities this AIR supports.
-     * e.g. ['text-editing', 'video-playback', 'market-data']
-     */
-    capabilities: string[];
-}