@almadar/cli 1.0.5 → 1.0.7

package/shells/typescript-shell/packages/client/src/evaluator/types/expression.ts

@@ -1,297 +0,0 @@
-/**
- * S-Expression Types
- *
- * Defines the S-Expression type system for guards, effects, and computed values.
- * S-expressions are JSON arrays where the first element is an operator string.
- *
- * @example
- * // Guard: health > 0
- * [">", "@entity.health", 0]
- *
- * // Effect: set x to x + vx
- * ["set", "@entity.x", ["+", "@entity.x", "@entity.vx"]]
- *
- * @packageDocumentation
- */
-
-import { z } from 'zod';
-
-// ============================================================================
-// S-Expression Type
-// ============================================================================
-
-/**
- * S-Expression type - recursive structure representing expressions.
- *
- * An S-expression is either:
- * - A literal value (string, number, boolean, null)
- * - An object literal (for payload data, props, etc.)
- * - A binding reference (string starting with @)
- * - A call expression (array with operator as first element)
- */
-export type SExprAtom = string | number | boolean | null | Record<string, unknown>;
-export type SExpr = SExprAtom | SExpr[];
-
-/**
- * Expression type - S-expressions only.
- * Used for guards, computed values, and effect expressions.
- *
- * NOTE: Legacy string format is no longer supported.
- * All expressions must be S-expression arrays.
- */
-export type Expression = SExpr;
-
-// ============================================================================
-// S-Expression Schema (Zod)
-// ============================================================================
-
-/**
- * Schema for atomic S-expression values (non-array)
- * Includes objects for payload data, props, etc.
- */
-export const SExprAtomSchema: z.ZodType<SExprAtom> = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.null(),
-  z.record(z.unknown()), // Objects for payload data
-]);
-
-/**
- * Recursive schema for S-expressions.
- * Validates that arrays have at least one element and first element is a string (operator).
- */
-export const SExprSchema: z.ZodType<SExpr> = z.lazy(() =>
-  z.union([
-    SExprAtomSchema,
-    z
-      .array(z.lazy(() => SExprSchema))
-      .min(1)
-      .refine(
-        (arr) => typeof arr[0] === 'string',
-        { message: 'S-expression array must have a string operator as first element' }
-      ),
-  ])
-);
-
-/**
- * Schema for Expression type - S-expressions only.
- * S-expressions are arrays with operator as first element.
- *
- * NOTE: Legacy string format is no longer supported.
- */
-export const ExpressionSchema: z.ZodType<Expression> = SExprSchema;
-
-// ============================================================================
-// Type Guards
-// ============================================================================
-
-/**
- * Type guard for S-expression detection.
- * 100% reliable - structural check, no regex or keyword matching.
- *
- * @param value - Value to check
- * @returns true if value is an S-expression (array with string operator)
- */
-export function isSExpr(value: unknown): value is SExpr[] {
-  return (
-    Array.isArray(value) &&
-    value.length > 0 &&
-    typeof value[0] === 'string'
-  );
-}
-
-/**
- * Type guard for S-expression atoms (non-array values).
- * Includes objects (for payload data, props, etc.)
- */
-export function isSExprAtom(value: unknown): value is SExprAtom {
-  if (value === null) return true;
-  if (Array.isArray(value)) return false;
-  const type = typeof value;
-  return type === 'string' || type === 'number' || type === 'boolean' || type === 'object';
-}
-
-/**
- * Check if a value is a binding reference.
- * Bindings start with @ (e.g., @entity.health, @payload.amount, @now)
- */
-export function isBinding(value: unknown): value is string {
-  return typeof value === 'string' && value.startsWith('@');
-}
-
-/**
- * Check if a value is a valid S-expression call (array with operator).
- * Use this to distinguish between S-expression calls and atom values.
- */
-export function isSExprCall(value: unknown): value is SExpr[] {
-  return isSExpr(value);
-}
-
-// ============================================================================
-// Binding Parsing
-// ============================================================================
-
-/**
- * Parsed binding reference
- */
-export interface ParsedBinding {
-  /** Type of binding: core (@entity, @payload, @state, @now) or entity (@EntityName) */
-  type: 'core' | 'entity';
-  /** The root binding name (entity, payload, state, now, or EntityName) */
-  root: string;
-  /** Path segments after the root (e.g., ['health'] for @entity.health) */
-  path: string[];
-  /** Full original binding string */
-  original: string;
-}
-
-/**
- * Core bindings that are always available.
- * Phase 4.5 adds: config, computed, trait (for behavior support)
- */
-export const CORE_BINDINGS = ['entity', 'payload', 'state', 'now', 'config', 'computed', 'trait'] as const;
-export type CoreBinding = (typeof CORE_BINDINGS)[number];
-
-/**
- * Parse a binding reference into its components.
- * Does NOT use regex - uses structured string operations.
- *
- * @param binding - Binding string starting with @
- * @returns Parsed binding object or null if invalid
- */
-export function parseBinding(binding: string): ParsedBinding | null {
-  if (!binding.startsWith('@')) {
-    return null;
-  }
-
-  // Remove @ prefix
-  const withoutPrefix = binding.slice(1);
-
-  // Split by dots
-  const parts = withoutPrefix.split('.');
-
-  if (parts.length === 0 || parts[0] === '') {
-    return null;
-  }
-
-  const root = parts[0];
-  const path = parts.slice(1);
-
-  // Determine if core binding or entity reference
-  const isCore = (CORE_BINDINGS as readonly string[]).includes(root);
-
-  return {
-    type: isCore ? 'core' : 'entity',
-    root,
-    path,
-    original: binding,
-  };
-}
-
-/**
- * Validate a binding reference format.
- *
- * @param binding - Binding string to validate
- * @returns true if valid binding format
- */
-export function isValidBinding(binding: string): boolean {
-  const parsed = parseBinding(binding);
-  if (!parsed) return false;
-
-  // Core bindings: @entity, @payload, @state, @now (optionally with path)
-  // @state and @now don't have paths
-  if (parsed.type === 'core') {
-    if (parsed.root === 'state' || parsed.root === 'now') {
-      return parsed.path.length === 0;
-    }
-    // @entity and @payload can have paths
-    return true;
-  }
-
-  // Entity bindings: @EntityName.field - must have at least one path segment
-  return parsed.path.length > 0;
-}
-
-// ============================================================================
-// S-Expression Utilities
-// ============================================================================
-
-/**
- * Get the operator from an S-expression call.
- *
- * @param expr - S-expression array
- * @returns The operator string or null if not a valid call
- */
-export function getOperator(expr: SExpr): string | null {
-  if (!isSExpr(expr)) return null;
-  return expr[0] as string;
-}
-
-/**
- * Get the arguments from an S-expression call.
- *
- * @param expr - S-expression array
- * @returns Array of arguments (empty if not a valid call)
- */
-export function getArgs(expr: SExpr): SExpr[] {
-  if (!isSExpr(expr)) return [];
-  return expr.slice(1);
-}
-
-/**
- * Create an S-expression call.
- *
- * @param operator - The operator string
- * @param args - Arguments to the operator
- * @returns S-expression array
- */
-export function sexpr(operator: string, ...args: SExpr[]): SExpr[] {
-  return [operator, ...args];
-}
-
-/**
- * Walk an S-expression tree and apply a visitor function to each node.
- *
- * @param expr - S-expression to walk
- * @param visitor - Function to call on each node
- */
-export function walkSExpr(
-  expr: SExpr,
-  visitor: (node: SExpr, parent: SExpr[] | null, index: number) => void,
-  parent: SExpr[] | null = null,
-  index: number = 0
-): void {
-  visitor(expr, parent, index);
-
-  if (isSExpr(expr)) {
-    for (let i = 0; i < expr.length; i++) {
-      walkSExpr(expr[i], visitor, expr, i);
-    }
-  }
-}
-
-/**
- * Collect all bindings referenced in an S-expression.
- *
- * @param expr - S-expression to analyze
- * @returns Array of binding strings found
- */
-export function collectBindings(expr: SExpr): string[] {
-  const bindings: string[] = [];
-
-  walkSExpr(expr, (node) => {
-    if (isBinding(node)) {
-      bindings.push(node);
-    }
-  });
-
-  return bindings;
-}
-
-// ============================================================================
-// Type Exports
-// ============================================================================
-
-export type SExprInput = z.input<typeof SExprSchema>;
-export type ExpressionInput = z.input<typeof ExpressionSchema>;

