@allternit/gizzi-code 1.0.0 → 1.0.1

package/src/bootstrap/state.ts

@@ -1,371 +1,214 @@
 /**
- * @fileoverview Bootstrap state management for gizzi-code integration
- * @module bootstrap/state
- *
- * Manages application initialization state, loading phases, and bootstrap
- * lifecycle events. Provides centralized state tracking during application startup.
+ * Bootstrap state management
+ * Core application state and signals
  */
 
-import type { TypedMessage } from '../types/message';
+import { createSignal, type Signal } from '../runtime/util/signal.js'
+import { log } from '../runtime/util/log.js'
 
-/**
- * Loading phase identifiers for the bootstrap process
- * @typedef {'idle' | 'initializing' | 'loading_config' | 'connecting' | 'authenticating' | 'ready' | 'error'} LoadingPhase
- */
-export type LoadingPhase =
-  | 'idle'
-  | 'initializing'
-  | 'loading_config'
-  | 'connecting'
-  | 'authenticating'
-  | 'ready'
-  | 'error';
-
-/**
- * Valid loading phase transitions
- * @constant {Record<LoadingPhase, readonly LoadingPhase[]>}
- */
-export const VALID_PHASE_TRANSITIONS: Readonly<Record<LoadingPhase, readonly LoadingPhase[]>> = {
-  idle: ['initializing'],
-  initializing: ['loading_config', 'error'],
-  loading_config: ['connecting', 'error'],
-  connecting: ['authenticating', 'error'],
-  authenticating: ['ready', 'error'],
-  ready: ['idle', 'initializing'],
-  error: ['idle', 'initializing'],
-} as const;
-
-/**
- * Bootstrap error structure
- * @interface BootstrapError
- */
-export interface BootstrapError {
-  /** Error code for programmatic handling */
-  readonly code: string;
-
-  /** Human-readable error message */
-  readonly message: string;
-
-  /** Error timestamp */
-  readonly timestamp: Date;
-
-  /** Optional error details or stack trace */
-  readonly details?: string;
-
-  /** Phase where the error occurred */
-  readonly phase: LoadingPhase;
+// Model settings
+export interface ModelSetting {
+  model: string
+  provider: string
+  temperature?: number
+  maxTokens?: number
 }
 
-/**
- * Bootstrap state interface tracking initialization progress
- * @interface BootstrapState
- */
-export interface BootstrapState {
-  /** Current loading phase */
-  readonly phase: LoadingPhase;
+export type SessionId = string & { readonly __brand: 'SessionId' }
 
-  /** Overall progress percentage (0-100) */
-  readonly progress: number;
-
-  /** Whether the application has completed bootstrap */
-  readonly isComplete: boolean;
-
-  /** Whether an error has occurred during bootstrap */
-  readonly hasError: boolean;
-
-  /** Current error if any */
-  readonly error: BootstrapError | null;
+// Session management
+interface SessionState {
+  id: SessionId
+  createdAt: Date
+  lastActiveAt: Date
+  modelSetting: ModelSetting
+}
 
-  /** Timestamp when bootstrap started */
-  readonly startTime: Date | null;
+// Global bootstrap state
+let currentSession: SessionState | null = null
+const slowOperations: { description: string; duration: number; timestamp: Date }[] = []
+
+// Signals for reactive state
+const sessionSignal = createSignal<SessionState | null>(null)
+const modelSettingSignal = createSignal<ModelSetting | null>(null)
+
+// Session management
+export function createSession(modelSetting: ModelSetting): SessionId {
+  const id = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 11)}` as SessionId
+  const session: SessionState = {
+    id,
+    createdAt: new Date(),
+    lastActiveAt: new Date(),
+    modelSetting,
+  }
+  
+  currentSession = session
+  sessionSignal.set(session)
+  modelSettingSignal.set(modelSetting)
+  
+  log('info', 'Session created', { sessionId: id, model: modelSetting.model })
+  return id
+}
 
-  /** Timestamp when bootstrap completed */
-  readonly endTime: Date | null;
+export function getCurrentSession(): SessionState | null {
+  return currentSession
+}
 
-  /** Messages collected during initialization */
-  readonly messages: readonly TypedMessage[];
+export function getSessionId(): SessionId | null {
+  return currentSession?.id || null
+}
 
-  /** Configuration data loaded during bootstrap */
-  readonly config: Readonly<Record<string, unknown>>;
+export function setSessionId(id: SessionId): void {
+  if (currentSession) {
+    currentSession.id = id
+    sessionSignal.set(currentSession)
+  }
+}
 
-  /** Services initialized during bootstrap */
-  readonly services: readonly string[];
+export function updateSessionActivity(): void {
+  if (currentSession) {
+    currentSession.lastActiveAt = new Date()
+    sessionSignal.set(currentSession)
+  }
 }
 
-/**
- * Initial bootstrap state
- * @constant {BootstrapState}
- */
-const INITIAL_STATE: BootstrapState = {
-  phase: 'idle',
-  progress: 0,
-  isComplete: false,
-  hasError: false,
-  error: null,
-  startTime: null,
-  endTime: null,
-  messages: [],
-  config: {},
-  services: [],
-} as const;
+export function clearSession(): void {
+  currentSession = null
+  sessionSignal.set(null)
+  modelSettingSignal.set(null)
+  log('info', 'Session cleared')
+}
 
-/**
- * Listener callback type for state changes
- * @typedef {(state: BootstrapState) => void} StateChangeListener
- */
-type StateChangeListener = (state: BootstrapState) => void;
+// Model settings
+export function getModelSetting(): ModelSetting | null {
+  return currentSession?.modelSetting || modelSettingSignal.get()
+}
 
-// Module-level state (singleton pattern)
-let currentState: BootstrapState = { ...INITIAL_STATE };
-const listeners: Set<StateChangeListener> = new Set();
+export function setModelSetting(setting: ModelSetting): void {
+  if (currentSession) {
+    currentSession.modelSetting = setting
+    sessionSignal.set(currentSession)
+  }
+  modelSettingSignal.set(setting)
+}
 
-/**
- * Gets the current bootstrap state
- * @returns {Readonly<BootstrapState>} The current bootstrap state (immutable)
- * @example
- * ```typescript
- * const state = getBootstrapState();
- * if (state.phase === 'ready') {
- *   console.log('Application is ready');
- * }
- * ```
- */
-export function getBootstrapState(): Readonly<BootstrapState> {
-  return Object.freeze({ ...currentState });
+// Session subscriptions
+export function subscribeToSession(listener: (session: SessionState | null) => void): () => void {
+  return sessionSignal.subscribe(() => listener(sessionSignal.get()))
 }
 
-/**
- * Sets the bootstrap state with partial updates
- * Automatically notifies all registered listeners
- *
- * @param {Partial<BootstrapState>} updates - Partial state updates to apply
- * @returns {Readonly<BootstrapState>} The updated state
- * @throws {Error} If attempting an invalid phase transition
- * @example
- * ```typescript
- * setBootstrapState({ phase: 'initializing', progress: 10 });
- * ```
- */
-export function setBootstrapState(updates: Partial<BootstrapState>): Readonly<BootstrapState> {
-  // Validate phase transition if phase is being updated
-  if (updates.phase && updates.phase !== currentState.phase) {
-    if (!isValidPhaseTransition(currentState.phase, updates.phase)) {
-      throw new Error(
-        `Invalid phase transition from '${currentState.phase}' to '${updates.phase}'. ` +
-          `Valid transitions: ${VALID_PHASE_TRANSITIONS[currentState.phase].join(', ')}`
-      );
-    }
-  }
+export function subscribeToModelSetting(listener: (setting: ModelSetting | null) => void): () => void {
+  return modelSettingSignal.subscribe(() => listener(modelSettingSignal.get()))
+}
 
-  // Create new state with updates
-  const previousState = currentState;
-  currentState = {
-    ...currentState,
-    ...updates,
-    // Merge nested objects carefully
-    config: updates.config ? { ...currentState.config, ...updates.config } : currentState.config,
-    messages: updates.messages ?? currentState.messages,
-    services: updates.services ?? currentState.services,
-  };
-
-  // Update computed fields
-  currentState = {
-    ...currentState,
-    isComplete: currentState.phase === 'ready',
-    hasError: currentState.phase === 'error' || currentState.error !== null,
-  };
-
-  // Notify listeners (async to avoid blocking)
-  queueMicrotask(() => {
-    listeners.forEach((listener) => {
-      try {
-        listener(currentState);
-      } catch (error) {
-        console.error('Bootstrap state listener error:', error);
-      }
-    });
-  });
-
-  // Log state change in development
-  if (process.env.NODE_ENV === 'development') {
-    console.debug('[BootstrapState]', previousState.phase, '->', currentState.phase);
+// Slow operation tracking
+export function addSlowOperation(description: string, duration: number): void {
+  slowOperations.push({
+    description,
+    duration,
+    timestamp: new Date(),
+  })
+  
+  // Keep only recent operations
+  const cutoff = Date.now() - 5 * 60 * 1000 // 5 minutes
+  while (slowOperations.length > 0 && slowOperations[0].timestamp.getTime() < cutoff) {
+    slowOperations.shift()
   }
+  
+  log('warn', `Slow operation detected: ${description} (${duration.toFixed(1)}ms)`)
+}
 
-  return Object.freeze({ ...currentState });
+export function getSlowOperations(): typeof slowOperations {
+  return [...slowOperations]
 }
 
-/**
- * Subscribes to bootstrap state changes
- *
- * @param {StateChangeListener} listener - Callback function to invoke on state changes
- * @returns {() => void} Unsubscribe function
- * @example
- * ```typescript
- * const unsubscribe = subscribeToBootstrapState((state) => {
- *   console.log('Phase:', state.phase);
- * });
- * // Later: unsubscribe();
- * ```
- */
-export function subscribeToBootstrapState(listener: StateChangeListener): () => void {
-  listeners.add(listener);
+export function clearSlowOperations(): void {
+  slowOperations.length = 0
+}
 
-  // Immediately notify with current state
-  listener(currentState);
+// Working directory management
+let originalCwd = process.cwd()
+let kairosActive = false
+let isRemoteMode = false
 
-  return () => {
-    listeners.delete(listener);
-  };
+export function setOriginalCwd(cwd: string): void {
+  originalCwd = cwd
 }
 
-/**
- * Resets the bootstrap state to initial values
- * Useful for testing or re-initializing the application
- *
- * @param {boolean} [notifyListeners=true] - Whether to notify listeners of the reset
- * @returns {Readonly<BootstrapState>} The reset state
- */
-export function resetBootstrapState(notifyListeners = true): Readonly<BootstrapState> {
-  currentState = { ...INITIAL_STATE };
-
-  if (notifyListeners) {
-    queueMicrotask(() => {
-      listeners.forEach((listener) => {
-        try {
-          listener(currentState);
-        } catch (error) {
-          console.error('Bootstrap state listener error:', error);
-        }
-      });
-    });
-  }
-
-  return Object.freeze({ ...currentState });
+export function getOriginalCwd(): string {
+  return originalCwd
 }
 
-/**
- * Starts the bootstrap process
- * Sets phase to 'initializing' and records start time
- *
- * @returns {Readonly<BootstrapState>} The updated state
- */
-export function startBootstrap(): Readonly<BootstrapState> {
-  return setBootstrapState({
-    phase: 'initializing',
-    startTime: new Date(),
-    progress: 5,
-  });
+export function setKairosActive(active: boolean): void {
+  kairosActive = active
 }
 
-/**
- * Reports a bootstrap error
- * Sets phase to 'error' and records error details
- *
- * @param {string} code - Error code
- * @param {string} message - Error message
- * @param {string} [details] - Optional error details
- * @returns {Readonly<BootstrapState>} The updated state
- */
-export function setBootstrapError(
-  code: string,
-  message: string,
-  details?: string
-): Readonly<BootstrapState> {
-  const error: BootstrapError = {
-    code,
-    message,
-    timestamp: new Date(),
-    details,
-    phase: currentState.phase,
-  };
-
-  return setBootstrapState({
-    phase: 'error',
-    error,
-    endTime: new Date(),
-  });
+export function getKairosActive(): boolean {
+  return kairosActive
 }
 
-/**
- * Completes the bootstrap process
- * Sets phase to 'ready' and records completion time
- *
- * @returns {Readonly<BootstrapState>} The updated state
- */
-export function completeBootstrap(): Readonly<BootstrapState> {
-  return setBootstrapState({
-    phase: 'ready',
-    progress: 100,
-    endTime: new Date(),
-  });
+export function setIsRemoteMode(remote: boolean): void {
+  isRemoteMode = remote
 }
 
-/**
- * Validates if a phase transition is allowed
- *
- * @param {LoadingPhase} from - Current phase
- * @param {LoadingPhase} to - Target phase
- * @returns {boolean} Whether the transition is valid
- */
-function isValidPhaseTransition(from: LoadingPhase, to: LoadingPhase): boolean {
-  return VALID_PHASE_TRANSITIONS[from].includes(to);
+export function getIsRemoteMode(): boolean {
+  return isRemoteMode
 }
 
-/**
- * Gets the estimated time remaining for bootstrap
- *
- * @returns {number | null} Estimated milliseconds remaining, or null if not available
- */
-export function getEstimatedTimeRemaining(): number | null {
-  if (!currentState.startTime || currentState.progress === 0) {
-    return null;
-  }
+// Permission mode
+export type PermissionMode = 'ask' | 'acceptEdits' | 'bypassPermissions' | 'acceptAll'
 
-  const elapsed = Date.now() - currentState.startTime.getTime();
-  const progressRemaining = 100 - currentState.progress;
-  const estimatedTotal = (elapsed / currentState.progress) * 100;
+let currentPermissionMode: PermissionMode = 'ask'
 
-  return Math.max(0, (estimatedTotal * progressRemaining) / 100);
+export function setPermissionMode(mode: PermissionMode): void {
+  currentPermissionMode = mode
+  log('info', `Permission mode set to: ${mode}`)
 }
 
-/**
- * Adds a message to the bootstrap state
- *
- * @param {TypedMessage} message - The message to add
- * @returns {Readonly<BootstrapState>} The updated state
- */
-export function addBootstrapMessage(message: TypedMessage): Readonly<BootstrapState> {
-  return setBootstrapState({
-    messages: [...currentState.messages, message],
-  });
+export function getPermissionMode(): PermissionMode {
+  return currentPermissionMode
 }
 
-/**
- * Registers a service as initialized
- *
- * @param {string} serviceName - Name of the service
- * @returns {Readonly<BootstrapState>} The updated state
- */
-export function registerService(serviceName: string): Readonly<BootstrapState> {
-  if (currentState.services.includes(serviceName)) {
-    return getBootstrapState();
-  }
+// Debug mode
+let debugMode = false
+
+export function setDebugMode(enabled: boolean): void {
+  debugMode = enabled
+}
+
+export function isDebugMode(): boolean {
+  return debugMode
+}
 
-  return setBootstrapState({
-    services: [...currentState.services, serviceName],
-  });
+// Initialization
+export function initializeBootstrapState(): void {
+  log('info', 'Bootstrap state initialized')
 }
 
 // Default export
 export default {
-  getBootstrapState,
-  setBootstrapState,
-  subscribeToBootstrapState,
-  resetBootstrapState,
-  startBootstrap,
-  completeBootstrap,
-  setBootstrapError,
-  addBootstrapMessage,
-  registerService,
-  getEstimatedTimeRemaining,
-};
+  createSession,
+  getCurrentSession,
+  getSessionId,
+  setSessionId,
+  updateSessionActivity,
+  clearSession,
+  getModelSetting,
+  setModelSetting,
+  subscribeToSession,
+  subscribeToModelSetting,
+  addSlowOperation,
+  getSlowOperations,
+  clearSlowOperations,
+  setOriginalCwd,
+  getOriginalCwd,
+  setKairosActive,
+  getKairosActive,
+  setIsRemoteMode,
+  getIsRemoteMode,
+  setPermissionMode,
+  getPermissionMode,
+  setDebugMode,
+  isDebugMode,
+  initializeBootstrapState,
+}