@factorim/monotui 0.1.0

package/src/contexts/ProjectGridContext.tsx

@@ -0,0 +1,92 @@
+import { createContext, type JSX, type ReactNode, useMemo } from "react"
+
+import { useProjectGrid } from "../hooks/useProjectGrid.js"
+import {
+  getCommandFromCell,
+  getExecFromCell,
+  runCellCommand,
+  shouldKeepTuiOpen,
+} from "../services/runtime/command-runner.js"
+import { Page } from "../types/page.js"
+import type { Project } from "../types/project.js"
+import type { ProjectGridGrid } from "../types/project-grid.js"
+import {
+  buildProjectGrid,
+  getProjectCellByPosition,
+} from "../utils/project/project-grid.js"
+
+interface ProjectGridContextType {
+  project?: Project
+  workspaceNavigationGrid: ProjectGridGrid
+  row: number
+  col: number
+}
+
+export const ProjectGridContext = createContext<ProjectGridContextType>(
+  {} as ProjectGridContextType,
+)
+
+// The React 19 / TypeScript 5.9 Fix
+const Provider = ProjectGridContext as unknown as (props: {
+  value: ProjectGridContextType
+  children: ReactNode
+}) => JSX.Element
+
+interface ProjectGridProviderProps {
+  children: ReactNode
+  project: Project
+  setPage: (page: Page) => void
+  setProject: (project: Project | null) => void
+}
+
+export function ProjectGridProvider({
+  children,
+  project,
+  setPage,
+  setProject,
+}: ProjectGridProviderProps) {
+  const workspaceNavigationGrid = useMemo(
+    () => buildProjectGrid(project),
+    [project],
+  )
+
+  const { position } = useProjectGrid({
+    grid: workspaceNavigationGrid,
+    onExit: () => {
+      setPage(Page.Workspace)
+      setProject(null)
+    },
+    onSelect: (newRow, newCol) => {
+      const cell = getProjectCellByPosition(
+        workspaceNavigationGrid,
+        newRow,
+        newCol,
+      )
+
+      if (cell) {
+        const command = getCommandFromCell(cell)
+        const exec = getExecFromCell(cell)
+        if (command && exec) {
+          const keepTuiOpen = shouldKeepTuiOpen(exec)
+          runCellCommand(command, project.path, { detached: keepTuiOpen })
+          if (!keepTuiOpen) {
+            setPage(Page.Exit)
+          }
+        }
+      }
+    },
+  })
+
+  return (
+    <Provider
+      value={{
+        project,
+        workspaceNavigationGrid,
+        row: position.row,
+        col: position.col,
+      }}
+    >
+      {children}
+    </Provider>
+  )
+}

package/src/contexts/WorkspaceDiscoveryContext.tsx

@@ -0,0 +1,46 @@
+import {
+  createContext,
+  type JSX,
+  type ReactNode,
+  useMemo,
+  useState,
+} from "react"
+
+import { useWorkspaceDiscovery } from "../hooks/useWorkspaceDiscovery.js"
+import { useWorkspaceRuntime } from "../hooks/useWorkspaceRuntime.js"
+import type { Project } from "../types/project.js"
+import type { WorkspaceRuntimeState } from "../types/workspace-runtime.js"
+
+interface WorkspaceDiscoveryContextType {
+  projects: Project[]
+  workspaceRuntimes: WorkspaceRuntimeState[]
+  project: Project | null
+  setProject: (project: Project | null) => void
+}
+
+export const WorkspaceDiscoveryContext =
+  createContext<WorkspaceDiscoveryContextType>(
+    {} as WorkspaceDiscoveryContextType,
+  )
+
+const Provider = WorkspaceDiscoveryContext as unknown as (props: {
+  value: WorkspaceDiscoveryContextType
+  children: ReactNode
+}) => JSX.Element
+
+export function WorkspaceDiscoveryProvider({
+  children,
+}: {
+  children: ReactNode
+}) {
+  const [project, setProject] = useState<Project | null>(null)
+  const rootPath = useMemo(() => process.cwd(), [])
+  const { projects } = useWorkspaceDiscovery(rootPath)
+  const workspaceRuntimes = useWorkspaceRuntime(projects)
+
+  return (
+    <Provider value={{ projects, workspaceRuntimes, project, setProject }}>
+      {children}
+    </Provider>
+  )
+}

package/src/contexts/WorkspaceGridContext.tsx

