@decido/shell-vscode-core 1.0.0 → 4.0.2

package/src/appState.ts

@@ -1,167 +0,0 @@
-// src/appState.ts
-
-import { createSignal } from "./core/signals";
-import { StorageService } from "./core/StorageService";
-import { Pane, GamificationState, CalendarEvent } from "./types";
-
-export * from "./stores/editorStore";
-export * from "./stores/gamificationStore";
-export * from "./stores/workspaceStore";
-export * from "./stores/historyStore";
-
-import { editorPanes, setEditorPanes, setActivePaneId, activePaneId } from "./stores/editorStore";
-import { gamification, setGamification } from "./stores/gamificationStore";
-import { history, setHistory, isTimeTraveling } from "./stores/historyStore";
-let isDebuggingTimeTravel = false; // Flag interna para el modo de depuración
-// --- LÓGICA DE MANEJO DE ESTADO ---
-
-const storage = new StorageService(); // Instancia del servicio
-
-
-
-
-/**
- * Carga el estado inicial de la aplicación desde IndexedDB usando el StorageService.
- * @param storage El servicio de almacenamiento para interactuar con la BD.
- */
-// Esta función es más genérica y fácil de mantener
-export async function initializeStateFromStorage(storage: StorageService) {
-    console.log("💾 Cargando estado desde IndexedDB...");
-
-    const stateMap = [
-        // Para objetos únicos
-        { key: 'gamification', setter: setGamification, isSingle: true },
-        { key: 'editorPanes', setter: setEditorPanes, isSingle: true },
-        { key: 'activePaneId', setter: setActivePaneId, isSingle: true }
-    ];
-
-    for (const item of stateMap) {
-        const value = item.isSingle
-            ? await storage.getValue(item.key)
-            : await storage.getCollection(item.key);
-
-        if (value !== undefined && value !== null && Array.isArray(value) && value.length > 0) {
-            // @ts-ignore
-            item.setter(value);
-        } else if (value !== undefined && value !== null && !Array.isArray(value)) {
-            // @ts-ignore
-            item.setter(value);
-        }
-    }
-
-    // Si después de cargar, no hay paneles, crea uno por defecto.
-    if (editorPanes().length === 0) {
-        console.log("No se encontró layout de editor, creando uno por defecto.");
-        const defaultPane: Pane = {
-            id: 'pane-main',
-            tabs: [{
-                id: 'welcome',
-                title: 'Bienvenido',
-                componentTag: 'welcome-view',
-                icon: 'fas fa-hand-sparkles'
-            }],
-            activeTabId: 'welcome'
-        };
-        setEditorPanes([defaultPane]);
-        setActivePaneId(defaultPane.id);
-    }
-    console.log("✅ Estado cargado desde IndexedDB.");
-}
-
-// Una bandera para evitar que el viaje en el tiempo se grabe a sí mismo en el historial
-let isTimeTravelingLocal = false;
-
-/**
- * Función central y ÚNICA para modificar el estado de la aplicación.
- * Es llamada por los Servicios de Lógica de Negocio.
- * @param action Un nombre descriptivo para el cambio (ej: 'TASK:CREATE').
- * @param updater Una función que realiza el cambio de estado en memoria (llama a un setter).
- * @param persistenceFn Una función asíncrona que guarda los cambios en la base de datos.
- */
-export function updateState(action: string, updater: () => void, persistenceFn?: () => Promise<void>) {
-    if (isTimeTraveling()) {
-        console.warn(`[STATE] Escritura bloqueada (${action}). La aplicación está en modo de revisión de solo lectura.`);
-        return;
-    }
-
-    if (!isDebuggingTimeTravel) {
-        const snapshot = getFullStateSnapshot();
-        setHistory(prev => [...prev, { id: prev.length, timestamp: new Date(), action, snapshot }]);
-    }
-
-    // 1. Actualización optimista en la UI (en memoria)
-    updater();
-
-    // 2. Persistencia asíncrona en segundo plano
-    if (persistenceFn) {
-        persistenceFn().catch(err => {
-            console.error(`[STATE] Fallo de persistencia en la acción '${action}':`, err);
-            // Aquí se podría implementar una lógica de "rollback" o reintento.
-        });
-    }
-}
-
-
-// --- FUNCIONES DE AYUDA Y DE INICIALIZACIÓN ---
-// (Estas funciones como `getFullStateSnapshot`, `restoreStateFromSnapshot`, 
-// `initializeStateFromStorage`, `timeTravelLocal`, etc., se quedan aquí,
-// ya que operan directamente sobre el conjunto del estado).
-
-export function getFullStateSnapshot(): any {
-    return {
-        gamification: gamification(),
-        editorPanes: editorPanes(),
-        activePaneId: activePaneId(),
-        // ... el resto de tu estado ...
-    };
-}
-
-export function restoreStateFromSnapshot(snapshot: any) {
-    if (!snapshot) return;
-    setGamification(snapshot.gamification || { xp: 0, level: 1, streak: 0, lastJournalDate: null, unlockedAchievements: [], achievements: [] });
-    setEditorPanes(snapshot.editorPanes || []);
-    setActivePaneId(snapshot.activePaneId || null);
-    // ... el resto de tus setters ...
-}
-
-export function timeTravelLocal(historyIndex: number) {
-    const log = history();
-    if (!log[historyIndex]) return;
-
-    isDebuggingTimeTravel = true;
-    restoreStateFromSnapshot(log[historyIndex].snapshot);
-    setHistory(log.slice(0, historyIndex + 1));
-    isDebuggingTimeTravel = false;
-}
-
-export function timeTravel(historyIndex: number) {
-    const log = history();
-    if (!log[historyIndex]) return;
-
-    // Obtenemos la "foto" del estado que queremos restaurar
-    const snapshot = log[historyIndex].snapshot;
-
-    // Activamos la bandera para que `updateState` no grabe este cambio
-    isTimeTravelingLocal = true;
-
-    // Restauramos el estado llamando a los setters originales
-    // Esto es un ejemplo, debes hacerlo para todas tus señales
-    // setUser(snapshot.user);
-    // setAppSettings(snapshot.settings);
-    // setActiveView(snapshot.activeView);
-
-    console.log(`✈️ Viajando en el tiempo al estado ${historyIndex}`, snapshot);
-
-    // Cortamos el historial para que el estado actual sea el final de la línea de tiempo
-    setHistory(log.slice(0, historyIndex + 1));
-
-    // Desactivamos la bandera
-    isTimeTravelingLocal = false;
-}
-
-// Ejemplo de cómo usarlo en tu app:
-/*
-updateState('SET_USER_NAME', () => {
-    setUserName('Nuevo Nombre');
-});
-*/

