@algolia/wizard 0.8.0-rc.62.50 → 0.8.0-rc.64.51

package/dist/main.js

@@ -907,7 +907,7 @@ var accessItems = [
   {
     tag: "READ",
     title: "Project files",
-    description: "reads your dependency manifests (package.json, pyproject.toml, Gemfile\u2026), configs & source to detect your stack. Read-only; nothing is uploaded."
+    description: "reads your dependency manifests (package.json, pyproject.toml, Gemfile, go.mod, pom.xml\u2026), configs & source to detect your stack. Read-only; nothing is uploaded."
   },
   {
     tag: "WRITE",
@@ -2206,6 +2206,7 @@ function shellQuote(value) {
 // src/lib/languages.ts
 var ENTRYPOINT_TOKEN = "{entrypoint}";
 var INGEST_DIR = ".algolia-wizard";
+var VISIBLE_INGEST_DIR = "algolia-wizard";
 var PY_VENV = `${INGEST_DIR}/.venv`;
 var PY_VENV_PYTHON = `${PY_VENV}/bin/python`;
 var PY_REQUIREMENTS = `${INGEST_DIR}/requirements.txt`;
@@ -2396,6 +2397,187 @@ var LANGUAGE_PROFILES = {
     verification: [],
     envReadInstruction: "Read them from `getenv('NAME')`.",
     skipDirs: ["vendor", "node_modules"]
+  },
+  go: {
+    id: "go",
+    displayName: "Go",
+    aliases: ["go", "golang"],
+    manifests: ["go.mod"],
+    packageManagers: [
+      {
+        id: "gomod",
+        // Imports in the generated file are the declaration; `go mod tidy`
+        // resolves and fetches them — which only works because the script lives
+        // outside INGEST_DIR (see VISIBLE_INGEST_DIR).
+        dependency: { mode: "code-imports" },
+        installSteps: [{ argv: ["go", "mod", "tidy"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["go", "run", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".go"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "github.com/algolia/algoliasearch-client-go/v4",
+      versionPin: "v4",
+      docKey: "go"
+    },
+    ingestEntrypointExample: `${VISIBLE_INGEST_DIR}/ingest.go`,
+    verification: [
+      { label: "go vet", argv: ["go", "vet", "./..."], requiresFile: "go.mod" }
+    ],
+    envReadInstruction: "Read them from `os.Getenv`.",
+    skipDirs: ["vendor", "bin"]
+  },
+  java: {
+    id: "java",
+    displayName: "Java",
+    aliases: ["java"],
+    manifests: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    packageManagers: [
+      {
+        id: "maven",
+        detectFiles: ["pom.xml"],
+        sdkVersionPin: "[4,5)",
+        dependency: { mode: "agent-declares", file: "pom.xml" },
+        installSteps: [{ argv: ["mvn", "-q", "-DskipTests", "compile"] }],
+        // The main class is a wizard constant the instructions require the agent
+        // to use, so execution can't be redirected by agent output. Runnable only
+        // because the install step above compiles src/main/java first — which is
+        // why the entrypoint lives there rather than under .algolia-wizard/.
+        ingest: {
+          kind: "auto",
+          argv: [
+            "mvn",
+            "-q",
+            "org.codehaus.mojo:exec-maven-plugin:3.5.0:java",
+            "-Dexec.mainClass=AlgoliaWizardIngest"
+          ],
+          entrypointExtensions: [".java"]
+        }
+      },
+      {
+        id: "gradle",
+        detectFiles: ["build.gradle", "build.gradle.kts"],
+        dependency: {
+          mode: "agent-declares",
+          file: "build.gradle",
+          alternatives: ["build.gradle.kts"]
+        },
+        installSteps: [],
+        // Auto-running means executing the repo's own ./gradlew wrapper; out of
+        // scope for now, so the wizard writes the code and prints the command.
+        ingest: {
+          kind: "manual",
+          entrypointExtensions: [".java"],
+          runCommand: "./gradlew runAlgoliaIngest",
+          requiresBuildTask: "runAlgoliaIngest"
+        }
+      }
+    ],
+    sdk: {
+      packageName: "com.algolia:algoliasearch",
+      versionPin: "4.+",
+      docKey: "java",
+      alsoRequires: "The class must be named AlgoliaWizardIngest, in the default package (no `package` statement), with a `public static void main`."
+    },
+    // Not under .algolia-wizard/: Maven and Gradle only compile src/main/<lang>,
+    // so a class outside it never makes it onto the classpath and the run command
+    // fails with "class not found".
+    ingestEntrypointExample: "src/main/java/AlgoliaWizardIngest.java",
+    verification: [
+      {
+        label: "mvn compile",
+        argv: ["mvn", "-q", "-DskipTests", "compile"],
+        requiresFile: "pom.xml"
+      }
+    ],
+    envReadInstruction: "Read them from `System.getenv`.",
+    skipDirs: ["target", "build", "out"]
+  },
+  kotlin: {
+    id: "kotlin",
+    displayName: "Kotlin",
+    aliases: ["kotlin", "kt", "ktor"],
+    manifests: ["build.gradle.kts", "build.gradle", "pom.xml"],
+    packageManagers: [
+      {
+        id: "gradle",
+        detectFiles: ["build.gradle.kts", "build.gradle"],
+        dependency: {
+          mode: "agent-declares",
+          file: "build.gradle.kts",
+          alternatives: ["build.gradle"]
+        },
+        installSteps: [],
+        ingest: {
+          kind: "manual",
+          entrypointExtensions: [".kt"],
+          runCommand: "./gradlew runAlgoliaIngest",
+          requiresBuildTask: "runAlgoliaIngest"
+        }
+      },
+      // Kotlin/Maven is rare but real, and pom.xml is a Kotlin manifest — without
+      // this spec such a repo falls through to Gradle and is told to run a
+      // ./gradlew task that doesn't exist. Compiling needs the repo's own
+      // kotlin-maven-plugin, so the run stays the developer's step.
+      {
+        id: "maven",
+        detectFiles: ["pom.xml"],
+        sdkVersionPin: "[3,4)",
+        dependency: { mode: "agent-declares", file: "pom.xml" },
+        installSteps: [{ argv: ["mvn", "-q", "-DskipTests", "compile"] }],
+        ingest: {
+          kind: "manual",
+          entrypointExtensions: [".kt"],
+          runCommand: "mvn -q org.codehaus.mojo:exec-maven-plugin:3.5.0:java -Dexec.mainClass=AlgoliaWizardIngest"
+        }
+      }
+    ],
+    sdk: {
+      packageName: "com.algolia:algoliasearch-client-kotlin",
+      versionPin: "3.+",
+      docKey: "kotlin",
+      // The published client's commonMain ships only ktor-client-core; without an
+      // engine the script compiles and then fails at its first request.
+      alsoRequires: "The Kotlin client bundles no HTTP engine, so also declare one (e.g. io.ktor:ktor-client-okhttp). Name the object AlgoliaWizardIngest in the default package, with a @JvmStatic main."
+    },
+    ingestEntrypointExample: "src/main/kotlin/AlgoliaWizardIngest.kt",
+    verification: [],
+    envReadInstruction: "Read them from `System.getenv`.",
+    skipDirs: ["build", "out"]
+  },
+  scala: {
+    id: "scala",
+    displayName: "Scala",
+    aliases: ["scala", "sbt"],
+    manifests: ["build.sbt", "build.sc"],
+    packageManagers: [
+      {
+        id: "sbt",
+        dependency: { mode: "agent-declares", file: "build.sbt" },
+        installSteps: [],
+        ingest: {
+          kind: "manual",
+          entrypointExtensions: [".scala"],
+          runCommand: 'sbt "runMain AlgoliaWizardIngest"'
+        }
+      }
+    ],
+    sdk: {
+      packageName: "com.algolia:algoliasearch-scala_2.13",
+      versionPin: "2.+",
+      docKey: "scala",
+      alsoRequires: "Name the object AlgoliaWizardIngest in the default package (no `package` statement) so `runMain AlgoliaWizardIngest` resolves it."
+    },
+    ingestEntrypointExample: "src/main/scala/AlgoliaWizardIngest.scala",
+    verification: [],
+    envReadInstruction: "Read them from `sys.env`.",
+    // `project/` holds sbt's build definition, but the name is generic enough
+    // that some repos use it for source; scanning it is cheap, missing source
+    // is not.
+    skipDirs: ["target"]
   }
 };
 var DEFAULT_LANGUAGE_ID = "javascript";
@@ -3078,9 +3260,9 @@ var detectLanguageSchema = z16.object({
 var detectLanguage = () => runAgent({
   instructions: [
     "Analyze the codebase and determine the programming languages and frameworks used",
-    "Start from the dependency manifests: package.json, pyproject.toml, requirements.txt, Gemfile, composer.json.",
+    "Start from the dependency manifests: package.json, pyproject.toml, requirements.txt, Gemfile, composer.json, go.mod, pom.xml, build.gradle(.kts), build.sbt.",
     "List the language that owns the backend/data code first \u2014 that is the one an ingestion script will be written in.",
-    "If a superset language is found, exclude the subset language. TS-over-JS.",
+    "If a superset language is found, exclude the subset language. TS-over-JS. Kotlin-over-Java when Kotlin is primary.",
     "If a meta-framework is used, exclude the framework. Next-over-React.",
     "Frameworks include backend and server-rendering frameworks (e.g. Rails, Django, Laravel, Symfony, Spring Boot, ASP.NET Core, Flask, Gin, Ktor) as well as frontend ones (React, Vue, Angular, Svelte) and mobile ones (Flutter, SwiftUI).",
     "Return the exact version",
@@ -3131,7 +3313,7 @@ var MODE_CONFIG = {
       "Analyze the codebase to find the data entities (models) that should be ingested into Algolia.",
       "For each entity, return its name, the file path(s) where it is defined, and its indexable attribute keys (the fields a user would search or filter on).",
       "Inspect the source of each entity to extract real field names for attributes \u2014 do not guess or leave attributes empty.",
-      "Entities live wherever the stack keeps them: TypeScript interfaces or a Prisma schema, Django models.py, Rails app/models, Laravel Eloquent models, Pydantic models.",
+      "Entities live wherever the stack keeps them: TypeScript interfaces or a Prisma schema, Django models.py, Rails app/models, Laravel Eloquent models, JPA @Entity classes, Go structs, Pydantic models.",
       "Prefer domain models (e.g. Document, Product, User) over framework or infrastructure types.",
       "Use as few tools as possible, but do not guess. If you cannot find any entities, return an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
@@ -3154,7 +3336,7 @@ var MODE_CONFIG = {
   verification: {
     instructions: [
       "Analyze the codebase to determine which code-quality tools are available to validate changes.",
-      "Look at the dependency manifest and config files for the project's languages: package.json scripts with tsconfig/eslint/prettier, pyproject.toml or setup.cfg (ruff, mypy, black), Gemfile with .rubocop.yml, composer.json scripts (phpstan, pint).",
+      "Look at the dependency manifest and config files for the project's languages: package.json scripts with tsconfig/eslint/prettier, pyproject.toml or setup.cfg (ruff, mypy, black), Gemfile with .rubocop.yml, composer.json scripts (phpstan, pint), go.mod with a golangci-lint config, Maven/Gradle verification tasks.",
       'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"] or ["ruff", "mypy"].',
       "Use as few tools as possible, but do not guess. If you cannot find any, return an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
@@ -3182,7 +3364,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.8.0-rc.62.50",
+  version: "0.8.0-rc.64.51",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3648,7 +3830,7 @@ ${JSON.stringify(s.output, null, 2)}`
 }
 function formatReviewSummary(result) {
   const nextStepLines = result.nextSteps.map((step) => {
-    const isIngestCommand = step.includes("algolia-wizard/");
+    const isIngestCommand = step.includes("algolia-wizard/") || step.includes("AlgoliaWizardIngest");
     const isWorktreeCommand = step.includes("/worktrees/");
     return {
       text: `\u2192 ${step}`,

package/docs/algolia-sdk/README.md

@@ -19,6 +19,10 @@ Install the latest stable within the major; never pin an exact patch.
 | Python | `algoliasearch` | `>=4,<5` |
 | Ruby | `algolia` | `~> 3.0` |
 | PHP | `algolia/algoliasearch-client-php` | `^4` |
+| Go | `github.com/algolia/algoliasearch-client-go/v4` | `v4` |
+| Java | `com.algolia:algoliasearch` | `4.+` |
+| Kotlin | `com.algolia:algoliasearch-client-kotlin` | `3.+` |
+| Scala | `com.algolia:algoliasearch-scala_2.13` | `2.+` |
 
 ## Search UI
 

package/docs/algolia-sdk/save-records-go.md

@@ -0,0 +1,62 @@
+# Save records (algoliasearch-client-go v4)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+Imports are the dependency declaration; `go mod tidy` resolves
+`github.com/algolia/algoliasearch-client-go/v4`. Standalone `package main` file,
+run with `go run`. Nothing panics on its own — every call returns `(value, error)`.
+
+```go
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/algolia/algoliasearch-client-go/v4/algolia/search"
+)
+
+func main() {
+	client, err := search.NewClient(os.Getenv("ALGOLIA_APPLICATION_ID"), os.Getenv("ALGOLIA_WRITE_API_KEY"))
+	if err != nil {
+		panic(err) // NewClient fails on an empty/invalid app ID or key
+	}
+
+	indexName := "products"
+	records := []map[string]any{{"objectID": "1", "name": "Hot 100"}}
+
+	if _, err := client.SaveObjects(indexName, records, search.WithWaitForTasks(true)); err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("ALGOLIA_WIZARD_RECORD_COUNT=%d\n", len(records))
+}
+```
+
+```go
+func (c *APIClient) SaveObjects(
+	indexName string,
+	objects []map[string]any,   // maps only, each with an "objectID"
+	opts ...ChunkedBatchOption, // search.WithWaitForTasks(bool), search.WithBatchSize(int) (default 1000)
+) ([]BatchResponse, error)     // BatchResponse{ TaskID int64; ObjectIDs []string }
+```
+
+One `BatchResponse` per batch of 1,000, not per record — `len(res)` is the batch count.
+
+Read records from a JSON file:
+
+```go
+import "encoding/json"
+
+content, err := os.ReadFile("records.json")
+if err != nil {
+	panic(err)
+}
+var records []map[string]any
+if err := json.Unmarshal(content, &records); err != nil {
+	panic(err)
+}
+```
+
+After a successful ingest print `ALGOLIA_WIZARD_RECORD_COUNT=<n>` (n = records
+read, not `len(res)`) as the last stdout line, trailing newline included.

package/docs/algolia-sdk/save-records-java.md

@@ -0,0 +1,66 @@
+# Save records (algoliasearch Java v4)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+```xml
+<dependency>
+  <groupId>com.algolia</groupId>
+  <artifactId>algoliasearch</artifactId>
+  <version>4.20.0</version>
+</dependency>
+```
+
+```groovy
+implementation 'com.algolia:algoliasearch:4.20.0'
+```
+
+The class MUST be `AlgoliaWizardIngest` with a `public static void main`, in the
+**default package** (no `package` statement) — the wizard runs a fixed main class.
+
+```java
+import com.algolia.api.SearchClient;
+import java.util.List;
+import java.util.Map;
+
+public class AlgoliaWizardIngest {
+
+  public static void main(String[] args) throws Exception {
+    String indexName = "products";
+    List<Map<String, Object>> records = List.of(Map.of("objectID", "1", "name", "Hot 100"));
+
+    SearchClient client =
+        new SearchClient(System.getenv("ALGOLIA_APPLICATION_ID"), System.getenv("ALGOLIA_WRITE_API_KEY"));
+    try {
+      client.saveObjects(indexName, records);
+      System.out.printf("ALGOLIA_WIZARD_RECORD_COUNT=%d%n", records.size());
+    } finally {
+      client.close(); // required: okhttp's non-daemon threads keep the JVM alive otherwise
+    }
+  }
+}
+```
+
+Blocking API — calls return directly and throw `AlgoliaApiException` on failure.
+
+```java
+// objects: Maps or POJOs (Jackson-serialized), each with an objectID
+<T> List<BatchResponse> saveObjects(String indexName, Iterable<T> objects)
+<T> List<BatchResponse> saveObjects(String indexName, Iterable<T> objects,
+    boolean waitForTasks, int batchSize, RequestOptions requestOptions) // batchSize default 1000
+```
+
+One `BatchResponse` (`getTaskID()`, `getObjectIDs()`) per batch of 1,000, not per record.
+
+Read records from a JSON file (Jackson is a transitive dependency):
+
+```java
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.File;
+
+List<Map<String, Object>> records = new ObjectMapper()
+    .readValue(new File("records.json"), new TypeReference<List<Map<String, Object>>>() {});
+```
+
+After a successful ingest print `ALGOLIA_WIZARD_RECORD_COUNT=<n>` (n = records
+read, not the returned list size) as the last stdout line.

package/docs/algolia-sdk/save-records-kotlin.md

@@ -0,0 +1,60 @@
+# Save records (algoliasearch-client-kotlin v3)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+Gradle Kotlin DSL. The client ships only `ktor-client-core`, so a JVM engine must
+be declared too or the first call fails with no HTTP engine found:
+
+```kotlin
+implementation("com.algolia:algoliasearch-client-kotlin:3.23.0")
+implementation("io.ktor:ktor-client-okhttp:3.2.0")
+```
+
+`saveObjects` is a `suspend` extension, so a standalone script wraps it in
+`runBlocking`. The object MUST be `AlgoliaWizardIngest` in the **default package**
+(no `package` statement), and `@JvmStatic` is required — a `fun main` inside an
+object is not a JVM entrypoint without it.
+
+```kotlin
+import com.algolia.client.api.SearchClient
+import com.algolia.client.extensions.*
+import java.io.File
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.*
+
+object AlgoliaWizardIngest {
+  @JvmStatic
+  fun main(args: Array<String>): Unit = runBlocking {
+    val indexName = "products"
+    val records: List<JsonObject> = listOf(buildJsonObject { put("objectID", "1"); put("name", "Hot 100") })
+
+    // System.getenv returns String?; the constructor params are non-null
+    SearchClient(
+      appId = requireNotNull(System.getenv("ALGOLIA_APPLICATION_ID")),
+      apiKey = requireNotNull(System.getenv("ALGOLIA_WRITE_API_KEY")),
+    ).use { client -> // AutoCloseable: without use/close, okhttp's non-daemon threads hang the JVM
+      client.saveObjects(indexName = indexName, objects = records)
+      println("ALGOLIA_WIZARD_RECORD_COUNT=${records.size}")
+    }
+  }
+}
+```
+
+```kotlin
+// objects is List<JsonObject> — not arbitrary data classes; each needs an objectID
+suspend fun SearchClient.saveObjects(
+  indexName: String, objects: List<JsonObject>, waitForTasks: Boolean = false,
+  batchSize: Int = 1000, requestOptions: RequestOptions? = null,
+): List<BatchResponse>
+```
+
+One `BatchResponse` (`taskID`, `objectIDs`) per batch of 1,000, not per record.
+
+Read records from a JSON file (no serialization plugin needed for `JsonObject`):
+
+```kotlin
+val records = Json.parseToJsonElement(File("records.json").readText()).jsonArray.map { it.jsonObject }
+```
+
+After a successful ingest print `ALGOLIA_WIZARD_RECORD_COUNT=<n>` (n = records
+read, not the returned list size) as the last stdout line.

package/docs/algolia-sdk/save-records-scala.md

@@ -0,0 +1,68 @@
+# Save records (algoliasearch-scala v2)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+sbt (`%%` appends the Scala binary version, resolving to
+`com.algolia:algoliasearch-scala_2.13` on Scala 2.13):
+
+```scala
+libraryDependencies += "com.algolia" %% "algoliasearch-scala" % "2.22.0"
+```
+
+The object MUST be `AlgoliaWizardIngest` with an explicit `main` (not `extends
+App`), in the **default package** (no `package` statement) — the wizard runs
+`sbt "runMain AlgoliaWizardIngest"`.
+
+```scala
+import algoliasearch.api.SearchClient
+import algoliasearch.extension.SearchClientExtensions // brings saveObjects into scope
+import scala.concurrent.Await
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.duration.Duration
+
+object AlgoliaWizardIngest {
+  def main(args: Array[String]): Unit = {
+    val indexName = "products"
+    val records: Seq[Map[String, Any]] = Seq(Map("objectID" -> "1", "name" -> "Hot 100"))
+
+    val client = SearchClient(
+      appId = sys.env("ALGOLIA_APPLICATION_ID"),
+      apiKey = sys.env("ALGOLIA_WRITE_API_KEY")
+    )
+    try {
+      Await.result(client.saveObjects(indexName, records), Duration(120, "sec"))
+      println(s"ALGOLIA_WIZARD_RECORD_COUNT=${records.size}")
+    } finally client.close() // else okhttp's non-daemon threads hang the JVM
+  }
+}
+```
+
+Future-based API: a script must `Await.result` with a generous timeout, and an
+implicit `ExecutionContext` must be in scope.
+
+```scala
+// objects: Seq[Map[String, Any]] or case classes, each carrying an objectID
+def saveObjects(indexName: String, objects: Seq[Any], waitForTasks: Boolean = false,
+    batchSize: Int = 1000, requestOptions: Option[RequestOptions] = None)(
+    implicit ec: ExecutionContext): Future[Seq[BatchResponse]]
+```
+
+Yields one `BatchResponse` (`taskID`, `objectIDs`) per batch of 1,000, not per record.
+
+Read records from a JSON file (json4s ships with the client):
+
+```scala
+import algoliasearch.search.JsonSupport
+import org.json4s.native.JsonMethods
+import org.json4s.jvalue2extractable
+import scala.io.Source
+import scala.util.Using
+
+implicit val formats: org.json4s.Formats = JsonSupport.format // required by extract
+val records = JsonMethods
+  .parse(Using(Source.fromFile("records.json"))(_.mkString).get)
+  .extract[Seq[Map[String, Any]]]
+```
+
+After a successful ingest print `ALGOLIA_WIZARD_RECORD_COUNT=<n>` (n = records
+read, not the returned `Seq` size) as the last stdout line.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.8.0-rc.62.50",
+  "version": "0.8.0-rc.64.51",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {