@tomkapa/tayto 0.5.4 → 0.6.0

package/dist/index.js

@@ -33,7 +33,9 @@ function loadConfig() {
     dbPath: process.env["TASK_DB_PATH"] ?? join(dataDir, "data.db"),
     logDir,
     logLevel: process.env["TASK_LOG_LEVEL"] ?? "info",
-    otelEndpoint: process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]
+    otelEndpoint: process.env["OTEL_EXPORTER_OTLP_ENDPOINT"],
+    updateCachePath: join(dataDir, "update-check.json"),
+    noUpdateCheck: process.env["TAYTO_NO_UPDATE_CHECK"] === "1"
   };
 }
 
@@ -109,6 +111,10 @@ async function shutdownTelemetry() {
   }
 }
 
+// src/cli/container.ts
+import { join as join3 } from "path";
+import { tmpdir } from "os";
+
 // src/errors/app-error.ts
 var AppError = class extends Error {
   constructor(code, message, cause) {
@@ -120,6 +126,9 @@ var AppError = class extends Error {
   code;
   cause;
 };
+function toMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
 
 // src/repository/project.repository.ts
 import { ulid } from "ulid";
@@ -1997,8 +2006,141 @@ var PortabilityServiceImpl = class {
   }
 };
 
+// src/service/update.service.ts
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import { execFileSync } from "child_process";
+import { trace } from "@opentelemetry/api";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@tomkapa/tayto/latest";
+var PACKAGE_NAME = "@tomkapa/tayto";
+var CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
+function isValidCache(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return typeof obj["checkedAt"] === "number" && typeof obj["latestVersion"] === "string";
+}
+function isNewerVersion(a, b) {
+  const parse = (v) => {
+    const parts = v.replace(/^v/, "").split(".").map(Number);
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+  };
+  const [aMaj, aMin, aPatch] = parse(a);
+  const [bMaj, bMin, bPatch] = parse(b);
+  if (aMaj !== bMaj) return aMaj > bMaj;
+  if (aMin !== bMin) return aMin > bMin;
+  return aPatch > bPatch;
+}
+function defaultExec(cmd, args) {
+  execFileSync(cmd, args, { stdio: "inherit", timeout: 6e4 });
+}
+var tracer = trace.getTracer("task");
+var UpdateServiceImpl = class {
+  constructor(cachePath, fetchImpl = globalThis.fetch, execImpl = defaultExec) {
+    this.cachePath = cachePath;
+    this.fetchImpl = fetchImpl;
+    this.execImpl = execImpl;
+  }
+  cachePath;
+  fetchImpl;
+  execImpl;
+  async checkForUpdate(currentVersion) {
+    return tracer.startActiveSpan("UpdateService.checkForUpdate", async (span) => {
+      try {
+        span.setAttribute("update.current_version", currentVersion);
+        const cached = this.readCache();
+        if (cached && Date.now() - cached.checkedAt < CHECK_TTL_MS) {
+          span.setAttribute("update.cache_hit", true);
+          const updateAvailable2 = isNewerVersion(cached.latestVersion, currentVersion);
+          span.setAttribute("update.latest_version", cached.latestVersion);
+          span.setAttribute("update.available", updateAvailable2);
+          return ok({ currentVersion, latestVersion: cached.latestVersion, updateAvailable: updateAvailable2 });
+        }
+        span.setAttribute("update.cache_hit", false);
+        let latestVersion;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+          controller.abort();
+        }, 5e3);
+        try {
+          const response = await this.fetchImpl(NPM_REGISTRY_URL, { signal: controller.signal });
+          if (!response.ok) {
+            logger.warn("Update check: registry returned non-OK status", {
+              status: response.status
+            });
+            return err(
+              new AppError(
+                "UPGRADE_CHECK",
+                `npm registry returned status ${String(response.status)}`
+              )
+            );
+          }
+          const body = await response.json();
+          if (typeof body["version"] !== "string") {
+            return err(
+              new AppError("UPGRADE_CHECK", "Unexpected response format from npm registry")
+            );
+          }
+          latestVersion = body["version"];
+        } catch (e) {
+          logger.warn("Update check: fetch failed", { error: toMessage(e) });
+          return err(
+            new AppError("UPGRADE_CHECK", `Failed to check for updates: ${toMessage(e)}`, e)
+          );
+        } finally {
+          clearTimeout(timeout);
+        }
+        this.writeCache({ checkedAt: Date.now(), latestVersion });
+        const updateAvailable = isNewerVersion(latestVersion, currentVersion);
+        span.setAttribute("update.latest_version", latestVersion);
+        span.setAttribute("update.available", updateAvailable);
+        return ok({ currentVersion, latestVersion, updateAvailable });
+      } finally {
+        span.end();
+      }
+    });
+  }
+  performUpgrade(currentVersion) {
+    return logger.startSpan("UpdateService.performUpgrade", (span) => {
+      span.setAttribute("update.previous_version", currentVersion);
+      try {
+        this.execImpl("npm", ["install", "-g", `${PACKAGE_NAME}@latest`]);
+      } catch (e) {
+        logger.error("Upgrade failed", e, { command: `npm install -g ${PACKAGE_NAME}@latest` });
+        span.setAttribute("update.success", false);
+        return err(new AppError("UPGRADE_CHECK", `Upgrade failed: ${toMessage(e)}`, e));
+      }
+      const cached = this.readCache();
+      const installedVersion = cached?.latestVersion ?? "unknown";
+      span.setAttribute("update.success", true);
+      span.setAttribute("update.installed_version", installedVersion);
+      this.writeCache({ checkedAt: 0, latestVersion: installedVersion });
+      return ok({ installedVersion });
+    });
+  }
+  readCache() {
+    try {
+      const raw = readFileSync2(this.cachePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return isValidCache(parsed) ? parsed : null;
+    } catch (e) {
+      logger.info("Update cache not available", {
+        error: toMessage(e)
+      });
+      return null;
+    }
+  }
+  writeCache(entry) {
+    try {
+      writeFileSync(this.cachePath, JSON.stringify(entry), "utf-8");
+    } catch (e) {
+      logger.warn("Failed to write update cache", {
+        error: toMessage(e)
+      });
+    }
+  }
+};
+
 // src/cli/container.ts
