wogiflow 1.9.5 → 1.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "1.9.5",
+  "version": "1.9.6",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/flow-version-check.js

@@ -1,12 +1,16 @@
 /**
  * flow-version-check.js
  *
- * Proactive Claude Code version compatibility check.
- * Called at session start, but only checks once per install/update
- * to avoid nagging on every session.
+ * Version compatibility and update checks.
+ * Called at session start with two independent checks:
  *
- * - Hard minimum (2.1.23): Hooks don't work below this — always warn
- * - Soft gates (2.1.50+, 2.1.72+): Degrade gracefully, no warning
+ * 1. Claude Code compatibility: checks once per install/update
+ *    - Hard minimum (2.1.23): Hooks don't work below this — always warn
+ *    - Soft gates (2.1.50+, 2.1.72+): Degrade gracefully, no warning
+ *
+ * 2. WogiFlow npm update: checks once per 24h
+ *    - Fetches latest version from npm registry
+ *    - Warns if local version is outdated
  */
 
 const fs = require('fs');
@@ -135,4 +139,107 @@ function checkClaudeCodeVersionOnce() {
   return null;
 }
 
-module.exports = { checkClaudeCodeVersionOnce, getClaudeCodeVersion };
+// --- WogiFlow npm update check ---
+
+const UPDATE_CHECK_PATH = path.join(PATHS.state, '.update-check.json');
+const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+/**
+ * Get the installed WogiFlow version from package.json.
+ * @returns {string} Version string or 'unknown'
+ */
+function getLocalWogiFlowVersion() {
+  try {
+    const pkgPath = path.join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version || 'unknown';
+  } catch (err) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Fetch the latest WogiFlow version from the npm registry.
+ * Uses a short timeout to avoid blocking session start.
+ * @returns {string|null} Latest version or null on failure
+ */
+function fetchLatestNpmVersion() {
+  try {
+    const output = execSync(
+      'npm view wogiflow version 2>/dev/null || echo ""',
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000 }
+    ).trim();
+    const match = output.match(/^(\d+\.\d+\.\d+)$/);
+    return match ? match[1] : null;
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Compare two semver strings. Returns true if remote is newer than local.
+ * @param {string} local - e.g. "1.9.4"
+ * @param {string} remote - e.g. "1.9.5"
+ * @returns {boolean}
+ */
+function isNewerVersion(local, remote) {
+  const [lMaj, lMin, lPat] = local.split('.').map(Number);
+  const [rMaj, rMin, rPat] = remote.split('.').map(Number);
+  if (rMaj !== lMaj) return rMaj > lMaj;
+  if (rMin !== lMin) return rMin > lMin;
+  return rPat > lPat;
+}
+
+/**
+ * Check if a newer WogiFlow version is available on npm.
+ * Checks at most once per 24 hours to avoid unnecessary network calls.
+ *
+ * @returns {string|null} Warning message if outdated, null otherwise
+ */
+function checkWogiFlowUpdateOnce() {
+  const localVersion = getLocalWogiFlowVersion();
+  if (localVersion === 'unknown') return null;
+
+  // Check cached result
+  try {
+    const cached = fs.readFileSync(UPDATE_CHECK_PATH, 'utf-8');
+    const data = JSON.parse(cached);
+    const age = Date.now() - new Date(data.checkedAt).getTime();
+    if (age < UPDATE_CHECK_TTL_MS && data.localVersion === localVersion) {
+      // Still within TTL and same local version — return cached result
+      if (data.latestVersion && isNewerVersion(localVersion, data.latestVersion)) {
+        return `WogiFlow ${localVersion} is outdated. Latest: ${data.latestVersion}. Update with: npm install -D wogiflow@latest`;
+      }
+      return null;
+    }
+  } catch (err) {
+    // No cache or invalid — proceed with fresh check
+  }
+
+  // Fetch from npm
+  const latestVersion = fetchLatestNpmVersion();
+
+  // Cache the result (even if null — prevents retrying on every session)
+  try {
+    fs.mkdirSync(path.dirname(UPDATE_CHECK_PATH), { recursive: true });
+    fs.writeFileSync(UPDATE_CHECK_PATH, JSON.stringify({
+      localVersion,
+      latestVersion: latestVersion || null,
+      checkedAt: new Date().toISOString()
+    }, null, 2));
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[version-check] Failed to cache update check: ${err.message}`);
+    }
+  }
+
+  if (!latestVersion) return null;
+
+  if (isNewerVersion(localVersion, latestVersion)) {
+    return `WogiFlow ${localVersion} is outdated. Latest: ${latestVersion}. Update with: npm install -D wogiflow@latest`;
+  }
+
+  return null;
+}
+
+module.exports = { checkClaudeCodeVersionOnce, getClaudeCodeVersion, checkWogiFlowUpdateOnce };

package/scripts/hooks/entry/claude-code/session-start.js

@@ -82,12 +82,15 @@ async function main() {
       }
     }
 
-    // --- Version compatibility check (runs once per install/update) ---
-    // Only warns if Claude Code is below the hard minimum (2.1.23) where hooks don't work.
+    // --- Version compatibility checks ---
+    // 1. Claude Code: warns if below hard minimum (2.1.23) where hooks don't work
+    // 2. WogiFlow npm: warns if a newer version is available (checks once per 24h)
     let versionWarning = null;
+    let updateWarning = null;
     try {
-      const { checkClaudeCodeVersionOnce } = require('../../../flow-version-check');
+      const { checkClaudeCodeVersionOnce, checkWogiFlowUpdateOnce } = require('../../../flow-version-check');
       versionWarning = checkClaudeCodeVersionOnce();
+      updateWarning = checkWogiFlowUpdateOnce();
     } catch (err) {
       if (process.env.DEBUG) {
         console.error(`[session-start] Version check failed: ${err.message}`);
@@ -285,6 +288,11 @@ async function main() {
       coreResult.context.versionWarning = versionWarning;
     }
 
+    // Inject WogiFlow update warning (if any)
+    if (updateWarning && coreResult && coreResult.context) {
+      coreResult.context.updateWarning = updateWarning;
+    }
+
     // Inject drift detection results (if any)
     if (driftDetected && coreResult && coreResult.context) {
       if (driftMarkerMissing) {