@deepagents/text2sql 7.1.4 → 7.3.0

package/README.md

@@ -438,7 +438,8 @@ To let only one caller introspect, acquire a key around `index()`. This example
 uses [`@zukhruf/mutex`](https://www.npmjs.com/package/@zukhruf/mutex):
 
 ```typescript
-import { Mutex, SqliteStore } from '@zukhruf/mutex';
+import { Mutex } from '@zukhruf/mutex';
+import { SqliteStore } from '@zukhruf/mutex/sqlite';
 
 const mutex = new Mutex(new SqliteStore('/var/lib/my-app/locks'));
 

package/dist/bin/sql.js

@@ -10,9 +10,10 @@ import {
 } from "@deepagents/context";
 
 // packages/text2sql/src/lib/file-cache.ts
-import { createHash, randomUUID } from "node:crypto";
+import { atomicWrite } from "@zukhruf/fs";
+import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 var FileCache = class {
@@ -29,9 +30,7 @@ var FileCache = class {
   }
   async set(content) {
     await mkdir(path.dirname(this.path), { recursive: true });
-    const tempPath = `${this.path}.${randomUUID()}.tmp`;
-    await writeFile(tempPath, content, "utf-8");
-    await rename(tempPath, this.path);
+    await atomicWrite(this.path, content);
   }
 };
 var JsonCache = class extends FileCache {
@@ -555,7 +554,7 @@ import {
   mkdir as mkdir2,
   open,
   stat,
-  writeFile as writeFile2
+  writeFile
 } from "node:fs/promises";
 import * as path3 from "node:path";
 import { finished } from "node:stream/promises";
@@ -621,7 +620,7 @@ var IndexCommand = class extends SqlCommand {
           names,
           onProgress: createProgressHandler(eventsStream, verbose, ctx.stderr)
         });
-        await writeFile2(fragmentsPath, JSON.stringify(fragments, null, 2));
+        await writeFile(fragmentsPath, JSON.stringify(fragments, null, 2));
         const manifest = {
           fragmentsPath,
           eventsPath,
@@ -734,7 +733,7 @@ function dedupe(values) {
 }
 
 // packages/text2sql/src/bin/commands/run.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
 import * as path4 from "node:path";
 import { v7 as v72 } from "uuid";
 var RunCommand = class extends SqlQueryCommand {
@@ -749,7 +748,7 @@ var RunCommand = class extends SqlQueryCommand {
     const outPath = path4.join(outputDir, `${v72()}.json`);
     try {
       await mkdir3(outputDir, { recursive: true });
-      await writeFile3(outPath, JSON.stringify(rows, null, 2));
+      await writeFile2(outPath, JSON.stringify(rows, null, 2));
     } catch (error) {
       this.fail(errorMessage2(error));
     }

package/dist/finetune/convert-to-gguf.d.ts

@@ -1,18 +1,2 @@
-/**
- * Convert HuggingFace model to GGUF format using Docker
- * Uses the official llama.cpp image - no local installation needed
- *
- * Usage: node convert-to-gguf.ts <model_dir> <output.gguf> [quantization]
- *
- * Arguments:
- *   model_dir     Path to HuggingFace model directory (contains model.safetensors)
- *   output.gguf   Output path for the GGUF file
- *   quantization  Quantization type (default: q8_0)
- *                 Options: f32, f16, bf16, q8_0, q4_0, q4_1, q5_0, q5_1
- *
- * Examples:
- *   node convert-to-gguf.ts ./qwen3-sql-final ./qwen3-sql.gguf
- *   node convert-to-gguf.ts ./qwen3-sql-final ./qwen3-sql-q4.gguf q4_0
- */
 export {};
 //# sourceMappingURL=convert-to-gguf.d.ts.map

package/dist/finetune/convert-to-gguf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert-to-gguf.d.ts","sourceRoot":"","sources":["../../src/finetune/convert-to-gguf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}
+{"version":3,"file":"convert-to-gguf.d.ts","sourceRoot":"","sources":["../../src/finetune/convert-to-gguf.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -548,9 +548,9 @@ SQL: ${sql.trim()}`,
     return "";
   }
 };
