@useatlas/create 0.0.5 → 0.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Sywulak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -214,4 +214,4 @@ bun run lint             # Lint with ESLint
 
 ## License
 
-MIT
+MIT — see [LICENSE](./LICENSE)

package/index.ts

@@ -52,10 +52,53 @@ function bail(message?: string): never {
   process.exit(1);
 }
 
+/** Extract a stream from an execSync error. Returns the stream content, or err.message as fallback. */
+function extractExecOutput(err: unknown, stream: "stdout" | "stderr" = "stderr"): string {
+  if (err && typeof err === "object" && stream in err) {
+    const value = String((err as Record<string, unknown>)[stream]).trim();
+    if (value) return value;
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+
+/** Extract a stream from an execSync error. Returns empty string if not present. */
+function extractExecStream(err: unknown, stream: "stdout" | "stderr"): string {
+  if (err && typeof err === "object" && stream in err) {
+    return String((err as Record<string, unknown>)[stream]).trim();
+  }
+  return "";
+}
+
 // Parse --defaults / -y flag for non-interactive mode
 const args = process.argv.slice(2);
 const useDefaults = args.includes("--defaults") || args.includes("-y");
-const positionalArgs = args.filter((a) => !a.startsWith("-"));
+
+const skipDoctor = args.includes("--skip-doctor");
+
+// Parse --demo flag (optionally with dataset name)
+const VALID_DEMO_DATASETS = ["simple", "cybersec", "ecommerce"] as const;
+type DemoDataset = (typeof VALID_DEMO_DATASETS)[number];
+let demoFlag = false;
+let demoDatasetFlag: DemoDataset = "simple";
+const demoIdx = args.indexOf("--demo");
+if (demoIdx !== -1) {
+  demoFlag = true;
+  const next = args[demoIdx + 1];
+  if (next && !next.startsWith("-")) {
+    if (!VALID_DEMO_DATASETS.includes(next as DemoDataset)) {
+      console.error(`Unknown demo dataset "${next}". Available: ${VALID_DEMO_DATASETS.join(", ")}`);
+      process.exit(1);
+    }
+    demoDatasetFlag = next as DemoDataset;
+  }
+}
+
+const positionalArgs = args.filter((a, i) => {
+  if (a.startsWith("-")) return false;
+  // Skip the dataset value after --demo
+  if (i > 0 && args[i - 1] === "--demo") return false;
+  return true;
+});
 
 // Platform → template mapping
 const VALID_PLATFORMS = ["vercel", "railway", "docker", "other"] as const;
@@ -219,7 +262,7 @@ ${projectName}/
 
 | Variable | Required | Description |
 |----------|----------|-------------|
-| \`ATLAS_PROVIDER\` | Yes | LLM provider (\`anthropic\`, \`openai\`, \`bedrock\`, \`ollama\`, \`gateway\`) |
+| \`ATLAS_PROVIDER\` | Yes | LLM provider (\`anthropic\`, \`openai\`, \`bedrock\`, \`ollama\`, \`openai-compatible\`, \`gateway\`) |
 | Provider API key | Yes | e.g. \`ANTHROPIC_API_KEY=sk-ant-...\` |
 | \`ATLAS_DATASOURCE_URL\` | Yes | Analytics database connection string |
 | \`DATABASE_URL\` | No | Atlas internal Postgres (auth, audit). Auto-set on most platforms |
@@ -263,6 +306,7 @@ if (args.includes("--help") || args.includes("-h")) {
   Usage: bun create @useatlas [project-name] [options]
 
   Options:
+    --demo [dataset]   Load demo data (simple, cybersec, ecommerce) [default: simple]
     --platform <name>  Deploy target (${VALID_PLATFORMS.join(", ")}) [default: docker]
     --preset <name>    Alias for --platform
     --defaults, -y     Use all default values (non-interactive)
@@ -279,17 +323,19 @@ if (args.includes("--help") || args.includes("-h")) {
     bun create @useatlas my-app --platform vercel
     bun create @useatlas my-app --preset railway
     bun create @useatlas my-app --defaults
+    bun create @useatlas my-app --demo --defaults
+    bun create @useatlas my-app --demo cybersec
 `);
   process.exit(0);
 }
 
 // Reject unknown flags