-function createContainer(db, dbPath, detectGitRemote2) {
+function createContainer(db, dbPath, detectGitRemote2, updateCachePath) {
   const projectRepo = new SqliteProjectRepository(db);
   const taskRepo = new SqliteTaskRepository(db);
   const depRepo = new SqliteDependencyRepository(db);
@@ -2006,12 +2148,25 @@ function createContainer(db, dbPath, detectGitRemote2) {
   const dependencyService = new DependencyServiceImpl(depRepo, taskRepo);
   const taskService = new TaskServiceImpl(taskRepo, projectService, () => dependencyService);
   const portabilityService = new PortabilityServiceImpl(taskService, dependencyService);
-  return { dbPath, projectService, taskService, dependencyService, portabilityService };
+  const updateService = new UpdateServiceImpl(
+    updateCachePath ?? join3(tmpdir(), "tayto-update-check.json")
+  );
+  return {
+    dbPath,
+    projectService,
+    taskService,
+    dependencyService,
+    portabilityService,
+    updateService
+  };
 }
 
 // src/cli/index.ts
 import { Command } from "commander";
 
+// src/version.ts
+var APP_VERSION = true ? "0.6.0" : "0.0.0-dev";
+
 // src/cli/output.ts
 function printSuccess(data) {
   process.stdout.write(JSON.stringify({ ok: true, data }, null, 2) + "\n");
@@ -2204,12 +2359,12 @@ function registerTaskDelete(parent, container) {
 }
 
 // src/cli/commands/task/breakdown.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 function registerTaskBreakdown(parent, container) {
   parent.command("breakdown <parentId>").description("Create subtasks from a JSON file").requiredOption("-f, --file <path>", "JSON file with array of subtask definitions").action((parentId, opts) => {
     let content;
     try {
-      content = readFileSync2(opts.file, "utf-8");
+      content = readFileSync3(opts.file, "utf-8");
     } catch (e) {
       return printError(
         new AppError("VALIDATION", `Failed to read subtasks file: ${opts.file}`, e)
@@ -2263,7 +2418,7 @@ function registerTaskSearch(parent, container) {
 }
 
 // src/cli/commands/task/export.ts
-import { writeFileSync } from "fs";
+import { writeFileSync as writeFileSync2 } from "fs";
 function registerTaskExport(parent, container) {
   parent.command("export").description("Export tasks to JSON file").option("-p, --project <project>", "Project id or name").option("-o, --output <file>", "Output file path (defaults to stdout)").action((opts) => {
     const projectResult = withProject(container, opts.project);
@@ -2274,7 +2429,7 @@ function registerTaskExport(parent, container) {
     }
     if (opts.output) {
       try {
-        writeFileSync(opts.output, JSON.stringify(result.value, null, 2) + "\n", "utf-8");
+        writeFileSync2(opts.output, JSON.stringify(result.value, null, 2) + "\n", "utf-8");
       } catch (e) {
         return printError(new AppError("UNKNOWN", `Failed to write file: ${opts.output}`, e));
       }
@@ -2290,7 +2445,7 @@ function registerTaskExport(parent, container) {
 }
 
 // src/cli/commands/task/import.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 function registerTaskImport(parent, container) {
   parent.command("import").description("Import tasks from JSON file").requiredOption("-f, --file <file>", "Input JSON file path").option("-p, --project <project>", "Target project id or name").option(
     "--map <mapping>",
@@ -2298,7 +2453,7 @@ function registerTaskImport(parent, container) {
   ).action((opts) => {
     let fileData;
     try {
-      const raw = readFileSync3(opts.file, "utf-8");
+      const raw = readFileSync4(opts.file, "utf-8");
       fileData = JSON.parse(raw);
     } catch (e) {
       return printError(
@@ -2372,10 +2527,42 @@ function registerDepGraph(parent, container) {
   });
 }
 
+// src/cli/commands/upgrade.ts
+function registerUpgrade(program, container) {
+  program.command("upgrade").description("Check for updates and upgrade to the latest version").action(async () => {
+    const checkResult = await container.updateService.checkForUpdate(APP_VERSION);
+    if (!checkResult.ok) {
+      printError(checkResult.error);
+      return;
+    }
+    if (!checkResult.value.updateAvailable) {
+      printSuccess({
+        message: "Already up to date",
+        currentVersion: checkResult.value.currentVersion
+      });
+      return;
+    }
+    process.stderr.write(
+      `Upgrading from ${checkResult.value.currentVersion} to ${checkResult.value.latestVersion}...
+`
+    );
+    const upgradeResult = container.updateService.performUpgrade(APP_VERSION);
+    if (!upgradeResult.ok) {
+      printError(upgradeResult.error);
+      return;
+    }
+    printSuccess({
+      message: "Upgrade complete",
+      previousVersion: checkResult.value.currentVersion,
+      installedVersion: upgradeResult.value.installedVersion
+    });
+  });
+}
+
 // src/cli/index.ts
 function buildCLI(container) {
   const program = new Command();
-  program.name("tayto").description("CLI task management for solo devs and AI agents").version("0.1.0");
+  program.name("tayto").description("CLI task management for solo devs and AI agents").version(APP_VERSION);
   const project = program.command("project").description("Manage projects");
   registerProjectCreate(project, container);
   registerProjectList(project, container);
@@ -2400,26 +2587,63 @@ function buildCLI(container) {
   registerDepRemove(dep, container);
   registerDepList(dep, container);
   registerDepGraph(dep, container);
+  registerUpgrade(program, container);
   program.command("tui").description("Launch interactive terminal UI").option("-p, --project <project>", "Start with specific project").action(async (opts) => {
-    const { launchTUI } = await import("./tui-24ZW56Q6.js");
+    const { launchTUI } = await import("./tui-WMESKCRD.js");
     await launchTUI(container, opts.project);
   });
   return program;
 }
 
 // src/index.ts
+async function checkForUpdateQuietly(container, currentVersion) {
+  let timerId;
+  try {
+    const result = await Promise.race([
+      container.updateService.checkForUpdate(currentVersion),
+      new Promise((resolve) => {
+        timerId = setTimeout(() => {
+          resolve(null);
+        }, 2e3);
+      })
+    ]);
+    clearTimeout(timerId);
+    if (result !== null && result.ok) {
+      return result.value;
+    }
+    return null;
+  } catch {
+    clearTimeout(timerId);
+    return null;
+  }
+}
 async function main() {
   const config = loadConfig();
   logger.init(config.logDir);
   initTelemetry(config);
   const db = createDatabase(config.dbPath);
   runMigrations(db);
-  const container = createContainer(db, config.dbPath);
+  const container = createContainer(db, config.dbPath, void 0, config.updateCachePath);
   const args = process.argv.slice(2);
+  const isUpgradeCommand = args[0] === "upgrade";
+  let updateCheck = null;
+  if (!config.noUpdateCheck && !isUpgradeCommand) {
+    updateCheck = await checkForUpdateQuietly(container, APP_VERSION);
+  }
   if (args.length === 0) {
-    const { launchTUI } = await import("./tui-24ZW56Q6.js");
-    await launchTUI(container);
+    const { launchTUI } = await import("./tui-WMESKCRD.js");
+    await launchTUI(
+      container,
+      void 0,
+      updateCheck?.updateAvailable ? updateCheck.latestVersion : void 0
+    );
   } else {
+    if (updateCheck?.updateAvailable) {
+      process.stderr.write(
+        `\x1B[33m[tayto]\x1B[0m Update available: ${updateCheck.currentVersion} \u2192 ${updateCheck.latestVersion}. Run: tayto upgrade
+`
+      );
+    }
     const program = buildCLI(container);
     await program.parseAsync(process.argv);
   }