workflow-ai 1.0.63 → 1.0.65

package/src/lib/error-classifier.mjs

@@ -0,0 +1,274 @@
+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;
+}
+
+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 });

package/src/scripts/move-to-review.js

@@ -16,8 +16,6 @@ import fs from "fs";
 import path from "path";
 import { findProjectRoot } from "workflow-ai/lib/find-root.mjs";
 import {
-  parseFrontmatter,
-  serializeFrontmatter,
   printResult,
   getLastReviewStatus,
 } from "workflow-ai/lib/utils.mjs";
@@ -98,18 +96,18 @@ function moveToReview(ticketId) {
   }
 
   const content = fs.readFileSync(sourcePath, "utf8");
-  const { frontmatter, body } = parseFrontmatter(content);
 
-  frontmatter.updated_at = new Date().toISOString();
-
-  const newContent = serializeFrontmatter(frontmatter) + body;
+  // updated_at не обновляем: verify-artifacts сравнивает mtime файлов с updated_at,
+  // чтобы убедиться, что они были изменены агентом. updated_at должен сохранять момент
+  // перемещения тикета в in-progress (до начала работы агента) — иначе любой
+  // легитимно изменённый файл будет ложно отклонён (mtime_edit < updated_at_review).
 
   if (!fs.existsSync(REVIEW_DIR)) {
     fs.mkdirSync(REVIEW_DIR, { recursive: true });
   }
 
   fs.renameSync(sourcePath, targetPath);
-  fs.writeFileSync(targetPath, newContent, "utf8");
+  fs.writeFileSync(targetPath, content, "utf8");
 
   return {
     status: "moved",

package/src/scripts/reset-agent-health.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+import { loadHealth, markHealthy, unhealthy } from '../lib/agent-health-registry.mjs';
+
+const projectRoot = process.cwd();
+
+function getState() {
+  return loadHealth(projectRoot);
+}
+
+function showState() {
+  const state = getState();
+  console.log('---RESULT---');
+  console.log(JSON.stringify(state, null, 2));
+  console.log('---RESULT---');
+}
+
+function resetAgent(agentId) {
+  const state = getState();
+  const agent = state.agents[agentId];
+  
+  if (!agent) {
+    console.log(`Agent "${agentId}" not found in health registry`);
+    return;
+  }
+  
+  markHealthy(projectRoot, agentId);
+  console.log(`Reset health status for agent "${agentId}"`);
+}
+
+function resetAll() {
+  const unhealthyAgents = unhealthy(projectRoot);
+  
+  if (unhealthyAgents.length === 0) {
+    console.log('No unhealthy agents to reset');
+    return;
+  }
+  
+  const resetList = unhealthyAgents.map(a => a.agentId);
+  
+  for (const agentId of resetList) {
+    markHealthy(projectRoot, agentId);
+  }
+  
+  console.log(`Reset ${resetList.length} agent(s): ${resetList.join(', ')}`);
+}
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  showState();
+} else if (args[0] === '--agent' && args[1]) {
+  resetAgent(args[1]);
+} else if (args[0] === '--all') {
+  resetAll();
+} else {
+  console.log('Usage:');
+  console.log('  node reset-agent-health.js              # Show current state');
+  console.log('  node reset-agent-health.js --agent <id> # Reset single agent');
+  console.log('  node reset-agent-health.js --all   # Reset all unhealthy');
+  process.exit(1);
+}