@algolia/wizard 0.9.0-rc.80.70 → 0.9.0-rc.82.72

package/dist/main.js

@@ -2266,6 +2266,7 @@ function shellQuote(value) {
 // src/lib/languages.ts
 var ENTRYPOINT_TOKEN = "{entrypoint}";
 var INGEST_DIR = ".algolia-wizard";
+var SWIFT_PACKAGE_DIR = `${INGEST_DIR}/Ingest`;
 var CSHARP_PROJECT = `${INGEST_DIR}/ingest/ingest.csproj`;
 var VISIBLE_INGEST_DIR = "algolia-wizard";
 var PY_VENV = `${INGEST_DIR}/.venv`;
@@ -2677,6 +2678,99 @@ var LANGUAGE_PROFILES = {
     // `packages/` is where pnpm/Lerna/Turborepo monorepos keep all their source —
     // skipping it would hide the entities the scan is looking for.
     skipDirs: ["bin", "obj"]
+  },
+  swift: {
+    id: "swift",
+    displayName: "Swift",
+    aliases: ["swift", "swiftui", "ios", "vapor"],
+    manifests: ["Package.swift", "*.xcodeproj", "*.xcworkspace"],
+    packageManagers: [
+      {
+        id: "swiftpm",
+        dependency: {
+          mode: "agent-declares",
+          file: `${SWIFT_PACKAGE_DIR}/Package.swift`
+        },
+        // `swift build` resolves and fetches; a cold build of the client is slow
+        // (minutes), which is why the caller degrades to the manual command when
+        // this fails.
+        installSteps: [
+          {
+            argv: ["swift", "build", "--package-path", SWIFT_PACKAGE_DIR],
+            requiresFile: `${SWIFT_PACKAGE_DIR}/Package.swift`
+          }
+        ],
+        ingest: {
+          kind: "auto",
+          argv: ["swift", "run", "--package-path", SWIFT_PACKAGE_DIR],
+          entrypointExtensions: [".swift"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "algoliasearch-client-swift",
+      // SwiftPM range syntax, not an exact version — a bare "9.0.0" in a
+      // Package.swift dependency pins the patch.
+      versionPin: 'from: "9.0.0"',
+      docKey: "swift"
+    },
+    ingestEntrypointExample: `${SWIFT_PACKAGE_DIR}/Sources/Ingest/main.swift`,
+    verification: [
+      {
+        label: "swift build",
+        argv: ["swift", "build", "--package-path", SWIFT_PACKAGE_DIR],
+        requiresFile: `${SWIFT_PACKAGE_DIR}/Package.swift`
+      }
+    ],
+    envReadInstruction: "Read them from `ProcessInfo.processInfo.environment`.",
+    skipDirs: ["Pods", "DerivedData", "Carthage", ".build"]
+  },
+  dart: {
+    id: "dart",
+    displayName: "Dart",
+    aliases: ["dart", "flutter"],
+    manifests: ["pubspec.yaml"],
+    packageManagers: [
+      {
+        id: "flutter-pub",
+        detectFiles: [".metadata"],
+        dependency: { mode: "agent-declares", file: "pubspec.yaml" },
+        installSteps: [{ argv: ["flutter", "pub", "get"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["dart", "run", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".dart"]
+        }
+      },
+      {
+        id: "pub",
+        dependency: { mode: "agent-declares", file: "pubspec.yaml" },
+        installSteps: [{ argv: ["dart", "pub", "get"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["dart", "run", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".dart"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "algolia_client_search",
+      versionPin: "^1.0.0",
+      docKey: "dart"
+    },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.dart`,
+    verification: [
+      {
+        // Gated on the directory it analyzes, not just pubspec.yaml: a run that
+        // only built a search UI never created it, and `dart analyze` on a
+        // missing path fails the whole verification pass.
+        label: "dart analyze",
+        argv: ["dart", "analyze", INGEST_DIR],
+        requiresFile: INGEST_DIR
+      }
+    ],
+    envReadInstruction: "Read them from `Platform.environment`.",
+    skipDirs: ["build"]
   }
 };
 var DEFAULT_LANGUAGE_ID = "javascript";
@@ -3359,7 +3453,7 @@ 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, go.mod, pom.xml, build.gradle(.kts), *.csproj, build.sbt.",
+    "Start from the dependency manifests: package.json, pyproject.toml, requirements.txt, Gemfile, composer.json, go.mod, pom.xml, build.gradle(.kts), *.csproj, build.sbt, Package.swift, pubspec.yaml.",
     "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. Kotlin-over-Java when Kotlin is primary.",
     "If a meta-framework is used, exclude the framework. Next-over-React.",
@@ -3435,7 +3529,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), go.mod with a golangci-lint config, Maven/Gradle verification tasks, .NET analyzers.",
+      "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, .NET analyzers, analysis_options.yaml.",
       '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",
@@ -3463,7 +3557,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.9.0-rc.80.70",
+  version: "0.9.0-rc.82.72",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/docs/algolia-sdk/README.md

@@ -24,6 +24,8 @@ Install the latest stable within the major; never pin an exact patch.
 | Kotlin | `com.algolia:algoliasearch-client-kotlin` | `3.+` |
 | Scala | `com.algolia:algoliasearch-scala_2.13` | `2.+` |
 | C# | `Algolia.Search` | `7.*` |
+| Swift | `algoliasearch-client-swift` | `9.0.0` |
+| Dart | `algolia_client_search` | `^1.0.0` |
 
 ## Search UI
 

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

@@ -0,0 +1,74 @@
+# Save records (algolia_client_search v1)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+Use the generated v2 client `algolia_client_search`, never the legacy community
+`algolia` package. The script is run with `dart run .algolia-wizard/ingest.dart`.
+
+```yaml
+dependencies:
+  algolia_client_search: ^1.0.0
+```
+
+This client has **no `saveObjects` helper** (only `saveObjectsWithTransformation`,
+which needs an Ingestion transformation) — use `batch` with `addObject` actions.
+
+```dart
+import 'dart:convert';
+import 'dart:io';
+import 'dart:math';
+
+import 'package:algolia_client_search/algolia_client_search.dart';
+
+Future<void> main() async {
+  final appId = Platform.environment['ALGOLIA_APPLICATION_ID'];
+  final writeKey = Platform.environment['ALGOLIA_WRITE_API_KEY'];
+  if (appId == null || writeKey == null) {
+    stderr.writeln('missing Algolia credentials');
+    exit(1);
+  }
+
+  const indexName = 'products';
+  final client = SearchClient(appId: appId, apiKey: writeKey);
+
+  final records = <Map<String, dynamic>>[
+    {'objectID': '1', 'name': 'Adam'},
+    {'objectID': '2', 'name': 'Benoit'},
+  ];
+
+  try {
+    for (var i = 0; i < records.length; i += 1000) {
+      final chunk = records.sublist(i, min(i + 1000, records.length));
+      final response = await client.batch(
+        indexName: indexName,
+        batchWriteParams: BatchWriteParams(
+          requests: chunk
+              .map((r) => BatchRequest(action: Action.addObject, body: r))
+              .toList(),
+        ),
+      );
+      stderr.writeln('task ${response.taskID}');
+    }
+    print('ALGOLIA_WIZARD_RECORD_COUNT=${records.length}');
+  } finally {
+    client.dispose();
+  }
+}
+```
+
+`batch` returns a **single** `BatchResponse { int taskID, List<String> objectIDs }`,
+not a list. Gotchas: every record needs an `objectID`; there is no auto-chunking,
+so cap each call at 1,000 records yourself; use the `Action.addObject` enum value
+(`Action.updateObject` replaces instead of adds); and `client.dispose()` is
+mandatory — without it `dart run` never exits.
+
+Read records from a JSON file:
+
+```dart
+final json = await File('records.json').readAsString();
+final records = (jsonDecode(json) as List).cast<Map<String, dynamic>>();
+```
+
+After a successful ingest, print `ALGOLIA_WIZARD_RECORD_COUNT=<n>` as the last
+stdout line (before `dispose()` is fine); send all other logging to stderr so
+nothing follows it on stdout.

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

@@ -0,0 +1,88 @@
+# Save records (algoliasearch-client-swift v9)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+The generated script is a standalone SwiftPM executable package at
+`.algolia-wizard/Ingest` (`Package.swift` + `Sources/Ingest/main.swift`), run with
+`swift run --package-path .algolia-wizard/Ingest`.
+
+```swift
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "Ingest",
+    platforms: [.macOS(.v13)],
+    products: [.executable(name: "Ingest", targets: ["Ingest"])],
+    dependencies: [
+        .package(url: "https://github.com/algolia/algoliasearch-client-swift", from: "9.0.0"),
+    ],
+    targets: [
+        .executableTarget(name: "Ingest", dependencies: [
+            .product(name: "AlgoliaSearch", package: "algoliasearch-client-swift"),
+            .product(name: "AlgoliaCore", package: "algoliasearch-client-swift"),
+        ]),
+    ]
+)
+```
+
+Exactly one executable product, so `swift run --package-path` needs no target name.
+`platforms:` must be declared (the client requires macOS 11+); it is ignored on
+Linux. `package:` is the repo name, not the manifest's `AlgoliaSearchClient`.
+
+`main.swift` top-level code can't propagate a thrown error — wrap calls in `do`/`catch`.
+
+```swift
+import Foundation
+#if canImport(AlgoliaCore)
+    import AlgoliaCore
+#endif
+import AlgoliaSearch
+
+let env = ProcessInfo.processInfo.environment
+guard let appID = env["ALGOLIA_APPLICATION_ID"],
+      let writeKey = env["ALGOLIA_WRITE_API_KEY"]
+else {
+    FileHandle.standardError.write(Data("missing Algolia credentials\n".utf8))
+    exit(1)
+}
+let indexName = "products"
+
+do {
+    let client = try SearchClient(appID: appID, apiKey: writeKey)
+    let records: [AnyCodable] = [
+        ["objectID": "1", "name": "Adam"],
+        ["objectID": "2", "name": "Benoit"],
+    ]
+    let responses = try await client.saveObjects(
+        indexName: indexName, objects: records, waitForTasks: true
+    )
+    FileHandle.standardError.write(Data("batches: \(responses.count)\n".utf8))
+    print("ALGOLIA_WIZARD_RECORD_COUNT=\(records.count)")
+} catch {
+    FileHandle.standardError.write(Data("\(error)\n".utf8))
+    exit(1)
+}
+```
+
+```swift
+func saveObjects(
+    indexName: String, objects: [some Encodable], waitForTasks: Bool = false,
+    batchSize: Int = 1000, requestOptions: RequestOptions? = nil
+) async throws -> [BatchResponse]
+```
+
+Records need an `objectID`; batching in 1,000s is automatic. Returns an **array**
+of `BatchResponse` (`taskID`, `objectIDs`), one per batch. `objects` is
+`[some Encodable]` — one homogeneous element type, so use `[AnyCodable]` (from
+`AlgoliaCore`) for arbitrary JSON records.
+
+Read records from a JSON file:
+
+```swift
+let data = try Data(contentsOf: URL(fileURLWithPath: "records.json"))
+let records = try JSONDecoder().decode([AnyCodable].self, from: data)
+```
+
+After a successful ingest, print `ALGOLIA_WIZARD_RECORD_COUNT=<n>` as the last
+stdout line; send all other logging to stderr so nothing follows it on stdout.

package/package.json

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