@shepai/cli 1.72.9 → 1.73.0

package/dist/src/presentation/web/hooks/use-graph-state.js

@@ -0,0 +1,257 @@
+'use client';
+import { useState, useMemo, useCallback, useRef } from 'react';
+import { deriveGraph, } from '../lib/derive-graph.js';
+import { layoutWithDagre, CANVAS_LAYOUT_DEFAULTS } from '../lib/layout-with-dagre.js';
+/** Parse initialNodes + initialEdges into domain Maps. */
+function parseMaps(initialNodes, initialEdges) {
+    // Build parentNodeId map from dependency edges
+    const parentByChild = new Map();
+    for (const edge of initialEdges) {
+        if (edge.type === 'dependencyEdge') {
+            parentByChild.set(edge.target, edge.source);
+        }
+    }
+    const featureMap = new Map();
+    const repoMap = new Map();
+    for (const node of initialNodes) {
+        if (node.type === 'featureNode') {
+            featureMap.set(node.id, {
+                nodeId: node.id,
+                data: node.data,
+                parentNodeId: parentByChild.get(node.id),
+            });
+        }
+        else if (node.type === 'repositoryNode') {
+            repoMap.set(node.id, {
+                nodeId: node.id,
+                data: node.data,
+            });
+        }
+    }
+    return { featureMap, repoMap };
+}
+function isFeatureDataUnchanged(data, updates) {
+    return ((updates.state === undefined || updates.state === data.state) &&
+        (updates.lifecycle === undefined || updates.lifecycle === data.lifecycle) &&
+        (updates.name === undefined || updates.name === data.name) &&
+        (updates.description === undefined || updates.description === data.description));
+}
+export function useGraphState(initialNodes, initialEdges) {
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- intentional: parse only on mount (like useState initializer)
+    const init = useMemo(() => parseMaps(initialNodes, initialEdges), []);
+    const [featureMap, setFeatureMap] = useState(init.featureMap);
+    const [repoMap, setRepoMap] = useState(init.repoMap);
+    const [pendingMap, setPendingMap] = useState(new Map());
+    // Buffer for SSE updates that arrive before their feature is in featureMap.
+    // When reconcile adds new features, buffered updates are applied automatically.
+    const pendingUpdatesRef = useRef(new Map());
+    // Callbacks stored in a ref so changing them doesn't trigger re-render.
+    // The stable wrapper object reads from the ref so node closures always use latest callbacks.
+    const callbacksRef = useRef({});
+    const stableCallbacks = useMemo(() => ({
+        onNodeAction: (nodeId) => callbacksRef.current.onNodeAction?.(nodeId),
+        onNodeSettings: (nodeId) => callbacksRef.current.onNodeSettings?.(nodeId),
+        onFeatureDelete: (featureId) => callbacksRef.current.onFeatureDelete?.(featureId),
+        onRepositoryAdd: (nodeId) => callbacksRef.current.onRepositoryAdd?.(nodeId),
+        onRepositoryClick: (nodeId) => callbacksRef.current.onRepositoryClick?.(nodeId),
+        onRepositoryDelete: (repositoryId) => callbacksRef.current.onRepositoryDelete?.(repositoryId),
+    }), []);
+    // Stable refs for domain Maps (for use in callbacks without depending on state)
+    const featureMapRef = useRef(featureMap);
+    featureMapRef.current = featureMap;
+    const repoMapRef = useRef(repoMap);
+    repoMapRef.current = repoMap;
+    // Derive graph from domain Maps (runs on every Map change, but dagre only on topology change)
+    const derived = useMemo(() => deriveGraph(featureMap, repoMap, pendingMap, stableCallbacks), [featureMap, repoMap, pendingMap, stableCallbacks]);
+    // Cache dagre layout positions — only re-run when node set or edge connections change
+    const layoutCacheRef = useRef({ key: '', positions: new Map() });
+    const { nodes, edges } = useMemo(() => {
+        const nodeIds = derived.nodes
+            .map((n) => n.id)
+            .sort()
+            .join(',');
+        const edgeKeys = derived.edges
+            .map((e) => `${e.source}-${e.target}`)
+            .sort()
+            .join(',');
+        const topologyKey = `${nodeIds}|${edgeKeys}`;
+        if (topologyKey !== layoutCacheRef.current.key) {
+            // Topology changed — re-run dagre
+            const result = layoutWithDagre(derived.nodes, derived.edges, CANVAS_LAYOUT_DEFAULTS);
+            const positions = new Map();
+            for (const node of result.nodes) {
+                positions.set(node.id, {
+                    position: node.position,
+                    targetPosition: node.targetPosition,
+                    sourcePosition: node.sourcePosition,
+                });
+            }
+            layoutCacheRef.current = { key: topologyKey, positions };
+            return result;
+        }
+        // Data-only change — apply cached positions without re-running dagre
+        const { positions } = layoutCacheRef.current;
+        const nodes = derived.nodes.map((node) => {
+            const cached = positions.get(node.id);
+            return cached ? { ...node, ...cached } : node;
+        });
+        return { nodes, edges: derived.edges };
+    }, [derived]);
+    // --- Mutations ---
+    const reconcile = useCallback((newNodes, newEdges) => {
+        const { featureMap: newFeatureMap, repoMap: newRepoMap } = parseMaps(newNodes, newEdges);
+        // Precompute match keys so we don't scan newFeatureMap.values() per pending entry
+        const realFeatureKeys = new Set([...newFeatureMap.values()].map((e) => `${e.data.name}\0${e.data.repositoryPath}`));
+        setFeatureMap((currentFeatureMap) => {
+            // Preserve pending (creating) nodes unless matched by name+repositoryPath from newFeatureMap
+            const pendingEntries = [...currentFeatureMap.entries()].filter(([, e]) => e.data.state === 'creating');
+            const merged = new Map(newFeatureMap);
+            // Keep pending nodes that don't have a real counterpart in new data
+            for (const [tempId, pendingEntry] of pendingEntries) {
+                const key = `${pendingEntry.data.name}\0${pendingEntry.data.repositoryPath}`;
+                if (!realFeatureKeys.has(key)) {
+                    merged.set(tempId, pendingEntry);
+                }
+            }
+            // Apply any buffered SSE updates to features that now exist in the map
+            for (const [nodeId, updates] of pendingUpdatesRef.current) {
+                const entry = merged.get(nodeId);
+                if (entry) {
+                    merged.set(nodeId, { ...entry, data: { ...entry.data, ...updates } });
+                    pendingUpdatesRef.current.delete(nodeId);
+                }
+            }
+            return merged;
+        });
+        // Clean pendingMap entries that now have a real counterpart in server data
+        setPendingMap((currentPendingMap) => {
+            if (currentPendingMap.size === 0)
+                return currentPendingMap;
+            let changed = false;
+            const next = new Map(currentPendingMap);
+            for (const [tempId, pendingEntry] of currentPendingMap) {
+                const key = `${pendingEntry.data.name}\0${pendingEntry.data.repositoryPath}`;
+                if (realFeatureKeys.has(key)) {
+                    next.delete(tempId);
+                    changed = true;
+                }
+            }
+            return changed ? next : currentPendingMap;
+        });
+        setRepoMap(newRepoMap);
+    }, []);
+    const updateFeature = useCallback((featureNodeId, updates) => {
+        setFeatureMap((prev) => {
+            const entry = prev.get(featureNodeId);
+            if (!entry) {
+                // Feature not yet in map — buffer update for when reconcile adds it
+                pendingUpdatesRef.current.set(featureNodeId, {
+                    ...pendingUpdatesRef.current.get(featureNodeId),
+                    ...updates,
+                });
+                return prev;
+            }
+            // Clear any buffered update for this feature since it's now in the map
+            pendingUpdatesRef.current.delete(featureNodeId);
+            if (isFeatureDataUnchanged(entry.data, updates))
+                return prev;
+            const next = new Map(prev);
+            next.set(featureNodeId, { ...entry, data: { ...entry.data, ...updates } });
+            return next;
+        });
+        // Also check pendingMap
+        setPendingMap((prev) => {
+            const entry = prev.get(featureNodeId);
+            if (!entry)
+                return prev;
+            if (isFeatureDataUnchanged(entry.data, updates))
+                return prev;
+            const next = new Map(prev);
+            next.set(featureNodeId, { ...entry, data: { ...entry.data, ...updates } });
+            return next;
+        });
+    }, []);
+    const addPendingFeature = useCallback((nodeId, data, parentNodeId) => {
+        setPendingMap((prev) => {
+            const next = new Map(prev);
+            next.set(nodeId, { nodeId, data, parentNodeId });
+            return next;
+        });
+    }, []);
+    const removePendingFeature = useCallback((nodeId) => {
+        setPendingMap((prev) => {
+            if (!prev.has(nodeId))
+                return prev;
+            const next = new Map(prev);
+            next.delete(nodeId);
+            return next;
+        });
+    }, []);
+    const removeFeature = useCallback((nodeId) => {
+        setFeatureMap((prev) => {
+            if (!prev.has(nodeId))
+                return prev;
+            const next = new Map(prev);
+            next.delete(nodeId);
+            return next;
+        });
+    }, []);
+    const restoreFeature = useCallback((nodeId, entry) => {
+        setFeatureMap((prev) => {
+            const next = new Map(prev);
+            next.set(nodeId, entry);
+            return next;
+        });
+    }, []);
+    const addRepository = useCallback((nodeId, data) => {
+        setRepoMap((prev) => {
+            const next = new Map(prev);
+            next.set(nodeId, { nodeId, data });
+            return next;
+        });
+    }, []);
+    const removeRepository = useCallback((nodeId) => {
+        setRepoMap((prev) => {
+            if (!prev.has(nodeId))
+                return prev;
+            const next = new Map(prev);
+            next.delete(nodeId);
+            return next;
+        });
+    }, []);
+    const replaceRepository = useCallback((tempId, realId, data) => {
+        setRepoMap((prev) => {
+            if (!prev.has(tempId))
+                return prev;
+            const next = new Map(prev);
+            next.delete(tempId);
+            next.set(realId, { nodeId: realId, data });
+            return next;
+        });
+    }, []);
+    const getFeatureRepositoryPath = useCallback((featureNodeId) => {
+        return featureMapRef.current.get(featureNodeId)?.data.repositoryPath;
+    }, []);
+    const getRepositoryData = useCallback((nodeId) => {
+        return repoMapRef.current.get(nodeId)?.data;
+    }, []);
+    const setCallbacks = useCallback((callbacks) => {
+        callbacksRef.current = callbacks;
+    }, []);
+    return {
+        nodes,
+        edges,
+        reconcile,
+        updateFeature,
+        addPendingFeature,
+        removePendingFeature,
+        removeFeature,
+        restoreFeature,
+        addRepository,
+        removeRepository,
+        replaceRepository,
+        getFeatureRepositoryPath,
+        getRepositoryData,
+        setCallbacks,
+    };
+}

