@factorim/monotui 0.1.0

package/src/services/discovery/facets/compose-parser.ts

@@ -0,0 +1,236 @@
+import { readFile } from "node:fs/promises"
+import { dirname, join, relative } from "node:path"
+import { parse as parseYaml } from "yaml"
+
+import type { ComposeFacet } from "../../../types/project.js"
+import { fileExists } from "../../../utils/fs/file.js"
+import { logger } from "../../../utils/logging/logger.js"
+
+const ENV_VAR_PATTERN = /\$\{([^}:]+)(?::-([^}]*))?\}|\$([A-Za-z_]\w*)/
+const ENV_VAR_PATTERN_GLOBAL = /\$\{([^}:]+)(?::-([^}]*))?\}|\$([A-Za-z_]\w*)/g
+
+/**
+ * Resolve all env variable references in a string.
+ * Supports: ${VAR}, ${VAR:-default}, $VAR
+ * Returns the string with all variables replaced, or undefined if any remain unresolved.
+ */
+function resolveEnvVars(
+  raw: string,
+  envVars: Record<string, string>,
+): string | undefined {
+  let hasUnresolved = false
+  const result = raw.replace(
+    ENV_VAR_PATTERN_GLOBAL,
+    (_match, braced, defaultVal, bare) => {
+      const varName = braced ?? bare
+      const resolved = envVars[varName] ?? defaultVal
+      if (resolved == null) {
+        hasUnresolved = true
+        logger.debug(`Unresolved env variable $${varName} in "${raw}"`)
+        return _match
+      }
+      return resolved
+    },
+  )
+  return hasUnresolved ? undefined : result
+}
+
+/**
+ * Parse an .env file into a key→value map.
+ * Handles KEY=VALUE, quotes, and inline comments.
+ */
+async function parseEnvFile(envPath: string): Promise<Record<string, string>> {
+  const vars: Record<string, string> = {}
+  if (!(await fileExists(envPath))) {
+    return vars
+  }
+  try {
+    const content = await readFile(envPath, "utf-8")
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim()
+      if (!trimmed || trimmed.startsWith("#")) continue
+      const eqIndex = trimmed.indexOf("=")
+      if (eqIndex === -1) continue
+      const key = trimmed.slice(0, eqIndex).trim()
+      let value = trimmed.slice(eqIndex + 1).trim()
+      // Strip surrounding quotes
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1)
+      }
+      vars[key] = value
+    }
+  } catch {
+    // Silently ignore unreadable env files
+  }
+  return vars
+}
+
+/**
+ * Resolve a port string that may contain env variable references.
+ * Supports: ${VAR}, ${VAR:-default}, $VAR
+ * Falls back to the env file(s), then the default value, then null.
+ */
+function resolvePortValue(
+  raw: string,
+  envVars: Record<string, string>,
+): number | null {
+  const match = raw.match(ENV_VAR_PATTERN)
+  if (!match) {
+    // No variable — plain number
+    const n = Number.parseInt(raw, 10)
+    return Number.isNaN(n) ? null : n
+  }
+
+  const varName = match[1] ?? match[3]
+  const defaultValue = match[2] // from ${VAR:-default} syntax
+
+  const resolved = envVars[varName] ?? defaultValue
+  if (resolved == null) {
+    logger.debug(`Unresolved env variable $${varName} in port mapping "${raw}"`)
+    return null
+  }
+
+  const n = Number.parseInt(resolved, 10)
+  return Number.isNaN(n) ? null : n
+}
+
+/**
+ * Extract and resolve host ports from a compose service's port mappings.
+ * Resolves env variables (${VAR}, ${VAR:-default}, $VAR) using the
+ * .env file located next to the compose file.
+ */
+export async function getPorts(
+  rawPorts: (string | number)[],
+  composeDir: string,
+  envFileName = ".env",
+): Promise<number[]> {
+  const envVars = await parseEnvFile(join(composeDir, envFileName))
+  const resolved: number[] = []
+
+  for (const p of rawPorts) {
+    if (typeof p === "number") {
+      resolved.push(p)
+      continue
+    }
+
+    // Extract the host part from "host:container" or "host:container/proto"
+    const hostPart = p.toString().split(":")[0]
+    const port = resolvePortValue(hostPart, envVars)
+    if (port != null) {
+      resolved.push(port)
+    }
+  }
+
+  return resolved
+}
+
+export interface ComposeParseOptions {
+  filenames?: string[]
+  services?: {
+    include?: string[]
+    exclude?: string[]
+  }
+  envFile?: string
+}
+
+export async function parseDockerCompose(
+  dir: string,
+  options: ComposeParseOptions = {},
+): Promise<ComposeFacet | null> {
+  const filenames = options.filenames ?? [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+  ]
+  const envFileName = options.envFile ?? ".env"
+
+  const services: Array<{
+    name: string
+    containerName?: string
+    image?: string
+    ports?: number[]
+  }> = []
+  let foundFile: string | null = null
+
+  for (const filename of filenames) {
+    const composePath = join(dir, filename)
+
+    if (!(await fileExists(composePath))) {
+      continue
+    }
+
+    try {
+      const content = await readFile(composePath, "utf-8")
+      const data = parseYaml(content) as {
+        services?: Record<
+          string,
+          {
+            container_name?: string
+            image?: string
+            ports?: (string | number)[]
+            env_file?: string | string[]
+          }
+        >
+      }
+
+      if (!data.services) {
+        continue
+      }
+
+      foundFile = filename
+      const composeDir = dirname(composePath)
+      const envVars = await parseEnvFile(join(composeDir, envFileName))
+
+      for (const [serviceName, serviceConfig] of Object.entries(
+        data.services,
+      )) {
+        // Apply service include/exclude filters
+        if (
+          options.services?.include &&
+          !options.services.include.includes(serviceName)
+        ) {
+          continue
+        }
+        if (options.services?.exclude?.includes(serviceName)) {
+          continue
+        }
+
+        const ports = serviceConfig.ports
+          ? await getPorts(serviceConfig.ports, composeDir, envFileName)
+          : []
+
+        // Resolve env variables in container_name (e.g. "${NAMESPACE}-postgres")
+        const containerName = serviceConfig.container_name
+          ? resolveEnvVars(serviceConfig.container_name, envVars)
+          : undefined
+
+        services.push({
+          name: serviceName,
+          containerName,
+          image: serviceConfig.image,
+          ports,
+        })
+      }
+
+      break // Only parse the first found compose file
+    } catch (error) {
+      // Skip invalid YAML files
+      logger.debug(error, `Failed to parse ${filename}:`)
+    }
+  }
+
+  if (!foundFile || services.length === 0) {
+    return null
+  }
+
+  return {
+    type: "compose",
+    filename: foundFile,
+    path: relative(process.cwd(), join(dir, foundFile)),
+    services,
+  }
+}