package/shells/typescript-shell/packages/client/src/features/auth/AuthContext.tsx

@@ -1,192 +0,0 @@
-import React, { createContext, useContext, useEffect, useState } from 'react';
-import { User } from 'firebase/auth';
-import { auth, isPreviewMode } from '../../config/firebase';
-import { authService } from './authService';
-import { AuthContextType } from './types';
-
-const AuthContext = createContext<AuthContextType | undefined>(undefined);
-
-export const useAuthContext = () => {
-  const context = useContext(AuthContext);
-  if (context === undefined) {
-    throw new Error('useAuthContext must be used within an AuthProvider');
-  }
-  return context;
-};
-
-interface AuthProviderProps {
-  children: React.ReactNode;
-}
-
-// Mock user for preview mode
-const PREVIEW_USER = {
-  uid: 'preview-user',
-  email: 'preview@example.com',
-  displayName: 'Preview User',
-  photoURL: null,
-  emailVerified: true,
-  isAnonymous: false,
-} as unknown as User;
-
-export const AuthProvider: React.FC<AuthProviderProps> = ({ children }) => {
-  // In preview mode, use mock user; otherwise null until Firebase auth loads
-  const [user, setUserState] = useState<User | null>(isPreviewMode ? PREVIEW_USER : null);
-  const [loading, setLoading] = useState(!isPreviewMode);
-  const [error, setError] = useState<string | null>(null);
-  const [onAuthSuccess, setOnAuthSuccess] = useState<(() => void) | undefined>(undefined);
-
-  useEffect(() => {
-    // Skip Firebase auth listener in preview mode
-    if (isPreviewMode || !auth) {
-      setLoading(false);
-      return;
-    }
-
-    const unsubscribe = auth.onAuthStateChanged((user) => {
-      setUserState(user);
-      setLoading(false);
-
-      // Call the auth success callback if it exists
-      if (user && onAuthSuccess) {
-        onAuthSuccess();
-      }
-    });
-
-    return () => unsubscribe();
-  }, [onAuthSuccess]);
-
-  const clearError = () => setError(null);
-
-  const signInWithGoogle = async () => {
-    // In preview mode, auth methods are no-ops (user is already set)
-    if (isPreviewMode) {
-      console.info('Preview mode: signInWithGoogle skipped');
-      return;
-    }
-    try {
-      setLoading(true);
-      clearError();
-      await authService.signInWithGoogle();
-    } catch (err: unknown) {
-      setLoading(false);
-      const error = err as { code?: string; message?: string };
-      const isUserCancellation = error.code === 'auth/popup-closed-by-user' ||
-                                  error.code === 'auth/cancelled-popup-request' ||
-                                  error.code === 'auth/popup-blocked';
-      if (!isUserCancellation) {
-        setError(error.message || 'Sign in failed');
-      } else {
-        clearError();
-      }
-    }
-  };
-
-  const signInWithEmail = async (email: string, password: string) => {
-    if (isPreviewMode) {
-      console.info('Preview mode: signInWithEmail skipped');
-      return;
-    }
-    try {
-      setLoading(true);
-      clearError();
-      await authService.signInWithEmail(email, password);
-    } catch (err: unknown) {
-      setLoading(false);
-      const error = err as { message?: string };
-      setError(error.message || 'Sign in failed');
-    }
-  };
-
-  const signUpWithEmail = async (email: string, password: string, displayName?: string) => {
-    if (isPreviewMode) {
-      console.info('Preview mode: signUpWithEmail skipped');
-      return;
-    }
-    try {
-      setLoading(true);
-      clearError();
-      await authService.signUpWithEmail(email, password, displayName);
-    } catch (err: unknown) {
-      setLoading(false);
-      const error = err as { message?: string };
-      setError(error.message || 'Sign up failed');
-    }
-  };
-
-  const sendSignInLinkToEmail = async (email: string) => {
-    if (isPreviewMode) {
-      console.info('Preview mode: sendSignInLinkToEmail skipped');
-      return;
-    }
-    try {
-      setLoading(true);
-      clearError();
-      const actionCodeSettings = {
-        url: `${window.location.origin}/login`,
-        handleCodeInApp: true,
-      };
-      await authService.sendSignInLinkToEmail(email, actionCodeSettings);
-      setLoading(false);
-    } catch (err: unknown) {
-      setLoading(false);
-      const error = err as { message?: string };
-      setError(error.message || 'Failed to send sign-in link');
-    }
-  };
-
-  const signInWithEmailLink = async (email: string, emailLink: string) => {
-    if (isPreviewMode) {
-      console.info('Preview mode: signInWithEmailLink skipped');
-      return;
-    }
-    try {
-      setLoading(true);
-      clearError();
-      await authService.signInWithEmailLink(email, emailLink);
-    } catch (err: unknown) {
-      setLoading(false);
-      const error = err as { message?: string };
-      setError(error.message || 'Sign in failed');
-    }
-  };
-
-  const isSignInWithEmailLink = (emailLink: string): boolean => {
-    if (isPreviewMode) return false;
-    return authService.isSignInWithEmailLink(emailLink);
-  };
-
-  const signOut = async () => {
-    if (isPreviewMode) {
-      console.info('Preview mode: signOut skipped');
-      return;
-    }
-    try {
-      setLoading(true);
-      await authService.signOut();
-      setUserState(null);
-      setLoading(false);
-    } catch (err: unknown) {
-      setLoading(false);
-      const error = err as { message?: string };
-      setError(error.message || 'Sign out failed');
-    }
-  };
-
-  const value: AuthContextType = {
-    user,
-    loading,
-    error,
-    isPreviewMode,
-    signInWithGoogle,
-    signOut,
-    signInWithEmail,
-    signUpWithEmail,
-    sendSignInLinkToEmail,
-    signInWithEmailLink,
-    isSignInWithEmailLink,
-    onAuthSuccess,
-    setOnAuthSuccess,
-  };
-
-  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
-};

