Detect bun test via package.json scripts matcher

src/Ivy.StackAnalyzer.Test/RuleEngineTests.cs

@@ -13,7 +13,8 @@ private static ComponentContext Ctx(
         IEnumerable<string>? fileNames = null,
         IEnumerable<string>? sdks = null,
         IEnumerable<string>? extensions = null,
-        IEnumerable<string>? envVars = null)
+        IEnumerable<string>? envVars = null,
+        IEnumerable<string>? scripts = null)
     {
         var names = (fileNames ?? []).ToHashSet(StringComparer.OrdinalIgnoreCase);
         return new ComponentContext
@@ -30,6 +31,7 @@ private static ComponentContext Ctx(
             FilePaths = names.Select(n => "apps/web/" + n).ToHashSet(StringComparer.Ordinal),
             Extensions = (extensions ?? []).ToHashSet(StringComparer.OrdinalIgnoreCase),
             EnvVarNames = (envVars ?? []).ToHashSet(StringComparer.OrdinalIgnoreCase),
+            Scripts = (scripts ?? []).ToHashSet(StringComparer.OrdinalIgnoreCase),
         };
     }
 
@@ -46,6 +48,24 @@ public void Detects_framework_by_dependency()
         Assert.Contains(result, t => t.Name == "React" && t.Category == TechCategory.Framework);
     }
 
+    [Theory]
+    [InlineData("bun test")]
+    [InlineData("bun test --coverage")]
+    public void Detects_bun_test_from_package_json_script(string command)
+    {
+        var engine = new RuleEngine(Data);
+        var result = engine.Detect(Ctx(scripts: [command]));
+        Assert.Contains(result, t => t.Name == "bun test" && t.Category == TechCategory.Testing);
+    }
+
+    [Fact]
+    public void Does_not_detect_bun_test_from_unrelated_script()
+    {
+        var engine = new RuleEngine(Data);
+        var result = engine.Detect(Ctx(scripts: ["bun run build", "vitest"]));
+        Assert.DoesNotContain(result, t => t.Name == "bun test");
+    }
+
     [Fact]
     public void Supersedes_hides_subsumed_framework()
     {

src/Ivy.StackAnalyzer.Test/Snapshots/django-spa.verified.yaml

@@ -151,6 +151,6 @@ readme:
     in `frontend/`.
 metadata:
   analyzerVersion: 0.1.0
-  rulesLoaded: 759
+  rulesLoaded: 760
   languageDefsLoaded: 815
   ignoredDirectories: []

src/Ivy.StackAnalyzer.Test/Snapshots/go-service.verified.yaml

@@ -62,6 +62,6 @@ infrastructure:
   - Dockerfile
 metadata:
   analyzerVersion: 0.1.0
-  rulesLoaded: 759
+  rulesLoaded: 760
   languageDefsLoaded: 815
   ignoredDirectories: []

src/Ivy.StackAnalyzer.Test/Snapshots/next-dotnet-monorepo.verified.yaml

@@ -220,6 +220,6 @@ readme:
     backed by Postgres.
 metadata:
   analyzerVersion: 0.1.0
-  rulesLoaded: 759
+  rulesLoaded: 760
   languageDefsLoaded: 815
   ignoredDirectories: []

src/Ivy.StackAnalyzer.Test/Snapshots/numpy-style-lib.verified.yaml

@@ -53,6 +53,6 @@ technologies:
 infrastructure: []
 metadata:
   analyzerVersion: 0.1.0
-  rulesLoaded: 759
+  rulesLoaded: 760
   languageDefsLoaded: 815
   ignoredDirectories: []

src/Ivy.StackAnalyzer/Components/ComponentContext.cs

@@ -39,4 +39,8 @@ public sealed class ComponentContext
 
     /// <summary>Environment-variable names discovered in <c>.env*</c> files.</summary>
     public IReadOnlySet<string> EnvVarNames { get; init; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>Run-script command strings across this component's manifests (e.g. <c>package.json</c>
+    /// <c>scripts</c> values). Used to detect tools invoked only via a script, such as <c>bun test</c>.</summary>
+    public IReadOnlySet<string> Scripts { get; init; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 }

src/Ivy.StackAnalyzer/Components/ComponentDetector.cs

@@ -111,6 +111,7 @@ public IReadOnlyList<ComponentContext> Detect(IReadOnlyList<ClassifiedFile> file
                 FilePaths = filePaths,
                 Extensions = extensions,
                 EnvVarNames = ReadEnvVarNames(compFiles),
+                Scripts = manifests.SelectMany(m => m.Scripts).ToHashSet(StringComparer.OrdinalIgnoreCase),
             });
         }
 

