@dtt_siye/atool 1.3.1 → 1.5.0

package/hooks/task-state-tracker

@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+# aTool - hooks/task-state-tracker
+# PostToolUse hook: tracks session-level task state for feedback loop
+# Records: modified files, doc staleness, verification status, pending actions
+# State file: .claude/task-state.json (session-scoped, gitignored)
+
+set -euo pipefail
+
+# Escape string for JSON embedding
+escape_for_json() {
+    local s="$1"
+    s="${s//\\/\\\\}"
+    s="${s//\"/\\\"}"
+    s="${s//$'\n'/\\n}"
+    s="${s//$'\r'/\\r}"
+    s="${s//$'\t'/\\t}"
+    printf '%s' "$s"
+}
+
+# ── Read tool input ───────────────────────────────────────────────────────
+
+INPUT=""
+if [[ ! -t 0 ]]; then
+    INPUT=$(cat)
+fi
+
+TOOL_NAME=""
+FILE_PATH=""
+if command -v jq &>/dev/null && [[ -n "$INPUT" ]]; then
+    TOOL_NAME=$(printf '%s' "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null || echo "")
+    FILE_PATH=$(printf '%s' "$INPUT" | jq -r '.tool_input.file_path // empty' 2>/dev/null || echo "")
+fi
+
+# Only respond to Write/Edit
+if [[ "$TOOL_NAME" != "Write" && "$TOOL_NAME" != "Edit" ]]; then
+    exit 0
+fi
+if [[ -z "$FILE_PATH" ]]; then
+    exit 0
+fi
+
+# ── Source file detection ────────────────────────────────────────────────
+
+FILE_EXT="${FILE_PATH##*.}"
+FILE_BASE=$(basename "$FILE_PATH")
+
+# Skip non-source files (same logic as doc-sync-reminder)
+case "$FILE_EXT" in
+    md|markdown|txt|rst) exit 0 ;;
+    json|yaml|yml|toml|xml) exit 0 ;;
+    css|scss|less|sass|styl) exit 0 ;;
+    lock|map|log) exit 0 ;;
+    svg|png|jpg|jpeg|gif|ico|webp|ttf|woff|woff2|eot) exit 0 ;;
+esac
+case "$FILE_BASE" in
+    .*|*.config.*) exit 0 ;;
+esac
+case "$FILE_EXT" in
+    ts|tsx|js|jsx|vue|svelte|html|rs|py|go|java|kt|kts|swift|dart|ets|sh|bash) ;;
+    *) exit 0 ;;
+esac
+
+# ── State management ──────────────────────────────────────────────────────
+
+# Require jq
+if ! command -v jq &>/dev/null; then
+    exit 0
+fi
+
+NOW=$(date +%s 2>/dev/null || echo "0")
+STATE_FILE=".claude/task-state.json"
+MAX_TRACKED_FILES=50
+
+# Initialize state file if needed
+if [[ ! -f "$STATE_FILE" ]]; then
+    mkdir -p ".claude" 2>/dev/null || true
+    printf '{"session_id":"","modified_files":[],"docs_stale":false,"verification_passed":false,"pending_actions":[],"architecture_violations":0,"created_at":%s,"updated_at":%s}\n' "$NOW" "$NOW" > "$STATE_FILE"
+fi
+
+# Read current state
+STATE=$(cat "$STATE_FILE" 2>/dev/null || echo "{}")
+
+# Update: add file, set docs_stale=true, reset verification, update timestamp
+NEW_STATE=$(printf '%s' "$STATE" | jq \
+    --arg fp "$FILE_PATH" \
+    --argjson now "$NOW" \
+    '
+    # Add file if not already tracked
+    if (.modified_files | map(select(.path == $fp)) | length) == 0 then
+        .modified_files += [{"path": $fp, "modified_at": $now}]
+    else
+        .modified_files = [.modified_files[] | if .path == $fp then .modified_at = $now else . end]
+    end
+    # Cap modified files to 50
+    | .modified_files = (.modified_files | sort_by(-.modified_at) | .[0:50])
+    # Mark docs as stale
+    | .docs_stale = true
+    # Reset verification since we made changes
+    | .verification_passed = false
+    # Ensure pending_actions includes doc update
+    | if (.pending_actions | index("update_docs") | not) then
+        .pending_actions += ["update_docs"]
+      else . end
+    | .updated_at = $now
+    ')
+
+printf '%s' "$NEW_STATE" | jq '.' > "$STATE_FILE" 2>/dev/null || true
+
+# ── Output feedback at milestones ─────────────────────────────────────────
+
+FILE_COUNT=$(jq '.modified_files | length' "$STATE_FILE" 2>/dev/null || echo "0")
+
+_MILESTONE=""
+# Milestone check: for every 5 files >= 10, show progress update
+if (( FILE_COUNT >= 10 && FILE_COUNT % 5 == 0 )); then
+    if (( FILE_COUNT == 10 )); then
+        _MILESTONE="<ATOOL-TASK-PROGRESS>
+Progress check: You have modified ${FILE_COUNT} source files. This is substantial.
+- Consider breaking your work into smaller, verifiable units
+- Docs are STALE and need updating
+- Run /verification-before-completion before claiming done
+</ATOOL-TASK-PROGRESS>"
+    else
+        _MILESTONE="<ATOOL-TASK-PROGRESS>
+Progress check: You have modified ${FILE_COUNT} source files.
+- This is a large refactoring. Consider intermediate commits/verification
+- Docs are STALE and need updating
+- Run /verification-before-completion to validate progress
+</ATOOL-TASK-PROGRESS>"
+    fi
+elif (( FILE_COUNT == 5 )); then
+    _MILESTONE="<ATOOL-TASK-PROGRESS>
+Progress check: You have modified ${FILE_COUNT} source files.
+- Docs are STALE and need updating
+- Verification has NOT been run since last changes
+Remember: Run /verification-before-completion before claiming done.
+</ATOOL-TASK-PROGRESS>"
+fi
+
+if [[ -n "$_MILESTONE" ]]; then
+    _ESCAPED=$(escape_for_json "$_MILESTONE")
+    printf '{"hookSpecificOutput":{"hookEventName":"PostToolUse","additionalContext":"%s"}}\n' "$_ESCAPED"
+fi
+
+exit 0

package/install.sh

@@ -77,12 +77,22 @@ parse_args() {
                 shift
                 ;;
             --project)
-                PROJECT_PATH="$2"
-                shift 2
+                if [[ $# -ge 2 && ! "$2" =~ ^-- ]]; then
+                    PROJECT_PATH="$2"
+                    shift 2
+                else
+                    PROJECT_PATH="."
+                    shift
+                fi
                 ;;
             --analyze)
-                ANALYZE_PROJECT="$2"
-                shift 2
+                if [[ $# -ge 2 && ! "$2" =~ ^-- ]]; then
+                    ANALYZE_PROJECT="$2"
+                    shift 2
+                else
+                    ANALYZE_PROJECT="."
+                    shift
+                fi
                 ;;
             --uninstall)
                 do_uninstall

package/lib/common.sh

@@ -140,11 +140,9 @@ ensure_dir() {
 # ── IDE Config Directory Helpers (cross-platform) ─────────────────────────────
 
 get_claude_config_dir() {
-    if is_windows && [[ -n "${APPDATA:-}" ]]; then
-        cygpath -u "$APPDATA/claude" 2>/dev/null || echo "$HOME/.claude"
-    else
-        echo "$HOME/.claude"
-    fi
+    # Claude Code CLI always uses ~/.claude/ on all platforms
+    # (APPDATA/claude is the Claude Desktop app, not the CLI)
+    echo "$HOME/.claude"
 }
 
 get_cursor_config_dir() {
@@ -861,15 +859,20 @@ scan_skills_catalog() {
                 ;;
             pdf|docx|pptx|xlsx)
                 office="${office}- ${skill_name}: ${desc}
+"
+                ;;
+            # Core initialization
+            atool-init)
+                planning="${planning}- ${skill_name}: ${desc}
 "
                 ;;
             # Architecture & Design
-            software-architecture|ai-project-architecture|ui-ux-pro)
+            software-architecture|ai-project-architecture|ui-ux-pro|architecture-guard)
                 arch_design="${arch_design}- ${skill_name}: ${desc}
 "
                 ;;
             # Quality & Review
-            code-review|project-analyze|project-query|verification-before-completion)
+            code-review|project-analyze|project-query|verification-before-completion|agent-audit)
                 quality_review="${quality_review}- ${skill_name}: ${desc}
 "
                 ;;
