@synapta/skills 0.1.1 → 0.2.0

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

@@ -0,0 +1,358 @@
+#!/usr/bin/env bash
+# Extract build commands from various build tool files
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/config-root.sh"
+
+PROJECT_DIR="${1:-.}"
+cd "$PROJECT_DIR"
+
+# Stack filter: node, php, go, python, or auto (default)
+STACK_FILTER="${2:-auto}"
+
+# Skip extraction functions based on stack
+should_extract_node() {
+    [[ "$STACK_FILTER" == "auto" || "$STACK_FILTER" == "node" ]]
+}
+
+should_extract_php() {
+    [[ "$STACK_FILTER" == "auto" || "$STACK_FILTER" == "php" ]]
+}
+
+should_extract_go() {
+    [[ "$STACK_FILTER" == "auto" || "$STACK_FILTER" == "go" ]]
+}
+
+should_extract_python() {
+    [[ "$STACK_FILTER" == "auto" || "$STACK_FILTER" == "python" ]]
+}
+
+# Get project info (use . since we already cd'd to PROJECT_DIR)
+PROJECT_INFO=$(bash "$SCRIPT_DIR/detect-project.sh" ".")
+LANGUAGE=$(echo "$PROJECT_INFO" | jq -r '.language')
+# shellcheck disable=SC2034  # BUILD_TOOL reserved for future build-tool-specific detection
+BUILD_TOOL=$(echo "$PROJECT_INFO" | jq -r '.build_tool')
+
+# Initialize command variables
+INSTALL_CMD=""
+TYPECHECK_CMD=""
+LINT_CMD=""
+FORMAT_CMD=""
+TEST_CMD=""
+TEST_SINGLE_CMD=""
+BUILD_CMD=""
+DEV_CMD=""
+
+# Detect package manager for Node.js projects
+# Workspace-aware: checks workspace root for lockfiles if in a monorepo
+PACKAGE_MANAGER="npm"
+detect_package_manager() {
+    # First, check if we're in a workspace - lockfile will be at workspace root
+    local workspace_root
+    workspace_root=$(find_node_workspace_root "$(pwd)" || true)
+    if [ -n "$workspace_root" ]; then
+        if [ -f "$workspace_root/pnpm-lock.yaml" ]; then
+            PACKAGE_MANAGER="pnpm"
+            return
+        elif [ -f "$workspace_root/yarn.lock" ]; then
+            PACKAGE_MANAGER="yarn"
+            return
+        elif [ -f "$workspace_root/bun.lockb" ]; then
+            PACKAGE_MANAGER="bun"
+            return
+        elif [ -f "$workspace_root/package-lock.json" ]; then
+            PACKAGE_MANAGER="npm"
+            return
+        fi
+    fi
+
+    # Fallback: check local directory
+    if [ -f "pnpm-lock.yaml" ]; then
+        PACKAGE_MANAGER="pnpm"
+    elif [ -f "yarn.lock" ]; then
+        PACKAGE_MANAGER="yarn"
+    elif [ -f "bun.lockb" ]; then
+        PACKAGE_MANAGER="bun"
+    elif [ -f "package.json" ]; then
+        # Check packageManager field
+        local pm_field
+        pm_field=$(jq -r '.packageManager // empty' package.json 2>/dev/null | cut -d@ -f1)
+        if [ -n "$pm_field" ]; then
+            PACKAGE_MANAGER="$pm_field"
+        fi
+    fi
+}
+
+# Get the run command for package manager
+get_pm_run() {
+    case "$PACKAGE_MANAGER" in
+        pnpm) echo "pnpm" ;;
+        yarn) echo "yarn" ;;
+        bun) echo "bun run" ;;
+        *) echo "npm run" ;;
+    esac
+}
+
+# Get the npx-equivalent for package manager
+get_pm_dlx() {
+    case "$PACKAGE_MANAGER" in
+        pnpm) echo "pnpm dlx" ;;
+        yarn) echo "yarn dlx" ;;
+        bun) echo "bunx" ;;
+        *) echo "npx" ;;
+    esac
+}
+
+# Extract from Makefile
+extract_from_makefile() {
+    [ ! -f "Makefile" ] && return 0
+
+    # Extract targets with ## comments
+    while IFS= read -r line; do
+        if [[ $line =~ ^([a-zA-Z_-]+):.*\#\#(.*)$ ]]; then
+            target="${BASH_REMATCH[1]}"
+            # description captured but not yet used (for future enhanced output)
+            # description="${BASH_REMATCH[2]}"
+
+            case "$target" in
+                lint|check) LINT_CMD="make $target" ;;
+                format|fmt) FORMAT_CMD="make $target" ;;
+                test|tests) TEST_CMD="make $target" ;;
+                build) BUILD_CMD="make $target" ;;
+                typecheck|types) TYPECHECK_CMD="make $target" ;;
+                dev|serve) DEV_CMD="make $target" ;;
+            esac
+        fi
+    done < Makefile
+}
+
+# Extract from package.json
+extract_from_package_json() {
+    [ ! -f "package.json" ] && return 0
+
+    # Detect package manager first
+    detect_package_manager
+
+    local pm_run pm_dlx
+    pm_run=$(get_pm_run)
+    pm_dlx=$(get_pm_dlx)
+
+    # Set install command based on package manager
+    INSTALL_CMD="$PACKAGE_MANAGER install"
+
+    local has_typecheck has_lint has_format has_test has_build has_dev
+    has_typecheck=$(jq -r '.scripts.typecheck // .scripts["type-check"] // empty' package.json 2>/dev/null)
+    has_lint=$(jq -r '.scripts.lint // empty' package.json 2>/dev/null)
+    has_format=$(jq -r '.scripts.format // empty' package.json 2>/dev/null)
+    has_test=$(jq -r '.scripts.test // empty' package.json 2>/dev/null)
+    has_build=$(jq -r '.scripts.build // empty' package.json 2>/dev/null)
+    has_dev=$(jq -r '.scripts.dev // .scripts.start // empty' package.json 2>/dev/null)
+
+    if [ -n "$has_typecheck" ]; then
+        TYPECHECK_CMD="$pm_run typecheck"
+    else
+        TYPECHECK_CMD="$pm_dlx tsc --noEmit"
+    fi
+
+    if [ -n "$has_lint" ]; then
+        LINT_CMD="$pm_run lint"
+    else
+        LINT_CMD="$pm_dlx eslint ."
+    fi
+
+    if [ -n "$has_format" ]; then
+        FORMAT_CMD="$pm_run format"
+    else
+        FORMAT_CMD="$pm_dlx prettier --write ."
+    fi
+
+    if [ -n "$has_test" ]; then
+        TEST_CMD="$PACKAGE_MANAGER test"
+        # Single file test command
+        if grep -q 'vitest' package.json 2>/dev/null; then
+            TEST_SINGLE_CMD="$pm_dlx vitest run"
+        elif grep -q 'jest' package.json 2>/dev/null; then
+            TEST_SINGLE_CMD="$pm_dlx jest"
+        else
+            TEST_SINGLE_CMD="$PACKAGE_MANAGER test --"
+        fi
+    fi
+
+    if [ -n "$has_build" ]; then
+        BUILD_CMD="$pm_run build"
+    fi
+
+    if [ -n "$has_dev" ]; then
+        DEV_CMD="$pm_run dev"
+    fi
+}
+
+# Extract from composer.json
+extract_from_composer_json() {
+    [ ! -f "composer.json" ] && return 0
+
+    local has_lint has_format has_test has_phpstan
+    has_lint=$(jq -r '.scripts.lint // .scripts["cs:check"] // empty' composer.json 2>/dev/null)
+    has_format=$(jq -r '.scripts.format // .scripts["cs:fix"] // empty' composer.json 2>/dev/null)
+    has_test=$(jq -r '.scripts.test // empty' composer.json 2>/dev/null)
+    has_phpstan=$(jq -r '.scripts.phpstan // .scripts["stan"] // empty' composer.json 2>/dev/null)
+
+    if [ -n "$has_lint" ]; then
+        LINT_CMD="composer run lint"
+    fi
+
+    if [ -n "$has_format" ]; then
+        FORMAT_CMD="composer run format"
+    fi
+
+    if [ -n "$has_test" ]; then
+        TEST_CMD="composer run test"
+    else
+        TEST_CMD="vendor/bin/phpunit"
+    fi
+
+    if [ -n "$has_phpstan" ]; then
+        TYPECHECK_CMD="composer run phpstan"
+    elif [ -f "phpstan.neon" ] || [ -f "Build/phpstan.neon" ]; then
+        TYPECHECK_CMD="vendor/bin/phpstan analyze"
+    fi
+}
+
+# Extract from pyproject.toml
+extract_from_pyproject() {
+    [ ! -f "pyproject.toml" ] && return 0
+
+    # Check for ruff
+    if grep -q '\[tool.ruff\]' pyproject.toml; then
+        LINT_CMD="ruff check ."
+        FORMAT_CMD="ruff format ."
+    fi
+
+    # Check for black
+    if grep -q 'black' pyproject.toml; then
+        FORMAT_CMD="black ."
+    fi
+
+    # Check for mypy
+    if grep -q 'mypy' pyproject.toml; then
+        TYPECHECK_CMD="mypy ."
+    fi
+
+    # Check for pytest
+    if grep -q 'pytest' pyproject.toml; then
+        TEST_CMD="pytest"
+    fi
+}
+
+# Language-specific defaults
+set_language_defaults() {
+    case "$LANGUAGE" in
+        "go")
+            : "${INSTALL_CMD:=go mod download}"
+            : "${TYPECHECK_CMD:=go build -v ./...}"
+            if [ -z "$LINT_CMD" ]; then
+                if [ -f ".golangci.yml" ] || [ -f ".golangci.yaml" ]; then
+                    LINT_CMD="golangci-lint run ./..."
+                fi
+            fi
+            : "${FORMAT_CMD:=gofmt -w .}"
+            : "${TEST_CMD:=go test -v -race -short ./...}"
+            : "${TEST_SINGLE_CMD:=go test -v -race}"
+            : "${BUILD_CMD:=go build -v ./...}"
+            ;;
+
+        "php")
+            : "${INSTALL_CMD:=composer install}"
+            if [ -z "$TYPECHECK_CMD" ]; then
+                if [ -f "phpstan.neon" ] || [ -f "Build/phpstan.neon" ]; then
+                    TYPECHECK_CMD="vendor/bin/phpstan analyze"
+                fi
+            fi
+            : "${LINT_CMD:=vendor/bin/php-cs-fixer fix --dry-run}"
+            : "${FORMAT_CMD:=vendor/bin/php-cs-fixer fix}"
+            : "${TEST_CMD:=vendor/bin/phpunit}"
+            : "${TEST_SINGLE_CMD:=vendor/bin/phpunit}"
+            ;;
+
+        "typescript")
+            local pm_dlx
+            pm_dlx=$(get_pm_dlx)
+            : "${INSTALL_CMD:=$PACKAGE_MANAGER install}"
+            : "${TYPECHECK_CMD:=$pm_dlx tsc --noEmit}"
+            : "${LINT_CMD:=$pm_dlx eslint .}"
+            : "${FORMAT_CMD:=$pm_dlx prettier --write .}"
+            if [ -z "$TEST_CMD" ]; then
+                if [ -f "jest.config.js" ] || [ -f "jest.config.ts" ]; then
+                    TEST_CMD="$PACKAGE_MANAGER test"
+                    TEST_SINGLE_CMD="$pm_dlx jest"
+                elif grep -q 'vitest' package.json 2>/dev/null; then
+                    TEST_CMD="$pm_dlx vitest run"
+                    TEST_SINGLE_CMD="$pm_dlx vitest run"
+                fi
+            fi
+            ;;
+
+        "python")
+            if [ -f "pyproject.toml" ]; then
+                if grep -q '\[tool.poetry\]' pyproject.toml 2>/dev/null; then
+                    INSTALL_CMD="poetry install"
+                elif grep -q '\[tool.uv\]' pyproject.toml 2>/dev/null; then
+                    INSTALL_CMD="uv sync"
+                else
+                    INSTALL_CMD="pip install -e ."
+                fi
+            else
+                INSTALL_CMD="pip install -r requirements.txt"
+            fi
+            : "${LINT_CMD:=ruff check .}"
+            : "${FORMAT_CMD:=ruff format .}"
+            : "${TYPECHECK_CMD:=mypy .}"
+            : "${TEST_CMD:=pytest}"
+            : "${TEST_SINGLE_CMD:=pytest}"
+            ;;
+    esac
+}
+
+# Run extraction (stack-filtered)
+extract_from_makefile  # Always extract Makefile (cross-stack)
+should_extract_node && extract_from_package_json
+should_extract_php && extract_from_composer_json
+should_extract_python && extract_from_pyproject
+
+# Only set language defaults if matching stack or auto
+case "$STACK_FILTER" in
+    "auto") set_language_defaults ;;
+    "node") [[ "$LANGUAGE" == "typescript" || "$LANGUAGE" == "javascript" ]] && set_language_defaults ;;
+    "php") [[ "$LANGUAGE" == "php" ]] && set_language_defaults ;;
+    "go") [[ "$LANGUAGE" == "go" ]] && set_language_defaults ;;
+    "python") [[ "$LANGUAGE" == "python" ]] && set_language_defaults ;;
+    *)
+        echo "ERROR: Invalid STACK_FILTER value: $STACK_FILTER" >&2
+        echo "Valid options: auto, node, php, go, python" >&2
+        exit 1
+        ;;
+esac
+
+# Output JSON
+jq -n \
+    --arg install "$INSTALL_CMD" \
+    --arg typecheck "$TYPECHECK_CMD" \
+    --arg lint "$LINT_CMD" \
+    --arg format "$FORMAT_CMD" \
+    --arg test "$TEST_CMD" \
+    --arg test_single "$TEST_SINGLE_CMD" \
+    --arg build "$BUILD_CMD" \
+    --arg dev "$DEV_CMD" \
+    --arg package_manager "$PACKAGE_MANAGER" \
+    '{
+        install: $install,
+        typecheck: $typecheck,
+        lint: $lint,
+        format: $format,
+        test: $test,
+        test_single: $test_single,
+        build: $build,
+        dev: $dev,
+        package_manager: $package_manager
+    }'

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

