@hasna/todos 0.11.6 → 0.11.7

package/dist/cli/index.js

@@ -10538,6 +10538,8 @@ import {
 import { homedir as homedir3 } from "os";
 import { join as join9, relative as relative2 } from "path";
 import { hostname } from "os";
+import { homedir as homedir32 } from "os";
+import { join as join32 } from "path";
 function __accessProp2(key) {
   return this[key];
 }
@@ -10605,6 +10607,9 @@ class SqliteAdapter {
   exec(sql) {
     this.db.exec(sql);
   }
+  query(sql) {
+    return this.db.query(sql);
+  }
   prepare(sql) {
     const stmt = this.db.prepare(sql);
     return {
@@ -10762,6 +10767,62 @@ class PgAdapter {
     return this.pool;
   }
 }
+
+class PgAdapterAsync {
+  pool;
+  constructor(arg) {
+    if (typeof arg === "string") {
+      this.pool = new esm_default.Pool({ connectionString: arg });
+    } else {
+      this.pool = arg;
+    }
+  }
+  async run(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return {
+      changes: res.rowCount ?? 0,
+      lastInsertRowid: res.rows?.[0]?.id ?? 0
+    };
+  }
+  async get(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return res.rows[0] ?? null;
+  }
+  async all(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return res.rows;
+  }
+  async exec(sql) {
+    const pgSql = translateSql(sql, "pg");
+    await this.pool.query(pgSql);
+  }
+  async close() {
+    await this.pool.end();
+  }
+  async transaction(fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (err) {
+      await client.query("ROLLBACK");
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  get raw() {
+    return this.pool;
+  }
+}
 function setErrorMap2(map) {
   overrideErrorMap2 = map;
 }
@@ -11373,19 +11434,133 @@ function createDatabase(options) {
   const dbPath = options.sqlitePath ?? getDbPath2(options.service);
   return new SqliteAdapter(dbPath);
 }
-function syncPush(local, cloud, options) {
-  return syncTransfer(local, cloud, options, "push");
+async function syncPush(local, remote, options) {
+  const orderedTables = await getTableOrder(remote, options.tables);
+  return syncTransfer(local, remote, { ...options, tables: orderedTables }, "push");
+}
+async function syncPull(remote, local, options) {
+  const orderedTables = await getTableOrder(remote, options.tables);
+  return syncTransfer(remote, local, { ...options, tables: orderedTables }, "pull");
+}
+async function getTableOrder(remote, tables) {
+  if (tables.length <= 1)
+    return tables;
+  try {
+    const fks = await remote.all(`
+      SELECT DISTINCT
+        tc.table_name AS source_table,
+        ccu.table_name AS referenced_table
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.constraint_column_usage ccu
+        ON tc.constraint_name = ccu.constraint_name
+        AND tc.table_schema = ccu.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = 'public'
+    `);
+    if (fks.length > 0) {
+      return topoSort(tables, fks);
+    }
+  } catch {}
+  return heuristicOrder(tables);
+}
+function topoSort(tables, fks) {
+  const tableSet = new Set(tables);
+  const deps = new Map;
+  for (const t of tables) {
+    deps.set(t, new Set);
+  }
+  for (const fk of fks) {
+    if (tableSet.has(fk.source_table) && tableSet.has(fk.referenced_table)) {
+      deps.get(fk.source_table).add(fk.referenced_table);
+    }
+  }
+  const sorted = [];
+  const visited = new Set;
+  const visiting = new Set;
+  function visit(table) {
+    if (visited.has(table))
+      return;
+    if (visiting.has(table)) {
+      sorted.push(table);
+      visited.add(table);
+      return;
+    }
+    visiting.add(table);
+    const tableDeps = deps.get(table) ?? new Set;
+    for (const dep of tableDeps) {
+      visit(dep);
+    }
+    visiting.delete(table);
+    visited.add(table);
+    sorted.push(table);
+  }
+  for (const t of tables) {
+    visit(t);
+  }
+  return sorted;
+}
+function heuristicOrder(tables) {
+  const sorted = [...tables].sort((a, b) => {
+    const aIsChild = a.includes("_") && tables.some((t) => a.startsWith(t + "_") || a.endsWith("_" + t));
+    const bIsChild = b.includes("_") && tables.some((t) => b.startsWith(t + "_") || b.endsWith("_" + t));
+    if (aIsChild && !bIsChild)
+      return 1;
+    if (!aIsChild && bIsChild)
+      return -1;
+    return a.localeCompare(b);
+  });
+  return sorted;
+}
+function getSqlitePrimaryKeys(adapter, table) {
+  try {
+    const cols = adapter.all(`PRAGMA table_info("${table}")`);
+    const pkCols = cols.filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk).map((c) => c.name);
+    return pkCols;
+  } catch {
+    return [];
+  }
 }
-function syncPull(local, cloud, options) {
-  return syncTransfer(cloud, local, options, "pull");
+async function getPgPrimaryKeys(adapter, table) {
+  try {
+    const rows = await adapter.all(`
+        SELECT kcu.column_name, kcu.ordinal_position
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        WHERE tc.constraint_type = 'PRIMARY KEY'
+          AND tc.table_schema = 'public'
+          AND tc.table_name = '${table}'
+        ORDER BY kcu.ordinal_position
+      `);
+    return rows.map((r) => r.column_name);
+  } catch {
+    return [];
+  }
+}
+async function detectPrimaryKeys(adapter, table) {
+  if (isAsyncAdapter(adapter)) {
+    return getPgPrimaryKeys(adapter, table);
+  }
+  return getSqlitePrimaryKeys(adapter, table);
+}
+async function resolvePrimaryKeys(source, target, table, pkOption) {
+  if (pkOption) {
+    return Array.isArray(pkOption) ? pkOption : [pkOption];
+  }
+  let pks = await detectPrimaryKeys(source, table);
+  if (pks.length === 0) {
+    pks = await detectPrimaryKeys(target, table);
+  }
+  return pks;
 }
-function syncTransfer(source, target, options, _direction) {
+async function syncTransfer(source, target, options, _direction) {
   const {
     tables,
     onProgress,
-    batchSize = 500,
+    batchSize = 100,
     conflictColumn = "updated_at",
-    primaryKey = "id"
+    primaryKey: pkOption
   } = options;
   const results = [];
   for (let i = 0;i < tables.length; i++) {
@@ -11406,7 +11581,7 @@ function syncTransfer(source, target, options, _direction) {
         totalTables: tables.length,
         currentTableIndex: i
       });
-      const rows = source.all(`SELECT * FROM "${table}"`);
+      const rows = await readAll(source, `SELECT * FROM "${table}"`);
       result.rowsRead = rows.length;
       if (rows.length === 0) {
         onProgress?.({
@@ -11420,11 +11595,45 @@ function syncTransfer(source, target, options, _direction) {
         results.push(result);
         continue;
       }
+      const pkColumns = await resolvePrimaryKeys(source, target, table, pkOption);
       const columns = Object.keys(rows[0]);
-      const hasConflictCol = columns.includes(conflictColumn);
-      const hasPrimaryKey = columns.includes(primaryKey);
-      if (!hasPrimaryKey) {
-        result.errors.push(`Table "${table}" has no "${primaryKey}" column \u2014 skipping`);
+      if (pkColumns.length === 0) {
+        result.errors.push(`Table "${table}" has no primary key \u2014 inserting without conflict handling`);
+        onProgress?.({
+          table,
+          phase: "writing",
+          rowsRead: result.rowsRead,
+          rowsWritten: 0,
+          totalTables: tables.length,
+          currentTableIndex: i
+        });
+        for (let offset = 0;offset < rows.length; offset += batchSize) {
+          const batch = rows.slice(offset, offset + batchSize);
+          try {
+            if (isAsyncAdapter(target)) {
+              await batchInsertPg(target, table, columns, batch);
+            } else {
+              batchInsertSqlite(target, table, columns, batch);
+            }
+            result.rowsWritten += batch.length;
+          } catch (err) {
+            result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
+          }
+        }
+        onProgress?.({
+          table,
+          phase: "done",
+          rowsRead: result.rowsRead,
+          rowsWritten: result.rowsWritten,
+          totalTables: tables.length,
+          currentTableIndex: i
+        });
+        results.push(result);
+        continue;
+      }
+      const missingPks = pkColumns.filter((pk) => !columns.includes(pk));
+      if (missingPks.length > 0) {
+        result.errors.push(`Table "${table}" missing PK columns in data: ${missingPks.join(", ")} \u2014 skipping`);
         results.push(result);
         continue;
       }
@@ -11436,34 +11645,18 @@ function syncTransfer(source, target, options, _direction) {
         totalTables: tables.length,
         currentTableIndex: i
       });
+      const updateCols = columns.filter((c) => !pkColumns.includes(c));
       for (let offset = 0;offset < rows.length; offset += batchSize) {
         const batch = rows.slice(offset, offset + batchSize);
-        for (const row of batch) {
-          try {
-            const existing = target.get(`SELECT "${primaryKey}"${hasConflictCol ? `, "${conflictColumn}"` : ""} FROM "${table}" WHERE "${primaryKey}" = ?`, row[primaryKey]);
-            if (existing) {
-              if (hasConflictCol && existing[conflictColumn] && row[conflictColumn]) {
-                const existingTime = new Date(existing[conflictColumn]).getTime();
-                const incomingTime = new Date(row[conflictColumn]).getTime();
-                if (existingTime >= incomingTime) {
-                  result.rowsSkipped++;
-                  continue;
-                }
-              }
-              const setClauses = columns.filter((c) => c !== primaryKey).map((c) => `"${c}" = ?`).join(", ");
-              const values = columns.filter((c) => c !== primaryKey).map((c) => row[c]);
-              values.push(row[primaryKey]);
-              target.run(`UPDATE "${table}" SET ${setClauses} WHERE "${primaryKey}" = ?`, ...values);
-            } else {
-              const placeholders = columns.map(() => "?").join(", ");
-              const colList = columns.map((c) => `"${c}"`).join(", ");
-              const values = columns.map((c) => row[c]);
-              target.run(`INSERT INTO "${table}" (${colList}) VALUES (${placeholders})`, ...values);
-            }
-            result.rowsWritten++;
-          } catch (err) {
-            result.errors.push(`Row ${row[primaryKey]}: ${err?.message ?? String(err)}`);
+        try {
+          if (isAsyncAdapter(target)) {
+            await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch);
+          } else {
+            batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch);
           }
+          result.rowsWritten += batch.length;
+        } catch (err) {
+          result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
         }
         onProgress?.({
           table,
@@ -11489,10 +11682,69 @@ function syncTransfer(source, target, options, _direction) {
   }
   return results;
 }
+async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map((_, rowIdx) => {
+    const offset = rowIdx * columns.length;
+    return `(${columns.map((_2, colIdx) => `$${offset + colIdx + 1}`).join(", ")})`;
+  }).join(", ");
+  const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
+  const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  await target.run(sql, ...params);
+}
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
+  const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
+  const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  target.run(sql, ...params);
+}
+async function batchInsertPg(target, table, columns, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map((_, rowIdx) => {
+    const offset = rowIdx * columns.length;
+    return `(${columns.map((_2, colIdx) => `$${offset + colIdx + 1}`).join(", ")})`;
+  }).join(", ");
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  await target.run(sql, ...params);
+}
+function batchInsertSqlite(target, table, columns, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  target.run(sql, ...params);
+}
+function isAsyncAdapter(adapter) {
+  return adapter.constructor.name === "PgAdapterAsync" || typeof adapter.raw?.connect === "function";
+}
+async function readAll(adapter, sql) {
+  const result = adapter.all(sql);
+  return result instanceof Promise ? await result : result;
+}
 function listSqliteTables(db) {
   const rows = db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
   return rows.map((r) => r.name);
 }
+async function listPgTables(db) {
+  const rows = await db.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`);
+  return rows.map((r) => r.tablename);
+}
 function ensureFeedbackTable(db) {
   db.exec(FEEDBACK_TABLE_SQL);
 }
@@ -11545,6 +11797,126 @@ async function sendFeedback(feedback, db) {
     return { sent: false, id, error: errorMsg };
   }
 }
+
+class SyncProgressTracker {
+  db;
+  progress = new Map;
+  startTimes = new Map;
+  callback;
+  constructor(db, callback) {
+    this.db = db;
+    this.callback = callback;
+    this.ensureResumeTable();
+  }
+  ensureResumeTable() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS _sync_resume (
+        table_name TEXT PRIMARY KEY,
+        last_row_id TEXT,
+        direction TEXT,
+        started_at TEXT,
+        status TEXT DEFAULT 'in_progress'
+      )
+    `);
+  }
+  start(table, total, direction) {
+    const resumed = this.canResume(table);
+    const now2 = Date.now();
+    this.startTimes.set(table, now2);
+    const status = resumed ? "resumed" : "in_progress";
+    const info = {
+      table,
+      total,
+      done: 0,
+      percent: 0,
+      elapsed_ms: 0,
+      eta_ms: 0,
+      status
+    };
+    this.progress.set(table, info);
+    this.db.run(`INSERT INTO _sync_resume (table_name, last_row_id, direction, started_at, status)
+       VALUES (?, ?, ?, datetime('now'), ?)
+       ON CONFLICT (table_name) DO UPDATE SET
+         direction = excluded.direction,
+         started_at = datetime('now'),
+         status = excluded.status`, table, "", direction, status);
+    this.notify(table);
+  }
+  update(table, done, lastRowId) {
+    const info = this.progress.get(table);
+    if (!info)
+      return;
+    const startTime = this.startTimes.get(table) ?? Date.now();
+    const elapsed = Date.now() - startTime;
+    const rate = done > 0 ? elapsed / done : 0;
+    const remaining = info.total - done;
+    const eta = remaining > 0 ? Math.round(rate * remaining) : 0;
+    info.done = done;
+    info.percent = info.total > 0 ? Math.round(done / info.total * 100) : 0;
+    info.elapsed_ms = elapsed;
+    info.eta_ms = eta;
+    info.status = "in_progress";
+    this.db.run(`UPDATE _sync_resume SET last_row_id = ?, status = 'in_progress' WHERE table_name = ?`, lastRowId, table);
+    this.notify(table);
+  }
+  markComplete(table) {
+    const info = this.progress.get(table);
+    if (info) {
+      const startTime = this.startTimes.get(table) ?? Date.now();
+      info.elapsed_ms = Date.now() - startTime;
+      info.done = info.total;
+      info.percent = 100;
+      info.eta_ms = 0;
+      info.status = "completed";
+      this.notify(table);
+    }
+    this.db.run(`UPDATE _sync_resume SET status = 'completed' WHERE table_name = ?`, table);
+  }
+  markFailed(table, _error) {
+    const info = this.progress.get(table);
+    if (info) {
+      const startTime = this.startTimes.get(table) ?? Date.now();
+      info.elapsed_ms = Date.now() - startTime;
+      info.status = "failed";
+      this.notify(table);
+    }
+    this.db.run(`UPDATE _sync_resume SET status = 'failed' WHERE table_name = ?`, table);
+  }
+  canResume(table) {
+    const row = this.db.get(`SELECT status FROM _sync_resume WHERE table_name = ?`, table);
+    if (!row)
+      return false;
+    return row.status === "in_progress" || row.status === "resumed";
+  }
+  getResumePoint(table) {
+    const row = this.db.get(`SELECT table_name, last_row_id, direction, started_at, status FROM _sync_resume WHERE table_name = ?`, table);
+    if (!row)
+      return null;
+    if (row.status !== "in_progress" && row.status !== "resumed")
+      return null;
+    return row;
+  }
+  clearResume(table) {
+    this.db.run(`DELETE FROM _sync_resume WHERE table_name = ?`, table);
+    this.progress.delete(table);
+    this.startTimes.delete(table);
+  }
+  getProgress(table) {
+    return this.progress.get(table) ?? null;
+  }
+  getAllProgress() {
+    return Array.from(this.progress.values());
+  }
+  listResumeRecords() {
+    return this.db.all(`SELECT table_name, last_row_id, direction, started_at, status FROM _sync_resume ORDER BY started_at DESC`);
+  }
+  notify(table) {
+    const info = this.progress.get(table);
+    if (info && this.callback) {
+      this.callback({ ...info });
+    }
+  }
+}
 function registerCloudTools(server, serviceName) {
   server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
     const config = getCloudConfig();
@@ -11555,10 +11927,10 @@ function registerCloudTools(server, serviceName) {
     ];
     if (config.rds.host && config.rds.username) {
       try {
-        const pg2 = new PgAdapter(getConnectionString("postgres"));
-        pg2.get("SELECT 1 as ok");
+        const pg2 = new PgAdapterAsync(getConnectionString("postgres"));
+        await pg2.get("SELECT 1 as ok");
         lines.push("PostgreSQL: connected");
-        pg2.close();
+        await pg2.close();
       } catch (err) {
         lines.push(`PostgreSQL: failed \u2014 ${err?.message}`);
       }
@@ -11579,11 +11951,11 @@ function registerCloudTools(server, serviceName) {
       };
     }
     const local = new SqliteAdapter(getDbPath2(serviceName));
-    const cloud = new PgAdapter(getConnectionString(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
-    const results = syncPush(local, cloud, { tables: tableList });
+    const results = await syncPush(local, cloud, { tables: tableList });
     local.close();
-    cloud.close();
+    await cloud.close();
     const total = results.reduce((s, r) => s + r.rowsWritten, 0);
     return {
       content: [{ type: "text", text: `Pushed ${total} rows across ${tableList.length} table(s).` }]
@@ -11602,17 +11974,16 @@ function registerCloudTools(server, serviceName) {
       };
     }
     const local = new SqliteAdapter(getDbPath2(serviceName));
-    const cloud = new PgAdapter(getConnectionString(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tableList;
     if (tablesStr) {
       tableList = tablesStr.split(",").map((t) => t.trim());
     } else {
       try {
-        const rows = cloud.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public'`);
-        tableList = rows.map((r) => r.tablename);
+        tableList = await listPgTables(cloud);
       } catch {
         local.close();
-        cloud.close();
+        await cloud.close();
         return {
           content: [
             { type: "text", text: "Error: failed to list cloud tables." }
@@ -11621,9 +11992,9 @@ function registerCloudTools(server, serviceName) {
         };
       }
     }
-    const results = syncPull(local, cloud, { tables: tableList });
+    const results = await syncPull(cloud, local, { tables: tableList });
     local.close();
-    cloud.close();
+    await cloud.close();
     const total = results.reduce((s, r) => s + r.rowsWritten, 0);
     return {
       content: [{ type: "text", text: `Pulled ${total} rows across ${tableList.length} table(s).` }]
@@ -11898,7 +12269,7 @@ CREATE TABLE IF NOT EXISTS feedback (
   email TEXT DEFAULT '',
   machine_id TEXT DEFAULT '',
   created_at TEXT DEFAULT (datetime('now'))
-)`;
+)`, AUTO_SYNC_CONFIG_PATH;
 var init_dist = __esm(() => {
   __create2 = Object.create;
   __getProtoOf2 = Object.getPrototypeOf;
@@ -19841,6 +20212,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   });
   CONFIG_DIR2 = join22(homedir22(), ".hasna", "cloud");
   CONFIG_PATH2 = join22(CONFIG_DIR2, "config.json");
+  AUTO_SYNC_CONFIG_PATH = join32(homedir32(), ".hasna", "cloud", "config.json");
 });
 
 // src/db/traces.ts