@factorim/monotui 0.1.0

package/src/types/config.ts

@@ -0,0 +1,50 @@
+import type { WorkspaceQuickAction } from "./workspace-quick-actions"
+
+export interface Config {
+  discovery?: DiscoveryConfig
+  quickActions: WorkspaceQuickAction[]
+  execution?: ExecutionConfig
+  logging?: LoggingConfig
+  theme?: ThemeName
+}
+
+export type ThemeName = "dark"
+
+export interface DiscoveryConfig {
+  maxDepth?: number
+  ignore?: string[]
+  folders?: {
+    app?: string[]
+    package?: string[]
+    infra?: string[]
+    contract?: string[]
+  }
+  scripts?: {
+    include?: string[]
+    exclude?: string[]
+  }
+  env?: DiscoveryEnvConfig
+  order?: string[]
+  makefile?: MakefileConfig
+}
+
+export interface DiscoveryEnvConfig {
+  files?: string[]
+  portKeys?: string[]
+}
+
+export interface MakefileConfig {
+  showDefault?: boolean
+}
+
+export interface ExecutionConfig {
+  useTmux?: boolean
+}
+
+export interface LoggingConfig {
+  level?: "debug" | "info" | "warn" | "error"
+  file?: boolean
+  logDir?: string
+  prettyPrint?: boolean
+  truncateOnStart?: boolean
+}

package/src/types/page.ts

@@ -0,0 +1,5 @@
+export enum Page {
+  Workspace = "workspace",
+  Project = "project",
+  Exit = "exit",
+}

package/src/types/project-grid.ts

@@ -0,0 +1,73 @@
+import type {
+  ComposeService,
+  MakefileCommand,
+  PackageJsonScript,
+} from "./project.js"
+
+export type ProjectGridGrid = {
+  packageJsonCells: PackageJsonCell[]
+  composeCommandCells: ComposeCommandCell[]
+  composeServiceCells: ComposeServiceCell[]
+  makefileCells: MakefileCell[]
+  maxCol: number
+}
+
+export type ProjectGridCell =
+  | PackageJsonCell
+  | ComposeCommandCell
+  | ComposeServiceCell
+  | MakefileCell
+
+export interface PackageJsonCell {
+  type: "packageJson"
+  filepath: string
+  row: number
+  col: number
+  script: PackageJsonScript
+}
+
+export interface ComposeCommandCell {
+  type: "composeCommand"
+  filepath: string
+  row: number
+  col: number
+  action: ComposeCommand
+}
+
+export interface ComposeServiceCell {
+  type: "composeService"
+  filepath: string
+  row: number
+  col: number
+  service: ComposeService
+}
+
+export const COMPOSE_COMMANDS = [
+  "up",
+  "up -d",
+  "down",
+  "build",
+  "stop",
+  "logs",
+] as const
+
+export type ComposeCommandName = (typeof COMPOSE_COMMANDS)[number]
+
+export interface ComposeCommand {
+  name: ComposeCommandName
+  command: string
+}
+
+export interface MakefileCell {
+  type: "makefile"
+  filepath: string
+  row: number
+  col: number
+  command: MakefileCommand
+}
+
+// Simple navigation
+export interface NavigationPosition {
+  row: number
+  col: number
+}

package/src/types/project.ts

@@ -0,0 +1,81 @@
+export type ProjectType = "workspace" | "app" | "package" | "infra" | "contract"
+export type FacetType = "packageJson" | "compose" | "makefile"
+
+export interface EnvFile {
+  filepath: string // e.g. "/home/user/project-name/.env"
+}
+
+export interface Project {
+  path: string // e.g. "project-name/app"
+  absolutePath: string // e.g. "/home/user/project-name/"
+  type: ProjectType // e.g. "app"
+  folder: string // e.g. "project-name"
+  envFile?: EnvFile
+  facets: {
+    packageJson?: PackageJsonFacet
+    compose?: ComposeFacet
+    makefile?: MakefileFacet
+  }
+}
+
+// Base Facet
+
+export interface BaseFacet {
+  type: FacetType
+  path: string // e.g. "apps/api"
+  envFile?: EnvFile
+}
+
+// PackageJson Facet
+
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun" | "deno"
+
+export interface PackageJsonFacet extends BaseFacet {
+  type: "packageJson"
+  filename: string // e.g. "package.json"
+  name: string // e.g. "@factorim/api"
+  version?: string // e.g. "1.0.0"
+  framework?: string // e.g. "react", "Next.js""
+  packageManager: PackageManager // e.g. "pnpm"
+  description?: string // e.g. "My awesome app"
+  scripts: PackageJsonScript[]
+}
+
+export interface PackageJsonScript {
+  name: string // e.g. "start"
+  command: string // e.g. "pnpm start"
+  exec: string // e.g. "biome check ."
+  port?: number // e.g. 3000
+}
+
+// Compose Facet
+
+export interface ComposeFacet extends BaseFacet {
+  type: "compose"
+  filename: string // e.g. "docker-compose.yml"
+  services: ComposeService[]
+}
+
+export interface ComposeService {
+  name: string // e.g. "database" (service key in compose file)
+  containerName?: string // e.g. "my-pg-db" (explicit container_name, if set)
+  image?: string // e.g. "postgres:latest"
+  ports?: number[] // e.g. [5432]
+}
+
+// Makefile Facet
+
+export interface MakefileFacet extends BaseFacet {
+  type: "makefile"
+  filename: string // e.g. "Makefile"
+  commands: MakefileCommand[]
+}
+
+export interface MakefileCommand {
+  name: string // e.g. "dev"
+  command: string // e.g. "make dev"
+  exec: string // e.g. "pnpm run dev"
+  port?: number // e.g. 3000
+  description?: string // e.g. "Start the development server"
+  dependencies?: string[] // e.g. ["build"]
+}

