@ai-agent-tools/picgen 0.1.0-alpha.0 → 0.1.0-alpha.1

package/README.md

@@ -44,6 +44,7 @@ For first-user rollout, see [docs/release-alpha.md](./docs/release-alpha.md).
 ```bash
 picgen setup
 picgen quickstart
+picgen update check
 picgen doctor --json
 picgen create --dry-run "一张产品发布会主视觉"
 picgen create --yes "一张产品发布会主视觉"
@@ -103,3 +104,17 @@ Providers may optionally set `test_model` in `~/.picgen/config.yaml` when health
 Providers expose capabilities such as `text-to-image` and `reference-image`. Old configs that omit capabilities are upgraded in memory from the provider protocol: Gemini supports both text and reference-image generation, while OpenAI-compatible `/v1/images/generations` supports text-to-image only.
 
 Generated image data and provider-only fields such as base64 image payloads and Gemini thought signatures are redacted from metadata. PicGen keeps the generated assets as local image files and keeps stdout compact for agent workflows.
+
+## Updates
+
+Check npm for the latest PicGen version:
+
+```bash
+picgen update check
+```
+
+`picgen doctor` and `picgen quickstart` may show a lightweight update hint. PicGen caches update checks for 24 hours. Disable update checks with:
+
+```bash
+PICGEN_DISABLE_UPDATE_CHECK=1 picgen doctor
+```

package/dist/cli.js

@@ -992,6 +992,140 @@ function inspectProviders(config) {
   });
 }
 
+// src/commands/update.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/version.ts
+var PACKAGE_NAME = "@ai-agent-tools/picgen";
+var VERSION = "0.1.0-alpha.0";
+
+// src/commands/update.ts
+var UPDATE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+async function runUpdateCheck(options = {}) {
+  const result = await checkForUpdate({ force: true });
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const message = formatUpdateMessage(result);
+  console.log(message ?? "PicGen is up to date.");
+}
+async function maybePrintUpdateHint() {
+  const result = await checkForUpdate({ force: false });
+  const message = formatUpdateMessage(result);
+  if (message) {
+    console.log("");
+    console.log(message);
+  }
+}
+async function checkForUpdate(options = {}) {
+  if (process.env.PICGEN_DISABLE_UPDATE_CHECK === "1") {
+    return {
+      checked: false,
+      disabled: true,
+      current_version: VERSION,
+      package_name: PACKAGE_NAME
+    };
+  }
+  try {
+    const cached = options.force ? void 0 : await readFreshCache();
+    const latestVersion = cached?.latest_version ?? await fetchLatestVersion();
+    const checkedAt = cached?.checked_at ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (!cached) {
+      await writeCache({
+        checked_at: checkedAt,
+        latest_version: latestVersion
+      });
+    }
+    return {
+      checked: true,
+      current_version: VERSION,
+      latest_version: latestVersion,
+      update_available: isNewerVersion(latestVersion, VERSION),
+      package_name: PACKAGE_NAME,
+      checked_at: checkedAt
+    };
+  } catch (error) {
+    return {
+      checked: false,
+      current_version: VERSION,
+      package_name: PACKAGE_NAME,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatUpdateMessage(result) {
+  if (!result.checked || !result.update_available || !result.latest_version) {
+    return void 0;
+  }
+  return [
+    `PicGen update available: ${result.current_version} -> ${result.latest_version}`,
+    "Upgrade with:",
+    `  npm install -g ${result.package_name}@latest`
+  ].join("\n");
+}
+function isNewerVersion(candidate, current) {
+  const candidateParts = parseVersion(candidate);
+  const currentParts = parseVersion(current);
+  for (let index = 0; index < 3; index += 1) {
+    if (candidateParts.numbers[index] > currentParts.numbers[index]) return true;
+    if (candidateParts.numbers[index] < currentParts.numbers[index]) return false;
+  }
+  if (!candidateParts.prerelease && currentParts.prerelease) return true;
+  if (candidateParts.prerelease && !currentParts.prerelease) return false;
+  if (candidateParts.prerelease && currentParts.prerelease) {
+    return candidateParts.prerelease.localeCompare(currentParts.prerelease) > 0;
+  }
+  return false;
+}
+async function fetchLatestVersion() {
+  const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}`);
+  if (!response.ok) {
+    throw new Error(`npm registry returned ${response.status} ${response.statusText}`.trim());
+  }
+  const body = await response.json();
+  const latest = body["dist-tags"]?.latest;
+  if (typeof latest !== "string" || !latest) {
+    throw new Error("npm registry response did not include dist-tags.latest.");
+  }
+  return latest;
+}
+async function readFreshCache() {
+  try {
+    const cache = JSON.parse(await readFile3(getUpdateCachePath(), "utf8"));
+    const checkedAt = Date.parse(cache.checked_at);
+    if (!Number.isFinite(checkedAt)) return void 0;
+    if (Date.now() - checkedAt > UPDATE_CACHE_TTL_MS) return void 0;
+    return cache;
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    return void 0;
+  }
+}
+async function writeCache(cache) {
+  const path = getUpdateCachePath();
+  await mkdir3(dirname2(path), { recursive: true });
+  await writeFile3(path, JSON.stringify(cache, null, 2), "utf8");
+}
+function getUpdateCachePath() {
+  if (process.env.PICGEN_UPDATE_CACHE_PATH) return process.env.PICGEN_UPDATE_CACHE_PATH;
+  return join4(homedir2(), ".picgen", "update-check.json");
+}
+function parseVersion(version) {
+  const [core, prerelease] = version.split("-", 2);
+  const numbers = core.split(".").map((part) => Number.parseInt(part, 10));
+  return {
+    numbers: [
+      Number.isFinite(numbers[0]) ? numbers[0] : 0,
+      Number.isFinite(numbers[1]) ? numbers[1] : 0,
+      Number.isFinite(numbers[2]) ? numbers[2] : 0
+    ],
+    prerelease
+  };
+}
+
 // src/commands/doctor.ts
 async function runDoctor(options) {
   const config = await loadConfig();
@@ -1002,6 +1136,7 @@ async function runDoctor(options) {
       JSON.stringify(
         {
           configured,
+          version: VERSION,
           config_path: getConfigPath(),
           default_preset: config.default_preset,
           default_mode: config.routing.default_mode,
@@ -1016,6 +1151,7 @@ async function runDoctor(options) {
     return;
   }
   console.log(`Config: ${getConfigPath()}`);
+  console.log(`Version: ${VERSION}`);
   console.log(`Default preset: ${config.default_preset}`);
   console.log(`Default mode: ${config.routing.default_mode}`);
   console.log(`Default provider: ${config.routing.default_provider}`);
@@ -1031,6 +1167,7 @@ async function runDoctor(options) {
     console.log("");
     console.log("No usable provider found. Run `picgen setup` or set the API key env vars above.");
   }
+  await maybePrintUpdateHint();
 }
 
 // src/commands/provider.ts
@@ -1320,8 +1457,9 @@ async function preferPreset(name) {
 }
 
 // src/commands/quickstart.ts
-function runQuickstart() {
+async function runQuickstart() {
   console.log(formatQuickstart());
+  await maybePrintUpdateHint();
 }
 function formatQuickstart() {
   return [
@@ -1572,7 +1710,7 @@ function modeLabel(modeName) {
 
 // src/cli.ts
 var program = new Command();
-program.name("picgen").description("Lightweight image generation connector for AI agents.").version("0.1.0-alpha.0");
+program.name("picgen").description("Lightweight image generation connector for AI agents.").version(VERSION);
 program.command("setup").description("Run the interactive PicGen setup wizard.").action(runSetup);
 program.command("quickstart").description("Print install and first-run guidance.").action(runQuickstart);
 program.command("doctor").description("Inspect PicGen configuration and provider readiness.").option("--json", "Print machine-readable JSON.").action(runDoctor);
@@ -1593,6 +1731,7 @@ provider.command("disable").argument("<name>").description("Disable a provider."
 provider.command("remove").argument("<name>").description("Remove a provider.").action(removeProvider);
 program.command("mode").description("Manage generation mode preferences.").command("prefer").argument("<name>").description("Set the default mode preference.").action(preferMode);
 program.command("preset").description("Manage generation preset preferences.").command("prefer").argument("<name>").description("Set the default preset preference.").action(preferPreset);
+program.command("update").description("Manage PicGen updates.").command("check").description("Check whether a newer PicGen version is available.").option("--json", "Print machine-readable JSON.").action(runUpdateCheck);
 program.parseAsync().catch((error) => {
   console.error(error instanceof Error ? error.message : String(error));
   process.exitCode = 1;

package/docs/release-alpha.md

@@ -57,6 +57,12 @@ GEMINI_API_KEY=...
 picgen doctor --json
 ```
 
+6. Check whether a newer PicGen version is available:
+
+```bash
+picgen update check
+```
+
 ## Safe Preview
 
 Always start with dry-run:
@@ -157,3 +163,9 @@ Publish when ready:
 ```bash
 npm publish --otp <code>
 ```
+
+After publishing, ask trial users to upgrade with:
+
+```bash
+npm install -g @ai-agent-tools/picgen@latest
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-agent-tools/picgen",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.1",
   "description": "A lightweight image generation connector for AI agents.",
   "type": "module",
   "bin": {