@@ -0,0 +1,113 @@
+import { createContext, type JSX, type ReactNode, useMemo } from "react"
+
+import { useWorkspaceGrid } from "../hooks/useWorkspaceGrid.js"
+import {
+  runCellCommand,
+  shouldKeepTuiOpen,
+} from "../services/runtime/command-runner.js"
+import { Page } from "../types/page.js"
+import type { Project } from "../types/project.js"
+import type { CursorPosition } from "../types/workspace-grid.js"
+import type { WorkspaceQuickAction } from "../types/workspace-quick-actions.js"
+import type { WorkspaceRuntimeState } from "../types/workspace-runtime.js"
+import { logger } from "../utils/logging/logger.js"
+import {
+  buildWorkspacesGrid,
+  getWorkspaceCellByPosition,
+} from "../utils/workspace/workspace-grid.js"
+
+interface WorkspaceGridContextType {
+  projects?: Project[]
+  workspaceQuickActions?: WorkspaceQuickAction[]
+  workspaceRuntimes?: WorkspaceRuntimeState[]
+  workspacesNavigationGrid: ReturnType<typeof buildWorkspacesGrid>
+  row: number
+  col: number
+}
+
+export const WorkspaceGridContext = createContext<WorkspaceGridContextType>(
+  {} as WorkspaceGridContextType,
+)
+
+// The Type-Safe Provider Fix
+const Provider = WorkspaceGridContext as unknown as (props: {
+  value: WorkspaceGridContextType
+  children: ReactNode
+}) => JSX.Element
+
+interface WorkspacesNavigationProviderProps {
+  children: ReactNode
+  projects: Project[]
+  workspaceQuickActions?: WorkspaceQuickAction[]
+  workspaceRuntimes: WorkspaceRuntimeState[]
+  initialPosition?: CursorPosition
+  setPage: (page: Page) => void
+  setProject: (workspace: Project | null) => void
+  onPositionChange?: (position: CursorPosition) => void
+}
+
+export function WorkspacesNavigationProvider({
+  children,
+  projects,
+  workspaceQuickActions,
+  workspaceRuntimes,
+  initialPosition,
+  setPage,
+  setProject,
+  onPositionChange,
+}: WorkspacesNavigationProviderProps) {
+  const workspacesNavigationGrid = useMemo(
+    () =>
+      buildWorkspacesGrid(
+        projects,
+        workspaceQuickActions ?? [],
+        workspaceRuntimes,
+      ),
+    [projects, workspaceQuickActions, workspaceRuntimes],
+  )
+
+  const { position } = useWorkspaceGrid({
+    grid: workspacesNavigationGrid,
+    initialPosition,
+    onSelect: (newRow, newCol) => {
+      const selectedCell = getWorkspaceCellByPosition(
+        workspacesNavigationGrid,
+        newRow,
+        newCol,
+      )
+
+      logger.debug(`Selected position: Row ${newRow}, Col ${newCol}`)
+      onPositionChange?.({ row: newRow, col: newCol })
+
+      if (selectedCell?.type === "workspace") {
+        setPage(Page.Project)
+        setProject(selectedCell.workspace)
+      } else if (selectedCell?.type === "quickAction") {
+        const workspace = projects[newRow]
+        const command = selectedCell.action.command
+        const keepTuiOpen = shouldKeepTuiOpen(selectedCell.action.exec)
+        runCellCommand(command, workspace.path, { detached: keepTuiOpen })
+        if (!keepTuiOpen) {
+          setPage(Page.Exit)
+        }
+      } else {
+        console.warn("No workspace cell found at the selected position")
+      }
+    },
+  })
+
+  return (
+    <Provider
+      value={{
+        projects,
+        workspaceQuickActions,
+        workspaceRuntimes,
+        workspacesNavigationGrid,
+        row: position.row,
+        col: position.col,
+      }}
+    >
+      {children}
+    </Provider>
+  )
+}

package/src/hooks/useProjectGrid.ts