package/src/services/discovery/facets/makefile-parser.ts

@@ -0,0 +1,196 @@
+import { readFile } from "node:fs/promises"
+import { dirname, join, relative, resolve } from "node:path"
+
+import type { MakefileFacet } from "../../../types/project.js"
+import { fileExists } from "../../../utils/fs/file.js"
+import { logger } from "../../../utils/logging/logger.js"
+
+export interface MakefileParseOptions {
+  include?: string[]
+  exclude?: string[]
+  followIncludes?: boolean
+}
+
+export async function parseMakefile(
+  dir: string,
+  options: MakefileParseOptions = {},
+): Promise<MakefileFacet | null> {
+  const config = getConfig()
+  const filenames = ["Makefile", "makefile", "GNUmakefile"]
+  let foundFile: string | null = null
+  let allTargets: MakefileCommand[] = []
+
+  for (const filename of filenames) {
+    const makefilePath = join(dir, filename)
+
+    if (!(await fileExists(makefilePath))) {
+      continue
+    }
+
+    const followIncludes = options.followIncludes ?? true
+    const targets = await parseMakefileTargets(makefilePath, followIncludes)
+
+    // Apply exclude filter
+    let filteredTargets = targets
+
+    // Hide "default" target unless showDefault is true
+    if (config.discovery?.makefile?.showDefault === false) {
+      filteredTargets = filteredTargets.filter((t) => t.name !== "default")
+    }
+
+    if (options.exclude && options.exclude.length > 0) {
+      filteredTargets = filteredTargets.filter(
+        (t) => !options.exclude?.includes(t.name),
+      )
+    }
+
+    if (filteredTargets.length > 0) {
+      foundFile = filename
+      allTargets = filteredTargets
+      break // Only parse the first found Makefile
+    }
+  }
+
+  if (!foundFile || allTargets.length === 0) {
+    return null
+  }
+
+  // Remove duplicates (keep first occurrence)
+  const seenNames = new Set<string>()
+  const commands = allTargets.filter((target) => {
+    if (seenNames.has(target.name)) {
+      return false
+    }
+    seenNames.add(target.name)
+    return true
+  })
+
+  return {
+    type: "makefile",
+    filename: foundFile,
+    path: relative(process.cwd(), join(dir, foundFile)),
+    commands,
+  }
+}
+
+import { getConfig } from "../../../config/config.js"
+import type { MakefileCommand } from "../../../types/project.js"
+
+async function parseSingleMakefile(
+  makefilePath: string,
+  visitedFiles: Set<string> = new Set(),
+): Promise<{ targets: MakefileCommand[]; includes: string[] }> {
+  // Prevent infinite loops
+  if (visitedFiles.has(makefilePath)) {
+    return { targets: [], includes: [] }
+  }
+  visitedFiles.add(makefilePath)
+
+  if (!(await fileExists(makefilePath))) {
+    return { targets: [], includes: [] }
+  }
+
+  try {
+    const content = await readFile(makefilePath, "utf-8")
+    const targets: MakefileCommand[] = []
+    const includes: string[] = []
+    const lines = content.split("\n")
+    let currentTarget: string | null = null
+    let currentCommand = ""
+
+    for (const line of lines) {
+      // Skip comments and empty lines
+      if (line.trim().startsWith("#") || line.trim() === "") {
+        continue
+      }
+
+      // Collect include statements
+      if (line.trim().startsWith("include ")) {
+        const includeMatch = line.match(/^include\s+(.+)$/)
+        if (includeMatch) {
+          const includePath = includeMatch[1].trim()
+          const absolutePath = resolve(dirname(makefilePath), includePath)
+          includes.push(absolutePath)
+        }
+        continue
+      }
+
+      // Target line (starts at column 0, contains :)
+      if (line[0] !== "\t" && line.includes(":")) {
+        // Skip variable assignments (NAME := value or NAME = value)
+        if (line.includes(":=") || line.match(/^\s*[A-Z_]+\s*=/)) {
+          continue
+        }
+
+        // Save previous target
+        if (currentTarget) {
+          targets.push({
+            name: currentTarget,
+            command: `make ${currentTarget}`,
+            exec: currentCommand.trim(),
+            port: undefined,
+            description: undefined,
+            dependencies: undefined,
+          })
+        }
+
+        // Extract new target name (before the colon)
+        const match = line.match(/^([a-zA-Z0-9_-]+)\s*:/)
+        if (match) {
+          currentTarget = match[1]
+          currentCommand = ""
+        }
+      }
+      // Command line (starts with tab)
+      else if (line[0] === "\t" && currentTarget) {
+        currentCommand += (currentCommand ? " && " : "") + line.trim()
+      }
+    }
+
+    // Save last target
+    if (currentTarget) {
+      targets.push({
+        name: currentTarget,
+        command: `make ${currentTarget}`,
+        exec: currentCommand.trim(),
+        port: undefined,
+        description: undefined,
+        dependencies: undefined,
+      })
+    }
+
+    return { targets, includes }
+  } catch (error) {
+    logger.debug(error, `Failed to read or parse Makefile at ${makefilePath}:`)
+    return { targets: [], includes: [] }
+  }
+}
+
+async function parseMakefileTargets(
+  makefilePath: string,
+  followIncludes = true,
+  visitedFiles: Set<string> = new Set(),
+): Promise<MakefileCommand[]> {
+  const { targets, includes } = await parseSingleMakefile(
+    makefilePath,
+    visitedFiles,
+  )
+
+  if (!followIncludes) {
+    return targets
+  }
+
+  // First add main file commands, then process includes in order
+  const allTargets: MakefileCommand[] = [...targets]
+
+  for (const includePath of includes) {
+    const includedTargets = await parseMakefileTargets(
+      includePath,
+      true,
+      visitedFiles,
+    )
+    allTargets.push(...includedTargets)
+  }
+
+  return allTargets
+}

