@nemus-cli/nemus 0.2.1

package/dist/cli/dashboard/DashboardSidebar.js

@@ -0,0 +1,280 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardSidebar = void 0;
+const React = __importStar(require("react"));
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const agent_state_1 = require("../../utils/agent-state");
+const dashboard_1 = require("../../types/dashboard");
+const AgentList_1 = require("./AgentList");
+const HelpFooter_1 = require("./HelpFooter");
+const tmux_dashboard_1 = require("../../utils/tmux-dashboard");
+const { sessionName, pollIntervalMs } = dashboard_1.DASHBOARD_DEFAULTS;
+const DashboardSidebar = ({ Box, Text, useInput, useApp }) => {
+    const [agents, setAgents] = React.useState([]);
+    const [selectedIndex, setSelectedIndex] = React.useState(0);
+    const [isZoomed, setIsZoomed] = React.useState(false);
+    const { exit } = useApp();
+    // Refs for always-current values inside the useInput closure
+    const agentsRef = React.useRef([]);
+    const selectedIndexRef = React.useRef(0);
+    const isZoomedRef = React.useRef(false);
+    // Store original pane PID order before zoom so we can restore it
+    const originalPaneOrderRef = React.useRef([]);
+    // Poll agent states every 2s
+    React.useEffect(() => {
+        function refresh() {
+            const visiblePanes = (0, tmux_dashboard_1.getAgentPanes)();
+            const hiddenPanes = (0, tmux_dashboard_1.getHiddenPanes)();
+            const allPanes = [...visiblePanes, ...hiddenPanes];
+            const panePids = new Set(allPanes.map(p => p.pid));
+            const allStates = (0, agent_state_1.readAllAgentStates)().filter(s => {
+                if (s.status === 'stopped')
+                    return false;
+                return panePids.has(s.pid);
+            });
+            // When zoomed, sort by the original pane order so the sidebar
+            // display stays stable (zoomed pane doesn't jump to the top)
+            const originalOrder = originalPaneOrderRef.current;
+            let sorted;
+            if (originalOrder.length > 0) {
+                sorted = (0, tmux_dashboard_1.sortAgentsByPidOrder)(allStates, originalOrder);
+            }
+            else {
+                sorted = (0, tmux_dashboard_1.sortAgentsByPaneOrder)(allStates, allPanes);
+            }
+            agentsRef.current = sorted;
+            setAgents(sorted);
+        }
+        refresh();
+        const timer = setInterval(refresh, pollIntervalMs);
+        return () => clearInterval(timer);
+    }, []);
+    // Keep selectedIndex ref in sync
+    React.useEffect(() => {
+        selectedIndexRef.current = selectedIndex;
+    }, [selectedIndex]);
+    // Keep isZoomed ref in sync
+    React.useEffect(() => {
+        isZoomedRef.current = isZoomed;
+    }, [isZoomed]);
+    // Clamp selection — handles both too-high and negative values
+    const clampedIndex = Math.min(Math.max(selectedIndex, 0), Math.max(0, agents.length - 1));
+    if (clampedIndex !== selectedIndex) {
+        setSelectedIndex(clampedIndex);
+        selectedIndexRef.current = clampedIndex;
+    }
+    /**
+     * Apply zoom to a specific agent index.
+     */
+    function applyZoom(agentIndex) {
+        const currentAgents = agentsRef.current;
+        if (agentIndex >= currentAgents.length)
+            return;
+        if (isZoomedRef.current) {
+            // Already zoomed — restore panes in original order, then re-zoom
+            (0, tmux_dashboard_1.restoreHiddenPanes)(originalPaneOrderRef.current);
+        }
+        else {
+            // First zoom — capture the current pane order before hiding anything
+            const panes = (0, tmux_dashboard_1.getAgentPanes)();
+            originalPaneOrderRef.current = panes.map(p => p.pid);
+            (0, tmux_dashboard_1.restoreHiddenPanes)(); // no-op if nothing hidden
+        }
+        (0, child_process_1.spawnSync)('tmux', ['select-layout', '-t', sessionName, 'main-vertical'], { stdio: 'pipe' });
+        (0, child_process_1.spawnSync)('tmux', ['resize-pane', '-t', `${sessionName}:0.0`, '-x', '32'], { stdio: 'pipe' });
+        const panes = (0, tmux_dashboard_1.getAgentPanes)();
+        const pane = (0, tmux_dashboard_1.findPaneForAgent)(currentAgents[agentIndex], panes);
+        if (pane) {
+            (0, tmux_dashboard_1.zoomPane)(pane);
+            setIsZoomed(true);
+            isZoomedRef.current = true;
+        }
+    }
+    /**
+     * Unzoom and reset layout, restoring original pane order.
+     */
+    function unzoom() {
+        (0, tmux_dashboard_1.restoreHiddenPanes)(originalPaneOrderRef.current);
+        originalPaneOrderRef.current = [];
+        (0, child_process_1.spawnSync)('tmux', ['select-layout', '-t', sessionName, 'main-vertical'], { stdio: 'pipe' });
+        (0, child_process_1.spawnSync)('tmux', ['resize-pane', '-t', `${sessionName}:0.0`, '-x', '32'], { stdio: 'pipe' });
+        (0, child_process_1.spawnSync)('tmux', ['select-pane', '-t', `${sessionName}:0.0`], { stdio: 'pipe' });
+        setIsZoomed(false);
+        isZoomedRef.current = false;
+    }
+    // Keyboard handling — reads from refs for always-current data
+    useInput((input, key) => {
+        const currentAgents = agentsRef.current;
+        const currentIdx = selectedIndexRef.current;
+        const currentZoomed = isZoomedRef.current;
+        const clampedIdx = Math.min(Math.max(currentIdx, 0), Math.max(0, currentAgents.length - 1));
+        // q — detach (session stays running in background, agents keep working)
+        if (input === 'q') {
+            (0, tmux_dashboard_1.restoreHiddenPanes)();
+            (0, child_process_1.spawnSync)('tmux', ['detach-client', '-s', sessionName], { stdio: 'pipe' });
+            // Do NOT call exit() — the sidebar process must keep running so
+            // the session is alive when the user re-attaches with 'w dash'
+            return;
+        }
+        // Q (shift+q) — kill session and all agents
+        if (input === 'Q') {
+            (0, tmux_dashboard_1.restoreHiddenPanes)();
+            (0, child_process_1.spawnSync)('tmux', ['kill-session', '-t', sessionName], { stdio: 'pipe' });
+            exit();
+            return;
+        }
+        // Navigation
+        if (key.upArrow || input === 'K') {
+            const next = Math.max(0, clampedIdx - 1);
+            setSelectedIndex(next);
+            selectedIndexRef.current = next;
+            return;
+        }
+        if (key.downArrow || input === 'J') {
+            const next = Math.max(0, Math.min(currentAgents.length - 1, clampedIdx + 1));
+            setSelectedIndex(next);
+            selectedIndexRef.current = next;
+            return;
+        }
+        // Number keys 1-9
+        if (input >= '1' && input <= '9') {
+            const idx = parseInt(input, 10) - 1;
+            if (idx < currentAgents.length) {
+                setSelectedIndex(idx);
+                selectedIndexRef.current = idx;
+            }
+            return;
+        }
+        // Focus — switch to agent pane
+        if (input === 'f' || key.return) {
+            if (clampedIdx < currentAgents.length) {
+                if (currentZoomed) {
+                    applyZoom(clampedIdx);
+                    const panes = (0, tmux_dashboard_1.getAgentPanes)();
+                    const pane = (0, tmux_dashboard_1.findPaneForAgent)(currentAgents[clampedIdx], panes);
+                    if (pane) {
+                        (0, child_process_1.spawnSync)('tmux', ['select-pane', '-t', `${sessionName}:0.${pane.index}`], { stdio: 'pipe' });
+                    }
+                }
+                else {
+                    const panes = (0, tmux_dashboard_1.getAgentPanes)();
+                    const pane = (0, tmux_dashboard_1.findPaneForAgent)(currentAgents[clampedIdx], panes);
+                    if (pane) {
+                        (0, child_process_1.spawnSync)('tmux', ['select-pane', '-t', `${sessionName}:0.${pane.index}`], { stdio: 'pipe' });
+                    }
+                }
+            }
+            return;
+        }
+        // Zoom toggle
+        if (input === 'z') {
+            if (currentZoomed) {
+                unzoom();
+                isZoomedRef.current = false;
+            }
+            else {
+                applyZoom(clampedIdx);
+            }
+            return;
+        }
+        // Reset layout
+        if (input === 'r') {
+            unzoom();
+            isZoomedRef.current = false;
+            return;
+        }
+        // New agent
+        if (input === 'n') {
+            if (currentZoomed) {
+                unzoom();
+                isZoomedRef.current = false;
+            }
+            const pickerScript = path.join(__dirname, '..', '..', 'commands', 'dashboard', 'workspace-picker.js');
+            const popupResult = (0, child_process_1.spawnSync)('tmux', [
+                'display-popup', '-E', '-w', '60%', '-h', '60%',
+                '-t', sessionName,
+                `node "${pickerScript}"`,
+            ], { stdio: 'pipe' });
+            if (popupResult.status !== 0) {
+                (0, child_process_1.spawnSync)('tmux', ['split-window', '-t', sessionName, '-v', `node "${pickerScript}"`], { stdio: 'pipe' });
+            }
+            setTimeout(() => (0, tmux_dashboard_1.resetLayout)(), 500);
+            return;
+        }
+        // Resume session
+        if (input === 's') {
+            if (currentZoomed) {
+                unzoom();
+                isZoomedRef.current = false;
+            }
+            const sessionPickerScript = path.join(__dirname, '..', '..', 'commands', 'dashboard', 'session-picker.js');
+            const popupResult = (0, child_process_1.spawnSync)('tmux', [
+                'display-popup', '-E', '-w', '60%', '-h', '60%',
+                '-t', sessionName,
+                `node "${sessionPickerScript}"`,
+            ], { stdio: 'pipe' });
+            if (popupResult.status !== 0) {
+                (0, child_process_1.spawnSync)('tmux', ['split-window', '-t', sessionName, '-v', `node "${sessionPickerScript}"`], { stdio: 'pipe' });
+            }
+            setTimeout(() => (0, tmux_dashboard_1.resetLayout)(), 500);
+            return;
+        }
+        // Kill / close session
+        if (input === 'x') {
+            if (clampedIdx < currentAgents.length) {
+                if (currentZoomed) {
+                    unzoom();
+                    isZoomedRef.current = false;
+                }
+                const panes = (0, tmux_dashboard_1.getAgentPanes)();
+                const pane = (0, tmux_dashboard_1.findPaneForAgent)(currentAgents[clampedIdx], panes);
+                if (pane) {
+                    (0, child_process_1.spawnSync)('tmux', ['kill-pane', '-t', `${sessionName}:0.${pane.index}`], { stdio: 'pipe' });
+                    setTimeout(() => (0, tmux_dashboard_1.resetLayout)(), 100);
+                }
+            }
+            return;
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, '─ Agent Dashboard ─'),
+            isZoomed && React.createElement(Text, { color: "yellow" }, " [ZOOM]")),
+        React.createElement(AgentList_1.AgentList, { agents: agents, selectedIndex: clampedIndex, onSelect: setSelectedIndex, Box: Box, Text: Text }),
+        React.createElement(HelpFooter_1.HelpFooter, { isZoomed: isZoomed, Box: Box, Text: Text })));
+};
+exports.DashboardSidebar = DashboardSidebar;