src/Ivy.StackAnalyzer/Detection/RuleEngine.cs

@@ -123,6 +123,14 @@ public IReadOnlyList<DetectedTechnology> Detect(ComponentContext ctx)
             if (ctx.Extensions.Contains(ext)) evidence.Add($"*{ext}");
         }
 
+        // Run-script commands (e.g. package.json scripts.test = "bun test")
+        foreach (var sr in m.ScriptsRegex)
+        {
+            var rx = GetRegex(sr);
+            var hit = ctx.Scripts.FirstOrDefault(s => rx.IsMatch(s));
+            if (hit is not null) evidence.Add($"script '{hit}'");
+        }
+
         // Every facet above is a strong signal; dotenv (below) is weak.
         bool strong = evidence.Count > 0;
 

src/Ivy.StackAnalyzer/Manifests/IManifestParser.cs

@@ -14,6 +14,10 @@ public sealed record ParsedManifest
     /// <summary>Workspace member globs declared here (npm/pnpm/cargo/etc.), if any.</summary>
     public IReadOnlyList<string> Workspaces { get; init; } = [];
 
+    /// <summary>Run-script command strings declared here (e.g. <c>package.json</c> <c>scripts</c>
+    /// values like <c>"bun test"</c>). Lets the rule engine detect tools invoked only via a script.</summary>
+    public IReadOnlyList<string> Scripts { get; init; } = [];
+
     /// <summary>MSBuild <c>Sdk</c> attribute for <c>*.csproj</c> / <c>*.fsproj</c>.</summary>
     public string? Sdk { get; init; }
 

src/Ivy.StackAnalyzer/Manifests/NpmParser.cs

@@ -12,6 +12,7 @@ public ParsedManifest Parse(string relativePath, string content)
     {
         var deps = new List<Dependency>();
         var workspaces = new List<string>();
+        var scripts = new List<string>();
         try
         {
             using var doc = JsonDocument.Parse(content, new JsonDocumentOptions
@@ -25,6 +26,11 @@ public ParsedManifest Parse(string relativePath, string content)
             ReadDeps(root, "peerDependencies", DependencyScope.Peer, deps);
             ReadDeps(root, "optionalDependencies", DependencyScope.Optional, deps);
 
+            if (root.TryGetProperty("scripts", out var sc) && sc.ValueKind == JsonValueKind.Object)
+                foreach (var s in sc.EnumerateObject())
+                    if (s.Value.ValueKind == JsonValueKind.String && s.Value.GetString() is { Length: > 0 } cmd)
+                        scripts.Add(cmd);
+
             if (root.TryGetProperty("workspaces", out var ws))
             {
                 if (ws.ValueKind == JsonValueKind.Array)
@@ -44,6 +50,7 @@ public ParsedManifest Parse(string relativePath, string content)
             Ecosystem = "npm",
             Dependencies = deps,
             Workspaces = workspaces,
+            Scripts = scripts,
         };
     }
 

src/Ivy.StackAnalyzer/Models/DataModels.cs

@@ -44,6 +44,10 @@ public sealed class MatchSpec
     public List<string> Dotenv { get; set; } = [];
     public List<string> Sdk { get; set; } = [];
     public List<string> PathGlobs { get; set; } = [];
+
+    /// <summary>Regexes matched against run-script command strings (e.g. <c>package.json</c>
+    /// <c>scripts</c> values). Detects tools invoked only via a script, such as <c>bun test</c>.</summary>
+    public List<string> ScriptsRegex { get; set; } = [];
 }
 
 /// <summary>A technology detection rule as loaded from <c>detectors/*.yml</c>.</summary>

src/Ivy.StackAnalyzer/data/detectors/testing.yml

@@ -12,6 +12,14 @@
       - { ecosystem: docker, pattern: cypress }
     filesRegex: ["cypress.config.(js|ts|mjs|cjs)"]
   confidence: high
+- id: bun-test
+  name: bun test
+  category: testing
+  match:
+    # bun's test runner has no dependency or config-file marker; it is wired
+    # through package.json scripts (e.g. "test": "bun test").
+    scriptsRegex: ['\bbun test\b']
+  confidence: high
 - id: go-testing
   name: Go testing
   category: testing