package/shells/typescript-shell/packages/client/src/features/auth/authService.ts

@@ -1,90 +0,0 @@
-import {
-  signInWithPopup,
-  GoogleAuthProvider,
-  signInWithEmailAndPassword,
-  createUserWithEmailAndPassword,
-  updateProfile,
-  signOut as firebaseSignOut,
-  sendSignInLinkToEmail as firebaseSendSignInLinkToEmail,
-  isSignInWithEmailLink as firebaseIsSignInWithEmailLink,
-  signInWithEmailLink as firebaseSignInWithEmailLink,
-  ActionCodeSettings,
-} from 'firebase/auth';
-import { auth, isPreviewMode } from '../../config/firebase';
-
-const googleProvider = new GoogleAuthProvider();
-
-/**
- * Auth service - provides authentication methods.
- * In preview mode (no Firebase config), these methods are no-ops.
- */
-export const authService = {
-  // Google Sign In
-  signInWithGoogle: async () => {
-    if (isPreviewMode || !auth) {
-      console.info('Preview mode: signInWithGoogle is disabled');
-      return null;
-    }
-    const result = await signInWithPopup(auth, googleProvider);
-    return result.user;
-  },
-
-  // Email/Password Sign In
-  signInWithEmail: async (email: string, password: string) => {
-    if (isPreviewMode || !auth) {
-      console.info('Preview mode: signInWithEmail is disabled');
-      return null;
-    }
-    const result = await signInWithEmailAndPassword(auth, email, password);
-    return result.user;
-  },
-
-  // Email/Password Sign Up
-  signUpWithEmail: async (email: string, password: string, displayName?: string) => {
-    if (isPreviewMode || !auth) {
-      console.info('Preview mode: signUpWithEmail is disabled');
-      return null;
-    }
-    const result = await createUserWithEmailAndPassword(auth, email, password);
-
-    if (displayName) {
-      await updateProfile(result.user, { displayName });
-    }
-
-    return result.user;
-  },
-
-  // Sign Out
-  signOut: async () => {
-    if (isPreviewMode || !auth) {
-      console.info('Preview mode: signOut is disabled');
-      return;
-    }
-    await firebaseSignOut(auth);
-  },
-
-  // Email Link Authentication
-  sendSignInLinkToEmail: async (email: string, actionCodeSettings: ActionCodeSettings) => {
-    if (isPreviewMode || !auth) {
-      console.info('Preview mode: sendSignInLinkToEmail is disabled');
-      return;
-    }
-    await firebaseSendSignInLinkToEmail(auth, email, actionCodeSettings);
-  },
-
-  isSignInWithEmailLink: (emailLink: string): boolean => {
-    if (isPreviewMode || !auth) {
-      return false;
-    }
-    return firebaseIsSignInWithEmailLink(auth, emailLink);
-  },
-
-  signInWithEmailLink: async (email: string, emailLink: string) => {
-    if (isPreviewMode || !auth) {
-      console.info('Preview mode: signInWithEmailLink is disabled');
-      return null;
-    }
-    const result = await firebaseSignInWithEmailLink(auth, email, emailLink);
-    return result.user;
-  },
-};