package/src/types/workspace-grid.ts

@@ -0,0 +1,41 @@
+import type { Project } from "./project.js"
+import type { FacetQuickAction } from "./workspace-quick-actions.js"
+import type { RunState } from "./workspace-runtime.js"
+
+export interface CursorPosition {
+  row: number
+  col: number
+}
+
+export interface WorkspacesNavigationRow {
+  id: string
+  cells: (WorkspacesNavigationCell | null)[]
+}
+
+export type WorkspacesNavigationGrid = WorkspacesNavigationRow[]
+
+export type WorkspacesNavigationCell =
+  | WorkspaceCell
+  | WorkspaceQuickActionCell
+  | WorkspaceRuntimeCell
+
+export interface WorkspaceCell {
+  type: "workspace"
+  row: number
+  col: number
+  workspace: Project
+}
+
+export interface WorkspaceQuickActionCell {
+  type: "quickAction"
+  row: number
+  col: number
+  action: FacetQuickAction
+}
+
+export interface WorkspaceRuntimeCell {
+  type: "runtime"
+  row: number
+  col: number
+  runState: RunState
+}

package/src/types/workspace-quick-actions.ts

@@ -0,0 +1,12 @@
+export interface WorkspaceQuickAction {
+  workspacePath: string
+  facets: FacetQuickAction[]
+}
+
+export interface FacetQuickAction {
+  facetPath: string
+  name: string
+  command: string
+  exec: string
+  order?: number
+}

package/src/types/workspace-runtime.ts

@@ -0,0 +1,28 @@
+export type RuntimeStatus =
+  | "starting"
+  | "running"
+  | "stopping"
+  | "stopped"
+  | "failed"
+  | "conflict"
+
+/**
+ * Aggregated running state for an entire workspaces
+ */
+export interface WorkspaceRuntimeState {
+  workspacePath: string // e.g. "myapp"
+  runStates: RunState[]
+}
+
+/**
+ * Running state for a single run (script, command, or service)
+ */
+export interface RunState {
+  id: string // e.g. "myapp::packageJson::dev"
+  name: string // e.g. "dev"
+  type: "script" | "command" | "service"
+  status: RuntimeStatus
+  statusMessage?: string // e.g. "Port 3000 already in use", "2 containers match service db"
+  command: string // e.g. "pnpm start"
+  port?: number // e.g. 3000
+}

package/src/utils/fs/directories.test.ts