package/dist/src/presentation/web/hooks/use-notifications.d.ts

@@ -1,6 +1,2 @@
-export interface UseNotificationsResult {
-    requestBrowserPermission: () => Promise<void>;
-    browserPermissionState: NotificationPermission;
-}
-export declare function useNotifications(): UseNotificationsResult;
+export declare function useNotifications(): void;
 //# sourceMappingURL=use-notifications.d.ts.map

package/dist/src/presentation/web/hooks/use-notifications.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-notifications.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/hooks/use-notifications.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,sBAAsB;IACrC,wBAAwB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,sBAAsB,EAAE,sBAAsB,CAAC;CAChD;AA2CD,wBAAgB,gBAAgB,IAAI,sBAAsB,CAiEzD"}
+{"version":3,"file":"use-notifications.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/hooks/use-notifications.ts"],"names":[],"mappings":"AA0CA,wBAAgB,gBAAgB,IAAI,IAAI,CA8CvC"}

package/dist/src/presentation/web/hooks/use-notifications.js

@@ -1,5 +1,5 @@
 'use client';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
 import { useRouter } from 'next/navigation';
 import { toast } from 'sonner';
 import { NotificationEventType, NotificationSeverity } from '../../../../packages/core/src/domain/generated/output.js';
@@ -27,15 +27,6 @@ function dispatchToast(event, navigate) {
         }),
     });
 }
