Skip to content

netresearch/agent-rules-skill / skills/agent-rules

agent-rules

Flagged

Use when creating or updating AGENTS.md files, .github/copilot-instructions.md, or other AI agent rule files, onboarding AI agents to a project, standardizing agent documentation, or when anyone mentions AGENTS.md, agent rules, project onboarding, or codebase documentation for AI agents.

FileKindSize
AGENTS.mdmarkdown4.0 KB
CLAUDE.mdmarkdown9 B
SKILL.mdskill md5.2 KB
assets/.markdownlint-cli2.jsoncother624 B
assets/example-workflows/validate-agents.ymlconfig2.8 KB
assets/root-thin.mdmarkdown5.7 KB
assets/root-verbose.mdmarkdown5.5 KB
assets/scoped/backend-go.mdmarkdown3.6 KB
assets/scoped/backend-php.mdmarkdown3.0 KB
assets/scoped/backend-python.mdmarkdown2.6 KB
assets/scoped/backend-typescript.mdmarkdown2.8 KB
assets/scoped/claude-code-skill.mdmarkdown3.4 KB
assets/scoped/cli.mdmarkdown2.7 KB
assets/scoped/concourse.mdmarkdown5.2 KB
assets/scoped/ddev.mdmarkdown2.4 KB
assets/scoped/docker.mdmarkdown5.3 KB
assets/scoped/documentation.mdmarkdown3.5 KB
assets/scoped/examples.mdmarkdown3.4 KB
assets/scoped/frontend-typescript.mdmarkdown2.7 KB
assets/scoped/github-actions.mdmarkdown5.2 KB
assets/scoped/gitlab-ci.mdmarkdown4.6 KB
assets/scoped/oro-bundle.mdmarkdown6.5 KB
assets/scoped/oro-project.mdmarkdown5.5 KB
assets/scoped/python-modern.mdmarkdown6.1 KB
assets/scoped/resources.mdmarkdown3.5 KB
assets/scoped/skill-repo.mdmarkdown5.4 KB
assets/scoped/symfony.mdmarkdown5.3 KB
assets/scoped/testing.mdmarkdown3.0 KB
assets/scoped/typo3-docs.mdmarkdown3.6 KB
assets/scoped/typo3-extension.mdmarkdown5.1 KB
assets/scoped/typo3-project.mdmarkdown4.7 KB
assets/scoped/typo3-testing.mdmarkdown3.0 KB
checkpoints.yamlconfig14.4 KB
evals/evals.jsonconfig22.9 KB
references/ai-contribution-guidelines.mdmarkdown2.6 KB
references/ai-tool-compatibility.mdmarkdown8.0 KB
references/directory-coverage.mdmarkdown2.5 KB
references/examples/coding-agent-cli/AGENTS.mdmarkdown2.5 KB
references/examples/coding-agent-cli/go.modmanifest45 B
references/examples/coding-agent-cli/scripts-AGENTS.mdmarkdown10.1 KB
references/examples/express-api-ts/.env.exampleother232 B
references/examples/express-api-ts/AGENTS.mdmarkdown3.1 KB
references/examples/express-api-ts/package.jsonmanifest757 B
references/examples/express-api-ts/pnpm-lock.yamlmanifest101 B
references/examples/express-api-ts/src/AGENTS.mdmarkdown3.1 KB
references/examples/express-api-ts/src/config.tsscript917 B
references/examples/express-api-ts/src/controllers/userController.tsscript2.1 KB
references/examples/express-api-ts/src/index.tsscript671 B
references/examples/express-api-ts/src/middleware/errorHandler.tsscript1.0 KB
references/examples/express-api-ts/src/middleware/requestLogger.tsscript471 B
references/examples/express-api-ts/src/routes/health.tsscript428 B
references/examples/express-api-ts/src/routes/users.tsscript397 B
references/examples/express-api-ts/src/utils/errors.tsscript1.2 KB
references/examples/express-api-ts/src/utils/logger.tsscript441 B
references/examples/express-api-ts/tsconfig.jsonconfig630 B
references/examples/fastapi-app/.env.exampleother348 B
references/examples/fastapi-app/AGENTS.mdmarkdown3.2 KB
references/examples/fastapi-app/pyproject.tomlmanifest1.8 KB
references/examples/fastapi-app/src/AGENTS.mdmarkdown2.9 KB
references/examples/fastapi-app/src/__init__.pyscript58 B
references/examples/fastapi-app/src/config.pyscript1.1 KB
references/examples/fastapi-app/src/main.pyscript1.7 KB
references/examples/fastapi-app/src/models/__init__.pyscript278 B
references/examples/fastapi-app/src/models/item.pyscript1.0 KB
references/examples/fastapi-app/src/models/user.pyscript922 B
references/examples/fastapi-app/src/routes/__init__.pyscript110 B
references/examples/fastapi-app/src/routes/health.pyscript470 B
references/examples/fastapi-app/src/routes/items.pyscript1.9 KB
references/examples/fastapi-app/src/routes/users.pyscript1.7 KB
references/examples/fastapi-app/src/services/__init__.pyscript174 B
references/examples/fastapi-app/src/services/item_service.pyscript2.5 KB
references/examples/fastapi-app/src/services/user_service.pyscript2.1 KB
references/examples/fastapi-app/uv.lockmanifest136 B
references/examples/go-api-with-react-admin/.scopesother93 B
references/examples/go-api-with-react-admin/AGENTS.mdmarkdown3.0 KB
references/examples/go-api-with-react-admin/admin/package.jsonmanifest423 B
references/examples/go-api-with-react-admin/admin/src/App.tsxother101 B
references/examples/go-api-with-react-admin/cmd/api/main.goscript75 B
references/examples/go-api-with-react-admin/go.modmanifest31 B
references/examples/go-api-with-react-admin/main.goscript71 B
references/examples/go-with-internal-web-tsx/.scopesother102 B
references/examples/go-with-internal-web-tsx/AGENTS.mdmarkdown3.1 KB
references/examples/go-with-internal-web-tsx/go.modmanifest34 B
references/examples/go-with-internal-web-tsx/internal/web/AGENTS.mdmarkdown3.1 KB
references/examples/go-with-internal-web-tsx/internal/web/package.jsonmanifest329 B
references/examples/go-with-internal-web-tsx/internal/web/src/App.tsxother57 B
references/examples/go-with-internal-web-tsx/internal/web/src/Button.tsxother63 B
references/examples/go-with-internal-web-tsx/internal/web/src/Footer.tsxother63 B
references/examples/go-with-internal-web-tsx/internal/web/src/Header.tsxother63 B
references/examples/go-with-internal-web-tsx/internal/web/src/Sidebar.tsxother65 B
references/examples/go-with-internal-web-tsx/main.goscript85 B
references/examples/go-with-internal-web-tsx/package-lock.jsonmanifest87 B
references/examples/go-with-internal-web-tsx/package.jsonmanifest221 B
references/examples/ldap-selfservice/AGENTS.mdmarkdown2.5 KB
references/examples/ldap-selfservice/go.modmanifest45 B
references/examples/ldap-selfservice/internal-AGENTS.mdmarkdown10.0 KB
references/examples/ldap-selfservice/internal-web-AGENTS.mdmarkdown12.1 KB
references/examples/php-with-frontend/.scopesother89 B
references/examples/php-with-frontend/AGENTS.mdmarkdown3.1 KB
references/examples/php-with-frontend/composer.jsonconfig185 B
references/examples/php-with-frontend/package.jsonmanifest307 B
references/examples/php-with-frontend/pnpm-lock.yamlmanifest101 B
references/examples/php-with-frontend/src/Controller.phpscript41 B
references/examples/php-with-frontend/web/AGENTS.mdmarkdown3.1 KB
references/examples/php-with-frontend/web/package.jsonmanifest515 B
references/examples/php-with-frontend/web/src/App.tsxother63 B
references/examples/php-with-frontend/web/src/Button.tsxother215 B
references/examples/php-with-frontend/web/src/Footer.tsxother125 B
references/examples/php-with-frontend/web/src/Header.tsxother122 B
references/examples/php-with-frontend/web/src/main.tsxother41 B
references/examples/php-with-frontend/web/tsconfig.jsonconfig280 B
references/examples/pnpm-workspace/AGENTS.mdmarkdown2.6 KB
references/examples/pnpm-workspace/package.jsonmanifest105 B
references/examples/pnpm-workspace/packages/web/package.jsonmanifest187 B
references/examples/pnpm-workspace/packages/web/src/index.tsxother258 B
references/examples/pnpm-workspace/pnpm-lock.yamlmanifest920 B
references/examples/pnpm-workspace/pnpm-workspace.yamlconfig27 B
references/examples/simple-ldap-go/AGENTS.mdmarkdown2.5 KB
references/examples/simple-ldap-go/examples-AGENTS.mdmarkdown1.8 KB
references/examples/simple-ldap-go/go.modmanifest43 B
references/examples/t3x-rte-ckeditor-image/AGENTS.mdmarkdown2.5 KB
references/examples/t3x-rte-ckeditor-image/Classes-AGENTS.mdmarkdown12.0 KB
references/examples/t3x-rte-ckeditor-image/composer.jsonconfig174 B
references/feedback-memory-schema.mdmarkdown6.2 KB
references/fleet-sync-sweep.mdmarkdown4.8 KB
references/git-hooks-setup.mdmarkdown2.5 KB
references/output-structure.mdmarkdown5.4 KB
references/quality-rubric.mdmarkdown6.2 KB
references/scripts-guide.mdmarkdown7.7 KB
references/verification-guide.mdmarkdown9.4 KB
scripts/analyze-git-history.shexecutablescript10.2 KB
scripts/check-freshness.shexecutablescript8.9 KB
scripts/detect-golden-samples.shexecutablescript5.7 KB
scripts/detect-heuristics.shexecutablescript3.2 KB
scripts/detect-project.shexecutablescript19.6 KB
scripts/detect-scopes.shexecutablescript13.4 KB
scripts/detect-utilities.shexecutablescript4.6 KB
scripts/extract-adrs.shexecutablescript6.8 KB
scripts/extract-agent-configs.shexecutablescript9.3 KB
scripts/extract-architecture-rules.shexecutablescript19.9 KB
scripts/extract-ci-commands.shexecutablescript12.5 KB
scripts/extract-ci-rules.shexecutablescript16.1 KB
scripts/extract-commands.shexecutablescript11.9 KB
scripts/extract-documentation.shexecutablescript7.8 KB
scripts/extract-github-rulesets.shexecutablescript3.8 KB
scripts/extract-github-settings.shexecutablescript3.6 KB
scripts/extract-ide-settings.shexecutablescript7.0 KB
scripts/extract-platform-files.shexecutablescript8.0 KB
scripts/extract-quality-configs.shexecutablescript14.9 KB
scripts/generate-agents.shexecutablescript118.2 KB
scripts/generate-file-map.shexecutablescript4.6 KB
scripts/lib/config-root.shexecutablescript5.8 KB
scripts/lib/git.shscript1.2 KB
scripts/lib/summary.shscript11.7 KB
scripts/lib/template.shexecutablescript15.9 KB
scripts/score-agents.shexecutablescript9.8 KB
scripts/tests/test-agents-file-write-boundary.shscript5.8 KB
scripts/tests/test-agents-scan-dependency-trees.shexecutablescript4.5 KB
scripts/tests/test-changelog-rule.shexecutablescript3.4 KB
scripts/tests/test-claude-import-file.shscript3.3 KB
scripts/tests/test-command-allowlist.shexecutablescript4.7 KB
scripts/tests/test-dependency-tree-exclusion.shscript2.5 KB
scripts/tests/test-extract-commands-real-scripts.shexecutablescript4.0 KB
scripts/tests/test-git-history-counts.shexecutablescript3.6 KB
scripts/tests/test-golden-sample-file-names.shexecutablescript2.2 KB
scripts/tests/test-json-manifest.shexecutablescript5.5 KB
scripts/tests/test-last-verified-opt-in.shscript1.6 KB
scripts/tests/test-make-target-lookup.shscript2.5 KB
scripts/tests/test-merge-heuristic.shscript1.8 KB
scripts/tests/test-scope-index-heading.shexecutablescript4.4 KB
scripts/tests/test-scope-index-keeps-existing.shexecutablescript2.5 KB
scripts/tests/test-symlink-write-boundary.shexecutablescript6.3 KB
scripts/tests/test-untrusted-git-config.shscript5.0 KB
scripts/tests/test-verification-sidecar.shscript2.7 KB
scripts/validate-structure.shexecutablescript13.3 KB
scripts/verify-commands.shexecutablescript32.5 KB
scripts/verify-content.shexecutablescript13.2 KB

