Improve build test artifact detection and cmake package install

- Prefer simple artifact filenames (1 dot) over versioned ones in link.txt
- Derive link targets from artifacts instead of raw cmake target names
- Enable package_install for static/shared/cshared cmake libraries so
  cmake --install runs and places artifacts properly
- Detect generated headers in build dir and inform user about package_install
- Make --debug conditional on debug flag in build test commands
- Use --dest to place ce_install staging in wizard temp directory
- Preserve temp directory on build test failure for debugging
- Search all staging dirs for artifacts, warn about empty ones
- Abort on missing link libraries instead of creating PRs

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: partouf

cli/main.py

@@ -123,6 +123,12 @@ def process_cpp_library(
                         build_result = cpp_handler.run_build_test(library_id, config.version)
                         if not build_result.success:
                             click.echo("❌ Build test failed.", err=True)
+                            if build_result.staging_dir:
+                                git_mgr.keep_temp = True
+                                click.echo(
+                                    f"   Build directory: {build_result.staging_dir}",
+                                    err=True,
+                                )
                             if is_auto_mode:
                                 click.echo(
                                     "   💡 Hint: Use --build-test=no to skip build testing "
@@ -143,6 +149,14 @@ def process_cpp_library(
                                     f"  ⚠️  Missing: {', '.join(build_result.missing_links)}",
                                     err=True,
                                 )
+                                if build_result.staging_dir:
+                                    git_mgr.keep_temp = True
+                                    click.echo(
+                                        f"   Build directory: {build_result.staging_dir}",
+                                        err=True,
+                                    )
+                                click.echo("Aborting.", err=True)
+                                return
 
             # Show diffs if verify or dry_run flag is set
             if verify or dry_run:
@@ -292,6 +306,12 @@ def process_rust_library(
                         build_result = rust_handler.run_build_test(config.name, config.version)
                         if not build_result.success:
                             click.echo("❌ Build test failed.", err=True)
+                            if build_result.staging_dir:
+                                git_mgr.keep_temp = True
+                                click.echo(
+                                    f"   Build directory: {build_result.staging_dir}",
+                                    err=True,
+                                )
                             if is_auto_mode:
                                 click.echo(
                                     "   💡 Hint: Use --build-test=no to skip build testing "
@@ -460,6 +480,12 @@ def process_c_library(
                         build_result = c_handler.run_build_test(library_id, config.version)
                         if not build_result.success:
                             click.echo("❌ Build test failed.", err=True)
+                            if build_result.staging_dir:
+                                git_mgr.keep_temp = True
+                                click.echo(
+                                    f"   Build directory: {build_result.staging_dir}",
+                                    err=True,
+                                )
                             if is_auto_mode:
                                 click.echo(
                                     "   💡 Hint: Use --build-test=no to skip build testing "
@@ -480,6 +506,14 @@ def process_c_library(
                                     f"  ⚠️  Missing: {', '.join(build_result.missing_links)}",
                                     err=True,
                                 )
+                                if build_result.staging_dir:
+                                    git_mgr.keep_temp = True
+                                    click.echo(
+                                        f"   Build directory: {build_result.staging_dir}",
+                                        err=True,
+                                    )
+                                click.echo("Aborting.", err=True)
+                                return
 
             # Show diffs if verify or dry_run flag is set
             if verify or dry_run:
@@ -800,6 +834,12 @@ def process_fortran_library(
                         build_result = fortran_handler.run_build_test(library_id, config.version)
                         if not build_result.success:
                             click.echo("❌ Build test failed.", err=True)
+                            if build_result.staging_dir:
+                                git_mgr.keep_temp = True
+                                click.echo(
+                                    f"   Build directory: {build_result.staging_dir}",
+                                    err=True,
+                                )
                             if is_auto_mode:
                                 click.echo(
                                     "   💡 Hint: Use --build-test=no to skip build testing "
@@ -989,6 +1029,12 @@ def process_go_library(
                         build_result = go_handler.run_build_test(library_id, config.version)
                         if not build_result.success:
                             click.echo("Build test failed.", err=True)
+                            if build_result.staging_dir:
+                                git_mgr.keep_temp = True
+                                click.echo(
+                                    f"   Build directory: {build_result.staging_dir}",
+                                    err=True,
+                                )
                             if is_auto_mode:
                                 click.echo(
                                     "   Hint: Use --build-test=no to skip build testing "
@@ -1264,13 +1310,20 @@ def main(
                             exit(1)
 
                 # Set package install based on type and flag
-                if config.library_type == LibraryType.PACKAGED_HEADERS:
-                    # packaged-headers always uses package installation
+                if config.library_type in (
+                    LibraryType.PACKAGED_HEADERS,
+                    LibraryType.STATIC,
+                    LibraryType.SHARED,
+                    LibraryType.CSHARED,
+                ):
                     config.package_install = True
-                    click.echo("✓ Using CMake package installation (default for packaged-headers)")
+                    click.echo(
+                        f"✓ Using CMake package installation"
+                        f" (default for {config.library_type.value})"
+                    )
                 elif package_install:
                     config.package_install = True
-                    click.echo("✓ Using CMake package installation for headers")
+                    click.echo("✓ Using CMake package installation")
 
                 config.validate_versions_and_exit_on_missing()
         else:

core/build_tester.py

@@ -257,12 +257,17 @@ def get_latest_compiler(
 
 
 def _find_staging_dirs(output: str) -> list[str]:
-    """Extract staging directory paths from build output."""
-    # Pattern: /tmp/ce-cefs-temp/staging/<uuid>
-    pattern = r"/tmp/ce-cefs-temp/staging/[a-f0-9-]+"
-    matches = re.findall(pattern, output)
-    # Return unique paths
-    return list(set(matches))
+    """Extract staging directory paths from build output.
+
+    Returns unique paths, preferring directories that contain an install/
+    subdirectory or build artifacts over empty ones.
+    """
+    # Pattern: <any-path>/staging/<uuid>
+    pattern = r"/\S+/staging/[a-f0-9-]+"
+    matches = list(set(re.findall(pattern, output)))
+    # Sort so dirs with content (install/ or any subdirs) come first
+    matches.sort(key=lambda d: (not Path(d, "install").exists(), d))
+    return matches
 
 
 def _list_artifacts(install_dir: Path) -> list[str]:
@@ -424,11 +429,13 @@ def run_build_test(
         library_spec = f"libraries/{language}/{library_id} {version}"
 
         # Build the command
-        # Command: bin/ce_install --debug --dry-run --keep-staging --force-traditional build
-        #          --temp-install --buildfor <compiler_id> '<library_spec>'
+        # bin/ce_install [--debug] --dry-run --dest <dir> --keep-staging
+        # --force-traditional build --temp-install --buildfor <id> '<spec>'
+        dest_path = str(infra_path.parent / "build-test")
         subcommand = [
-            "--debug",
             "--dry-run",
+            "--dest",
+            dest_path,
             "--keep-staging",
             "--force-traditional",
             "build",
@@ -437,6 +444,8 @@ def run_build_test(
             compiler_id,
             library_spec,
         ]
+        if debug:
+            subcommand.insert(0, "--debug")
 
         logger.info(f"Running build test for {library_id} {version} with {compiler_id}...")
         logger.info(f"Command: bin/ce_install {' '.join(subcommand)}")
@@ -445,29 +454,53 @@ def run_build_test(
 
         output = f"{result.stdout}\n{result.stderr}".strip()
 
+        # Parse staging directories from output
+        staging_dirs = _find_staging_dirs(output)
+        staging_dir = staging_dirs[0] if staging_dirs else None
+
         if result.returncode != 0:
             logger.error(f"Build test failed with exit code {result.returncode}")
+            if staging_dir:
+                logger.error(f"Build directory preserved at: {staging_dir}")
             if debug:
                 logger.debug(f"Output: {output}")
             return BuildTestResult(
                 success=False,
                 message=f"Build test failed: {output}",
                 compiler_id=compiler_id,
+                staging_dir=staging_dir,
             )
-
-        # Parse staging directories from output
-        staging_dirs = _find_staging_dirs(output)
-        staging_dir = staging_dirs[0] if staging_dirs else None
         install_dir = None
         artifacts: list[str] = []
 
-        if staging_dir:
-            # Check for install directory
-            install_path = Path(staging_dir) / "install"
+        # Search all staging dirs for artifacts
+        for sdir in staging_dirs:
+            staging_path = Path(sdir)
+            # Check for install directory (used when package_install is set)
+            install_path = staging_path / "install"
             if install_path.exists():
-                install_dir = str(install_path)
-                artifacts = _list_artifacts(install_path)
-                logger.info(f"Found {len(artifacts)} artifacts in {install_dir}")
+                found = _list_artifacts(install_path)
+                if found:
+                    install_dir = str(install_path)
+                    artifacts = found
+                    logger.info(f"Found {len(found)} artifacts in {install_dir}")
+                else:
+                    logger.warning(f"Empty install directory in {sdir}")
+                continue
+            # Fall back to searching build subdirs (no package_install)
+            found_in_subdir = False
+            for subdir in sorted(staging_path.iterdir()):
+                if subdir.is_dir():
+                    found = _list_artifacts(subdir)
+                    if found:
+                        if not artifacts:
+                            install_dir = str(subdir)
+                            artifacts = found
+                        logger.info(f"Found {len(found)} artifacts in {subdir}")
+                        found_in_subdir = True
+                        break
+            if not found_in_subdir:
+                logger.warning(f"No build artifacts found in {sdir}")
 
         # Verify link libraries
         static_links, shared_links = _get_expected_link_libraries(infra_path, library_id, language)
@@ -716,9 +749,11 @@ def run_rust_build_test(
         library_spec = f"libraries/rust/{crate_name} {version}"
 
         # Build the command
+        dest_path = str(infra_path.parent / "build-test")
         subcommand = [
-            "--debug",
             "--dry-run",
+            "--dest",
+            dest_path,
             "--keep-staging",
             "--force-traditional",
             "build",
@@ -727,6 +762,8 @@ def run_rust_build_test(
             compiler_id,
             library_spec,
         ]
+        if debug:
+            subcommand.insert(0, "--debug")
 
         logger.info(f"Running Rust build test for {crate_name} {version} with {compiler_id}...")
         logger.info(f"Command: bin/ce_install {' '.join(subcommand)}")
@@ -979,8 +1016,10 @@ def run_fortran_build_test(
 
         # Build the command - note: we can't use --dry-run for fpm libraries
         # as they need to be "installed" (source extracted) to verify
+        dest_path = str(infra_path.parent / "build-test")
         subcommand = [
-            "--debug",
+            "--dest",
+            dest_path,
             "--keep-staging",
             "--force-traditional",
             "build",
@@ -989,6 +1028,8 @@ def run_fortran_build_test(
             compiler_id,
             library_spec,
         ]
+        if debug:
+            subcommand.insert(0, "--debug")
 
         logger.info(f"Running Fortran build test for {library_id} {version}...")
         logger.info(f"Command: bin/ce_install {' '.join(subcommand)}")
@@ -1224,8 +1265,10 @@ def run_go_build_test(
         library_spec = f"libraries/go/{library_id} {version}"
 
         # Build the command
+        dest_path = str(infra_path.parent / "build-test")
         subcommand = [
-            "--debug",
+            "--dest",
+            dest_path,
             "--keep-staging",
             "--force-traditional",
             "build",
@@ -1234,6 +1277,8 @@ def run_go_build_test(
             compiler_id,
             library_spec,
         ]
+        if debug:
+            subcommand.insert(0, "--debug")
 
         logger.info(f"Running Go build test for {library_id} {version} with {compiler_id}...")
         logger.info(f"Command: bin/ce_install {' '.join(subcommand)}")