Name: flow.map-codebase
Author: jpoley

Prompt file imported from jpoley/rune-forge (.github/prompts/flow.map-codebase.prompt.md). Fill in {{arguments}} before use. Copyright stays with the author.

User Input

{{arguments}}

You MUST consider the user input before proceeding (if not empty).

Execution Instructions

This command generates bounded directory tree listings for relevant parts of the codebase. It creates readable maps that support PRP generation and feature context.

Argument Parsing

Parse the user input for paths and flags:

# Expected formats:
# /flow:map-codebase src/commands           # Single path
# /flow:map-codebase src/ tests/            # Multiple paths
# /flow:map-codebase src/ --depth 3         # With depth flag
# /flow:map-codebase src/ --output docs/feature-maps/task-123.md
# /flow:map-codebase src/ --prp task-123    # Update PRP file

PATHS=""
DEPTH=3
OUTPUT=""
PRP_TASK=""

# Parse arguments
for arg in {{arguments}}; do
  case "$arg" in
    --depth)
      # Next arg is depth value
      ;;
    --output)
      # Next arg is output path
      ;;
    --prp)
      # Next arg is task ID
      ;;
    *)
      # Treat as path if doesn't start with --
      if [[ ! "$arg" =~ ^-- ]]; then
        PATHS="$PATHS $arg"
      fi
      ;;
  esac
done

Default Values

If no arguments provided, show usage:

Usage: /flow:map-codebase <paths...> [options]

Options:
  --depth <n>     Maximum directory depth (default: 3)
  --output <path> Write to specific file
  --prp <task-id> Update CODEBASE SNAPSHOT in docs/prp/<task-id>.md

Examples:
  /flow:map-codebase src/
  /flow:map-codebase src/ tests/ --depth 4
  /flow:map-codebase src/commands --prp task-123
  /flow:map-codebase src/ --output docs/feature-maps/auth.md

Step 1: Validate Paths

Verify all specified paths exist:

for path in $PATHS; do
  if [ ! -e "$path" ]; then
    echo "ERROR: Path not found: $path"
    exit 1
  fi
done

echo "Mapping paths: $PATHS"
echo "Depth: $DEPTH"

Step 2: Generate Directory Tree

Generate a bounded directory tree for each path, excluding common non-essential directories:

# Exclusion patterns
EXCLUDES="--exclude node_modules --exclude __pycache__ --exclude .git --exclude .venv --exclude venv --exclude .mypy_cache --exclude .pytest_cache --exclude .ruff_cache --exclude dist --exclude build --exclude *.egg-info --exclude .tox --exclude coverage --exclude .coverage --exclude htmlcov"

# Generate tree for each path
for path in $PATHS; do
  echo ""
  echo "## $path"
  echo ""
  echo '```'
  # Use tree command if available, otherwise use find
  if command -v tree &> /dev/null; then
    tree -L $DEPTH $EXCLUDES --noreport "$path"
  else
    # Fallback to find + custom formatting
    find "$path" -maxdepth $DEPTH -type f -o -type d | \
      grep -v "node_modules\|__pycache__\|\.git\|\.venv\|\.mypy_cache" | \
      sort
  fi
  echo '```'
done

Step 3: Identify Key Entry Points

For each mapped path, identify key entry points:

echo ""
echo "### Key Entry Points"
echo ""
echo "| Entry Point | Location | Purpose |"
echo "|-------------|----------|---------|"

# Look for common entry point patterns
for path in $PATHS; do
  # Main files
  find "$path" -maxdepth 2 -name "main.py" -o -name "main.ts" -o -name "index.ts" -o -name "index.py" -o -name "app.py" -o -name "cli.py" 2>/dev/null | while read f; do
    echo "| \`$(basename $f)\` | \`$f\` | Main entry point |"
  done

  # Command files
  find "$path" -maxdepth 3 -path "*/commands/*.py" -o -path "*/commands/*.ts" 2>/dev/null | head -5 | while read f; do
    echo "| \`$(basename $f)\` | \`$f\` | Command handler |"
  done