scripts/detect-project.sh

View on GitHub
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: Netresearch DTT GmbH
# Detect project type, language, version, and build tools
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# shellcheck source-path=SCRIPTDIR
# shellcheck disable=SC1091  # pre-commit runs shellcheck without -x, so
# it cannot follow this source however the path is written.
source "$SCRIPT_DIR/lib/config-root.sh"

PROJECT_DIR="${1:-.}"
cd "$PROJECT_DIR"

# Initialize variables
LANGUAGE="unknown"
VERSION="unknown"
BUILD_TOOL="unknown"      # Deprecated: use package_manager or task_runner
PACKAGE_MANAGER="unknown" # Package manager: npm/yarn/pnpm/bun, composer, poetry/uv/pip, go
TASK_RUNNER="none"        # Task runner: make/just/mage/bazel, or none
FRAMEWORK="none"
PROJECT_TYPE="unknown"
QUALITY_TOOLS=()
TEST_FRAMEWORK="unknown"
HAS_DOCKER=false
CI="none"
IDE_CONFIGS=()
AGENT_CONFIGS=()
STACKS=()                 # Multi-stack detection: (go, php, python, typescript, docker)

# Detect language and version
detect_language() {
    if [ -f "go.mod" ]; then
        LANGUAGE="go"
        VERSION=$(grep '^go ' go.mod | awk '{print $2}' || echo "unknown")
        BUILD_TOOL="go"
        PACKAGE_MANAGER="go"
        TEST_FRAMEWORK="testing"

        # Detect Go project type
        if [ -d "cmd" ]; then
            PROJECT_TYPE="go-cli"
        elif grep -q "github.com/gofiber/fiber" go.mod 2>/dev/null; then
            PROJECT_TYPE="go-web-app"
            FRAMEWORK="fiber"
        elif grep -q "github.com/labstack/echo" go.mod 2>/dev/null; then
            PROJECT_TYPE="go-web-app"
            FRAMEWORK="echo"
        elif grep -q "github.com/gin-gonic/gin" go.mod 2>/dev/null; then
            PROJECT_TYPE="go-web-app"
            FRAMEWORK="gin"
        else
            PROJECT_TYPE="go-library"
        fi

        # Detect Go quality tools
        { [ -f ".golangci.yml" ] || [ -f ".golangci.yaml" ]; } && QUALITY_TOOLS+=("golangci-lint") || true
        command -v gofmt &>/dev/null && QUALITY_TOOLS+=("gofmt") || true

    elif [ -f "composer.json" ]; then
        # Check if this is actually a PHP project:
        # 1. Has PHP version requirement, OR
        # 2. Has PHP source files, OR
        # 3. Has PHP framework dependencies
        local has_php_requirement=false
        local has_php_files=false
        local has_php_deps=false

        # Check for PHP version requirement
        if jq -e '.require.php // .["require-dev"].php' composer.json &>/dev/null; then
            has_php_requirement=true
        fi

        # Check for PHP source files (common locations)
        if [[ -d "src" ]] && [[ -n "$(find src -name "*.php" -type f -print -quit 2>/dev/null)" ]]; then
            has_php_files=true
        elif [[ -d "Classes" ]] && [[ -n "$(find Classes -name "*.php" -type f -print -quit 2>/dev/null)" ]]; then
            has_php_files=true
        elif [[ -d "lib" ]] && [[ -n "$(find lib -name "*.php" -type f -print -quit 2>/dev/null)" ]]; then
            has_php_files=true
        elif [ -f "ext_emconf.php" ]; then
            has_php_files=true
        elif [[ -n "$(find . -maxdepth 2 -name "*.php" -type f -print -quit 2>/dev/null)" ]]; then
            has_php_files=true
        fi

        # Check for PHP framework dependencies
        if jq -e '.require."typo3/cms-core" // .require."laravel/framework" // .require."symfony/framework-bundle" // .require."oro/platform"' composer.json &>/dev/null; then
            has_php_deps=true
        fi

        # Only treat as PHP if we have evidence it's a PHP project
        if [ "$has_php_requirement" = true ] || [ "$has_php_files" = true ] || [ "$has_php_deps" = true ]; then
            LANGUAGE="php"
            VERSION=$(jq -r '.require.php // "unknown"' composer.json 2>/dev/null || echo "unknown")
            BUILD_TOOL="composer"
            PACKAGE_MANAGER="composer"
        else
            # composer.json exists but this isn't a PHP project
            # Continue to check other languages
            :
        fi

        # Detect PHP framework (only if we determined this is PHP)
        if [ "$LANGUAGE" = "php" ]; then
            # TYPO3 extension detection (ext_emconf.php is definitive)
            if [ -f "ext_emconf.php" ]; then
                PROJECT_TYPE="php-typo3-extension"
                FRAMEWORK="typo3"
            elif jq -e '.require."typo3/cms-core"' composer.json &>/dev/null; then
                PROJECT_TYPE="php-typo3"
                FRAMEWORK="typo3"
            # Oro detection (OroCommerce, OroPlatform, OroCRM)
            # Differentiate between full Oro project and standalone bundle
            elif jq -e '.require."oro/platform"' composer.json &>/dev/null || \
                 jq -e '.require."oro/commerce"' composer.json &>/dev/null || \
                 jq -e '.require."oro/crm"' composer.json &>/dev/null; then
                FRAMEWORK="oro"
                # Check if it's a standalone bundle (has type: oro-bundle, or no bin/console)
                composer_type=$(jq -r '.type // ""' composer.json 2>/dev/null)
                if [ "$composer_type" = "oro-bundle" ] || [ "$composer_type" = "symfony-bundle" ]; then
                    PROJECT_TYPE="php-oro-bundle"
                elif [ -f "bin/console" ] || [ -f "public/index.php" ]; then
                    PROJECT_TYPE="php-oro"
                else
                    # Likely a standalone bundle without explicit type
                    PROJECT_TYPE="php-oro-bundle"
                fi
            elif [ -f "config/oro/bundles.yml" ]; then
                PROJECT_TYPE="php-oro-bundle"
                FRAMEWORK="oro"
            elif jq -e '.require."laravel/framework"' composer.json &>/dev/null; then
                PROJECT_TYPE="php-laravel"
                FRAMEWORK="laravel"
            elif jq -e '.require."symfony/symfony"' composer.json &>/dev/null || \
                 jq -e '.require."symfony/framework-bundle"' composer.json &>/dev/null; then
                PROJECT_TYPE="php-symfony"
                FRAMEWORK="symfony"
            else
                PROJECT_TYPE="php-library"
            fi

            # Detect PHP quality tools
            jq -e '.require."phpstan/phpstan" // .["require-dev"]."phpstan/phpstan"' composer.json &>/dev/null && QUALITY_TOOLS+=("phpstan") || true
            jq -e '.require."friendsofphp/php-cs-fixer" // .["require-dev"]."friendsofphp/php-cs-fixer"' composer.json &>/dev/null && QUALITY_TOOLS+=("php-cs-fixer") || true
            { [ -f "phpunit.xml" ] || [ -f "phpunit.xml.dist" ]; } && TEST_FRAMEWORK="phpunit" || true
        fi
        # If composer.json exists but it's not a PHP project, fall through to other checks

    fi

    # Check for package.json (might also exist alongside composer.json)
    if [ "$LANGUAGE" = "unknown" ] && [ -f "package.json" ]; then
        LANGUAGE="typescript"
        VERSION=$(jq -r '.engines.node // "unknown"' package.json 2>/dev/null || echo "unknown")

        # Detect package manager from lockfile (workspace-aware, default npm)
        PACKAGE_MANAGER="npm"
        local ws_root
        ws_root=$(find_node_workspace_root "$(pwd)" || true)
        if [ -n "$ws_root" ]; then
            # Check workspace root for lockfiles
            [ -f "$ws_root/pnpm-lock.yaml" ] && PACKAGE_MANAGER="pnpm"
            [ -f "$ws_root/yarn.lock" ] && PACKAGE_MANAGER="yarn"
            [ -f "$ws_root/bun.lockb" ] && PACKAGE_MANAGER="bun"
            [ -f "$ws_root/package-lock.json" ] && PACKAGE_MANAGER="npm"
        else
            # Fallback to local lockfiles
            [ -f "yarn.lock" ] && PACKAGE_MANAGER="yarn"
            [ -f "pnpm-lock.yaml" ] && PACKAGE_MANAGER="pnpm"
            [ -f "bun.lockb" ] && PACKAGE_MANAGER="bun"
        fi
        BUILD_TOOL="$PACKAGE_MANAGER"

        # Detect JS/TS framework
        if jq -e '.dependencies."next"' package.json &>/dev/null; then
            PROJECT_TYPE="typescript-nextjs"
            FRAMEWORK="next.js"
        elif jq -e '.dependencies."react"' package.json &>/dev/null; then
            PROJECT_TYPE="typescript-react"
            FRAMEWORK="react"
        elif jq -e '.dependencies."vue"' package.json &>/dev/null; then
            PROJECT_TYPE="typescript-vue"
            FRAMEWORK="vue"
        elif jq -e '.dependencies."express"' package.json &>/dev/null; then
            PROJECT_TYPE="typescript-node"
            FRAMEWORK="express"
        else
            PROJECT_TYPE="typescript-library"
        fi

        # Detect quality tools
        jq -e '.devDependencies."eslint"' package.json &>/dev/null && QUALITY_TOOLS+=("eslint") || true
        jq -e '.devDependencies."prettier"' package.json &>/dev/null && QUALITY_TOOLS+=("prettier") || true
        jq -e '.devDependencies."typescript"' package.json &>/dev/null && QUALITY_TOOLS+=("tsc") || true

        # Detect test framework
        if jq -e '.devDependencies."jest"' package.json &>/dev/null; then
            TEST_FRAMEWORK="jest"
        elif jq -e '.devDependencies."vitest"' package.json &>/dev/null; then
            TEST_FRAMEWORK="vitest"
        fi || true

    fi

    # Check for pyproject.toml
    if [ "$LANGUAGE" = "unknown" ] && [ -f "pyproject.toml" ]; then
        LANGUAGE="python"
        VERSION=$(grep 'requires-python' pyproject.toml | cut -d'"' -f2 2>/dev/null || echo "unknown")

        # Detect Python package manager
        if grep -q '\[tool.poetry\]' pyproject.toml 2>/dev/null; then
            PACKAGE_MANAGER="poetry"
        elif grep -q '\[tool.uv\]' pyproject.toml 2>/dev/null || [ -f "uv.lock" ]; then
            PACKAGE_MANAGER="uv"
        elif grep -q '\[tool.hatch\]' pyproject.toml 2>/dev/null; then
            PACKAGE_MANAGER="hatch"
        else
            PACKAGE_MANAGER="pip"
        fi
        BUILD_TOOL="$PACKAGE_MANAGER"

        # Detect framework
        if grep -q 'django' pyproject.toml 2>/dev/null; then
            PROJECT_TYPE="python-django"
            FRAMEWORK="django"
        elif grep -q 'flask' pyproject.toml 2>/dev/null; then
            PROJECT_TYPE="python-flask"
            FRAMEWORK="flask"
        elif grep -q 'fastapi' pyproject.toml 2>/dev/null; then
            PROJECT_TYPE="python-fastapi"
            FRAMEWORK="fastapi"
        elif [ -d "scripts" ] && [ "$(find scripts -name '*.py' | wc -l)" -gt 3 ]; then
            PROJECT_TYPE="python-cli"
        else
            PROJECT_TYPE="python-library"
        fi

        # Detect quality tools
        grep -q 'ruff' pyproject.toml 2>/dev/null && QUALITY_TOOLS+=("ruff")
        grep -q 'black' pyproject.toml 2>/dev/null && QUALITY_TOOLS+=("black")
        grep -q 'mypy' pyproject.toml 2>/dev/null && QUALITY_TOOLS+=("mypy")
        grep -q 'pytest' pyproject.toml 2>/dev/null && TEST_FRAMEWORK="pytest"
    fi

    # Check for Claude Code plugin/skill repos
    # Can be: plugin-only, skill-only, plugin+skills, or any of these with bash
    if [ "$LANGUAGE" = "unknown" ]; then
        local has_plugin=false
        local has_skills=false
        local skill_count=0

        [ -f ".claude-plugin/plugin.json" ] && has_plugin=true
        [ -d "skills" ] && skill_count=$(find skills -maxdepth 2 -name "SKILL.md" -type f 2>/dev/null | wc -l)
        [ "$skill_count" -gt 0 ] && has_skills=true

        if [ "$has_plugin" = true ] || [ "$has_skills" = true ]; then
            FRAMEWORK="claude-code"
            PACKAGE_MANAGER="none"

            # Determine project type based on combination
            if [ "$has_plugin" = true ] && [ "$has_skills" = true ]; then
                if [ "$skill_count" -gt 1 ]; then
                    PROJECT_TYPE="claude-code-plugin-monorepo"
                else
                    PROJECT_TYPE="claude-code-plugin"
                fi
                LANGUAGE="claude-code-plugin"
            elif [ "$has_plugin" = true ]; then
                PROJECT_TYPE="claude-code-plugin"
                LANGUAGE="claude-code-plugin"
            else
                # Skills without plugin.json (standalone skill repo)
                if [ "$skill_count" -gt 1 ]; then
                    PROJECT_TYPE="claude-code-skill-monorepo"
                else
                    PROJECT_TYPE="claude-code-skill"
                fi
                LANGUAGE="claude-code-skill"
            fi

            # Check for shell scripts (common in skills)
            local sh_count
            sh_count=$(find . -maxdepth 5 -name "*.sh" -type f 2>/dev/null | wc -l)
            if [ "$sh_count" -gt 3 ]; then
                BUILD_TOOL="bash"
                [ -f ".shellcheckrc" ] && QUALITY_TOOLS+=("shellcheck") || true
            fi
        fi
    fi

    # Container-primary detection (Dockerfile-only repos)
    # Must come before bash fallback - some container repos have helper scripts
    if [ "$LANGUAGE" = "unknown" ]; then
        if [ -f "Dockerfile" ]; then
            # Check if this is primarily a container image project
            # Indicators: no source code, or only build scripts
            local has_source=false
            # Check for significant source files
            [ "$(find . -maxdepth 3 -name '*.go' -o -name '*.py' -o -name '*.php' -o -name '*.ts' -o -name '*.js' 2>/dev/null | head -5 | wc -l)" -gt 3 ] && has_source=true

            if [ "$has_source" = false ]; then
                LANGUAGE="docker"
                PROJECT_TYPE="container-image"
                BUILD_TOOL="docker"
                PACKAGE_MANAGER="none"
                FRAMEWORK="docker"

                # Detect if it's a compose-based project
                if [ -f "docker-compose.yml" ] || [ -f "compose.yml" ] || [ -f "compose.yaml" ]; then
                    PROJECT_TYPE="container-stack"
                fi
            fi
        fi
    fi

    # Fallback: Check for bash/shell projects
    if [ "$LANGUAGE" = "unknown" ]; then
        local sh_count
        sh_count=$(find . -maxdepth 5 -name "*.sh" -type f 2>/dev/null | wc -l)
        if [ "$sh_count" -gt 3 ]; then
            LANGUAGE="bash"
            PROJECT_TYPE="bash-scripts"
            BUILD_TOOL="bash"
            PACKAGE_MANAGER="none"
            # Check for shellcheck
            [ -f ".shellcheckrc" ] && QUALITY_TOOLS+=("shellcheck") || true
        fi
    fi
}