package/src/core/AIService.ts

@@ -1,109 +0,0 @@
-// File: packages/core/src/core/AIService.ts
-
-import { IPlatformAPI } from './api.js';
-import { createSignal, Signal } from './signals.js';
-
-export interface AIServiceOptions {
-    // Si es `true`, devuelve una señal que se actualiza en tiempo real.
-    // Si es `false`, devuelve una Promesa con el resultado completo.
-    stream?: boolean;
-}
-
-/**
- * Servicio central para interactuar con las capacidades de IA de la plataforma.
- * Abstrae las llamadas al backend de Genkit y gestiona el streaming de respuestas.
- */
-export class AIService {
-    private api!: IPlatformAPI;
-
-    public init(api: IPlatformAPI): void {
-        this.api = api;
-    }
-
-    /**
-     * Ejecuta un flujo de Genkit definido en el backend.
-     * @param flowId El ID del flujo a ejecutar (ej. 'decidoFlow').
-     * @param payload El objeto de entrada para el flujo, con `promptKey` y `context`.
-     * @param options Opciones de ejecución, como habilitar el streaming.
-     * @returns Si stream=true, devuelve el getter de una señal. Si no, una Promesa con el resultado final.
-     */
-    public runFlow<T = string>(
-        flowId: string,
-        payload: { promptKey: string, context: Record<string, unknown> | unknown },
-        options: { stream: true }
-    ): Signal<T>[0]; // Devuelve el getter de la señal
-    public runFlow<T = string>(
-        flowId: string,
-        payload: { promptKey: string, context: Record<string, unknown> | unknown },
-        options?: { stream?: false }
-    ): Promise<T>; // Devuelve una Promesa
-    public runFlow<T = string>(
-        flowId: string,
-        payload: { promptKey: string, context: Record<string, unknown> | unknown },
-        options: AIServiceOptions = {}
-    ): Promise<T> | Signal<T>[0] {
-        const { stream = false } = options;
-
-        if (!stream) {
-            // Caso simple: No streaming. Ejecución directa HTTP
-            return new Promise<T>(async (resolve, reject) => {
-                try {
-                    const token = localStorage.getItem('decido-token');
-                    const response = await fetch(`http://localhost:8888/flow/${flowId}`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${token}`
-                        },
-                        body: JSON.stringify(payload)
-                    });
-                    if (!response.ok) throw new Error(`HTTP Error: ${response.statusText}`);
-                    const json = await response.json();
-                    resolve(json as T);
-                } catch (e) {
-                    reject(e);
-                }
-            });
-        }
-
-        // --- Caso Avanzado: Streaming ---
-        const [getStreamedResponse, setStreamedResponse] = createSignal("" as any);
-
-        // Envolvemos la lógica de streaming en una función asíncrona
-        const startStreaming = async () => {
-            try {
-                const token = localStorage.getItem('decido-token');
-                const response = await fetch(`http://localhost:8888/flow/${flowId}/stream`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${token}`
-                    },
-                    body: JSON.stringify(payload),
-                });
-
-                if (!response.ok || !response.body) {
-                    throw new Error(`Error en la respuesta del servidor: ${response.statusText}`);
-                }
-
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder();
-                let fullText = "";
-
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) break;
-
-                    fullText += decoder.decode(value, { stream: true });
-                    setStreamedResponse(fullText);
-                }
-            } catch (error) {
-                console.error("[AIService] Error durante el streaming:", error);
-                setStreamedResponse("Error al generar la respuesta." as any);
-            }
-        };
-
-        startStreaming();
-        return getStreamedResponse; // Devolvemos el getter inmediatamente
-    }
-}

