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

package/dist/main.js

@@ -2206,6 +2206,8 @@ 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`;
 var PY_VENV_PYTHON = `${PY_VENV}/bin/python`;
@@ -2578,6 +2580,137 @@ var LANGUAGE_PROFILES = {
     // that some repos use it for source; scanning it is cheap, missing source
     // is not.
     skipDirs: ["target"]
+  },
+  csharp: {
+    id: "csharp",
+    displayName: "C#",
+    aliases: ["c#", "csharp", "cs", ".net", "dotnet", "net", "asp.net"],
+    manifests: ["*.csproj", "*.sln", "global.json"],
+    packageManagers: [
+      {
+        id: "dotnet",
+        // A self-contained project under .algolia-wizard keeps the ingest script
+        // out of the repo's own build graph.
+        dependency: { mode: "agent-declares", file: CSHARP_PROJECT },
+        installSteps: [{ argv: ["dotnet", "restore", CSHARP_PROJECT] }],
+        ingest: {
+          kind: "auto",
+          argv: ["dotnet", "run", "--project", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".csproj"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "Algolia.Search",
+      versionPin: "7.*",
+      docKey: "csharp"
+    },
+    ingestEntrypointExample: CSHARP_PROJECT,
+    verification: [
+      {
+        label: "dotnet build",
+        argv: ["dotnet", "build", CSHARP_PROJECT, "--nologo"],
+        requiresFile: CSHARP_PROJECT
+      }
+    ],
+    envReadInstruction: 'Read them from `Environment.GetEnvironmentVariable("NAME")`.',
+    // Deliberately not `packages`: modern .NET uses PackageReference, and
+    // `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";
@@ -3260,7 +3393,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), 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.",
@@ -3313,7 +3446,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, JPA @Entity classes, Go structs, 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, C# entity classes, 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",
@@ -3336,7 +3469,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.",
+      "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",
@@ -3364,7 +3497,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.8.0-rc.64.51",
+  version: "0.8.0-rc.67.55",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/docs/algolia-sdk/README.md

@@ -23,6 +23,9 @@ Install the latest stable within the major; never pin an exact patch.
 | Java | `com.algolia:algoliasearch` | `4.+` |
 | 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-csharp.md

@@ -0,0 +1,71 @@
+# Save records (Algolia.Search v7)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+The generated script is a self-contained console project at
+`.algolia-wizard/ingest/ingest.csproj` + `Program.cs`, run with
+`dotnet run --project .algolia-wizard/ingest/ingest.csproj`.
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Algolia.Search" Version="7.*" />
+  </ItemGroup>
+</Project>
+```
+
+`<OutputType>Exe</OutputType>` is required — `dotnet run` on a library has no entry
+point. `<TargetFramework>` must match an installed SDK; `net8.0` (LTS) is the safe
+default. Under Central Package Management (`Directory.Packages.props` at the repo
+root) omit `Version` here and pin it there — `Version` on a `PackageReference` is
+an error under CPM (NU1008).
+
+```csharp
+using System.Text.Json;
+using Algolia.Search.Clients;
+
+var appId = Environment.GetEnvironmentVariable("ALGOLIA_APPLICATION_ID")
+    ?? throw new InvalidOperationException("ALGOLIA_APPLICATION_ID is not set");
+var writeKey = Environment.GetEnvironmentVariable("ALGOLIA_WRITE_API_KEY")
+    ?? throw new InvalidOperationException("ALGOLIA_WRITE_API_KEY is not set");
+
+var client = new SearchClient(new SearchConfig(appId, writeKey));
+var indexName = "products";
+
+var records = new List<Dictionary<string, object>>
+{
+    new() { ["objectID"] = "1", ["name"] = "Adam" },
+    new() { ["objectID"] = "2", ["name"] = "Benoit" },
+};
+
+var responses = await client.SaveObjectsAsync(indexName, records, waitForTasks: true);
+```
+
+```csharp
+Task<List<BatchResponse>> SaveObjectsAsync<T>(
+  string indexName, IEnumerable<T> objects, bool waitForTasks = false,
+  int batchSize = 1000, RequestOptions options = null,
+  CancellationToken cancellationToken = default) where T : class;
+```
+
+Records need an `objectID`; batching in 1,000s is automatic. Returns
+`List<BatchResponse>` — one entry per batch, each `{ TaskID, ObjectIDs }`, never a
+single response. `T` is constrained to `class`, so use `Dictionary<string, object>`
+or a record/class, never a struct.
+
+Read records from a JSON file:
+
+```csharp
+var json = await File.ReadAllTextAsync("records.json");
+var records = JsonSerializer.Deserialize<List<Dictionary<string, object>>>(json)
+    ?? new List<Dictionary<string, object>>();
+```
+
+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/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.8.0-rc.64.51",
+  "version": "0.8.0-rc.67.55",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {