Extract common utilities and improve default granularity

- Extract shared configuration logic to .claude/skills/common.sh
  - Container naming and detection functions
  - Git branch sanitization
  - Docker image configuration
  - GPU target detection
  - Reduces ~50 lines of duplicate code between skills

- Refactor ck-docker to use common.sh utilities
  - Replace manual docker ps checks with helper functions
  - Use shared container_exists() and container_is_running()
  - Use shared detect_gpu_target() and get_docker_image()

- Refactor ck-build-analysis to use common.sh utilities
  - Use shared get_project_root() and get_container_name()
  - Use shared ensure_container_running()
  - Use shared detect_gpu_target()

- Change default granularity from 500µs to 100µs
  - Provides better balance between detail and performance
  - Captures ~15k instantiations vs ~5k at 500µs
  - Still manageable 15-20 MB trace files
  - Update all documentation and help text

Co-Authored-By: Claude <noreply@anthropic.com>

Author: tenpercent

.claude/skills/ck-build-analysis

@@ -4,26 +4,16 @@
 set -e
 set -o pipefail
 
-# Find project root
+# Find script directory and load common utilities
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+source "${SCRIPT_DIR}/common.sh"
 
-# Detect git branch and sanitize for docker naming
-GIT_BRANCH=$(cd "${PROJECT_ROOT}" && git rev-parse --abbrev-ref HEAD 2>/dev/null | tr '/' '_' | tr -cd 'a-zA-Z0-9_-' || echo "")
-GIT_BRANCH=${GIT_BRANCH:-unknown}
-if [ "${GIT_BRANCH}" = "HEAD" ]; then
-    GIT_BRANCH="detached"
-fi
-
-# Ensure USER is set
-USER_NAME=${USER:-$(whoami 2>/dev/null || echo "user")}
-
-# Default container name
-DEFAULT_NAME="ck_${USER_NAME}_${GIT_BRANCH}"
-CONTAINER_NAME="${CK_CONTAINER_NAME:-${DEFAULT_NAME}}"
+# Initialize configuration
+PROJECT_ROOT=$(get_project_root "${SCRIPT_DIR}")
+CONTAINER_NAME=$(get_container_name "${PROJECT_ROOT}")
 
 # Default settings
-GRANULARITY="${CK_BUILD_ANALYSIS_GRANULARITY:-500}"
+GRANULARITY="${CK_BUILD_ANALYSIS_GRANULARITY:-100}"
 OUTPUT_FILE="build_time_analysis_report.md"
 RECONFIGURE=true
 
@@ -38,7 +28,7 @@ Arguments:
   target                      Build target to analyze (e.g., example_convnd_fwd_xdl_fp8)
 
 Options:
-  --granularity=N            Time trace granularity in microseconds (default: 500)
+  --granularity=N            Time trace granularity in microseconds (default: 100)
   --output=FILE              Output report filename (default: build_time_analysis_report.md)
   --name=NAME                Docker container name (default: ${CONTAINER_NAME})
   --no-reconfigure           Skip CMake reconfiguration if build exists
@@ -50,8 +40,8 @@ Examples:
   ck-build-analysis test_amdgcn_mma --granularity=100 --output=mma_test_analysis.md
 
 Granularity Guide:
-  500 (default)  - Quick overview, filters 86% of events (~5k instantiations, 3-5 MB)
-  100            - Balanced detail (~15k instantiations, 15-20 MB)
+  100 (default)  - Balanced detail (~15k instantiations, 15-20 MB)
+  500            - Quick overview, filters 86% of events (~5k instantiations, 3-5 MB)
   1              - Complete analysis (~36k instantiations, 80-100 MB)
 EOF
 }
@@ -116,17 +106,14 @@ echo "════════════════════════
 echo ""
 
 # Ensure container is running
-if ! docker ps --filter "name=^${CONTAINER_NAME}$" --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
-    echo "Container not running. Starting with ck-docker..."
-    "${SCRIPT_DIR}/ck-docker" start "${CONTAINER_NAME}"
-fi
+ensure_container_running "${CONTAINER_NAME}" "${SCRIPT_DIR}"
 
 # Configure CMake with -ftime-trace if needed
 if [ "$RECONFIGURE" = true ] || ! docker exec "${CONTAINER_NAME}" test -f /workspace/build/build.ninja 2>/dev/null; then
     echo ""
     echo "Configuring CMake with -ftime-trace (granularity=${GRANULARITY}µs)..."
 