-function filterTablesByName(tables, filter) {
-  if (!filter) return tables;
-  return tables.filter((table2) => matchesFilter(table2.name, filter));
+function filterTablesByName(tables2, filter) {
+  if (!filter) return tables2;
+  return tables2.filter((table2) => matchesFilter(table2.name, filter));
 }
 function filterRelationshipsByTables(relationships, tableNames) {
   if (tableNames === void 0) {
@@ -563,15 +563,15 @@ function filterRelationshipsByTables(relationships, tableNames) {
     (it) => tableNames.has(it.table) || tableNames.has(it.referenced_table)
   );
 }
-function applyTablesFilter(tables, relationships, filter) {
+function applyTablesFilter(tables2, relationships, filter) {
   if (!filter) {
-    return { tables, relationships };
+    return { tables: tables2, relationships };
   }
   const allowedNames = new Set(
-    getTablesWithRelated(tables, relationships, filter)
+    getTablesWithRelated(tables2, relationships, filter)
   );
   return {
-    tables: tables.filter((table2) => allowedNames.has(table2.name)),
+    tables: tables2.filter((table2) => allowedNames.has(table2.name)),
     relationships: filterRelationshipsByTables(relationships, allowedNames)
   };
 }
@@ -1129,9 +1129,10 @@ import {
 } from "@deepagents/context";
 
 // packages/text2sql/src/lib/file-cache.ts
-import { createHash, randomUUID } from "node:crypto";
+import { atomicWrite } from "@zukhruf/fs";
+import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 var FileCache = class {
@@ -1148,9 +1149,7 @@ var FileCache = class {
   }
   async set(content) {
     await mkdir(path.dirname(this.path), { recursive: true });
-    const tempPath = `${this.path}.${randomUUID()}.tmp`;
-    await writeFile(tempPath, content, "utf-8");
-    await rename(tempPath, this.path);
+    await atomicWrite(this.path, content);
   }
 };
 var JsonCache = class extends FileCache {
@@ -1367,8 +1366,9 @@ function errorMessage(error) {
 }
 
 // packages/text2sql/src/lib/checkpoint.ts
+import { durableWrite } from "@zukhruf/fs";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync2, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
 import pLimit from "p-limit";
 import z4 from "zod";
 function jsonCodec(schema) {
@@ -1388,6 +1388,9 @@ var Checkpoint = class _Checkpoint {
   points;
   path;
   configHash;
+  #writes = pLimit(1);
+  #changes = 0;
+  #writtenChanges = 0;
   constructor(path6, configHash, points) {
     this.points = points;
     this.path = path6;
@@ -1484,15 +1487,23 @@ var Checkpoint = class _Checkpoint {
   getPath() {
     return this.path;
   }
-  async save() {
-    const file = {
-      configHash: this.configHash,
-      points: this.points
-    };
-    const content = JSON.stringify(file, null, 2);
-    const tempPath = `${this.path}.tmp`;
-    writeFileSync(tempPath, content);
-    renameSync(tempPath, this.path);
+  /**
+   * Writes one snapshot at a time, so an older snapshot never lands after a
+   * newer one. Each write takes the snapshot when it starts, so a save that
+   * waited behind a write that already holds its change writes nothing.
+   */
+  save() {
+    this.#changes += 1;
+    return this.#writes(async () => {
+      const changes = this.#changes;
+      if (changes === this.#writtenChanges) return;
+      const file = {
+        configHash: this.configHash,
+        points: this.points
+      };
+      await durableWrite(this.path, JSON.stringify(file, null, 2));
+      this.#writtenChanges = changes;
+    });
   }
 };
 function hash(value) {
@@ -1545,6 +1556,7 @@ function hashConfig(config) {
 }
 
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
+import { Declaration } from "@zukhruf/sqlite-drift";
 import { transaction } from "@zukhruf/sqlite-transaction";
 import * as path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
@@ -1555,10 +1567,38 @@ import z5 from "zod";
 var entryType = z5.enum(["file", "directory", "symlink"]);
 var bigintColumn = z5.union([z5.number(), z5.string().regex(/^-?\d+$/)]).transform(Number);
 
-// packages/text2sql/src/lib/fs/sqlite/ddl.sqlite-fs.sql
-var ddl_sqlite_fs_default = "-- SQLite-based filesystem schema for artifact storage\n-- Tables: fs_entries (file/directory metadata), fs_chunks (file content)\n\n-- Performance PRAGMAs (session-level, run on each connection)\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\n\n-- Integrity\nPRAGMA foreign_keys = ON;\n\n-- Filesystem entries table (files, directories, symlinks)\nCREATE TABLE IF NOT EXISTS fs_entries (\n  path TEXT PRIMARY KEY,            -- Normalized absolute path (e.g., '/results/uuid.json')\n  type TEXT NOT NULL,               -- 'file' | 'directory' | 'symlink'\n  mode INTEGER NOT NULL,            -- Unix permissions (e.g., 0o644 = 420)\n  size INTEGER NOT NULL,            -- File size in bytes (0 for directories)\n  mtime INTEGER NOT NULL,           -- Modified time (milliseconds since epoch)\n  symlinkTarget TEXT                -- Target path for symlinks (NULL for files/dirs)\n);\n\nCREATE INDEX IF NOT EXISTS idx_fs_entries_type ON fs_entries(type);\n\n-- File content chunks table (for handling large files)\n-- Files are split into 1MB chunks to avoid SQLite BLOB performance issues\nCREATE TABLE IF NOT EXISTS fs_chunks (\n  path TEXT NOT NULL,               -- Reference to fs_entries.path\n  chunkIndex INTEGER NOT NULL,      -- 0-based chunk sequence\n  data BLOB NOT NULL,               -- Chunk content (up to 1MB default)\n  PRIMARY KEY (path, chunkIndex),\n  FOREIGN KEY (path) REFERENCES fs_entries(path) ON DELETE CASCADE ON UPDATE CASCADE\n);\n";
+// packages/text2sql/src/lib/fs/sqlite/ddl.sqlite-fs.ts
+var SETUP = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+PRAGMA cache_size = -64000;
+PRAGMA temp_store = MEMORY;
+PRAGMA mmap_size = 268435456;
+`;
+var statements = [
+  // Filesystem entries table (files, directories, symlinks)
+  `CREATE TABLE fs_entries (
+  path TEXT PRIMARY KEY,            -- Normalized absolute path (e.g., '/results/uuid.json')
+  type TEXT NOT NULL,               -- 'file' | 'directory' | 'symlink'
+  mode INTEGER NOT NULL,            -- Unix permissions (e.g., 0o644 = 420)
+  size INTEGER NOT NULL,            -- File size in bytes (0 for directories)
+  mtime INTEGER NOT NULL,           -- Modified time (milliseconds since epoch)
+  symlinkTarget TEXT                -- Target path for symlinks (NULL for files/dirs)
+)`,
+  `CREATE INDEX idx_fs_entries_type ON fs_entries(type)`,
+  // File content chunks table (for handling large files)
+  // Files are split into 1MB chunks to avoid SQLite BLOB performance issues
+  `CREATE TABLE fs_chunks (
+  path TEXT NOT NULL,               -- Reference to fs_entries.path
+  chunkIndex INTEGER NOT NULL,      -- 0-based chunk sequence
+  data BLOB NOT NULL,               -- Chunk content (up to 1MB default)
+  PRIMARY KEY (path, chunkIndex),
+  FOREIGN KEY (path) REFERENCES fs_entries(path) ON DELETE CASCADE ON UPDATE CASCADE
+)`
+];
 
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
+var tables = new Declaration(statements, { rows: "keep" });
 var entryRow = z6.object({
   path: z6.string(),
   type: entryType,
@@ -1592,7 +1632,8 @@ var SqliteFs = class {
     const normalizedRoot = this.#normalizeRoot(options.root);
     this.#root = normalizedRoot === "/" ? "" : normalizedRoot;
     this.#db = new DatabaseSync(options.dbPath);
-    this.#db.exec(ddl_sqlite_fs_default);
+    this.#db.exec(SETUP);
+    tables.apply(this.#db);
     this.#sql = this.#db.createTagStore();
     const rootSlashExists = this.#sql.get`SELECT 1 FROM fs_entries WHERE path = '/'`;
     if (!rootSlashExists) {
@@ -4760,8 +4801,8 @@ function cloneInspectionContext(context) {
 function scriptContainsBlockedCommand(script, context, mode = "blocked-only") {
   return statementsContainBlockedCommand(script.statements, context, mode);
 }
-function statementsContainBlockedCommand(statements, context, mode) {
-  for (const statement of statements) {
+function statementsContainBlockedCommand(statements2, context, mode) {
+  for (const statement of statements2) {
     if (statementContainsBlockedCommand(statement, context, mode)) {
       return true;
     }
@@ -5426,9 +5467,9 @@ function rewriteSqlCommandsInList(commands, ast) {
   }
   return rewritten;
 }
-function rewriteSqlCommandsInStatements(statements, ast) {
+function rewriteSqlCommandsInStatements(statements2, ast) {
   let rewritten = false;
-  for (const statement of statements) {
+  for (const statement of statements2) {
     for (const pipeline of statement.pipelines) {
       if (rewriteSqlCommandsInList(pipeline.commands, ast)) {
         rewritten = true;