package/src/core/ApiService.ts

@@ -1,40 +0,0 @@
-import type { AuthService } from "./AuthService";
-
-const API_BASE_URL = 'http://localhost:8888/api';
-
-/**
- * Clase para gestionar las interacciones con la API del backend.
- * Encapsula la lógica de fetch, la gestión de errores y la autenticación.
- */
-export class ApiService {
-    public id = Math.random().toString(36).substr(2, 9);
-    private authService!: AuthService;
-
-    public init(authService: AuthService) {
-        console.log(`[ApiService:${this.id}] init called`);
-        this.authService = authService;
-    }
-
-    async fetch<T = unknown>(endpoint: string, options: RequestInit = {}, isText = false): Promise<T> {
-        console.log(`[ApiService Mock] Ignorando invocación de red a: ${endpoint}`);
-        return {} as T;
-    }
-
-    async login(email: string, password: string): Promise<unknown> { return {}; }
-    async refresh(refreshToken: string): Promise<{ token: string }> { return { token: "dev" }; }
-    async register(username: string, email: string, password: string): Promise<unknown> { return {}; }
-    logout(): void { }
-    async getProfile(): Promise<{ id: number; name: string }> { return { id: 1, name: "Local Dev" }; }
-    async updateProfile(profileData: Record<string, unknown>): Promise<Record<string, unknown>> { return profileData; }
-
-    // IA & Marketplace Mocks
-    async getAIProjectPlan(goal: { title: string; coreValueId: string }): Promise<unknown> { return {}; }
-    async generateBlueprint(goalData: Record<string, unknown>): Promise<string> { return ""; }
-    async getAIGoalSuggestion(idea: string): Promise<unknown> { return {}; }
-    async getRefinedText(text: string, context: string): Promise<string> { return text; }
-    async getModules(): Promise<unknown[]> { return []; }
-    async uploadModule(formData: FormData): Promise<unknown> { return {}; }
-    async generateTheme(prompt: string): Promise<unknown> { return {}; }
-}
-
-export const apiService = new ApiService();

package/src/core/AuthService.ts

