@synapta/skills 0.1.0 → 0.1.2

package/skills/repo-bootstrap/scripts/generate-file-map.sh

@@ -0,0 +1,153 @@
+#!/usr/bin/env bash
+# Generate file map (dir → purpose) for AGENTS.md
+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 "# Not a git repository - cannot generate file map" >&2
+    echo ""
+    exit 0
+fi
+
+# Map of known directory names to their purposes
+declare -A DIR_PURPOSES=(
+    # Source directories
+    ["src"]="application source code"
+    ["lib"]="library code"
+    ["app"]="application code (routes, pages)"
+    ["pkg"]="public packages"
+    ["internal"]="internal packages (not exported)"
+
+    # Language-specific
+    ["cmd"]="CLI entrypoints"
+    ["Classes"]="PHP classes (PSR-4)"
+    ["Configuration"]="framework configuration"
+
+    # Frontend
+    ["components"]="UI components"
+    ["pages"]="page components/routes"
+    ["views"]="view templates"
+    ["layouts"]="layout components"
+    ["hooks"]="React/Vue hooks"
+    ["stores"]="state management"
+    ["styles"]="CSS/styling"
+    ["assets"]="static assets (images, fonts)"
+    ["public"]="public static files"
+
+    # Backend
+    ["api"]="API routes/handlers"
+    ["routes"]="route definitions"
+    ["controllers"]="request handlers"
+    ["services"]="business logic"
+    ["models"]="data models"
+    ["entities"]="database entities"
+    ["repositories"]="data access layer"
+    ["middleware"]="request middleware"
+
+    # Infrastructure
+    ["scripts"]="automation scripts"
+    ["bin"]="compiled binaries"
+    ["build"]="build output"
+    ["dist"]="distribution files"
+    ["vendor"]="third-party dependencies (do not edit)"
+    ["node_modules"]="npm dependencies (do not edit)"
+
+    # Testing
+    ["tests"]="test suites"
+    ["test"]="test suites"
+    ["Tests"]="test suites"
+    ["__tests__"]="Jest test suites"
+    ["testutil"]="test utilities"
+    ["fixtures"]="test fixtures"
+    ["mocks"]="test mocks"
+
+    # Documentation
+    ["docs"]="documentation"
+    ["Documentation"]="documentation (RST/MD)"
+    ["doc"]="documentation"
+
+    # Configuration
+    ["config"]="configuration files"
+    ["configs"]="configuration files"
+    [".github"]="GitHub Actions, templates"
+    [".gitlab"]="GitLab CI configuration"
+
+    # Data
+    ["migrations"]="database migrations"
+    ["seeds"]="database seeds"
+    ["data"]="data files"
+    ["Resources"]="templates and assets"
+
+    # Examples
+    ["examples"]="usage examples"
+    ["example"]="usage examples"
+    ["samples"]="sample code"
+)
+
+# Get top-level directories with file counts
+get_directories() {
+    git ls-files | cut -d/ -f1 | sort | uniq -c | sort -rn | while read -r count dir; do
+        # Skip files (no directory)
+        [[ "$dir" == *.* ]] && continue
+        # Skip hidden except .github/.gitlab
+        [[ "$dir" == .* ]] && [[ "$dir" != ".github" ]] && [[ "$dir" != ".gitlab" ]] && continue
+        echo "$count $dir"
+    done
+}
+
+# Infer purpose from directory contents if not in known list
+infer_purpose() {
+    local dir="$1"
+
+    # Check for specific file patterns
+    if ls "$dir"/*.go 2>/dev/null | head -1 > /dev/null; then
+        echo "Go packages"
+    elif ls "$dir"/*.py 2>/dev/null | head -1 > /dev/null; then
+        echo "Python modules"
+    elif ls "$dir"/*.php 2>/dev/null | head -1 > /dev/null; then
+        echo "PHP classes"
+    elif ls "$dir"/*.ts 2>/dev/null | head -1 > /dev/null; then
+        echo "TypeScript modules"
+    elif ls "$dir"/*.tsx 2>/dev/null | head -1 > /dev/null; then
+        echo "React components"
+    elif ls "$dir"/*.vue 2>/dev/null | head -1 > /dev/null; then
+        echo "Vue components"
+    elif ls "$dir"/*.sh 2>/dev/null | head -1 > /dev/null; then
+        echo "shell scripts"
+    elif ls "$dir"/*.md 2>/dev/null | head -1 > /dev/null; then
+        echo "documentation"
+    elif ls "$dir"/*.json 2>/dev/null | head -1 > /dev/null; then
+        echo "configuration/data"
+    else
+        echo "project files"
+    fi
+}
+
+# Generate the file map
+generate_map() {
+    local max_dirs=15  # Limit to top 15 directories
+
+    while read -r count dir; do
+        [ -z "$dir" ] && continue
+        [ "$max_dirs" -le 0 ] && break
+
+        local purpose=""
+        if [ -n "${DIR_PURPOSES[$dir]:-}" ]; then
+            purpose="${DIR_PURPOSES[$dir]}"
+        else
+            purpose=$(infer_purpose "$dir")
+        fi
+
+        # Format: dir/ → purpose
+        # Pad directory name for alignment
+        printf "%-16s → %s\n" "${dir}/" "$purpose"
+
+        ((max_dirs--))
+    done < <(get_directories)
+}
+
+# Output the file map
+generate_map

package/skills/repo-bootstrap/scripts/lib/config-root.sh

@@ -0,0 +1,211 @@
+#!/usr/bin/env bash
+# Find nearest config root for a given stack type
+
+# Find nearest directory containing package.json (for Node scopes)
+# Usage: find_node_config_root "/path/to/scope"
+# Returns: directory path or empty string
+find_node_config_root() {
+    local start_dir="$1"
+    local search_dir="$start_dir"
+
+    while [[ "$search_dir" != "." && "$search_dir" != "/" ]]; do
+        if [[ -f "$search_dir/package.json" ]]; then
+            echo "$search_dir"
+            return 0
+        fi
+        search_dir=$(dirname "$search_dir")
+    done
+
+    # Check project root as fallback
+    if [[ -f "package.json" ]]; then
+        echo "."
+        return 0
+    fi
+
+    return 1
+}
+
+# Find nearest directory containing composer.json (for PHP scopes)
+find_php_config_root() {
+    local start_dir="$1"
+    local search_dir="$start_dir"
+
+    while [[ "$search_dir" != "." && "$search_dir" != "/" ]]; do
+        if [[ -f "$search_dir/composer.json" ]]; then
+            echo "$search_dir"
+            return 0
+        fi
+        search_dir=$(dirname "$search_dir")
+    done
+
+    if [[ -f "composer.json" ]]; then
+        echo "."
+        return 0
+    fi
+
+    return 1
+}
+
+# Find nearest directory containing go.mod (for Go scopes)
+find_go_config_root() {
+    local start_dir="$1"
+    local search_dir="$start_dir"
+
+    while [[ "$search_dir" != "." && "$search_dir" != "/" ]]; do
+        if [[ -f "$search_dir/go.mod" ]]; then
+            echo "$search_dir"
+            return 0
+        fi
+        search_dir=$(dirname "$search_dir")
+    done
+
+    if [[ -f "go.mod" ]]; then
+        echo "."
+        return 0
+    fi
+
+    return 1
+}
+
+# Find nearest directory containing pyproject.toml or setup.py (for Python scopes)
+find_python_config_root() {
+    local start_dir="$1"
+    local search_dir="$start_dir"
+
+    while [[ "$search_dir" != "." && "$search_dir" != "/" ]]; do
+        if [[ -f "$search_dir/pyproject.toml" || -f "$search_dir/setup.py" ]]; then
+            echo "$search_dir"
+            return 0
+        fi
+        search_dir=$(dirname "$search_dir")
+    done
+
+    if [[ -f "pyproject.toml" || -f "setup.py" ]]; then
+        echo "."
+        return 0
+    fi
+
+    return 1
+}
+
+# Find Node workspace root (monorepo root)
+# Detects: pnpm-workspace.yaml, package.json with "workspaces", lerna.json, nx.json
+# Usage: find_node_workspace_root "/path/to/scope"
+# Returns: workspace root directory or empty string
+find_node_workspace_root() {
+    local start_dir="$1"
+    local search_dir="$start_dir"
+
+    while [[ "$search_dir" != "." && "$search_dir" != "/" ]]; do
+        # pnpm workspace
+        if [[ -f "$search_dir/pnpm-workspace.yaml" ]]; then
+            echo "$search_dir"
+            return 0
+        fi
+
+        # npm/yarn workspaces (package.json with "workspaces" field)
+        if [[ -f "$search_dir/package.json" ]]; then
+            if jq -e '.workspaces' "$search_dir/package.json" >/dev/null 2>&1; then
+                echo "$search_dir"
+                return 0
+            fi
+        fi
+
+        # Lerna monorepo
+        if [[ -f "$search_dir/lerna.json" ]]; then
+            echo "$search_dir"
+            return 0
+        fi
+
+        # Nx monorepo
+        if [[ -f "$search_dir/nx.json" ]]; then
+            echo "$search_dir"
+            return 0
+        fi
+
+        search_dir=$(dirname "$search_dir")
+    done
+
+    # Check project root as fallback
+    if [[ -f "pnpm-workspace.yaml" ]]; then
+        echo "."
+        return 0
+    fi
+    if [[ -f "package.json" ]] && jq -e '.workspaces' "package.json" >/dev/null 2>&1; then
+        echo "."
+        return 0
+    fi
+    if [[ -f "lerna.json" || -f "nx.json" ]]; then
+        echo "."
+        return 0
+    fi
+
+    return 1
+}
+
+# Extract Node version from nearest config
+# Priority: package.json engines.node > .nvmrc > .node-version > .tool-versions
+get_node_version() {
+    local config_root="$1"
+    local version=""
+
+    # Try package.json engines.node
+    if [[ -f "$config_root/package.json" ]]; then
+        version=$(jq -r '.engines.node // empty' "$config_root/package.json" 2>/dev/null)
+        [[ -n "$version" ]] && echo "$version" && return 0
+    fi
+
+    # Try .nvmrc
+    if [[ -f "$config_root/.nvmrc" ]]; then
+        version=$(tr -d '[:space:]' < "$config_root/.nvmrc")
+        [[ -n "$version" ]] && echo "$version" && return 0
+    fi
+
+    # Try .node-version
+    if [[ -f "$config_root/.node-version" ]]; then
+        version=$(tr -d '[:space:]' < "$config_root/.node-version")
+        [[ -n "$version" ]] && echo "$version" && return 0
+    fi
+
+    # Try .tool-versions (asdf)
+    if [[ -f "$config_root/.tool-versions" ]]; then
+        version=$(grep '^nodejs ' "$config_root/.tool-versions" 2>/dev/null | awk '{print $2}')
+        [[ -n "$version" ]] && echo "$version" && return 0
+    fi
+
+    return 1
+}
+
+# Extract JS framework from package.json dependencies
+get_js_framework() {
+    local config_root="$1"
+
+    [[ ! -f "$config_root/package.json" ]] && return 1
+
+    local deps
+    deps=$(jq -r '(.dependencies // {}) + (.devDependencies // {}) | keys[]' \
+           "$config_root/package.json" 2>/dev/null)
+
+    # Check in priority order (more specific first)
+    echo "$deps" | grep -qw 'next' && echo "next.js" && return 0
+    echo "$deps" | grep -qw 'nuxt' && echo "nuxt" && return 0
+    echo "$deps" | grep -qw 'svelte' && echo "svelte" && return 0
+    echo "$deps" | grep -qw 'vue' && echo "vue" && return 0
+    echo "$deps" | grep -qw 'react' && echo "react" && return 0
+    echo "$deps" | grep -qw 'express' && echo "express" && return 0
+
+    return 1
+}
+
+# Check if TypeScript strict mode is enabled
+get_ts_strict_mode() {
+    local config_root="$1"
+
+    [[ ! -f "$config_root/tsconfig.json" ]] && return 1
+
+    local strict
+    strict=$(jq -r '.compilerOptions.strict // false' "$config_root/tsconfig.json" 2>/dev/null)
+
+    [[ "$strict" == "true" ]] && echo "true" && return 0
+    return 1
+}

package/skills/repo-bootstrap/scripts/lib/summary.sh

@@ -0,0 +1,244 @@
+#!/usr/bin/env bash
+# Summary output formatting helpers
+
+# Colors (only if terminal supports it)
+if [[ -t 1 ]]; then
+    GREEN='\033[0;32m'
+    YELLOW='\033[0;33m'
+    BLUE='\033[0;34m'
+    CYAN='\033[0;36m'
+    GRAY='\033[0;90m'
+    BOLD='\033[1m'
+    NC='\033[0m' # No Color
+else
+    GREEN=''
+    YELLOW=''
+    BLUE=''
+    CYAN=''
+    GRAY=''
+    BOLD=''
+    NC=''
+fi
+
+# Summary data storage
+declare -A SUMMARY_SOURCES
+declare -a SUMMARY_RULES
+declare -a SUMMARY_WARNINGS
+
+# Initialize summary
+init_summary() {
+    SUMMARY_SOURCES=()
+    SUMMARY_RULES=()
+    SUMMARY_WARNINGS=()
+}
+
+# Record a detected value with its source
+# Usage: record_detection "category" "value" "source_file" "source_detail"
+record_detection() {
+    local category="$1"
+    local value="$2"
+    local source_file="$3"
+    local source_detail="${4:-}"
+
+    if [[ -n "$source_detail" ]]; then
+        SUMMARY_SOURCES["$category"]="$value (from $source_file: $source_detail)"
+    else
+        SUMMARY_SOURCES["$category"]="$value (from $source_file)"
+    fi
+}
+
+# Record an extracted rule
+# Usage: record_rule "rule_type" "rule_value" "source"
+record_rule() {
+    local rule_type="$1"
+    local rule_value="$2"
+    local source="$3"
+
+    SUMMARY_RULES+=("$rule_type: $rule_value [$source]")
+}
+
+# Record a warning
+# Usage: record_warning "message"
+record_warning() {
+    local message="$1"
+    SUMMARY_WARNINGS+=("$message")
+}
+
+# Print the extraction summary
+print_summary() {
+    local project_info="$1"
+    local scopes_info="$2"
+    local commands_info="$3"
+    local docs_info="${4:-{}}"
+    local platform_info="${5:-{}}"
+    local ide_info="${6:-{}}"
+    local agent_info="${7:-{}}"
+
+    echo ""
+    echo -e "${BOLD}═══════════════════════════════════════════════════════════════${NC}"
+    echo -e "${BOLD}                    EXTRACTION SUMMARY                          ${NC}"
+    echo -e "${BOLD}═══════════════════════════════════════════════════════════════${NC}"
+    echo ""
+
+    # Project Detection
+    echo -e "${CYAN}▸ Project Detection${NC}"
+    echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+
+    local lang=$(echo "$project_info" | jq -r '.language')
+    local version=$(echo "$project_info" | jq -r '.version')
+    local ptype=$(echo "$project_info" | jq -r '.type')
+    local framework=$(echo "$project_info" | jq -r '.framework')
+    local build_tool=$(echo "$project_info" | jq -r '.build_tool')
+    local test_fw=$(echo "$project_info" | jq -r '.test_framework')
+    local ci=$(echo "$project_info" | jq -r '.ci')
+    local docker=$(echo "$project_info" | jq -r '.has_docker')
+
+    # Determine source file
+    local lang_source=""
+    case "$lang" in
+        go) lang_source="go.mod" ;;
+        php) lang_source="composer.json" ;;
+        typescript) lang_source="package.json" ;;
+        python) lang_source="pyproject.toml" ;;
+    esac
+
+    printf "  %-16s ${GREEN}%s${NC} ${GRAY}(from %s)${NC}\n" "Language:" "$lang" "$lang_source"
+    [[ "$version" != "unknown" ]] && printf "  %-16s ${GREEN}%s${NC}\n" "Version:" "$version"
+    [[ "$ptype" != "unknown" ]] && printf "  %-16s %s\n" "Project type:" "$ptype"
+    [[ "$framework" != "none" ]] && printf "  %-16s %s\n" "Framework:" "$framework"
+    printf "  %-16s %s\n" "Build tool:" "$build_tool"
+    [[ "$test_fw" != "unknown" ]] && printf "  %-16s %s\n" "Test framework:" "$test_fw"
+    [[ "$ci" != "none" ]] && printf "  %-16s %s\n" "CI/CD:" "$ci"
+    [[ "$docker" == "true" ]] && printf "  %-16s %s\n" "Docker:" "yes"
+
+    # Quality Tools
+    local tools=$(echo "$project_info" | jq -r '.quality_tools | join(", ")')
+    if [[ -n "$tools" && "$tools" != "" ]]; then
+        echo ""
+        echo -e "${CYAN}▸ Quality Tools Detected${NC}"
+        echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+        printf "  %s\n" "$tools"
+    fi
+
+    # IDE Configs (from ide_info)
+    local detected_ides=$(echo "$ide_info" | jq -r '.detected_ides | join(", ")' 2>/dev/null || echo "")
+    if [[ -n "$detected_ides" && "$detected_ides" != "" ]]; then
+        echo ""
+        echo -e "${CYAN}▸ IDE Configurations${NC}"
+        echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+        printf "  %s\n" "$detected_ides"
+
+        # Show editorconfig details if present
+        local indent=$(echo "$ide_info" | jq -r '.editorconfig.indent_style // ""' 2>/dev/null || echo "")
+        if [[ -n "$indent" ]]; then
+            local indent_size=$(echo "$ide_info" | jq -r '.editorconfig.indent_size // ""' 2>/dev/null || echo "")
+            printf "  ${GRAY}→ indent: %s (%s)${NC}\n" "$indent" "$indent_size"
+        fi
+    fi
+
+    # AI Agent Configs (from agent_info)
+    local detected_agents=$(echo "$agent_info" | jq -r '.detected_agents | join(", ")' 2>/dev/null || echo "")
+    if [[ -n "$detected_agents" && "$detected_agents" != "" ]]; then
+        echo ""
+        echo -e "${CYAN}▸ AI Agent Configurations${NC}"
+        echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+        printf "  %s\n" "$detected_agents"
+    fi
+
+    # Documentation Files (from docs_info)
+    local has_contributing=$(echo "$docs_info" | jq -r '.contributing.file // ""' 2>/dev/null || echo "")
+    local has_security=$(echo "$docs_info" | jq -r '.security.file // ""' 2>/dev/null || echo "")
+    local has_changelog=$(echo "$docs_info" | jq -r '.changelog.file // ""' 2>/dev/null || echo "")
+    local has_coc=$(echo "$docs_info" | jq -r '.code_of_conduct.exists // false' 2>/dev/null || echo "false")
+
+    if [[ -n "$has_contributing" || -n "$has_security" || -n "$has_changelog" || "$has_coc" == "true" ]]; then
+        echo ""
+        echo -e "${CYAN}▸ Documentation Files${NC}"
+        echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+        [[ -n "$has_contributing" ]] && printf "  ✓ %s\n" "$has_contributing"
+        [[ -n "$has_security" ]] && printf "  ✓ %s\n" "$has_security"
+        [[ -n "$has_changelog" ]] && printf "  ✓ %s\n" "$has_changelog"
+        [[ "$has_coc" == "true" ]] && printf "  ✓ CODE_OF_CONDUCT.md\n"
+    fi
+
+    # Platform Files (from platform_info)
+    local platform=$(echo "$platform_info" | jq -r '.platform // "none"' 2>/dev/null || echo "none")
+    if [[ "$platform" != "none" ]]; then
+        local pr_template=$(echo "$platform_info" | jq -r '.pull_request.template_file // ""' 2>/dev/null || echo "")
+        local codeowners=$(echo "$platform_info" | jq -r '.codeowners.file // ""' 2>/dev/null || echo "")
+        local dependabot=$(echo "$platform_info" | jq -r '.dependency_updates.dependabot.file // ""' 2>/dev/null || echo "")
+
+        if [[ -n "$pr_template" || -n "$codeowners" || -n "$dependabot" ]]; then
+            echo ""
+            echo -e "${CYAN}▸ Platform Files (${platform})${NC}"
+            echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+            [[ -n "$pr_template" ]] && printf "  ✓ PR template: %s\n" "$pr_template"
+            [[ -n "$codeowners" ]] && printf "  ✓ CODEOWNERS: %s\n" "$codeowners"
+            [[ -n "$dependabot" ]] && printf "  ✓ Dependabot: %s\n" "$dependabot"
+        fi
+    fi
+
+    # Commands Extracted
+    echo ""
+    echo -e "${CYAN}▸ Commands Extracted${NC}"
+    echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+
+    local typecheck=$(echo "$commands_info" | jq -r '.typecheck')
+    local lint=$(echo "$commands_info" | jq -r '.lint')
+    local format=$(echo "$commands_info" | jq -r '.format')
+    local test_cmd=$(echo "$commands_info" | jq -r '.test')
+    local build=$(echo "$commands_info" | jq -r '.build')
+    local dev=$(echo "$commands_info" | jq -r '.dev')
+
+    [[ -n "$typecheck" && "$typecheck" != "" ]] && printf "  %-12s ${YELLOW}%s${NC}\n" "typecheck:" "$typecheck"
+    [[ -n "$lint" && "$lint" != "" ]] && printf "  %-12s ${YELLOW}%s${NC}\n" "lint:" "$lint"
+    [[ -n "$format" && "$format" != "" ]] && printf "  %-12s ${YELLOW}%s${NC}\n" "format:" "$format"
+    [[ -n "$test_cmd" && "$test_cmd" != "" ]] && printf "  %-12s ${YELLOW}%s${NC}\n" "test:" "$test_cmd"
+    [[ -n "$build" && "$build" != "" ]] && printf "  %-12s ${YELLOW}%s${NC}\n" "build:" "$build"
+    [[ -n "$dev" && "$dev" != "" ]] && printf "  %-12s ${YELLOW}%s${NC}\n" "dev:" "$dev"
+
+    # Scopes Detected
+    local scope_count=$(echo "$scopes_info" | jq '.scopes | length')
+    if [[ "$scope_count" -gt 0 ]]; then
+        echo ""
+        echo -e "${CYAN}▸ Scopes Detected ($scope_count)${NC}"
+        echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+
+        echo "$scopes_info" | jq -r '.scopes[] | "  \(.path)/ (\(.files) files) → \(.type)"'
+    fi
+
+    # Files to Generate
+    echo ""
+    echo -e "${CYAN}▸ Files to Generate${NC}"
+    echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+    echo "  AGENTS.md (root)"
+    if [[ "$scope_count" -gt 0 ]]; then
+        echo "$scopes_info" | jq -r '.scopes[] | "  \(.path)/AGENTS.md"'
+    fi
+
+    # Warnings
+    if [[ ${#SUMMARY_WARNINGS[@]} -gt 0 ]]; then
+        echo ""
+        echo -e "${YELLOW}▸ Warnings${NC}"
+        echo -e "  ${GRAY}────────────────────────────────────────${NC}"
+        for warning in "${SUMMARY_WARNINGS[@]}"; do
+            echo -e "  ${YELLOW}⚠${NC}  $warning"
+        done
+    fi
+
+    echo ""
+    echo -e "${BOLD}═══════════════════════════════════════════════════════════════${NC}"
+    echo ""
+}
+
+# Print a compact summary (for non-verbose mode)
+print_compact_summary() {
+    local project_info="$1"
+    local scopes_info="$2"
+
+    local lang=$(echo "$project_info" | jq -r '.language')
+    local ptype=$(echo "$project_info" | jq -r '.type')
+    local scope_count=$(echo "$scopes_info" | jq '.scopes | length')
+
+    echo "Detected: $lang ($ptype), $((scope_count + 1)) AGENTS.md file(s) to generate"
+}