workflow-ai 1.0.64 → 1.0.65

package/src/init.mjs

@@ -357,7 +357,7 @@ export function initProject(targetPath = process.cwd(), options = {}) {
     errors: []
   };
   
-  // Step 1: Create .workflow/ structure (16 directories)
+  // Step 1: Create .workflow/ structure (directories)
   const directories = [
     'tickets/backlog',
     'tickets/ready',
@@ -371,13 +371,21 @@ export function initProject(targetPath = process.cwd(), options = {}) {
     'logs',
     'templates',
     'src/skills',
-    'tests/skills'
+    'tests/skills',
+    'state'
   ];
 
   for (const dir of directories) {
     ensureDir(join(workflowRoot, dir));
   }
-  result.steps.push('Created .workflow/ directory structure (16 directories)');
+  result.steps.push(`Created .workflow/ directory structure (${directories.length} directories)`);
+
+   // Create .gitkeep in .workflow/tests/skills/
+   // FIX-9: Ensure .gitkeep exists for tests/skills directory
+   const testsSkillsGitkeep = join(workflowRoot, 'tests', 'skills', '.gitkeep');
+   if (!existsSync(testsSkillsGitkeep)) {
+     writeFileSync(testsSkillsGitkeep, '');
+   }
 
   // Step 2: Ensure global dir and create skill junctions
   const globalDir = getGlobalDir();
@@ -432,6 +440,15 @@ export function initProject(targetPath = process.cwd(), options = {}) {
   updateGitignore(projectRoot);
   result.steps.push('Updated .gitignore with .workflow/logs/');
 
+  // Step 10: Copy agent-health-rules.yaml to .workflow/config/
+  const agentHealthRulesSrc = join(packageRoot, 'configs', 'agent-health-rules.yaml');
+  const agentHealthRulesDest = join(workflowRoot, 'config', 'agent-health-rules.yaml');
+  if (existsSync(agentHealthRulesSrc)) {
+    ensureDir(dirname(agentHealthRulesDest));
+    copyFileSync(agentHealthRulesSrc, agentHealthRulesDest);
+    result.steps.push('Copied agent-health-rules.yaml → .workflow/config/');
+  }
+
   return result;
 }
 

package/src/lib/agent-health-registry.mjs

@@ -0,0 +1,245 @@
+import fs from 'fs';
+import path from 'path';
+import { createLogger } from './logger.mjs';
+import { parseTtl } from './error-classifier.mjs';
+
+const HEALTH_FILE = '.workflow/state/agent-health.json';
+const LOCK_FILE = '.workflow/state/agent-health.json.lock';
+const SUPPORTED_VERSION = '1.0';
+const MAX_LOCK_RETRIES = 5;
+const LOCK_TIMEOUT_MS = 2000;
+const LOCK_BACKOFFS = [100, 200, 400, 800, 1600];
+
+const logger = createLogger();
+
+export class AgentHealthLockError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AgentHealthLockError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+function getHealthFilePath(projectRoot) {
+  return path.join(projectRoot, HEALTH_FILE);
+}
+
+function getLockFilePath(projectRoot) {
+  return path.join(projectRoot, LOCK_FILE);
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function parseTimestamp(isoString) {
+  if (!isoString) return null;
+  const date = new Date(isoString);
+  return isNaN(date.getTime()) ? null : date.getTime();
+}
+
+function readHealthFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { version: SUPPORTED_VERSION, updated_at: null, agents: {} };
+  }
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(content);
+    if (!data || typeof data !== 'object') {
+      logger.warn(`agent-health-registry: corrupted JSON in ${filePath}, returning empty state`);
+      return { version: SUPPORTED_VERSION, updated_at: null, agents: {} };
+    }
+    return {
+      version: data.version || SUPPORTED_VERSION,
+      updated_at: data.updated_at || null,
+      agents: data.agents || {}
+    };
+  } catch (e) {
+    logger.warn(`agent-health-registry: corrupted JSON in ${filePath}, returning empty state`);
+    return { version: SUPPORTED_VERSION, updated_at: null, agents: {} };
+  }
+}
+
+function writeHealthFileAtomic(filePath, data, lockFilePath, projectRoot) {
+  const tmpPath = filePath + '.tmp';
+  const dirPath = path.dirname(filePath);
+  ensureDir(dirPath);
+
+  const startTime = Date.now();
+  for (let attempt = 0; attempt < MAX_LOCK_RETRIES; attempt++) {
+    const elapsed = Date.now() - startTime;
+    if (elapsed >= LOCK_TIMEOUT_MS) {
+      throw new AgentHealthLockError(`Failed to acquire lock within ${LOCK_TIMEOUT_MS}ms`);
+    }
+
+    const backoff = LOCK_BACKOFFS[attempt];
+    const remaining = LOCK_TIMEOUT_MS - elapsed;
+    const sleepTime = Math.min(backoff, remaining);
+
+    if (attempt > 0) {
+      if (sleepTime > 0) {
+        const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+        const start = Date.now();
+        while (Date.now() - start < sleepTime) {
+          // busy wait
+        }
+      }
+    }
+
+    try {
+      fs.openSync(lockFilePath, 'wx');
+    } catch (e) {
+      if (e.code === 'EEXIST') {
+        continue;
+      }
+      throw e;
+    }
+
+    try {
+      const content = JSON.stringify(data, null, 2);
+      fs.writeFileSync(tmpPath, content, 'utf-8');
+      fs.renameSync(tmpPath, filePath);
+      return;
+    } finally {
+      try {
+        fs.unlinkSync(lockFilePath);
+      } catch (e) {
+        // ignore lock cleanup errors
+      }
+    }
+  }
+
+  throw new AgentHealthLockError(`Failed to acquire lock after ${MAX_LOCK_RETRIES} attempts`);
+}
+
+export function loadHealth(projectRoot, now = Date.now()) {
+  const filePath = getHealthFilePath(projectRoot);
+  const data = readHealthFile(filePath);
+  pruneExpired(projectRoot, now);
+  return { agents: data.agents };
+}
+
+export function markUnhealthy(projectRoot, agentId, options) {
+  const { class: agentClass, rule_id, ttl, reason } = options;
+  const filePath = getHealthFilePath(projectRoot);
+  const lockPath = getLockFilePath(projectRoot);
+
+  const existing = readHealthFile(filePath);
+  const currentTime = new Date().toISOString();
+
+  let untilMs;
+  const now = Date.now();
+  if (typeof ttl === 'number') {
+    // Legacy: numeric milliseconds offset
+    untilMs = now + ttl;
+  } else if (typeof ttl === 'string') {
+    // String TTL: 'until_utc_midnight', '1h', '5m', '1d', 'infinite', etc.
+    try {
+      untilMs = parseTtl(ttl, now);
+    } catch {
+      untilMs = now + 5 * 60 * 1000;
+    }
+  } else {
+    untilMs = now + 5 * 60 * 1000;
+  }
+
+  const untilIso = new Date(untilMs).toISOString();
+
+  existing.agents[agentId] = {
+    status: 'unhealthy',
+    class: agentClass,
+    rule_id: rule_id || null,
+    reason: reason || null,
+    marked_at: currentTime,
+    until: untilIso
+  };
+  existing.updated_at = currentTime;
+
+  writeHealthFileAtomic(filePath, existing, lockPath, projectRoot);
+}
+
+export function markHealthy(projectRoot, agentId) {
+  const filePath = getHealthFilePath(projectRoot);
+  const lockPath = getLockFilePath(projectRoot);
+
+  const existing = readHealthFile(filePath);
+
+  if (existing.agents[agentId]) {
+    delete existing.agents[agentId];
+    existing.updated_at = new Date().toISOString();
+    writeHealthFileAtomic(filePath, existing, lockPath, projectRoot);
+  }
+}
+
+export function isHealthy(projectRoot, agentId, now = Date.now()) {
+  const filePath = getHealthFilePath(projectRoot);
+  const data = readHealthFile(filePath);
+  const agent = data.agents[agentId];
+
+  if (!agent) {
+    return true;
+  }
+
+  if (agent.status !== 'unhealthy') {
+    return true;
+  }
+
+  const untilMs = parseTimestamp(agent.until);
+  if (untilMs === null) {
+    return true;
+  }
+
+  return now >= untilMs;
+}
+
+export function unhealthy(projectRoot, now = Date.now()) {
+  const filePath = getHealthFilePath(projectRoot);
+  const data = readHealthFile(filePath);
+  const result = [];
+
+  for (const [agentId, agent] of Object.entries(data.agents)) {
+    if (agent.status !== 'unhealthy') {
+      continue;
+    }
+    const untilMs = parseTimestamp(agent.until);
+    if (untilMs !== null && now < untilMs) {
+      result.push({
+        agentId,
+        class: agent.class,
+        rule_id: agent.rule_id,
+        reason: agent.reason,
+        until: agent.until
+      });
+    }
+  }
+
+  return result;
+}
+
+export function pruneExpired(projectRoot, now = Date.now()) {
+  const filePath = getHealthFilePath(projectRoot);
+  const lockPath = getLockFilePath(projectRoot);
+
+  const existing = readHealthFile(filePath);
+  let changed = false;
+
+  for (const [agentId, agent] of Object.entries(existing.agents)) {
+    if (agent.status !== 'unhealthy') {
+      continue;
+    }
+    const untilMs = parseTimestamp(agent.until);
+    if (untilMs !== null && now >= untilMs) {
+      delete existing.agents[agentId];
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    existing.updated_at = new Date().toISOString();
+    writeHealthFileAtomic(filePath, existing, lockPath, projectRoot);
+  }
+}

package/src/lib/artifact-snapshot.mjs

@@ -0,0 +1,233 @@
+import { execFileSync } from 'child_process';
+import { readdirSync, statSync, readFileSync, existsSync } from 'fs';
+import { join, relative, isAbsolute } from 'path';
+import { createHash } from 'crypto';
+
+const DEFAULT_SNAPSHOT_MAX_FILE_SIZE = 524288;
+const DEFAULT_EXCLUDE_PATTERNS = [
+  '.workflow/logs/**',
+  '.workflow/state/**',
+  '**/.git/**',
+  '**/node_modules/**',
+  '**/*.tmp'
+];
+const DEFAULT_INCLUDE_PATHS = [
+  '.workflow/tickets',
+  '.workflow/plans',
+  '.workflow/reports',
+  'src',
+  'configs'
+];
+
+function matchesGlob(filePath, pattern) {
+  // Normalize to forward slashes, strip leading ./
+  const normPath = filePath.replace(/\\/g, '/');
+  const p = pattern.replace(/\\/g, '/').replace(/^\.\//, '');
+
+  // Build regex from glob pattern.
+  // Rules:
+  //   **/ at the very start  → optional prefix of zero-or-more directories
+  //   /** at the end         → any file/subdir below this directory
+  //   **/{seg}/**            → {seg} appears anywhere as a path component
+  //   **/*.ext               → any file with .ext in any subdirectory
+  //   *                      → any characters except /
+  let result = '^';
+  let i = 0;
+
+  while (i < p.length) {
+    const ch = p[i];
+
+    if (ch === '*' && p[i + 1] === '*') {
+      // Double-star glob
+      if (i === 0 && p[i + 2] === '/') {
+        // **/ at the very start: zero-or-more leading directories
+        result += '(?:.+/)?';
+        i += 3;
+      } else if (p[i - 1] === '/' && i + 2 >= p.length) {
+        // /** at the end (preceded by /): any suffix including sub-paths
+        result += '.*';
+        i += 2;
+      } else if (p[i - 1] === '/' && p[i + 2] === '/') {
+        // /**/ in the middle: optional sub-path segment
+        result += '(?:.+/)?';
+        i += 3;
+      } else {
+        // ** in any other position: match anything
+        result += '.*';
+        i += 2;
+      }
+    } else if (ch === '*') {
+      // Single star: any characters except /
+      result += '[^/]*';
+      i++;
+    } else if (ch === '?') {
+      result += '[^/]';
+      i++;
+    } else if (/[.+^${}()|[\]\\]/.test(ch)) {
+      result += '\\' + ch;
+      i++;
+    } else {
+      result += ch;
+      i++;
+    }
+  }
+
+  result += '$';
+
+  try {
+    return new RegExp(result).test(normPath);
+  } catch {
+    return false;
+  }
+}
+
+function shouldExclude(path, excludePatterns) {
+  for (const pattern of excludePatterns) {
+    if (matchesGlob(path, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function computeFileHash(filePath, maxSize) {
+  try {
+    const stats = statSync(filePath);
+    if (stats.size > maxSize) {
+      return null;
+    }
+    const content = readFileSync(filePath);
+    return createHash('sha1').update(content).digest('hex');
+  } catch (e) {
+    return null;
+  }
+}
+
+function walkDirectory(dirPath, basePath, excludePatterns, maxFileSize) {
+  const result = new Map();
+  
+  if (!existsSync(dirPath)) {
+    return result;
+  }
+  
+  function walk(dir) {
+    try {
+      const entries = readdirSync(dir);
+      
+      for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const relativePath = relative(basePath, fullPath).replace(/\\/g, '/');
+        
+        if (shouldExclude(relativePath, excludePatterns)) {
+          continue;
+        }
+        
+        try {
+          const stats = statSync(fullPath);
+          
+          if (stats.isDirectory()) {
+            walk(fullPath);
+          } else if (stats.isFile()) {
+            const sha1 = computeFileHash(fullPath, maxFileSize);
+            result.set(relativePath, {
+              mtime: stats.mtimeMs,
+              size: stats.size,
+              sha1
+            });
+          }
+        } catch (e) {
+          console.warn(`[WARN] artifact-snapshot: skip ${relativePath}: ${e.message}`);
+        }
+      }
+    } catch (e) {
+      console.warn(`[WARN] artifact-snapshot: walk ${dir}: ${e.message}`);
+    }
+  }
+  
+  walk(dirPath);
+  return result;
+}
+
+export async function snapshot(projectRoot, options = {}) {
+  const includePaths = options.includePaths || DEFAULT_INCLUDE_PATHS;
+  const excludePatterns = options.excludePatterns || DEFAULT_EXCLUDE_PATTERNS;
+  const snapshotMaxFileSize = options.snapshotMaxFileSize || DEFAULT_SNAPSHOT_MAX_FILE_SIZE;
+  
+  let gitOutput = '';
+  const gitEnabled = existsSync(join(projectRoot, '.git'));
+  
+  if (gitEnabled) {
+    try {
+      gitOutput = execFileSync('git', ['status', '--porcelain=v1', '-z'], {
+        cwd: projectRoot,
+        encoding: 'utf8',
+        maxBuffer: 10 * 1024 * 1024
+      });
+    } catch (e) {
+      console.warn(`[WARN] artifact-snapshot: git status failed: ${e.message}`);
+      gitOutput = '';
+    }
+  }
+  
+  const fsMap = new Map();
+  
+  for (const includePath of includePaths) {
+    const fullPath = isAbsolute(includePath) 
+      ? includePath 
+      : join(projectRoot, includePath);
+    
+    if (existsSync(fullPath)) {
+      const dirMap = walkDirectory(fullPath, projectRoot, excludePatterns, snapshotMaxFileSize);
+      for (const [key, value] of dirMap) {
+        fsMap.set(key, value);
+      }
+    }
+  }
+  
+  return {
+    git: gitOutput,
+    fs: fsMap,
+    timestamp: Date.now()
+  };
+}
+
+export function diff(before, after) {
+  const created = [];
+  const changed = [];
+  const deleted = [];
+  
+  const beforeFs = before.fs;
+  const afterFs = after.fs;
+  
+  const beforeFiles = new Set(beforeFs.keys());
+  const afterFiles = new Set(afterFs.keys());
+  
+  for (const file of afterFiles) {
+    if (!beforeFiles.has(file)) {
+      created.push(file);
+    } else {
+      const beforeMeta = beforeFs.get(file);
+      const afterMeta = afterFs.get(file);
+      
+      if (beforeMeta.mtime !== afterMeta.mtime ||
+          beforeMeta.size !== afterMeta.size ||
+          beforeMeta.sha1 !== afterMeta.sha1) {
+        changed.push(file);
+      }
+    }
+  }
+  
+  for (const file of beforeFiles) {
+    if (!afterFiles.has(file)) {
+      deleted.push(file);
+    }
+  }
+  
+  return { changed, created, deleted };
+}
+
+export function isEmpty(diffResult) {
+  return diffResult.changed.length === 0 &&
+         diffResult.created.length === 0 &&
+         diffResult.deleted.length === 0;
+}