takibibase 1.0.2 → 1.0.3

package/SKILL.md

@@ -23,6 +23,10 @@ error hints.
   takes a name or a UUID; single-grant keys may omit it.
   `takibi projects --add <name> <uuid>` keeps local aliases for offline use.
 - First probe: `takibi version` (needs no key; shows build + `jev` status).
+- Update notice: the CLI polls the npm registry once a day and nudges on
+  stderr when behind (never on `--json`). Silence it with
+  `TAKIBI_NO_UPDATE_CHECK=1`; point it at a mirror with
+  `TAKIBI_REGISTRY_URL`.
 
 ## Commands
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "takibibase",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Thin CLI for the Takibi API: ask, search, tasks, docs. Single file, zero dependencies.",
   "type": "module",
   "bin": {
-    "takibi": "./takibi.mjs"
+    "takibi": "takibi.mjs"
   },
   "files": [
     "takibi.mjs",

package/takibi.mjs

@@ -22,21 +22,24 @@
  * Exit codes: 0 ok (honest abstains included), 1 transport/API error,
  * 2 usage error.
  */
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, writeSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
 /** Baked fallback; the published package re-reads package.json next door. */
-const BAKED_VERSION = '1.0.2';
-const CLI_VERSION = (() => {
+const BAKED_VERSION = '1.0.3';
+const CLI_INFO = (() => {
   try {
     const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
-    if (pkg.name === 'takibibase' && typeof pkg.version === 'string' && pkg.version.length > 0) return pkg.version;
+    if (pkg.name === 'takibibase' && typeof pkg.version === 'string' && pkg.version.length > 0) {
+      return { version: pkg.version, singleFile: false };
+    }
   } catch {
     // Single-file download: no package.json travels with takibi.mjs.
   }
-  return BAKED_VERSION;
+  return { version: BAKED_VERSION, singleFile: true };
 })();
+const CLI_VERSION = CLI_INFO.version;
 const DEFAULT_BASE_URL = 'http://localhost:3849';
 const REQUEST_TIMEOUT_MS = 90_000;
 const USER_AGENT = `takibibase/${CLI_VERSION}`;
@@ -66,6 +69,78 @@ const usageError = (message) => new CliError(message, { exitCode: 2 });
 
 const takibiDir = () => join(homedir(), '.takibi');
 
+const UPDATE_CHECK_TTL_MS = 86_400_000;
+const REGISTRY_URL = (process.env.TAKIBI_REGISTRY_URL ?? '').trim().replace(/\/+$/, '') || 'https://registry.npmjs.org';
+
+/** Numeric dotted-version compare; false on anything unparseable. */
+function versionBehind(current, latest) {
+  const parts = (v) => String(v ?? '').trim().split('.');
+  const c = parts(current);
+  const l = parts(latest);
+  for (let i = 0; i < Math.max(c.length, l.length); i++) {
+    const a = i < c.length ? Number(c[i]) : 0;
+    const b = i < l.length ? Number(l[i]) : 0;
+    if (!Number.isInteger(a) || !Number.isInteger(b)) return false;
+    if (b > a) return true;
+    if (a > b) return false;
+  }
+  return false;
+}
+
+/** Once-a-day latest-version poll. Stderr only (stdout stays clean),
+ * best-effort, never fails the command. Failures are cached too, so an
+ * unreachable registry costs one slow run a day, not every invocation.
+ * Skipped for --json (errors there are a single JSON object), in CI, and
+ * with TAKIBI_NO_UPDATE_CHECK=1. */
+async function maybeNotifyUpdate({ json = false } = {}) {
+  try {
+    if (json || process.env.CI || process.env.TAKIBI_NO_UPDATE_CHECK === '1') return;
+    const path = join(takibiDir(), 'update-check');
+    let cached = null;
+    try {
+      cached = JSON.parse(readFileSync(path, 'utf8'));
+    } catch {
+      // First run: no cache yet.
+    }
+    const fresh = cached && typeof cached.at === 'number' && Date.now() - cached.at < UPDATE_CHECK_TTL_MS;
+    let latest = null;
+    if (fresh) {
+      if (typeof cached.latest !== 'string' || !cached.latest) return;
+      latest = cached.latest;
+    } else {
+      try {
+        const res = await fetch(`${REGISTRY_URL}/takibibase/latest`, { signal: AbortSignal.timeout(1200) });
+        const v = res.ok ? (await res.json())?.version : null;
+        if (typeof v === 'string' && v) latest = v;
+      } catch {
+        // Offline: fall through below.
+      }
+      if (!latest && cached && typeof cached.latest === 'string' && cached.latest) {
+        // Failed refresh keeps the last known version: a timeout or 5xx must
+        // not delete a nudge we already knew about. The fresh timestamp still
+        // stops us hammering the registry.
+        latest = cached.latest;
+      }
+      try {
+        mkdirSync(takibiDir(), { recursive: true });
+        writeFileSync(path, JSON.stringify({ at: Date.now(), latest }));
+      } catch {
+        // Read-only home: notifying still works, caching just retries daily.
+      }
+      if (!latest) return;
+    }
+    if (!versionBehind(CLI_VERSION, latest)) return;
+    err(`takibi: ${latest} is available (you have ${CLI_VERSION}).`);
+    err(
+      CLI_INFO.singleFile
+        ? 'hint: download the latest takibi.mjs from https://takibibase.com/downloads/takibi.mjs'
+        : 'hint: `npm i -g takibibase@latest`, or `npx takibibase@latest` for one-shot runs.',
+    );
+  } catch {
+    // Offline, broken cache, slow registry: stay silent, run the command.
+  }
+}
+
 /** First non-blank, non-comment line of a file, or null when missing. */
 function firstLine(path) {
   if (!existsSync(path)) return null;
@@ -753,8 +828,10 @@ async function main(argv) {
   const { globals, rest } = parseArgv(argv);
   if (globals.version) {
     out(`takibi ${CLI_VERSION}`);
+    await maybeNotifyUpdate({ json: globals.json });
     return;
   }
+  await maybeNotifyUpdate({ json: globals.json });
   const [cmd, ...tokens] = rest;
   if (globals.help || !cmd) {
     out(HELP);