@@ -0,0 +1,60 @@
+// scanDirectories.test.ts
+import { mkdir, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals"
+import { scanDirectories } from "./directories"
+
+describe("scanDirectories", () => {
+  let root: string
+
+  beforeEach(async () => {
+    root = join(tmpdir(), `monotui-scan-${Date.now()}-${Math.random()}`)
+    await mkdir(root, { recursive: true })
+
+    await mkdir(join(root, "apps", "api"), { recursive: true })
+    await mkdir(join(root, "packages", "ui", "components"), { recursive: true })
+    await mkdir(join(root, ".git"), { recursive: true })
+    await mkdir(join(root, "node_modules"), { recursive: true })
+    await mkdir(join(root, "unreadable"), { recursive: true })
+
+    // Add a file just to ensure files are ignored (only dirs collected)
+    await writeFile(join(root, "apps", "api", "index.ts"), "export {}")
+  })
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true })
+  })
+
+  it("includes root directory and discovers nested directories", async () => {
+    const dirs = await scanDirectories(root, {
+      maxDepth: 10,
+      ignore: [],
+    })
+
+    expect(dirs).toContain(root)
+    expect(dirs).toContain(join(root, "apps"))
+    expect(dirs).toContain(join(root, "apps", "api"))
+    expect(dirs).toContain(join(root, "packages"))
+    expect(dirs).toContain(join(root, "packages", "ui"))
+    expect(dirs).toContain(join(root, "packages", "ui", "components"))
+  })
+
+  it("skips dot-directories (e.g. .git)", async () => {
+    const dirs = await scanDirectories(root, {
+      maxDepth: 10,
+      ignore: [],
+    })
+
+    expect(dirs).not.toContain(join(root, ".git"))
+  })
+
+  it("skips ignored directories (e.g. node_modules)", async () => {
+    const dirs = await scanDirectories(root, {
+      maxDepth: 10,
+      ignore: ["node_modules"],
+    })
+
+    expect(dirs).not.toContain(join(root, "node_modules"))
+  })
+})

package/src/utils/fs/directories.ts

@@ -0,0 +1,54 @@
+import { readdir } from "node:fs/promises"
+import { basename, dirname, join, relative } from "node:path"
+
+export interface ScanOptions {
+  maxDepth: number
+  ignore: string[]
+}
+
+export async function scanDirectories(
+  rootDir: string,
+  options: ScanOptions,
+): Promise<string[]> {
+  const directories: string[] = []
+
+  async function scan(dir: string, depth: number) {
+    if (depth > options.maxDepth) return
+
+    try {
+      const entries = await readdir(dir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        // Skip ignored directories
+        if (options.ignore.includes(entry.name)) continue
+        if (entry.name.startsWith(".")) continue
+
+        if (entry.isDirectory()) {
+          const fullPath = join(dir, entry.name)
+          directories.push(fullPath)
+          await scan(fullPath, depth + 1)
+        }
+      }
+    } catch {
+      // Skip directories we can't read
+    }
+  }
+
+  // Add root directory
+  directories.push(rootDir)
+  await scan(rootDir, 0)
+
+  return directories
+}
+
+export function getDirectoryName(filePath: string, rootDir: string): string {
+  const dir = dirname(filePath)
+  const relativePath = relative(rootDir, dir)
+
+  // If in root, use directory name
+  if (relativePath === "") {
+    return basename(dir)
+  }
+
+  return relativePath.replace(/\\/g, "/")
+}

package/src/utils/fs/file.test.ts

@@ -0,0 +1,90 @@
+import { mkdir, rm, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals"
+
+import { fileExists, readJsonFile } from "./file.js"
+
+const TEST_DIR = join(process.cwd(), "test-temp")
+
+describe("file utils", () => {
+  beforeEach(async () => {
+    await mkdir(TEST_DIR, { recursive: true })
+  })
+
+  afterEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true })
+  })
+
+  describe("fileExists", () => {
+    it("should return true for existing file", async () => {
+      const filePath = join(TEST_DIR, "test.txt")
+      await writeFile(filePath, "test content")
+
+      const exists = await fileExists(filePath)
+
+      expect(exists).toBe(true)
+    })
+
+    it("should return false for non-existing file", async () => {
+      const filePath = join(TEST_DIR, "non-existing.txt")
+
+      const exists = await fileExists(filePath)
+
+      expect(exists).toBe(false)
+    })
+
+    it("should return true for existing directory", async () => {
+      const exists = await fileExists(TEST_DIR)
+
+      expect(exists).toBe(true)
+    })
+  })
+
+  describe("readJsonFile", () => {
+    it("should read and parse valid JSON file", async () => {
+      const filePath = join(TEST_DIR, "data.json")
+      const data = { name: "test", value: 42 }
+      await writeFile(filePath, JSON.stringify(data))
+
+      const result = await readJsonFile<typeof data>(filePath)
+
+      expect(result).toEqual(data)
+    })
+
+    it("should return null for non-existing file", async () => {
+      const filePath = join(TEST_DIR, "missing.json")
+
+      const result = await readJsonFile(filePath)
+
+      expect(result).toBeNull()
+    })
+
+    it("should return null for invalid JSON", async () => {
+      const filePath = join(TEST_DIR, "invalid.json")
+      await writeFile(filePath, "not valid json{")
+
+      const result = await readJsonFile(filePath)
+
+      expect(result).toBeNull()
+    })
+
+    it("should handle nested JSON objects", async () => {
+      const filePath = join(TEST_DIR, "nested.json")
+      const data = {
+        workspace: {
+          name: "my-app",
+          scripts: {
+            build: "tsc",
+            test: "jest",
+          },
+        },
+      }
+      await writeFile(filePath, JSON.stringify(data))
+
+      const result = await readJsonFile<typeof data>(filePath)
+
+      expect(result).toEqual(data)
+      expect(result?.workspace.scripts.build).toBe("tsc")
+    })
+  })
+})