-function dispatchBrowserNotification(event) {
-    if (globalThis.Notification?.permission !== 'granted') {
-        return;
-    }
-    new Notification(`Shep: ${event.featureName}`, {
-        body: event.message,
-        icon: '/favicon-light.svg',
-    });
-}
 const SEVERITY_TO_ACTION = {
     [NotificationSeverity.Success]: 'notification-success',
     [NotificationSeverity.Error]: 'notification-error',
@@ -55,11 +46,6 @@ export function useNotifications() {
         'notification-warning': warningSound,
         'notification-info': infoSound,
     }), [successSound, errorSound, warningSound, infoSound]);
-    const [browserPermissionState, setBrowserPermissionState] = useState(() => {
-        if (typeof globalThis.Notification === 'undefined')
-            return 'default';
-        return globalThis.Notification.permission;
-    });
     // Track how many events from the array we've already processed.
     // Using the array index (instead of lastEvent) prevents React batching
     // from silently dropping events when multiple SSE messages arrive together.
@@ -77,19 +63,8 @@ export function useNotifications() {
                 continue;
             }
             dispatchToast(event, (path) => router.push(path));
-            dispatchBrowserNotification(event);
             const actionName = SEVERITY_TO_ACTION[event.severity];
             soundsByAction[actionName]?.play();
         }
     }, [events, soundsByAction, router]);
