@dtt_siye/atool 1.1.0

package/lib/project-init.sh

@@ -0,0 +1,552 @@
+#!/usr/bin/env bash
+# aTool - lib/project-init.sh
+# Project initialization orchestration: detect stack + generate templates
+# Supports both single projects and monorepos
+
+set -euo pipefail
+
+# Read a field value from .atool-initialized marker file
+# Args: MARKER_FILE, FIELD_NAME
+# Outputs: field value or empty string
+read_marker_field() {
+    local marker_file="$1"
+    local field_name="$2"
+    grep "^# ${field_name}:" "$marker_file" 2>/dev/null | head -1 | sed "s/^# ${field_name}: //" || true
+}
+
+# Compute checksums of template files for the given stack
+# Args: TEMPLATE_NAME, ATOOL_ROOT
+# Outputs: lines of "filename=checksum" pairs
+compute_template_checksums() {
+    local template_name="$1"
+    local atool_root="$2"
+    local templates_dir="$atool_root/templates"
+
+    local template_files=(
+        "CLAUDE.md.${template_name}"
+        "cursor-rules.${template_name}.mdc"
+        "kiro-steering.${template_name}.md"
+        "README.md.${template_name}"
+        "COMPONENT.md.${template_name}"
+        "UI_STYLE.md.${template_name}"
+    )
+
+    for tf in "${template_files[@]}"; do
+        local full_path="$templates_dir/$tf"
+        if [[ -f "$full_path" ]]; then
+            local cksum
+            cksum=$(file_checksum "$full_path")
+            echo "${tf}=${cksum}"
+        fi
+    done
+}
+
+# Initialize a project with aTool configuration
+# Args: PROJECT_DIR
+# Handles both single projects and monorepos automatically
+project_init() {
+    local project_dir
+    project_dir="$(cd "$1" && pwd)"
+    local atool_root="${ATOOL_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
+
+    # shellcheck source=lib/detect-stack.sh
+    source "$atool_root/lib/detect-stack.sh"
+    # shellcheck source=lib/analyze-source.sh
+    source "$atool_root/lib/analyze-source.sh"
+    # shellcheck source=lib/install-kiro.sh
+    source "$atool_root/lib/install-kiro.sh"
+
+    log_step "Initializing project: $project_dir"
+
+    # Check if already initialized
+    if [[ -f "$project_dir/.atool-initialized" ]]; then
+        local marker_version
+        marker_version=$(read_marker_field "$project_dir/.atool-initialized" "Version")
+        local current_version="${ATOOL_VERSION:-unknown}"
+
+        if [[ "$marker_version" != "$current_version" ]] && [[ "$marker_version" != "unknown" ]]; then
+            log_info "Project initialized with aTool v${marker_version}, current is v${current_version}"
+            log_info "Templates may have been updated since last initialization."
+            echo ""
+        fi
+
+        if ! confirm "Re-initialize and overwrite?" "N"; then
+            return 0
+        fi
+    fi
+
+    # Check for monorepo
+    local sub_projects
+    sub_projects=$(detect_monorepo "$project_dir" || true)
+
+    if [[ -n "$sub_projects" ]]; then
+        # Monorepo path
+        local sub_count
+        sub_count=$(echo "$sub_projects" | wc -l | tr -d ' ')
+        log_info "Detected monorepo with ${sub_count} sub-projects"
+        echo ""
+
+        # Initialize each sub-project
+        while IFS= read -r sub_dir; do
+            [[ -z "$sub_dir" ]] && continue
+            echo ""
+            log_step "Initializing sub-project: $(basename "$sub_dir")"
+            project_init_single "$sub_dir" "$atool_root"
+        done <<< "$sub_projects"
+
+        # Generate root-level monorepo README
+        generate_monorepo_readme "$project_dir" "$atool_root" "$sub_projects"
+
+        # Write initialization marker
+        if ! is_dry_run; then
+            cat > "$project_dir/.atool-initialized" <<MARKER
+# aTool monorepo initialization
+# Generated: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+# Sub-projects: ${sub_count}
+# Version: ${ATOOL_VERSION:-unknown}
+MARKER
+            log_success "Monorepo initialized: $project_dir"
+        fi
+    else
+        # Single project path
+        project_init_single "$project_dir" "$atool_root"
+    fi
+}
+
+# Initialize a single project (used by both monorepo and standalone paths)
+# Args: PROJECT_DIR, ATOOL_ROOT
+project_init_single() {
+    local project_dir="$1"
+    local atool_root="$2"
+
+    local stack
+    stack=$(detect_stack "$project_dir")
+    local template_name
+    template_name=$(get_template_name "$stack")
+    local description
+    description=$(get_stack_description "$stack")
+    local confidence
+    confidence=$(get_stack_confidence "$project_dir")
+
+    echo ""
+    log_info "Detected stack: ${BOLD}$description${NC} (${stack})"
+    log_info "Confidence: ${confidence}%"
+    log_info "Template: ${template_name}"
+    echo ""
+
+    if [[ "$stack" == "generic" ]]; then
+        log_warn "Could not detect a specific technology stack."
+        log_warn "A generic template will be used."
+        if ! confirm "Continue with generic template?" "Y"; then
+            log_info "Cancelled. You can specify a stack manually."
+            return 0
+        fi
+    else
+        confirm "Use '$description' template?" "Y" || {
+            log_info "Cancelled."
+            return 0
+        }
+    fi
+
+    # Generate CLAUDE.md
+    generate_claude_md "$project_dir" "$template_name" "$atool_root"
+
+    # Generate Cursor rules (from template + copy staging rules)
+    generate_cursor_conventions_from_template "$project_dir" "$template_name" "$atool_root"
+    copy_staging_rules "cursor" "$project_dir"
+
+    # Generate Kiro steering (from template + copy staging rules)
+    generate_kiro_steering "$project_dir" "$template_name" "$atool_root"
+    # Clean up old per-skill files from previous aTool versions
+    cleanup_project_kiro_steering "$project_dir/.kiro/steering"
+    copy_staging_rules "kiro" "$project_dir"
+
+    # Install project-level hooks (Claude only)
+    install_hooks "$project_dir" "claude"
+
+    # Collect metadata: basic + source analysis
+    local metadata
+    metadata=$(extract_project_metadata "$project_dir")
+
+    # Setup temp dir for block values
+    local tmpdir="${ATOOL_ANALYSIS_TMPDIR:-$(mktemp -d)}"
+    export ATOOL_ANALYSIS_TMPDIR="$tmpdir"
+    mkdir -p "$tmpdir"
+
+    # Run source analysis (writes block files to tmpdir)
+    local source_metadata
+    source_metadata=$(extract_source_metadata "$project_dir" 2>/dev/null || true)
+
+    # Merge all metadata
+    local all_metadata="$metadata"
+    if [[ -n "$source_metadata" ]]; then
+        all_metadata="${metadata}
+${source_metadata}"
+    fi
+
+    # Generate documentation with rich content
+    generate_readme_md "$project_dir" "$template_name" "$atool_root" "$all_metadata"
+    generate_component_md "$project_dir" "$template_name" "$atool_root" "$all_metadata"
+    generate_ui_style_md "$project_dir" "$template_name" "$atool_root" "$all_metadata"
+
+    # Write initialization marker
+    if ! is_dry_run; then
+        local checksums
+        checksums=$(compute_template_checksums "$template_name" "$atool_root")
+
+        cat > "$project_dir/.atool-initialized" <<MARKER
+# aTool project initialization
+# Generated: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+# Stack: $stack
+# Template: $template_name
+# Version: ${ATOOL_VERSION:-unknown}
+MARKER
+
+        # Append template checksums
+        while IFS='=' read -r fname cksum; do
+            [[ -z "$fname" ]] && continue
+            echo "# Checksum: ${fname}=${cksum}" >> "$project_dir/.atool-initialized"
+        done <<< "$checksums"
+
+        log_success "Project initialized: $project_dir"
+    else
+        log_info "[DRY-RUN] Would create .atool-initialized"
+    fi
+
+    echo ""
+    log_info "Generated files:"
+    log_info "  CLAUDE.md       - Claude Code rules"
+    log_info "  .cursor/rules/  - Cursor rules"
+    log_info "  .kiro/steering/ - Kiro steering"
+    log_info "  .claude/hooks/  - Claude Code hooks"
+    log_info "  README.md       - Project overview"
+    log_info "  COMPONENT.md    - Component/module documentation"
+    log_info "  UI_STYLE.md     - UI style documentation"
+}
+
+# Generate monorepo root-level README
+# Args: PROJECT_DIR, ATOOL_ROOT, SUB_PROJECTS (newline-separated paths)
+generate_monorepo_readme() {
+    local project_dir="$1"
+    local atool_root="$2"
+    local sub_projects="$3"
+
+    local template="$atool_root/templates/README.md.monorepo"
+    local output="$project_dir/README.md"
+
+    if [[ ! -f "$template" ]]; then
+        log_warn "Monorepo README template not found: $template"
+        return 1
+    fi
+
+    if [[ -f "$output" ]]; then
+        backup_file "$output"
+    fi
+
+    # Extract root metadata
+    local metadata
+    metadata=$(extract_project_metadata "$project_dir")
+
+    # Build sub-project data into temp files
+    local tmpdir="${ATOOL_ANALYSIS_TMPDIR:-$(mktemp -d)}"
+    export ATOOL_ANALYSIS_TMPDIR="$tmpdir"
+    mkdir -p "$tmpdir"
+
+    local sub_table_file="$tmpdir/subproject_table.txt"
+    local sub_quick_start_file="$tmpdir/subproject_quick_start.txt"
+    : > "$sub_table_file"
+    : > "$sub_quick_start_file"
+
+    while IFS= read -r sub_dir; do
+        [[ -z "$sub_dir" ]] && continue
+        local sub_name sub_stack sub_desc sub_files
+        sub_name=$(basename "$sub_dir")
+        sub_stack=$(detect_stack "$sub_dir")
+        sub_desc=$(jq -r '.description // empty' "$sub_dir/package.json" 2>/dev/null || echo "")
+        sub_files=$(count_source_files "$sub_dir" 2>/dev/null || echo "unknown")
+
+        printf '| %s | %s | %s | %s |\n' "$sub_name" "$sub_stack" "$sub_files" "$sub_desc" >> "$sub_table_file"
+
+        # Quick start for each sub-project
+        local pkg_mgr dev_script
+        pkg_mgr=$(detect_package_manager "$sub_dir" || echo "npm")
+        dev_script=$(get_npm_script "$sub_dir" "dev")
+        if [[ -n "$dev_script" ]]; then
+            printf '### %s\n\n```bash\ncd %s\n%s install\n%s dev\n```\n\n' \
+                "$sub_name" "$sub_name" "$pkg_mgr" "$pkg_mgr" >> "$sub_quick_start_file"
+        fi
+    done <<< "$sub_projects"
+
+    # Generate directory structure
+    local structure_file="$tmpdir/project_structure.txt"
+    : > "$structure_file"
+    for sub_dir in $sub_projects; do
+        [[ -z "$sub_dir" ]] && continue
+        printf '├── %s/\n' "$(basename "$sub_dir")" >> "$structure_file"
+    done
+
+    # Step 1: template_substitute for single-line values
+    local subst_args=()
+    while IFS='=' read -r key value; do
+        [[ -n "$key" ]] && subst_args+=("${key}=${value}")
+    done <<< "$metadata"
+
+    template_substitute "$template" "$output" "${subst_args[@]}"
+
+    # Step 2: template_substitute_blocks for multi-line values
+    template_substitute_blocks "$output" \
+        "SUBPROJECT_TABLE=__BLOCK__:$sub_table_file" \
+        "SUBPROJECT_QUICK_START=__BLOCK__:$sub_quick_start_file" \
+        "PROJECT_STRUCTURE=__BLOCK__:$structure_file"
+
+    # Step 3: Strip any remaining block markers (keep content between them)
+    strip_block_markers "$output"
+
+    log_success "Generated: README.md (monorepo overview)"
+}
+
+# Generate CLAUDE.md from template
+generate_claude_md() {
+    local project_dir="$1"
+    local template_name="$2"
+    local atool_root="$3"
+
+    local template="$atool_root/templates/CLAUDE.md.${template_name}"
+    local output="$project_dir/CLAUDE.md"
+
+    if [[ ! -f "$template" ]]; then
+        log_warn "Template not found: $template"
+        return 1
+    fi
+
+    if [[ -f "$output" ]]; then
+        backup_file "$output"
+    fi
+
+    run_cmd cp "$template" "$output"
+    log_success "Generated: CLAUDE.md"
+}
+
+# Generate Cursor rules from template
+generate_cursor_conventions_from_template() {
+    local project_dir="$1"
+    local template_name="$2"
+    local atool_root="$3"
+
+    local template="$atool_root/templates/cursor-rules.${template_name}.mdc"
+    local rules_dir="$project_dir/.cursor/rules"
+
+    if [[ ! -f "$template" ]]; then
+        log_warn "Cursor template not found: $template"
+        return 1
+    fi
+
+    ensure_dir "$rules_dir"
+    run_cmd cp "$template" "$rules_dir/atool-conventions.mdc"
+    log_success "Generated: .cursor/rules/atool-conventions.mdc"
+}
+
+# Copy staging rules/steering from global install to project directory
+# Cursor and Kiro only load from project-level dirs, so we copy from staging
+# Args: IDE_TYPE, PROJECT_DIR
+copy_staging_rules() {
+    local ide_type="$1"
+    local project_dir="$2"
+    local staging_dir=""
+    local target_dir=""
+
+    case "$ide_type" in
+        cursor)
+            staging_dir="$(get_cursor_config_dir)/rules/.atool-staging"
+            target_dir="$project_dir/.cursor/rules"
+            ;;
+        kiro)
+            staging_dir="$(get_kiro_config_dir)/steering/.atool-staging"
+            target_dir="$project_dir/.kiro/steering"
+            ;;
+        *)
+            return 0
+            ;;
+    esac
+
+    if [[ ! -d "$staging_dir" ]]; then
+        log_info "No staging rules found for $ide_type (run install first)"
+        return 0
+    fi
+
+    if ! is_dry_run; then
+        ensure_dir "$target_dir"
+    fi
+
+    local count=0
+    local updated=0
+    for file in "$staging_dir"/*; do
+        [[ ! -f "$file" ]] && continue
+        local filename
+        filename=$(basename "$file")
+        local dest="$target_dir/$filename"
+
+        if [[ -f "$dest" ]]; then
+            # Use checksum comparison to detect content changes
+            local src_ck dest_ck
+            src_ck=$(file_checksum "$file")
+            dest_ck=$(file_checksum "$dest")
+            if [[ "$src_ck" == "$dest_ck" ]]; then
+                continue  # Identical content, skip
+            fi
+            # Content differs — backup old file and update
+            backup_file "$dest"
+            run_cmd cp "$file" "$dest"
+            updated=$((updated + 1))
+        else
+            run_cmd cp "$file" "$dest"
+        fi
+        count=$((count + 1))
+    done
+
+    if [[ "$count" -gt 0 ]]; then
+        log_info "Copied $count $ide_type rules to $target_dir/"
+        if [[ "$updated" -gt 0 ]]; then
+            log_info "  ($updated updated from previous version)"
+        fi
+    fi
+}
+
+# Generate Kiro steering from template
+generate_kiro_steering() {
+    local project_dir="$1"
+    local template_name="$2"
+    local atool_root="$3"
+
+    local template="$atool_root/templates/kiro-steering.${template_name}.md"
+    local steering_dir="$project_dir/.kiro/steering"
+
+    if [[ ! -f "$template" ]]; then
+        log_warn "Kiro template not found: $template"
+        return 1
+    fi
+
+    ensure_dir "$steering_dir"
+    run_cmd cp "$template" "$steering_dir/atool-conventions.md"
+    log_success "Generated: .kiro/steering/atool-conventions.md"
+}
+
+# Generate README.md from template with variable substitution (single-line + block)
+# Args: PROJECT_DIR TEMPLATE_NAME ATOOL_ROOT METADATA
+generate_readme_md() {
+    local project_dir="$1" template_name="$2" atool_root="$3" metadata="$4"
+    local template="$atool_root/templates/README.md.${template_name}"
+    local output="$project_dir/README.md"
+
+    if [[ ! -f "$template" ]]; then
+        log_warn "README template not found: $template"
+        return 1
+    fi
+
+    if [[ -f "$output" ]]; then
+        backup_file "$output"
+    fi
+
+    # Parse metadata into args for template_substitute
+    local subst_args=()
+    local block_args=()
+    while IFS='=' read -r key value; do
+        [[ -n "$key" ]] || continue
+        if [[ "$value" == __BLOCK__:* ]]; then
+            block_args+=("${key}=${value}")
+        else
+            subst_args+=("${key}=${value}")
+        fi
+    done <<< "$metadata"
+
+    # Step 1: Single-line substitution
+    template_substitute "$template" "$output" "${subst_args[@]}"
+
+    # Step 2: Block substitution (only if template has block markers)
+    if grep -q '{{#' "$output" 2>/dev/null && [[ ${#block_args[@]} -gt 0 ]]; then
+        template_substitute_blocks "$output" "${block_args[@]}"
+    fi
+
+    # Step 3: Strip any remaining block markers (keep content between them)
+    strip_block_markers "$output"
+
+    log_success "Generated: README.md"
+}
+
+# Generate COMPONENT.md from template with variable substitution (single-line + block)
+# Args: PROJECT_DIR TEMPLATE_NAME ATOOL_ROOT METADATA
+generate_component_md() {
+    local project_dir="$1" template_name="$2" atool_root="$3" metadata="$4"
+    local template="$atool_root/templates/COMPONENT.md.${template_name}"
+    local output="$project_dir/COMPONENT.md"
+
+    if [[ ! -f "$template" ]]; then
+        log_warn "COMPONENT template not found: $template"
+        return 1
+    fi
+
+    if [[ -f "$output" ]]; then
+        backup_file "$output"
+    fi
+
+    local subst_args=()
+    local block_args=()
+    while IFS='=' read -r key value; do
+        [[ -n "$key" ]] || continue
+        if [[ "$value" == __BLOCK__:* ]]; then
+            block_args+=("${key}=${value}")
+        else
+            subst_args+=("${key}=${value}")
+        fi
+    done <<< "$metadata"
+
+    template_substitute "$template" "$output" "${subst_args[@]}"
+
+    if grep -q '{{#' "$output" 2>/dev/null && [[ ${#block_args[@]} -gt 0 ]]; then
+        template_substitute_blocks "$output" "${block_args[@]}"
+    fi
+
+    # Strip any remaining block markers (keep content between them)
+    strip_block_markers "$output"
+
+    log_success "Generated: COMPONENT.md"
+}
+
+# Generate UI_STYLE.md from template with variable substitution (single-line + block)
+# Args: PROJECT_DIR TEMPLATE_NAME ATOOL_ROOT METADATA
+generate_ui_style_md() {
+    local project_dir="$1" template_name="$2" atool_root="$3" metadata="$4"
+    local template="$atool_root/templates/UI_STYLE.md.${template_name}"
+    local output="$project_dir/UI_STYLE.md"
+
+    if [[ ! -f "$template" ]]; then
+        log_warn "UI_STYLE template not found: $template"
+        return 1
+    fi
+
+    if [[ -f "$output" ]]; then
+        backup_file "$output"
+    fi
+
+    local subst_args=()
+    local block_args=()
+    while IFS='=' read -r key value; do
+        [[ -n "$key" ]] || continue
+        if [[ "$value" == __BLOCK__:* ]]; then
+            block_args+=("${key}=${value}")
+        else
+            subst_args+=("${key}=${value}")
+        fi
+    done <<< "$metadata"
+
+    template_substitute "$template" "$output" "${subst_args[@]}"
+
+    if grep -q '{{#' "$output" 2>/dev/null && [[ ${#block_args[@]} -gt 0 ]]; then
+        template_substitute_blocks "$output" "${block_args[@]}"
+    fi
+
+    # Strip any remaining block markers (keep content between them)
+    strip_block_markers "$output"
+
+    log_success "Generated: UI_STYLE.md"
+}