@@ -0,0 +1,77 @@
+import { exit } from "node:process"
+import { type Key, useInput } from "ink"
+import { useState } from "react"
+import type { ProjectGridGrid } from "../types/project-grid.js"
+import type { CursorPosition } from "../types/workspace-grid.js"
+import { getCellsByColumn } from "../utils/project/project-grid.js"
+
+interface UseNavigationOptions {
+  grid: ProjectGridGrid
+  onSelect?: (row: number, col: number) => void
+  onExit?: () => void
+}
+
+export function useProjectGrid({
+  grid,
+  onSelect,
+  onExit,
+}: UseNavigationOptions) {
+  const [position, setPosition] = useState<CursorPosition>({ row: 0, col: 0 })
+
+  const maxCol = grid.maxCol
+
+  const getMaxRowForCol = (col: number): number => {
+    const cells = getCellsByColumn(grid, col)
+    return cells.length > 0 ? cells.length - 1 : 0
+  }
+
+  useInput((_input: string, key: Key) => {
+    if (key.upArrow) {
+      setPosition((prev) => {
+        const maxRow = getMaxRowForCol(prev.col)
+        const newRow = prev.row - 1 < 0 ? maxRow : prev.row - 1
+        return { ...prev, row: newRow }
+      })
+    }
+    if (key.downArrow) {
+      setPosition((prev) => {
+        const maxRow = getMaxRowForCol(prev.col)
+        const newRow = prev.row + 1 > maxRow ? 0 : prev.row + 1
+        return { ...prev, row: newRow }
+      })
+    }
+    if (key.leftArrow) {
+      if (position.col - 1 < 0) {
+        onExit?.()
+      } else {
+        setPosition((prev) => {
+          const newCol = prev.col - 1
+          const maxRow = getMaxRowForCol(newCol)
+          const newRow = Math.min(prev.row, maxRow)
+          return { row: newRow, col: newCol }
+        })
+      }
+    }
+    if (key.rightArrow) {
+      setPosition((prev) => {
+        if (prev.col + 1 > maxCol) {
+          return prev
+        }
+        const newCol = prev.col + 1
+        const maxRow = getMaxRowForCol(newCol)
+        const newRow = Math.min(prev.row, maxRow)
+        return { row: newRow, col: newCol }
+      })
+    }
+    if (key.return && onSelect) {
+      onSelect(position.row, position.col)
+    }
+    if (key.escape) {
+      exit()
+    }
+  })
+
+  return {
+    position,
+  }
+}

package/src/hooks/useWorkspaceDiscovery.ts

@@ -0,0 +1,61 @@
+import { useEffect, useState } from "react"
+
+import { discoverWorkspaces } from "../services/discovery/workspace-discovery.js"
+import type { Project } from "../types/project.js"
+import { logger } from "../utils/logging/logger.js"
+
+interface UseWorkspaceDiscoveryOptions {
+  refreshIntervalMs?: number
+}
+
+export function useWorkspaceDiscovery(
+  rootPath: string,
+  options?: UseWorkspaceDiscoveryOptions,
+) {
+  const [loading, setLoading] = useState(true)
+  const [projects, setProjects] = useState<Project[]>([])
+  const [error, setError] = useState<Error | null>(null)
+  const refreshIntervalMs = options?.refreshIntervalMs ?? 0
+
+  useEffect(() => {
+    let cancelled = false
+    let pending = false
+
+    async function load() {
+      if (pending || cancelled) {
+        return
+      }
+
+      pending = true
+      setLoading(true)
+      setError(null)
+      try {
+        const result = await discoverWorkspaces(rootPath)
+        logger.debug(rootPath, "discovered workspaces")
+        if (!cancelled) {
+          setProjects(result)
+          logger.debug(`Workspace discovery result count: ${result.length}`)
+        }
+      } catch (err) {
+        if (!cancelled) setError(err as Error)
+      } finally {
+        if (!cancelled) setLoading(false)
+        pending = false
+      }
+    }
+
+    load()
+
+    const intervalId =
+      refreshIntervalMs > 0 ? setInterval(load, refreshIntervalMs) : null
+
+    return () => {
+      cancelled = true
+      if (intervalId) {
+        clearInterval(intervalId)
+      }
+    }
+  }, [rootPath, refreshIntervalMs])
+
+  return { loading, projects, error }
+}

package/src/hooks/useWorkspaceGrid.ts