-    GPU_TARGET=$(docker exec "${CONTAINER_NAME}" bash -c "rocminfo 2>/dev/null | grep -oP 'gfx[0-9a-z]+' | head -1 || echo 'gfx950'" | tr -d '\r\n')
+    GPU_TARGET=$(detect_gpu_target "${CONTAINER_NAME}")
 
     docker exec "${CONTAINER_NAME}" bash -c "
         cd /workspace || exit 1

.claude/skills/ck-build-analysis.md

@@ -30,7 +30,7 @@ Just ask in natural language:
 ck-build-analysis <target> [options]
 
 Options:
-  --granularity=N      Time trace granularity in microseconds (default: 500)
+  --granularity=N      Time trace granularity in microseconds (default: 100)
   --output=FILE        Output report filename (default: build_time_analysis_report.md)
   --name=NAME          Docker container name (default: from CK_CONTAINER_NAME or auto-generated)
   --no-reconfigure     Skip CMake reconfiguration if build exists
@@ -58,27 +58,27 @@ Options:
 ## Environment
 
 ```bash
-export CK_CONTAINER_NAME=my_build     # Override container name
-export CK_BUILD_ANALYSIS_GRANULARITY=1  # Default granularity in µs
+export CK_CONTAINER_NAME=my_build       # Override container name
+export CK_BUILD_ANALYSIS_GRANULARITY=100  # Default granularity in µs
 ```
 
 ## Examples
 
 ```bash
-# Basic analysis with default granularity (500µs)
+# Basic analysis with default granularity (100µs)
 ck-build-analysis example_convnd_fwd_xdl_fp8
 
-# High-resolution analysis (1µs granularity, 22x larger trace)
-ck-build-analysis example_convnd_fwd_xdl_fp8 --granularity=1
+# Quick overview (500µs granularity, filters minor events)
+ck-build-analysis example_convnd_fwd_xdl_fp8 --granularity=500
 
-# Medium-resolution analysis (100µs granularity, good balance)
-ck-build-analysis example_convnd_fwd_xdl_fp8 --granularity=100
+# High-resolution analysis (1µs granularity, complete picture)
+ck-build-analysis example_convnd_fwd_xdl_fp8 --granularity=1
 
 # Custom output filename
 ck-build-analysis example_convnd_fwd_xdl_fp8 --output=fp8_conv_analysis.md
 
 # Analyze test target
-ck-build-analysis test_amdgcn_mma --granularity=1
+ck-build-analysis test_amdgcn_mma
 
 # Use existing build (skip reconfigure)
 ck-build-analysis example_convnd_fwd_xdl_fp8 --no-reconfigure
@@ -99,17 +99,17 @@ The report includes:
 
 | Granularity | Events | Trace Size | Use Case |
 |-------------|--------|------------|----------|
-| 500µs (default) | ~50k | 3-5 MB | Quick overview, major bottlenecks |
-| 100µs | ~150k | 15-20 MB | Balanced detail and performance |
+| 500µs | ~50k | 3-5 MB | Quick overview, major bottlenecks only |
+| 100µs (default) | ~150k | 15-20 MB | Balanced detail and performance |
 | 50µs | ~200k | 30-40 MB | Detailed analysis |
 | 1µs (high-res) | ~300k | 80-100 MB | Complete picture, all instantiations |
 
 ## Notes
 
 - Lower granularity = more events = larger files = longer analysis
-- Default 500µs captures major bottlenecks (filters out 86% of instantiations)
+- Default 100µs provides balanced detail for most use cases
+- 500µs captures only major bottlenecks (filters out 86% of instantiations)
 - 1µs granularity reveals all 36,000+ instantiations but takes longer to analyze
-- 100µs is a good middle ground for most use cases
 
 ## Implementation Details
 

.claude/skills/ck-docker

@@ -4,25 +4,13 @@
 set -e
 set -o pipefail
 
-# Find project root (where .git directory is)
+# Find script directory and load common utilities
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+source "${SCRIPT_DIR}/common.sh"
 
-# Detect git branch and sanitize for docker naming (replace / and special chars with _)
-GIT_BRANCH=$(cd "${PROJECT_ROOT}" && git rev-parse --abbrev-ref HEAD 2>/dev/null | tr '/' '_' | tr -cd 'a-zA-Z0-9_-' || echo "")
-# Handle edge cases: detached HEAD, empty branch name
-GIT_BRANCH=${GIT_BRANCH:-unknown}
-# If branch is just "HEAD" (detached state), make it more descriptive
-if [ "${GIT_BRANCH}" = "HEAD" ]; then
-    GIT_BRANCH="detached"
-fi
-
-# Ensure USER is set
-USER_NAME=${USER:-$(whoami 2>/dev/null || echo "user")}
-
-# Default container name: ck_<username>_<branch>
-DEFAULT_NAME="ck_${USER_NAME}_${GIT_BRANCH}"
-CONTAINER_NAME="${CK_CONTAINER_NAME:-${DEFAULT_NAME}}"
+# Initialize configuration
+PROJECT_ROOT=$(get_project_root "${SCRIPT_DIR}")
+CONTAINER_NAME=$(get_container_name "${PROJECT_ROOT}")
 
 # Help message
 show_help() {
@@ -53,28 +41,14 @@ Environment:
 EOF
 }
 
-# Detect GPU target
-detect_gpu() {
-    local container=$1
-    # Allow override via GPU_TARGET environment variable
-    if [ -n "${GPU_TARGET:-}" ]; then
-        echo "${GPU_TARGET}"
-        return 0
-    fi
-    docker exec "${container}" bash -c "
-      rocminfo 2>/dev/null | grep -oP 'gfx[0-9a-z]+' | head -1 || echo 'gfx950'
-    " | tr -d '\r\n'
-}
-
 # Start container
 cmd_start() {
     local name="${1:-${CONTAINER_NAME}}"
-    local docker_image="${CK_DOCKER_IMAGE:-rocm/composable_kernel:ck_ub24.04_rocm7.0.1}"
+    local docker_image=$(get_docker_image)
 
-    # Check if container exists (exact match to avoid substring collisions)
-    if docker ps -a --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"; then
-        # Check if container is running
-        if docker ps --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"; then
+    # Check if container exists and is running
+    if container_exists "${name}"; then
+        if container_is_running "${name}"; then
             echo "Container '${name}' is already running"
             return 0
         else
@@ -123,16 +97,16 @@ cmd_build() {
         esac
     done
 
-    # Check if container is running (exact match)
-    if ! docker ps --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"; then
+    # Check if container is running
+    if ! container_is_running "${name}"; then
         echo "Container '${name}' not running. Starting..."
         cmd_start "${name}"
     fi
 
     # Reconfigure CMake if requested or if build.ninja doesn't exist
     if [ "$reconfigure" = true ] || ! docker exec "${name}" test -f /workspace/build/build.ninja 2>/dev/null; then
         echo "Detecting GPU target..."
-        local gpu_target=$(detect_gpu "${name}")
+        local gpu_target=$(detect_gpu_target "${name}")
 
         if [ "$reconfigure" = true ]; then
             echo "Reconfiguring CMake from scratch for GPU target: ${gpu_target}"
@@ -200,8 +174,8 @@ cmd_test() {
         return 1
     fi
 
-    # Check if container is running (exact match)
-    if ! docker ps --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"; then
+    # Check if container is running
+    if ! container_is_running "${name}"; then
         echo "Error: Container '${name}' not running"
         echo "Start it with: ck-docker start --name ${name}"
         return 1
@@ -226,8 +200,8 @@ cmd_test() {
 cmd_shell() {
     local name="${1:-${CONTAINER_NAME}}"
 
-    # Check if container is running (exact match)
-    if ! docker ps --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"; then
+    # Check if container is running
+    if ! container_is_running "${name}"; then
         echo "Container '${name}' not running. Starting..."
         cmd_start "${name}"
     fi
@@ -239,22 +213,22 @@ cmd_shell() {
 # Status
 cmd_status() {
     local name="${1:-}"
-    local docker_image="${CK_DOCKER_IMAGE:-rocm/composable_kernel:ck_ub24.04_rocm7.0.1}"
+    local docker_image=$(get_docker_image)
 
     if [ -z "$name" ]; then
         echo "Composable Kernel Docker Containers:"
         echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
         docker ps -a --filter "ancestor=${docker_image}" \
             --format "table {{.Names}}\t{{.Status}}\t{{.CreatedAt}}" || echo "No containers found"
     else
-        # Check if container is running (exact match)
-        if docker ps --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"; then
+        # Check container status
+        if container_is_running "${name}"; then
             echo "Container '${name}' is RUNNING"
             docker ps --filter "name=^${name}$" --format "table {{.Names}}\t{{.Status}}\t{{.Image}}"
             echo ""
             echo "GPU Information:"
             docker exec "${name}" bash -c "rocm-smi --showproductname 2>/dev/null | head -10 || echo 'No GPU detected'"
-        elif docker ps -a --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"; then
+        elif container_exists "${name}"; then
             echo "Container '${name}' exists but is STOPPED"
             echo "Start with: ck-docker start ${name}"
         else
@@ -268,8 +242,8 @@ cmd_status() {
 cmd_stop() {
     local name="${1:-${CONTAINER_NAME}}"
 
-    # Check if container exists (exact match)
-    if docker ps -a --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"; then
+    # Check if container exists
+    if container_exists "${name}"; then
         echo "Stopping and removing container '${name}'..."
         docker stop "${name}" 2>/dev/null || true
         docker rm "${name}" 2>/dev/null || true

.claude/skills/common.sh

@@ -0,0 +1,94 @@
+#!/bin/bash
+# Common utilities for CK Docker skills
+# Shared configuration and helper functions
+
+# Find project root (where .git directory is)
+get_project_root() {
+    local script_dir="$1"
+    cd "${script_dir}/../.." && pwd
+}
+
+# Detect git branch and sanitize for Docker naming
+get_sanitized_branch() {
+    local project_root="$1"
+    local branch
+
+    branch=$(cd "${project_root}" && git rev-parse --abbrev-ref HEAD 2>/dev/null | tr '/' '_' | tr -cd 'a-zA-Z0-9_-' || echo "")
+    branch=${branch:-unknown}
+
+    # Handle detached HEAD state
+    if [ "${branch}" = "HEAD" ]; then
+        branch="detached"
+    fi
+
+    echo "${branch}"
+}
+
+# Get username with fallback
+get_username() {
+    echo "${USER:-$(whoami 2>/dev/null || echo "user")}"
+}
+
+# Generate default container name: ck_<username>_<branch>
+get_default_container_name() {
+    local project_root="$1"
+    local user_name
+    local git_branch
+
+    user_name=$(get_username)
+    git_branch=$(get_sanitized_branch "${project_root}")
+
+    echo "ck_${user_name}_${git_branch}"
+}
+
+# Get container name (respects CK_CONTAINER_NAME env var)
+get_container_name() {
+    local project_root="$1"
+    local default_name
+
+    default_name=$(get_default_container_name "${project_root}")
+    echo "${CK_CONTAINER_NAME:-${default_name}}"
+}
+
+# Get Docker image (respects CK_DOCKER_IMAGE env var)
+get_docker_image() {
+    echo "${CK_DOCKER_IMAGE:-rocm/composable_kernel:ck_ub24.04_rocm7.0.1}"
+}
+
+# Check if container exists (exact match)
+container_exists() {
+    local name="$1"
+    docker ps -a --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"
+}
+
+# Check if container is running (exact match)
+container_is_running() {
+    local name="$1"
+    docker ps --filter "name=^${name}$" --format '{{.Names}}' | grep -q "^${name}$"
+}
+
+# Detect GPU target in container
+detect_gpu_target() {
+    local container="$1"
+
+    # Allow override via GPU_TARGET environment variable
+    if [ -n "${GPU_TARGET:-}" ]; then
+        echo "${GPU_TARGET}"
+        return 0
+    fi
+
+    docker exec "${container}" bash -c "
+        rocminfo 2>/dev/null | grep -oP 'gfx[0-9a-z]+' | head -1 || echo 'gfx950'
+    " | tr -d '\r\n'
+}
+
+# Ensure container is running, start if needed
+ensure_container_running() {
+    local container="$1"
+    local script_dir="$2"
+
+    if ! container_is_running "${container}"; then
+        echo "Container '${container}' not running. Starting with ck-docker..."
+        "${script_dir}/ck-docker" start "${container}"
+    fi
+}