workflow-ai 1.0.64 → 1.0.66

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;
+}

package/src/lib/error-classifier.mjs

@@ -0,0 +1,311 @@
+import { load as loadYaml } from './js-yaml.mjs';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, join } from 'path';
+
+const STDERR_MATCH_LIMIT = 64 * 1024;
+const MATCH_TIMEOUT_MS = 100;
+const SUPPORTED_VERSION = '1.0';
+const MIN_UTC_MIDNIGHT_DELAY_MS = 30 * 60 * 1000;
+
+export class InvalidRulesConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'InvalidRulesConfigError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+function parseConfigFile(configPath) {
+  if (!existsSync(configPath)) {
+    return { common: [], agents: {} };
+  }
+  const content = readFileSync(configPath, 'utf-8');
+  const config = loadYaml(content);
+  if (!config || typeof config !== 'object') {
+    return { common: [], agents: {} };
+  }
+  return config;
+}
+
+function validateVersion(version) {
+  if (version !== SUPPORTED_VERSION) {
+    throw new InvalidRulesConfigError(
+      `Unsupported rules version: ${version}. Update runner or downgrade rules file.`
+    );
+  }
+}
+
+function compilePattern(pattern) {
+  if (!pattern) {
+    return null;
+  }
+  try {
+    return new RegExp(pattern);
+  } catch (e) {
+    throw new InvalidRulesConfigError(`Invalid regex pattern: ${pattern}. ${e.message}`);
+  }
+}
+
+function resolveExtends(agentsConfig, agentId, visited = new Set()) {
+  if (!agentsConfig[agentId]) {
+    return null;
+  }
+  if (!agentsConfig[agentId].extends) {
+    return null;
+  }
+  const extendsTarget = agentsConfig[agentId].extends;
+  if (visited.has(agentId)) {
+    throw new InvalidRulesConfigError('chained extends not supported');
+  }
+  if (!agentsConfig[extendsTarget]) {
+    throw new InvalidRulesConfigError(`extends target '${extendsTarget}' not found`);
+  }
+  if (agentsConfig[extendsTarget].extends) {
+    throw new InvalidRulesConfigError('chained extends not supported');
+  }
+  visited.add(agentId);
+  return agentsConfig[extendsTarget].rules || [];
+}
+
+function buildRules(rulesData, compiledRules = []) {
+  if (!Array.isArray(rulesData)) {
+    return compiledRules;
+  }
+  for (const rule of rulesData) {
+    if (!rule || !rule.id || !rule.class || !rule.ttl) {
+      continue;
+    }
+    compiledRules.push({
+      id: rule.id,
+      class: rule.class,
+      ttl: rule.ttl,
+      pattern: compilePattern(rule.pattern),
+      exitCodes: rule.exit_codes === 'any' ? 'any' : (
+        Array.isArray(rule.exit_codes)
+          ? rule.exit_codes.filter(c => typeof c === 'number')
+          : []
+      ),
+    });
+  }
+  return compiledRules;
+}
+
+export function loadRules(projectRoot, configPath) {
+  const defaultPath = join(projectRoot, '.workflow/config/agent-health-rules.yaml');
+  const fullPath = configPath || defaultPath;
+  let config;
+  try {
+    config = parseConfigFile(fullPath);
+  } catch (e) {
+    if (e instanceof InvalidRulesConfigError) {
+      throw e;
+    }
+    return { common: [], agents: new Map() };
+  }
+  if (!config || typeof config !== 'object') {
+    return { common: [], agents: new Map() };
+  }
+  if (config.version) {
+    validateVersion(config.version);
+  }
+  const commonRules = buildRules(config.common || []);
+  const agents = new Map();
+  const agentsConfig = config.agents || {};
+  for (const agentId of Object.keys(agentsConfig)) {
+    const agentConfig = agentsConfig[agentId];
+    if (!agentConfig) {
+      continue;
+    }
+    const inheritedRules = resolveExtends(agentsConfig, agentId);
+    const ownRules = buildRules(agentConfig.rules || []);
+    const finalRules = [...ownRules];
+    if (inheritedRules && inheritedRules.length > 0) {
+      finalRules.push(...buildRules(inheritedRules));
+    }
+    agents.set(agentId, finalRules);
+  }
+  return { common: commonRules, agents };
+}
+
+function truncateStderr(stderr) {
+  if (!stderr || stderr.length <= STDERR_MATCH_LIMIT) {
+    return stderr;
+  }
+  const halfLimit = STDERR_MATCH_LIMIT / 2;
+  const head = stderr.slice(0, halfLimit);
+  const tail = stderr.slice(-halfLimit);
+  return head + '\n...[TRUNCATED]...\n' + tail;
+}
+
+function matchRule(rule, exitCode, truncatedStderr) {
+  const exitCodesMatch = rule.exitCodes === 'any' ||
+    rule.exitCodes.includes(exitCode);
+  if (!exitCodesMatch) {
+    return false;
+  }
+  if (!rule.pattern) {
+    return true;
+  }
+  try {
+    return rule.pattern.test(truncatedStderr);
+  } catch (e) {
+    return false;
+  }
+}
+
+function matchWithTimeout(regex, text) {
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(() => {
+      resolve(false);
+    }, MATCH_TIMEOUT_MS);
+    try {
+      const result = regex.test(text);
+      clearTimeout(timeoutId);
+      resolve(result);
+    } catch (e) {
+      clearTimeout(timeoutId);
+      resolve(false);
+    }
+  });
+}
+
+export async function classify(rules, agentId, { exitCode, stderr }) {
+  const truncatedStderr = truncateStderr(stderr);
+  const agentRules = rules.agents.get(agentId) || [];
+  for (const rule of agentRules) {
+    const matched = rule.pattern
+      ? await matchWithTimeout(rule.pattern, truncatedStderr)
+      : matchRule(rule, exitCode, truncatedStderr);
+    if (matched) {
+      return {
+        class: rule.class,
+        rule_id: rule.id,
+        ttl: rule.ttl,
+        reason: truncatedStderr,
+      };
+    }
+  }
+  for (const rule of rules.common) {
+    const matched = rule.pattern
+      ? await matchWithTimeout(rule.pattern, truncatedStderr)
+      : matchRule(rule, exitCode, truncatedStderr);
+    if (matched) {
+      return {
+        class: rule.class,
+        rule_id: rule.id,
+        ttl: rule.ttl,
+        reason: truncatedStderr,
+      };
+    }
+  }
+  return null;
+}
+
+/**
+ * Онлайн-проверка stderr на "фатальные" паттерны для агента.
+ * Используется spawn-хендлером для раннего kill зависшего процесса,
+ * когда дочерний агент уходит в retry-цикл на HTTP 429 / quota без завершения.
+ *
+ * Проверяет только правила самого агента (не common), и только те,
+ * у которых class ∈ {unavailable, misconfigured} — это сигналы, после которых
+ * продолжать вызов бессмысленно.
+ *
+ * @param {{common: Array, agents: Map}} rules — результат loadRules()
+ * @param {string} agentId
+ * @param {string} stderrText — весь накопленный stderr (до STDERR_MATCH_LIMIT)
+ * @returns {{rule_id: string, class: string, ttl: string, reason: string} | null}
+ */
+export function scanStderrForFatalRule(rules, agentId, stderrText) {
+  if (!stderrText || !agentId) return null;
+  const truncated = truncateStderr(stderrText);
+  const agentRules = rules.agents.get(agentId) || [];
+  for (const rule of agentRules) {
+    if (rule.class !== 'unavailable' && rule.class !== 'misconfigured') continue;
+    if (!rule.pattern) continue;
+    try {
+      if (rule.pattern.test(truncated)) {
+        return {
+          rule_id: rule.id,
+          class: rule.class,
+          ttl: rule.ttl,
+          reason: truncated,
+        };
+      }
+    } catch {
+      // broken regex — пропускаем
+    }
+  }
+  return null;
+}
+
+export function parseTtl(ttl, now = Date.now()) {
+  if (ttl === 'infinite') {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  const untilMatch = ttl.match(/^(\d+)d$/);
+  if (untilMatch) {
+    return now + parseInt(untilMatch[1], 10) * 24 * 60 * 60 * 1000;
+  }
+  const hourMatch = ttl.match(/^(\d+)h$/);
+  if (hourMatch) {
+    return now + parseInt(hourMatch[1], 10) * 60 * 60 * 1000;
+  }
+  const minMatch = ttl.match(/^(\d+)m$/);
+  if (minMatch) {
+    return now + parseInt(minMatch[1], 10) * 60 * 1000;
+  }
+  if (ttl === 'until_utc_midnight') {
+    const nextMidnight = new Date(now);
+    nextMidnight.setUTCHours(24, 0, 0, 0);
+    const minDelay = now + MIN_UTC_MIDNIGHT_DELAY_MS;
+    return Math.max(nextMidnight.getTime(), minDelay);
+  }
+  throw new Error(`Invalid TTL format: ${ttl}. Expected Nm, Nh, Nd, until_utc_midnight, or infinite.`);
+}
+
+export function classifySync(rules, agentId, { exitCode, stderr }) {
+  const truncatedStderr = truncateStderr(stderr);
+  const agentRules = rules.agents.get(agentId) || [];
+  for (const rule of agentRules) {
+    const matched = rule.pattern
+      ? (() => {
+          try {
+            return rule.pattern.test(truncatedStderr);
+          } catch (e) {
+            return false;
+          }
+        })()
+      : matchRule(rule, exitCode, truncatedStderr);
+    if (matched) {
+      return {
+        class: rule.class,
+        rule_id: rule.id,
+        ttl: rule.ttl,
+        reason: truncatedStderr,
+      };
+    }
+  }
+  for (const rule of rules.common) {
+    const matched = rule.pattern
+      ? (() => {
+          try {
+            return rule.pattern.test(truncatedStderr);
+          } catch (e) {
+            return false;
+          }
+        })()
+      : matchRule(rule, exitCode, truncatedStderr);
+    if (matched) {
+      return {
+        class: rule.class,
+        rule_id: rule.id,
+        ttl: rule.ttl,
+        reason: truncatedStderr,
+      };
+    }
+  }
+  return null;
+}
+

package/src/lib/test-error-classifier.mjs

@@ -0,0 +1,60 @@
+import { loadRules, classify, parseTtl, classifySync, InvalidRulesConfigError } from './error-classifier.mjs';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+const tmp = mkdtempSync(path.join(os.tmpdir(), 'ec-test-'));
+const configDir = path.join(tmp, '.workflow/config');
+mkdirSync(configDir, { recursive: true });
+const configPath = path.join(configDir, 'agent-health-rules.yaml');
+
+writeFileSync(configPath, `version: "1.0"
+common:
+  - id: "net-econnreset"
+    class: "transient"
+    ttl: "5m"
+    pattern: "ECONNRESET|ETIMEDOUT"
+    exit_codes: "any"
+agents:
+  qwen-code:
+    rules:
+      - id: "qwen-quota"
+        class: "unavailable"
+        ttl: "until_utc_midnight"
+        pattern: "Qwen OAuth quota exceeded"
+        exit_codes: "any"
+`);
+
+const rules = loadRules(tmp);
+console.log('loadRules result:', { commonLen: rules.common.length, agentsSize: rules.agents.size });
+
+const result1 = await classify(rules, 'qwen-code', { exitCode: 1, stderr: 'Qwen OAuth quota exceeded' });
+console.log('classify qwen-quota:', result1?.class, result1?.rule_id);
+
+const result2 = await classify(rules, 'qwen-code', { exitCode: 1, stderr: 'Some other error' });
+console.log('classify no match:', result2);
+
+const result3 = await classify(rules, 'claude-sonnet', { exitCode: 1, stderr: 'ECONNRESET' });
+console.log('classify common:', result3?.class, result3?.rule_id);
+
+const result4 = classifySync(rules, 'qwen-code', { exitCode: 1, stderr: 'Qwen OAuth quota exceeded' });
+console.log('classifySync qwen-quota:', result4?.class, result4?.rule_id);
+
+const ttl1 = parseTtl('5m');
+console.log('parseTtl 5m:', typeof ttl1, ttl1 > Date.now());
+
+const ttl2 = parseTtl('infinite');
+console.log('parseTtl infinite:', ttl2 === Number.MAX_SAFE_INTEGER);
+
+const now = new Date('2026-04-21T12:00:00Z').getTime();
+const ttl3 = parseTtl('until_utc_midnight', now);
+console.log('parseTtl until_utc_midnight:', ttl3 >= now);
+
+const ttl4 = parseTtl('1h');
+console.log('parseTtl 1h:', ttl4 > now);
+
+const ttl5 = parseTtl('1d');
+console.log('parseTtl 1d:', ttl5 > now);
+
+rmSync(tmp, { recursive: true, force: true });
+console.log('All tests passed!');

package/src/lib/test-extends.mjs

@@ -0,0 +1,58 @@
+import { loadRules, classify, classifySync } from './error-classifier.mjs';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+const tmp = mkdtempSync(path.join(os.tmpdir(), 'ec-test-'));
+const configDir = path.join(tmp, '.workflow/config');
+mkdirSync(configDir, { recursive: true });
+const configPath = path.join(configDir, 'agent-health-rules.yaml');
+
+writeFileSync(configPath, `version: "1.0"
+common:
+  - id: "common-test"
+    class: "transient"
+    ttl: "5m"
+    pattern: "common-error"
+    exit_codes: "any"
+agents:
+  claude-sonnet:
+    rules:
+      - id: "claude-specific"
+        class: "unavailable"
+        ttl: "10m"
+        pattern: "claude-specific-error"
+        exit_codes: "any"
+  claude-opus:
+    extends: claude-sonnet
+  kilo-glm:
+    rules:
+      - id: "kilo-own"
+        class: "misconfigured"
+        ttl: "1h"
+        pattern: "kilo-error"
+        exit_codes: "any"
+`);
+
+const rules = loadRules(tmp);
+console.log('loadRules with extends:');
+
+const opusRules = rules.agents.get('claude-opus');
+console.log('claude-opus rules (from extends):', opusRules?.length);
+console.log('claude-opus first rule:', opusRules?.[0]?.id);
+
+const glmRules = rules.agents.get('kilo-glm');
+console.log('kilo-glm rules (own):', glmRules?.length);
+console.log('kilo-glm first rule:', glmRules?.[0]?.id);
+
+const test1 = classifySync(rules, 'claude-opus', { exitCode: 1, stderr: 'claude-specific-error' });
+console.log('classify claude-opus with specific error:', test1?.class, test1?.rule_id);
+
+const test2 = classifySync(rules, 'claude-opus', { exitCode: 1, stderr: 'common-error' });
+console.log('classify claude-opus with common error:', test2?.class, test2?.rule_id);
+
+const test3 = classifySync(rules, 'kilo-glm', { exitCode: 1, stderr: 'kilo-error' });
+console.log('classify kilo-glm with own error:', test3?.class, test3?.rule_id);
+
+rmSync(tmp, { recursive: true, force: true });
+console.log('Extends tests passed!');

package/src/lib/test-version.mjs

@@ -0,0 +1,21 @@
+import { InvalidRulesConfigError } from './error-classifier.mjs';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+const tmp = mkdtempSync(path.join(os.tmpdir(), 'ec-test-'));
+const configDir = path.join(tmp, '.workflow/config');
+mkdirSync(configDir, { recursive: true });
+const configPath = path.join(configDir, 'agent-health-rules.yaml');
+
+writeFileSync(configPath, 'version: "2.0"\ncommon: []');
+
+try {
+  const { loadRules } = await import('./error-classifier.mjs');
+  loadRules(tmp);
+  console.log('ERROR: should have thrown');
+} catch (e) {
+  console.log('Version error works:', e.name === 'InvalidRulesConfigError', e.message.includes('2.0'));
+}
+
+rmSync(tmp, { recursive: true, force: true });