package/src/utils/fs/file.ts

@@ -0,0 +1,32 @@
+import { readFile, stat } from "node:fs/promises"
+import { join } from "node:path"
+import type { PackageJson } from "type-fest"
+
+export async function fileExists(path: string): Promise<boolean> {
+  try {
+    await stat(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function readJsonFile<T>(path: string): Promise<T | null> {
+  try {
+    const content = await readFile(path, "utf-8")
+    return JSON.parse(content) as T
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Generic helper to read package.json from a directory
+ */
+export async function getPackageJson(dir: string): Promise<PackageJson | null> {
+  const packagePath = join(dir, "package.json")
+  if (!(await fileExists(packagePath))) {
+    return null
+  }
+  return readJsonFile<PackageJson>(packagePath)
+}

package/src/utils/fs/package-json.ts

@@ -0,0 +1,12 @@
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { readPackage } from "read-pkg"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export async function getPackageVersion(): Promise<string> {
+  const appPackageJsonPath = path.resolve(__dirname, "../../../package.json")
+  const pkg = await readPackage({ cwd: path.dirname(appPackageJsonPath) })
+  return pkg.version
+}

package/src/utils/logging/logger.ts

@@ -0,0 +1,103 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { type Logger, pino } from "pino"
+
+import type { Config } from "../../types/config"
+
+/**
+ * Initialize logger based on configuration
+ * Must be called once at startup before using logger
+ */
+export function initLogger(config: Config): Logger {
+  const loggingConfig = config.logging || {}
+  const level = loggingConfig.level || "info"
+  const enableFile = loggingConfig.file !== false
+  const truncateOnStart = loggingConfig.truncateOnStart !== false
+  const logDir = loggingConfig.logDir
+    ? loggingConfig.logDir.replace(/^~/, homedir())
+    : join(homedir(), ".workspace-cli", "logs")
+
+  if (enableFile) {
+    const logFilePath = join(logDir, "workspace-cli.log")
+
+    // Truncate log file if configured
+    if (truncateOnStart) {
+      if (!existsSync(logDir)) {
+        mkdirSync(logDir, { recursive: true })
+      }
+      writeFileSync(logFilePath, "", "utf-8")
+    }
+
+    const usePretty = loggingConfig.prettyPrint === true
+
+    _logger = pino({
+      level,
+      transport: {
+        target: usePretty ? "pino-pretty" : "pino/file",
+        options: {
+          destination: logFilePath,
+          mkdir: true,
+          ...(usePretty && {
+            colorize: false,
+            translateTime: "SYS:standard",
+            ignore: "pid,hostname",
+          }),
+        },
+      },
+    })
+  } else {
+    // Create a minimal logger that writes to stderr (above Ink UI)
+    // stderr doesn't interfere with Ink's stdout rendering
+    _logger = pino({
+      level,
+      transport: {
+        target: "pino-pretty",
+        options: {
+          destination: 2, // stderr (file descriptor 2)
+          colorize: true,
+          translateTime: "HH:MM:ss",
+          ignore: "pid,hostname",
+        },
+      },
+    })
+  }
+
+  return _logger
+}
+
+// Singleton logger instance - starts as no-op
+let _logger: Logger = pino({ level: "silent" })
+const _useConsole = false
+
+// Export the logger directly - pino already has all the methods
+export const logger = {
+  debug: (obj: unknown, msg?: string) => {
+    if (_useConsole) {
+      console.log("[DEBUG]", ...(msg ? [msg] : []), obj)
+    } else {
+      _logger.debug(obj, msg)
+    }
+  },
+  info: (obj: unknown, msg?: string) => {
+    if (_useConsole) {
+      console.log("[INFO]", ...(msg ? [msg] : []), obj)
+    } else {
+      _logger.info(obj, msg)
+    }
+  },
+  warn: (obj: unknown, msg?: string) => {
+    if (_useConsole) {
+      console.log("[WARN]", ...(msg ? [msg] : []), obj)
+    } else {
+      _logger.warn(obj, msg)
+    }
+  },
+  error: (obj: unknown, msg?: string) => {
+    if (_useConsole) {
+      console.log("[ERROR]", ...(msg ? [msg] : []), obj)
+    } else {
+      _logger.error(obj, msg)
+    }
+  },
+}