package/dist/cli/dashboard/HelpFooter.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpFooter = void 0;
+const React = __importStar(require("react"));
+const HelpFooter = ({ isZoomed, Box, Text }) => {
+    return (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+        React.createElement(Text, { dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+        React.createElement(Text, null,
+            React.createElement(Text, { color: "yellow" }, "\u2191\u2193"),
+            " select  ",
+            React.createElement(Text, { color: "yellow" }, "f"),
+            "/\u23CE focus"),
+        React.createElement(Text, null,
+            React.createElement(Text, { color: "yellow" }, "z"),
+            "  ",
+            isZoomed ? 'unzoom' : 'zoom',
+            "    ",
+            React.createElement(Text, { color: "yellow" }, "x"),
+            "   kill"),
+        React.createElement(Text, null,
+            React.createElement(Text, { color: "yellow" }, "n"),
+            "  new     ",
+            React.createElement(Text, { color: "yellow" }, "q"),
+            "   detach"),
+        React.createElement(Text, null,
+            React.createElement(Text, { color: "yellow" }, "s"),
+            "  resume  ",
+            React.createElement(Text, { color: "yellow" }, "Q"),
+            "   quit all"),
+        React.createElement(Text, null,
+            React.createElement(Text, { color: "yellow" }, "r"),
+            "  reset layout"),
+        React.createElement(Text, { dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+        React.createElement(Text, { dimColor: true }, "From agent pane:"),
+        React.createElement(Text, null,
+            " ",
+            React.createElement(Text, { color: "yellow" }, "prefix+M"),
+            " sidebar/reset")));
+};
+exports.HelpFooter = HelpFooter;

package/dist/cli/dashboard/StatusBadge.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusBadge = void 0;
+const React = __importStar(require("react"));
+const STATUS_CONFIG = {
+    working: { icon: '●', color: 'green', label: 'working' },
+    waiting: { icon: '●', color: 'yellow', label: 'approve' },
+    idle: { icon: '◌', color: 'gray', label: 'idle' },
+    stopped: { icon: '✕', color: 'red', label: 'stopped' },
+};
+const StatusBadge = ({ status, Box, Text }) => {
+    const config = STATUS_CONFIG[status] || STATUS_CONFIG.idle;
+    return (React.createElement(Box, { gap: 1 },
+        React.createElement(Text, { color: config.color }, config.icon),
+        React.createElement(Text, { color: config.color }, config.label)));
+};
+exports.StatusBadge = StatusBadge;

package/dist/cli/dashboard/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpFooter = exports.StatusBadge = exports.AgentList = exports.DashboardSidebar = void 0;
+var DashboardSidebar_1 = require("./DashboardSidebar");
+Object.defineProperty(exports, "DashboardSidebar", { enumerable: true, get: function () { return DashboardSidebar_1.DashboardSidebar; } });
+var AgentList_1 = require("./AgentList");
+Object.defineProperty(exports, "AgentList", { enumerable: true, get: function () { return AgentList_1.AgentList; } });
+var StatusBadge_1 = require("./StatusBadge");
+Object.defineProperty(exports, "StatusBadge", { enumerable: true, get: function () { return StatusBadge_1.StatusBadge; } });
+var HelpFooter_1 = require("./HelpFooter");
+Object.defineProperty(exports, "HelpFooter", { enumerable: true, get: function () { return HelpFooter_1.HelpFooter; } });

package/dist/cli/dashboard/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/tui.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+"use strict";
+// TUI implementation - simplified version without ink for now
+// Full ink-based implementation can be added after dependencies are installed
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const workspace_meta_1 = require("../utils/workspace-meta");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const main = async () => {
+    try {
+        (0, logger_1.logInfo)('Interactive TUI mode');
+        console.log((0, colors_1.colorize)('\n╔══════════════════════════════════════════╗', 'cyan'));
+        console.log((0, colors_1.colorize)('║    Workspace Manager - Interactive UI   ║', 'cyan'));
+        console.log((0, colors_1.colorize)('╚══════════════════════════════════════════╝\n', 'cyan'));
+        const workspaces = await (0, workspace_meta_1.listWorkspaces)();
+        if (workspaces.length === 0) {
+            (0, logger_1.logError)('No workspaces found');
+            console.log((0, colors_1.colorize)('Create a workspace with: workspace create', 'gray'));
+            process.exit(1);
+        }
+        console.log((0, colors_1.colorize)('Available Workspaces:', 'bright'));
+        for (let i = 0; i < workspaces.length; i++) {
+            const ws = workspaces[i];
+            const repoCount = ws.metadata?.repositories.length || 0;
+            console.log(`  ${i + 1}. ${(0, colors_1.colorize)(ws.name, 'cyan')} (${repoCount} repos)`);
+        }
+        console.log('\n' + (0, colors_1.colorize)('Commands:', 'bright'));
+        console.log('  workspace status <name>    - Check git status');
+        console.log('  workspace doctor <name>    - Run health checks');
+        console.log('  workspace sync <name>      - Pull latest changes');
+        console.log('  wgo <name>                 - Navigate to workspace');
+        console.log('');
+        (0, logger_1.logInfo)('Full interactive TUI with ink will be available after running: npm install');
+    }
+    catch (error) {
+        (0, logger_1.logError)('TUI failed');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        process.exit(1);
+    }
+};
+exports.main = main;
+// Auto-execute only when run directly (not when imported by Commander)
+if (require.main === module) {
+    (0, exports.main)();
+}

package/dist/commands/ai-prompt.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAiPrompt = handleAiPrompt;
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const ai_prompt_1 = require("../cli/ai-prompt");
+/**
+ * Handle the `nemus -- <prompt>` command.
+ * This is called directly from bin/workspace.js before Commander parses,
+ * because Commander treats `--` as end-of-options.
+ */
+async function handleAiPrompt(prompt) {
+    if (!prompt || !prompt.trim()) {
+        (0, logger_1.logError)('No prompt provided');
+        console.log(`\n  Usage: ${(0, colors_1.colorize)('nemus -- <prompt>', 'green')}`);
+        console.log(`  Example: ${(0, colors_1.colorize)('nemus -- create a workspace for the payments team', 'gray')}\n`);
+        process.exit(1);
+        return;
+    }
+    const exitCode = await (0, ai_prompt_1.run)(prompt.trim());
+    process.exit(exitCode);
+}

package/dist/commands/analyze-deps.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAnalyzeDepsCommand = registerAnalyzeDepsCommand;
+const path = __importStar(require("path"));
+const config_1 = require("../utils/config");
+const workspace_meta_1 = require("../utils/workspace-meta");
+const dependency_analyzer_1 = require("../utils/dependency-analyzer");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const inquirer_1 = __importDefault(require("inquirer"));
+const command_helpers_1 = require("../utils/command-helpers");
+const displayDependencyAnalysis = (analyses) => {
+    console.log('\n' + (0, colors_1.colorize)('Dependency Analysis', 'bright'));
+    console.log((0, colors_1.colorize)('═'.repeat(100), 'gray'));
+    for (const [repoName, analysis] of analyses) {
+        console.log(`\n${(0, colors_1.colorize)(repoName, 'cyan')}`);
+        if (analysis.dependencies.length > 0) {
+            console.log(`  ${(0, colors_1.colorize)('Depends on:', 'gray')} ${analysis.dependencies.join(', ')}`);
+        }
+        if (analysis.dependents.length > 0) {
+            console.log(`  ${(0, colors_1.colorize)('Depended by:', 'gray')} ${analysis.dependents.join(', ')}`);
+        }
+        if (analysis.missingDependencies.length > 0) {
+            console.log(`  ${(0, colors_1.colorize)('⚠ Missing deps:', 'yellow')} ${analysis.missingDependencies.join(', ')}`);
+        }
+        if (analysis.dependencies.length === 0 && analysis.dependents.length === 0 && analysis.missingDependencies.length === 0) {
+            console.log(`  ${(0, colors_1.colorize)('No dependencies detected', 'gray')}`);
+        }
+    }
+    console.log('\n' + (0, colors_1.colorize)('═'.repeat(100), 'gray'));
+};
+function registerAnalyzeDepsCommand(parent) {
+    parent
+        .command('analyze-deps')
+        .alias('ad')
+        .description('Analyze inter-repo dependencies')
+        .argument('[workspace]', 'Workspace name')
+        .action(async (workspace) => {
+        await handleAnalyzeDeps(workspace);
+    });
+}
+async function handleAnalyzeDeps(workspaceArg) {
+    try {
+        const selectedWorkspace = await (0, command_helpers_1.resolveWorkspace)(workspaceArg);
+        const workspacePath = path.join(config_1.WORKSPACES_DIR, selectedWorkspace);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            (0, logger_1.logError)(`Workspace metadata not found for: ${selectedWorkspace}`);
+            process.exit(1);
+        }
+        (0, logger_1.logStep)(`Analyzing dependencies for workspace: ${(0, colors_1.colorize)(selectedWorkspace, 'cyan')}`);
+        (0, logger_1.logInfo)('Scanning package.json, Dockerfile, and docker-compose.yml files...');
+        const repoNames = metadata.repositories.map(r => r.name);
+        const analyses = await (0, dependency_analyzer_1.analyzeDependencies)(workspacePath, repoNames);
+        displayDependencyAnalysis(analyses);
+        const cycles = (0, dependency_analyzer_1.detectCircularDependencies)(analyses);
+        if (cycles.length > 0) {
+            console.log('\n' + (0, colors_1.colorize)('⚠ Circular Dependencies Detected:', 'yellow'));
+            for (const cycle of cycles) {
+                console.log(`  ${cycle.join(' → ')}`);
+            }
+        }
+        const diagram = (0, dependency_analyzer_1.generateMermaidDiagram)(analyses);
+        console.log('\n' + (0, colors_1.colorize)('Dependency Graph (Mermaid):', 'bright'));
+        console.log(diagram);
+        const missingDeps = new Set();
+        for (const [, analysis] of analyses) {
+            for (const dep of analysis.missingDependencies) {
+                missingDeps.add(dep);
+            }
+        }
+        if (missingDeps.size > 0) {
+            console.log('\n' + (0, colors_1.colorize)('💡 Suggested Missing Repositories:', 'yellow'));
+            for (const dep of missingDeps) {
+                console.log(`  • ${dep}`);
+            }
+            (0, logger_1.logInfo)(`Consider adding these repositories with: workspace update ${selectedWorkspace}`);
+        }
+        if (process.stdout.isTTY) {
+            const { saveToMetadata } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'saveToMetadata',
+                    message: 'Save dependency analysis to workspace metadata?',
+                    default: true,
+                },
+            ]);
+            if (saveToMetadata) {
+                const updatedMetadata = (0, dependency_analyzer_1.updateWorkspaceMetadata)(metadata, analyses);
+                await (0, workspace_meta_1.saveMetadata)(workspacePath, updatedMetadata);
+                (0, logger_1.logSuccess)('Dependency analysis saved to metadata');
+            }
+        }
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to analyze dependencies');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        process.exit(1);
+    }
+}