# Detect task runner (does NOT override package_manager)
if [ -f "Makefile" ]; then
    TASK_RUNNER="make"
elif [ -f "justfile" ] || [ -f "Justfile" ]; then
    TASK_RUNNER="just"
elif [ -f "Taskfile.yml" ] || [ -f "Taskfile.yaml" ]; then
    TASK_RUNNER="task"
fi

# Detect Docker (check both old and new compose naming)
[ -f "Dockerfile" ] || [ -f "docker-compose.yml" ] || [ -f "compose.yml" ] || [ -f "compose.yaml" ] && HAS_DOCKER=true

# Detect CI
if [ -d ".github/workflows" ]; then
    CI="github-actions"
elif [ -f ".gitlab-ci.yml" ]; then
    CI="gitlab-ci"
elif [ -f ".circleci/config.yml" ]; then
    CI="circleci"
fi

# Detect IDE configurations
[ -f ".editorconfig" ] && IDE_CONFIGS+=("editorconfig") || true
[ -d ".vscode" ] && IDE_CONFIGS+=("vscode") || true
[ -d ".idea" ] && IDE_CONFIGS+=("idea") || true
[ -d ".phpstorm" ] && IDE_CONFIGS+=("phpstorm") || true
[ -d ".fleet" ] && IDE_CONFIGS+=("fleet") || true
[ -f ".sublime-project" ] && IDE_CONFIGS+=("sublime") || true
{ [ -d ".vim" ] || [ -f ".vimrc" ]; } && IDE_CONFIGS+=("vim") || true
{ [ -d ".nvim" ] || [ -f ".nvimrc" ]; } && IDE_CONFIGS+=("neovim") || true

