dynim-core 1.0.0

package/dist/builder/code-client.js

@@ -0,0 +1,418 @@
+/**
+ * Code Client - Handles communication with the flexcode endpoints via build server
+ *
+ * Uses:
+ * - HTTP POST + SSE for code generation (streaming responses)
+ * - HTTP POST for save/abandon operations
+ * - HTTP GET for retrieving edits
+ * - JWT session tokens for authentication
+ *
+ * The SDK only talks to the build server (:8080), which forwards
+ * code requests to the flexcode service (:8765).
+ */
+const DEFAULT_API_BASE = 'http://localhost:8080';
+/** Create initial empty message state */
+function createEmptyMessage() {
+    return {
+        thinking: '',
+        text: '',
+        edits: [],
+        status: 'idle',
+        bundleReady: false,
+        bundleError: undefined,
+    };
+}
+export function createCodeClient(config = {}) {
+    const { apiBase = DEFAULT_API_BASE, sessionToken: initialSessionToken, refreshToken: initialRefreshToken, getSession, onMessageUpdate, onRawEvent, onMessage, // deprecated but still supported
+    onEdit, onError, onStreamStart, onStreamEnd, onSessionRefresh, onAuthError } = config;
+    let currentSessionToken = initialSessionToken;
+    let currentRefreshToken = initialRefreshToken;
+    let isRefreshing = false;
+    // Track if cache has been warmed (projectId comes from JWT, so just need one flag)
+    let hasWarmedCache = false;
+    // Current message state (accumulated)
+    let currentMessage = createEmptyMessage();
+    // Track if we need to add a line break before next text (after tool use)
+    let needsTextBreak = false;
+    /** Update message state and notify listeners */
+    function updateMessage(updates) {
+        currentMessage = { ...currentMessage, ...updates };
+        onMessageUpdate?.(currentMessage);
+    }
+    /** Append to thinking content */
+    function appendThinking(content) {
+        // If we already have text output and now Claude is thinking again,
+        // that means a new response segment is starting - mark for line break
+        if (currentMessage.text.length > 0) {
+            needsTextBreak = true;
+        }
+        currentMessage = {
+            ...currentMessage,
+            thinking: currentMessage.thinking + content
+        };
+        onMessageUpdate?.(currentMessage);
+    }
+    /** Append to text content */
+    function appendText(content) {
+        // Add line break if this is new text after a tool use
+        let prefix = '';
+        if (needsTextBreak && currentMessage.text.length > 0) {
+            prefix = '\n\n';
+            needsTextBreak = false;
+        }
+        currentMessage = {
+            ...currentMessage,
+            text: currentMessage.text + prefix + content
+        };
+        onMessageUpdate?.(currentMessage);
+    }
+    /** Mark that next text should have a line break (called after tool use) */
+    function markTextBreak() {
+        needsTextBreak = true;
+    }
+    /** Add an edit */
+    function addEdit(edit) {
+        currentMessage = {
+            ...currentMessage,
+            edits: [...currentMessage.edits, edit]
+        };
+        onMessageUpdate?.(currentMessage);
+    }
+    /**
+     * Get a valid session token, refreshing if necessary
+     */
+    async function getValidToken() {
+        if (currentSessionToken) {
+            // Check if token is expired (JWT decode)
+            try {
+                const payload = JSON.parse(atob(currentSessionToken.split('.')[1]));
+                const exp = payload.exp * 1000; // Convert to ms
+                if (Date.now() < exp - 60000) { // 1 minute buffer
+                    return currentSessionToken;
+                }
+            }
+            catch {
+                // Token parse failed, try to refresh
+            }
+        }
+        // Try to refresh
+        if (currentRefreshToken && !isRefreshing) {
+            isRefreshing = true;
+            try {
+                const response = await fetch(`${apiBase}/api/sessions/refresh`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ refresh_token: currentRefreshToken })
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    currentSessionToken = data.token;
+                    onSessionRefresh?.(data.token);
+                    isRefreshing = false;
+                    return currentSessionToken ?? null;
+                }
+            }
+            catch (err) {
+                console.error('[CodeClient] Failed to refresh session:', err);
+            }
+            isRefreshing = false;
+        }
+        // Try to get new session from callback
+        if (getSession) {
+            try {
+                const session = await getSession();
+                currentSessionToken = session.token;
+                if (session.refreshToken) {
+                    currentRefreshToken = session.refreshToken;
+                }
+                return currentSessionToken;
+            }
+            catch (err) {
+                console.error('[CodeClient] Failed to get session:', err);
+                onAuthError?.(err);
+            }
+        }
+        onAuthError?.(new Error('No valid session token available'));
+        return null;
+    }
+    /**
+     * Make an authenticated request
+     */
+    async function authenticatedFetch(url, options = {}) {
+        const token = await getValidToken();
+        if (!token) {
+            throw new Error('Not authenticated');
+        }
+        const headers = new Headers(options.headers);
+        headers.set('Authorization', `Bearer ${token}`);
+        return fetch(url, { ...options, headers });
+    }
+    /**
+     * Send a code generation request and receive SSE streaming response
+     * ProjectId comes from the JWT token (set when session was created)
+     */
+    async function sendCode(query) {
+        const token = await getValidToken();
+        if (!token) {
+            onAuthError?.(new Error('Not authenticated'));
+            return;
+        }
+        // Reset message state for new request
+        currentMessage = createEmptyMessage();
+        needsTextBreak = false;
+        updateMessage({ status: 'streaming' });
+        // Auto-warm cache (fire and forget)
+        if (!hasWarmedCache) {
+            hasWarmedCache = true;
+            warmCache().catch(() => { });
+        }
+        const body = JSON.stringify({ query });
+        console.log('[CodeClient] Sending code request:', { query: query.slice(0, 50) });
+        try {
+            const response = await fetch(`${apiBase}/api/code`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                    'Accept': 'text/event-stream'
+                },
+                body
+            });
+            if (!response.ok) {
+                if (response.status === 401 || response.status === 403) {
+                    onAuthError?.(new Error('Authentication failed'));
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            onStreamStart?.();
+            try {
+                // Read SSE stream
+                const reader = response.body?.getReader();
+                if (!reader) {
+                    throw new Error('No response body');
+                }
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    // Process complete SSE events
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                    for (const line of lines) {
+                        if (line.startsWith('data: ')) {
+                            try {
+                                const data = JSON.parse(line.slice(6));
+                                // Skip keepalive events (just for connection health)
+                                if (data.type === 'keepalive') {
+                                    continue;
+                                }
+                                // Notify raw event listeners
+                                onRawEvent?.(data);
+                                onMessage?.(data); // deprecated callback
+                                // Process event and update structured message
+                                switch (data.type) {
+                                    case 'thinking':
+                                        if (data.content) {
+                                            appendThinking(data.content);
+                                        }
+                                        break;
+                                    case 'text':
+                                        if (data.content) {
+                                            appendText(data.content);
+                                        }
+                                        break;
+                                    case 'edit':
+                                        if (data.edit) {
+                                            addEdit(data.edit);
+                                            onEdit?.(data.edit);
+                                            // Next text after an edit should be on a new line
+                                            markTextBreak();
+                                        }
+                                        break;
+                                    case 'question':
+                                        updateMessage({
+                                            status: 'waiting',
+                                            question: data.content
+                                        });
+                                        break;
+                                    case 'error':
+                                        updateMessage({
+                                            status: 'error',
+                                            error: data.content
+                                        });
+                                        break;
+                                    case 'session_started':
+                                        updateMessage({ sessionId: data.session_id });
+                                        break;
+                                    case 'done':
+                                        if (currentMessage.status !== 'waiting' && currentMessage.status !== 'error') {
+                                            updateMessage({ status: 'done' });
+                                        }
+                                        break;
+                                    case 'bundle_ready':
+                                        console.log('[CodeClient] Bundle ready:', { projectId: data.project_id });
+                                        updateMessage({ bundleReady: true, projectId: data.project_id });
+                                        break;
+                                    case 'bundle_error':
+                                        console.log('[CodeClient] Bundle error:', { error: data.content });
+                                        updateMessage({ bundleError: data.content });
+                                        break;
+                                }
+                            }
+                            catch {
+                                // Ignore parse errors for malformed events
+                            }
+                        }
+                    }
+                }
+                // Ensure we mark as done if stream ends without done event
+                if (currentMessage.status === 'streaming') {
+                    updateMessage({ status: 'done' });
+                }
+            }
+            finally {
+                onStreamEnd?.();
+            }
+        }
+        catch (error) {
+            console.error('[CodeClient] Code request error:', error);
+            updateMessage({ status: 'error', error: error.message });
+            onError?.(error);
+        }
+    }
+    /**
+     * Save pending edits (commit temp changes)
+     * ProjectId comes from the JWT token
+     */
+    async function saveCode() {
+        console.log('[CodeClient] Saving code');
+        try {
+            const response = await authenticatedFetch(`${apiBase}/api/code/save`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: '{}'
+            });
+            if (!response.ok) {
+                if (response.status === 401 || response.status === 403) {
+                    onAuthError?.(new Error('Authentication failed'));
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            // Reset message state after save
+            currentMessage = createEmptyMessage();
+            onMessageUpdate?.(currentMessage);
+            console.log('[CodeClient] Code saved successfully');
+        }
+        catch (error) {
+            console.error('[CodeClient] Save error:', error);
+            onError?.(error);
+            throw error;
+        }
+    }
+    /**
+     * Abandon pending edits (discard temp changes)
+     * ProjectId comes from the JWT token
+     */
+    async function abandonCode() {
+        console.log('[CodeClient] Abandoning code');
+        try {
+            const response = await authenticatedFetch(`${apiBase}/api/code/abandon`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: '{}'
+            });
+            if (!response.ok) {
+                if (response.status === 401 || response.status === 403) {
+                    onAuthError?.(new Error('Authentication failed'));
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            // Reset message state after abandon
+            currentMessage = createEmptyMessage();
+            onMessageUpdate?.(currentMessage);
+            console.log('[CodeClient] Code abandoned successfully');
+        }
+        catch (error) {
+            console.error('[CodeClient] Abandon error:', error);
+            onError?.(error);
+            throw error;
+        }
+    }
+    /**
+     * Get list of current edits
+     * ProjectId comes from the JWT token
+     */
+    async function getEdits() {
+        console.log('[CodeClient] Getting edits');
+        // Proactively warm cache when fetching edits (common init pattern)
+        if (!hasWarmedCache) {
+            hasWarmedCache = true;
+            warmCache().catch(() => { });
+        }
+        try {
+            const response = await authenticatedFetch(`${apiBase}/api/code/edits`);
+            if (!response.ok) {
+                if (response.status === 401 || response.status === 403) {
+                    onAuthError?.(new Error('Authentication failed'));
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            console.log('[CodeClient] Got edits:', data);
+            return data.edits || [];
+        }
+        catch (error) {
+            console.error('[CodeClient] Get edits error:', error);
+            onError?.(error);
+            throw error;
+        }
+    }
+    /**
+     * Pre-warm the file cache for faster code requests
+     * ProjectId comes from the JWT token
+     */
+    async function warmCache() {
+        try {
+            const response = await authenticatedFetch(`${apiBase}/api/code/warm-cache`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: '{}'
+            });
+            if (!response.ok) {
+                console.warn('[CodeClient] Warm cache request failed:', response.status);
+                return;
+            }
+            console.log('[CodeClient] Cache warming started');
+        }
+        catch (error) {
+            console.warn('[CodeClient] Warm cache error:', error);
+        }
+    }
+    /**
+     * Set/update the session token
+     */
+    function setSessionToken(token, refreshToken) {
+        currentSessionToken = token;
+        if (refreshToken) {
+            currentRefreshToken = refreshToken;
+        }
+    }
+    return {
+        sendCode,
+        saveCode,
+        abandonCode,
+        getEdits,
+        warmCache,
+        setSessionToken,
+        isAuthenticated: () => !!currentSessionToken,
+        getMessage: () => currentMessage,
+        resetMessage: () => {
+            currentMessage = createEmptyMessage();
+            needsTextBreak = false;
+            onMessageUpdate?.(currentMessage);
+        }
+    };
+}

package/dist/builder/diff-state.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Diff State - Tracks original element positions for computing serializable diffs
+ *
+ * This module records the FIRST position of each moved element.
+ * When getDiff() is called, it compares original vs current DOM state
+ * to produce serializable diff objects (not DOM references).
+ */
+import { type ElementIdentifier, type PlacementTarget } from './element-utils';
+export interface DiffEntry {
+    element: ElementIdentifier;
+    type: 'moved' | 'removed';
+    from: PlacementTarget;
+    to: PlacementTarget;
+}
+export interface DiffState {
+    snapshotInitialState: (rootElement: HTMLElement) => void;
+    trackElement: (domElement: HTMLElement, fallbackPlacement?: PlacementTarget) => void;
+    getDiff: () => DiffEntry[];
+    hasChanges: () => boolean;
+    clearAll: () => void;
+    getTrackedCount: () => number;
+}
+export declare function createDiffState(): DiffState;
+//# sourceMappingURL=diff-state.d.ts.map

package/dist/builder/diff-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-state.d.ts","sourceRoot":"","sources":["../../src/builder/diff-state.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAKL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,IAAI,EAAE,eAAe,CAAC;IACtB,EAAE,EAAE,eAAe,CAAC;CACrB;AA6CD,MAAM,WAAW,SAAS;IACxB,oBAAoB,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;IACzD,YAAY,EAAE,CAAC,UAAU,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,eAAe,KAAK,IAAI,CAAC;IACrF,OAAO,EAAE,MAAM,SAAS,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,eAAe,EAAE,MAAM,MAAM,CAAC;CAC/B;AAED,wBAAgB,eAAe,IAAI,SAAS,CAyG3C"}

package/dist/builder/diff-state.js

@@ -0,0 +1,134 @@
+/**
+ * Diff State - Tracks original element positions for computing serializable diffs
+ *
+ * This module records the FIRST position of each moved element.
+ * When getDiff() is called, it compares original vs current DOM state
+ * to produce serializable diff objects (not DOM references).
+ */
+import { getStableId, findByStableId, buildElementIdentifier, buildPlacementTarget } from './element-utils';
+function serializeIdentifier(el) {
+    if (!el)
+        return '';
+    if (el.id)
+        return `#${el.id}`;
+    const parts = [
+        el.tagName,
+        el.classes.sort().join('.'),
+        `nth:${el.nthOfType}`,
+        el.textContentPreview?.slice(0, 20) || '',
+    ];
+    if (el.parentIdentifier) {
+        parts.push('>' + serializeIdentifier(el.parentIdentifier));
+    }
+    return parts.join('|');
+}
+function placementsEqual(a, b) {
+    if (!a || !b)
+        return a === b;
+    if (a.position !== b.position)
+        return false;
+    if (a.parentStableId && b.parentStableId) {
+        if (a.parentStableId !== b.parentStableId)
+            return false;
+    }
+    else {
+        if (serializeIdentifier(a.parent) !== serializeIdentifier(b.parent))
+            return false;
+    }
+    if (a.referenceStableId && b.referenceStableId) {
+        return a.referenceStableId === b.referenceStableId;
+    }
+    if (a.referenceElement && b.referenceElement) {
+        return serializeIdentifier(a.referenceElement) === serializeIdentifier(b.referenceElement);
+    }
+    return a.referenceElement === b.referenceElement;
+}
+export function createDiffState() {
+    const initialSnapshot = new Map();
+    const movedElements = new Map();
+    function snapshotInitialState(rootElement) {
+        if (!rootElement)
+            return;
+        function walkAndSnapshot(element) {
+            if (element.nodeType !== Node.ELEMENT_NODE)
+                return;
+            const htmlElement = element;
+            const stableId = getStableId(htmlElement);
+            const placement = buildPlacementTarget(htmlElement);
+            if (placement) {
+                initialSnapshot.set(stableId, placement);
+            }
+            for (const child of Array.from(element.children)) {
+                walkAndSnapshot(child);
+            }
+        }
+        for (const child of Array.from(rootElement.children)) {
+            walkAndSnapshot(child);
+        }
+    }
+    function trackElement(domElement, _fallbackPlacement) {
+        if (!domElement)
+            return;
+        const stableId = getStableId(domElement);
+        if (movedElements.has(stableId)) {
+            return;
+        }
+        const elementIdentifier = buildElementIdentifier(domElement);
+        movedElements.set(stableId, {
+            stableId,
+            element: elementIdentifier,
+        });
+    }
+    function getDiff() {
+        const diffs = [];
+        for (const [stableId, tracked] of movedElements) {
+            const element = findByStableId(stableId);
+            const originalPlacement = initialSnapshot.get(stableId);
+            if (!element) {
+                if (originalPlacement) {
+                    diffs.push({
+                        element: tracked.element,
+                        type: 'removed',
+                        from: originalPlacement,
+                        to: originalPlacement,
+                    });
+                }
+                continue;
+            }
+            if (!originalPlacement)
+                continue;
+            const currentPlacement = buildPlacementTarget(element);
+            if (!currentPlacement)
+                continue;
+            if (!placementsEqual(originalPlacement, currentPlacement)) {
+                diffs.push({
+                    element: tracked.element,
+                    type: 'moved',
+                    from: originalPlacement,
+                    to: currentPlacement,
+                });
+            }
+        }
+        return diffs;
+    }
+    function hasChanges() {
+        return movedElements.size > 0;
+    }
+    function clearAll() {
+        movedElements.clear();
+    }
+    function getTrackedCount() {
+        return movedElements.size;
+    }
+    if (typeof window !== 'undefined') {
+        window.__diffState = { getDiff, hasChanges, getTrackedCount, movedElements, initialSnapshot };
+    }
+    return {
+        snapshotInitialState,
+        trackElement,
+        getDiff,
+        hasChanges,
+        clearAll,
+        getTrackedCount,
+    };
+}

package/dist/builder/dom-scanner.d.ts

@@ -0,0 +1,20 @@
+/**
+ * DOM scanner - serializes DOM tree for the component tree
+ */
+import { STABLE_ID_ATTR } from './element-utils';
+import type { SerializedDOMNode } from './tree-state';
+export interface ScanOptions {
+    maxDepth?: number;
+    skipIds?: string[];
+}
+export declare function scanDOM(root: HTMLElement, options?: ScanOptions): SerializedDOMNode | null;
+export interface DebouncedScanner {
+    scan: () => void;
+    cancel: () => void;
+}
+export declare function createDebouncedScanner(root: HTMLElement, callback: (tree: SerializedDOMNode | null) => void, delay?: number): DebouncedScanner;
+export declare function getElementAtPath(path: number[], root: HTMLElement): HTMLElement | null;
+export declare function queryElements(selector: string, root?: HTMLElement): HTMLElement[];
+export declare function generateSelector(element: HTMLElement): string;
+export { STABLE_ID_ATTR };
+//# sourceMappingURL=dom-scanner.d.ts.map

package/dist/builder/dom-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-scanner.d.ts","sourceRoot":"","sources":["../../src/builder/dom-scanner.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAgD,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC/F,OAAO,KAAK,EAAE,iBAAiB,EAAkB,MAAM,cAAc,CAAC;AAEtE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,GAAE,WAAgB,GAAG,iBAAiB,GAAG,IAAI,CAiD9F;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,KAAK,IAAI,EAClD,KAAK,SAAM,GACV,gBAAgB,CAqBlB;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CAStF;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,WAA2B,GAAG,WAAW,EAAE,CAMhG;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAiB7D;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}