@@ -1,85 +0,0 @@
-import { createSignal, Signal } from './signals.js';
-import type { ApiService } from './ApiService.js'; // Type-only import to break cycle
-
-type AuthStatus = 'loading' | 'authenticated' | 'unauthenticated' | 'error';
-
-//TODO: Completar propiedades
-interface User {
-    id: string | number;
-    name: string;
-    email: string;
-    // ... otras propiedades del usuario
-}
-
-interface Session {
-    user: User | null;
-    token: string | null;
-    status: AuthStatus;
-    error?: string;
-}
-
-export class AuthService {
-    private apiService!: ApiService;
-    public session: Signal<Session>;
-
-    constructor() {
-        this.session = createSignal<Session>({
-            user: null,
-            token: null,
-            status: 'loading',
-        });
-    }
-
-    public init(apiService: ApiService) {
-        this.apiService = apiService;
-    }
-
-    async checkSession() {
-        const fakeUser: User = { id: 1, name: "Local Dev", email: "dev@local.host" };
-        this.setSession({ user: fakeUser, token: "local-dev-token", status: 'authenticated' });
-        console.log('[Auth] CheckSession local - Auto autenticado.');
-    }
-
-    login = async (email: any, password: any) => {
-        const fakeUser: User = { id: 1, name: "Local Dev", email };
-        this.setSession({ user: fakeUser, token: "local-dev-token", status: 'authenticated' });
-
-        const fullscreenContainer = document.getElementById('fullscreen-view-container');
-        if (fullscreenContainer) fullscreenContainer.innerHTML = '';
-        const appContainer = document.getElementById('app');
-        if (appContainer) appContainer.style.display = 'block';
-        return fakeUser;
-    }
-
-    async register(username: string, email: string, password: string): Promise<any> {
-        return { success: true };
-    }
-
-    public logout = () => {
-        this.setSession({ user: null, token: null, status: 'unauthenticated' });
-    }
-
-    refreshToken = async (): Promise<string | null> => {
-        return "local-dev-token";
-    }
-
-    private listeners = new Set<(session: Session) => void>();
-
-    public subscribe(cb: (session: Session) => void) {
-        this.listeners.add(cb);
-        cb(this.session[0]());
-        return () => {
-            this.listeners.delete(cb);
-        };
-    }
-
-    private setSession(partialState: Partial<Session>) {
-        const [get, set] = this.session;
-        set({ ...get(), ...partialState });
-        const newState = get();
-        this.listeners.forEach(cb => cb(newState));
-    }
-}
-
-// Exportamos una instancia única para toda la aplicación
-export const authService = new AuthService();

package/src/core/BaseService.ts

@@ -1,47 +0,0 @@
-import { StorageService } from './StorageService.js';
-import { HookService } from './HookService.js';
-// import { updateState } from '../appState.js';
-import { ServiceContainer } from './ServiceContainer.js';
-import { NotificationService } from './NotificationService.js';
-import { GamificationService } from './GamificationService.js';
-import { IPlatformAPI } from './api.js';
-
-/**
- * La clase base para todos los servicios de lógica de negocio.
- * Utiliza el ServiceContainer para obtener sus dependencias, promoviendo
- * un bajo acoplamiento.
- */
-export class BaseService {
-    // Las dependencias comunes se declaran como protegidas
-    protected storage: StorageService;
-    protected hooks: HookService;
-    protected notifications: NotificationService;
-    protected gamification: GamificationService;
-    protected api: IPlatformAPI;
-    protected container: ServiceContainer;
-
-    constructor(container: ServiceContainer) {
-        // Cada servicio base pide al contenedor lo que necesita.
-        this.container = container;
-        this.storage = container.get('storage');
-        this.hooks = container.get('hooks');
-        this.notifications = container.get('notifications');
-        this.gamification = container.get('gamification');
-        this.api = container.get('api');
-    }
-
-    /**
-     * Envuelve la función global `updateState`.
-     * Este es el único punto de entrada para realizar cambios de estado persistentes.
-     * @param action El nombre de la acción para el historial de depuración (ej: 'TASK:CREATE').
-     * @param updater La función que modifica la señal de estado en memoria.
-     * @param persistenceFn La función asíncrona que guarda el cambio en IndexedDB.
-     */
-    protected executeUpdate(
-        action: string,
-        updater: () => void,
-        persistenceFn: () => Promise<void>
-    ) {
-        // updateState(action, updater, persistenceFn);
-    }
-}

package/src/core/CalendarService.ts

@@ -1,44 +0,0 @@
-// /src/core/CalendarService.ts
-
-import { CalendarEvent } from '../types/platform.js';
-import { IPlatformAPI } from './api.js';
-
-export class CalendarService {
-    public api!: IPlatformAPI;
-
-    /**
-     * Crea un nuevo evento y lo añade al estado.
-     */
-    public createEvent(eventData: Omit<CalendarEvent, 'id'>): CalendarEvent {
-        const newEvent: CalendarEvent = {
-            ...eventData,
-            id: Date.now(),
-        };
-        // const currentEvents = this.api.state.calendar();
-        // this.api.state.setCalendar([...currentEvents, newEvent]);
-        this.api.notifications.show('success', 'Evento Creado', `Se añadió "${newEvent.title}" a tu calendario.`);
-        return newEvent;
-    }
-
-    /**
-     * Obtiene todos los eventos para un día específico.
-     * @param date El día para el que se quieren obtener los eventos.
-     */
-    public getEventsForDay(date: Date) {
-        // const allEvents = this.api.state.calendar();
-        // const dayStart = new Date(date);
-        // dayStart.setHours(0, 0, 0, 0);
-
-        // const dayEnd = new Date(date);
-        // dayEnd.setHours(23, 59, 59, 999);
-
-        // return allEvents.filter((event: any) => {
-        //     const eventStart = new Date(event.start);
-        //     return eventStart >= dayStart && eventStart <= dayEnd;
-        // });
-    }
-
-    // En el futuro, podríamos añadir métodos como:
-    // public updateEvent(eventId: number, updates: Partial<CalendarEvent>) { ... }
-    // public deleteEvent(eventId: number) { ... }
-}