@@ -0,0 +1,85 @@
+import { type Key, useApp, useInput } from "ink"
+import { useState } from "react"
+import {
+  stopComposeService,
+  stopScriptProcess,
+} from "../services/runtime/stop-runtime.js"
+import type {
+  CursorPosition,
+  WorkspacesNavigationCell,
+  WorkspacesNavigationGrid,
+} from "../types/workspace-grid.js"
+import { findNextPosition } from "../utils/navigation/navigation-helper.js"
+import { getWorkspaceCellByPosition } from "../utils/workspace/workspace-grid.js"
+
+interface UseNavigationOptions {
+  grid: WorkspacesNavigationGrid
+  initialPosition?: CursorPosition
+  onSelect?: (row: number, col: number) => void
+}
+
+export function useWorkspaceGrid({
+  grid,
+  initialPosition,
+  onSelect,
+}: UseNavigationOptions) {
+  const { exit } = useApp()
+  const [position, setPosition] = useState<CursorPosition>(
+    initialPosition ?? { row: 0, col: 0 },
+  )
+
+  useInput((input: string, key: Key) => {
+    if (key.upArrow) {
+      const next = findNextPosition(grid, position, "up")
+      setPosition(next)
+    }
+    if (key.downArrow) {
+      const next = findNextPosition(grid, position, "down")
+      setPosition(next)
+    }
+    if (key.leftArrow) {
+      const next = findNextPosition(grid, position, "left")
+      setPosition(next)
+    }
+    if (key.rightArrow) {
+      const next = findNextPosition(grid, position, "right")
+      setPosition(next)
+    }
+    if (key.return && onSelect) {
+      onSelect(position.row, position.col)
+    }
+    // Handle 's' key to stop/kill
+    if (input === "s" && !key.ctrl && !key.meta && !key.shift) {
+      const cell = getWorkspaceCellByPosition(grid, position.row, position.col)
+      stopWorkspaceCell(cell)
+    }
+    // Helper to stop a running workspace cell (script or service)
+    function stopWorkspaceCell(cell: WorkspacesNavigationCell | null) {
+      if (
+        !cell ||
+        cell.type !== "runtime" ||
+        cell.runState.status !== "running"
+      )
+        return
+
+      // Optimistically reflect stopping state in the UI
+      cell.runState.status = "stopping"
+      setPosition((current) => ({ ...current }))
+
+      const runState = cell.runState
+      if (runState.type === "script") {
+        stopScriptProcess(runState)
+      } else if (runState.type === "service") {
+        stopComposeService(runState)
+      }
+    }
+
+    if (key.escape) {
+      exit()
+    }
+  })
+
+  return {
+    position,
+  }
+}

package/src/hooks/useWorkspaceQuickActions.ts

@@ -0,0 +1,114 @@
+import type { Project } from "../types/project.js"
+import type {
+  FacetQuickAction,
+  WorkspaceQuickAction,
+} from "../types/workspace-quick-actions.js"
+import { logger } from "../utils/logging/logger.js"
+
+export function useWorkspaceQuickActions(projects: Project[]) {
+  const quickActions: WorkspaceQuickAction[] = []
+
+  for (const project of projects) {
+    const faccetQuickActions: FacetQuickAction[] = []
+
+    // Priority 1: Makefile (dev, up)
+    const makefile = project.facets.makefile
+    let hasMakefileUp = false
+    let hasMakefileUpDetached = false
+    if (makefile) {
+      const dev = makefile.commands.find((cmd) => cmd.name === "dev")
+      if (dev)
+        faccetQuickActions.push({
+          facetPath: makefile.path,
+          name: dev.name,
+          command: dev.command,
+          exec: dev.exec,
+          order: 1,
+        })
+      const up = makefile.commands.find((cmd) => cmd.name === "up")
+      if (up)
+        faccetQuickActions.push({
+          facetPath: makefile.path,
+          name: up.name,
+          command: up.command,
+          exec: up.exec,
+          order: 2,
+        })
+      hasMakefileUp = Boolean(up)
+      const upDetached = makefile.commands.find(
+        (cmd) => cmd.name === "up-detached",
+      )
+      if (upDetached)
+        faccetQuickActions.push({
+          facetPath: makefile.path,
+          name: "up -d",
+          command: upDetached.command,
+          exec: upDetached.exec,
+          order: 2,
+        })
+      hasMakefileUpDetached = Boolean(upDetached)
+
+      if (project.facets.compose) {
+        const compose = project.facets.compose
+        if (!hasMakefileUp)
+          faccetQuickActions.push({
+            facetPath: compose.path,
+            name: "up",
+            command: "docker compose up",
+            exec: "docker compose up",
+            order: 2,
+          })
+        if (!hasMakefileUpDetached)
+          faccetQuickActions.push({
+            facetPath: compose.path,
+            name: "up -d",
+            command: "docker compose up -d",
+            exec: "docker compose up -d",
+            order: 2,
+          })
+      }
+    }
+
+    // Priority 2: package.json (dev)
+    if (faccetQuickActions.length === 0 && project.facets.packageJson) {
+      const pkg = project.facets.packageJson
+      const dev = pkg.scripts.find((s) => s.name === "dev")
+      if (dev)
+        faccetQuickActions.push({
+          facetPath: pkg.path,
+          name: dev.name,
+          command: dev.command,
+          exec: dev.exec,
+          order: 1,
+        })
+    }
+
+    // Priority 3: compose (up)
+    if (faccetQuickActions.length === 0 && project.facets.compose) {
+      const compose = project.facets.compose
+      faccetQuickActions.push({
+        facetPath: compose.path,
+        name: "up",
+        command: "docker compose up",
+        exec: "docker compose up",
+        order: 1,
+      })
+      faccetQuickActions.push({
+        facetPath: compose.path,
+        name: "up -d",
+        command: "docker compose up -d",
+        exec: "docker compose up -d",
+        order: 2,
+      })
+    }
+
+    const quickWorkspaceAction: WorkspaceQuickAction = {
+      workspacePath: project.path,
+      facets: faccetQuickActions,
+    }
+    quickActions.push(quickWorkspaceAction)
+  }
+
+  logger.debug(quickActions, "Quick Actions")
+  return quickActions
+}

