@synapta/skills 0.1.1 → 0.2.0

package/skills/repo-bootstrap/scripts/detect-scopes.sh

@@ -0,0 +1,330 @@
+#!/usr/bin/env bash
+# Detect directories that should have scoped AGENTS.md files
+set -euo pipefail
+
+PROJECT_DIR="${1:-.}"
+cd "$PROJECT_DIR"
+
+MIN_FILES=5  # Minimum files to warrant scoped AGENTS.md
+
+# Get project info
+PROJECT_INFO=$(bash "$(dirname "$0")/detect-project.sh" "$PROJECT_DIR")
+LANGUAGE=$(echo "$PROJECT_INFO" | jq -r '.language')
+
+scopes=()
+
+# Function to count source files in a directory
+count_source_files() {
+    local dir="$1"
+    local pattern="$2"
+    find "$dir" -maxdepth 3 -type f -name "$pattern" 2>/dev/null | wc -l
+}
+
+# Function to add scope (uses jq for proper JSON escaping)
+add_scope() {
+    local path="$1"
+    local type="$2"
+    local count="$3"
+
+    scopes+=("$(jq -n --arg p "$path" --arg t "$type" --argjson c "$count" \
+        '{path: $p, type: $t, files: $c}')")
+}
+
+# Language-specific scope detection
+case "$LANGUAGE" in
+    "go")
+        # Check common Go directories
+        [ -d "internal" ] && {
+            count=$(count_source_files "internal" "*.go")
+            [ "$count" -ge "$MIN_FILES" ] && add_scope "internal" "backend-go" "$count"
+        }
+
+        [ -d "pkg" ] && {
+            count=$(count_source_files "pkg" "*.go")
+            [ "$count" -ge "$MIN_FILES" ] && add_scope "pkg" "backend-go" "$count"
+        }
+
+        [ -d "cmd" ] && {
+            count=$(count_source_files "cmd" "*.go")
+            [ "$count" -ge 3 ] && add_scope "cmd" "cli" "$count"
+        }
+
+        [ -d "examples" ] && {
+            count=$(count_source_files "examples" "*.go")
+            [ "$count" -ge 3 ] && add_scope "examples" "examples" "$count"
+        }
+
+        [ -d "testutil" ] && {
+            count=$(count_source_files "testutil" "*.go")
+            [ "$count" -ge 3 ] && add_scope "testutil" "testing" "$count"
+        }
+
+        [ -d "docs" ] && {
+            count=$(find docs -type f \( -name "*.md" -o -name "*.rst" \) | wc -l)
+            [ "$count" -ge 3 ] && add_scope "docs" "documentation" "$count"
+        }
+        ;;
+
+    "php")
+        # Determine PHP backend type based on framework
+        FRAMEWORK=$(echo "$PROJECT_INFO" | jq -r '.framework')
+        PROJECT_TYPE=$(echo "$PROJECT_INFO" | jq -r '.type')
+
+        # Select appropriate backend template
+        # Differentiate between extension/bundle (standalone package) vs project (full installation)
+        if [ "$PROJECT_TYPE" = "php-typo3-extension" ]; then
+            PHP_BACKEND_TYPE="typo3-extension"
+        elif [ "$PROJECT_TYPE" = "php-typo3" ]; then
+            PHP_BACKEND_TYPE="typo3-project"
+        elif [ "$PROJECT_TYPE" = "php-oro-bundle" ]; then
+            PHP_BACKEND_TYPE="oro-bundle"
+        elif [ "$PROJECT_TYPE" = "php-oro" ]; then
+            PHP_BACKEND_TYPE="oro-project"
+        elif [ "$FRAMEWORK" = "symfony" ] || [ "$PROJECT_TYPE" = "php-symfony" ]; then
+            PHP_BACKEND_TYPE="symfony"
+        else
+            PHP_BACKEND_TYPE="backend-php"
+        fi
+
+        # Check common PHP directories
+        [ -d "Classes" ] && {
+            count=$(count_source_files "Classes" "*.php")
+            [ "$count" -ge "$MIN_FILES" ] && add_scope "Classes" "$PHP_BACKEND_TYPE" "$count"
+        }
+
+        [ -d "src" ] && {
+            count=$(count_source_files "src" "*.php")
+            [ "$count" -ge "$MIN_FILES" ] && add_scope "src" "$PHP_BACKEND_TYPE" "$count"
+        }
+
+        [ -d "Tests" ] && {
+            count=$(count_source_files "Tests" "*.php")
+            if [ "$count" -ge 3 ]; then
+                # Use TYPO3-specific testing template for TYPO3 extensions
+                if [ "$PROJECT_TYPE" = "php-typo3-extension" ]; then
+                    add_scope "Tests" "typo3-testing" "$count"
+                else
+                    add_scope "Tests" "testing" "$count"
+                fi
+            fi
+        }
+
+        [ -d "tests" ] && {
+            count=$(count_source_files "tests" "*.php")
+            [ "$count" -ge 3 ] && add_scope "tests" "testing" "$count"
+        }
+
+        [ -d "Documentation" ] && {
+            count=$(find Documentation -type f \( -name "*.rst" -o -name "*.md" \) | wc -l)
+            if [ "$count" -ge 3 ]; then
+                # Use TYPO3-specific docs template for TYPO3 extensions
+                if [ "$PROJECT_TYPE" = "php-typo3-extension" ]; then
+                    add_scope "Documentation" "typo3-docs" "$count"
+                else
+                    add_scope "Documentation" "documentation" "$count"
+                fi
+            fi
+        }
+
+        [ -d "Resources" ] && {
+            count=$(find Resources -type f | wc -l)
+            [ "$count" -ge 5 ] && add_scope "Resources" "resources" "$count"
+        }
+
+        # Oro-specific: check for Bundle directories within projects
+        if [ "$PROJECT_TYPE" = "php-oro" ]; then
+            for bundle_dir in src/*/Bundle/*/; do
+                [ -d "$bundle_dir" ] && {
+                    count=$(count_source_files "$bundle_dir" "*.php")
+                    [ "$count" -ge "$MIN_FILES" ] && add_scope "${bundle_dir%/}" "oro-bundle" "$count"
+                }
+            done
+        fi
+        ;;
+
+    "typescript")
+        # Check common TypeScript/JavaScript directories
+        [ -d "src" ] && {
+            count=$(count_source_files "src" "*.ts")
+            ts_count=$count
+            count=$(count_source_files "src" "*.tsx")
+            tsx_count=$count
+
+            if [ "$tsx_count" -ge "$MIN_FILES" ]; then
+                add_scope "src" "frontend-typescript" "$tsx_count"
+            elif [ "$ts_count" -ge "$MIN_FILES" ]; then
+                add_scope "src" "backend-typescript" "$ts_count"
+            fi
+        }
+
+        [ -d "components" ] && {
+            count=$(count_source_files "components" "*.tsx")
+            [ "$count" -ge "$MIN_FILES" ] && add_scope "components" "frontend-typescript" "$count"
+        }
+
+        [ -d "pages" ] && {
+            count=$(count_source_files "pages" "*.tsx")
+            [ "$count" -ge 3 ] && add_scope "pages" "frontend-typescript" "$count"
+        }
+
+        [ -d "app" ] && {
+            count=$(count_source_files "app" "*.tsx")
+            [ "$count" -ge 3 ] && add_scope "app" "frontend-typescript" "$count"
+        }
+
+        if [ -d "server" ] || [ -d "backend" ]; then
+            dir=$([ -d "server" ] && echo "server" || echo "backend")
+            count=$(count_source_files "$dir" "*.ts")
+            [ "$count" -ge "$MIN_FILES" ] && add_scope "$dir" "backend-typescript" "$count"
+        fi
+
+        if [ -d "__tests__" ] || [ -d "tests" ]; then
+            dir=$([ -d "__tests__" ] && echo "__tests__" || echo "tests")
+            count=$(count_source_files "$dir" "*.test.ts")
+            [ "$count" -ge 3 ] && add_scope "$dir" "testing" "$count"
+        fi
+        ;;
+
+    "python")
+        # Determine Python template: use python-modern if pyproject.toml with ruff/mypy
+        PYTHON_TEMPLATE="backend-python"
+        if [ -f "pyproject.toml" ]; then
+            if grep -q 'ruff' pyproject.toml 2>/dev/null || grep -q 'mypy' pyproject.toml 2>/dev/null; then
+                PYTHON_TEMPLATE="python-modern"
+            fi
+        fi
+
+        # Check common Python directories
+        [ -d "src" ] && {
+            count=$(count_source_files "src" "*.py")
+            [ "$count" -ge "$MIN_FILES" ] && add_scope "src" "$PYTHON_TEMPLATE" "$count"
+        }
+
+        [ -d "tests" ] && {
+            count=$(count_source_files "tests" "*.py")
+            [ "$count" -ge 3 ] && add_scope "tests" "testing" "$count"
+        }
+
+        [ -d "scripts" ] && {
+            count=$(count_source_files "scripts" "*.py")
+            [ "$count" -ge 3 ] && add_scope "scripts" "cli" "$count"
+        }
+
+        [ -d "docs" ] && {
+            count=$(find docs -type f \( -name "*.md" -o -name "*.rst" \) | wc -l)
+            [ "$count" -ge 3 ] && add_scope "docs" "documentation" "$count"
+        }
+        ;;
+esac
+
+# Check for web subdirectories (cross-language)
+# IMPORTANT: Only create frontend-typescript scopes if Node toolchain exists
+# Either: package.json in scope dir, package.json at root, or lockfile at root
+has_node_toolchain() {
+    local scope_dir="$1"
+    [ -f "$scope_dir/package.json" ] || \
+    [ -f "package.json" ] || \
+    [ -f "pnpm-lock.yaml" ] || \
+    [ -f "yarn.lock" ] || \
+    [ -f "bun.lockb" ] || \
+    [ -f "package-lock.json" ]
+}
+
+for web_dir in internal/web web frontend client ui; do
+    if [ -d "$web_dir" ]; then
+        count=$(find "$web_dir" -type f \( -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" \) 2>/dev/null | wc -l)
+        if [ "$count" -ge "$MIN_FILES" ] && has_node_toolchain "$web_dir"; then
+            add_scope "$web_dir" "frontend-typescript" "$count"
+        fi
+    fi
+done
+
+# Check for Claude Code skills (each skill gets its own scope)
+if [ -d "skills" ]; then
+    for skill_dir in skills/*/; do
+        if [ -f "${skill_dir}SKILL.md" ]; then
+            # Count files in skill (sh, md, yaml)
+            count=$(find "$skill_dir" -type f \( -name "*.sh" -o -name "*.md" -o -name "*.yaml" -o -name "*.yml" \) 2>/dev/null | wc -l)
+            add_scope "${skill_dir%/}" "claude-code-skill" "$count"
+        fi
+    done
+fi
+
+# Check for DDEV local development environment (cross-language)
+if [ -d ".ddev" ]; then
+    count=$(find .ddev -type f \( -name "*.yaml" -o -name "*.yml" \) 2>/dev/null | wc -l)
+    [ "$count" -ge 1 ] && add_scope ".ddev" "ddev" "$count"
+fi
+
+# Check for Docker/container directories (cross-language)
+# These get "docker" scope type for container-focused documentation
+for docker_dir in docker deploy .docker infrastructure infra; do
+    if [ -d "$docker_dir" ]; then
+        # Count Docker-related files
+        count=$(find "$docker_dir" -type f \( -name "Dockerfile*" -o -name "*.dockerfile" -o -name "docker-compose*.yml" -o -name "compose*.yml" -o -name "*.yaml" -o -name "*.sh" \) 2>/dev/null | wc -l)
+        [ "$count" -ge 2 ] && add_scope "$docker_dir" "docker" "$count"
+    fi
+done
+
+# Check for CI/CD configurations (cross-language)
+# GitHub Actions
+if [ -d ".github/workflows" ]; then
+    count=$(find .github/workflows -type f -name "*.yml" -o -name "*.yaml" 2>/dev/null | wc -l)
+    [ "$count" -ge 1 ] && add_scope ".github/workflows" "github-actions" "$count"
+fi
+
+# GitLab CI - use .gitlab directory if exists, otherwise skip (root AGENTS.md covers it)
+if [ -f ".gitlab-ci.yml" ]; then
+    if [ -d ".gitlab" ]; then
+        count=$(find .gitlab -type f -name "*.yml" 2>/dev/null | wc -l)
+        [ "$count" -ge 1 ] && add_scope ".gitlab" "gitlab-ci" "$count"
+    fi
+    # Note: If no .gitlab/ directory, the root AGENTS.md will mention gitlab-ci.yml
+fi
+
+# Concourse CI
+concourse_detected=false
+concourse_dir=""
+for concourse_pattern in "ci/pipeline.yml" "ci/pipeline.yaml" "concourse/pipeline.yml"; do
+    if [ -f "$concourse_pattern" ]; then
+        concourse_dir=$(dirname "$concourse_pattern")
+        concourse_detected=true
+        break
+    fi
+done
+# Check for pipeline.yml at root - only create scope if ci/ directory exists
+if [ "$concourse_detected" = false ]; then
+    if [ -f "pipeline.yml" ] || [ -f "pipeline.yaml" ]; then
+        if [ -d "ci" ]; then
+            concourse_dir="ci"
+            concourse_detected=true
+        fi
+        # If no ci/ directory, root AGENTS.md will cover the pipeline file
+    fi
+fi
+# Also check for *-pipeline.yml at root - only create scope if ci/ directory exists
+if [ "$concourse_detected" = false ]; then
+    pipeline_files=$(find . -maxdepth 1 -name "*-pipeline.yml" -o -name "*-pipeline.yaml" 2>/dev/null | wc -l)
+    if [ "$pipeline_files" -gt 0 ] && [ -d "ci" ]; then
+        concourse_dir="ci"
+        concourse_detected=true
+    fi
+fi
+if [ "$concourse_detected" = true ] && [ -n "$concourse_dir" ] && [ -d "$concourse_dir" ]; then
+    count=$(find "$concourse_dir" -type f \( -name "*.yml" -o -name "*.yaml" -o -name "*.sh" \) 2>/dev/null | wc -l)
+    [ "$count" -ge 1 ] && add_scope "$concourse_dir" "concourse" "$count"
+fi
+
+# Output JSON
+if [ ${#scopes[@]} -eq 0 ]; then
+    echo '{"scopes": []}'
+else
+    # Join scopes with commas via explicit loop — avoids IFS= entirely
+    # (the opengrep bash.lang.security.ifs-tampering rule flags any
+    # IFS= assignment, even inside subshells).
+    joined="${scopes[0]}"
+    for ((i=1; i<${#scopes[@]}; i++)); do
+        joined+=",${scopes[i]}"
+    done
+    echo "{\"scopes\": [$joined]}"
+fi

package/skills/repo-bootstrap/scripts/detect-utilities.sh

@@ -0,0 +1,133 @@
+#!/usr/bin/env bash
+# Detect utility files and libraries to prevent reinvention
+set -euo pipefail
+
+PROJECT_DIR="${1:-.}"
+cd "$PROJECT_DIR"
+
+# Check if git is available
+if ! git rev-parse --git-dir > /dev/null 2>&1; then
+    echo ""
+    exit 0
+fi
+
+# Get project language
+PROJECT_INFO=$(bash "$(dirname "$0")/detect-project.sh" "$PROJECT_DIR" 2>/dev/null || echo '{"language":"unknown"}')
+LANGUAGE=$(echo "$PROJECT_INFO" | jq -r '.language')
+
+# Common utility directory names
+UTIL_DIRS=("utils" "util" "helpers" "helper" "lib" "shared" "common" "pkg")
+
+# Find utility directories
+find_util_dirs() {
+    for dir in "${UTIL_DIRS[@]}"; do
+        [ -d "$dir" ] && echo "$dir"
+        [ -d "src/$dir" ] && echo "src/$dir"
+        [ -d "internal/$dir" ] && echo "internal/$dir"
+    done
+}
+
+# Extract exports from TypeScript index file
+extract_ts_exports() {
+    local file="$1"
+    grep -oE "export \{ [^}]+ \}" "$file" 2>/dev/null | \
+        sed 's/export { //; s/ }//; s/,/\n/g' | \
+        tr -d ' ' | head -10
+}
+
+# Extract function names from Go file
+extract_go_exports() {
+    local dir="$1"
+    find "$dir" -name "*.go" -type f 2>/dev/null | while read -r file; do
+        grep -oE "^func [A-Z][a-zA-Z0-9_]*" "$file" 2>/dev/null | \
+            sed 's/func //' | head -5
+    done | sort -u | head -10
+}
+
+# Extract function names from Python file
+extract_py_exports() {
+    local dir="$1"
+    find "$dir" -name "*.py" ! -name "__*" -type f 2>/dev/null | while read -r file; do
+        grep -oE "^def [a-z_][a-z0-9_]*" "$file" 2>/dev/null | \
+            sed 's/def //' | head -5
+    done | sort -u | head -10
+}
+
+# Infer utility purpose from name
+infer_purpose() {
+    local name="$1"
+    case "$name" in
+        *date*|*time*|*format*Date*) echo "date/time formatting" ;;
+        *http*|*fetch*|*api*|*client*) echo "HTTP requests" ;;
+        *log*) echo "logging" ;;
+        *valid*|*check*) echo "validation" ;;
+        *parse*) echo "parsing" ;;
+        *format*) echo "formatting" ;;
+        *error*) echo "error handling" ;;
+        *auth*|*token*) echo "authentication" ;;
+        *cache*) echo "caching" ;;
+        *config*) echo "configuration" ;;
+        *string*|*str*) echo "string manipulation" ;;
+        *file*|*path*) echo "file operations" ;;
+        *) echo "utility" ;;
+    esac
+}
+
+# Generate output
+output=""
+
+while IFS= read -r dir; do
+    [ -z "$dir" ] && continue
+
+    case "$LANGUAGE" in
+        "typescript")
+            # Check for index.ts barrel export
+            if [ -f "$dir/index.ts" ]; then
+                while IFS= read -r export; do
+                    [ -z "$export" ] && continue
+                    purpose=$(infer_purpose "$export")
+                    output="$output| $purpose | \`$export\` | \`$dir/\` |\n"
+                done < <(extract_ts_exports "$dir/index.ts")
+            fi
+            ;;
+
+        "go")
+            while IFS= read -r func; do
+                [ -z "$func" ] && continue
+                purpose=$(infer_purpose "$func")
+                output="$output| $purpose | \`$func\` | \`$dir/\` |\n"
+            done < <(extract_go_exports "$dir")
+            ;;
+
+        "python")
+            while IFS= read -r func; do
+                [ -z "$func" ] && continue
+                purpose=$(infer_purpose "$func")
+                output="$output| $purpose | \`$func\` | \`$dir/\` |\n"
+            done < <(extract_py_exports "$dir")
+            ;;
+
+        "php")
+            # List PHP utility classes
+            while read -r file; do
+                class=$(grep -oE "class [A-Z][a-zA-Z0-9_]+" "$file" 2>/dev/null | head -1 | sed 's/class //')
+                [ -n "$class" ] && {
+                    purpose=$(infer_purpose "$class")
+                    relpath="${file#./}"
+                    output="$output| $purpose | \`$class\` | \`$relpath\` |\n"
+                }
+            done < <(find "$dir" -name "*.php" -type f 2>/dev/null | head -20)
+            ;;
+    esac
+done < <(find_util_dirs)
+
+# Check for common utility files at root or src
+for util_file in "utils.ts" "utils.js" "helpers.ts" "helpers.js" "utils.py" "helpers.py"; do
+    for prefix in "" "src/"; do
+        file="${prefix}${util_file}"
+        [ -f "$file" ] && output="$output| utilities | \`$file\` | \`$file\` |\n"
+    done
+done
+
+# Output (remove empty lines, duplicates)
+echo -e "$output" | sed '/^$/d' | sort -u | head -15

package/skills/repo-bootstrap/scripts/extract-adrs.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+# Extract Architectural Decision Records (ADRs) from common locations
+# Returns JSON with ADR metadata for AGENTS.md generation
+set -euo pipefail
+
+PROJECT_DIR="${1:-.}"
+cd "$PROJECT_DIR"
+
+# Common ADR directory locations
+ADR_DIRS=(
+    "docs/adr" "docs/adrs" "docs/decisions" "docs/architecture/decisions"
+    "Documentation/ADR" "Documentation/Decisions"
+    "adr" "ADR"
+)
+
+# Find the first existing ADR directory
+ADR_DIR=""
+for dir in "${ADR_DIRS[@]}"; do
+    if [ -d "$dir" ]; then
+        ADR_DIR="$dir"
+        break
+    fi
+done
+
+# If no ADR directory found, check for standalone ADR files in docs/
+if [ -z "$ADR_DIR" ]; then
+    # Look for ADR-named files anywhere in docs/
+    if [ -d "docs" ]; then
+        adr_file=$(find docs -maxdepth 2 -type f \( -name "ADR-*.md" -o -name "adr-*.md" -o -name "*-adr-*.md" -o -name "ADR*.rst" \) 2>/dev/null | head -1)
+        if [ -n "$adr_file" ]; then
+            ADR_DIR=$(dirname "$adr_file")
+        fi
+    fi
+fi
+
+# No ADRs found
+if [ -z "$ADR_DIR" ]; then
+    jq -n '{adr_count: 0, adr_directory: null, adrs: []}'
+    exit 0
+fi
+
+# Collect ADR files
+ADR_FILES=()
+while IFS= read -r -d '' file; do
+    ADR_FILES+=("$file")
+done < <(find "$ADR_DIR" -maxdepth 1 -type f \( -name "ADR-*.md" -o -name "adr-*.md" -o -name "*-adr-*.md" -o -name "ADR*.rst" -o -name "adr*.rst" -o -name "*.md" \) -print0 2>/dev/null | sort -z)
+
+# Deduplicate and filter — only include files that look like ADRs
+FILTERED_FILES=()
+for file in "${ADR_FILES[@]}"; do
+    basename=$(basename "$file")
+    # Accept files with ADR in the name, or numbered files (common ADR pattern like 0001-*.md)
+    if [[ "$basename" =~ ^[Aa][Dd][Rr][-_] ]] || [[ "$basename" =~ ^[0-9]{3,4}[-_] ]] || [[ "$basename" =~ -[Aa][Dd][Rr][-_] ]]; then
+        FILTERED_FILES+=("$file")
+    fi
+done
+
+if [ ${#FILTERED_FILES[@]} -eq 0 ]; then
+    jq -n --arg dir "$ADR_DIR" '{adr_count: 0, adr_directory: $dir, adrs: []}'
+    exit 0
+fi
+
+# Extract metadata from each ADR
+ADRS_JSON="[]"
+for file in "${FILTERED_FILES[@]}"; do
+    filename=$(basename "$file")
+
+    # Read file content
+    content=$(cat "$file" 2>/dev/null) || continue
+    [ -z "$content" ] && continue
+
+    # Extract title: first heading (# or ##)
+    title=""
+    while IFS= read -r line; do
+        if [[ "$line" =~ ^#{1,2}[[:space:]]+(.*) ]]; then
+            title="${BASH_REMATCH[1]}"
+            # Strip leading ADR number prefix like "ADR-001:" or "ADR 1:"
+            title=$(echo "$title" | sed -E 's/^ADR[-_ ]?[0-9]+:?\s*//i')
+            break
+        fi
+    done <<< "$content"
+    [ -z "$title" ] && title="$filename"
+
+    # Extract status: look for "Status:" line or **Status** pattern
+    status="Unknown"
+    while IFS= read -r line; do
+        # Match patterns like "## Status", then read next non-empty line
+        if [[ "$line" =~ ^#{1,3}[[:space:]]+[Ss]tatus ]]; then
+            # Read lines after the status heading to find the actual status
+            found_heading=false
+            while IFS= read -r sline; do
+                if [ "$found_heading" = false ]; then
+                    found_heading=true
+                    continue
+                fi
+                # Skip empty lines
+                [[ -z "${sline// /}" ]] && continue
+                # Extract the status value
+                sline=$(echo "$sline" | sed -E 's/^\*\*//;s/\*\*.*$//;s/^- //;s/^`//;s/`$//')
+                if [[ "$sline" =~ ^(Accepted|Proposed|Deprecated|Superseded|Rejected|Draft|Approved) ]]; then
+                    status="${BASH_REMATCH[1]}"
+                fi
+                break
+            done
+            break
+        fi
+        # Match inline patterns: "**Status**: Accepted", "**Status:** Accepted", "Status: Accepted"
+        if [[ "$line" =~ \*?\*?[Ss]tatus\*?\*?:?[[:space:]]*(Accepted|Proposed|Deprecated|Superseded|Rejected|Draft|Approved) ]]; then
+            status="${BASH_REMATCH[1]}"
+            break
+        fi
+    done <<< "$content"
+
+    # Extract summary: first paragraph after Context heading, or first paragraph after title
+    summary=""
+    # Try "Context" section first
+    in_context=false
+    while IFS= read -r line; do
+        if [[ "$line" =~ ^#{1,3}[[:space:]]+(Context|Background) ]]; then
+            in_context=true
+            continue
+        fi
+        if [ "$in_context" = true ]; then
+            [[ -z "${line// /}" ]] && continue
+            # Stop at next heading
+            [[ "$line" =~ ^# ]] && break
+            # Take the first non-empty, non-heading line
+            summary=$(echo "$line" | sed -E 's/^\*\*//;s/\*\*$//;s/^- //')
+            # Truncate to ~120 chars
+            if [ ${#summary} -gt 120 ]; then
+                summary="${summary:0:117}..."
+            fi
+            break
+        fi
+    done <<< "$content"
+
+    # Fallback: first paragraph after title
+    if [ -z "$summary" ]; then
+        past_title=false
+        while IFS= read -r line; do
+            if [[ "$line" =~ ^# ]] && [ "$past_title" = false ]; then
+                past_title=true
+                continue
+            fi
+            if [ "$past_title" = true ]; then
+                [[ -z "${line// /}" ]] && continue
+                [[ "$line" =~ ^# ]] && break
+                [[ "$line" =~ ^[*-][[:space:]] ]] && continue
+                summary=$(echo "$line" | sed -E 's/^\*\*//;s/\*\*$//;s/^- //')
+                if [ ${#summary} -gt 120 ]; then
+                    summary="${summary:0:117}..."
+                fi
+                break
+            fi
+        done <<< "$content"
+    fi
+
+    # Extract decision: look for "Decision" section
+    decision=""
+    in_decision=false
+    while IFS= read -r line; do
+        if [[ "$line" =~ ^#{1,3}[[:space:]]+(Decision|Resolution) ]]; then
+            in_decision=true
+            continue
+        fi
+        if [ "$in_decision" = true ]; then
+            [[ -z "${line// /}" ]] && continue
+            [[ "$line" =~ ^# ]] && break
+            [[ "$line" =~ ^\`\`\` ]] && break
+            decision=$(echo "$line" | sed -E 's/^\*\*//;s/\*\*$//;s/^- //')
+            if [ ${#decision} -gt 150 ]; then
+                decision="${decision:0:147}..."
+            fi
+            break
+        fi
+    done <<< "$content"
+
+    # Build JSON entry
+    ADRS_JSON=$(echo "$ADRS_JSON" | jq \
+        --arg file "$filename" \
+        --arg title "$title" \
+        --arg status "$status" \
+        --arg summary "$summary" \
+        --arg decision "$decision" \
+        '. + [{file: $file, title: $title, status: $status, summary: $summary, decision: $decision}]')
+done
+
+# Output final JSON
+ADR_COUNT=$(echo "$ADRS_JSON" | jq 'length')
+jq -n \
+    --argjson count "$ADR_COUNT" \
+    --arg dir "$ADR_DIR" \
+    --argjson adrs "$ADRS_JSON" \
+    '{adr_count: $count, adr_directory: $dir, adrs: $adrs}'