# Detect AI coding agent configurations
[ -d ".cursor" ] && AGENT_CONFIGS+=("cursor") || true
{ [ -d ".claude" ] || [ -f "CLAUDE.md" ] || [ -f ".claude/CLAUDE.md" ]; } && AGENT_CONFIGS+=("claude") || true
[ -d ".windsurf" ] && AGENT_CONFIGS+=("windsurf") || true
{ [ -d ".aider" ] || [ -f ".aider.conf.yml" ]; } && AGENT_CONFIGS+=("aider") || true
[ -d ".continue" ] && AGENT_CONFIGS+=("continue") || true
{ [ -f "copilot-instructions.md" ] || [ -f ".github/copilot-instructions.md" ]; } && AGENT_CONFIGS+=("copilot") || true
[ -d ".codeium" ] && AGENT_CONFIGS+=("codeium") || true
[ -d ".tabnine" ] && AGENT_CONFIGS+=("tabnine") || true
{ [ -d ".sourcegraph" ] || [ -f ".sourcegraph/cody.json" ]; } && AGENT_CONFIGS+=("cody") || true

# Run detection
detect_language

# Multi-stack detection: detect secondary languages/technologies
# STACKS array is populated here after primary language detection
detect_stacks() {
    # Always add primary language to stacks (if known)
    [ "$LANGUAGE" != "unknown" ] && STACKS+=("$LANGUAGE")

    # Detect Docker as secondary stack (if not already primary)
    if [ "$LANGUAGE" != "docker" ] && [ "$HAS_DOCKER" = true ]; then
        STACKS+=("docker")
    fi

    # Detect frontend stack in backend projects
    if [[ "$LANGUAGE" =~ ^(php|go|python)$ ]]; then
        # Check for Node.js frontend
        if [ -f "package.json" ]; then
            # Check what kind of frontend
            if jq -e '.dependencies."react" // .dependencies."next"' package.json &>/dev/null; then
                STACKS+=("react")
            elif jq -e '.dependencies."vue"' package.json &>/dev/null; then
                STACKS+=("vue")
            elif jq -e '.dependencies."svelte"' package.json &>/dev/null; then
                STACKS+=("svelte")
            else
                STACKS+=("typescript")
            fi
        fi
        # Check for frontend in subdirectories
        for frontend_dir in web frontend client ui internal/web; do
            if [ -d "$frontend_dir" ] && [ -f "$frontend_dir/package.json" ]; then
                if jq -e '.dependencies."react" // .dependencies."next"' "$frontend_dir/package.json" &>/dev/null; then
                    [[ ! " ${STACKS[*]} " =~ " react " ]] && STACKS+=("react")
                elif jq -e '.dependencies."vue"' "$frontend_dir/package.json" &>/dev/null; then
                    [[ ! " ${STACKS[*]} " =~ " vue " ]] && STACKS+=("vue")
                fi
            fi
        done
    fi

    # Detect backend in frontend projects (monorepo patterns)
    if [[ "$LANGUAGE" == "typescript" ]]; then
        # Check for Go backend
        if [ -f "go.mod" ] || [ -d "server" ] && [ -f "server/go.mod" ]; then
            STACKS+=("go")
        fi
        # Check for Python backend
        if [ -f "pyproject.toml" ] || { [ -d "server" ] && [ -f "server/pyproject.toml" ]; }; then
            STACKS+=("python")
        fi
        # Check for PHP backend
        if [ -f "composer.json" ] || { [ -d "api" ] && [ -f "api/composer.json" ]; }; then
            STACKS+=("php")
        fi
    fi
}

