@worca/ui 0.1.0-rc.5 → 0.1.1

package/server/versions.js

@@ -0,0 +1,260 @@
+// server/versions.js — version fetching + caching for worca-cc and @worca/ui
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readPreferences } from './preferences.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/** Cache: { data, timestamp } */
+let _cache = null;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Compare two semver-ish strings. Returns -1, 0, or 1.
+ * Strips pre-release suffixes for comparison (e.g. "rc", "dev", "alpha").
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+export function compareVersions(a, b) {
+  if (!a || !b) return 0;
+  const parse = (v) =>
+    v.split('.').map((s) => {
+      const n = parseInt(s, 10);
+      return Number.isNaN(n) ? 0 : n;
+    });
+  const pa = parse(a);
+  const pb = parse(b);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const x = pa[i] || 0;
+    const y = pb[i] || 0;
+    if (x > y) return 1;
+    if (x < y) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Parse a PyPI pre-release version like "0.6.0rc7" → { base: "0.6.0", rc: 7 }
+ * Returns null if not an RC version.
+ * @param {string} versionStr
+ * @returns {{ base: string, rc: number } | null}
+ */
+export function parsePyPIPreRelease(versionStr) {
+  const match = versionStr.match(/^(.+?)rc(\d+)$/);
+  if (!match) return null;
+  return { base: match[1], rc: parseInt(match[2], 10) };
+}
+
+/**
+ * Fetch latest + latestRc versions from npm registry.
+ * @param {string} packageName
+ * @returns {Promise<{ latest: string|null, latestRc: string|null }>}
+ */
+export async function fetchNpmVersions(packageName) {
+  const nullResult = { latest: null, latestRc: null };
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3000);
+    let res;
+    try {
+      res = await fetch(`https://registry.npmjs.org/${packageName}`, {
+        signal: controller.signal,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) return nullResult;
+    const data = await res.json();
+    const latest = data['dist-tags']?.latest || null;
+    let latestRc = data['dist-tags']?.rc || null;
+    if (!latestRc && data.versions) {
+      // Scan version keys for highest *-rc.* pattern
+      let bestRc = null;
+      let bestRcNum = -1;
+      for (const ver of Object.keys(data.versions)) {
+        const rcMatch = ver.match(/^(.+)-rc\.(\d+)$/);
+        if (rcMatch) {
+          const rcNum = parseInt(rcMatch[2], 10);
+          const base = rcMatch[1];
+          // Compare base+rcNum to find the highest RC
+          if (
+            !bestRc ||
+            compareVersions(base, bestRc.base) > 0 ||
+            (compareVersions(base, bestRc.base) === 0 && rcNum > bestRcNum)
+          ) {
+            bestRc = { base, full: ver };
+            bestRcNum = rcNum;
+          }
+        }
+      }
+      if (bestRc) latestRc = bestRc.full;
+    }
+    return { latest, latestRc };
+  } catch {
+    return nullResult;
+  }
+}
+
+/**
+ * Fetch latest + latestRc versions from PyPI.
+ * @param {string} packageName
+ * @returns {Promise<{ latest: string|null, latestRc: string|null }>}
+ */
+export async function fetchPyPIVersions(packageName) {
+  const nullResult = { latest: null, latestRc: null };
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3000);
+    let res;
+    try {
+      res = await fetch(`https://pypi.org/pypi/${packageName}/json`, {
+        signal: controller.signal,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) return nullResult;
+    const data = await res.json();
+    const latest = data.info?.version || null;
+    // Scan releases for highest rc version
+    let latestRc = null;
+    if (data.releases) {
+      let bestRcNum = -1;
+      let bestBase = null;
+      for (const ver of Object.keys(data.releases)) {
+        const parsed = parsePyPIPreRelease(ver);
+        if (parsed) {
+          if (
+            !bestBase ||
+            compareVersions(parsed.base, bestBase) > 0 ||
+            (compareVersions(parsed.base, bestBase) === 0 &&
+              parsed.rc > bestRcNum)
+          ) {
+            bestBase = parsed.base;
+            bestRcNum = parsed.rc;
+            latestRc = ver;
+          }
+        }
+      }
+    }
+    return { latest, latestRc };
+  } catch {
+    return nullResult;
+  }
+}
+
+/**
+ * Read versions from local dev path.
+ * @param {string} sourceRepo - path to local worca-cc repo
+ * @returns {{ worcaCc: string|null, worcaUi: string|null }}
+ */
+export function getDevPathVersions(sourceRepo) {
+  const result = { worcaCc: null, worcaUi: null };
+  if (!sourceRepo) return result;
+  try {
+    const pyproject = readFileSync(join(sourceRepo, 'pyproject.toml'), 'utf8');
+    const match = pyproject.match(/^version\s*=\s*"([^"]+)"/m);
+    if (match) result.worcaCc = match[1];
+  } catch {
+    // pyproject.toml not found or unreadable
+  }
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(sourceRepo, 'worca-ui', 'package.json'), 'utf8'),
+    );
+    if (pkg.version) result.worcaUi = pkg.version;
+  } catch {
+    // package.json not found or unreadable
+  }
+  return result;
+}
+
+/**
+ * Get installed @worca/ui version from own package.json.
+ * @returns {string|null}
+ */
+function getInstalledUiVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(__dirname, '..', 'package.json'), 'utf8'),
+    );
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Main orchestrator: fetch all version info with caching.
+ * @param {{ prefsPath?: string|null, worcaVersion?: object|null, force?: boolean }} options
+ * @returns {Promise<object>}
+ */
+export async function getVersionInfo({ prefsPath, worcaVersion, force } = {}) {
+  // Return cached result if fresh
+  if (!force && _cache && Date.now() - _cache.timestamp < CACHE_TTL_MS) {
+    return _cache.data;
+  }
+
+  // Read source_repo from preferences
+  let sourceRepo = null;
+  if (prefsPath) {
+    const prefs = readPreferences(prefsPath);
+    sourceRepo = prefs.source_repo || null;
+  }
+
+  // Fetch in parallel
+  const [npmResult, pypiResult] = await Promise.allSettled([
+    fetchNpmVersions('@worca/ui'),
+    fetchPyPIVersions('worca-cc'),
+  ]);
+
+  const npm =
+    npmResult.status === 'fulfilled'
+      ? npmResult.value
+      : { latest: null, latestRc: null };
+  const pypi =
+    pypiResult.status === 'fulfilled'
+      ? pypiResult.value
+      : { latest: null, latestRc: null };
+
+  // Dev path versions
+  const devVersions = sourceRepo ? getDevPathVersions(sourceRepo) : null;
+
+  // Installed versions
+  const installedUi = getInstalledUiVersion();
+  const installedCc = worcaVersion?.installed || null;
+
+  const data = {
+    ok: true,
+    worcaCc: {
+      installed: installedCc,
+      latest: pypi.latest,
+      latestRc: pypi.latestRc,
+    },
+    worcaUi: {
+      installed: installedUi,
+      latest: npm.latest,
+      latestRc: npm.latestRc,
+    },
+    devPath: devVersions
+      ? {
+          path: sourceRepo,
+          worcaCc: devVersions.worcaCc,
+          worcaUi: devVersions.worcaUi,
+        }
+      : null,
+    activeWorcaCc: devVersions?.worcaCc || installedCc,
+    cachedAt: new Date().toISOString(),
+  };
+
+  _cache = { data, timestamp: Date.now() };
+  return data;
+}
+
+/** Clear the cache (for testing). */
+export function clearCache() {
+  _cache = null;
+}

package/server/worca-setup.js

@@ -9,7 +9,7 @@
  */
 
 import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 /**
@@ -19,6 +19,23 @@ export function checkWorcaInstalled(projectPath) {
   return existsSync(join(projectPath, '.claude', 'worca'));
 }
 
+/**
+ * Read the worca-cc version from a project's .claude/worca/__init__.py.
+ * Returns the version string or null if not found.
+ */
+export function readProjectWorcaVersion(projectPath) {
+  try {
+    const initPy = readFileSync(
+      join(projectPath, '.claude', 'worca', '__init__.py'),
+      'utf8',
+    );
+    const match = initPy.match(/^__version__\s*=\s*["']([^"']+)["']/m);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Spawn `worca init --upgrade` in the target project directory.
  * Optionally passes --source if a source repo path is provided.

package/server/ws-beads-watcher.js

@@ -8,7 +8,7 @@ import { existsSync, watch } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { listIssues } from './beads-reader.js';
 
-const BEADS_DEBOUNCE_MS = 200;
+const BEADS_DEBOUNCE_MS = 300;
 
 /**
  * @param {{ worcaDir: string, broadcaster: { broadcast: Function }, projectId?: string }} deps