@worca/ui 0.8.1 → 0.9.0-rc.1

package/server/subagents-discovery.js

@@ -0,0 +1,116 @@
+/**
+ * Subagent discovery for the settings dispatch-rule editor.
+ *
+ * Walks three sources (built-ins, user-global, plugin cache) and returns a
+ * deduplicated list matching the shape used by `worca-ui/app/views/
+ * dispatch-tag-state.js` (`{name, label, group}`).
+ *
+ * The three sources:
+ *   1. Built-ins — hardcoded Claude Code types that are not on disk.
+ *   2. User — `<userDir>/*.md`, one file per subagent.
+ *   3. Plugins — `<pluginCacheDir>/<marketplace>/<plugin>/<version>/agents/*.md`.
+ *      Deduped by the qualified name `<plugin>:<agent>` — first file wins
+ *      across versions (the set of agents within a plugin is stable in
+ *      practice; when two versions disagree we prefer filesystem order for
+ *      determinism rather than trying to parse semver from directory names).
+ */
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+// Built-in Claude Code subagents — shipped with a factory CC install, no
+// plugins required. Mirror this list in worca-ui/app/views/
+// dispatch-tag-state.js (KNOWN_TYPES) so the UI falls back to the same set
+// when the /api/subagents fetch fails.
+export const BUILTINS = [
+  { name: 'Explore', label: '(built-in)', group: 'Built-in' },
+  { name: 'general-purpose', label: '(built-in)', group: 'Built-in' },
+  { name: 'Plan', label: '(built-in)', group: 'Built-in' },
+  { name: 'statusline-setup', label: '(built-in)', group: 'Built-in' },
+  { name: 'claude-code-guide', label: '(built-in)', group: 'Built-in' },
+];
+
+function listMarkdownBasenames(dir) {
+  if (!dir || !existsSync(dir)) return [];
+  try {
+    return readdirSync(dir)
+      .filter((n) => n.endsWith('.md'))
+      .map((n) => basename(n, '.md'));
+  } catch {
+    return [];
+  }
+}
+
+function listSubdirs(dir) {
+  if (!existsSync(dir)) return [];
+  try {
+    return readdirSync(dir).filter((n) => {
+      try {
+        return statSync(join(dir, n)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Discover all subagent types reachable from the given directories.
+ *
+ * @param {object} options
+ * @param {Array<{name:string,label:string,group:string}>} [options.builtins]
+ * @param {string} [options.userDir]           e.g. ~/.claude/agents
+ * @param {string} [options.pluginCacheDir]    e.g. ~/.claude/plugins/cache
+ * @param {string} [options.projectAgentsDir]  e.g. <project>/.claude/agents
+ * @returns {Array<{name:string,label:string,group:string}>}
+ */
+export function discoverSubagents({
+  builtins = BUILTINS,
+  userDir,
+  pluginCacheDir,
+  projectAgentsDir,
+} = {}) {
+  const result = [...builtins];
+  const seen = new Set(result.map((t) => t.name));
+
+  for (const name of listMarkdownBasenames(userDir)) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      result.push({ name, label: '(user)', group: 'User' });
+    }
+  }
+
+  if (pluginCacheDir && existsSync(pluginCacheDir)) {
+    for (const marketplace of listSubdirs(pluginCacheDir)) {
+      const marketplaceDir = join(pluginCacheDir, marketplace);
+      for (const plugin of listSubdirs(marketplaceDir)) {
+        const pluginDir = join(marketplaceDir, plugin);
+        for (const version of listSubdirs(pluginDir)) {
+          const agentsDir = join(pluginDir, version, 'agents');
+          for (const agent of listMarkdownBasenames(agentsDir)) {
+            const qualified = `${plugin}:${agent}`;
+            if (!seen.has(qualified)) {
+              seen.add(qualified);
+              result.push({
+                name: qualified,
+                label: '(plugin)',
+                group: 'Plugin',
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (const name of listMarkdownBasenames(projectAgentsDir)) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      result.push({ name, label: '(project)', group: 'Project' });
+    }
+  }
+
+  return result;
+}

package/server/version-check.js

@@ -40,6 +40,41 @@ export function meetsMinimum(installed, minimum) {
   return true; // equal
 }
 
+/**
+ * Parse a version string into comparable parts, tracking RC suffixes.
+ * "0.6.0rc7" → { parts: [0, 6, 0], rc: 7 }
+ * "0.6.0"    → { parts: [0, 6, 0], rc: Infinity } (stable > any rc)
+ * "0.1.0-rc.5" → { parts: [0, 1, 0], rc: 5 }
+ */
+export function parseVersion(v) {
+  if (!v) return { parts: [], rc: Infinity };
+  const rcMatch = v.match(/^(.+?)[-.]?rc\.?(\d+)$/);
+  const base = rcMatch ? rcMatch[1] : v;
+  const rc = rcMatch ? parseInt(rcMatch[2], 10) : Infinity;
+  const parts = base.split('.').map((s) => parseInt(s, 10) || 0);
+  return { parts, rc };
+}
+
+/**
+ * Returns true if `project` version is strictly behind `active`.
+ * RC-aware: "0.6.0rc3" is behind "0.6.0". Returns false if either arg is falsy.
+ */
+export function isVersionBehind(project, active) {
+  if (!project || !active) return false;
+  const p = parseVersion(project);
+  const a = parseVersion(active);
+  const len = Math.max(p.parts.length, a.parts.length);
+  for (let i = 0; i < len; i++) {
+    const pv = p.parts[i] || 0;
+    const av = a.parts[i] || 0;
+    if (pv < av) return true;
+    if (pv > av) return false;
+  }
+  // Same base version — compare RC numbers
+  if (p.rc < a.rc) return true;
+  return false;
+}
+
 /**
  * Run `worca --version` and check compatibility.
  * @returns {Promise<{ok: boolean, installed: string|null, minimum: string, message: string}>}

package/server/watcher.js

@@ -2,6 +2,25 @@ import { createHash } from 'node:crypto';
 import { existsSync, readdirSync, readFileSync, watch } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import {
+  assignEventsToIterations,
+  readDispatchEventsFromJsonl,
+} from './dispatch-events-aggregator.js';
+
+/**
+ * Enrich a status object with dispatch events read from events.jsonl in the
+ * same run directory. Mutates `status.stages` by adding `dispatch_events` to
+ * matching iterations. No-op when events.jsonl is missing (e.g. a run that
+ * started before the emit was wired, or a run with no dispatches).
+ */
+function enrichWithDispatchEvents(status, runDir) {
+  if (!status?.stages) return status;
+  const eventsPath = join(runDir, 'events.jsonl');
+  const events = readDispatchEventsFromJsonl(eventsPath);
+  if (events.length === 0) return status;
+  status.stages = assignEventsToIterations(events, status.stages);
+  return status;
+}
 
 export function createRunId(status) {
   // Prefer run_id from status (new per-run format)
@@ -35,9 +54,11 @@ export function discoverRuns(worcaDir) {
   if (existsSync(activeRunPath)) {
     try {
       const activeId = readFileSync(activeRunPath, 'utf8').trim();
-      const candidate = join(worcaDir, 'runs', activeId, 'status.json');
+      const runDir = join(worcaDir, 'runs', activeId);
+      const candidate = join(runDir, 'status.json');
       if (existsSync(candidate)) {
-        const status = JSON.parse(readFileSync(candidate, 'utf8'));
+        let status = JSON.parse(readFileSync(candidate, 'utf8'));
+        status = enrichWithDispatchEvents(status, runDir);
         const active =
           !isTerminal(status) && status.pipeline_status === 'running';
         const id = createRunId(status);
@@ -53,10 +74,12 @@ export function discoverRuns(worcaDir) {
   const runsDir = join(worcaDir, 'runs');
   if (existsSync(runsDir)) {
     for (const entry of readdirSync(runsDir)) {
-      const statusPath = join(runsDir, entry, 'status.json');
+      const runDir = join(runsDir, entry);
+      const statusPath = join(runDir, 'status.json');
       if (!existsSync(statusPath)) continue;
       try {
-        const status = JSON.parse(readFileSync(statusPath, 'utf8'));
+        let status = JSON.parse(readFileSync(statusPath, 'utf8'));
+        status = enrichWithDispatchEvents(status, runDir);
         const id = createRunId(status);
         if (seenIds.has(id)) continue;
         seenIds.add(id);
@@ -140,8 +163,10 @@ export async function discoverRunsAsync(worcaDir) {
   const activeRunPath = join(worcaDir, 'active_run');
   try {
     const activeId = (await readFile(activeRunPath, 'utf8')).trim();
-    const candidate = join(worcaDir, 'runs', activeId, 'status.json');
-    const status = JSON.parse(await readFile(candidate, 'utf8'));
+    const runDir = join(worcaDir, 'runs', activeId);
+    const candidate = join(runDir, 'status.json');
+    let status = JSON.parse(await readFile(candidate, 'utf8'));
+    status = enrichWithDispatchEvents(status, runDir);
     const active = !isTerminal(status) && status.pipeline_status === 'running';
     const id = createRunId(status);
     runs.push({ id, active, ...status });
@@ -156,15 +181,17 @@ export async function discoverRunsAsync(worcaDir) {
     const entries = await readdir(runsDir);
     const readPromises = entries.map(async (entry) => {
       try {
-        const statusPath = join(runsDir, entry, 'status.json');
+        const runDir = join(runsDir, entry);
+        const statusPath = join(runDir, 'status.json');
         const status = JSON.parse(await readFile(statusPath, 'utf8'));
-        return status;
+        return { status, runDir };
       } catch {
         return null;
       }
     });
-    for (const status of await Promise.all(readPromises)) {
-      if (!status) continue;
+    for (const result of await Promise.all(readPromises)) {
+      if (!result) continue;
+      const status = enrichWithDispatchEvents(result.status, result.runDir);
       const id = createRunId(status);
       if (seenIds.has(id)) continue;
       seenIds.add(id);

package/server/worca-setup.js

@@ -20,10 +20,24 @@ export function checkWorcaInstalled(projectPath) {
 }
 
 /**
- * Read the worca-cc version from a project's .claude/worca/__init__.py.
+ * Read the worca-cc version from a project's worca installation.
+ * Tries .claude/worca/version.json first, then falls back to __init__.py.
  * Returns the version string or null if not found.
  */
 export function readProjectWorcaVersion(projectPath) {
+  // Try version.json first (preferred format)
+  try {
+    const versionJson = JSON.parse(
+      readFileSync(
+        join(projectPath, '.claude', 'worca', 'version.json'),
+        'utf8',
+      ),
+    );
+    if (versionJson.version) return versionJson.version;
+  } catch {
+    // fall through to __init__.py
+  }
+  // Fall back to __init__.py
   try {
     const initPy = readFileSync(
       join(projectPath, '.claude', 'worca', '__init__.py'),

package/server/ws-modular.js

@@ -11,6 +11,7 @@ import { join } from 'node:path';
 import { WebSocketServer } from 'ws';
 import { readProjects, synthesizeDefaultProject } from './project-registry.js';
 import { TIER_FULL, TIER_POLLING, WatcherSet } from './watcher-set.js';
+import { readProjectWorcaVersion } from './worca-setup.js';
 import { createBroadcaster } from './ws-broadcaster.js';
 import { createClientManager } from './ws-client-manager.js';
 import { createMessageRouter } from './ws-message-router.js';
@@ -157,9 +158,12 @@ export function attachWsServer(httpServer, config) {
     }
 
     // Broadcast projects-updated to all clients
+    // Shape must match GET /api/projects so frontend state stays consistent
+    // (include worcaVersion — without it, clients would show "unknown" after
+    // the WS event clobbers the enriched REST response on add/remove)
     const projectList = freshProjects.map((p) => ({
-      name: p.name,
-      path: p.path,
+      ...p,
+      worcaVersion: readProjectWorcaVersion(p.path),
     }));
     broadcaster.broadcast('projects-updated', { projects: projectList });
   }