done

Step 4: Identify Integration Points

Look for files that represent integration boundaries:

echo ""
echo "### Integration Points"
echo ""
echo "| Integration | File | Function/Method | Notes |"
echo "|-------------|------|-----------------|-------|"

for path in $PATHS; do
  # API route files
  find "$path" -maxdepth 3 -name "routes*.py" -o -name "routes*.ts" -o -name "api*.py" 2>/dev/null | head -3 | while read f; do
    echo "| API | \`$f\` | - | REST/GraphQL endpoints |"
  done

  # Database files
  find "$path" -maxdepth 3 -name "models*.py" -o -name "database*.py" -o -name "db*.py" 2>/dev/null | head -3 | while read f; do
    echo "| Database | \`$f\` | - | Data models |"
  done

  # Config files
  find "$path" -maxdepth 2 -name "config*.py" -o -name "settings*.py" 2>/dev/null | head -2 | while read f; do
    echo "| Config | \`$f\` | - | Configuration |"
  done
done

Step 5: Output Handling

Based on flags, write output to appropriate destination:

Option A: Standard Output (default)

If no --output or --prp flag, print to stdout:

Codebase Map Generated
======================

[Directory tree output]
[Key Entry Points table]
[Integration Points table]

Copy this output to your PRP or documentation.

Option B: Write to File (--output flag)

if [ -n "$OUTPUT" ]; then
  # Ensure directory exists
  mkdir -p "$(dirname $OUTPUT)"

  # Write header
  echo "# Codebase Map" > "$OUTPUT"
  echo "" >> "$OUTPUT"
  echo "> Generated by /flow:map-codebase" >> "$OUTPUT"
  echo "> Generated at: $(date -u +"%Y-%m-%dT%H:%M:%SZ")" >> "$OUTPUT"
  echo "" >> "$OUTPUT"

  # Append tree output
  # ... (tree generation)

  echo ""
  echo "Map written to: $OUTPUT"
fi

Option C: Update PRP File (--prp flag)

if [ -n "$PRP_TASK" ]; then
  PRP_FILE="docs/prp/$PRP_TASK.md"

  if [ ! -f "$PRP_FILE" ]; then
    echo "ERROR: PRP file not found: $PRP_FILE"
    echo "Run /flow:generate-prp $PRP_TASK first"
    exit 1
  fi

  echo "Updating CODEBASE SNAPSHOT in: $PRP_FILE"

  # Replace content between CODEBASE SNAPSHOT markers
  # ... (sed/awk replacement logic)

  echo "PRP updated successfully"
fi

Step 6: File Type Summary

Generate a summary of file types found:

echo ""
echo "### File Type Summary"
echo ""
echo "| Extension | Count |"
echo "|-----------|-------|"

for path in $PATHS; do
  find "$path" -type f -name "*.*" | \
    grep -v "node_modules\|__pycache__\|\.git" | \
    sed 's/.*\.//' | sort | uniq -c | sort -rn | head -10 | \
    while read count ext; do
      echo "| .$ext | $count |"
    done
done

Output Format

The complete output format is:

# Codebase Map

> Generated by /flow:map-codebase
> Paths: src/commands tests/
> Depth: 3
> Generated at: 2024-01-15T10:30:00Z

## Directory Tree

### src/commands

src/commands/ ├── flow/ │ ├── assess.md │ ├── implement.md │ └── specify.md ├── dev/ │ └── debug.md └── README.md


### tests/

tests/ ├── unit/ │ └── test_commands.py └── integration/ └── test_flow.py


## Key Entry Points

| Entry Point | Location | Purpose |
|-------------|----------|---------|
| `main.py` | `src/main.py` | CLI entry point |
| `assess.md` | `src/commands/flow/assess.md` | Assessment command |

## Integration Points

| Integration | File | Function/Method | Notes |
|-------------|------|-----------------|-------|
| CLI | `src/cli.py` | `main()` | Typer CLI |
| Commands | `src/commands/` | - | Slash commands |

## File Type Summary

