Subdirectories Within the Openship Directory: Complete Monorepo Structure

Yes, the openship repository contains eight primary subdirectories including apps/, packages/, docs/, scripts/, docker/, fixtures/, .github/, and .githooks/, organized as a multi-package monorepo.

The oblien/openship project follows a multi-package monorepo architecture that groups related functionality into distinct subdirectories within the openship directory. Understanding this hierarchical structure is essential for navigating the codebase, contributing to specific components, or deploying the application in different environments according to the oblien/openship source code.

Primary Subdirectories in the Openship Repository

The repository root organizes functionality into logical groups. Each subdirectory serves a specific purpose in the overall architecture.

apps/ - Frontend Applications

The apps/ directory houses the front-end applications, including the main web UI and optional desktop client. According to the source code, the web application configuration resides in [apps/web/package.json](https://github.com/oblien/openship/blob/main/apps/web/package.json), while build settings are defined in apps/web/next.config.mjs.

packages/ - Shared Libraries

The packages/ directory contains reusable libraries that power the applications, including UI components, onboarding flows, and database integration. The onboarding module exports its functionality from [packages/onboarding/src/index.ts](https://github.com/oblien/openship/blob/main/packages/onboarding/src/index.ts), with its own manifest at [packages/onboarding/package.json](https://github.com/oblien/openship/blob/main/packages/onboarding/package.json).

docs/ - Documentation Assets

Documentation, screenshots, and language-specific READMEs reside in the docs/ directory. Installation instructions can be found in [docs/installation.md](https://github.com/oblien/openship/blob/main/docs/installation.md), providing entry points for new developers.

scripts/ - Build and Automation Tools

The scripts/ directory contains TypeScript, Bash, and PowerShell helpers for building and releasing. The release automation logic is implemented in [scripts/release.ts](https://github.com/oblien/openship/blob/main/scripts/release.ts), while geo-IP updates are handled by scripts/update-geoip.mjs.

docker/ - Container Configuration

Docker Compose files for development and production containers are stored in the docker/ directory. The primary orchestration file is located at [docker/docker-compose.yml](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml).

fixtures/ - Test Sample Projects

Sample projects used in integration testing—spanning Spring Boot, FastAPI, Go, and .NET—are organized under fixtures/. A Python FastAPI example is available at [fixtures/deploy/python-fastapi/main.py](https://github.com/oblien/openship/blob/main/fixtures/deploy/python-fastapi/main.py).

.github/ and .githooks/ - CI/CD and Git Automation

The .github/ directory stores CI/CD workflow definitions, issue templates, and funding metadata, with continuous integration configured in [.github/workflows/ci.yml](https://github.com/oblien/openship/blob/main/.github/workflows/ci.yml). Git hook scripts used by maintainers are located in .githooks/, such as the post-rewrite hook at .githooks/post-rewrite.

Root-Level Configuration Files

In addition to subdirectories, the repository root contains configuration and metadata files that define the workspace structure. The [package.json](https://github.com/oblien/openship/blob/main/package.json) declares the monorepo layout and lists top-level packages, while [pnpm-workspace.yaml](https://github.com/oblien/openship/blob/main/pnpm-workspace.yaml) confirms the presence of apps/** and packages/** through workspace glob patterns. The [README.md](https://github.com/oblien/openship/blob/main/README.md) provides a high-level introduction to the project and its major components.

How to List Openship Subdirectories Programmatically

You can verify the directory structure locally using either Node.js or shell scripts.

To list directories using Node.js and the native fs module:

import { readdir } from 'node:fs/promises';
import { join } from 'node:path';

async function listTopLevelDirs(repoRoot) {
  const entries = await readdir(repoRoot, { withFileTypes: true });
  return entries
    .filter(entry => entry.isDirectory())
    .map(entry => entry.name);
}

// Example usage:
listTopLevelDirs('.')
  .then(dirs => console.log('Top-level dirs:', dirs))
  .catch(err => console.error(err));

To list directories using a POSIX shell script:

#!/usr/bin/env bash

# List only directories in the repository root

for d in */ ; do
  echo "${d%/}"
done

Both methods output the eight primary subdirectories documented in the repository structure.

Summary

• The oblien/openship repository organizes code into eight primary subdirectories within the root level.
• The apps/ directory contains the Next.js web application and other front-end clients.
• The packages/ directory hosts reusable libraries shared across applications.
• Infrastructure and deployment files are separated into docker/, scripts/, and fixtures/.
• Development workflow automation resides in .github/ and .githooks/.
• Workspace configuration is governed by pnpm-workspace.yaml and root package.json.

Frequently Asked Questions

What is the purpose of the apps/ directory in openship?

The apps/ directory contains the deployable front-end applications, primarily the web interface built with Next.js. As configured in apps/web/next.config.mjs, this directory holds the entry points for user-facing functionality, distinct from the shared libraries in packages/.

How does the packages/ directory differ from apps/?

While apps/ contains runnable applications, packages/ stores reusable libraries that provide shared functionality such as UI components and onboarding flows. Files like packages/onboarding/src/index.ts export modules that applications import, following the monorepo pattern defined in pnpm-workspace.yaml.

Where are Docker configuration files located in the openship repository?

Docker Compose configurations for development and production environments are located in the docker/ subdirectory, specifically at docker/docker-compose.yml. This separation keeps container orchestration files isolated from application source code.

How can I verify the openship directory structure on my local machine?

You can list all subdirectories using the Node.js fs/promises module with readdir and isDirectory() filtering, or by running a shell loop that iterates over */ patterns. Both methods will reveal the eight primary directories: apps/, packages/, docs/, scripts/, docker/, fixtures/, .github/, and .githooks/.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}