tradeblocks-mcp 3.0.2 → 3.3.1

package/server/{chunk-NZO6PT64.js → chunk-RM4B2VKS.js}

@@ -3,19 +3,19 @@ import {
   REPORTING_TRADE_COLUMN_ALIASES,
   convertTatRowToReportingTrade,
   isTatFormat
-} from "./chunk-72GKJE2U.js";
+} from "./chunk-RJDJHZ5Y.js";
 
 // src/sync/index.ts
 import { existsSync as existsSync2 } from "fs";
 import * as fs9 from "fs/promises";
-import * as path11 from "path";
+import * as path12 from "path";
 
 // src/db/connection.ts
 import { DuckDBInstance } from "@duckdb/node-api";
 import { execFile } from "child_process";
 import * as fs4 from "fs/promises";
 import * as os from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 import { promisify } from "util";
 
 // src/db/schemas.ts
@@ -211,12 +211,13 @@ async function ensureMarketDataTables(conn) {
 
 // src/db/parquet-writer.ts
 import * as fs from "fs/promises";
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/db/market-datasets.ts
-import * as path from "path";
+import * as path2 from "path";
 
 // src/db/data-root.ts
+import path from "path";
 var KEY = "__tradeblocks_data_root__";
 function setDataRoot(dir) {
   globalThis[KEY] = dir;
@@ -236,26 +237,38 @@ var PARTITIONED_DATASETS = {
   option_quote_minutes: "option_quote_minutes"
 };
 function resolveMarketDir(dataDir) {
-  return path.join(getDataRoot(dataDir), "market");
+  return path2.join(getDataRoot(dataDir), "market");
 }
 function resolveCanonicalMarketFile(dataDir, dataset) {
-  return path.join(resolveMarketDir(dataDir), SINGLE_FILE_DATASETS[dataset]);
+  return path2.join(resolveMarketDir(dataDir), SINGLE_FILE_DATASETS[dataset]);
 }
 function resolveCanonicalMarketPartitionDir(dataDir, dataset) {
-  return path.join(resolveMarketDir(dataDir), PARTITIONED_DATASETS[dataset]);
+  return path2.join(resolveMarketDir(dataDir), PARTITIONED_DATASETS[dataset]);
 }
 var DATASETS_V3 = {
   spot: { subdir: "spot", partitionKeys: ["ticker", "date"], filename: "data.parquet" },
   enriched: { subdir: "enriched", partitionKeys: ["ticker"], filename: "data.parquet" },
   enriched_context: { subdir: "enriched/context", partitionKeys: [], filename: "data.parquet" },
-  option_chain: { subdir: "option_chain", partitionKeys: ["underlying", "date"], filename: "data.parquet" },
-  option_quote_minutes: { subdir: "option_quote_minutes", partitionKeys: ["underlying", "date"], filename: "data.parquet" },
-  option_oi_daily: { subdir: "option_oi_daily", partitionKeys: ["underlying", "date"], filename: "data.parquet" }
+  option_chain: {
+    subdir: "option_chain",
+    partitionKeys: ["underlying", "date"],
+    filename: "data.parquet"
+  },
+  option_quote_minutes: {
+    subdir: "option_quote_minutes",
+    partitionKeys: ["underlying", "date"],
+    filename: "data.parquet"
+  },
+  option_oi_daily: {
+    subdir: "option_oi_daily",
+    partitionKeys: ["underlying", "date"],
+    filename: "data.parquet"
+  }
 };
 async function writeSpotPartition(conn, args) {
   const def = DATASETS_V3.spot;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { ticker: args.ticker, date: args.date },
     // order matches def.partitionKeys
     selectQuery: args.selectQuery,
@@ -266,7 +279,7 @@ async function writeSpotPartition(conn, args) {
 async function writeChainPartition(conn, args) {
   const def = DATASETS_V3.option_chain;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: args.selectQuery,
     compression: args.compression,
@@ -277,7 +290,7 @@ async function writeQuoteMinutesPartition(conn, args) {
   const def = DATASETS_V3.option_quote_minutes;
   const sortedSelect = `SELECT * FROM (${args.selectQuery}) AS q ORDER BY q.ticker, q.time`;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: sortedSelect,
     compression: args.compression,
@@ -288,7 +301,7 @@ async function writeOiDailyPartition(conn, args) {
   const def = DATASETS_V3.option_oi_daily;
   const sortedSelect = `SELECT * FROM (${args.selectQuery}) AS q ORDER BY q.ticker`;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: sortedSelect,
     compression: args.compression,
@@ -310,7 +323,7 @@ async function writeParquetAtomic(conn, opts) {
   const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   try {
     await conn.run(`CREATE TEMP TABLE "${stagingName}" AS ${selectQuery}`);
-    await fs.mkdir(path2.dirname(targetPath), { recursive: true });
+    await fs.mkdir(path3.dirname(targetPath), { recursive: true });
     await conn.run(
       `COPY "${stagingName}" TO '${tempPath}' (FORMAT PARQUET, COMPRESSION ${compression})`
     );
@@ -341,9 +354,7 @@ async function writeParquetPartition(conn, opts) {
   const filename = isLegacy ? "data.parquet" : opts.filename ?? "data.parquet";
   for (const [k, v] of Object.entries(partitions)) {
     if (!PARTITION_KEY_RE.test(k)) {
-      throw new Error(
-        `writeParquetPartition: unsafe partition key: ${JSON.stringify(k)}`
-      );
+      throw new Error(`writeParquetPartition: unsafe partition key: ${JSON.stringify(k)}`);
     }
     if (!PARTITION_VALUE_RE.test(v)) {
       throw new Error(
@@ -351,10 +362,8 @@ async function writeParquetPartition(conn, opts) {
       );
     }
   }
-  const partitionSegments = Object.entries(partitions).map(
-    ([k, v]) => `${k}=${v}`
-  );
-  const targetPath = path2.join(opts.baseDir, ...partitionSegments, filename);
+  const partitionSegments = Object.entries(partitions).map(([k, v]) => `${k}=${v}`);
+  const targetPath = path3.join(opts.baseDir, ...partitionSegments, filename);
   return writeParquetAtomic(conn, {
     targetPath,
     selectQuery: opts.selectQuery,
@@ -364,18 +373,18 @@ async function writeParquetPartition(conn, opts) {
 
 // src/db/json-adapters.ts
 import * as fs3 from "fs/promises";
-import * as path4 from "path";
+import * as path5 from "path";
 import { z } from "zod";
 
 // src/db/json-store.ts
 import * as fs2 from "fs/promises";
-import * as path3 from "path";
+import * as path4 from "path";
 function isEnoent(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
 }
 async function writeJsonFile(filePath, data) {
   const tmpPath = filePath + ".tmp";
-  await fs2.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs2.mkdir(path4.dirname(filePath), { recursive: true });
   await fs2.writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
   await fs2.rename(tmpPath, filePath);
 }
@@ -404,7 +413,7 @@ async function deleteJsonFile(filePath) {
 async function listJsonFiles(dirPath, suffix = ".json") {
   try {
     const entries = await fs2.readdir(dirPath, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && e.name.endsWith(suffix)).map((e) => path3.join(dirPath, e.name)).sort();
+    return entries.filter((e) => e.isFile() && e.name.endsWith(suffix)).map((e) => path4.join(dirPath, e.name)).sort();
   } catch (err) {
     if (isEnoent(err)) {
       return [];
@@ -432,7 +441,7 @@ function jsonToProfile(json) {
   };
 }
 function profilePath(blockId, strategyName, blocksDir) {
-  return path4.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
+  return path5.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
 }
 async function upsertProfileJson(profile, blocksDir) {
   const filePath = profilePath(profile.blockId, profile.strategyName, blocksDir);
@@ -454,7 +463,7 @@ async function getProfileJson(blockId, strategyName, blocksDir) {
 }
 async function listProfilesJson(blocksDir, blockId) {
   if (blockId) {
-    const profileDir = path4.join(blocksDir, blockId, "profiles");
+    const profileDir = path5.join(blocksDir, blockId, "profiles");
     const files = await listJsonFiles(profileDir);
     const profiles2 = [];
     for (const file of files) {
@@ -494,7 +503,7 @@ function jsonToSyncMeta(json) {
   };
 }
 function syncMetaPath(blockId, blocksDir) {
-  return path4.join(blocksDir, blockId, ".sync-meta.json");
+  return path5.join(blocksDir, blockId, ".sync-meta.json");
 }
 async function getSyncMetadataJson(blockId, blocksDir) {
   const filePath = syncMetaPath(blockId, blocksDir);
@@ -532,7 +541,7 @@ function marketMetaKey(source, ticker, targetTable) {
   return `${source}|${ticker}|${targetTable}`;
 }
 function marketMetaFilePath(dataDir) {
-  return path4.join(getDataRoot(dataDir), "market-meta", "sync-metadata.json");
+  return path5.join(getDataRoot(dataDir), "market-meta", "sync-metadata.json");
 }
 async function upsertMarketImportMetadataJson(metadata, dataDir) {
   const filePath = marketMetaFilePath(dataDir);
@@ -548,7 +557,7 @@ function flatLogKey(entry) {
   return `${entry.date}|${entry.asset_class}|${entry.underlying}`;
 }
 function flatLogFilePath(dataDir) {
-  return path4.join(getDataRoot(dataDir), "market-meta", "flat-import-log.json");
+  return path5.join(getDataRoot(dataDir), "market-meta", "flat-import-log.json");
 }
 async function upsertFlatImportLogJson(entry, dataDir) {
   const filePath = flatLogFilePath(dataDir);
@@ -574,16 +583,14 @@ var EnrichmentWatermarksSchema = z.object({
   watermarks: z.record(z.string().regex(/^[A-Z0-9._-]+$/), TickerEntrySchema)
 });
 function watermarksFilePath(dataDir) {
-  return path4.join(getDataRoot(dataDir), "market-meta", "enrichment-watermarks.json");
+  return path5.join(getDataRoot(dataDir), "market-meta", "enrichment-watermarks.json");
 }
 async function loadEnrichmentWatermarks(dataDir) {
   const raw = await readJsonFile(watermarksFilePath(dataDir));
   if (raw === null) return { version: 1, watermarks: {} };
   const parsed = EnrichmentWatermarksSchema.safeParse(raw);
   if (!parsed.success) {
-    throw new Error(
-      `enrichment-watermarks.json is malformed: ${parsed.error.message}`
-    );
+    throw new Error(`enrichment-watermarks.json is malformed: ${parsed.error.message}`);
   }
   return parsed.data;
 }
@@ -624,13 +631,27 @@ async function ensureProfilesSchema(conn) {
   await conn.run(`
     ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS position_sizing JSON
   `);
-  await conn.run(`ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS underlying VARCHAR`);
-  await conn.run(`ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS re_entry BOOLEAN`);
-  await conn.run(`ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS cap_profits BOOLEAN`);
-  await conn.run(`ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS cap_losses BOOLEAN`);
-  await conn.run(`ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS require_two_prices_pt BOOLEAN`);
-  await conn.run(`ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS close_on_completion BOOLEAN`);
-  await conn.run(`ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS ignore_margin_req BOOLEAN`);
+  await conn.run(
+    `ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS underlying VARCHAR`
+  );
+  await conn.run(
+    `ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS re_entry BOOLEAN`
+  );
+  await conn.run(
+    `ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS cap_profits BOOLEAN`
+  );
+  await conn.run(
+    `ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS cap_losses BOOLEAN`
+  );
+  await conn.run(
+    `ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS require_two_prices_pt BOOLEAN`
+  );
+  await conn.run(
+    `ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS close_on_completion BOOLEAN`
+  );
+  await conn.run(
+    `ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS ignore_margin_req BOOLEAN`
+  );
   const strategyCols = [
     { name: "slippage_entry", type: "DOUBLE" },
     { name: "slippage_exit", type: "DOUBLE" },
@@ -644,7 +665,9 @@ async function ensureProfilesSchema(conn) {
     { name: "default_to_date", type: "VARCHAR" }
   ];
   for (const col of strategyCols) {
-    await conn.run(`ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS ${col.name} ${col.type}`);
+    await conn.run(
+      `ALTER TABLE profiles.strategy_profiles ADD COLUMN IF NOT EXISTS ${col.name} ${col.type}`
+    );
   }
   await migrateExpectedRegimes(conn);
 }
@@ -867,7 +890,7 @@ async function deleteProfile(conn, blockId, strategyName, baseDir) {
 
 // src/db/market-views.ts
 import { existsSync, readdirSync } from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 
 // src/utils/quote-parquet-projection.ts
 var describeCache = /* @__PURE__ */ new Map();
@@ -976,12 +999,12 @@ function hasParquetPartitions(dir, partitionKey = "date") {
     const prefix = `${partitionKey}=`;
     return readdirSync(dir).some((entry) => {
       if (!entry.startsWith(prefix)) return false;
-      const partDir = path5.join(dir, entry);
+      const partDir = path6.join(dir, entry);
       try {
         const entries = readdirSync(partDir);
         for (const sub of entries) {
           if (sub.endsWith(".parquet")) return true;
-          const nested = path5.join(partDir, sub);
+          const nested = path6.join(partDir, sub);
           try {
             if (readdirSync(nested).some((f) => f.endsWith(".parquet"))) return true;
           } catch {
@@ -1001,20 +1024,24 @@ function hasEnrichedTickerFiles(dir) {
   try {
     return readdirSync(dir).some((entry) => {
       if (!entry.startsWith("ticker=")) return false;
-      return existsSync(path5.join(dir, entry, "data.parquet"));
+      return existsSync(path6.join(dir, entry, "data.parquet"));
     });
   } catch {
     return false;
   }
 }
 function hasEnrichedContextFile(dir) {
-  return existsSync(path5.join(dir, "context", "data.parquet"));
+  return existsSync(path6.join(dir, "context", "data.parquet"));
 }
 async function createMarketParquetViews(conn, dataDir) {
   const viewsCreated = [];
   const tablesKept = [];
   const hiveViews = [
-    { name: "option_chain", subdir: resolveCanonicalMarketPartitionDir(dataDir, "option_chain"), partitionKey: "underlying" }
+    {
+      name: "option_chain",
+      subdir: resolveCanonicalMarketPartitionDir(dataDir, "option_chain"),
+      partitionKey: "underlying"
+    }
   ];
   for (const { name, subdir, partitionKey } of hiveViews) {
     const dirPath = subdir;
@@ -1085,7 +1112,7 @@ async function createMarketParquetViews(conn, dataDir) {
     await conn.run("DROP TABLE IF EXISTS market.option_delta_index");
   } catch {
   }
-  const spotDir = path5.join(resolveMarketDir(dataDir), "spot");
+  const spotDir = path6.join(resolveMarketDir(dataDir), "spot");
   if (hasParquetPartitions(spotDir, "ticker")) {
     try {
       await conn.run("DROP VIEW  IF EXISTS market.spot");
@@ -1107,7 +1134,7 @@ async function createMarketParquetViews(conn, dataDir) {
     }
     tablesKept.push("spot");
   }
-  const enrichedDir = path5.join(resolveMarketDir(dataDir), "enriched");
+  const enrichedDir = path6.join(resolveMarketDir(dataDir), "enriched");
   if (hasEnrichedTickerFiles(enrichedDir)) {
     try {
       await conn.run("DROP VIEW  IF EXISTS market.enriched");
@@ -1140,7 +1167,7 @@ async function createMarketParquetViews(conn, dataDir) {
     }
     await conn.run(
       `CREATE OR REPLACE VIEW market.enriched_context AS
-       SELECT * FROM read_parquet('${path5.join(enrichedDir, "context", "data.parquet")}')`
+       SELECT * FROM read_parquet('${path6.join(enrichedDir, "context", "data.parquet")}')`
     );
     viewsCreated.push("enriched_context");
   } else {
@@ -1205,7 +1232,7 @@ async function createMarketParquetViews(conn, dataDir) {
 }
 
 // src/db/json-migration.ts
-import * as path6 from "path";
+import * as path7 from "path";
 function toDate2(value) {
   if (value instanceof Date) return value;
   if (typeof value === "object" && value !== null && "micros" in value) {
@@ -1282,12 +1309,7 @@ async function migrateProfiles(conn, blocksDir) {
       createdAt: createdAt.toISOString(),
       updatedAt: updatedAt.toISOString()
     };
-    const filePath = path6.join(
-      blocksDir,
-      blockId,
-      "profiles",
-      toFileSlug(strategyName) + ".json"
-    );
+    const filePath = path7.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
     await writeJsonFile(filePath, profileJson);
   }
   return rows.length;
@@ -1320,7 +1342,7 @@ async function migrateSyncMetadata(conn, blocksDir) {
   return rows.length;
 }
 async function migrateMarketImportMetadata(conn, dataDir) {
-  const existingFile = await readJsonFile(path6.join(dataDir, "market-meta", "sync-metadata.json"));
+  const existingFile = await readJsonFile(path7.join(dataDir, "market-meta", "sync-metadata.json"));
   if (existingFile !== null) return 0;
   let rows;
   try {
@@ -1346,7 +1368,9 @@ async function migrateMarketImportMetadata(conn, dataDir) {
   return rows.length;
 }
 async function migrateFlatImportLog(conn, dataDir) {
-  const existingFile = await readJsonFile(path6.join(dataDir, "market-meta", "flat-import-log.json"));
+  const existingFile = await readJsonFile(
+    path7.join(dataDir, "market-meta", "flat-import-log.json")
+  );
   if (existingFile !== null) return 0;
   let rows;
   try {
@@ -1490,7 +1514,7 @@ async function tryRecoverLockByTerminatingStaleProcess(errorMessage, dbPath, for
     return false;
   }
   const normalizedDbPath = dbPath.replace(/\\/g, "/");
-  const normalizedDbDir = path7.dirname(normalizedDbPath);
+  const normalizedDbDir = path8.dirname(normalizedDbPath);
   const isTradeblocksProcess = command.includes("tradeblocks-mcp") || command.includes("/mcp-server/server/index.js") || command.includes("packages/mcp-server/server/index.js") || command.includes("\\mcp-server\\server\\index.js") || command.includes("packages\\mcp-server\\server\\index.js");
   const normalizedCommand = command.replace(/\\/g, "/");
   const targetsSameDb = normalizedCommand.includes(normalizedDbPath) || normalizedCommand.includes(normalizedDbDir);
@@ -1524,16 +1548,16 @@ function resolveMarketDbPath(dataDir) {
   const args = process.argv;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--market-db" && args[i + 1]) {
-      return path7.resolve(args[i + 1]);
+      return path8.resolve(args[i + 1]);
     }
   }
   if (process.env.MARKET_DB_PATH) {
-    return path7.resolve(process.env.MARKET_DB_PATH);
+    return path8.resolve(process.env.MARKET_DB_PATH);
   }
-  return path7.join(dataDir, "market.duckdb");
+  return path8.join(dataDir, "market.duckdb");
 }
 async function attachMarketDb(conn, marketDbPath, mode) {
-  await fs4.mkdir(path7.dirname(marketDbPath), { recursive: true });
+  await fs4.mkdir(path8.dirname(marketDbPath), { recursive: true });
   const readOnlyClause = mode === "read_only" ? " (READ_ONLY)" : "";
   const escapedPath = marketDbPath.replace(/'/g, "''");
   try {
@@ -1580,15 +1604,18 @@ async function openReadWriteConnection(dbPath, threads, memoryLimit) {
   await ensureReportingDataTable(connection);
   await ensureMutableMarketTables(connection);
   await ensureProfilesSchema(connection);
-  const dataDir = path7.dirname(dbPath);
+  const dataDir = path8.dirname(dbPath);
   const dataRoot = getDataRoot(dataDir);
   await createMarketParquetViews(connection, dataRoot);
   await ensureMarketDataTables(connection);
   try {
-    const blocksDir = (await import("./sync-QFI5L7S7.js")).getBlocksDir(dataRoot);
+    const blocksDir = (await import("./sync-CENKDN53.js")).getBlocksDir(dataRoot);
     await migrateMetadataToJson(connection, dataRoot, blocksDir);
   } catch (err) {
-    console.warn("[json-migration] Migration failed (non-fatal):", err instanceof Error ? err.message : err);
+    console.warn(
+      "[json-migration] Migration failed (non-fatal):",
+      err instanceof Error ? err.message : err
+    );
   }
   connectionMode = "read_write";
   return connection;
@@ -1628,7 +1655,7 @@ async function getConnection(dataDir) {
   if (connection) {
     return connection;
   }
-  const dbPath = path7.join(dataDir, "analytics.duckdb");
+  const dbPath = path8.join(dataDir, "analytics.duckdb");
   const threads = process.env.DUCKDB_THREADS || defaultThreads();
   const memoryLimit = process.env.DUCKDB_MEMORY_LIMIT || defaultMemoryLimit();
   storedDbPath = dbPath;
@@ -1643,7 +1670,11 @@ async function getConnection(dataDir) {
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     if (isLockError(errorMessage)) {
-      const recovered = await tryRecoverLockByTerminatingStaleProcess(errorMessage, dbPath, forceRecovery);
+      const recovered = await tryRecoverLockByTerminatingStaleProcess(
+        errorMessage,
+        dbPath,
+        forceRecovery
+      );
       if (recovered) {
         for (let attempt = 0; attempt < 3; attempt++) {
           await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
@@ -1701,7 +1732,7 @@ async function closeConnection() {
 async function upgradeToReadWrite(dataDir, options) {
   if (connectionMode === "read_write" && connection) return connection;
   await closeConnection();
-  const dbPath = storedDbPath || path7.join(dataDir, "analytics.duckdb");
+  const dbPath = storedDbPath || path8.join(dataDir, "analytics.duckdb");
   const threads = storedThreads || process.env.DUCKDB_THREADS || defaultThreads();
   const memoryLimit = storedMemoryLimit || process.env.DUCKDB_MEMORY_LIMIT || defaultMemoryLimit();
   if (!storedMarketDbPath) {
@@ -1755,7 +1786,7 @@ function getCurrentConnection() {
 
 // src/sync/block-sync.ts
 import * as fs8 from "fs/promises";
-import * as path10 from "path";
+import * as path11 from "path";
 
 // src/sync/hasher.ts
 import * as crypto from "crypto";
@@ -1813,18 +1844,13 @@ async function deleteSyncMetadata(conn, blockId, blocksDir) {
     await deleteSyncMetadataJson(blockId, blocksDir);
     return;
   }
-  await conn.run(
-    `DELETE FROM trades._sync_metadata WHERE block_id = $1`,
-    [blockId]
-  );
+  await conn.run(`DELETE FROM trades._sync_metadata WHERE block_id = $1`, [blockId]);
 }
 async function getAllSyncedBlockIds(conn, blocksDir) {
   if (isParquetMode() && blocksDir) {
     return getAllSyncedBlockIdsJson(blocksDir);
   }
-  const reader = await conn.runAndReadAll(
-    `SELECT block_id FROM trades._sync_metadata`
-  );
+  const reader = await conn.runAndReadAll(`SELECT block_id FROM trades._sync_metadata`);
   const rows = reader.getRows();
   return rows.map((row) => row[0]);
 }
@@ -1876,11 +1902,11 @@ function marketTickerDateKey(ticker, date) {
 
 // src/utils/block-loader.ts
 import * as fs7 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // src/utils/csv-discovery.ts
 import * as fs6 from "fs/promises";
-import * as path8 from "path";
+import * as path9 from "path";
 function parseCSVLine(line) {
   const result = [];
   let current = "";
@@ -1961,12 +1987,8 @@ async function detectCsvType(filePath) {
     const reportingAliases = Object.keys(REPORTING_TRADE_COLUMN_ALIASES).map(
       (k) => k.toLowerCase()
     );
-    const hasReportingColumns = reportingAliases.some(
-      (alias) => headers.includes(alias)
-    );
-    const hasActualPl = headers.some(
-      (h) => h.includes("actual") && h.includes("p")
-    );
+    const hasReportingColumns = reportingAliases.some((alias) => headers.includes(alias));
+    const hasActualPl = headers.some((h) => h.includes("actual") && h.includes("p"));
     const hasReportedStyle = headers.includes("trade id") || headers.some((h) => h.includes("reported"));
     if (hasActualPl || hasReportingColumns || hasReportedStyle) {
       if (!hasPl || hasActualPl) {
@@ -2009,7 +2031,7 @@ async function discoverCsvFiles(folderPath) {
       if (csvFile === "tradelog.csv" || csvFile === "dailylog.csv" || csvFile === "reportinglog.csv" || csvFile === mappings.reportinglog) {
         continue;
       }
-      const csvPath = path8.join(folderPath, csvFile);
+      const csvPath = path9.join(folderPath, csvFile);
       const detectedType = await detectCsvType(csvPath);
       if (detectedType) {
         if (detectedType === "tradelog" && !mappings.tradelog) {
@@ -2198,7 +2220,7 @@ function convertToDailyLogEntry(raw, blockId) {
   }
 }
 async function loadTrades(blockPath, filename = "tradelog.csv", blockId) {
-  const tradelogPath = path9.join(blockPath, filename);
+  const tradelogPath = path10.join(blockPath, filename);
   const content = await fs7.readFile(tradelogPath, "utf-8");
   const records = parseCSV(content);
   const trades = [];
@@ -2216,7 +2238,7 @@ async function loadTrades(blockPath, filename = "tradelog.csv", blockId) {
   return trades;
 }
 async function loadDailyLogs(blockPath, blockId, filename = "dailylog.csv") {
-  const dailylogPath = path9.join(blockPath, filename);
+  const dailylogPath = path10.join(blockPath, filename);
   try {
     await fs7.access(dailylogPath);
     const content = await fs7.readFile(dailylogPath, "utf-8");
@@ -2228,9 +2250,7 @@ async function loadDailyLogs(blockPath, blockId, filename = "dailylog.csv") {
         entries.push(entry);
       }
     }
-    entries.sort(
-      (a, b) => new Date(a.date).getTime() - new Date(b.date).getTime()
-    );
+    entries.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
     return entries.length > 0 ? entries : void 0;
   } catch {
     return void 0;
@@ -2238,10 +2258,10 @@ async function loadDailyLogs(blockPath, blockId, filename = "dailylog.csv") {
 }
 async function loadBlock(baseDir, blockId) {
   const blocksDir = resolveBlocksBaseDir(baseDir);
-  const blockPath = path9.join(blocksDir, blockId);
+  const blockPath = path10.join(blocksDir, blockId);
   const { mappings } = await discoverCsvFiles(blockPath);
   const tradelogFilename = mappings.tradelog || "tradelog.csv";
-  const tradelogPath = path9.join(blockPath, tradelogFilename);
+  const tradelogPath = path10.join(blockPath, tradelogFilename);
   try {
     await fs7.access(tradelogPath);
   } catch {
@@ -2411,7 +2431,7 @@ async function listBlocks(baseDir) {
         }
         blocks.push(info);
       } else if (!stats) {
-        const blockPath = path9.join(blocksDir, blockId);
+        const blockPath = path10.join(blocksDir, blockId);
         try {
           const { mappings } = await discoverCsvFiles(blockPath);
           if (mappings.tradelog) {
@@ -2439,14 +2459,12 @@ async function listBlocks(baseDir) {
 }
 function normalizeRecordHeaders(raw) {
   const normalized = { ...raw };
-  Object.entries(REPORTING_TRADE_COLUMN_ALIASES).forEach(
-    ([alias, canonical]) => {
-      if (normalized[alias] !== void 0) {
-        normalized[canonical] = normalized[alias];
-        delete normalized[alias];
-      }
+  Object.entries(REPORTING_TRADE_COLUMN_ALIASES).forEach(([alias, canonical]) => {
+    if (normalized[alias] !== void 0) {
+      normalized[canonical] = normalized[alias];
+      delete normalized[alias];
     }
-  );
+  });
   return normalized;
 }
 function convertToReportingTrade(raw) {
@@ -2481,10 +2499,10 @@ function convertToReportingTrade(raw) {
 }
 async function loadReportingLog(baseDir, blockId) {
   const blocksDir = resolveBlocksBaseDir(baseDir);
-  const blockPath = path9.join(blocksDir, blockId);
+  const blockPath = path10.join(blocksDir, blockId);
   const { mappings } = await discoverCsvFiles(blockPath);
   const filename = mappings.reportinglog || "reportinglog.csv";
-  const reportingLogPath = path9.join(blockPath, filename);
+  const reportingLogPath = path10.join(blockPath, filename);
   try {
     await fs7.access(reportingLogPath);
   } catch {
@@ -2499,9 +2517,7 @@ async function loadReportingLog(baseDir, blockId) {
       trades.push(trade);
     }
   }
-  trades.sort(
-    (a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime()
-  );
+  trades.sort((a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime());
   return trades;
 }
 function toKebabCase(str) {
@@ -2541,9 +2557,7 @@ function validateCsvColumns(records, csvType) {
       }
       const dateOpenedAliases = ["Date Opened", "date_opened"];
       const plAliases = ["P/L", "pl"];
-      const hasDateOpened = dateOpenedAliases.some(
-        (col) => headers.includes(col)
-      );
+      const hasDateOpened = dateOpenedAliases.some((col) => headers.includes(col));
       const hasPl = plAliases.some((col) => headers.includes(col));
       const missing = [];
       if (!hasDateOpened) missing.push("Date Opened");
@@ -2583,11 +2597,9 @@ async function importCsv(baseDir, options) {
   const name = blockName;
   const blockId = toKebabCase(name);
   if (!blockId) {
-    throw new Error(
-      "Could not derive a valid block ID from the filename or provided name"
-    );
+    throw new Error("Could not derive a valid block ID from the filename or provided name");
   }
-  const blockPath = path9.join(blocksDir, blockId);
+  const blockPath = path10.join(blocksDir, blockId);
   try {
     await fs7.access(blockPath);
     throw new Error(
@@ -2600,7 +2612,7 @@ async function importCsv(baseDir, options) {
   }
   await fs7.mkdir(blockPath, { recursive: true });
   const targetFilename = csvType === "tradelog" ? "tradelog.csv" : csvType === "dailylog" ? "dailylog.csv" : "reportinglog.csv";
-  const targetPath = path9.join(blockPath, targetFilename);
+  const targetPath = path10.join(blockPath, targetFilename);
   await fs7.copyFile(csvPath, targetPath);
   let dateRange = {
     start: null,
@@ -2744,10 +2756,7 @@ async function insertTradeBatch(conn, blockId, records, startIdx, batchSize) {
   for (let rowIdx = 0; rowIdx < batch.length; rowIdx++) {
     const record = batch[rowIdx];
     const baseParam = rowIdx * columnsPerRow + 1;
-    const rowPlaceholders = Array.from(
-      { length: columnsPerRow },
-      (_, i) => `$${baseParam + i}`
-    );
+    const rowPlaceholders = Array.from({ length: columnsPerRow }, (_, i) => `$${baseParam + i}`);
     placeholders.push(`(${rowPlaceholders.join(", ")})`);
     const premium = parseFloat(record["Premium"]);
     const numContracts = parseInt(record["No. of Contracts"], 10);
@@ -2815,10 +2824,7 @@ async function insertReportingBatch(conn, blockId, trades, tickers, startIdx, ba
   for (let rowIdx = 0; rowIdx < batch.length; rowIdx++) {
     const trade = batch[rowIdx];
     const baseParam = rowIdx * columnsPerRow + 1;
-    const rowPlaceholders = Array.from(
-      { length: columnsPerRow },
-      (_, i) => `$${baseParam + i}`
-    );
+    const rowPlaceholders = Array.from({ length: columnsPerRow }, (_, i) => `$${baseParam + i}`);
     placeholders.push(`(${rowPlaceholders.join(", ")})`);
     params.push(
       blockId,
@@ -2852,7 +2858,7 @@ function versionedHash(hash) {
   return `${hash}:${PARSE_VERSION}`;
 }
 async function syncBlockInternal(conn, blockId, blockPath) {
-  const blocksDir = path10.dirname(blockPath);
+  const blocksDir = path11.dirname(blockPath);
   try {
     const existingMetadata = await getSyncMetadata(conn, blockId, blocksDir);
     const tradelogFilename = await findTradelogFile(blockPath);
@@ -2860,14 +2866,8 @@ async function syncBlockInternal(conn, blockId, blockPath) {
       if (existingMetadata) {
         await conn.run("BEGIN TRANSACTION");
         try {
-          await conn.run(
-            "DELETE FROM trades.trade_data WHERE block_id = $1",
-            [blockId]
-          );
-          await conn.run(
-            "DELETE FROM trades.reporting_data WHERE block_id = $1",
-            [blockId]
-          );
+          await conn.run("DELETE FROM trades.trade_data WHERE block_id = $1", [blockId]);
+          await conn.run("DELETE FROM trades.reporting_data WHERE block_id = $1", [blockId]);
           await deleteSyncMetadata(conn, blockId, blocksDir);
           await conn.run("COMMIT");
           return { blockId, status: "deleted" };
@@ -2882,12 +2882,12 @@ async function syncBlockInternal(conn, blockId, blockPath) {
         error: "No tradelog CSV found in block"
       };
     }
-    const tradelogPath = path10.join(blockPath, tradelogFilename);
+    const tradelogPath = path11.join(blockPath, tradelogFilename);
     const tradelogHash = versionedHash(await hashFileContent(tradelogPath));
     if (existingMetadata && existingMetadata.tradelog_hash === tradelogHash) {
       const optionalLogs = await findOptionalLogFiles(blockPath);
       if (optionalLogs.reportinglog) {
-        const reportinglogPath = path10.join(blockPath, optionalLogs.reportinglog);
+        const reportinglogPath = path11.join(blockPath, optionalLogs.reportinglog);
         const reportinglogHash = versionedHash(await hashFileContent(reportinglogPath));
         if (existingMetadata.reportinglog_hash !== reportinglogHash) {
         } else {
@@ -2902,10 +2902,7 @@ async function syncBlockInternal(conn, blockId, blockPath) {
     }
     await conn.run("BEGIN TRANSACTION");
     try {
-      await conn.run(
-        "DELETE FROM trades.trade_data WHERE block_id = $1",
-        [blockId]
-      );
+      await conn.run("DELETE FROM trades.trade_data WHERE block_id = $1", [blockId]);
       const csvContent = await fs8.readFile(tradelogPath, "utf-8");
       const records = parseCSV2(csvContent);
       const batchSize = 500;
@@ -2917,26 +2914,23 @@ async function syncBlockInternal(conn, blockId, blockPath) {
       let reportinglogHash = null;
       if (optionalLogs.dailylog) {
         try {
-          dailylogHash = versionedHash(await hashFileContent(
-            path10.join(blockPath, optionalLogs.dailylog)
-          ));
+          dailylogHash = versionedHash(
+            await hashFileContent(path11.join(blockPath, optionalLogs.dailylog))
+          );
         } catch {
         }
       }
       if (optionalLogs.reportinglog) {
         try {
-          reportinglogHash = versionedHash(await hashFileContent(
-            path10.join(blockPath, optionalLogs.reportinglog)
-          ));
+          reportinglogHash = versionedHash(
+            await hashFileContent(path11.join(blockPath, optionalLogs.reportinglog))
+          );
         } catch {
         }
       }
-      await conn.run(
-        "DELETE FROM trades.reporting_data WHERE block_id = $1",
-        [blockId]
-      );
+      await conn.run("DELETE FROM trades.reporting_data WHERE block_id = $1", [blockId]);
       if (optionalLogs.reportinglog && reportinglogHash) {
-        const reportingPath = path10.join(blockPath, optionalLogs.reportinglog);
+        const reportingPath = path11.join(blockPath, optionalLogs.reportinglog);
         const reportingContent = await fs8.readFile(reportingPath, "utf-8");
         const reportingRecords = parseCSV2(reportingContent);
         const reportingTrades = [];
@@ -2949,7 +2943,14 @@ async function syncBlockInternal(conn, blockId, blockPath) {
           }
         }
         for (let i = 0; i < reportingTrades.length; i += batchSize) {
-          await insertReportingBatch(conn, blockId, reportingTrades, reportingTickers, i, batchSize);
+          await insertReportingBatch(
+            conn,
+            blockId,
+            reportingTrades,
+            reportingTickers,
+            i,
+            batchSize
+          );
         }
       }
       const newMetadata = {
@@ -2972,14 +2973,8 @@ async function syncBlockInternal(conn, blockId, blockPath) {
       if (existingMetadata) {
         try {
           await conn.run("BEGIN TRANSACTION");
-          await conn.run(
-            "DELETE FROM trades.trade_data WHERE block_id = $1",
-            [blockId]
-          );
-          await conn.run(
-            "DELETE FROM trades.reporting_data WHERE block_id = $1",
-            [blockId]
-          );
+          await conn.run("DELETE FROM trades.trade_data WHERE block_id = $1", [blockId]);
+          await conn.run("DELETE FROM trades.reporting_data WHERE block_id = $1", [blockId]);
           await deleteSyncMetadata(conn, blockId, blocksDir);
           await conn.run("COMMIT");
         } catch {
@@ -3009,10 +3004,11 @@ async function detectBlockChanges(conn, baseDir) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    if (entry.name.endsWith(".tmp") || entry.name.endsWith(".duckdb") || entry.name.endsWith(".duckdb.tmp")) continue;
+    if (entry.name.endsWith(".tmp") || entry.name.endsWith(".duckdb") || entry.name.endsWith(".duckdb.tmp"))
+      continue;
     const blockId = entry.name;
     folderNames.add(blockId);
-    const blockPath = path10.join(baseDir, blockId);
+    const blockPath = path11.join(baseDir, blockId);
     if (!syncedBlockIds.has(blockId)) {
       const tradelog = await findTradelogFile(blockPath);
       if (tradelog) {
@@ -3026,7 +3022,7 @@ async function detectBlockChanges(conn, baseDir) {
       continue;
     }
     try {
-      const tradelogPath = path10.join(blockPath, tradelogFilename);
+      const tradelogPath = path11.join(blockPath, tradelogFilename);
       const currentHash = versionedHash(await hashFileContent(tradelogPath));
       const metadata = await getSyncMetadata(conn, blockId, baseDir);
       if (!metadata || metadata.tradelog_hash !== currentHash) {
@@ -3034,7 +3030,7 @@ async function detectBlockChanges(conn, baseDir) {
       } else {
         const optionalLogs = await findOptionalLogFiles(blockPath);
         if (optionalLogs.reportinglog) {
-          const reportinglogPath = path10.join(blockPath, optionalLogs.reportinglog);
+          const reportinglogPath = path11.join(blockPath, optionalLogs.reportinglog);
           const reportingHash = versionedHash(await hashFileContent(reportinglogPath));
           if (metadata.reportinglog_hash !== reportingHash) {
             toSync.push(blockId);
@@ -3058,14 +3054,8 @@ async function cleanupDeletedBlocks(conn, deletedBlockIds, blocksDir) {
   for (const blockId of deletedBlockIds) {
     await conn.run("BEGIN TRANSACTION");
     try {
-      await conn.run(
-        "DELETE FROM trades.trade_data WHERE block_id = $1",
-        [blockId]
-      );
-      await conn.run(
-        "DELETE FROM trades.reporting_data WHERE block_id = $1",
-        [blockId]
-      );
+      await conn.run("DELETE FROM trades.trade_data WHERE block_id = $1", [blockId]);
+      await conn.run("DELETE FROM trades.reporting_data WHERE block_id = $1", [blockId]);
       await deleteSyncMetadata(conn, blockId, blocksDir);
       await conn.run("COMMIT");
     } catch (err) {
@@ -3082,7 +3072,7 @@ function setBlocksDir(dir) {
 }
 function getBlocksDir(baseDir) {
   if (_blocksDir) return _blocksDir;
-  const nestedBlocksDir = path11.join(baseDir, "blocks");
+  const nestedBlocksDir = path12.join(baseDir, "blocks");
   return existsSync2(nestedBlocksDir) ? nestedBlocksDir : baseDir;
 }
 async function syncAllBlocks(baseDir) {
@@ -3101,7 +3091,7 @@ async function syncAllBlocks(baseDir) {
     }
   }
   for (const blockId of toSync) {
-    const blockPath = path11.join(blocksDir, blockId);
+    const blockPath = path12.join(blocksDir, blockId);
     const result = await syncBlockInternal(conn, blockId, blockPath);
     results.push(result);
     if (result.status === "error" && result.error) {
@@ -3120,7 +3110,7 @@ async function syncAllBlocks(baseDir) {
 async function syncBlock(blockId, baseDir) {
   const conn = await getConnection(baseDir);
   const blocksDir = getBlocksDir(baseDir);
-  const blockPath = path11.join(blocksDir, blockId);
+  const blockPath = path12.join(blocksDir, blockId);
   try {
     await fs9.access(blockPath);
   } catch {
@@ -3183,4 +3173,4 @@ export {
   loadReportingLog,
   importCsv
 };
-//# sourceMappingURL=chunk-NZO6PT64.js.map
+//# sourceMappingURL=chunk-RM4B2VKS.js.map