package/src/core/CommandService.ts

@@ -1,69 +0,0 @@
-// src/platform/CommandService.ts
-import { IPlatformAPI } from './api.js';
-type SpyCommandHandler = (commandId: string, data?: any) => void;
-
-export interface Command {
-    id: string;
-    title: string;
-    icon?: string;
-    category?: string;
-    execute: (api: IPlatformAPI, arg?: any) => void;
-}
-
-export class CommandService {
-    private commands: Map<string, Command> = new Map();
-    public api!: IPlatformAPI;
-    private spy: SpyCommandHandler | null = null;
-
-    constructor() {
-        // The API is injected after construction to break circular dependencies.
-    }
-
-    register(command: Command) {
-        if (this.commands.has(command.id)) {
-            console.warn(`[CommandService] El comando "${command.id}" ya está registrado. Se sobrescribirá.`);
-        }
-        this.commands.set(command.id, command);
-    }
-
-    execute(commandId: string, arg?: any, callerId?: string) {
-        const command = this.commands.get(commandId);
-        if (command) {
-            try {
-                // Asumimos que un comando mapea a un servicio. 
-                // TODO: Hay qye mejorar la implementación real, el comando podría declarar qué servicio utiliza.
-                // Por ahora, usamos una convención: 'kanban.moveTask' activa 'svc:KanbanService'.
-                const targetServiceId = `svc:${command.id.split('.')[0]}Service`;
-
-                const startTime = performance.now(); // <-- INICIA EL CRONÓMETRO
-                command.execute(this.api, arg);
-                const endTime = performance.now(); // <-- DETIENE EL CRONÓMETRO
-                const duration = (endTime - startTime).toFixed(2);
-                
-                this.api.debug?.probe(targetServiceId, 'active', { 
-                sourceNodeId: callerId,
-                command: commandId, // <-- PASAMOS LA FUENTE
-                duration: `${duration} ms` // <-- AÑADE LA MÉTRICA
-            });
-                this.api.events.emit(`command:${commandId}:executed`, { arg });
-            } catch (error) {
-                console.error(`Error ejecutando el comando "${commandId}":`, error);
-                this.api.notifications.show('error', 'Error de Comando', `No se pudo ejecutar "${command.title}".`);
-            }
-        } else {
-            console.error(`[CommandService] Intento de ejecutar un comando no registrado: "${commandId}"`);
-        }
-    }
-
-    getAll(): Command[] {
-        return Array.from(this.commands.values());
-    }
-
-    /**
- * Registra una única función que recibirá TODOS los eventos emitidos.
- * @param handler La función espía.
- */
-    spyOn(handler: SpyCommandHandler): void {
-        this.spy = handler;
-    }
-}

package/src/core/DebugPanelService.ts

@@ -1,38 +0,0 @@
-// packages/core/src/core/DebugPanelService.ts
-import { createSignal } from './signals';
-
-interface PanelConfig {
-    id: string;
-    isVisible: boolean;
-    // ... futuras opciones como posición, tamaño, etc.
-}
-
-export class DebugPanelService {
-    public panels = createSignal<Record<string, PanelConfig>>({});
-
-    public create(panelId: string) {
-        this.panels[1](prev => ({
-            ...prev,
-            [panelId]: { id: panelId, isVisible: true }
-        }));
-    }
-
-    public toggle(panelId: string) {
-        this.panels[1](prev => {
-            const panel = prev[panelId];
-            if (!panel) return prev;
-            return {
-                ...prev,
-                [panelId]: { ...panel, isVisible: !panel.isVisible }
-            };
-        });
-    }
-
-    public destroy(panelId: string) {
-        this.panels[1](prev => {
-            const newPanels = { ...prev };
-            delete newPanels[panelId];
-            return newPanels;
-        });
-    }
-}