@cleocode/cleo 2026.3.0 → 2026.3.1

package/dist/mcp/index.js

@@ -939,6 +939,65 @@ var init_node_sqlite_adapter = __esm({
   }
 });
 
+// src/store/sqlite-backup.ts
+import { existsSync as existsSync3, mkdirSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { join as join3 } from "node:path";
+function formatTimestamp(d) {
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+function rotateSnapshots(backupDir) {
+  try {
+    const files = readdirSync(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).map((f) => ({ name: f, path: join3(backupDir, f), mtimeMs: statSync(join3(backupDir, f)).mtimeMs })).sort((a, b) => a.mtimeMs - b.mtimeMs);
+    while (files.length >= MAX_SNAPSHOTS) {
+      const oldest = files.shift();
+      unlinkSync(oldest.path);
+    }
+  } catch {
+  }
+}
+async function vacuumIntoBackup(opts = {}) {
+  const now = Date.now();
+  if (!opts.force && now - _lastBackupEpoch < DEBOUNCE_MS) {
+    return;
+  }
+  try {
+    const cleoDir = getCleoDir(opts.cwd);
+    const backupDir = join3(cleoDir, "backups", "sqlite");
+    mkdirSync(backupDir, { recursive: true });
+    const db = getNativeDb();
+    if (!db) return;
+    const dest = join3(backupDir, `tasks-${formatTimestamp(/* @__PURE__ */ new Date())}.db`);
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    rotateSnapshots(backupDir);
+    const safeDest = dest.replace(/'/g, "''");
+    db.exec(`VACUUM INTO '${safeDest}'`);
+    _lastBackupEpoch = Date.now();
+  } catch {
+  }
+}
+function listSqliteBackups(cwd) {
+  try {
+    const cleoDir = getCleoDir(cwd);
+    const backupDir = join3(cleoDir, "backups", "sqlite");
+    if (!existsSync3(backupDir)) return [];
+    return readdirSync(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).map((f) => ({ name: f, path: join3(backupDir, f), mtimeMs: statSync(join3(backupDir, f)).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  } catch {
+    return [];
+  }
+}
+var MAX_SNAPSHOTS, DEBOUNCE_MS, _lastBackupEpoch;
+var init_sqlite_backup = __esm({
+  "src/store/sqlite-backup.ts"() {
+    "use strict";
+    init_paths();
+    init_sqlite();
+    MAX_SNAPSHOTS = 10;
+    DEBOUNCE_MS = 3e4;
+    _lastBackupEpoch = 0;
+  }
+});
+
 // src/store/sqlite.ts
 var sqlite_exports = {};
 __export(sqlite_exports, {
@@ -954,16 +1013,74 @@ __export(sqlite_exports, {
   resolveMigrationsFolder: () => resolveMigrationsFolder,
   schema: () => schema_exports
 });
-import { existsSync as existsSync3, mkdirSync } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, copyFileSync, unlinkSync as unlinkSync2, renameSync as renameSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
+import { dirname as dirname2, join as join4, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { eq } from "drizzle-orm";
 import { readMigrationFiles } from "drizzle-orm/migrator";
 import { drizzle } from "drizzle-orm/sqlite-proxy";
 import { migrate } from "drizzle-orm/sqlite-proxy/migrator";
 function getDbPath(cwd) {
-  return join3(getCleoDirAbsolute(cwd), DB_FILENAME);
+  return join4(getCleoDirAbsolute(cwd), DB_FILENAME);
+}
+async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
+  const log5 = getLogger("sqlite");
+  try {
+    const countResult = nativeDb.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
+    const taskCount = countResult?.cnt ?? 0;
+    if (taskCount > 0) return;
+    const backups = listSqliteBackups(cwd);
+    if (backups.length === 0) {
+      return;
+    }
+    const newestBackup = backups[0];
+    const backupDb = new DatabaseSync2(newestBackup.path, { readOnly: true });
+    let backupTaskCount = 0;
+    try {
+      const backupCount = backupDb.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
+      backupTaskCount = backupCount?.cnt ?? 0;
+    } finally {
+      backupDb.close();
+    }
+    if (backupTaskCount < MIN_BACKUP_TASK_COUNT) {
+      return;
+    }
+    log5.warn(
+      { dbPath, backupPath: newestBackup.path, backupTasks: backupTaskCount },
+      `Empty database detected with ${backupTaskCount}-task backup available. Auto-recovering from backup. This likely happened because git-tracked WAL/SHM files were overwritten during a branch switch (T5188).`
+    );
+    nativeDb.close();
+    const walPath = dbPath + "-wal";
+    const shmPath = dbPath + "-shm";
+    try {
+      unlinkSync2(walPath);
+    } catch {
+    }
+    try {
+      unlinkSync2(shmPath);
+    } catch {
+    }
+    const tempPath = dbPath + ".recovery-tmp";
+    copyFileSync(newestBackup.path, tempPath);
+    renameSync2(tempPath, dbPath);
+    log5.info(
+      { dbPath, backupPath: newestBackup.path, restoredTasks: backupTaskCount },
+      "Database auto-recovered from backup successfully."
+    );
+    const restoredNativeDb = openNativeDatabase(dbPath);
+    _nativeDb = restoredNativeDb;
+    const callback = createDrizzleCallback(restoredNativeDb);
+    const batchCb = createBatchCallback(restoredNativeDb);
+    const restoredDb = drizzle(callback, batchCb, { schema: schema_exports });
+    await runMigrations(restoredNativeDb, restoredDb);
+    _db = restoredDb;
+  } catch (err) {
+    log5.error(
+      { err, dbPath },
+      "Auto-recovery from backup failed. Continuing with empty database."
+    );
+  }
 }
 async function getDb(cwd) {
   const requestedPath = getDbPath(cwd);
@@ -975,7 +1092,7 @@ async function getDb(cwd) {
   _initPromise = (async () => {
     const dbPath = requestedPath;
     _dbPath = dbPath;
-    mkdirSync(dirname2(dbPath), { recursive: true });
+    mkdirSync2(dirname2(dbPath), { recursive: true });
     const nativeDb = openNativeDatabase(dbPath);
     _nativeDb = nativeDb;
     const callback = createDrizzleCallback(nativeDb);
@@ -988,19 +1105,28 @@ async function getDb(cwd) {
     nativeDb.exec(
       `INSERT OR IGNORE INTO schema_meta (key, value) VALUES ('task_id_sequence', '{"counter":0,"lastId":"T000","checksum":"seed"}')`
     );
+    await autoRecoverFromBackup(nativeDb, dbPath, cwd);
     if (!_gitTrackingChecked) {
       _gitTrackingChecked = true;
       try {
         const { execFileSync: execFileSync6 } = await import("node:child_process");
-        execFileSync6("git", ["ls-files", "--error-unmatch", dbPath], {
-          cwd: resolve3(dbPath, "..", ".."),
-          stdio: "pipe"
-        });
+        const gitCwd = resolve3(dbPath, "..", "..");
+        const filesToCheck = [dbPath, dbPath + "-wal", dbPath + "-shm"];
         const log5 = getLogger("sqlite");
-        log5.warn(
-          { dbPath },
-          "tasks.db is tracked by project git \u2014 this risks data loss on git operations. Run: git rm --cached .cleo/tasks.db (see ADR-013)"
-        );
+        for (const fileToCheck of filesToCheck) {
+          try {
+            execFileSync6("git", ["ls-files", "--error-unmatch", fileToCheck], {
+              cwd: gitCwd,
+              stdio: "pipe"
+            });
+            const basename7 = fileToCheck.split("/").pop();
+            log5.warn(
+              { path: fileToCheck },
+              `${basename7} is tracked by project git \u2014 this risks data loss on branch switch. Run: git rm --cached ${fileToCheck.replace(gitCwd + "/", "")} (see ADR-013, T5188)`
+            );
+          } catch {
+          }
+        }
       } catch {
       }
     }
@@ -1016,7 +1142,7 @@ async function getDb(cwd) {
 function resolveMigrationsFolder() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname2 = dirname2(__filename);
-  return join3(__dirname2, "..", "..", "drizzle");
+  return join4(__dirname2, "..", "..", "drizzle");
 }
 function tableExists(nativeDb, tableName) {
   const result = nativeDb.prepare(
@@ -1110,12 +1236,12 @@ async function getSchemaVersion(cwd) {
   return result[0]?.value ?? null;
 }
 function dbExists(cwd) {
-  return existsSync3(getDbPath(cwd));
+  return existsSync4(getDbPath(cwd));
 }
 function getNativeDb() {
   return _nativeDb;
 }
-var _require2, DatabaseSync2, DB_FILENAME, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, _db, _nativeDb, _dbPath, _initPromise, _gitTrackingChecked, MAX_MIGRATION_RETRIES, MIGRATION_RETRY_BASE_DELAY_MS, MIGRATION_RETRY_MAX_DELAY_MS;
+var _require2, DatabaseSync2, DB_FILENAME, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, _db, _nativeDb, _dbPath, _initPromise, _gitTrackingChecked, MIN_BACKUP_TASK_COUNT, MAX_MIGRATION_RETRIES, MIGRATION_RETRY_BASE_DELAY_MS, MIGRATION_RETRY_MAX_DELAY_MS;
 var init_sqlite = __esm({
   "src/store/sqlite.ts"() {
     "use strict";
@@ -1123,6 +1249,7 @@ var init_sqlite = __esm({
     init_paths();
     init_node_sqlite_adapter();
     init_logger();
+    init_sqlite_backup();
     _require2 = createRequire2(import.meta.url);
     ({ DatabaseSync: DatabaseSync2 } = _require2("node:sqlite"));
     DB_FILENAME = "tasks.db";
@@ -1133,6 +1260,7 @@ var init_sqlite = __esm({
     _dbPath = null;
     _initPromise = null;
     _gitTrackingChecked = false;
+    MIN_BACKUP_TASK_COUNT = 10;
     MAX_MIGRATION_RETRIES = 5;
     MIGRATION_RETRY_BASE_DELAY_MS = 100;
     MIGRATION_RETRY_MAX_DELAY_MS = 2e3;
@@ -1397,7 +1525,7 @@ var init_atomic = __esm({
 
 // src/store/backup.ts
 import { copyFile, rename as fsRename, readdir, unlink as unlink2, stat, mkdir as mkdir2 } from "node:fs/promises";
-import { join as join4, basename } from "node:path";
+import { join as join5, basename } from "node:path";
 async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUPS) {
   try {
     await mkdir2(backupDir, { recursive: true });
@@ -1411,14 +1539,14 @@ async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUP
       );
     }
     for (let i = maxBackups; i >= 1; i--) {
-      const current = join4(backupDir, `${fileName}.${i}`);
+      const current = join5(backupDir, `${fileName}.${i}`);
       if (i === maxBackups) {
         try {
           await unlink2(current);
         } catch {
         }
       } else {
-        const next = join4(backupDir, `${fileName}.${i + 1}`);
+        const next = join5(backupDir, `${fileName}.${i + 1}`);
         try {
           await stat(current);
           await fsRename(current, next);
@@ -1426,7 +1554,7 @@ async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUP
         }
       }
     }
-    const backupPath = join4(backupDir, `${fileName}.1`);
+    const backupPath = join5(backupDir, `${fileName}.1`);
     await copyFile(filePath, backupPath);
     return backupPath;
   } catch (err) {
@@ -2196,15 +2324,15 @@ var init_sqlite_data_accessor = __esm({
 
 // src/store/git-checkpoint.ts
 import { readFile as readFile2, writeFile } from "node:fs/promises";
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { join as join5, resolve as resolve4 } from "node:path";
+import { join as join6, resolve as resolve4 } from "node:path";
 function makeCleoGitEnv(cleoDir) {
   const abs = resolve4(cleoDir);
   return {
     ...process.env,
-    GIT_DIR: join5(abs, ".git"),
+    GIT_DIR: join6(abs, ".git"),
     GIT_WORK_TREE: abs
   };
 }
@@ -2222,7 +2350,7 @@ async function cleoGitCommand(args, cleoDir) {
   }
 }
 function isCleoGitInitialized(cleoDir) {
-  return existsSync4(join5(cleoDir, ".git", "HEAD"));
+  return existsSync5(join6(cleoDir, ".git", "HEAD"));
 }
 async function loadCheckpointConfig(cwd) {
   try {
@@ -2249,25 +2377,25 @@ async function isCleoGitRepo(cleoDir) {
   return result.success && (result.stdout === "true" || isCleoGitInitialized(cleoDir));
 }
 function isMergeInProgress(cleoDir) {
-  return existsSync4(join5(cleoDir, ".git", "MERGE_HEAD"));
+  return existsSync5(join6(cleoDir, ".git", "MERGE_HEAD"));
 }
 async function isDetachedHead(cleoDir) {
   const result = await cleoGitCommand(["symbolic-ref", "HEAD"], cleoDir);
   return !result.success;
 }
 function isRebaseInProgress(cleoDir) {
-  return existsSync4(join5(cleoDir, ".git", "rebase-merge")) || existsSync4(join5(cleoDir, ".git", "rebase-apply"));
+  return existsSync5(join6(cleoDir, ".git", "rebase-merge")) || existsSync5(join6(cleoDir, ".git", "rebase-apply"));
 }
 async function recordCheckpointTime(cleoDir) {
   try {
-    const stateFile = join5(cleoDir, CHECKPOINT_STATE_FILE);
+    const stateFile = join6(cleoDir, CHECKPOINT_STATE_FILE);
     await writeFile(stateFile, String(Math.floor(Date.now() / 1e3)));
   } catch {
   }
 }
 async function getLastCheckpointTime(cleoDir) {
   try {
-    const stateFile = join5(cleoDir, CHECKPOINT_STATE_FILE);
+    const stateFile = join6(cleoDir, CHECKPOINT_STATE_FILE);
     const content = await readFile2(stateFile, "utf-8");
     const epoch = parseInt(content.trim(), 10);
     return isNaN(epoch) ? 0 : epoch;
@@ -2278,8 +2406,8 @@ async function getLastCheckpointTime(cleoDir) {
 async function getChangedStateFiles(cleoDir) {
   const changed = [];
   for (const stateFile of STATE_FILES) {
-    const fullPath = join5(cleoDir, stateFile);
-    if (!existsSync4(fullPath)) continue;
+    const fullPath = join6(cleoDir, stateFile);
+    if (!existsSync5(fullPath)) continue;
     const diffResult = await cleoGitCommand(["diff", "--quiet", "--", stateFile], cleoDir);
     const cachedResult = await cleoGitCommand(["diff", "--cached", "--quiet", "--", stateFile], cleoDir);
     const untrackedResult = await cleoGitCommand(
@@ -2303,7 +2431,7 @@ async function shouldCheckpoint(options) {
   const config = await loadCheckpointConfig(cwd);
   if (!config.enabled) return false;
   const cleoDir = getCleoDir(cwd);
-  if (!existsSync4(cleoDir)) return false;
+  if (!existsSync5(cleoDir)) return false;
   if (!isCleoGitInitialized(cleoDir)) return false;
   if (!await isCleoGitRepo(cleoDir)) return false;
   if (isMergeInProgress(cleoDir)) return false;
@@ -2375,55 +2503,6 @@ var init_git_checkpoint = __esm({
   }
 });
 
-// src/store/sqlite-backup.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync, statSync, unlinkSync } from "node:fs";
-import { join as join6 } from "node:path";
-function formatTimestamp(d) {
-  const pad = (n, len = 2) => String(n).padStart(len, "0");
-  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
-}
-function rotateSnapshots(backupDir) {
-  try {
-    const files = readdirSync(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).map((f) => ({ name: f, path: join6(backupDir, f), mtimeMs: statSync(join6(backupDir, f)).mtimeMs })).sort((a, b) => a.mtimeMs - b.mtimeMs);
-    while (files.length >= MAX_SNAPSHOTS) {
-      const oldest = files.shift();
-      unlinkSync(oldest.path);
-    }
-  } catch {
-  }
-}
-async function vacuumIntoBackup(opts = {}) {
-  const now = Date.now();
-  if (!opts.force && now - _lastBackupEpoch < DEBOUNCE_MS) {
-    return;
-  }
-  try {
-    const cleoDir = getCleoDir(opts.cwd);
-    const backupDir = join6(cleoDir, "backups", "sqlite");
-    mkdirSync2(backupDir, { recursive: true });
-    const db = getNativeDb();
-    if (!db) return;
-    const dest = join6(backupDir, `tasks-${formatTimestamp(/* @__PURE__ */ new Date())}.db`);
-    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
-    rotateSnapshots(backupDir);
-    const safeDest = dest.replace(/'/g, "''");
-    db.exec(`VACUUM INTO '${safeDest}'`);
-    _lastBackupEpoch = Date.now();
-  } catch {
-  }
-}
-var MAX_SNAPSHOTS, DEBOUNCE_MS, _lastBackupEpoch;
-var init_sqlite_backup = __esm({
-  "src/store/sqlite-backup.ts"() {
-    "use strict";
-    init_paths();
-    init_sqlite();
-    MAX_SNAPSHOTS = 10;
-    DEBOUNCE_MS = 3e4;
-    _lastBackupEpoch = 0;
-  }
-});
-
 // src/core/sequence/index.ts
 var sequence_exports = {};
 __export(sequence_exports, {
@@ -2432,7 +2511,7 @@ __export(sequence_exports, {
   repairSequence: () => repairSequence,
   showSequence: () => showSequence
 });
-import { existsSync as existsSync6, readFileSync as readFileSync3, renameSync as renameSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, renameSync as renameSync3 } from "node:fs";
 import { join as join7 } from "node:path";
 import { eq as eq4 } from "drizzle-orm";
 function getLegacySequenceJsonPath(cwd) {
@@ -2463,10 +2542,10 @@ function renameLegacyFile(path) {
   const migratedPath = `${path}.migrated`;
   try {
     if (!existsSync6(migratedPath)) {
-      renameSync2(path, migratedPath);
+      renameSync3(path, migratedPath);
       return;
     }
-    renameSync2(path, `${migratedPath}.${Date.now()}`);
+    renameSync3(path, `${migratedPath}.${Date.now()}`);
   } catch {
   }
 }
@@ -3028,7 +3107,7 @@ var init_data_accessor = __esm({
 });
 
 // src/store/file-utils.ts
-import { readFileSync as readFileSync4, writeFileSync, renameSync as renameSync3, existsSync as existsSync8, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "node:fs";
+import { readFileSync as readFileSync4, writeFileSync, renameSync as renameSync4, existsSync as existsSync8, unlinkSync as unlinkSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "node:fs";
 import { join as join8, dirname as dirname5, basename as basename2 } from "node:path";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import * as lockfile2 from "proper-lockfile";
@@ -3043,13 +3122,13 @@ function rotateBackup(filePath) {
     const current = join8(backupDir, `${name}.${i}`);
     if (i === MAX_BACKUPS) {
       try {
-        unlinkSync2(current);
+        unlinkSync3(current);
       } catch {
       }
     } else {
       const next = join8(backupDir, `${name}.${i + 1}`);
       try {
-        if (existsSync8(current)) renameSync3(current, next);
+        if (existsSync8(current)) renameSync4(current, next);
       } catch {
       }
     }
@@ -3069,10 +3148,10 @@ function writeJsonFileAtomic(filePath, data, indent = 2) {
     if (existsSync8(filePath)) {
       rotateBackup(filePath);
     }
-    renameSync3(tempPath, filePath);
+    renameSync4(tempPath, filePath);
   } catch (error) {
     try {
-      unlinkSync2(tempPath);
+      unlinkSync3(tempPath);
     } catch {
     }
     throw error;
@@ -12761,7 +12840,7 @@ import {
   writeFileSync as writeFileSync2,
   mkdirSync as mkdirSync6,
   readdirSync as readdirSync3,
-  copyFileSync,
+  copyFileSync as copyFileSync2,
   statSync as statSync3,
   rmSync
 } from "node:fs";
@@ -12842,7 +12921,7 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
         for (const sf of readdirSync3(srcPath)) {
           if (!copiedFiles.has(sf)) {
             try {
-              copyFileSync(join13(srcPath, sf), join13(dstPath, sf));
+              copyFileSync2(join13(srcPath, sf), join13(dstPath, sf));
               copiedFiles.add(sf);
               count2++;
             } catch {
@@ -12850,7 +12929,7 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
           }
         }
       } else if (!copiedFiles.has(entry)) {
-        copyFileSync(srcPath, dstPath);
+        copyFileSync2(srcPath, dstPath);
         copiedFiles.add(entry);
         count2++;
       }
@@ -13159,7 +13238,7 @@ function getMigrationStatus(projectRoot, opts) {
 // src/core/system/cleanup.ts
 init_errors();
 init_exit_codes();
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync4, existsSync as existsSync17, readdirSync as readdirSync4, unlinkSync as unlinkSync3 } from "node:fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync4, existsSync as existsSync17, readdirSync as readdirSync4, unlinkSync as unlinkSync4 } from "node:fs";
 import { join as join17 } from "node:path";
 function cleanupSystem(projectRoot, params) {
   if (!params.target) {
@@ -13210,11 +13289,11 @@ function cleanupSystem(projectRoot, params) {
                   if (params.olderThan && meta.timestamp < params.olderThan) {
                     items.push(file.replace(".meta.json", ""));
                     if (!dryRun) {
-                      unlinkSync3(metaFilePath);
+                      unlinkSync4(metaFilePath);
                       for (const bf of readdirSync4(fullDir)) {
                         if (bf.includes(meta.backupId)) {
                           try {
-                            unlinkSync3(join17(fullDir, bf));
+                            unlinkSync4(join17(fullDir, bf));
                           } catch {
                           }
                         }
@@ -13239,7 +13318,7 @@ function cleanupSystem(projectRoot, params) {
             items.push(file);
             if (!dryRun) {
               try {
-                unlinkSync3(join17(cleoDir, file));
+                unlinkSync4(join17(cleoDir, file));
               } catch {
               }
             }