@@ -879,8 +882,13 @@ scan_skills_catalog() {
 "
                 ;;
             # Planning & Dispatch
-            writing-plans|smart-dispatch|brainstorming|clarify-before-build)
+            writing-plans|smart-dispatch|brainstorming|clarify-before-build|using-git-worktrees|find-skills)
                 planning="${planning}- ${skill_name}: ${desc}
+"
+                ;;
+            # Testing & Automation
+            webapp-testing|ci-feedback)
+                quality_review="${quality_review}- ${skill_name}: ${desc}
 "
                 ;;
             *)
@@ -890,26 +898,31 @@ scan_skills_catalog() {
         esac
     done
 
-    # Check for Superpowers skills
+    # Check for Superpowers skills (only if Superpowers directory exists and is separate from skills_dir)
     local sp_dir="$skills_dir"
     if [[ -d "$skills_dir/_superpowers/skills" ]]; then
         sp_dir="$skills_dir/_superpowers/skills"
     fi
-    for skill_dir in "$sp_dir"/*/; do
-        [[ ! -d "$skill_dir" ]] && continue
-        local skill_name
-        skill_name=$(basename "$skill_dir")
-        [[ -L "$skill_dir" ]] && continue
-        local sp_md="$skill_dir/SKILL.md"
-        [[ ! -f "$sp_md" ]] && continue
-        local desc=""
-        desc=$(head -10 "$sp_md" | sed -n '/^---$/,/^---$/p' | grep '^description:' | head -1 | sed 's/^description:[[:space:]]*//')
-        if [[ -z "$desc" ]]; then
-            desc=$(head -10 "$sp_md" | grep -i '^#' | head -1 | sed 's/^#*\s*//' || echo "$skill_name")
-        fi
-        superpowers_list="${superpowers_list}- ${skill_name}: ${desc}
+
+    # Only scan Superpowers directory if it exists and is NOT the same as skills_dir
+    # (prevents double-scanning skills already categorized in first loop)
+    if [[ "$sp_dir" != "$skills_dir" ]] && [[ -d "$sp_dir" ]]; then
+        for skill_dir in "$sp_dir"/*/; do
+            [[ ! -d "$skill_dir" ]] && continue
+            local skill_name
+            skill_name=$(basename "$skill_dir")
+            [[ -L "$skill_dir" ]] && continue
+            local sp_md="$skill_dir/SKILL.md"
+            [[ ! -f "$sp_md" ]] && continue
+            local desc=""
+            desc=$(head -10 "$sp_md" | sed -n '/^---$/,/^---$/p' | grep '^description:' | head -1 | sed 's/^description:[[:space:]]*//')
+            if [[ -z "$desc" ]]; then
+                desc=$(head -10 "$sp_md" | grep -i '^#' | head -1 | sed 's/^#*\s*//' || echo "$skill_name")
+            fi
+            superpowers_list="${superpowers_list}- ${skill_name}: ${desc}
 "
-    done
+        done
+    fi
 
     # Output catalog
     if [[ -n "$conventions" ]]; then

package/lib/compute-importance.sh

@@ -591,6 +591,79 @@ compute_importance() {
     rm -rf "$tmpdir"
 }
 
+# === Batch Processing (for pre-scan manifest.json) ===
+
+# Update manifest.json modules array with importance scores
+# Args: MANIFEST_PATH - path to manifest.json
+#       PROJECT_ROOT - project root directory (parent of .atool-docs)
+# Updates: manifest.json modules[].importance field in-place
+compute_importance_batch() {
+    local manifest_path="${1:-.atool-docs/pre-scan/manifest.json}"
+    local project_root="${2:-.}"
+
+    if [[ ! -f "$manifest_path" ]]; then
+        log_error "Manifest not found: $manifest_path"
+        return 1
+    fi
+
+    log_info "Computing importance scores for modules in manifest..."
+
+    # Get inventory directory from project_root
+    local inventory_dir="${project_root}/.atool-docs/inventory"
+
+    # Read modules from manifest
+    local modules_json
+    modules_json=$(jq -r '.modules[] | .slug' "$manifest_path" 2>/dev/null)
+
+    if [[ -z "$modules_json" ]]; then
+        log_warn "No modules found in manifest"
+        return 0
+    fi
+
+    # Build module path map: slug -> importance_score
+    local tmpdir
+    tmpdir=$(mktemp -d)
+
+    # Discover all modules in project and compute importance
+    local all_modules
+    all_modules=$(discover_modules "$project_root")
+
+    if [[ -z "$all_modules" ]]; then
+        log_warn "No source modules found in project"
+        echo "{}" > "$tmpdir/importance_map"
+    else
+        # Compute importance for all discovered modules
+        log_info "Computing importance factors for discovered modules..."
+        local importance_output
+        importance_output=$(compute_importance "$project_root" --inventory-dir "$inventory_dir" 2>/dev/null || true)
+
+        # Build slug-to-importance map from output (module_path<tab>score<tab>tier)
+        # Convert module path to slug: extract last path component
+        {
+            while IFS=$'\t' read -r module_path score tier; do
+                [[ -z "$module_path" ]] && continue
+                local slug
+                slug=$(basename "$module_path")
+                printf '%s\t%s\n' "$slug" "$score"
+            done <<< "$importance_output"
+        } > "$tmpdir/importance_map"
+    fi
+
+    # Update manifest.json with importance scores
+    log_info "Updating manifest with importance scores..."
+    jq --slurpfile importance_data <(cat "$tmpdir/importance_map" | jq -R 'split("\t") | {key: .[0], value: (.[1] | tonumber)}' | jq -s 'from_entries') \
+        '.modules |= map(.importance = ($importance_data[0][.slug] // 0))' \
+        "$manifest_path" > "$tmpdir/manifest_updated.json"
+
+    # Atomically replace manifest
+    mv "$tmpdir/manifest_updated.json" "$manifest_path"
+
+    # Cleanup
+    rm -rf "$tmpdir"
+
+    log_success "Importance scores computed and manifest updated"
+}
+
 # === Standalone Execution ===
 # When run directly (not sourced), execute compute_importance with CLI args
 if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then

package/lib/install-cursor.sh

@@ -79,8 +79,8 @@ should_always_apply() {
         project-analyze)           return 0 ;;
         # Workflow skill with no good glob match - must be always-on
         using-git-worktrees)       return 0 ;;
-        # Conventions skills - always relevant for their file types (via globs too)
-        *-conventions)              return 0 ;;
+        # Conventions skills - globs handle triggering by file type (no need for alwaysApply)
+        *-conventions)              return 1 ;;
         # All other skills: use globs or on-demand (reduces context token consumption)
         *)                          return 1 ;;
     esac
@@ -140,6 +140,28 @@ skill_to_mdc() {
 
     # Append skill content, stripping YAML front matter from source
     awk '/^---$/{n++;next} n<2{next} {print}' "$skill_md" >> "$output_file"
+
+    # Append content from subdirectories (rules/, phases/, references/)
+    local subdirs=("rules" "phases" "references")
+    for subdir in "${subdirs[@]}"; do
+        local subdir_path="$skill_dir/$subdir"
+        if [[ -d "$subdir_path" ]]; then
+            # Sort files by name and append them
+            while IFS= read -r -d '' file; do
+                # Add a header for the file
+                echo "" >> "$output_file"
+                echo "# $(basename "$file")" >> "$output_file"
+                echo "" >> "$output_file"
+
+                # Append file content, only stripping YAML front matter if present
+                if head -n 1 "$file" | grep -q '^---$'; then
+                    awk '/^---$/{n++;next} n<2{next} {print}' "$file" >> "$output_file"
+                else
+                    cat "$file" >> "$output_file"
+                fi
+            done < <(find "$subdir_path" -name "*.md" -type f -print0 | sort -z)
+        fi
+    done
 }
 
 # Generate .mdc rules from skills into a target directory

