# How to View Arc-Kit Directory Structure with Bash: 5 Command Methods

> Explore the tractorjuice/arc-kit directory structure using Bash with 5 command methods. Learn quick ways to visualize your project with tree and find commands.

- Repository: [tractorjuice/arc-kit](https://github.com/tractorjuice/arc-kit)
- Tags: how-to-guide
- Published: 2026-04-19

---

**Use `tree -L 2` to display a visual hierarchy of the tractorjuice/arc-kit repository, or `find . -maxdepth 3 -type d` for a lightweight alternative that requires no installation.**

The ArcKit repository organizes its **core CLI tooling**, **project templates**, and **automation scripts** into a predictable layout. When you need to view the arc-kit directory structure with bash, standard Unix utilities provide several ways to inspect this hierarchy without leaving the terminal.

## Understanding the Arc-Kit Directory Layout

Before running commands, recognize the four primary zones in the repository root:

- **`src/arckit_cli/`** — Python source for the CLI entry point and `get_data_paths()` logic
- **`.arckit/`** — Default document templates and reusable Bash helpers (`.arckit/templates/`, `.arckit/scripts/bash/`)
- **`scripts/`** — Conversion utilities such as [`converter.py`](https://github.com/tractorjuice/arc-kit/blob/main/converter.py) that generate extension packages
- **`arckit-codex/`**, **`arckit-gemini/`**, **`arckit-opencode/`** — Generated AI-assistant extensions

## Method 1: Quick Recursive Listing with `ls`

The `ls -R` command provides the simplest way to view every file and subdirectory alphabetically.

```bash

# Show every file and sub-directory, sorted alphabetically

ls -R

```

This outputs a flat, long list without visual nesting. It works on all Unix systems without installing additional packages, making it ideal for constrained environments.

## Method 2: Visual Tree Hierarchy with `tree`

For a structured, indented view that mirrors the **Project Structure** diagram in the README, use the `tree` utility.

```bash

# Install tree if missing (Debian/Ubuntu)

sudo apt-get install -y tree

# Show the top-level hierarchy (2 levels deep)

tree -L 2

```

The `-L 2` flag limits depth to two levels, revealing top-level components such as `.arckit/`, `projects/`, `.codex/`, and `.github/` without overwhelming detail. This command best represents the visual layout described in the repository documentation.

## Method 3: Depth-Controlled Directory Discovery with `find`

When `tree` is unavailable, `find` offers a lightweight alternative to view the arc-kit directory structure with bash.

```bash

# Show the directory tree up to depth 3, stripping the leading "./"

find . -mindepth 1 -maxdepth 3 -type d | sed 's|^\./||' | sort

```

This command lists directories up to a configurable depth (`-maxdepth`) and works on any POSIX-compliant system without extra installations. The `sed` and `sort` pipeline cleans the output for readability.

## Method 4: File Count Analysis with `du` and `wc`

To understand the relative weight of each component (for example, the large number of generated prompts in `.github/prompts/`), combine `du` with a counting loop.

```bash

# How many files are in each top-level folder?

for d in */ ; do
    echo "$d: $(find "$d" -type f | wc -l) files"
done

```

This reveals which directories contain the most assets, helping you identify where core logic resides versus template content or generated extensions.

## Method 5: JSON Structure Output from Arc-Kit Scripts

ArcKit includes a Bash helper script that returns a machine-readable description of the scaffolded layout. Located at [`.arckit/scripts/bash/create-project.sh`](https://github.com/tractorjuice/arc-kit/blob/main/.arckit/scripts/bash/create-project.sh), this script can output the exact directories that would be created during project initialization.

```bash

# Run the helper to see the JSON summary of the project structure

.arckit/scripts/bash/create-project.sh --json

```

This method provides the canonical structure definition used by the ArcKit CLI, reflecting the intended layout for `arckit init` operations.

## Key Directories and Files to Observe

When you view the arc-kit directory structure with bash, prioritize these authoritative paths:

- **`src/arckit_cli/`** — Contains the CLI entry point and `get_data_paths()` resolution logic
- **`.arckit/templates/`** — Default document templates used by ArcKit commands
- **`.arckit/scripts/bash/`** — Reusable helpers including [`create-project.sh`](https://github.com/tractorjuice/arc-kit/blob/main/create-project.sh) and [`generate-document-id.sh`](https://github.com/tractorjuice/arc-kit/blob/main/generate-document-id.sh)
- **[`scripts/converter.py`](https://github.com/tractorjuice/arc-kit/blob/main/scripts/converter.py)** — Generates the Codex, OpenCode, Gemini, and Copilot extension packages
- **`arckit-codex/`**, **`arckit-gemini/`**, **`arckit-opencode/`** — Generated AI-assistant extensions
- **`VERSION`** — Single source of truth for the toolkit version

## Summary

- Use **`tree -L 2`** for the clearest visual representation of the ArcKit hierarchy
- Use **`find . -maxdepth 3 -type d`** when `tree` is unavailable to list directories precisely
- Use **`ls -R`** for simple, universal recursive listing without dependencies
- Use **`create-project.sh --json`** to see the canonical project structure definition used by the CLI
- Inspect **`src/arckit_cli/`** and **`.arckit/scripts/bash/`** to understand core tooling and helper logic

## Frequently Asked Questions

### How do I install the `tree` command on Ubuntu or Debian?

Run `sudo apt-get install -y tree` to install the `tree` utility. This package provides the `tree -L 2` command used to generate indented visual representations of the ArcKit directory structure.

### Where are the Bash helper scripts located in ArcKit?

The reusable Bash functions reside in `.arckit/scripts/bash/`. This directory contains [`create-project.sh`](https://github.com/tractorjuice/arc-kit/blob/main/create-project.sh), [`generate-document-id.sh`](https://github.com/tractorjuice/arc-kit/blob/main/generate-document-id.sh), and other helpers used during project scaffolding and document generation.

### What does the `.arckit` directory contain?

The `.arckit/` directory stores **default document templates** (in `.arckit/templates/`) and **automation scripts** (in `.arckit/scripts/`). These assets define the initial content and structure created when you run `arckit init`.

### How can I see the exact directory structure that `arckit init` creates?

Execute `.arckit/scripts/bash/create-project.sh --json` from the repository root. This outputs a JSON description of the scaffolded project layout, showing exactly which directories and files the initialization command generates.