| Extension | Count |
|-----------|-------|
| .py | 45 |
| .md | 23 |
| .yml | 8 |

Example Usage

# Map a single directory
/flow:map-codebase src/

# Map multiple directories with custom depth
/flow:map-codebase src/ tests/ --depth 4

# Update a PRP file's CODEBASE SNAPSHOT section
/flow:map-codebase src/commands --prp task-123

# Save to a specific file
/flow:map-codebase src/ --output docs/feature-maps/authentication.md

Deliverables

This command produces:

Directory Tree: Bounded tree listing of specified paths
Key Entry Points: Table of main entry files
Integration Points: Table of integration boundaries
File Type Summary: Count of file types

Output can be:

Displayed in terminal (default)
Written to a file (--output)
Inserted into a PRP file (--prp)

## User Input ```text {{arguments}} ``` You **MUST** consider the user input before proceeding (if not empty). ## Execution Instructions This command generates bounded directory tree listings for relevant parts of the codebase. It creates readable maps that support PRP generation and feature context. ### Argument Parsing Parse the user input for paths and flags: ```bash # Expected formats: # /flow:map-codebase src/commands # Single path # /flow:map-codebase src/ tests/ # Multiple paths # /flow:map-codebase src/ --depth 3 # With depth flag # /flow:map-codebase src/ --output docs/feature-maps/task-123.md # /flow:map-codebase src/ --prp task-123 # Update PRP file PATHS="" DEPTH=3 OUTPUT="" PRP_TASK="" # Parse arguments for arg in {{arguments}}; do case "$arg" in --depth) # Next arg is depth value ;; --output) # Next arg is output path ;; --prp) # Next arg is task ID ;; *) # Treat as path if doesn't start with -- if [[ ! "$arg" =~ ^-- ]]; then PATHS="$PATHS $arg" fi ;; esac done ``` ### Default Values If no arguments provided, show usage: ``` Usage: /flow:map-codebase <paths...> [options] Options: --depth <n> Maximum directory depth (default: 3) --output <path> Write to specific file --prp <task-id> Update CODEBASE SNAPSHOT in docs/prp/<task-id>.md Examples: /flow:map-codebase src/ /flow:map-codebase src/ tests/ --depth 4 /flow:map-codebase src/commands --prp task-123 /flow:map-codebase src/ --output docs/feature-maps/auth.md ``` ### Step 1: Validate Paths Verify all specified paths exist: ```bash for path in $PATHS; do if [ ! -e "$path" ]; then echo "ERROR: Path not found: $path" exit 1 fi done echo "Mapping paths: $PATHS" echo "Depth: $DEPTH" ``` ### Step 2: Generate Directory Tree Generate a bounded directory tree for each path, excluding common non-essential directories: ```bash # Exclusion patterns EXCLUDES="--exclude node_modules --exclude __pycache__ --exclude .git --exclude .venv --exclude venv --exclude .mypy_cache --exclude .pytest_cache --exclude .ruff_cache --exclude dist --exclude build --exclude *.egg-info --exclude .tox --exclude coverage --exclude .coverage --exclude htmlcov" # Generate tree for each path for path in $PATHS; do echo "" echo "## $path" echo "" echo '```' # Use tree command if available, otherwise use find if command -v tree &> /dev/null; then tree -L $DEPTH $EXCLUDES --noreport "$path" else # Fallback to find + custom formatting find "$path" -maxdepth $DEPTH -type f -o -type d | \ grep -v "node_modules\|__pycache__\|\.git\|\.venv\|\.mypy_cache" | \ sort fi echo '```' done ``` ### Step 3: Identify Key Entry Points For each mapped path, identify key entry points: ```bash echo "" echo "### Key Entry Points" echo "" echo "| Entry Point | Location | Purpose |" echo "|-------------|----------|---------|" # Look for common entry point patterns for path in $PATHS; do # Main files find "$path" -maxdepth 2 -name "main.py" -o -name "main.ts" -o -name "index.ts" -o -name "index.py" -o -name "app.py" -o -name "cli.py" 2>/dev/null | while read f; do echo "| \`$(basename $f)\` | \`$f\` | Main entry point |" done # Command files find "$path" -maxdepth 3 -path "*/commands/*.py" -o -path "*/commands/*.ts" 2>/dev/null | head -5 | while read f; do echo "| \`$(basename $f)\` | \`$f\` | Command handler |" done done ``` ### Step 4: Identify Integration Points Look for files that represent integration boundaries: ```bash echo "" echo "### Integration Points" echo "" echo "| Integration | File | Function/Method | Notes |" echo "|-------------|------|-----------------|-------|" for path in $PATHS; do # API route files find "$path" -maxdepth 3 -name "routes*.py" -o -name "routes*.ts" -o -name "api*.py" 2>/dev/null | head -3 | while read f; do echo "| API | \`$f\` | - | REST/GraphQL endpoints |" done # Database files find "$path" -maxdepth 3 -name "models*.py" -o -name "database*.py" -o -name "db*.py" 2>/dev/null | head -3 | while read f; do echo "| Database | \`$f\` | - | Data models |" done # Config files find "$path" -maxdepth 2 -name "config*.py" -o -name "settings*.py" 2>/dev/null | head -2 | while read f; do echo "| Config | \`$f\` | - | Configuration |" done done ``` ### Step 5: Output Handling Based on flags, write output to appropriate destination: #### Option A: Standard Output (default) If no `--output` or `--prp` flag, print to stdout: ``` Codebase Map Generated ====================== [Directory tree output] [Key Entry Points table] [Integration Points table] Copy this output to your PRP or documentation. ``` #### Option B: Write to File (--output flag) ```bash if [ -n "$OUTPUT" ]; then # Ensure directory exists mkdir -p "$(dirname $OUTPUT)" # Write header echo "# Codebase Map" > "$OUTPUT" echo "" >> "$OUTPUT" echo "> Generated by /flow:map-codebase" >> "$OUTPUT" echo "> Generated at: $(date -u +"%Y-%m-%dT%H:%M:%SZ")" >> "$OUTPUT" echo "" >> "$OUTPUT" # Append tree output # ... (tree generation) echo "" echo "Map written to: $OUTPUT" fi ``` #### Option C: Update PRP File (--prp flag) ```bash if [ -n "$PRP_TASK" ]; then PRP_FILE="docs/prp/$PRP_TASK.md" if [ ! -f "$PRP_FILE" ]; then echo "ERROR: PRP file not found: $PRP_FILE" echo "Run /flow:generate-prp $PRP_TASK first" exit 1 fi echo "Updating CODEBASE SNAPSHOT in: $PRP_FILE" # Replace content between CODEBASE SNAPSHOT markers # ... (sed/awk replacement logic) echo "PRP updated successfully" fi ``` ### Step 6: File Type Summary Generate a summary of file types found: ```bash echo "" echo "### File Type Summary" echo "" echo "| Extension | Count |" echo "|-----------|-------|" for path in $PATHS; do find "$path" -type f -name "*.*" | \ grep -v "node_modules\|__pycache__\|\.git" | \ sed 's/.*\.//' | sort | uniq -c | sort -rn | head -10 | \ while read count ext; do echo "| .$ext | $count |" done done ``` ### Output Format The complete output format is: ```markdown # Codebase Map > Generated by /flow:map-codebase > Paths: src/commands tests/ > Depth: 3 > Generated at: 2024-01-15T10:30:00Z ## Directory Tree ### src/commands ``` src/commands/ ├── flow/ │ ├── assess.md │ ├── implement.md │ └── specify.md ├── dev/ │ └── debug.md └── README.md ``` ### tests/ ``` tests/ ├── unit/ │ └── test_commands.py └── integration/ └── test_flow.py ``` ## Key Entry Points | Entry Point | Location | Purpose | |-------------|----------|---------| | `main.py` | `src/main.py` | CLI entry point | | `assess.md` | `src/commands/flow/assess.md` | Assessment command | ## Integration Points | Integration | File | Function/Method | Notes | |-------------|------|-----------------|-------| | CLI | `src/cli.py` | `main()` | Typer CLI | | Commands | `src/commands/` | - | Slash commands | ## File Type Summary | Extension | Count | |-----------|-------| | .py | 45 | | .md | 23 | | .yml | 8 | ``` ### Example Usage ```bash # Map a single directory /flow:map-codebase src/ # Map multiple directories with custom depth /flow:map-codebase src/ tests/ --depth 4 # Update a PRP file's CODEBASE SNAPSHOT section /flow:map-codebase src/commands --prp task-123 # Save to a specific file /flow:map-codebase src/ --output docs/feature-maps/authentication.md ``` ## Deliverables This command produces: 1. **Directory Tree**: Bounded tree listing of specified paths 2. **Key Entry Points**: Table of main entry files 3. **Integration Points**: Table of integration boundaries 4. **File Type Summary**: Count of file types Output can be: - Displayed in terminal (default) - Written to a file (`--output`) - Inserted into a PRP file (`--prp`)

