@deepagents/text2sql 2.2.0 → 2.3.0

package/README.md

@@ -201,13 +201,13 @@ For in-process or virtual-sandbox usage (without installing the package CLI),
 wrap an existing `Text2Sql` instance as a just-bash custom command:
 
 ```typescript
+import { InMemoryFs, createVirtualSandbox } from '@deepagents/context';
 import {
-  Text2Sql,
-  createSqlCommand,
   type CreateSqlCommandOptions,
   type CreateSqlCommandResult,
+  Text2Sql,
+  createSqlCommand,
 } from '@deepagents/text2sql';
-import { InMemoryFs, createVirtualSandbox } from '@deepagents/context';
 
 const text2sql = new Text2Sql({ model, adapters: { main: adapter } });
 

package/dist/index.js

@@ -5530,6 +5530,7 @@ import { posix as posix5 } from "node:path";
 import { parseArgs } from "node:util";
 import { v7 } from "uuid";
 import {
+  BashException as BashException2,
   buildSubcommandRepair as buildSubcommandRepair2,
   defineSubcommandGroup,
   repairQuotedArg as repairQuotedArg2,
@@ -5650,12 +5651,22 @@ var Text2Sql = class {
 
 // packages/text2sql/src/lib/sql-command.ts
 var SQL_VALIDATE_REMINDER2 = 'Always run `sql validate <db> "..."` before `sql run <db> "..."` to catch syntax errors early.';
-var SqlCommandError = class extends Error {
-  exitCode;
-  constructor(message, exitCode = 1) {
+var SqlCommandError = class extends BashException2 {
+  #subcommand;
+  #exitCode;
+  constructor(subcommand, message, exitCode = 1) {
     super(message);
     this.name = "SqlCommandError";
-    this.exitCode = exitCode;
+    this.#subcommand = subcommand;
+    this.#exitCode = exitCode;
+  }
+  format() {
+    return {
+      stdout: "",
+      stderr: `sql ${this.#subcommand}: ${this.message}
+`,
+      exitCode: this.#exitCode
+    };
   }
 };
 function createSqlCommand(text2Sql, options = {}) {
@@ -5672,11 +5683,6 @@ function createSqlCommand(text2Sql, options = {}) {
       description: "Validate query syntax against <db>",
       repair: repairDbNameAndQuotedArg,
       handler: (args) => handleValidate(text2Sql, args)
-    },
-    index: {
-      usage: "index [adapter ...]",
-      description: "Index adapter schemas and write context artifacts",
-      handler: (args, ctx) => handleIndex(text2Sql, defaultOutputDir, args, ctx)
     }
   };
   return {
@@ -5684,27 +5690,22 @@ function createSqlCommand(text2Sql, options = {}) {
     repair: buildSubcommandRepair2("sql", subcommands)
   };
 }
-function parseFlags(args) {
-  let parsed;
+function parseFlags(subcommand, args) {
   try {
-    parsed = parseArgs({
+    const parsed = parseArgs({
       args,
-      options: {
-        "out-dir": { type: "string" },
-        all: { type: "boolean" }
-      },
+      options: { "out-dir": { type: "string" } },
       allowPositionals: true,
       strict: true
     });
+    return {
+      positional: parsed.positionals,
+      outDir: parsed.values["out-dir"]
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new SqlCommandError(message, 1);
+    throw new SqlCommandError(subcommand, message);
   }
-  return {
-    positional: parsed.positionals,
-    outDir: parsed.values["out-dir"],
-    all: parsed.values.all === true
-  };
 }
 function resolveOutputDir(ctx, flags, fallback) {
   const envOutDir = ctx.env.get("TEXT2SQL_OUT_DIR");
@@ -5713,10 +5714,10 @@ function resolveOutputDir(ctx, flags, fallback) {
 }
 async function handleRun(text2Sql, defaultOutputDir, args, ctx) {
   return runHandler("run", async () => {
-    const flags = parseFlags(args);
+    const flags = parseFlags("run", args);
     const meta = useBashMeta2();
     meta?.setReminder(SQL_VALIDATE_REMINDER2);
-    const { name, sql } = takeDbAndSql(flags.positional, "run", text2Sql);
+    const { name, sql } = takeDbAndSql("run", flags.positional, text2Sql);
     const outputDir = resolveOutputDir(ctx, flags, defaultOutputDir);
     const { rows, columns } = await text2Sql.run(name, sql);
     const outPath = posix5.join(outputDir, `${v7()}.json`);
@@ -5734,87 +5735,42 @@ rows: ${rows.length}
 }
 async function handleValidate(text2Sql, args) {
   return runHandler("validate", async () => {
-    const flags = parseFlags(args);
-    const { name, sql } = takeDbAndSql(flags.positional, "validate", text2Sql);
+    const flags = parseFlags("validate", args);
+    const { name, sql } = takeDbAndSql("validate", flags.positional, text2Sql);
     await text2Sql.validate(name, sql);
     return { stdout: "valid\n", stderr: "", exitCode: 0 };
   });
 }
-async function handleIndex(text2Sql, defaultOutputDir, args, ctx) {
-  return runHandler("index", async () => {
-    const flags = parseFlags(args);
-    const available = text2Sql.adapterNames();
-    const requested = flags.all ? [] : dedupe(flags.positional);
-    const names = requested.length === 0 ? available : requested;
-    for (const name of names) {
-      if (!text2Sql.hasAdapter(name)) {
-        throw new SqlCommandError(
-          `unknown adapter "${name}". Available: ${available.join(", ")}`,
-          1
-        );
-      }
-    }
-    const outputDir = resolveOutputDir(ctx, flags, defaultOutputDir);
-    const fragments = await text2Sql.index({ names });
-    const fragmentsPath = posix5.join(outputDir, `index-${v7()}.json`);
-    await ctx.fs.mkdir(outputDir, { recursive: true });
-    await ctx.fs.writeFile(fragmentsPath, JSON.stringify(fragments, null, 2));
-    const manifest = {
-      fragmentsPath,
-      eventsPath: null,
-      adapters: names,
-      fragments: countSchemaFragments(fragments)
-    };
-    return {
-      stdout: JSON.stringify(manifest, null, 2) + "\n",
-      stderr: "",
-      exitCode: 0
-    };
-  });
-}
-async function runHandler(name, fn) {
+async function runHandler(subcommand, fn) {
   try {
     return await fn();
   } catch (error) {
-    if (error instanceof SqlCommandError) {
-      return {
-        stdout: "",
-        stderr: `sql ${name}: ${error.message}
-`,
-        exitCode: error.exitCode
-      };
-    }
+    if (error instanceof BashException2) return error.format();
     if (Text2SqlValidationError.isInstance(error) || Text2SqlUnknownAdapterError.isInstance(error)) {
-      return {
-        stdout: "",
-        stderr: `sql ${name}: ${error.message}
-`,
-        exitCode: 1
-      };
+      return new SqlCommandError(subcommand, error.message).format();
     }
     const message = error instanceof Error ? error.message : String(error);
-    return { stdout: "", stderr: `sql ${name}: ${message}
-`, exitCode: 1 };
+    return new SqlCommandError(subcommand, message).format();
   }
 }
-function takeDbAndSql(positional, cmd, text2Sql) {
+function takeDbAndSql(subcommand, positional, text2Sql) {
   const [db, ...rest] = positional;
   const available = text2Sql.adapterNames().join(", ");
   if (!db) {
     throw new SqlCommandError(
-      `missing database name. Usage: sql ${cmd} <db> "SELECT ...". Available: ${available}`,
-      1
+      subcommand,
+      `missing database name. Usage: sql ${subcommand} <db> "SELECT ...". Available: ${available}`
     );
   }
   if (!text2Sql.hasAdapter(db)) {
     throw new SqlCommandError(
-      `unknown database "${db}". Available: ${available}`,
-      1
+      subcommand,
+      `unknown database "${db}". Available: ${available}`
     );
   }
   const sql = rest.join(" ").trim();
   if (!sql) {
-    throw new SqlCommandError("no query provided", 1);
+    throw new SqlCommandError(subcommand, "no query provided");
   }
   return { name: db, sql };
 }
@@ -5829,14 +5785,6 @@ function repairDbNameAndQuotedArg(rawArgs) {
   if (repaired == null) return null;
   return `${dbName} ${repaired}`;
 }
-function dedupe(values) {
-  return [...new Set(values)];
-}
-function countSchemaFragments(fragments) {
-  return fragments.reduce((count, adapterFragment) => {
-    return Array.isArray(adapterFragment.data) ? count + adapterFragment.data.length : count + 1;
-  }, 0);
-}
 export {
   Adapter,
   AdapterIndexer,