@algolia/wizard 0.9.0-rc.74.64 → 0.9.0-rc.76.66

package/dist/main.js

@@ -1003,7 +1003,7 @@ var accessItems = [
   {
     tag: "READ",
     title: "Project files",
-    description: "reads your dependency manifests (package.json\u2026), configs & source to detect your stack. Read-only; nothing is uploaded."
+    description: "reads your dependency manifests (package.json, pyproject.toml, Gemfile\u2026), configs & source to detect your stack. Read-only; nothing is uploaded."
   },
   {
     tag: "WRITE",
@@ -2266,6 +2266,9 @@ function shellQuote(value) {
 // src/lib/languages.ts
 var ENTRYPOINT_TOKEN = "{entrypoint}";
 var 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`;
 var LANGUAGE_PROFILES = {
   javascript: {
     id: "javascript",
@@ -2308,6 +2311,109 @@ var LANGUAGE_PROFILES = {
     verification: [],
     envReadInstruction: "Read them from `process.env`.",
     skipDirs: ["node_modules", "dist", "build", "coverage", ".next", "out"]
+  },
+  python: {
+    id: "python",
+    displayName: "Python",
+    aliases: ["python", "python3", "py", "cpython"],
+    manifests: [
+      "pyproject.toml",
+      "requirements.txt",
+      "setup.py",
+      "setup.cfg",
+      "Pipfile"
+    ],
+    // Deliberately one path for every Python repo: a wizard-owned venv under
+    // .algolia-wizard. Reusing the project's uv/poetry environment would mean
+    // mutating the developer's real dependency manifest and lockfile, and the
+    // declare-here/install-there split is the main way ingestion silently ends
+    // up without the SDK installed. The tradeoff: the script can import the
+    // Algolia client and anything it declares itself, but not the project's own
+    // packages (see the optional root-requirements step below).
+    packageManagers: [
+      {
+        id: "pip-venv",
+        dependency: { mode: "agent-declares", file: PY_REQUIREMENTS },
+        installSteps: [
+          { argv: ["python3", "-m", "venv", PY_VENV] },
+          {
+            argv: [PY_VENV_PYTHON, "-m", "pip", "install", "-r", PY_REQUIREMENTS]
+          },
+          // Best-effort access to the project's own dependencies (DB drivers,
+          // ORMs) when the repo pins them the classic way.
+          {
+            argv: [
+              PY_VENV_PYTHON,
+              "-m",
+              "pip",
+              "install",
+              "-r",
+              "requirements.txt"
+            ],
+            requiresFile: "requirements.txt",
+            optional: true
+          }
+        ],
+        ingest: {
+          kind: "auto",
+          argv: [PY_VENV_PYTHON, ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".py"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "algoliasearch",
+      versionPin: ">=4,<5",
+      docKey: "python"
+    },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.py`,
+    localSourceCaveat: {
+      unless: "requirements.txt",
+      message: "The ingestion script runs in its own environment under .algolia-wizard/, so it can install the Algolia client but not this project's packages (no requirements.txt to install from). If the script needs your database driver or ORM, add those packages to .algolia-wizard/requirements.txt and re-run the install."
+    },
+    verification: [
+      {
+        // -x skips the venv this same directory holds; without it the check
+        // compiles every installed package instead of the generated script.
+        label: "python compileall",
+        argv: ["python3", "-m", "compileall", "-q", "-x", "[.]venv", INGEST_DIR],
+        requiresFile: INGEST_DIR
+      }
+    ],
+    envReadInstruction: "Read them from `os.environ`.",
+    skipDirs: [
+      "venv",
+      "__pycache__",
+      "site-packages",
+      "dist",
+      "build",
+      "htmlcov"
+    ]
+  },
+  ruby: {
+    id: "ruby",
+    displayName: "Ruby",
+    aliases: ["ruby", "rb", "rails", "ruby on rails", "rubyonrails"],
+    manifests: ["Gemfile", "*.gemspec"],
+    packageManagers: [
+      {
+        id: "bundler",
+        dependency: { mode: "agent-declares", file: "Gemfile" },
+        installSteps: [{ argv: ["bundle", "install"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["bundle", "exec", "ruby", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".rb"]
+        }
+      }
+    ],
+    sdk: { packageName: "algolia", versionPin: "~> 3.0", docKey: "ruby" },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.rb`,
+    // Ruby has no directory-level syntax check (`ruby -c` is one file at a
+    // time), so verification relies on the agent's own review here.
+    verification: [],
+    envReadInstruction: "Read them from `ENV.fetch('NAME')`.",
+    skipDirs: ["vendor", "tmp", "log", "coverage"]
   }
 };
 var DEFAULT_LANGUAGE_ID = "javascript";
@@ -2990,7 +3096,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.",
+    "Start from the dependency manifests: package.json, pyproject.toml, requirements.txt, Gemfile.",
     "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 meta-framework is used, exclude the framework. Next-over-React.",
@@ -3043,7 +3149,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.",
+      "Entities live wherever the stack keeps them: TypeScript interfaces or a Prisma schema, Django models.py, Rails app/models, 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",
@@ -3066,8 +3172,8 @@ 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.",
-      'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"].',
+      "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.",
+      '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",
       "When done, call reportStatus"
@@ -3094,7 +3200,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.9.0-rc.74.64",
+  version: "0.9.0-rc.76.66",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/docs/algolia-sdk/README.md

@@ -16,6 +16,8 @@ Install the latest stable within the major; never pin an exact patch.
 | Language | Package | Version |
 | --- | --- | --- |
 | JavaScript/TypeScript | `algoliasearch` | `^5` |
+| Python | `algoliasearch` | `>=4,<5` |
+| Ruby | `algolia` | `~> 3.0` |
 
 ## Search UI
 

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

@@ -0,0 +1,51 @@
+# Save records (algoliasearch v4)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+Dependency: `algoliasearch>=4,<5` (PyPI).
+
+v4 is async-first: `SearchClient` is coroutine-based (every method needs `await`).
+**`SearchClientSync` is the sync twin** — use it in a standalone script, via `with`
+so the transport closes.
+
+```python
+import os
+
+from algoliasearch.search.client import SearchClientSync
+
+app_id = os.environ["ALGOLIA_APPLICATION_ID"]
+api_key = os.environ["ALGOLIA_WRITE_API_KEY"]
+index_name = "playlists"
+records = [{"objectID": "1", "name": "Hot 100", "visibility": "public"}]
+
+with SearchClientSync(app_id, api_key) as client:
+    responses = client.save_objects(
+        index_name=index_name,
+        objects=records,
+        wait_for_tasks=True,
+    )
+```
+
+```python
+save_objects(
+    index_name: str,                     # required
+    objects: Iterable[Dict[str, Any]],   # required
+    wait_for_tasks: bool = False,
+    batch_size: int = 1000,
+) -> List[BatchResponse]                 # one entry per 1,000-record batch
+```
+
+`BatchResponse` attributes are **snake_case**: `r.task_id`, `r.object_ids` (the
+wire keys are `taskID`/`objectIDs`). It is a list — never treat it as one object.
+
+Read records from a JSON file:
+
+```python
+import json
+
+with open(records_path, encoding="utf-8") as f:
+    records = json.load(f)
+```
+
+After a successful ingest, print `ALGOLIA_WIZARD_RECORD_COUNT=<n>` as the last
+stdout line.

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

@@ -0,0 +1,48 @@
+# Save records (algolia v3)
+
+Adds records to an index. Write op — use a **write key**, server-side only.
+
+Dependency: gem `algolia`, `~> 3.0` (`gem 'algolia', '~> 3.0'`).
+
+`require "algolia"` (gem name is `algolia`, not `algoliasearch`). Build the client
+with `Algolia::SearchClient.create`.
+
+```ruby
+require "algolia"
+
+app_id = ENV.fetch("ALGOLIA_APPLICATION_ID")
+api_key = ENV.fetch("ALGOLIA_WRITE_API_KEY")
+index_name = "playlists"
+
+client = Algolia::SearchClient.create(app_id, api_key)
+
+records = [{ "objectID" => "1", "name" => "Hot 100", "visibility" => "public" }]
+
+responses = client.save_objects(index_name, records, true)
+```
+
+```ruby
+save_objects(
+  index_name,             # String, required
+  objects,                # Array<Hash>, required
+  wait_for_tasks = false,
+  batch_size = 1000,
+  request_options = {}
+) # => Array<Algolia::Search::BatchResponse>, one entry per 1,000-record batch
+```
+
+Args are **positional**, and every method/field is **snake_case**: read
+`r.task_id` and `r.object_ids`, not `taskID`/`objectIDs`. The return value is an
+array — never treat it as one object.
+
+Read records from a JSON file:
+
+```ruby
+require "json"
+
+records = JSON.parse(File.read(records_path))
+```
+
+After a successful ingest, print `ALGOLIA_WIZARD_RECORD_COUNT=<n>` as the last
+stdout line (`puts "ALGOLIA_WIZARD_RECORD_COUNT=#{records.length}"`), with no
+other output after it.

package/package.json

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