package/lib/install-hooks.sh

@@ -132,6 +132,58 @@ install_hooks() {
         fi
     fi
 
+    # Install pre-commit hook (PreToolUse - checks before git commit)
+    local pre_commit_src="$atool_root/hooks/pre-commit"
+    if [[ -f "$pre_commit_src" ]]; then
+        local pre_commit_name="atool-pre-commit"
+        local dest_pre_commit="$hooks_dir/$pre_commit_name"
+
+        if [[ -f "$dest_pre_commit" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+            local pc_existing pc_source
+            pc_existing=$(file_checksum "$dest_pre_commit")
+            pc_source=$(file_checksum "$pre_commit_src")
+            if [[ "$pc_existing" == "$pc_source" ]]; then
+                log_info "Hook '$pre_commit_name' already up to date, skipping"
+            else
+                log_info "Hook '$pre_commit_name' exists but differs - backing up"
+                backup_file "$dest_pre_commit"
+                run_cmd cp "$pre_commit_src" "$dest_pre_commit"
+                run_cmd chmod +x "$dest_pre_commit"
+                log_success "Hook installed: $dest_pre_commit"
+            fi
+        else
+            run_cmd cp "$pre_commit_src" "$dest_pre_commit"
+            run_cmd chmod +x "$dest_pre_commit"
+            log_success "Hook installed: $dest_pre_commit"
+        fi
+    fi
+
+    # Install task-state-tracker hook (PostToolUse - tracks session state)
+    local task_state_src="$atool_root/hooks/task-state-tracker"
+    if [[ -f "$task_state_src" ]]; then
+        local task_state_name="atool-task-state-tracker"
+        local dest_task_state="$hooks_dir/$task_state_name"
+
+        if [[ -f "$dest_task_state" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+            local ts_existing ts_source
+            ts_existing=$(file_checksum "$dest_task_state")
+            ts_source=$(file_checksum "$task_state_src")
+            if [[ "$ts_existing" == "$ts_source" ]]; then
+                log_info "Hook '$task_state_name' already up to date, skipping"
+            else
+                log_info "Hook '$task_state_name' exists but differs - backing up"
+                backup_file "$dest_task_state"
+                run_cmd cp "$task_state_src" "$dest_task_state"
+                run_cmd chmod +x "$dest_task_state"
+                log_success "Hook installed: $dest_task_state"
+            fi
+        else
+            run_cmd cp "$task_state_src" "$dest_task_state"
+            run_cmd chmod +x "$dest_task_state"
+            log_success "Hook installed: $dest_task_state"
+        fi
+    fi
+
     # Install hooks config JSON
     local config_file
     case "$ide_type" in
@@ -224,6 +276,18 @@ install_hooks_global() {
                 run_cmd chmod +x "$claude_hooks_dir/atool-doc-sync-reminder"
             fi
 
+            # Copy pre-commit hook (PreToolUse)
+            if [[ -f "$atool_root/hooks/pre-commit" ]]; then
+                run_cmd cp "$atool_root/hooks/pre-commit" "$claude_hooks_dir/atool-pre-commit"
+                run_cmd chmod +x "$claude_hooks_dir/atool-pre-commit"
+            fi
+
+            # Copy task-state-tracker hook (PostToolUse)
+            if [[ -f "$atool_root/hooks/task-state-tracker" ]]; then
+                run_cmd cp "$atool_root/hooks/task-state-tracker" "$claude_hooks_dir/atool-task-state-tracker"
+                run_cmd chmod +x "$claude_hooks_dir/atool-task-state-tracker"
+            fi
+
             # 2. Register hooks config in settings.json
             #    Claude Code reads hooks from settings.json, NOT from files on disk
             local settings_file="$claude_config_dir/settings.json"

package/lib/install-kiro.sh

@@ -112,7 +112,10 @@ get_superpowers_kiro_category() {
 # Args: SKILL_MD_PATH
 # Outputs: condensed content to stdout
 extract_condensed_skill() {
-    local skill_md="$1"
+    local skill_dir="$1"
+    local skill_md="$skill_dir/SKILL.md"
+
+    # First, extract the main SKILL.md content (with YAML frontmatter stripped)
     awk '
     BEGIN { fm = 0 }
     /^---$/ { fm++; next }
@@ -129,6 +132,27 @@ extract_condensed_skill() {
     }
     { print }
     ' "$skill_md"
+
+    # Then append content from subdirectories (rules/, phases/, references/)
+    local subdirs=("rules" "phases" "references")
+    for subdir in "${subdirs[@]}"; do
+        local subdir_path="$skill_dir/$subdir"
+        if [[ -d "$subdir_path" ]]; then
+            # Sort files by name and append them
+            while IFS= read -r -d '' file; do
+                echo ""
+                echo "### $(basename "$file")"
+                echo ""
+
+                # Append file content, only stripping YAML frontmatter if present
+                if head -n 1 "$file" | grep -q '^---$'; then
+                    awk '/^---$/{n++;next} n<2{next} {print}' "$file"
+                else
+                    cat "$file"
+                fi
+            done < <(find "$subdir_path" -name "*.md" -type f -print0 | sort -z)
+        fi
+    done
 }
 
 # Extract ultra-condensed instructions for always-in-context steering
@@ -232,7 +256,7 @@ generate_consolidated_steering() {
                 echo ""
                 echo "## Skill: $skill_name"
                 echo ""
-                $extract_func "$skill_md"
+                $extract_func "$skill_dir"
             } >> "$tmpdir/${category}.txt"
         done
     done

package/lib/install-skills.sh

@@ -122,8 +122,11 @@ install_skills() {
         # Skills reference scripts via "source lib/X.sh" relative to the skill dir
         local skill_lib_dir="$target_skill/lib"
         local referenced_libs
-        referenced_libs=$(find "$target_skill/phases" "$target_skill" -maxdepth 2 -name '*.md' -exec grep -roh 'source lib/[^ ]*\.sh' {} + 2>/dev/null \
-            | sed 's/source lib\///' | sort -u)
+        local _find_paths=()
+        [[ -d "$target_skill/phases" ]] && _find_paths+=("$target_skill/phases")
+        _find_paths+=("$target_skill")
+        referenced_libs=$(find "${_find_paths[@]}" -maxdepth 2 -name '*.md' -exec grep -roh 'source lib/[^ ]*\.sh' {} + 2>/dev/null \
+            | sed 's/source lib\///' | sort -u || true)
         if [[ -n "$referenced_libs" ]]; then
             run_cmd mkdir -p "$skill_lib_dir"
             for lib_name in $referenced_libs; do

package/lib/pre-scan.sh

@@ -1098,7 +1098,19 @@ pre_scan_project() {
         generated_at: (now | todate),
         total_modules: length,
         scan_duration_seconds: null,
-        modules: [.[].module_summary // {} | {total_files, total_classes, total_functions, total_api_endpoints, total_data_models}]
+        modules: [.[] | {
+            slug: .module,
+            name: .module,
+            importance: 0
+        } + (.module_summary // {} | {
+            total_files,
+            total_classes,
+            total_functions,
+            total_api_endpoints,
+            total_data_models
+        })],
+        aggregated_modules: null,
+        aggregated_count: null
     }' "$output_dir"/*.json 2>/dev/null || echo '{}')
 
     # Add duration to manifest

package/lib/project-init.sh

@@ -120,7 +120,14 @@ project_init_single() {
     local atool_root="$2"
 
     local stack
-    stack=$(detect_stack "$project_dir")
+    # Check if stack is specified via environment variable
+    if [[ -n "${ATOOL_STACK:-}" ]]; then
+        stack="$ATOOL_STACK"
+        log_info "Using specified stack: ${BOLD}$stack${NC}"
+    else
+        stack=$(detect_stack "$project_dir")
+    fi
+
     local template_name
     template_name=$(get_template_name "$stack")
     local description
@@ -130,22 +137,34 @@ project_init_single() {
 
     echo ""
     log_info "Detected stack: ${BOLD}$description${NC} (${stack})"
-    log_info "Confidence: ${confidence}%"
+    if [[ -n "${ATOOL_STACK:-}" ]]; then
+        log_info "Stack specified via --stack flag"
+    fi
+    if [[ "$stack" != "generic" ]]; then
+        log_info "Confidence: ${confidence}%"
+    fi
     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
+        if [[ -n "${ATOOL_STACK:-}" ]]; then
+            log_error "Specified stack '$ATOOL_STACK' is not supported."
+            log_info "Available stacks: $(ls "$atool_root/templates" | grep "CLAUDE\." | sed 's/CLAUDE\.//' | sed 's/\.md$//' | tr '\n' ',' | sed 's/,$//')"
+            return 1
+        else
+            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 with --stack <stack-name>"
+                return 0
+            fi
         fi
     else
-        confirm "Use '$description' template?" "Y" || {
+        if ! confirm "Use '$description' template?" "Y"; then
             log_info "Cancelled."
+            log_info "You can specify a different stack with --stack <stack-name>"
             return 0
-        }
+        fi
     fi
 
     # Generate CLAUDE.md

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtt_siye/atool",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "AI Developer Toolkit - 一键配置 AI IDE 的工具集",
   "bin": {
     "atool": "bin/atool.js"