package/src/hooks/useWorkspaceRuntime.ts

@@ -0,0 +1,92 @@
+import { useEffect, useState } from "react"
+
+import { getDockerRunStates } from "../services/runtime/docker-runtime.js"
+import { getNodeRunStates } from "../services/runtime/node-runtime.js"
+import { resolveRuntimeConflicts } from "../services/runtime/resolve-runtime.js"
+import type { Project } from "../types/project.js"
+import type { WorkspaceRuntimeState } from "../types/workspace-runtime.js"
+import { logger } from "../utils/logging/logger.js"
+
+function mergeTransientStatuses(
+  previous: WorkspaceRuntimeState[],
+  next: WorkspaceRuntimeState[],
+): WorkspaceRuntimeState[] {
+  const previousById = new Map<string, string>()
+
+  for (const workspace of previous) {
+    for (const runState of workspace.runStates) {
+      previousById.set(runState.id, runState.status)
+    }
+  }
+
+  return next.map((workspace) => ({
+    ...workspace,
+    runStates: workspace.runStates.map((runState) => {
+      const prevStatus = previousById.get(runState.id)
+      const isTransientPrevStatus =
+        prevStatus === "starting" || prevStatus === "stopping"
+      const isRunningNow = runState.status === "running"
+
+      if (isTransientPrevStatus && isRunningNow) {
+        return {
+          ...runState,
+          status: prevStatus,
+        }
+      }
+
+      return runState
+    }),
+  }))
+}
+
+export function useWorkspaceRuntime(projects: Project[]) {
+  const [runtimeStates, setRuntimeStates] = useState<WorkspaceRuntimeState[]>(
+    [],
+  )
+
+  useEffect(() => {
+    let cancelled = false
+    async function fetchStatus() {
+      const results: WorkspaceRuntimeState[] = []
+      for (const project of projects) {
+        const scripts = project.facets.packageJson?.scripts ?? []
+        const services = project.facets.compose?.services ?? []
+
+        // const [nodeStates, dockerStates] = await Promise.all([
+        //   getNodeRunStates(project.absolutePath, project.path, scripts),
+        //   getDockerRunStates(project.path, services),
+        // ])
+
+        const nodeStates = await getNodeRunStates(
+          project.absolutePath,
+          project.path,
+          scripts,
+        )
+        const dockerStates = await getDockerRunStates(project.path, services)
+
+        // Resolve conflicts between node and docker run states
+        const { node: resolvedNodeStates, docker: resolvedDockerStates } =
+          resolveRuntimeConflicts(nodeStates, dockerStates)
+
+        results.push({
+          workspacePath: project.path,
+          runStates: [...resolvedNodeStates, ...resolvedDockerStates],
+        })
+      }
+      if (!cancelled) {
+        setRuntimeStates((previous) =>
+          mergeTransientStatuses(previous, results),
+        )
+      }
+    }
+    fetchStatus()
+    const interval = setInterval(fetchStatus, 5000)
+    return () => {
+      cancelled = true
+      clearInterval(interval)
+    }
+  }, [projects])
+
+  logger.debug(runtimeStates, "Runtime States")
+  return runtimeStates
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { loadConfig } from "./config/config.js"
+import { initLogger } from "./utils/logging/logger.js"
+
+// Initialize config and logger before starting app
+const config = await loadConfig(process.cwd())
+initLogger(config)
+
+// Start the app (dynamic import so config is ready)
+await import("./app/App.js")