wogiflow 2.6.4 → 2.7.0

package/.claude/settings.json

@@ -36,7 +36,6 @@
     ],
     "PostToolUse": [
       {
-        "matcher": "Edit|Write|Bash",
         "hooks": [
           {
             "type": "command",

package/lib/workspace-changelog.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Workspace — Cross-Repo Changelog Aggregation
+ *
+ * Aggregates request-log entries from all member repos into a unified
+ * timeline showing the full story of cross-repo changes.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { WORKSPACE_CONFIG_FILE } = require('./workspace');
+
+// ============================================================
+// Request Log Parsing
+// ============================================================
+
+/**
+ * Parse a member's request-log.md into structured entries.
+ *
+ * @param {string} logContent — raw request-log.md content
+ * @param {string} repoName — name of the repo
+ * @returns {Array<Object>} parsed entries
+ */
+function parseRequestLog(logContent, repoName) {
+  const entries = [];
+  const sections = logContent.split(/^### /m).filter(Boolean);
+
+  for (const section of sections) {
+    const lines = section.trim().split('\n');
+    const header = lines[0] || '';
+
+    // Parse header: R-XXX | YYYY-MM-DD HH:MM
+    const headerMatch = header.match(/R-(\d+)\s*\|\s*(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2})/);
+    if (!headerMatch) continue;
+
+    const entry = {
+      repo: repoName,
+      id: `R-${headerMatch[1]}`,
+      date: headerMatch[2],
+      time: headerMatch[3],
+      // Note: request-log times are treated as local time (no timezone in format)
+      timestamp: new Date(`${headerMatch[2]}T${headerMatch[3]}:00`).toISOString(),
+      type: '',
+      tags: [],
+      request: '',
+      result: '',
+      files: []
+    };
+
+    // Parse fields
+    for (const line of lines.slice(1)) {
+      const typeMatch = line.match(/\*\*Type\*\*:\s*(.+)/);
+      if (typeMatch) entry.type = typeMatch[1].trim();
+
+      const tagsMatch = line.match(/\*\*Tags\*\*:\s*(.+)/);
+      if (tagsMatch) entry.tags = tagsMatch[1].trim().split(/\s+/);
+
+      const reqMatch = line.match(/\*\*Request\*\*:\s*"?(.+?)"?\s*$/);
+      if (reqMatch) entry.request = reqMatch[1].trim();
+
+      const resMatch = line.match(/\*\*Result\*\*:\s*(.+)/);
+      if (resMatch) entry.result = resMatch[1].trim();
+
+      const filesMatch = line.match(/\*\*Files\*\*:\s*(.+)/);
+      if (filesMatch) entry.files = filesMatch[1].trim().split(/[,\s]+/).filter(Boolean);
+    }
+
+    entries.push(entry);
+  }
+
+  return entries;
+}
+
+// ============================================================
+// Changelog Aggregation
+// ============================================================
+
+/**
+ * Aggregate request logs from all workspace members into a unified timeline.
+ *
+ * @param {string} workspaceRoot
+ * @param {Object} [options]
+ * @param {string} [options.since] — only entries after this date (YYYY-MM-DD)
+ * @param {number} [options.limit] — max entries (default: 50)
+ * @returns {{ entries: Array<Object>, memberCount: number, totalEntries: number }}
+ */
+function aggregateChangelogs(workspaceRoot, options = {}) {
+  const { since = '', limit = 50 } = options;
+  const configPath = path.join(workspaceRoot, WORKSPACE_CONFIG_FILE);
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  } catch (_err) {
+    return { entries: [], memberCount: 0, totalEntries: 0 };
+  }
+
+  let allEntries = [];
+  let memberCount = 0;
+
+  for (const [name, memberConfig] of Object.entries(config.members || {})) {
+    const memberPath = path.resolve(workspaceRoot, memberConfig.path);
+    const logPath = path.join(memberPath, '.workflow', 'state', 'request-log.md');
+
+    try {
+      if (!fs.existsSync(logPath)) continue;
+      const content = fs.readFileSync(logPath, 'utf-8');
+      const entries = parseRequestLog(content, name);
+      allEntries = allEntries.concat(entries);
+      memberCount++;
+    } catch (_err) {
+      // Skip unreadable logs
+    }
+  }
+
+  // Filter by date if specified
+  if (since) {
+    const sinceTime = new Date(since).getTime();
+    allEntries = allEntries.filter(e => new Date(e.timestamp).getTime() >= sinceTime);
+  }
+
+  // Sort by timestamp (newest first)
+  allEntries.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+  const totalEntries = allEntries.length;
+
+  // Apply limit
+  if (limit > 0) {
+    allEntries = allEntries.slice(0, limit);
+  }
+
+  return { entries: allEntries, memberCount, totalEntries };
+}
+
+/**
+ * Format aggregated changelog as markdown.
+ *
+ * @param {Object} result — from aggregateChangelogs()
+ * @returns {string} formatted markdown
+ */
+function formatAggregatedChangelog(result) {
+  const lines = [
+    '# Workspace Changelog',
+    '',
+    `*${result.memberCount} repos, ${result.totalEntries} entries*`,
+    ''
+  ];
+
+  let currentDate = '';
+  for (const entry of result.entries) {
+    if (entry.date !== currentDate) {
+      currentDate = entry.date;
+      lines.push(`## ${currentDate}`);
+      lines.push('');
+    }
+
+    const typeIcon = {
+      new: '+',
+      fix: '!',
+      change: '~',
+      refactor: '>'
+    }[entry.type] || '*';
+
+    lines.push(`- \`${entry.time}\` **${entry.repo}** [${typeIcon}${entry.type}] ${entry.request || entry.result}`);
+  }
+
+  return lines.join('\n');
+}
+
+// ============================================================
+// Exports
+// ============================================================
+
+module.exports = {
+  parseRequestLog,
+  aggregateChangelogs,
+  formatAggregatedChangelog
+};

package/lib/workspace-channel-server.js

@@ -384,6 +384,59 @@ rl.on('line', (line) => {
 // HTTP Webhook Server (receives dispatches from manager/peers)
 // ============================================================
 
+// ============================================================
+// SSE Client Management (Event Bus)
+// ============================================================
+
+const sseClients = new Set();
+
+function addSSEClient(res, lastEventId) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+    'X-Accel-Buffering': 'no'
+  });
+  res.write(':ok\n\n');
+
+  // If workspace root is available, send missed events
+  if (WORKSPACE_ROOT && lastEventId) {
+    try {
+      const events = require('./workspace-events');
+      const missed = events.getEventsSince(WORKSPACE_ROOT, lastEventId);
+      for (const evt of missed) {
+        res.write(events.formatAsSSE(evt));
+      }
+    } catch (_err) {
+      // Non-critical
+    }
+  }
+
+  sseClients.add(res);
+  res.on('close', () => sseClients.delete(res));
+}
+
+function broadcastSSE(event) {
+  let formatted;
+  try {
+    const events = require('./workspace-events');
+    formatted = events.formatAsSSE(event);
+  } catch (_err) {
+    formatted = `data: ${JSON.stringify(event)}\n\n`;
+  }
+  for (const client of sseClients) {
+    try {
+      client.write(formatted);
+    } catch (_err) {
+      sseClients.delete(client);
+    }
+  }
+}
+
+// ============================================================
+// HTTP Server
+// ============================================================
+
 const server = http.createServer(async (req, res) => {
   // Health check — minimal info, no topology exposure
   if (req.method === 'GET' && req.url === '/health') {
@@ -392,6 +445,13 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // SSE endpoint for event subscriptions
+  if (req.method === 'GET' && req.url?.startsWith('/events')) {
+    const lastEventId = req.headers['last-event-id'] || '';
+    addSSEClient(res, lastEventId);
+    return;
+  }
+
   // Receive webhook (POST)
   if (req.method === 'POST') {
     const { body, truncated } = await collectBody(req, MAX_BODY_BYTES);
@@ -406,12 +466,25 @@ const server = http.createServer(async (req, res) => {
     const from = req.headers['x-wogi-from'] || 'workspace-manager';
 
     // Forward as channel notification to Claude Code
-    sendChannelNotification(body, {
+    const meta = {
       from,
       port: String(PORT),
       repo: REPO_NAME,
       receivedAt: new Date().toISOString()
-    });
+    };
+    sendChannelNotification(body, meta);
+
+    // Also broadcast to SSE subscribers
+    if (sseClients.size > 0) {
+      const crypto = require('node:crypto');
+      broadcastSSE({
+        id: 'evt-' + crypto.randomBytes(4).toString('hex'),
+        type: 'webhook-received',
+        source: from,
+        data: { body: body.substring(0, 500) },
+        timestamp: meta.receivedAt
+      });
+    }
 
     res.writeHead(200, { 'Content-Type': 'text/plain' });
     res.end('ok');

package/lib/workspace-contracts.js

@@ -571,6 +571,152 @@ function writeContract(workspaceRoot, contractName, format, content, changedBy,
   return trackContractVersion(workspaceRoot, contractName, serialized, changedBy, reason);
 }
 
+// ============================================================
+// Schema/Type Sync Enforcement
+// ============================================================
+
+/**
+ * Auto-generate shared TypeScript interfaces from all providers' schemas.
+ * Writes to .workspace/contracts/shared-types.d.ts so consumers can import.
+ *
+ * @param {string} workspaceRoot
+ * @param {Object} manifest — workspace manifest
+ * @returns {{ typesGenerated: number, filePath: string }}
+ */
+function generateSharedTypes(workspaceRoot, manifest) {
+  const contractsDir = path.join(workspaceRoot, '.workspace', 'contracts');
+  fs.mkdirSync(contractsDir, { recursive: true });
+
+  const lines = [
+    '/**',
+    ' * Auto-generated shared types from workspace providers.',
+    ` * Generated: ${new Date().toISOString()}`,
+    ' * DO NOT EDIT — regenerated by `flow workspace sync`',
+    ' */',
+    ''
+  ];
+
+  let typesGenerated = 0;
+  const seenTypes = new Map(); // Track types across repos to detect conflicts
+
+  // Strict identifier validation to prevent code injection via manifest data
+  const VALID_TS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+  const VALID_REPO_NAME = /^[a-zA-Z0-9_-]+$/;
+
+  for (const [name, member] of Object.entries(manifest.members || {})) {
+    if (member.role !== 'provider' && member.role !== 'both' && member.role !== 'library') continue;
+
+    const schemas = member.schemas || [];
+    if (schemas.length === 0) continue;
+
+    const safeName = VALID_REPO_NAME.test(name) ? name : 'unknown';
+    const safeRole = VALID_REPO_NAME.test(member.role) ? member.role : 'unknown';
+    lines.push(`// ── From ${safeName} (${safeRole}) ${'─'.repeat(Math.max(1, 50 - safeName.length))}`);
+    lines.push('');
+
+    for (const schema of schemas) {
+      const typeName = schema.name || schema;
+      const fields = schema.fields || [];
+
+      // Validate type name is a safe TypeScript identifier
+      if (!VALID_TS_IDENTIFIER.test(typeName)) {
+        lines.push(`// SKIPPED: Invalid type name "${String(typeName).replace(/[^a-zA-Z0-9_$ ]/g, '')}"`);
+        continue;
+      }
+
+      // Track for conflict detection
+      if (seenTypes.has(typeName)) {
+        const prevDef = VALID_REPO_NAME.test(seenTypes.get(typeName)) ? seenTypes.get(typeName) : 'unknown';
+        lines.push(`// WARNING: Type "${typeName}" also defined by ${prevDef}`);
+      }
+      seenTypes.set(typeName, name);
+
+      lines.push(`export interface ${typeName} {`);
+      for (const field of fields) {
+        const fieldName = field.name || field;
+        // Validate field name is a safe identifier
+        if (!VALID_TS_IDENTIFIER.test(fieldName)) continue;
+        const fieldType = mapToTsType(field.type || 'string');
+        const optional = field.nullable || field.optional ? '?' : '';
+        lines.push(`  ${fieldName}${optional}: ${fieldType};`);
+      }
+      lines.push('}');
+      lines.push('');
+      typesGenerated++;
+    }
+  }
+
+  if (typesGenerated === 0) {
+    lines.push('// No provider schemas found in workspace manifest.');
+    lines.push('// Run `flow workspace sync` after adding provider repos.');
+  }
+
+  const filePath = path.join(contractsDir, 'shared-types.d.ts');
+  fs.writeFileSync(filePath, lines.join('\n'));
+
+  // Track version
+  const content = lines.join('\n');
+  try {
+    trackContractVersion(workspaceRoot, 'shared-types', content, 'workspace-sync', 'Auto-generated from provider schemas');
+  } catch (_err) {
+    // Non-critical
+  }
+
+  return { typesGenerated, filePath };
+}
+
+/**
+ * Verify that consumer repos reference shared types correctly.
+ * Checks if consumers have local type definitions that duplicate shared types.
+ *
+ * @param {string} workspaceRoot
+ * @param {Object} manifest
+ * @returns {Array<{ consumer: string, type: string, issue: string }>}
+ */
+function checkTypeSyncCompliance(workspaceRoot, manifest) {
+  const issues = [];
+  const sharedTypesPath = path.join(workspaceRoot, '.workspace', 'contracts', 'shared-types.d.ts');
+
+  if (!fs.existsSync(sharedTypesPath)) return issues;
+
+  // Extract type names from shared types
+  const sharedContent = fs.readFileSync(sharedTypesPath, 'utf-8');
+  const typeNames = [];
+  const typeRegex = /export interface (\w+)/g;
+  let match;
+  while ((match = typeRegex.exec(sharedContent)) !== null) {
+    typeNames.push(match[1]);
+  }
+
+  if (typeNames.length === 0) return issues;
+
+  // Check each consumer's schema-map for duplicates
+  const configPath = path.join(workspaceRoot, 'wogi-workspace.json');
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+
+    for (const [name, memberConfig] of Object.entries(config.members || {})) {
+      const member = manifest.members?.[name];
+      if (!member || member.role === 'provider') continue; // Only check consumers
+
+      const memberSchemas = (member.schemas || []).map(s => s.name || s);
+      for (const typeName of typeNames) {
+        if (memberSchemas.includes(typeName)) {
+          issues.push({
+            consumer: name,
+            type: typeName,
+            issue: `Consumer "${name}" defines "${typeName}" locally — should import from .workspace/contracts/shared-types.d.ts`
+          });
+        }
+      }
+    }
+  } catch (_err) {
+    // Non-critical
+  }
+
+  return issues;
+}
+
 // ============================================================
 // Exports
 // ============================================================
@@ -595,5 +741,9 @@ module.exports = {
 
   // Multi-format
   detectContractFormat,
-  writeContract
+  writeContract,
+
+  // Schema/type sync
+  generateSharedTypes,
+  checkTypeSyncCompliance
 };