package/src/services/discovery/facets/package-json-parser.ts

@@ -0,0 +1,151 @@
+import { existsSync } from "node:fs"
+import { join, relative } from "node:path"
+import type { PackageJson } from "type-fest"
+
+import type {
+  PackageJsonFacet,
+  PackageJsonScript,
+  PackageManager,
+} from "../../../types/project.js"
+import { getPackageJson } from "../../../utils/fs/file.js"
+import { detectFramework } from "../../../utils/workspace/framework-detector.js"
+
+export interface ManifestParseOptions {
+  include?: string[]
+  exclude?: string[]
+}
+
+export async function parsePackageJson(
+  dir: string,
+  options: ManifestParseOptions = {},
+): Promise<PackageJsonFacet | null> {
+  const pkg = await getPackageJson(dir)
+
+  if (!pkg) return null
+
+  let scripts = pkg.scripts || {}
+
+  // Apply exclude filter
+  if (options.exclude && options.exclude.length > 0) {
+    scripts = Object.fromEntries(
+      Object.entries(scripts).filter(
+        ([key]) => !options.exclude?.includes(key),
+      ),
+    )
+  }
+
+  const framework = detectFramework(pkg)
+  const packageManager = await detectPackageManager(dir, pkg)
+  const scriptArray = parseScripts(scripts, packageManager)
+
+  return {
+    type: "packageJson",
+    filename: "package.json",
+    path: relative(process.cwd(), join(dir, "package.json")),
+    name: pkg.name ?? "",
+    version: pkg.version,
+    framework,
+    packageManager,
+    description: pkg.description,
+    scripts: scriptArray,
+  }
+}
+
+function parseScripts(
+  scripts: PackageJson.Scripts,
+  packageManager: PackageManager,
+): PackageJsonScript[] {
+  return Object.entries(scripts)
+    .filter((entry): entry is [string, string] => typeof entry[1] === "string")
+    .map(([name, exec]) => {
+      // Extract port from common patterns
+      const port = extractPort(exec)
+
+      // Build the command to run the script
+      const command = buildScriptCommand(packageManager, name)
+
+      return {
+        name,
+        command,
+        exec,
+        port,
+      }
+    })
+}
+
+function buildScriptCommand(
+  packageManager: PackageManager,
+  scriptName: string,
+): string {
+  switch (packageManager) {
+    case "npm":
+      return `npm run ${scriptName}`
+    case "yarn":
+      return `yarn ${scriptName}`
+    case "pnpm":
+      return `pnpm run ${scriptName}`
+    case "bun":
+      return `bun run ${scriptName}`
+    case "deno":
+      return `deno task ${scriptName}`
+    default:
+      return `npm run ${scriptName}`
+  }
+}
+
+function extractPort(exec: string): number {
+  // Match common port patterns
+  const patterns = [
+    /-p\s+(\d+)/, // -p 8000
+    /--port[=\s]+(\d+)/, // --port=8000 or --port 8000
+    /PORT=(\d+)/, // PORT=8000
+    /:(\d{4,5})\b/, // :8000
+  ]
+
+  for (const pattern of patterns) {
+    const match = exec.match(pattern)
+    if (match?.[1]) {
+      const port = parseInt(match[1], 10)
+      if (port > 0 && port <= 65535) {
+        return port
+      }
+    }
+  }
+
+  return 0
+}
+
+async function detectPackageManager(
+  dir: string,
+  pkg: PackageJson,
+): Promise<PackageManager> {
+  // 1. Check package.json packageManager field (most explicit)
+  if (pkg.packageManager) {
+    if (pkg.packageManager.startsWith("npm")) return "npm"
+    if (pkg.packageManager.startsWith("yarn")) return "yarn"
+    if (pkg.packageManager.startsWith("pnpm")) return "pnpm"
+    if (pkg.packageManager.startsWith("bun")) return "bun"
+    if (pkg.packageManager.startsWith("deno")) return "deno"
+  }
+
+  // 2. Check for lockfiles (most reliable heuristic)
+  if (existsSync(join(dir, "bun.lockb"))) return "bun"
+  if (existsSync(join(dir, "pnpm-lock.yaml"))) return "pnpm"
+  if (existsSync(join(dir, "yarn.lock"))) return "yarn"
+  if (existsSync(join(dir, "package-lock.json"))) return "npm"
+  if (existsSync(join(dir, "deno.lock"))) return "deno"
+
+  // 3. Check for workspace configuration files
+  if (existsSync(join(dir, "pnpm-workspace.yaml"))) return "pnpm"
+
+  // 4. Check package.json workspaces field format
+  if (pkg.workspaces) {
+    // Yarn berry uses a specific format
+    if (typeof pkg.workspaces === "object" && "packages" in pkg.workspaces) {
+      return "yarn"
+    }
+  }
+
+  // 5. Default fallback
+  return "npm"
+}