-    const requestBrowserPermission = useCallback(async () => {
-        if (typeof globalThis.Notification === 'undefined')
-            return;
-        const result = await globalThis.Notification.requestPermission();
-        setBrowserPermissionState(result);
-    }, []);
-    return {
-        requestBrowserPermission,
-        browserPermissionState,
-    };
 }

package/dist/src/presentation/web/hooks/use-notifications.stories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-notifications.stories.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/hooks/use-notifications.stories.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAqKvD,QAAA,MAAM,IAAI,EAAE,IAcX,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC;AAEtB,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC"}
+{"version":3,"file":"use-notifications.stories.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/hooks/use-notifications.stories.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAyIvD,QAAA,MAAM,IAAI,EAAE,IAcX,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC;AAEtB,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC"}

package/dist/src/presentation/web/hooks/use-notifications.stories.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useCallback, useMemo, useState } from 'react';
+import { useCallback, useMemo } from 'react';
 import { toast } from 'sonner';
 import { Toaster } from '../components/ui/sonner.js';
 import { Button } from '../components/ui/button.js';
@@ -24,46 +24,36 @@ function NotificationDemo() {
     const simulateNotification = useCallback((event) => {
         const method = event.severity ?? 'info';
         toast[method](event.featureName, { description: event.message });
-        if (globalThis.Notification?.permission === 'granted') {
-            new Notification(event.featureName, { body: event.message });
-        }
         const soundName = SEVERITY_SOUNDS[event.severity];
         soundsByName[soundName]?.play();
     }, [soundsByName]);
-    const [browserPermission, setBrowserPermission] = useState(typeof globalThis.Notification !== 'undefined' ? globalThis.Notification.permission : 'default');
-    const requestPermission = async () => {
-        if (typeof globalThis.Notification === 'undefined')
-            return;
-        const result = await globalThis.Notification.requestPermission();
-        setBrowserPermission(result);
-    };
-    return (_jsxs("div", { className: "flex w-[420px] flex-col gap-6", children: [_jsxs("div", { className: "flex flex-col gap-2", children: [_jsx("h3", { className: "text-sm font-semibold", children: "Browser Notification Permission" }), _jsxs("div", { className: "flex items-center gap-3", children: [_jsxs("span", { className: "text-muted-foreground text-sm", children: ["Status: ", _jsx("code", { className: "bg-muted rounded px-1.5 py-0.5", children: browserPermission })] }), _jsx(Button, { size: "sm", variant: "outline", onClick: requestPermission, children: "Request Permission" })] })] }), _jsxs("div", { className: "flex flex-col gap-2", children: [_jsx("h3", { className: "text-sm font-semibold", children: "Simulate Notification Events" }), _jsx("p", { className: "text-muted-foreground text-xs", children: "Click a button to fire a toast, browser notification, and sound." }), _jsxs("div", { className: "flex flex-wrap gap-2", children: [_jsx(Button, { size: "sm", variant: "outline", onClick: () => simulateNotification({
-                                    eventType: 'agent_started',
-                                    severity: 'info',
-                                    featureName: 'Auth Module',
-                                    message: 'Agent started running',
-                                }), children: "Agent Started" }), _jsx(Button, { size: "sm", variant: "outline", onClick: () => simulateNotification({
-                                    eventType: 'phase_completed',
-                                    severity: 'info',
-                                    featureName: 'Auth Module',
-                                    message: 'Completed analyze phase',
-                                    phaseName: 'analyze',
-                                }), children: "Phase Completed" }), _jsx(Button, { size: "sm", variant: "secondary", onClick: () => simulateNotification({
-                                    eventType: 'waiting_approval',
-                                    severity: 'warning',
-                                    featureName: 'Auth Module',
-                                    message: 'Waiting for user approval',
-                                }), children: "Waiting Approval" }), _jsx(Button, { size: "sm", onClick: () => simulateNotification({
-                                    eventType: 'agent_completed',
-                                    severity: 'success',
-                                    featureName: 'Auth Module',
-                                    message: 'Agent completed successfully',
-                                }), children: "Agent Completed" }), _jsx(Button, { size: "sm", variant: "destructive", onClick: () => simulateNotification({
-                                    eventType: 'agent_failed',
-                                    severity: 'error',
-                                    featureName: 'Auth Module',
-                                    message: 'Agent failed: token refresh error',
-                                }), children: "Agent Failed" })] })] })] }));
+    return (_jsx("div", { className: "flex w-[420px] flex-col gap-6", children: _jsxs("div", { className: "flex flex-col gap-2", children: [_jsx("h3", { className: "text-sm font-semibold", children: "Simulate Notification Events" }), _jsx("p", { className: "text-muted-foreground text-xs", children: "Click a button to fire a toast and sound." }), _jsxs("div", { className: "flex flex-wrap gap-2", children: [_jsx(Button, { size: "sm", variant: "outline", onClick: () => simulateNotification({
+                                eventType: 'agent_started',
+                                severity: 'info',
+                                featureName: 'Auth Module',
+                                message: 'Agent started running',
+                            }), children: "Agent Started" }), _jsx(Button, { size: "sm", variant: "outline", onClick: () => simulateNotification({
+                                eventType: 'phase_completed',
+                                severity: 'info',
+                                featureName: 'Auth Module',
+                                message: 'Completed analyze phase',
+                                phaseName: 'analyze',
+                            }), children: "Phase Completed" }), _jsx(Button, { size: "sm", variant: "secondary", onClick: () => simulateNotification({
+                                eventType: 'waiting_approval',
+                                severity: 'warning',
+                                featureName: 'Auth Module',
+                                message: 'Waiting for user approval',
+                            }), children: "Waiting Approval" }), _jsx(Button, { size: "sm", onClick: () => simulateNotification({
+                                eventType: 'agent_completed',
+                                severity: 'success',
+                                featureName: 'Auth Module',
+                                message: 'Agent completed successfully',
+                            }), children: "Agent Completed" }), _jsx(Button, { size: "sm", variant: "destructive", onClick: () => simulateNotification({
+                                eventType: 'agent_failed',
+                                severity: 'error',
+                                featureName: 'Auth Module',
+                                message: 'Agent failed: token refresh error',
+                            }), children: "Agent Failed" })] })] }) }));
 }
 const meta = {
     title: 'Hooks/useNotifications',

package/dist/src/presentation/web/lib/derive-graph.d.ts

@@ -0,0 +1,52 @@
+/**
+ * derive-graph.ts
+ *
+ * Pure client-side derivation: domain Maps → React Flow nodes + edges.
+ * All edges are derived from domain relationships (repositoryPath matching,
+ * parentNodeId) — never stored independently.
+ */
+import type { Edge } from '@xyflow/react';
+import type { CanvasNodeType } from '../components/features/features-canvas/index.js';
+import type { FeatureNodeData } from '../components/common/feature-node/index.js';
+import type { RepositoryNodeData } from '../components/common/repository-node/index.js';
+/** A feature node entry stored in the domain Map. */
+export interface FeatureEntry {
+    nodeId: string;
+    data: FeatureNodeData;
+    /** If set, this feature connects to a parent feature via a dependency edge (no repo→feature edge). */
+    parentNodeId?: string;
+}
+/** A repository node entry stored in the domain Map. */
+export interface RepoEntry {
+    nodeId: string;
+    data: RepositoryNodeData;
+}
+/** Stable callbacks passed by the consumer, injected into derived node data. */
+export interface GraphCallbacks {
+    /** Called when the user triggers an action on a feature node (e.g., adds a sub-feature). */
+    onNodeAction?: (nodeId: string) => void;
+    /** Called when the user opens settings/details on a feature node. */
+    onNodeSettings?: (nodeId: string) => void;
+    /** Called when the user deletes a feature. */
+    onFeatureDelete?: (featureId: string) => void;
+    /** Called when the user clicks the "+" add-feature button on a repo node. */
+    onRepositoryAdd?: (repoNodeId: string) => void;
+    /** Called when the user clicks a repo node to navigate to its detail page. */
+    onRepositoryClick?: (repoNodeId: string) => void;
+    /** Called when the user deletes a repository. */
+    onRepositoryDelete?: (repositoryId: string) => void;
+}
+/**
+ * Derives React Flow nodes and edges from domain Maps.
+ *
+ * - Feature nodes without a parentNodeId → repo→feature edge (matched by repositoryPath)
+ * - Feature nodes without a parentNodeId but with no matching repo → virtual repo node
+ * - Feature nodes with a parentNodeId → dependency edge (parentNodeId→nodeId)
+ * - Pending feature nodes (creating state) from pendingMap → same rules, no action callbacks
+ * - Callbacks are injected into node data via closures
+ */
+export declare function deriveGraph(featureMap: Map<string, FeatureEntry>, repoMap: Map<string, RepoEntry>, pendingMap: Map<string, FeatureEntry>, callbacks?: GraphCallbacks): {
+    nodes: CanvasNodeType[];
+    edges: Edge[];
+};
+//# sourceMappingURL=derive-graph.d.ts.map

package/dist/src/presentation/web/lib/derive-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive-graph.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/derive-graph.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,qDAAqD;AACrD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,eAAe,CAAC;IACtB,sGAAsG;IACtG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wDAAwD;AACxD,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,kBAAkB,CAAC;CAC1B;AAED,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC7B,4FAA4F;IAC5F,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,qEAAqE;IACrE,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,8CAA8C;IAC9C,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,6EAA6E;IAC7E,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,8EAA8E;IAC9E,iBAAiB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,iDAAiD;IACjD,kBAAkB,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACrC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACrC,SAAS,CAAC,EAAE,cAAc,GACzB;IAAE,KAAK,EAAE,cAAc,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAyH5C"}

package/dist/src/presentation/web/lib/derive-graph.js

@@ -0,0 +1,126 @@
+/**
+ * derive-graph.ts
+ *
+ * Pure client-side derivation: domain Maps → React Flow nodes + edges.
+ * All edges are derived from domain relationships (repositoryPath matching,
+ * parentNodeId) — never stored independently.
+ */
+/**
+ * Derives React Flow nodes and edges from domain Maps.
+ *
+ * - Feature nodes without a parentNodeId → repo→feature edge (matched by repositoryPath)
+ * - Feature nodes without a parentNodeId but with no matching repo → virtual repo node
+ * - Feature nodes with a parentNodeId → dependency edge (parentNodeId→nodeId)
+ * - Pending feature nodes (creating state) from pendingMap → same rules, no action callbacks
+ * - Callbacks are injected into node data via closures
+ */
+export function deriveGraph(featureMap, repoMap, pendingMap, callbacks) {
+    const nodes = [];
+    const edges = [];
+    // Build a lookup: repositoryPath → repoNodeId
+    const repoByPath = new Map();
+    for (const [nodeId, entry] of repoMap) {
+        if (entry.data.repositoryPath) {
+            repoByPath.set(entry.data.repositoryPath, nodeId);
+        }
+    }
+    // Virtual repo nodes created for orphaned features (not in repoMap)
+    const virtualRepos = new Map(); // path → virtualNodeId
+    function getOrCreateVirtualRepo(repositoryPath) {
+        if (virtualRepos.has(repositoryPath)) {
+            return virtualRepos.get(repositoryPath);
+        }
+        const virtualId = `virtual-repo-${repositoryPath}`;
+        const repoName = repositoryPath.split('/').filter(Boolean).at(-1) ?? repositoryPath;
+        nodes.push({
+            id: virtualId,
+            type: 'repositoryNode',
+            position: { x: 0, y: 0 },
+            data: { name: repoName, repositoryPath },
+        });
+        virtualRepos.set(repositoryPath, virtualId);
+        return virtualId;
+    }
+    // Add repo nodes (real ones)
+    for (const [nodeId, entry] of repoMap) {
+        const data = {
+            ...entry.data,
+            ...(callbacks?.onRepositoryAdd && {
+                onAdd: () => callbacks.onRepositoryAdd(nodeId),
+            }),
+            ...(callbacks?.onRepositoryClick && {
+                onClick: () => callbacks.onRepositoryClick(nodeId),
+            }),
+            ...(callbacks?.onRepositoryDelete && {
+                onDelete: callbacks.onRepositoryDelete,
+            }),
+        };
+        nodes.push({
+            id: nodeId,
+            type: 'repositoryNode',
+            position: { x: 0, y: 0 },
+            data,
+        });
+    }
+    // Process feature entries (both real and pending).
+    // Skip pendingMap entries that already exist in featureMap (reconcile may not
+    // have cleaned them up yet if the AI-generated name differs from the original).
+    const allFeatureEntries = [
+        ...[...featureMap.entries()].map(([id, e]) => [id, e, false]),
+        ...[...pendingMap.entries()]
+            .filter(([id]) => !featureMap.has(id))
+            .map(([id, e]) => [id, e, true]),
+    ];
+    for (const [nodeId, entry, isPending] of allFeatureEntries) {
+        const isCreating = entry.data.state === 'creating' || isPending;
+        const data = {
+            ...entry.data,
+            // Callbacks only for non-creating nodes
+            ...(!isCreating &&
+                callbacks?.onNodeAction && {
+                onAction: () => callbacks.onNodeAction(nodeId),
+            }),
+            ...(!isCreating &&
+                callbacks?.onNodeSettings && {
+                onSettings: () => callbacks.onNodeSettings(nodeId),
+            }),
+            ...(!isCreating &&
+                callbacks?.onFeatureDelete && {
+                onDelete: callbacks.onFeatureDelete,
+            }),
+        };
+        nodes.push({
+            id: nodeId,
+            type: 'featureNode',
+            position: { x: 0, y: 0 },
+            data,
+        });
+        // Edge derivation
+        if (entry.parentNodeId) {
+            // Dependency edge (parent→child feature)
+            edges.push({
+                id: `dep-${entry.parentNodeId}-${nodeId}`,
+                source: entry.parentNodeId,
+                target: nodeId,
+                type: 'dependencyEdge',
+            });
+        }
+        else {
+            // Repo→feature edge (matched by repositoryPath)
+            const repositoryPath = entry.data.repositoryPath;
+            const repoNodeId = repoByPath.get(repositoryPath) ?? getOrCreateVirtualRepo(repositoryPath);
+            edges.push({
+                id: `edge-${repoNodeId}-${nodeId}`,
+                source: repoNodeId,
+                target: nodeId,
+                style: { strokeDasharray: '5 5' },
+            });
+        }
+    }
+    // Inject showHandles based on whether there are any edges
+    const hasEdges = edges.length > 0;
+    for (const node of nodes) {
+        node.data.showHandles = hasEdges;
+    }
+    return { nodes, edges };
+}

package/dist/src/presentation/web/lib/layout-with-dagre.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout-with-dagre.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/layout-with-dagre.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,+DAA+D;AAC/D,eAAO,MAAM,sBAAsB,EAAE,aAIpC,CAAC;AAmCF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,IAAI,EAC5C,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,GAAE,aAAkB,GACvB;IAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAoK/B"}
+{"version":3,"file":"layout-with-dagre.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/layout-with-dagre.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,+DAA+D;AAC/D,eAAO,MAAM,sBAAsB,EAAE,aAIpC,CAAC;AAkCF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,IAAI,EAC5C,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,GAAE,aAAkB,GACvB;IAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAoK/B"}

package/dist/src/presentation/web/lib/layout-with-dagre.js

@@ -8,8 +8,7 @@ export const CANVAS_LAYOUT_DEFAULTS = {
 /** Known node-type dimensions for the canvas node types */
 const NODE_DIMENSIONS = {
     featureNode: { width: 288, height: 140 },
-    repositoryNode: { width: 288, height: 50 },
-    addRepositoryNode: { width: 224, height: 50 },
+    repositoryNode: { width: 328, height: 50 },
 };
 function getNodeSize(node, defaultSize) {
     // Prefer per-node size from data, then type-based lookup, then default

package/dist/src/presentation/web/lib/logger.d.ts

@@ -0,0 +1,7 @@
+export declare function createLogger(prefix: string): {
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/presentation/web/lib/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/logger.ts"],"names":[],"mappings":"AAIA,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;oBAEb,OAAO,EAAE;qBACR,OAAO,EAAE;oBACpB,OAAO,EAAE;qBACR,OAAO,EAAE;EAE7B"}

package/dist/src/presentation/web/lib/logger.js

@@ -0,0 +1,11 @@
+/* eslint-disable no-console */
+const isDebug = !!process.env.NEXT_PUBLIC_DEBUG;
+const noop = () => undefined;
+export function createLogger(prefix) {
+    return {
+        info: isDebug ? (...args) => console.info(prefix, ...args) : noop,
+        debug: isDebug ? (...args) => console.debug(prefix, ...args) : noop,
+        warn: (...args) => console.warn(prefix, ...args),
+        error: (...args) => console.error(prefix, ...args),
+    };
+}