-const knownFlags = new Set(["--defaults", "-y", "--help", "-h", "--platform", "--preset"]);
+const knownFlags = new Set(["--defaults", "-y", "--help", "-h", "--platform", "--preset", "--demo"]);
 const unknownFlags = args.filter((a, i) => {
   if (!a.startsWith("-")) return false;
   if (knownFlags.has(a)) return false;
-  // --platform/--preset value argument
-  if (i > 0 && (args[i - 1] === "--platform" || args[i - 1] === "--preset")) return false;
+  // Value arguments for flags that take a parameter
+  if (i > 0 && (args[i - 1] === "--platform" || args[i - 1] === "--preset" || args[i - 1] === "--demo")) return false;
   return true;
 });
 if (unknownFlags.length > 0) {
@@ -338,6 +384,7 @@ async function confirmOrDefault(opts: {
 }
 
 async function main() {
+  const startTime = Date.now();
   console.log("");
   p.intro(
     `${pc.bgCyan(pc.black(" @useatlas/create "))} ${pc.dim(`v${ATLAS_VERSION}`)}`
@@ -577,12 +624,16 @@ async function main() {
   }
 
   // ── 7. Semantic layer / demo data ─────────────────────────────────
-  let loadDemo = false;
-  let demoDataset: "simple" | "cybersec" | "ecommerce" = "simple";
+  let loadDemo = demoFlag;
+  let demoDataset: "simple" | "cybersec" | "ecommerce" = demoDatasetFlag;
   let generateSemantic = false;
 
   // Demo data is not available for MySQL (SQL files use PostgreSQL-specific syntax)
   if (dbChoice === "mysql") {
+    if (demoFlag) {
+      p.log.warn("Demo data is not available for MySQL. The --demo flag will be ignored.");
+      loadDemo = false;
+    }
     p.log.info(`Demo data: ${pc.dim("not available for MySQL — use your own database")}`);
     generateSemantic = await confirmOrDefault({
       label: "Generate semantic layer",
@@ -590,6 +641,9 @@ async function main() {
       initialValue: false,
       defaultDisplay: "no",
     });
+  } else if (demoFlag) {
+    // --demo flag was provided — skip the prompt
+    p.log.info(`Demo data: ${pc.cyan(demoDataset)} ${pc.dim("(--demo)")}`);
   } else {
     loadDemo = await confirmOrDefault({
       label: "Demo data",
@@ -599,6 +653,14 @@ async function main() {
     });
 
     if (loadDemo) {
+      p.note(
+        [
+          `${pc.bold("Simple")}       3 tables, ~330 rows     Quick evaluation, tutorials`,
+          `${pc.bold("Cybersec")}     62 tables, ~500K rows   B2B SaaS with tech debt patterns`,
+          `${pc.bold("E-commerce")}   52 tables, ~480K rows   DTC brand + marketplace`,
+        ].join("\n"),
+        "Available demo datasets"
+      );
       demoDataset = await selectOrDefault({
         label: "Demo dataset",
         message: "Which demo dataset?",
@@ -650,10 +712,8 @@ async function main() {
       connSpinner.stop("Database is reachable.");
     } catch (err) {
       connSpinner.stop("Could not connect to database.");
-      if (err && typeof err === "object" && "stderr" in err) {
-        const stderr = String((err as { stderr: unknown }).stderr).trim();
-        if (stderr) p.log.warn(stderr);
-      }
+      const connStderr = extractExecStream(err, "stderr");
+      if (connStderr) p.log.warn(connStderr);
       const proceed = await p.confirm({
         message: "Database is not reachable. Try generating semantic layer anyway?",
         initialValue: false,
@@ -876,6 +936,7 @@ export default defineConfig({
     s.stop("Dependencies installed.");
   } catch (err) {
     s.stop("Failed to install dependencies.");
+    setupFailed = true;
     p.log.warn(
       `Could not run ${pc.cyan("bun install")}: ${err instanceof Error ? err.message : String(err)}`
     );
@@ -884,32 +945,124 @@ export default defineConfig({
 
   // Step 4: Load demo data + generate semantic layer
   if (loadDemo) {
-    const demoFlag = `--demo ${demoDataset}`;
+    const demoInitFlag = `--demo ${demoDataset}`;
     const timeoutMs = demoDataset === "cybersec" || demoDataset === "ecommerce" ? 120_000 : 60_000;
-    s.start(`Loading ${demoDataset} demo data and generating semantic layer...`);
+
+    // Check if Postgres is reachable before attempting to seed
+    s.start("Checking database connectivity...");
+    let dbReachable = false;
     try {
-      execSync(`bun run atlas -- init ${demoFlag}`, {
-        cwd: targetDir,
-        stdio: "pipe",
-        timeout: timeoutMs,
-        env: { ...process.env, ATLAS_DATASOURCE_URL: databaseUrl },
-      });
-      s.stop("Demo data loaded and semantic layer generated.");
-    } catch (err) {
-      s.stop("Failed to load demo data.");
-      setupFailed = true;
-      let detail = err instanceof Error ? err.message : String(err);
-      if (err && typeof err === "object" && "stderr" in err) {
-        const stderr = String((err as { stderr: unknown }).stderr).trim();
-        if (stderr) detail = stderr;
+      execSync(
+        `bun -e "const{Pool}=require('pg');const p=new Pool({connectionString:process.env.ATLAS_DATASOURCE_URL,connectionTimeoutMillis:5000});const c=await p.connect();c.release();await p.end()"`,
+        { stdio: "pipe", timeout: 10_000, cwd: targetDir, env: { ...process.env, ATLAS_DATASOURCE_URL: databaseUrl } }
+      );
+      dbReachable = true;
+      s.stop("Database is reachable.");
+    } catch (connErr) {
+      s.stop("Database is not reachable.");
+      const connDetail = extractExecOutput(connErr);
+
+      // If the error is about a missing module, bun install likely failed — don't chase Docker
+      if (connDetail.includes("Cannot find module") || connDetail.includes("MODULE_NOT_FOUND")) {
+        p.log.warn("pg module not found — bun install may have failed. Skipping DB check.");
+        p.log.warn(`Run: cd ${projectName} && bun install && bun run atlas -- init ${demoInitFlag}`);
+      } else {
+        // Provide actionable guidance based on the connection string
+        const isLocalhost = databaseUrl.includes("localhost") || databaseUrl.includes("127.0.0.1");
+        if (isLocalhost) {
+          // Check if Docker is available
+          let dockerRunning = false;
+          let dockerError = "";
+          try {
+            execSync("docker info", { stdio: "pipe", timeout: 5_000 });
+            dockerRunning = true;
+          } catch (dockerCheckErr) {
+            dockerError = extractExecOutput(dockerCheckErr);
+          }
+          if (!dockerRunning) {
+            if (dockerError.includes("permission denied")) {
+              p.log.warn("Docker is running but inaccessible (permission denied). Try: sudo usermod -aG docker $USER");
+            } else {
+              p.log.warn("Docker is not running. Demo data requires a PostgreSQL database.");
+            }
+            p.log.warn(`Start Docker, then run:\n  cd ${projectName} && docker compose up -d postgres && bun run atlas -- init ${demoInitFlag}`);
+          } else if (!fs.existsSync(path.join(targetDir, "docker-compose.yml")) && !fs.existsSync(path.join(targetDir, "compose.yml"))) {
+            // No compose file (e.g. Vercel template) — can't auto-start Postgres
+            p.log.warn("PostgreSQL is not reachable and no docker-compose.yml found in the project.");
+            p.log.warn(`Run manually: cd ${projectName} && bun run atlas -- init ${demoInitFlag}`);
+          } else {
+            p.log.warn("PostgreSQL is not running. Starting it with Docker Compose...");
+            try {
+              execSync("docker compose up -d postgres", {
+                cwd: targetDir,
+                stdio: "pipe",
+                timeout: 30_000,
+              });
+              // Wait for Postgres to become healthy
+              const waitStart = Date.now();
+              while (Date.now() - waitStart < 20_000) {
+                try {
+                  execSync(
+                    `bun -e "const{Pool}=require('pg');const p=new Pool({connectionString:process.env.ATLAS_DATASOURCE_URL,connectionTimeoutMillis:2000});const c=await p.connect();c.release();await p.end()"`,
+                    { stdio: "pipe", timeout: 5_000, cwd: targetDir, env: { ...process.env, ATLAS_DATASOURCE_URL: databaseUrl } }
+                  );
+                  dbReachable = true;
+                  break;
+                } catch (retryErr) {
+                  // Break immediately on non-retryable errors
+                  const retryDetail = extractExecOutput(retryErr);
+                  if (retryDetail.includes("Cannot find module") || retryDetail.includes("password authentication failed")) {
+                    p.log.warn(`Connection error: ${retryDetail}`);
+                    break;
+                  }
+                  // Retryable (ECONNREFUSED, timeout) — wait and try again
+                  await new Promise((r) => setTimeout(r, 1_000));
+                }
+              }
+              if (dbReachable) {
+                p.log.info("PostgreSQL is ready.");
+              } else {
+                p.log.warn("PostgreSQL did not become ready in time.");
+                p.log.warn(`Run manually: cd ${projectName} && bun run atlas -- init ${demoInitFlag}`);
+              }
+            } catch (dockerErr) {
+              p.log.warn(`Could not start PostgreSQL: ${extractExecOutput(dockerErr)}`);
+              p.log.warn(`Run manually:\n  cd ${projectName} && docker compose up -d postgres && bun run atlas -- init ${demoInitFlag}`);
+            }
+          }
+        } else {
+          p.log.warn(`Cannot connect to ${databaseUrl.replace(/\/\/[^@]*@/, "//***@")}: ${connDetail.replace(/\/\/[^@]*@/g, "//***@")}`);
+          p.log.warn("Check that the database server is running and the connection string is correct.");
+          p.log.warn(`Then run: cd ${projectName} && bun run atlas -- init ${demoInitFlag}`);
+        }
       }
-      if (err && typeof err === "object" && "signal" in err && (err as { signal: unknown }).signal === "SIGTERM") {
-        detail = `Timed out after ${timeoutMs / 1000}s. The ${demoDataset} dataset may need more time on slow connections. Run the command manually without a timeout.`;
+    }
+
+    if (dbReachable) {
+      s.start(`Loading ${demoDataset} demo data and generating semantic layer...`);
+      try {
+        execSync(`bun run atlas -- init ${demoInitFlag}`, {
+          cwd: targetDir,
+          stdio: "pipe",
+          timeout: timeoutMs,
+          env: { ...process.env, ATLAS_DATASOURCE_URL: databaseUrl },
+        });
+        s.stop("Demo data loaded and semantic layer generated.");
+      } catch (err) {
+        s.stop("Failed to load demo data.");
+        setupFailed = true;
+        const signal = err && typeof err === "object" && "signal" in err ? (err as { signal: unknown }).signal : null;
+        const detail = signal === "SIGTERM"
+          ? `Timed out after ${timeoutMs / 1000}s. The ${demoDataset} dataset may need more time on slow connections.`
+          : extractExecOutput(err);
+        p.log.error(`Demo seeding failed: ${detail}`);
+        p.log.error(
+          `Run ${pc.cyan(`bun run atlas -- init ${demoInitFlag}`)} manually after resolving the issue.`
+        );
       }
-      p.log.error(`Demo seeding failed: ${detail}`);
-      p.log.error(
-        `Run ${pc.cyan(`bun run atlas -- init ${demoFlag}`)} manually after resolving the issue.`
-      );
+    } else {
+      setupFailed = true;
+      p.log.warn("Skipping demo data seeding (no database connection). The project is ready — seed later.");
     }
   }
 
@@ -974,16 +1127,80 @@ export default defineConfig({
 
   p.note(noteBody, "Next steps");
 
+  let doctorFailed = false;
+  if (!skipDoctor && !setupFailed) {
+    s.start("Running atlas doctor...");
+    try {
+      const doctorOutput = execSync("bun run atlas -- doctor", {
+        cwd: targetDir,
+        stdio: "pipe",
+        timeout: 30_000,
+        env: { ...process.env, ATLAS_DATASOURCE_URL: databaseUrl },
+      });
+      s.stop("Health check complete.");
+      const output = doctorOutput.toString().trim();
+      if (output) {
+        console.log(output);
+      }
+    } catch (err) {
+      doctorFailed = true;
+      const isExecError = err && typeof err === "object";
+      const signal = isExecError && "signal" in err ? (err as { signal: unknown }).signal : null;
+      const status = isExecError && "status" in err ? (err as { status: unknown }).status : null;
+
+      if (signal === "SIGTERM") {
+        s.stop("Health check timed out.");
+        p.log.warn(
+          `Atlas doctor timed out after 30s. Run ${pc.cyan("bun run atlas -- doctor")} manually.`
+        );
+      } else if (status === 1) {
+        s.stop("Health check found issues.");
+        const stdout = extractExecStream(err, "stdout");
+        const stderr = extractExecStream(err, "stderr");
+        if (stdout) console.log(stdout);
+        if (stderr) p.log.warn(stderr);
+        p.log.warn(
+          `Some checks failed. Run ${pc.cyan("bun run atlas -- doctor")} after fixing the issues above.`
+        );
+      } else {
+        s.stop("Could not run health check.");
+        p.log.warn(`Atlas doctor could not run: ${extractExecOutput(err)}`);
+        p.log.warn(
+          `Run ${pc.cyan("bun run atlas -- doctor")} manually to validate your setup.`
+        );
+      }
+    }
+  }
+
+  // Print total elapsed time
+  const elapsed = Math.round((Date.now() - startTime) / 1000);
+  const timeStr = elapsed >= 60
+    ? `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`
+    : `${elapsed}s`;
+
   if (setupFailed) {
-    p.outro(`${pc.yellow("Partial setup.")} See errors above.`);
+    p.outro(`${pc.yellow("Partial setup")} in ${pc.dim(timeStr)}. See errors above.`);
+  } else if (doctorFailed) {
+    p.outro(`${pc.yellow("Setup complete")} in ${pc.dim(timeStr)} — fix issues above, then ${pc.cyan("bun run dev")}.`);
   } else {
     p.outro(
-      `${pc.green("Done!")} Your Atlas project is ready at ${pc.cyan(`./${projectName}`)}`
+      `${pc.green("Done!")} Setup complete in ${pc.dim(timeStr)} — ${pc.cyan(`./${projectName}`)} is ready.`
     );
   }
 }
 
 main().catch((err) => {
-  p.log.error(err instanceof Error ? err.message : String(err));
+  // Show actionable message, not a stack trace
+  const code = err && typeof err === "object" && "code" in err ? (err as { code: string }).code : "";
+  const message = err instanceof Error ? err.message : String(err);
+  if (code === "EADDRINUSE" || message.includes("EADDRINUSE")) {
+    p.log.error(`Port already in use. Stop the process using that port and try again.`);
+  } else if (code === "EACCES" || message.includes("EACCES")) {
+    p.log.error(`Permission denied. Check file permissions or try a different directory.`);
+  } else if (code === "ENOSPC" || message.includes("ENOSPC")) {
+    p.log.error(`No space left on disk. Free up space and try again.`);
+  } else {
+    p.log.error(message);
+  }
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useatlas/create",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Create a new Atlas text-to-SQL agent project",
   "bin": {
     "create-useatlas": "./index.ts"
@@ -27,11 +27,11 @@
     "url": "https://github.com/AtlasDevHQ/atlas/issues"
   },
   "engines": {
-    "bun": ">=1.3.10"
+    "bun": ">=1.3.11"
   },
   "dependencies": {
-    "@clack/prompts": "^0.10.0",
-    "picocolors": "^1.1.0"
+    "@clack/prompts": "^1.1.0",
+    "picocolors": "^1.1.1"
   },
   "files": ["index.ts", "templates/", "README.md"],
   "license": "MIT"

package/templates/docker/Dockerfile

@@ -1,4 +1,4 @@
-FROM oven/bun:1.3.10 AS base
+FROM oven/bun:1.3.11 AS base
 
 FROM base AS deps
 WORKDIR /app

package/templates/docker/Dockerfile.sidecar

@@ -1,4 +1,4 @@
-FROM oven/bun:1.3.10-debian AS base
+FROM oven/bun:1.3.11 AS base
 
 # Install only the tools needed for explore mode
 RUN apt-get update && apt-get install -y --no-install-recommends \

package/templates/docker/bin/__tests__/duckdb-ingest.test.ts

@@ -3,11 +3,16 @@
  *
  * Tests the ingestIntoDuckDB, listDuckDBObjects, and profileDuckDB functions
  * using real DuckDB instances with temporary files.
+ *
+ * Previously skipped due to @duckdb/node-api segfault in Bun 1.3.10.
+ * Fixed in Bun 1.3.11 — re-enabled.
  */
 import { describe, it, expect, afterEach } from "bun:test";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import type { DuckDBConnection } from "@duckdb/node-api";
+import type { DuckDBInstance as DuckDBInstanceType } from "@duckdb/node-api";
 import { ingestIntoDuckDB, listDuckDBObjects, profileDuckDB } from "../atlas";
 
 let tmpDir: string;
@@ -83,15 +88,12 @@ describe("ingestIntoDuckDB", () => {
     // Create a Parquet file using DuckDB
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { DuckDBInstance } = require("@duckdb/node-api");
-    const inst = await DuckDBInstance.create(":memory:");
-    const c = await inst.connect();
+    const inst: DuckDBInstanceType = await DuckDBInstance.create(":memory:");
+    const c: DuckDBConnection = await inst.connect();
     const parquetPath = path.join(dir, "data.parquet");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await (c as any).run(`COPY (SELECT 1 AS id, 'test' AS name) TO '${parquetPath.replace(/'/g, "''")}' (FORMAT PARQUET)`);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (c as any).disconnectSync();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (inst as any).closeSync();
+    await c.run(`COPY (SELECT 1 AS id, 'test' AS name) TO '${parquetPath.replace(/'/g, "''")}' (FORMAT PARQUET)`);
+    c.disconnectSync();
+    inst.closeSync();
 
     const dbPath = path.join(dir, "test.duckdb");
     const tables = await ingestIntoDuckDB(dbPath, [{ path: parquetPath, format: "parquet" }]);
@@ -132,10 +134,11 @@ describe("profileDuckDB", () => {
     const dbPath = path.join(dir, "test.duckdb");
     await ingestIntoDuckDB(dbPath, [{ path: csvPath, format: "csv" }]);
 
-    const profiles = await profileDuckDB(dbPath);
-    expect(profiles).toHaveLength(1);
+    const result = await profileDuckDB(dbPath);
+    expect(result.profiles).toHaveLength(1);
+    expect(result.errors).toHaveLength(0);
 
-    const profile = profiles[0];
+    const profile = result.profiles[0];
     expect(profile.table_name).toBe("employees");
     expect(profile.row_count).toBe(5);
     expect(profile.columns.length).toBe(4);
@@ -164,8 +167,8 @@ describe("profileDuckDB", () => {
       { path: csv2, format: "csv" },
     ]);
 
-    const profiles = await profileDuckDB(dbPath, ["a"]);
-    expect(profiles).toHaveLength(1);
-    expect(profiles[0].table_name).toBe("a");
+    const result = await profileDuckDB(dbPath, ["a"]);
+    expect(result.profiles).toHaveLength(1);
+    expect(result.profiles[0].table_name).toBe("a");
   });
 });