{ "prompt": "## User Input\n\n```text\n{{arguments}}\n```\n\nYou **MUST** consider the user input before proceeding (if not empty).\n\n## Execution Instructions\n\nThis command generates bounded directory tree listings for relevant parts of the codebase. It creates readable maps that support PRP generation and feature context.\n\n### Argument Parsing\n\nParse the user input for paths and flags:\n\n```bash\n# Expected formats:\n# /flow:map-codebase src/commands # Single path\n# /flow:map-codebase src/ tests/ # Multiple paths\n# /flow:map-codebase src/ --depth 3 # With depth flag\n# /flow:map-codebase src/ --output docs/feature-maps/task-123.md\n# /flow:map-codebase src/ --prp task-123 # Update PRP file\n\nPATHS=\"\"\nDEPTH=3\nOUTPUT=\"\"\nPRP_TASK=\"\"\n\n# Parse arguments\nfor arg in {{arguments}}; do\n case \"$arg\" in\n --depth)\n # Next arg is depth value\n ;;\n --output)\n # Next arg is output path\n ;;\n --prp)\n # Next arg is task ID\n ;;\n *)\n # Treat as path if doesn't start with --\n if [[ ! \"$arg\" =~ ^-- ]]; then\n PATHS=\"$PATHS $arg\"\n fi\n ;;\n esac\ndone\n```\n\n### Default Values\n\nIf no arguments provided, show usage:\n\n```\nUsage: /flow:map-codebase <paths...> [options]\n\nOptions:\n --depth <n> Maximum directory depth (default: 3)\n --output <path> Write to specific file\n --prp <task-id> Update CODEBASE SNAPSHOT in docs/prp/<task-id>.md\n\nExamples:\n /flow:map-codebase src/\n /flow:map-codebase src/ tests/ --depth 4\n /flow:map-codebase src/commands --prp task-123\n /flow:map-codebase src/ --output docs/feature-maps/auth.md\n```\n\n### Step 1: Validate Paths\n\nVerify all specified paths exist:\n\n```bash\nfor path in $PATHS; do\n if [ ! -e \"$path\" ]; then\n echo \"ERROR: Path not found: $path\"\n exit 1\n fi\ndone\n\necho \"Mapping paths: $PATHS\"\necho \"Depth: $DEPTH\"\n```\n\n### Step 2: Generate Directory Tree\n\nGenerate a bounded directory tree for each path, excluding common non-essential directories:\n\n```bash\n# Exclusion patterns\nEXCLUDES=\"--exclude node_modules --exclude __pycache__ --exclude .git --exclude .venv --exclude venv --exclude .mypy_cache --exclude .pytest_cache --exclude .ruff_cache --exclude dist --exclude build --exclude *.egg-info --exclude .tox --exclude coverage --exclude .coverage --exclude htmlcov\"\n\n# Generate tree for each path\nfor path in $PATHS; do\n echo \"\"\n echo \"## $path\"\n echo \"\"\n echo '```'\n # Use tree command if available, otherwise use find\n if command -v tree &> /dev/null; then\n tree -L $DEPTH $EXCLUDES --noreport \"$path\"\n else\n # Fallback to find + custom formatting\n find \"$path\" -maxdepth $DEPTH -type f -o -type d | \\\n grep -v \"node_modules\\|__pycache__\\|\\.git\\|\\.venv\\|\\.mypy_cache\" | \\\n sort\n fi\n echo '```'\ndone\n```\n\n### Step 3: Identify Key Entry Points\n\nFor each mapped path, identify key entry points:\n\n```bash\necho \"\"\necho \"### Key Entry Points\"\necho \"\"\necho \"| Entry Point | Location | Purpose |\"\necho \"|-------------|----------|---------|\"\n\n# Look for common entry point patterns\nfor path in $PATHS; do\n # Main files\n find \"$path\" -maxdepth 2 -name \"main.py\" -o -name \"main.ts\" -o -name \"index.ts\" -o -name \"index.py\" -o -name \"app.py\" -o -name \"cli.py\" 2>/dev/null | while read f; do\n echo \"| \\`$(basename $f)\\` | \\`$f\\` | Main entry point |\"\n done\n\n # Command files\n find \"$path\" -maxdepth 3 -path \"*/commands/*.py\" -o -path \"*/commands/*.ts\" 2>/dev/null | head -5 | while read f; do\n echo \"| \\`$(basename $f)\\` | \\`$f\\` | Command handler |\"\n done\ndone\n```\n\n### Step 4: Identify Integration Points\n\nLook for files that represent integration boundaries:\n\n```bash\necho \"\"\necho \"### Integration Points\"\necho \"\"\necho \"| Integration | File | Function/Method | Notes |\"\necho \"|-------------|------|-----------------|-------|\"\n\nfor path in $PATHS; do\n # API route files\n find \"$path\" -maxdepth 3 -name \"routes*.py\" -o -name \"routes*.ts\" -o -name \"api*.py\" 2>/dev/null | head -3 | while read f; do\n echo \"| API | \\`$f\\` | - | REST/GraphQL endpoints |\"\n done\n\n # Database files\n find \"$path\" -maxdepth 3 -name \"models*.py\" -o -name \"database*.py\" -o -name \"db*.py\" 2>/dev/null | head -3 | while read f; do\n echo \"| Database | \\`$f\\` | - | Data models |\"\n done\n\n # Config files\n find \"$path\" -maxdepth 2 -name \"config*.py\" -o -name \"settings*.py\" 2>/dev/null | head -2 | while read f; do\n echo \"| Config | \\`$f\\` | - | Configuration |\"\n done\ndone\n```\n\n### Step 5: Output Handling\n\nBased on flags, write output to appropriate destination:\n\n#### Option A: Standard Output (default)\n\nIf no `--output` or `--prp` flag, print to stdout:\n\n```\nCodebase Map Generated\n======================\n\n[Directory tree output]\n[Key Entry Points table]\n[Integration Points table]\n\nCopy this output to your PRP or documentation.\n```\n\n#### Option B: Write to File (--output flag)\n\n```bash\nif [ -n \"$OUTPUT\" ]; then\n # Ensure directory exists\n mkdir -p \"$(dirname $OUTPUT)\"\n\n # Write header\n echo \"# Codebase Map\" > \"$OUTPUT\"\n echo \"\" >> \"$OUTPUT\"\n echo \"> Generated by /flow:map-codebase\" >> \"$OUTPUT\"\n echo \"> Generated at: $(date -u +\"%Y-%m-%dT%H:%M:%SZ\")\" >> \"$OUTPUT\"\n echo \"\" >> \"$OUTPUT\"\n\n # Append tree output\n # ... (tree generation)\n\n echo \"\"\n echo \"Map written to: $OUTPUT\"\nfi\n```\n\n#### Option C: Update PRP File (--prp flag)\n\n```bash\nif [ -n \"$PRP_TASK\" ]; then\n PRP_FILE=\"docs/prp/$PRP_TASK.md\"\n\n if [ ! -f \"$PRP_FILE\" ]; then\n echo \"ERROR: PRP file not found: $PRP_FILE\"\n echo \"Run /flow:generate-prp $PRP_TASK first\"\n exit 1\n fi\n\n echo \"Updating CODEBASE SNAPSHOT in: $PRP_FILE\"\n\n # Replace content between CODEBASE SNAPSHOT markers\n # ... (sed/awk replacement logic)\n\n echo \"PRP updated successfully\"\nfi\n```\n\n### Step 6: File Type Summary\n\nGenerate a summary of file types found:\n\n```bash\necho \"\"\necho \"### File Type Summary\"\necho \"\"\necho \"| Extension | Count |\"\necho \"|-----------|-------|\"\n\nfor path in $PATHS; do\n find \"$path\" -type f -name \"*.*\" | \\\n grep -v \"node_modules\\|__pycache__\\|\\.git\" | \\\n sed 's/.*\\.//' | sort | uniq -c | sort -rn | head -10 | \\\n while read count ext; do\n echo \"| .$ext | $count |\"\n done\ndone\n```\n\n### Output Format\n\nThe complete output format is:\n\n```markdown\n# Codebase Map\n\n> Generated by /flow:map-codebase\n> Paths: src/commands tests/\n> Depth: 3\n> Generated at: 2024-01-15T10:30:00Z\n\n## Directory Tree\n\n### src/commands\n\n```\nsrc/commands/\n├── flow/\n│ ├── assess.md\n│ ├── implement.md\n│ └── specify.md\n├── dev/\n│ └── debug.md\n└── README.md\n```\n\n### tests/\n\n```\ntests/\n├── unit/\n│ └── test_commands.py\n└── integration/\n └── test_flow.py\n```\n\n## Key Entry Points\n\n| Entry Point | Location | Purpose |\n|-------------|----------|---------|\n| `main.py` | `src/main.py` | CLI entry point |\n| `assess.md` | `src/commands/flow/assess.md` | Assessment command |\n\n## Integration Points\n\n| Integration | File | Function/Method | Notes |\n|-------------|------|-----------------|-------|\n| CLI | `src/cli.py` | `main()` | Typer CLI |\n| Commands | `src/commands/` | - | Slash commands |\n\n## File Type Summary\n\n| Extension | Count |\n|-----------|-------|\n| .py | 45 |\n| .md | 23 |\n| .yml | 8 |\n```\n\n### Example Usage\n\n```bash\n# Map a single directory\n/flow:map-codebase src/\n\n# Map multiple directories with custom depth\n/flow:map-codebase src/ tests/ --depth 4\n\n# Update a PRP file's CODEBASE SNAPSHOT section\n/flow:map-codebase src/commands --prp task-123\n\n# Save to a specific file\n/flow:map-codebase src/ --output docs/feature-maps/authentication.md\n```\n\n## Deliverables\n\nThis command produces:\n1. **Directory Tree**: Bounded tree listing of specified paths\n2. **Key Entry Points**: Table of main entry files\n3. **Integration Points**: Table of integration boundaries\n4. **File Type Summary**: Count of file types\n\nOutput can be:\n- Displayed in terminal (default)\n- Written to a file (`--output`)\n- Inserted into a PRP file (`--prp`)", "variables": [ "arguments" ], "notes": "Generate bounded directory tree listings and feature maps for codebase areas. Mode: agent.", "metadata": { "source": { "provider": "github-prompts", "repository": "https://github.com/jpoley/rune-forge", "path": ".github/prompts/flow.map-codebase.prompt.md", "ref": "130b2e46f0c9666e686f3f18ef5ea11f98169308", "url": "https://github.com/jpoley/rune-forge/blob/130b2e46f0c9666e686f3f18ef5ea11f98169308/.github/prompts/flow.map-codebase.prompt.md", "key": "jpoley/rune-forge/.github/prompts/flow.map-codebase.prompt.md" } } }

flow.map-codebase

About