package/src/services/discovery/index.ts

@@ -0,0 +1 @@
+export * from "./workspace-discovery.js"

package/src/services/discovery/workspace-discovery.ts

@@ -0,0 +1,105 @@
+import { basename } from "node:path"
+
+import { getConfig } from "../../config/config.js"
+import type { Project, ProjectType } from "../../types/project"
+import { scanDirectories } from "../../utils/fs/directories.js"
+import { logger } from "../../utils/logging/logger.js"
+import { parseDockerCompose } from "./facets/compose-parser.js"
+import { parseMakefile } from "./facets/makefile-parser.js"
+import { parsePackageJson } from "./facets/package-json-parser.js"
+
+export async function discoverWorkspaces(rootPath: string): Promise<Project[]> {
+  const config = getConfig()
+  const directories = await scanDirectories(rootPath, {
+    maxDepth: 4,
+    ignore: config.discovery?.ignore || [],
+  })
+  logger.debug(directories, "Scanned Directories")
+
+  const workspaces: Project[] = []
+  for (const dir of directories) {
+    const packageFacet = await parsePackageJson(dir)
+
+    const composeFacet = await parseDockerCompose(dir)
+
+    const makefileFacet = await parseMakefile(dir)
+
+    if (packageFacet || composeFacet || makefileFacet) {
+      const relPath = dir.startsWith(rootPath)
+        ? dir.slice(rootPath.length).replace(/^\/+/, "")
+        : dir
+      const type = await determineProjectType(relPath)
+      const workspace: Project = {
+        type,
+        folder: basename(dir),
+        path: relPath || ".",
+        absolutePath: dir,
+        facets: {
+          packageJson: packageFacet || undefined,
+          compose: composeFacet || undefined,
+          makefile: makefileFacet || undefined,
+        },
+      }
+      workspaces.push(workspace)
+    }
+  }
+
+  const orderedWorkspaces = orderWorkspaces(
+    workspaces,
+    config.discovery?.order || [],
+  )
+
+  return orderedWorkspaces
+}
+
+/**
+ * Determine the workspace type based on location and facets
+ */
+async function determineProjectType(dir: string): Promise<ProjectType> {
+  const config = getConfig()
+
+  const appFolders = config.discovery?.folders?.app || ["apps"]
+  const packageFolders = config.discovery?.folders?.package || ["packages"]
+  const infraFolders = config.discovery?.folders?.infra || ["infra"]
+  const contractFolders = config.discovery?.folders?.contract || ["contracts"]
+
+  if (dir === "") {
+    return "workspace"
+  }
+  for (const folder of appFolders) {
+    if (dir.split("/").includes(folder)) {
+      return "app"
+    }
+  }
+  for (const folder of infraFolders) {
+    if (dir.split("/").includes(folder)) {
+      return "infra"
+    }
+  }
+  for (const folder of packageFolders) {
+    if (dir.split("/").includes(folder)) {
+      return "package"
+    }
+  }
+  for (const folder of contractFolders) {
+    if (dir.split("/").includes(folder)) {
+      return "contract"
+    }
+  }
+
+  // 5. Default to 'app'
+  return "app"
+}
+
+export function orderWorkspaces(
+  workspaces: Project[],
+  order: string[],
+): Project[] {
+  return workspaces
+    .filter((w) => order.includes(w.type))
+    .sort((a, b) => {
+      const aIndex = order.indexOf(a.type)
+      const bIndex = order.indexOf(b.type)
+      return aIndex - bIndex
+    })
+}