@@ -0,0 +1,308 @@
+#!/usr/bin/env bash
+# Extract information from documentation files (README, CONTRIBUTING, SECURITY, etc.)
+set -euo pipefail
+
+PROJECT_DIR="${1:-.}"
+cd "$PROJECT_DIR"
+
+# Initialize outputs
+PROJECT_DESCRIPTION=""
+ARCHITECTURE_SECTION=""
+PR_PROCESS=""
+SECURITY_POLICY=""
+VULNERABILITY_REPORTING=""
+CHANGELOG_FORMAT=""
+
+# Helper to extract section from markdown
+# Usage: extract_section "file" "heading" [max_lines]
+extract_section() {
+    local file="$1"
+    local heading="$2"
+    local max_lines="${3:-20}"
+
+    if [ ! -f "$file" ]; then
+        echo ""
+        return
+    fi
+
+    # Find section and extract content until next heading
+    awk -v heading="$heading" -v max="$max_lines" '
+        BEGIN { found=0; count=0 }
+        /^##?#?[[:space:]]/ {
+            if (found) exit
+            if (tolower($0) ~ tolower(heading)) { found=1; next }
+        }
+        found && count < max { print; count++ }
+    ' "$file"
+}
+
+# Extract first paragraph after title (project description)
+extract_description() {
+    local file="$1"
+
+    if [ ! -f "$file" ]; then
+        echo ""
+        return
+    fi
+
+    # Skip title and badges, get first paragraph
+    awk '
+        BEGIN { started=0; in_para=0 }
+        /^#[^#]/ { started=1; next }
+        started && /^\[!\[/ { next }  # Skip badges
+        started && /^[![]/ { next }   # Skip images
+        started && /^>/ { next }      # Skip blockquotes initially
+        started && !in_para && /^[A-Za-z]/ { in_para=1 }
+        in_para && /^$/ { exit }
+        in_para { print }
+    ' "$file" | head -5
+}
+
+# Extract badges from README
+extract_badges() {
+    local file="$1"
+    local badges=()
+
+    if [ ! -f "$file" ]; then
+        echo "[]"
+        return
+    fi
+
+    # Find badge patterns: [![text](url)](link) or ![text](url)
+    while IFS= read -r line; do
+        if [[ "$line" =~ \[!\[([^\]]+)\] ]]; then
+            badges+=("${BASH_REMATCH[1]}")
+        elif [[ "$line" =~ !\[([^\]]+)\] ]]; then
+            badges+=("${BASH_REMATCH[1]}")
+        fi
+    done < <(grep -E '^\[?!\[' "$file" 2>/dev/null || true)
+
+    if [ ${#badges[@]} -eq 0 ]; then
+        echo "[]"
+    else
+        printf '%s\n' "${badges[@]}" | jq -R . | jq -s .
+    fi
+}
+
+# Extract key rules from CONTRIBUTING.md
+extract_contributing_rules() {
+    local file="$1"
+    local rules=()
+
+    if [ ! -f "$file" ]; then
+        echo "[]"
+        return
+    fi
+
+    # Extract bullet points from key sections
+    while IFS= read -r line; do
+        # Clean up the line
+        line=$(echo "$line" | sed 's/^[[:space:]]*[-*][[:space:]]*//' | sed 's/[[:space:]]*$//')
+        if [ -n "$line" ] && [ ${#line} -gt 10 ] && [ ${#line} -lt 200 ]; then
+            rules+=("$line")
+        fi
+    done < <(grep -E '^[[:space:]]*[-*][[:space:]]' "$file" 2>/dev/null | head -20 || true)
+
+    if [ ${#rules[@]} -eq 0 ]; then
+        echo "[]"
+    else
+        printf '%s\n' "${rules[@]}" | jq -R . | jq -s .
+    fi
+}
+
+# Check for PR process documentation
+extract_pr_process() {
+    local file="$1"
+
+    if [ ! -f "$file" ]; then
+        echo ""
+        return
+    fi
+
+    # Look for PR-related sections
+    local section
+    section=$(extract_section "$file" "pull request" 15)
+    if [ -z "$section" ]; then
+        section=$(extract_section "$file" "submitting" 15)
+    fi
+    if [ -z "$section" ]; then
+        section=$(extract_section "$file" "how to contribute" 15)
+    fi
+
+    echo "$section" | head -10
+}
+
+# Extract security policy
+extract_security_policy() {
+    local file="$1"
+
+    if [ ! -f "$file" ]; then
+        echo ""
+        return
+    fi
+
+    # Get main content
+    awk '
+        BEGIN { started=0 }
+        /^#/ { started=1; next }
+        started { print }
+    ' "$file" | head -20
+}
+
+# Detect changelog format
+detect_changelog_format() {
+    local file="$1"
+
+    if [ ! -f "$file" ]; then
+        echo "none"
+        return
+    fi
+
+    # Check for Keep a Changelog format
+    if grep -qi "keep a changelog" "$file" 2>/dev/null; then
+        echo "keepachangelog"
+        return
+    fi
+
+    # Check for conventional changelog
+    if grep -qE '^\s*###?\s*(Added|Changed|Deprecated|Removed|Fixed|Security)' "$file" 2>/dev/null; then
+        echo "keepachangelog"
+        return
+    fi
+
+    # Check for date-based entries
+    if grep -qE '^\s*##\s*\[?[0-9]+\.[0-9]+' "$file" 2>/dev/null; then
+        echo "semver-sections"
+        return
+    fi
+
+    # Check for simple list format
+    if grep -qE '^[-*]\s+' "$file" 2>/dev/null; then
+        echo "simple-list"
+        return
+    fi
+
+    echo "custom"
+}
+
+# Main extraction
+
+# README.md
+if [ -f "README.md" ]; then
+    PROJECT_DESCRIPTION=$(extract_description "README.md")
+    BADGES_JSON=$(extract_badges "README.md")
+    ARCHITECTURE_SECTION=$(extract_section "README.md" "architecture" 30)
+    if [ -z "$ARCHITECTURE_SECTION" ]; then
+        ARCHITECTURE_SECTION=$(extract_section "README.md" "structure" 30)
+    fi
+fi
+
+# CONTRIBUTING.md (check multiple locations)
+CONTRIBUTING_FILE=""
+for f in CONTRIBUTING.md .github/CONTRIBUTING.md docs/CONTRIBUTING.md; do
+    if [ -f "$f" ]; then
+        CONTRIBUTING_FILE="$f"
+        break
+    fi
+done
+
+if [ -n "$CONTRIBUTING_FILE" ]; then
+    CONTRIBUTING_RULES_JSON=$(extract_contributing_rules "$CONTRIBUTING_FILE")
+    PR_PROCESS=$(extract_pr_process "$CONTRIBUTING_FILE")
+    CODE_STYLE_SECTION=$(extract_section "$CONTRIBUTING_FILE" "code style" 20)
+    if [ -z "$CODE_STYLE_SECTION" ]; then
+        CODE_STYLE_SECTION=$(extract_section "$CONTRIBUTING_FILE" "style guide" 20)
+    fi
+else
+    CONTRIBUTING_RULES_JSON="[]"
+    CODE_STYLE_SECTION=""
+fi
+
+# SECURITY.md (check multiple locations)
+SECURITY_FILE=""
+for f in SECURITY.md .github/SECURITY.md docs/SECURITY.md; do
+    if [ -f "$f" ]; then
+        SECURITY_FILE="$f"
+        break
+    fi
+done
+
+if [ -n "$SECURITY_FILE" ]; then
+    SECURITY_POLICY=$(extract_security_policy "$SECURITY_FILE")
+    VULNERABILITY_REPORTING=$(extract_section "$SECURITY_FILE" "reporting" 15)
+else
+    SECURITY_POLICY=""
+    VULNERABILITY_REPORTING=""
+fi
+
+# CHANGELOG.md
+CHANGELOG_FILE=""
+for f in CHANGELOG.md HISTORY.md CHANGES.md; do
+    if [ -f "$f" ]; then
+        CHANGELOG_FILE="$f"
+        break
+    fi
+done
+
+if [ -n "$CHANGELOG_FILE" ]; then
+    CHANGELOG_FORMAT=$(detect_changelog_format "$CHANGELOG_FILE")
+else
+    CHANGELOG_FORMAT="none"
+fi
+
+# CODE_OF_CONDUCT.md
+COC_FILE=""
+for f in CODE_OF_CONDUCT.md .github/CODE_OF_CONDUCT.md; do
+    if [ -f "$f" ]; then
+        COC_FILE="$f"
+        break
+    fi
+done
+
+HAS_CODE_OF_CONDUCT=false
+if [ -n "$COC_FILE" ]; then
+    HAS_CODE_OF_CONDUCT=true
+fi
+
+# Build JSON output
+jq -n \
+    --arg desc "$PROJECT_DESCRIPTION" \
+    --argjson badges "${BADGES_JSON:-[]}" \
+    --arg arch "$ARCHITECTURE_SECTION" \
+    --arg contributing_file "$CONTRIBUTING_FILE" \
+    --argjson contributing_rules "${CONTRIBUTING_RULES_JSON:-[]}" \
+    --arg pr_process "$PR_PROCESS" \
+    --arg code_style "$CODE_STYLE_SECTION" \
+    --arg security_file "$SECURITY_FILE" \
+    --arg security_policy "$SECURITY_POLICY" \
+    --arg vuln_reporting "$VULNERABILITY_REPORTING" \
+    --arg changelog_file "$CHANGELOG_FILE" \
+    --arg changelog_format "$CHANGELOG_FORMAT" \
+    --argjson has_coc "$HAS_CODE_OF_CONDUCT" \
+    --arg coc_file "$COC_FILE" \
+    '{
+        readme: {
+            description: $desc,
+            badges: $badges,
+            architecture_section: $arch
+        },
+        contributing: {
+            file: $contributing_file,
+            rules: $contributing_rules,
+            pr_process: $pr_process,
+            code_style: $code_style
+        },
+        security: {
+            file: $security_file,
+            policy: $security_policy,
+            vulnerability_reporting: $vuln_reporting
+        },
+        changelog: {
+            file: $changelog_file,
+            format: $changelog_format
+        },
+        code_of_conduct: {
+            exists: $has_coc,
+            file: $coc_file
+        }
+    }'