|
320 | 320 | with open(os.environ['SPECKIT_REGISTRY']) as f: |
321 | 321 | data = json.load(f) |
322 | 322 | presets = data.get('presets', {}) |
323 | | - for pid, meta in sorted(presets.items(), key=lambda x: x[1].get('priority', 10)): |
324 | | - print(pid) |
| 323 | + for pid, meta in sorted(presets.items(), key=lambda x: x[1].get('priority', 10) if isinstance(x[1], dict) else 10): |
| 324 | + if isinstance(meta, dict) and meta.get('enabled', True) is not False: |
| 325 | + print(pid) |
325 | 326 | except Exception: |
326 | 327 | sys.exit(1) |
327 | 328 | " 2>/dev/null); then |
@@ -373,3 +374,225 @@ except Exception: |
373 | 374 | return 1 |
374 | 375 | } |
375 | 376 |
|
| 377 | +# Resolve a template name to composed content using composition strategies. |
| 378 | +# Reads strategy metadata from preset manifests and composes content |
| 379 | +# from multiple layers using prepend, append, or wrap strategies. |
| 380 | +# |
| 381 | +# Usage: CONTENT=$(resolve_template_content "template-name" "$REPO_ROOT") |
| 382 | +# Returns composed content string on stdout; exit code 1 if not found. |
| 383 | +resolve_template_content() { |
| 384 | + local template_name="$1" |
| 385 | + local repo_root="$2" |
| 386 | + local base="$repo_root/.specify/templates" |
| 387 | + |
| 388 | + # Collect all layers (highest priority first) |
| 389 | + local -a layer_paths=() |
| 390 | + local -a layer_strategies=() |
| 391 | + |
| 392 | + # Priority 1: Project overrides (always "replace") |
| 393 | + local override="$base/overrides/${template_name}.md" |
| 394 | + if [ -f "$override" ]; then |
| 395 | + layer_paths+=("$override") |
| 396 | + layer_strategies+=("replace") |
| 397 | + fi |
| 398 | + |
| 399 | + # Priority 2: Installed presets (sorted by priority from .registry) |
| 400 | + local presets_dir="$repo_root/.specify/presets" |
| 401 | + if [ -d "$presets_dir" ]; then |
| 402 | + local registry_file="$presets_dir/.registry" |
| 403 | + local sorted_presets="" |
| 404 | + if [ -f "$registry_file" ] && command -v python3 >/dev/null 2>&1; then |
| 405 | + if sorted_presets=$(SPECKIT_REGISTRY="$registry_file" python3 -c " |
| 406 | +import json, sys, os |
| 407 | +try: |
| 408 | + with open(os.environ['SPECKIT_REGISTRY']) as f: |
| 409 | + data = json.load(f) |
| 410 | + presets = data.get('presets', {}) |
| 411 | + for pid, meta in sorted(presets.items(), key=lambda x: x[1].get('priority', 10) if isinstance(x[1], dict) else 10): |
| 412 | + if isinstance(meta, dict) and meta.get('enabled', True) is not False: |
| 413 | + print(pid) |
| 414 | +except Exception: |
| 415 | + sys.exit(1) |
| 416 | +" 2>/dev/null); then |
| 417 | + if [ -n "$sorted_presets" ]; then |
| 418 | + local yaml_warned=false |
| 419 | + while IFS= read -r preset_id; do |
| 420 | + # Read strategy and file path from preset manifest |
| 421 | + local strategy="replace" |
| 422 | + local manifest_file="" |
| 423 | + local manifest="$presets_dir/$preset_id/preset.yml" |
| 424 | + if [ -f "$manifest" ] && command -v python3 >/dev/null 2>&1; then |
| 425 | + # Requires PyYAML; falls back to replace/convention if unavailable |
| 426 | + local result |
| 427 | + local py_stderr |
| 428 | + py_stderr=$(mktemp) |
| 429 | + result=$(SPECKIT_MANIFEST="$manifest" SPECKIT_TMPL="$template_name" python3 -c " |
| 430 | +import sys, os |
| 431 | +try: |
| 432 | + import yaml |
| 433 | +except ImportError: |
| 434 | + print('yaml_missing', file=sys.stderr) |
| 435 | + print('replace\t') |
| 436 | + sys.exit(0) |
| 437 | +try: |
| 438 | + with open(os.environ['SPECKIT_MANIFEST']) as f: |
| 439 | + data = yaml.safe_load(f) |
| 440 | + for t in data.get('provides', {}).get('templates', []): |
| 441 | + if t.get('name') == os.environ['SPECKIT_TMPL'] and t.get('type', 'template') == 'template': |
| 442 | + print(t.get('strategy', 'replace') + '\t' + t.get('file', '')) |
| 443 | + sys.exit(0) |
| 444 | + print('replace\t') |
| 445 | +except Exception: |
| 446 | + print('replace\t') |
| 447 | +" 2>"$py_stderr") |
| 448 | + local parse_status=$? |
| 449 | + if [ $parse_status -eq 0 ] && [ -n "$result" ]; then |
| 450 | + IFS=$'\t' read -r strategy manifest_file <<< "$result" |
| 451 | + strategy=$(printf '%s' "$strategy" | tr '[:upper:]' '[:lower:]') |
| 452 | + fi |
| 453 | + if [ "$yaml_warned" = false ] && grep -q 'yaml_missing' "$py_stderr" 2>/dev/null; then |
| 454 | + echo "Warning: PyYAML not available; composition strategies may be ignored" >&2 |
| 455 | + yaml_warned=true |
| 456 | + fi |
| 457 | + rm -f "$py_stderr" |
| 458 | + fi |
| 459 | + # Try manifest file path first, then convention path |
| 460 | + local candidate="" |
| 461 | + if [ -n "$manifest_file" ]; then |
| 462 | + # Reject absolute paths and parent traversal |
| 463 | + case "$manifest_file" in |
| 464 | + /*|*../*|../*) manifest_file="" ;; |
| 465 | + esac |
| 466 | + fi |
| 467 | + if [ -n "$manifest_file" ]; then |
| 468 | + local mf="$presets_dir/$preset_id/$manifest_file" |
| 469 | + [ -f "$mf" ] && candidate="$mf" |
| 470 | + fi |
| 471 | + if [ -z "$candidate" ]; then |
| 472 | + local cf="$presets_dir/$preset_id/templates/${template_name}.md" |
| 473 | + [ -f "$cf" ] && candidate="$cf" |
| 474 | + fi |
| 475 | + if [ -n "$candidate" ]; then |
| 476 | + layer_paths+=("$candidate") |
| 477 | + layer_strategies+=("$strategy") |
| 478 | + fi |
| 479 | + done <<< "$sorted_presets" |
| 480 | + fi |
| 481 | + else |
| 482 | + # python3 failed — fall back to unordered directory scan (replace only) |
| 483 | + for preset in "$presets_dir"/*/; do |
| 484 | + [ -d "$preset" ] || continue |
| 485 | + local candidate="$preset/templates/${template_name}.md" |
| 486 | + if [ -f "$candidate" ]; then |
| 487 | + layer_paths+=("$candidate") |
| 488 | + layer_strategies+=("replace") |
| 489 | + fi |
| 490 | + done |
| 491 | + fi |
| 492 | + else |
| 493 | + # No python3 or registry — fall back to unordered directory scan (replace only) |
| 494 | + for preset in "$presets_dir"/*/; do |
| 495 | + [ -d "$preset" ] || continue |
| 496 | + local candidate="$preset/templates/${template_name}.md" |
| 497 | + if [ -f "$candidate" ]; then |
| 498 | + layer_paths+=("$candidate") |
| 499 | + layer_strategies+=("replace") |
| 500 | + fi |
| 501 | + done |
| 502 | + fi |
| 503 | + fi |
| 504 | + |
| 505 | + # Priority 3: Extension-provided templates (always "replace") |
| 506 | + local ext_dir="$repo_root/.specify/extensions" |
| 507 | + if [ -d "$ext_dir" ]; then |
| 508 | + for ext in "$ext_dir"/*/; do |
| 509 | + [ -d "$ext" ] || continue |
| 510 | + case "$(basename "$ext")" in .*) continue;; esac |
| 511 | + local candidate="$ext/templates/${template_name}.md" |
| 512 | + if [ -f "$candidate" ]; then |
| 513 | + layer_paths+=("$candidate") |
| 514 | + layer_strategies+=("replace") |
| 515 | + fi |
| 516 | + done |
| 517 | + fi |
| 518 | + |
| 519 | + # Priority 4: Core templates (always "replace") |
| 520 | + local core="$base/${template_name}.md" |
| 521 | + if [ -f "$core" ]; then |
| 522 | + layer_paths+=("$core") |
| 523 | + layer_strategies+=("replace") |
| 524 | + fi |
| 525 | + |
| 526 | + local count=${#layer_paths[@]} |
| 527 | + [ "$count" -eq 0 ] && return 1 |
| 528 | + |
| 529 | + # Check if any layer uses a non-replace strategy |
| 530 | + local has_composition=false |
| 531 | + for s in "${layer_strategies[@]}"; do |
| 532 | + [ "$s" != "replace" ] && has_composition=true && break |
| 533 | + done |
| 534 | + |
| 535 | + # If the top (highest-priority) layer is replace, it wins entirely — |
| 536 | + # lower layers are irrelevant regardless of their strategies. |
| 537 | + if [ "${layer_strategies[0]}" = "replace" ]; then |
| 538 | + cat "${layer_paths[0]}" |
| 539 | + return 0 |
| 540 | + fi |
| 541 | + |
| 542 | + if [ "$has_composition" = false ]; then |
| 543 | + cat "${layer_paths[0]}" |
| 544 | + return 0 |
| 545 | + fi |
| 546 | + |
| 547 | + # Find the effective base: scan from highest priority (index 0) downward |
| 548 | + # to find the nearest replace layer. Only compose layers above that base. |
| 549 | + local base_idx=-1 |
| 550 | + local i |
| 551 | + for (( i=0; i<count; i++ )); do |
| 552 | + if [ "${layer_strategies[$i]}" = "replace" ]; then |
| 553 | + base_idx=$i |
| 554 | + break |
| 555 | + fi |
| 556 | + done |
| 557 | + |
| 558 | + if [ $base_idx -lt 0 ]; then |
| 559 | + return 1 # no base layer found |
| 560 | + fi |
| 561 | + |
| 562 | + # Read the base content; compose layers above the base (higher priority) |
| 563 | + local content |
| 564 | + content=$(cat "${layer_paths[$base_idx]}"; printf x) |
| 565 | + content="${content%x}" |
| 566 | + |
| 567 | + for (( i=base_idx-1; i>=0; i-- )); do |
| 568 | + local path="${layer_paths[$i]}" |
| 569 | + local strat="${layer_strategies[$i]}" |
| 570 | + local layer_content |
| 571 | + # Preserve trailing newlines |
| 572 | + layer_content=$(cat "$path"; printf x) |
| 573 | + layer_content="${layer_content%x}" |
| 574 | + |
| 575 | + case "$strat" in |
| 576 | + replace) content="$layer_content" ;; |
| 577 | + prepend) content="$(printf '%s\n\n%s' "$layer_content" "$content")" ;; |
| 578 | + append) content="$(printf '%s\n\n%s' "$content" "$layer_content")" ;; |
| 579 | + wrap) |
| 580 | + case "$layer_content" in |
| 581 | + *'{CORE_TEMPLATE}'*) ;; |
| 582 | + *) echo "Error: wrap strategy missing {CORE_TEMPLATE} placeholder" >&2; return 1 ;; |
| 583 | + esac |
| 584 | + while [[ "$layer_content" == *'{CORE_TEMPLATE}'* ]]; do |
| 585 | + local before="${layer_content%%\{CORE_TEMPLATE\}*}" |
| 586 | + local after="${layer_content#*\{CORE_TEMPLATE\}}" |
| 587 | + layer_content="${before}${content}${after}" |
| 588 | + done |
| 589 | + content="$layer_content" |
| 590 | + ;; |
| 591 | + *) echo "Error: unknown strategy '$strat'" >&2; return 1 ;; |
| 592 | + esac |
| 593 | + done |
| 594 | + |
| 595 | + printf '%s' "$content" |
| 596 | + return 0 |
| 597 | +} |
| 598 | + |
0 commit comments