detect_stacks

# Output JSON
# Handle empty arrays
if [ ${#QUALITY_TOOLS[@]} -eq 0 ]; then
    TOOLS_JSON="[]"
else
    TOOLS_JSON="$(printf '%s\n' "${QUALITY_TOOLS[@]}" | jq -R . | jq -s .)"
fi

if [ ${#IDE_CONFIGS[@]} -eq 0 ]; then
    IDE_JSON="[]"
else
    IDE_JSON="$(printf '%s\n' "${IDE_CONFIGS[@]}" | jq -R . | jq -s .)"
fi

if [ ${#AGENT_CONFIGS[@]} -eq 0 ]; then
    AGENT_JSON="[]"
else
    AGENT_JSON="$(printf '%s\n' "${AGENT_CONFIGS[@]}" | jq -R . | jq -s .)"
fi

if [ ${#STACKS[@]} -eq 0 ]; then
    STACKS_JSON="[]"
else
    STACKS_JSON="$(printf '%s\n' "${STACKS[@]}" | jq -R . | jq -s .)"
fi

jq -n \
    --arg type "$PROJECT_TYPE" \
    --arg lang "$LANGUAGE" \
    --arg ver "$VERSION" \
    --arg build "$BUILD_TOOL" \
    --arg pkg_mgr "$PACKAGE_MANAGER" \
    --arg task_runner "$TASK_RUNNER" \
    --arg framework "$FRAMEWORK" \
    --argjson docker "$HAS_DOCKER" \
    --argjson tools "$TOOLS_JSON" \
    --arg test "$TEST_FRAMEWORK" \
    --arg ci "$CI" \
    --argjson ide_configs "$IDE_JSON" \
    --argjson agent_configs "$AGENT_JSON" \
    --argjson stacks "$STACKS_JSON" \
    '{
        type: $type,
        language: $lang,
        version: $ver,
        build_tool: $build,
        package_manager: $pkg_mgr,
        task_runner: $task_runner,
        framework: $framework,
        has_docker: $docker,
        quality_tools: $tools,
        test_framework: $test,
        ci: $ci,
        ide_configs: $ide_configs,
        agent_configs: $agent_configs,
        stacks: $stacks
    }'
rea-changelog-updatemorluto/reaPrepare or rewrite REA release changelogs and GitHub release notes from pinned Git history, with verified contributor thanks and Release Please synchronization.Stars: 468kUpdated Claude CodeCodexVerifiedInstall
academy-guideanthropics/skillsStop and check this skill before finishing any reply to a question about how to use Claude or a Claude product — it recommends matching courses, tutorials, and use cases from Claude Academy (academy.claude.com), Anthropic's learning hub. Trigger on: "how do I", "how can I", "getting started with", "what can Claude do", "teach me", "learn to use"; questions about artifacts, projects, skills, plugins, connectors, MCP; requests about rolling Claude out to a team, class, or organization; and any ask for training materials, onboarding content, or learning resources. Use it when the user is learning how to use a feature or product — not when they are mid-task and just want the task done. This skill composes with other skills: after consulting product documentation to answer how a Claude feature works, also check here for a matching course or tutorial — a docs-grounded answer and an Academy recommendation belong together. Only recommend on a strong match; never invent Academy content.Stars: 197kUpdated Claude CodeCodexVerifiedInstall
claude-apianthropics/skillsReference for the Claude API / Anthropic SDK — model ids, pricing, params, streaming, tool use, MCP, agents, caching, token counting, model migration. TRIGGER — read BEFORE opening the target file; don't skip because it "looks like a one-liner" — whenever: the prompt names Claude/Anthropic in any form (Claude, Anthropic, Fable, Opus, Sonnet, Haiku, `anthropic`, `@anthropic-ai`, `claude-*`, `us.anthropic.*`, `[1m]`); the user asks about an LLM (pricing/model choice/limits/caching) — never answer from memory; OR the task is LLM-shaped with provider unstated (agent/MCP/tool-definition/multi-agent/RAG/LLM-judge/computer-use; generate/summarize/extract/classify/rewrite/converse over NL; debugging refusals/cutoffs/streaming/tool-calls/tokens). SKIP only when another provider is being worked on (overrides all triggers): OpenAI/GPT/Gemini/Llama/Mistral/Cohere/Ollama named in the query; OR `grep -rE 'openai|langchain_openai|google.generativeai|genai|mistralai|cohere|ollama'` over the project hits (run this grep FIRST if no provider named — don't Read the file).Stars: 197kUpdated Claude CodeCodexUnverifiedInstall
doc-coauthoringanthropics/skillsGuide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.Stars: 197kUpdated Claude CodeCodexVerifiedInstall